MercurialSharpLibHid / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
RemoteControlDevice.cs
author sl
Tue, 04 Nov 2014 20:58:19 +0100
changeset 3 db8e6a25d6bc
parent 2 505a13a09336
child 4 eed66dfd9848
permissions -rw-r--r--
Proper support for all MCE buttons. 
     1 using System;

     2 using System.Windows.Forms;

     3 using System.Runtime.InteropServices;

     4 using System.Diagnostics;

     5 

     6 

     7 namespace BruceThomas.Devices.RemoteControl

     8 {

     9 	public enum InputDevice

    10 	{

    11 		Key,

    12 		Mouse,

    13 		OEM

    14 	}

    15 

    16 

    17 	public enum RemoteControlButton

    18 	{

    19 		Clear,

    20 		Down,

    21 		Left,

    22 		Digit0,

    23 		Digit1,

    24 		Digit2,

    25 		Digit3,

    26 		Digit4,

    27 		Digit5,

    28 		Digit6,

    29 		Digit7,

    30 		Digit8,

    31 		Digit9,

    32 		Enter,

    33 		Right,

    34 		Up,

    35 

    36 		Back,

    37 		ChannelDown,

    38 		ChannelUp,

    39 		FastForward,

    40 		VolumeMute,

    41 		Pause,

    42 		Play,

    43         PlayPause,

    44 		Record,

    45 		PreviousTrack,

    46 		Rewind,

    47 		NextTrack,

    48 		Stop,

    49 		VolumeDown,

    50 		VolumeUp,

    51 

    52 		RecordedTV,

    53 		Guide,

    54 		LiveTV,

    55 		Details,

    56 		DVDMenu,

    57 		DVDAngle,

    58 		DVDAudio,

    59 		DVDSubtitle,

    60 		MyMusic,

    61 		MyPictures,

    62 		MyVideos,

    63 		MyTV,

    64 		OEM1,

    65 		OEM2,

    66 		StandBy,

    67 		TVJump,

    68 

    69 		Unknown

    70 	}

    71 

    72     /// <summary>

    73     /// 

    74     /// </summary>

    75     public enum MceButton

    76     {

    77         Null                    =   0x00, //Not defined by the specs

    78         GreenStart              =   0x0D,

    79         ClosedCaptioning        =   0x2B,

    80         Teletext                =   0x5A,

    81         TeletextRed             =   0x5B,

    82         TeletextGreen           =   0x5C,

    83         TeletextYellow          =   0x5D,

    84         TeletextBlue            =   0x5E,

    85         LiveTv                  =   0x25,

    86         Music                   =   0x47,

    87         RecordedTv              =   0x48,

    88         Pictures                =   0x49,

    89         Videos                  =   0x4A,

    90         FmRadio                 =   0x50,

    91         Extras                  =   0x3C,

    92         ExtrasApp               =   0x3D,

    93         DvdMenu                 =   0x24,

    94         DvdAngle                =   0x4B,

    95         DvdAudio                =   0x4C,

    96         DvdSubtitle             =   0x4D,

    97         Eject                   =   0x28,

    98         DvdTopMenu              =   0x43,

    99         Ext0                    =   0x32,

   100         Ext1                    =   0x33,

   101         Ext2                    =   0x34,

   102         Ext3                    =   0x35,

   103         Ext4                    =   0x36,

   104         Ext5                    =   0x37,

   105         Ext6                    =   0x38,

   106         Ext7                    =   0x39,

   107         Ext8                    =   0x3A,

   108         Ext9                    =   0x80,

   109         Ext10                   =   0x81,

   110         Ext11                   =   0x6F,

   111         Zoom                    =   0x27,

   112         ChannelInput            =   0x42,

   113         SubAudio                =   0x2D,

   114         Channel10               =   0x3E,

   115         Channel11               =   0x3F,

   116         Channel12               =   0x40,

   117         Display                 =   0x4F,

   118         Kiosk                   =   0x6A,

   119         NetworkSelection        =   0x2C,

   120         BlueRayTool             =   0x78,

   121         ChannelInfo             =   0x41,

   122         VideoSelection          =   0x61                

   123     }

   124 

   125 

   126 	#region RemoteControlEventArgs

   127 

   128 	public class RemoteControlEventArgs : EventArgs

   129 	{

   130         RemoteControlButton _rcb;

   131 		InputDevice _device;

   132         MceButton iMceButton;

   133 

   134         public RemoteControlEventArgs(RemoteControlButton rcb, InputDevice device)

   135 		{

   136             iMceButton = MceButton.Null;

   137 			_rcb = rcb;

   138 			_device = device;

   139 		}

   140 

   141         public RemoteControlEventArgs(MceButton mce, InputDevice device)

   142         {

   143             iMceButton = mce;

   144             _rcb = RemoteControlButton.Unknown;

   145             _device = device;

   146         }

   147 

   148 		public RemoteControlEventArgs()

   149 		{

   150             iMceButton = MceButton.Null;

   151 			_rcb = RemoteControlButton.Unknown;

   152 			_device = InputDevice.Key;

   153 		}

   154 

   155 		public RemoteControlButton Button

   156 		{

   157 			get { return _rcb;  }

   158 			set { _rcb = value; }

   159 		}

   160 

   161         public MceButton MceButton

   162         {

   163             get { return iMceButton; }

   164             set { iMceButton = value; }

   165         }

   166 

   167 		public InputDevice Device

   168 		{

   169 			get { return _device;  }

   170 			set { _device = value; }

   171 		}

   172 	}

   173 

   174 	#endregion RemoteControlEventArgs

   175 

   176 

   177 	public sealed class RemoteControlDevice

   178 	{

   179 

   180         [StructLayout(LayoutKind.Sequential, Pack = 1)]

   181 		internal struct RAWINPUTDEVICE

   182 		{

   183 			[MarshalAs(UnmanagedType.U2)]

   184 			public ushort usUsagePage;

   185 			[MarshalAs(UnmanagedType.U2)]

   186 			public ushort usUsage;

   187 			[MarshalAs(UnmanagedType.U4)]

   188 			public int	 dwFlags;

   189 			public IntPtr hwndTarget;

   190 		}

   191 

   192 

   193         [StructLayout(LayoutKind.Sequential, Pack = 1)]

   194 		internal struct RAWINPUTHEADER

   195 		{

   196 			[MarshalAs(UnmanagedType.U4)]

   197 			public int dwType;

   198 			[MarshalAs(UnmanagedType.U4)]

   199 			public int dwSize;

   200             public IntPtr hDevice;

   201 			[MarshalAs(UnmanagedType.U4)]

   202 			public int wParam;

   203 		}

   204 

   205 

   206         [StructLayout(LayoutKind.Sequential, Pack = 1)]

   207 		internal struct RAWHID

   208 		{

   209 			[MarshalAs(UnmanagedType.U4)]

   210 			public int dwSizeHid;

   211 			[MarshalAs(UnmanagedType.U4)]

   212 			public int dwCount;

   213             //

   214             //BYTE  bRawData[1];

   215 		}

   216 

   217 

   218         [StructLayout(LayoutKind.Sequential, Pack = 1)]

   219 		internal struct BUTTONSSTR

   220 		{

   221 			[MarshalAs(UnmanagedType.U2)]

   222 			public ushort usButtonFlags;

   223 			[MarshalAs(UnmanagedType.U2)]

   224 			public ushort usButtonData;

   225 		}

   226 

   227 

   228         [StructLayout(LayoutKind.Explicit, Pack = 1)]

   229 		internal struct RAWMOUSE

   230 		{

   231 			[MarshalAs(UnmanagedType.U2)]

   232 			[FieldOffset (0)] public ushort usFlags;

   233 			[MarshalAs(UnmanagedType.U4)]

   234 			[FieldOffset (4)] public uint ulButtons;

   235 			[FieldOffset (4)] public BUTTONSSTR buttonsStr;

   236 			[MarshalAs(UnmanagedType.U4)]

   237 			[FieldOffset (8)] public uint ulRawButtons;

   238             [MarshalAs(UnmanagedType.U4)]

   239             [FieldOffset (12)] public int lLastX;

   240             [MarshalAs(UnmanagedType.U4)]

   241             [FieldOffset (16)] public int lLastY;

   242 			[MarshalAs(UnmanagedType.U4)]

   243 			[FieldOffset (20)] public uint ulExtraInformation;

   244 		}

   245 

   246         [StructLayout(LayoutKind.Sequential, Pack = 1)]

   247 		internal struct RAWKEYBOARD

   248 		{

   249 			[MarshalAs(UnmanagedType.U2)]

   250 			public ushort MakeCode;

   251 			[MarshalAs(UnmanagedType.U2)]

   252 			public ushort Flags;

   253 			[MarshalAs(UnmanagedType.U2)]

   254 			public ushort Reserved;

   255 			[MarshalAs(UnmanagedType.U2)]

   256 			public ushort VKey;

   257 			[MarshalAs(UnmanagedType.U4)]

   258 			public uint Message;

   259 			[MarshalAs(UnmanagedType.U4)]

   260 			public uint ExtraInformation;

   261 		}

   262 

   263 

   264 		[StructLayout(LayoutKind.Explicit, Pack=1)]

   265 		internal struct RAWINPUT

   266 		{

   267 			[FieldOffset  (0)] public RAWINPUTHEADER header;

   268 			[FieldOffset (16)] public RAWMOUSE mouse;

   269 			[FieldOffset (16)] public RAWKEYBOARD keyboard;

   270 			[FieldOffset (16)] public RAWHID hid;

   271 		}

   272 

   273 

   274 		[DllImport("User32.dll")]

   275 		extern static bool RegisterRawInputDevices(RAWINPUTDEVICE[] pRawInputDevice, uint uiNumDevices, uint cbSize);

   276 

   277 		[DllImport("User32.dll")]

   278 		extern static uint GetRawInputData(IntPtr hRawInput, uint uiCommand, IntPtr pData, ref uint pcbSize, uint cbSizeHeader);

   279 

   280 

   281 		private const int WM_KEYDOWN	= 0x0100;

   282 		private const int WM_APPCOMMAND	= 0x0319;

   283 		private const int WM_INPUT		= 0x00FF;

   284 

   285 		private const int APPCOMMAND_BROWSER_BACKWARD   = 1;

   286 		private const int APPCOMMAND_VOLUME_MUTE        = 8;

   287 		private const int APPCOMMAND_VOLUME_DOWN        = 9;

   288 		private const int APPCOMMAND_VOLUME_UP          = 10;

   289 		private const int APPCOMMAND_MEDIA_NEXTTRACK    = 11;

   290 		private const int APPCOMMAND_MEDIA_PREVIOUSTRACK = 12;

   291 		private const int APPCOMMAND_MEDIA_STOP         = 13;

   292 		private const int APPCOMMAND_MEDIA_PLAY_PAUSE   = 14;

   293 		private const int APPCOMMAND_MEDIA_PLAY         = 46;

   294 		private const int APPCOMMAND_MEDIA_PAUSE        = 47;

   295 		private const int APPCOMMAND_MEDIA_RECORD       = 48;

   296 		private const int APPCOMMAND_MEDIA_FAST_FORWARD = 49;

   297 		private const int APPCOMMAND_MEDIA_REWIND       = 50;

   298 		private const int APPCOMMAND_MEDIA_CHANNEL_UP   = 51;

   299 		private const int APPCOMMAND_MEDIA_CHANNEL_DOWN = 52;

   300 

   301 		private const int RIM_TYPEMOUSE					= 0;

   302 		private const int RIM_TYPEKEYBOARD				= 1;

   303 		private const int RIM_TYPEHID					= 2;

   304 

   305 		private const int RID_INPUT						= 0x10000003;

   306 		private const int RID_HEADER					= 0x10000005;

   307 

   308 		private const int FAPPCOMMAND_MASK				= 0xF000;

   309 		private const int FAPPCOMMAND_MOUSE				= 0x8000;

   310 		private const int FAPPCOMMAND_KEY				= 0;

   311 		private const int FAPPCOMMAND_OEM				= 0x1000;

   312 

   313 		public delegate void RemoteControlDeviceEventHandler(object sender, RemoteControlEventArgs e);

   314 		public event RemoteControlDeviceEventHandler ButtonPressed;

   315 

   316 

   317 		//-------------------------------------------------------------

   318 		// constructors

   319 		//-------------------------------------------------------------

   320 

   321 		public RemoteControlDevice()

   322 		{

   323 			// Register the input device to receive the commands from the

   324 			// remote device. See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwmt/html/remote_control.asp

   325 			// for the vendor defined usage page.

   326 

   327 			RAWINPUTDEVICE[] rid = new RAWINPUTDEVICE[3];

   328 

   329 			rid[0].usUsagePage = 0xFFBC;

   330 			rid[0].usUsage = 0x88;

   331 			rid[0].dwFlags = 0;

   332 

   333 			rid[1].usUsagePage = 0x0C;

   334 			rid[1].usUsage = 0x01;

   335 			rid[1].dwFlags = 0;

   336 

   337 			rid[2].usUsagePage = 0x0C;

   338 			rid[2].usUsage = 0x80;

   339 			rid[2].dwFlags = 0;

   340 

   341 			if (!RegisterRawInputDevices(rid,

   342 				(uint) rid.Length,

   343 				(uint) Marshal.SizeOf(rid[0]))

   344 				)

   345 			{

   346 				throw new ApplicationException("Failed to register raw input devices.");

   347 			}

   348 		}

   349 

   350 

   351 		//-------------------------------------------------------------

   352 		// methods

   353 		//-------------------------------------------------------------

   354 

   355 		public void ProcessMessage(Message message)

   356 		{

   357 			int param;

   358 

   359 			switch (message.Msg)

   360 			{

   361 				case WM_KEYDOWN:

   362 					param = message.WParam.ToInt32();

   363 					ProcessKeyDown(param);

   364 					break;

   365 				case WM_APPCOMMAND:

   366 					param = message.LParam.ToInt32();

   367 					ProcessAppCommand(param);

   368 					break;

   369 				case WM_INPUT:

   370 					ProcessInputCommand(ref message);

   371                     message.Result = new IntPtr(0);

   372 					break;

   373 			}

   374 

   375 		}

   376 

   377 

   378 		//-------------------------------------------------------------

   379 		// methods (helpers)

   380 		//-------------------------------------------------------------

   381 

   382 		private void ProcessKeyDown(int param)

   383 		{

   384 			RemoteControlButton rcb = RemoteControlButton.Unknown;

   385 

   386 			switch (param)

   387 			{

   388 				case (int) Keys.Escape:

   389 					rcb = RemoteControlButton.Clear;

   390 					break;

   391 				case (int) Keys.Down:

   392 					rcb = RemoteControlButton.Down;

   393 					break;

   394 				case (int) Keys.Left:

   395 					rcb = RemoteControlButton.Left;

   396 					break;

   397 				case (int) Keys.D0:

   398 					rcb = RemoteControlButton.Digit0;

   399 					break;

   400 				case (int) Keys.D1:

   401 					rcb = RemoteControlButton.Digit1;

   402 					break;

   403 				case (int) Keys.D2:

   404 					rcb = RemoteControlButton.Digit2;

   405 					break;

   406 				case (int) Keys.D3:

   407 					rcb = RemoteControlButton.Digit3;

   408 					break;

   409 				case (int) Keys.D4:

   410 					rcb = RemoteControlButton.Digit4;

   411 					break;

   412 				case (int) Keys.D5:

   413 					rcb = RemoteControlButton.Digit5;

   414 					break;

   415 				case (int) Keys.D6:

   416 					rcb = RemoteControlButton.Digit6;

   417 					break;

   418 				case (int) Keys.D7:

   419 					rcb = RemoteControlButton.Digit7;

   420 					break;

   421 				case (int) Keys.D8:

   422 					rcb = RemoteControlButton.Digit8;

   423 					break;

   424 				case (int) Keys.D9:

   425 					rcb = RemoteControlButton.Digit9;

   426 					break;

   427 				case (int) Keys.Enter:

   428 					rcb = RemoteControlButton.Enter;

   429 					break;

   430 				case (int) Keys.Right:

   431 					rcb = RemoteControlButton.Right;

   432 					break;

   433 				case (int) Keys.Up:

   434 					rcb = RemoteControlButton.Up;

   435 					break;

   436 			}

   437 

   438 			if (this.ButtonPressed != null && rcb != RemoteControlButton.Unknown)

   439 				this.ButtonPressed(this, new RemoteControlEventArgs(rcb, GetDevice(param)));

   440 		}

   441 

   442 

   443 		private void ProcessAppCommand(int param)

   444 		{

   445 			RemoteControlButton rcb = RemoteControlButton.Unknown;

   446 

   447 			int cmd	= (int) (((ushort) (param >> 16)) & ~FAPPCOMMAND_MASK);

   448 

   449 			switch (cmd)

   450 			{

   451 				case APPCOMMAND_BROWSER_BACKWARD:

   452 					rcb = RemoteControlButton.Back;

   453 					break;

   454 				case APPCOMMAND_MEDIA_CHANNEL_DOWN:

   455 					rcb = RemoteControlButton.ChannelDown;

   456 					break;

   457 				case APPCOMMAND_MEDIA_CHANNEL_UP:

   458 					rcb = RemoteControlButton.ChannelUp;

   459 					break;

   460 				case APPCOMMAND_MEDIA_FAST_FORWARD:

   461 					rcb = RemoteControlButton.FastForward;

   462 					break;

   463 				case APPCOMMAND_VOLUME_MUTE:

   464 					rcb = RemoteControlButton.VolumeMute;

   465 					break;

   466 				case APPCOMMAND_MEDIA_PAUSE:

   467 					rcb = RemoteControlButton.Pause;

   468 					break;

   469 				case APPCOMMAND_MEDIA_PLAY:

   470 					rcb = RemoteControlButton.Play;

   471 					break;

   472                 case APPCOMMAND_MEDIA_PLAY_PAUSE:

   473                     rcb = RemoteControlButton.PlayPause;

   474                     break;

   475 				case APPCOMMAND_MEDIA_RECORD:

   476 					rcb = RemoteControlButton.Record;

   477 					break;

   478 				case APPCOMMAND_MEDIA_PREVIOUSTRACK:

   479 					rcb = RemoteControlButton.PreviousTrack;

   480 					break;

   481 				case APPCOMMAND_MEDIA_REWIND:

   482 					rcb = RemoteControlButton.Rewind;

   483 					break;

   484 				case APPCOMMAND_MEDIA_NEXTTRACK:

   485 					rcb = RemoteControlButton.NextTrack;

   486 					break;

   487 				case APPCOMMAND_MEDIA_STOP:

   488 					rcb = RemoteControlButton.Stop;

   489 					break;

   490 				case APPCOMMAND_VOLUME_DOWN:

   491 					rcb = RemoteControlButton.VolumeDown;

   492 					break;

   493 				case APPCOMMAND_VOLUME_UP:

   494 					rcb = RemoteControlButton.VolumeUp;

   495 					break;

   496 			}

   497 

   498 			if (this.ButtonPressed != null && rcb != RemoteControlButton.Unknown)

   499 				this.ButtonPressed(this, new RemoteControlEventArgs(rcb, GetDevice(param)));

   500 		}

   501 

   502 

   503 		private void ProcessInputCommand(ref Message message)

   504 		{

   505 			RemoteControlButton rcb = RemoteControlButton.Unknown;

   506 			uint dwSize = 0;

   507 

   508             uint sizeOfHeader=(uint)Marshal.SizeOf(typeof(RAWINPUTHEADER));

   509 

   510             //Get the size of our raw input data.

   511 			GetRawInputData(message.LParam,	RID_INPUT, IntPtr.Zero,	ref dwSize,	sizeOfHeader);

   512 

   513             //Allocate a large enough buffer

   514 			IntPtr buffer = Marshal.AllocHGlobal((int) dwSize);

   515 			try

   516 			{

   517 				if(buffer == IntPtr.Zero)

   518 					return;

   519 

   520                 //Now read our RAWINPUT data

   521 				if (GetRawInputData(message.LParam,	RID_INPUT, buffer, ref dwSize, (uint) Marshal.SizeOf(typeof(RAWINPUTHEADER))) != dwSize)

   522 				{

   523 					return;

   524 				}

   525 

   526                 //Cast our buffer

   527                 RAWINPUT raw = (RAWINPUT)Marshal.PtrToStructure(buffer, typeof(RAWINPUT));

   528 

   529                 //Check that our raw input is HID

   530                 if (raw.header.dwType == RIM_TYPEHID && raw.hid.dwSizeHid>0)

   531 				{

   532                     //Allocate a buffer for one HID message

   533 					byte[] bRawData = new byte[raw.hid.dwSizeHid];

   534 

   535                     //Compute the address from which to copy our HID message

   536                     int pRawData = 0;

   537                     unsafe

   538                     {

   539                         byte* source = (byte*)buffer;

   540                         source += sizeof(RAWINPUTHEADER) + sizeof(RAWHID);

   541                         //source += 1;

   542                         pRawData = (int)source;

   543                     }

   544                     //int pRawData = buffer.ToUint32() + Marshal.SizeOf(typeof(RAWINPUT)) + 1;

   545 

   546 					//Marshal.Copy(new IntPtr(pRawData), bRawData, 0, raw.hid.dwSizeHid - 1);

   547                     Marshal.Copy(new IntPtr(pRawData), bRawData, 0, raw.hid.dwSizeHid);

   548 					//int rawData = bRawData[0] | bRawData[1] << 8;

   549                     int rawData = bRawData[1]; //Get button code

   550                     Debug.WriteLine("HID " + raw.hid.dwCount + "/" + raw.hid.dwSizeHid + ":" + bRawData[0].ToString("X2") + bRawData[1].ToString("X2"));

   551 

   552                     if (Enum.IsDefined(typeof(MceButton), rawData) && rawData!=0) //Our button is a known MCE button

   553                     {

   554                         if (this.ButtonPressed != null) //What's that?

   555                         {

   556                             this.ButtonPressed(this, new RemoteControlEventArgs((MceButton)rawData, GetDevice(message.LParam.ToInt32())));

   557                         }

   558                     }

   559 				}

   560 				else if(raw.header.dwType == RIM_TYPEMOUSE)

   561 				{

   562 					// do mouse handling...

   563 				}

   564 				else if(raw.header.dwType == RIM_TYPEKEYBOARD)

   565 				{

   566 					// do keyboard handling...

   567 				}

   568 			}

   569 			finally

   570 			{

   571 				Marshal.FreeHGlobal(buffer);

   572 			}

   573 		}

   574 

   575 

   576 		private InputDevice GetDevice(int param)

   577 		{

   578 			InputDevice inputDevice;

   579 

   580 			switch ((int) (((ushort) (param >> 16)) & FAPPCOMMAND_MASK))

   581 			{

   582 				case FAPPCOMMAND_OEM:

   583 					inputDevice = InputDevice.OEM;

   584 					break;

   585 				case FAPPCOMMAND_MOUSE:

   586 					inputDevice = InputDevice.Mouse;

   587 					break;

   588 				default:

   589 					inputDevice = InputDevice.Key;

   590 					break;

   591 			}

   592 

   593 			return inputDevice;

   594 		}

   595 	}

   596 }
SharpLibHid