MercurialSharpLibHid / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
RemoteControlDevice.cs
author sl
Wed, 03 Dec 2014 21:54:45 +0100
changeset 16 9a3e77655031
parent 15 2044181ade12
child 17 8f7e35c3bfd1
permissions -rw-r--r--
Now supporting alternative codes for program guid and properties/info. 
     1 using System;

     2 using System.Windows.Forms;

     3 using System.Runtime.InteropServices;

     4 using System.Diagnostics;

     5 using Hid.UsageTables;

     6 using Win32;

     7 

     8 namespace Devices.RemoteControl

     9 {

    10 

    11 	public enum InputDevice

    12 	{

    13 		Key,

    14 		Mouse,

    15 		OEM

    16 	}

    17 

    18 

    19 	public enum RemoteControlButton

    20 	{

    21 		Clear,

    22 		Down,

    23 		Left,

    24 		Digit0,

    25 		Digit1,

    26 		Digit2,

    27 		Digit3,

    28 		Digit4,

    29 		Digit5,

    30 		Digit6,

    31 		Digit7,

    32 		Digit8,

    33 		Digit9,

    34 		Enter,

    35 		Right,

    36 		Up,

    37 

    38 		Back,

    39 		ChannelDown,

    40 		ChannelUp,

    41 		FastForward,

    42 		VolumeMute,

    43 		Pause,

    44 		Play,

    45         PlayPause,

    46 		Record,

    47 		PreviousTrack,

    48 		Rewind,

    49 		NextTrack,

    50 		Stop,

    51 		VolumeDown,

    52 		VolumeUp,

    53 

    54 		RecordedTV,

    55 		Guide,

    56 		LiveTV,

    57 		MoreInfo,

    58         Print,

    59 		DVDMenu,

    60 		DVDAngle,

    61 		DVDAudio,

    62 		DVDSubtitle,

    63 		MyMusic,

    64 		MyPictures,

    65 		MyVideos,

    66 		MyTV,

    67 		OEM1,

    68 		OEM2,

    69 		StandBy,

    70 		TVJump,

    71 

    72 		Unknown

    73 	}

    74 

    75 

    76 	#region RemoteControlEventArgs

    77 

    78 	public class RemoteControlEventArgs : EventArgs

    79 	{

    80         RemoteControlButton _rcb;

    81 		InputDevice _device;

    82         MceButton iMceButton;

    83 

    84         public RemoteControlEventArgs(RemoteControlButton rcb, InputDevice device)

    85 		{

    86             iMceButton = MceButton.Null;

    87 			_rcb = rcb;

    88 			_device = device;

    89 		}

    90 

    91         public RemoteControlEventArgs(MceButton mce, InputDevice device)

    92         {

    93             iMceButton = mce;

    94             _rcb = RemoteControlButton.Unknown;

    95             _device = device;

    96         }

    97 

    98 		public RemoteControlEventArgs()

    99 		{

   100             iMceButton = MceButton.Null;

   101 			_rcb = RemoteControlButton.Unknown;

   102 			_device = InputDevice.Key;

   103 		}

   104 

   105 		public RemoteControlButton Button

   106 		{

   107 			get { return _rcb;  }

   108 			set { _rcb = value; }

   109 		}

   110 

   111         public MceButton MceButton

   112         {

   113             get { return iMceButton; }

   114             set { iMceButton = value; }

   115         }

   116 

   117 		public InputDevice Device

   118 		{

   119 			get { return _device;  }

   120 			set { _device = value; }

   121 		}

   122 	}

   123 

   124 	#endregion RemoteControlEventArgs

   125 

   126 

   127 	public sealed class RemoteControlDevice

   128 	{

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

   130 		public event RemoteControlDeviceEventHandler ButtonPressed;

   131 

   132         public delegate void HidUsageHandler(ushort aUsage);

   133         

   134 

   135 		//-------------------------------------------------------------

   136 		// constructors

   137 		//-------------------------------------------------------------

   138 

   139 		public RemoteControlDevice(IntPtr aHWND)

   140 		{

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

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

   143 			// for the vendor defined usage page.

   144 

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

   146 

   147 			rid[0].usUsagePage = 0xFFBC;

   148 			rid[0].usUsage = 0x88;

   149             rid[0].dwFlags = Const.RIDEV_EXINPUTSINK;

   150             rid[0].hwndTarget = aHWND;

   151 

   152 			rid[1].usUsagePage = 0x0C;

   153 			rid[1].usUsage = 0x01;

   154             rid[1].dwFlags = Const.RIDEV_EXINPUTSINK;

   155             rid[1].hwndTarget = aHWND;

   156 

   157 			rid[2].usUsagePage = 0x0C;

   158 			rid[2].usUsage = 0x80;

   159             rid[2].dwFlags = Const.RIDEV_EXINPUTSINK;

   160             rid[2].hwndTarget = aHWND;

   161 

   162 			if (!Function.RegisterRawInputDevices(rid,(uint) rid.Length,(uint) Marshal.SizeOf(rid[0])))

   163 			{

   164                 throw new ApplicationException("Failed to register raw input devices: " + Marshal.GetLastWin32Error().ToString());

   165 			}

   166 		}

   167 

   168 

   169 		//-------------------------------------------------------------

   170 		// methods

   171 		//-------------------------------------------------------------

   172 

   173 		public void ProcessMessage(Message message)

   174 		{

   175 			switch (message.Msg)

   176 			{

   177 				case Const.WM_KEYDOWN:

   178                     ProcessKeyDown(message.WParam);

   179 					break;

   180                 case Const.WM_APPCOMMAND:

   181 					ProcessAppCommand(message.LParam);

   182 					break;

   183                 case Const.WM_INPUT:

   184 					ProcessInputCommand(ref message);

   185                     message.Result = new IntPtr(0);

   186 					break;

   187 			}

   188 

   189 		}

   190 

   191 

   192 		//-------------------------------------------------------------

   193 		// methods (helpers)

   194 		//-------------------------------------------------------------

   195 

   196 		private void ProcessKeyDown(IntPtr wParam)

   197 		{

   198 			RemoteControlButton rcb = RemoteControlButton.Unknown;

   199 

   200             switch (wParam.ToInt32())

   201 			{

   202 				case (int) Keys.Escape:

   203 					rcb = RemoteControlButton.Clear;

   204 					break;

   205 				case (int) Keys.Down:

   206 					rcb = RemoteControlButton.Down;

   207 					break;

   208 				case (int) Keys.Left:

   209 					rcb = RemoteControlButton.Left;

   210 					break;

   211 				case (int) Keys.D0:

   212 					rcb = RemoteControlButton.Digit0;

   213 					break;

   214 				case (int) Keys.D1:

   215 					rcb = RemoteControlButton.Digit1;

   216 					break;

   217 				case (int) Keys.D2:

   218 					rcb = RemoteControlButton.Digit2;

   219 					break;

   220 				case (int) Keys.D3:

   221 					rcb = RemoteControlButton.Digit3;

   222 					break;

   223 				case (int) Keys.D4:

   224 					rcb = RemoteControlButton.Digit4;

   225 					break;

   226 				case (int) Keys.D5:

   227 					rcb = RemoteControlButton.Digit5;

   228 					break;

   229 				case (int) Keys.D6:

   230 					rcb = RemoteControlButton.Digit6;

   231 					break;

   232 				case (int) Keys.D7:

   233 					rcb = RemoteControlButton.Digit7;

   234 					break;

   235 				case (int) Keys.D8:

   236 					rcb = RemoteControlButton.Digit8;

   237 					break;

   238 				case (int) Keys.D9:

   239 					rcb = RemoteControlButton.Digit9;

   240 					break;

   241 				case (int) Keys.Enter:

   242 					rcb = RemoteControlButton.Enter;

   243 					break;

   244 				case (int) Keys.Right:

   245 					rcb = RemoteControlButton.Right;

   246 					break;

   247 				case (int) Keys.Up:

   248 					rcb = RemoteControlButton.Up;

   249 					break;

   250 			}

   251 

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

   253 				this.ButtonPressed(this, new RemoteControlEventArgs(rcb, GetDevice(wParam)));

   254 		}

   255 

   256 

   257 		private void ProcessAppCommand(IntPtr lParam)

   258 		{

   259 			RemoteControlButton rcb = RemoteControlButton.Unknown;

   260 

   261             int cmd = Macro.GET_APPCOMMAND_LPARAM(lParam);

   262                 //(int) (((ushort) (param >> 16)) & ~Const.FAPPCOMMAND_MASK);

   263 

   264 			switch (cmd)

   265 			{

   266                 case Const.APPCOMMAND_BROWSER_BACKWARD:

   267 					rcb = RemoteControlButton.Back;

   268 					break;

   269                 case Const.APPCOMMAND_MEDIA_CHANNEL_DOWN:

   270 					rcb = RemoteControlButton.ChannelDown;

   271 					break;

   272                 case Const.APPCOMMAND_MEDIA_CHANNEL_UP:

   273 					rcb = RemoteControlButton.ChannelUp;

   274 					break;

   275                 case Const.APPCOMMAND_MEDIA_FAST_FORWARD:

   276 					rcb = RemoteControlButton.FastForward;

   277 					break;

   278                 case Const.APPCOMMAND_VOLUME_MUTE:

   279 					rcb = RemoteControlButton.VolumeMute;

   280 					break;

   281                 case Const.APPCOMMAND_MEDIA_PAUSE:

   282 					rcb = RemoteControlButton.Pause;

   283 					break;

   284                 case Const.APPCOMMAND_MEDIA_PLAY:

   285 					rcb = RemoteControlButton.Play;

   286 					break;

   287                 case Const.APPCOMMAND_MEDIA_PLAY_PAUSE:

   288                     rcb = RemoteControlButton.PlayPause;

   289                     break;

   290                 case Const.APPCOMMAND_MEDIA_RECORD:

   291 					rcb = RemoteControlButton.Record;

   292 					break;

   293                 case Const.APPCOMMAND_MEDIA_PREVIOUSTRACK:

   294 					rcb = RemoteControlButton.PreviousTrack;

   295 					break;

   296                 case Const.APPCOMMAND_MEDIA_REWIND:

   297 					rcb = RemoteControlButton.Rewind;

   298 					break;

   299                 case Const.APPCOMMAND_MEDIA_NEXTTRACK:

   300 					rcb = RemoteControlButton.NextTrack;

   301 					break;

   302                 case Const.APPCOMMAND_MEDIA_STOP:

   303 					rcb = RemoteControlButton.Stop;

   304 					break;

   305                 case Const.APPCOMMAND_VOLUME_DOWN:

   306 					rcb = RemoteControlButton.VolumeDown;

   307 					break;

   308                 case Const.APPCOMMAND_VOLUME_UP:

   309 					rcb = RemoteControlButton.VolumeUp;

   310 					break;

   311 			}

   312 

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

   314                 this.ButtonPressed(this, new RemoteControlEventArgs(rcb, GetDevice(lParam)));

   315 		}

   316 

   317         /// <summary>

   318         /// 

   319         /// </summary>

   320         /// <param name="aUsage"></param>

   321         private void HidConsumerDeviceHandler(ushort aUsage)

   322         {

   323             if (aUsage == 0)

   324             {

   325                 //Just skip those

   326                 return;

   327             }

   328 

   329             if (Enum.IsDefined(typeof(ConsumerControl), aUsage) && aUsage != 0) //Our button is a known consumer control

   330             {

   331                 if (this.ButtonPressed != null)

   332                 {

   333                     RemoteControlButton button=RemoteControlButton.Unknown;

   334                     if (aUsage == (ushort)ConsumerControl.AppCtrlProperties || aUsage == (ushort)ConsumerControl.MceProperties)

   335                     {

   336                         button = RemoteControlButton.MoreInfo;

   337                     }

   338                     else if (aUsage == (ushort)ConsumerControl.AppCtrlPrint)

   339                     {

   340                         button = RemoteControlButton.Print;

   341                     }

   342                     else if (aUsage == (ushort)ConsumerControl.MediaSelectProgramGuide || aUsage == (ushort)ConsumerControl.MceProgramGuide)

   343                     {

   344                         button = RemoteControlButton.Guide;

   345                     }

   346                     this.ButtonPressed(this, new RemoteControlEventArgs(button, InputDevice.OEM));

   347                 }

   348             }

   349             else

   350             {

   351                 Debug.WriteLine("Unknown Consumer Control!");

   352             }

   353         }

   354 

   355         /// <summary>

   356         /// 

   357         /// </summary>

   358         /// <param name="aUsage"></param>

   359         private void HidMceRemoteHandler(ushort aUsage)

   360         {

   361             if (aUsage == 0)

   362             {

   363                 //Just skip those

   364                 return;

   365             }

   366 

   367 

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

   369             {

   370                 if (this.ButtonPressed != null)

   371                 {

   372                     this.ButtonPressed(this, new RemoteControlEventArgs((MceButton)aUsage, InputDevice.OEM));

   373                 }

   374             }

   375             else

   376             {

   377                 Debug.WriteLine("Unknown MCE button!");

   378             }

   379 

   380         }

   381 

   382 

   383 		private void ProcessInputCommand(ref Message message)

   384 		{

   385             //We received a WM_INPUT message

   386             Debug.WriteLine("================WM_INPUT================");

   387 

   388             //Check if we received this message while in background or foreground

   389             if (Macro.GET_RAWINPUT_CODE_WPARAM(message.WParam) == Const.RIM_INPUT)

   390             {

   391                 Debug.WriteLine("================FOREGROUND");

   392             }

   393             else if (Macro.GET_RAWINPUT_CODE_WPARAM(message.WParam) == Const.RIM_INPUTSINK)

   394             {

   395                 Debug.WriteLine("================BACKGROUND");

   396             }

   397 

   398             //Declare a pointer

   399             IntPtr rawInputBuffer = IntPtr.Zero;

   400 

   401             try

   402             {

   403                 //Fetch raw input

   404                 RAWINPUT rawInput = new RAWINPUT();

   405                 if (!RawInput.GetRawInputData(message.LParam, ref rawInput, ref rawInputBuffer))

   406                 {

   407                     return;

   408                 }

   409 

   410                 //Fetch device info

   411                 RID_DEVICE_INFO deviceInfo = new RID_DEVICE_INFO();

   412                 if (!RawInput.GetDeviceInfo(rawInput.header.hDevice, ref deviceInfo))

   413                 {

   414                     return;

   415                 }

   416                

   417 

   418                 if (rawInput.header.dwType == Const.RIM_TYPEHID)  //Check that our raw input is HID                        

   419                 {

   420                     Debug.WriteLine("WM_INPUT source device is HID.");

   421                     //Get Usage Page and Usage

   422                     Debug.WriteLine("Usage Page: 0x" + deviceInfo.hid.usUsagePage.ToString("X4") + " Usage ID: 0x" + deviceInfo.hid.usUsage.ToString("X4"));

   423 

   424                     //

   425                     HidUsageHandler usagePageHandler=null;

   426 

   427                     //Check if this an MCE remote HID message

   428                     if (deviceInfo.hid.usUsagePage == (ushort)Hid.UsagePage.MceRemote && deviceInfo.hid.usUsage == (ushort)Hid.UsageId.MceRemoteUsage)

   429                     {                        

   430                         usagePageHandler = HidMceRemoteHandler;

   431                     }

   432                     //Check if this is a consumer control HID message

   433                     else if (deviceInfo.hid.usUsagePage == (ushort)Hid.UsagePage.Consumer && deviceInfo.hid.usUsage == (ushort)Hid.UsageId.ConsumerControl)

   434                     {

   435                         usagePageHandler = HidConsumerDeviceHandler;

   436                     }

   437                     //Unknown HID message

   438                     else

   439                     {

   440                         Debug.WriteLine("Unknown HID message.");

   441                         return;

   442                     }

   443 

   444                     if (!(rawInput.hid.dwSizeHid > 1     //Make sure our HID msg size more than 1. In fact the first ushort is irrelevant to us for now

   445                         && rawInput.hid.dwCount > 0))    //Check that we have at least one HID msg

   446                     {

   447                         return;

   448                     }

   449 

   450 

   451                     //Allocate a buffer for one HID input

   452                     byte[] hidInput = new byte[rawInput.hid.dwSizeHid];

   453 

   454                     //For each HID input in our raw input

   455                     for (int i = 0; i < rawInput.hid.dwCount; i++)

   456                     {

   457                         //Compute the address from which to copy our HID input

   458                         int hidInputOffset = 0;

   459                         unsafe

   460                         {

   461                             byte* source = (byte*)rawInputBuffer;

   462                             source += sizeof(RAWINPUTHEADER) + sizeof(RAWHID) + (rawInput.hid.dwSizeHid * i);

   463                             hidInputOffset = (int)source;

   464                         }

   465 

   466                         //Copy HID input into our buffer

   467                         Marshal.Copy(new IntPtr(hidInputOffset), hidInput, 0, rawInput.hid.dwSizeHid);

   468 

   469                         //Print HID raw input in our debug output

   470                         string hidDump = "HID " + rawInput.hid.dwCount + "/" + rawInput.hid.dwSizeHid + ":";

   471                         foreach (byte b in hidInput)

   472                         {

   473                             hidDump += b.ToString("X2");

   474                         }

   475                         Debug.WriteLine(hidDump);

   476                         

   477                         ushort usage = 0;

   478                         //hidInput[0] //Not sure what's the meaning of the code at offset 0

   479                         if (hidInput.Length == 2)

   480                         {

   481                             //Single byte code

   482                             usage = hidInput[1]; //Get button code

   483                         }

   484                         else if (hidInput.Length > 2) //Defensive

   485                         {

   486                             //Assuming double bytes code

   487                             usage = (ushort)((hidInput[2] << 8) + hidInput[1]);

   488                         }

   489 

   490                         Debug.WriteLine("Usage: 0x" + usage.ToString("X4"));

   491 

   492                         //Call on our Usage Page handler

   493                         usagePageHandler(usage);

   494                     }

   495 

   496                 }

   497                 else if (rawInput.header.dwType == Const.RIM_TYPEMOUSE)

   498                 {

   499                     Debug.WriteLine("WM_INPUT source device is Mouse.");

   500                     // do mouse handling...

   501                 }

   502                 else if (rawInput.header.dwType == Const.RIM_TYPEKEYBOARD)

   503                 {

   504                     Debug.WriteLine("WM_INPUT source device is Keyboard.");

   505                     // do keyboard handling...

   506 

   507                 }

   508             }

   509             finally

   510             {

   511                 //Always executed when leaving our try block

   512                 Marshal.FreeHGlobal(rawInputBuffer);

   513             }

   514 		}

   515 

   516 

   517 		private InputDevice GetDevice(IntPtr lParam)

   518 		{

   519 			InputDevice inputDevice;

   520 

   521             switch (Macro.GET_DEVICE_LPARAM(lParam))

   522 			{

   523 				case Const.FAPPCOMMAND_OEM:

   524 					inputDevice = InputDevice.OEM;

   525 					break;

   526 				case Const.FAPPCOMMAND_MOUSE:

   527 					inputDevice = InputDevice.Mouse;

   528 					break;

   529 				default:

   530 					inputDevice = InputDevice.Key;

   531 					break;

   532 			}

   533 

   534 			return inputDevice;

   535 		}

   536 	}

   537 }
SharpLibHid