How To's

Configuring Window Mobile Smartphone Emulator for Network Access

I was asked recently how to configure the ~~Smartphone~~ (excuse me Windows Mobile Standard) device in the emulator to access network resources. Since there doesn’t appear to be any clear step-by-step directions on this, I will outline the necessary steps here.

First, begin by launching Visual Studio and create or open a SmartClient (SmartPhone) project and set the target platform to Windows Mobile 5.0 SmartPhone SDK. In Visual Studio, select Tools | Connect to Device…

From the emulator window select File | Configure…, then select the network tab. Select the Enable NE2000 PCMCIA network adapter and bind to: checkbox and select the Connected Network Card option or the specific network adapter in use by your workstation and click OK…

Using the device emulator, select [Start] | 9 (Device Setting) | 6 (Connections) | 5 (Proxy) | 1 (Add). Set the description value to the workstation name, set the Connects from field to “Work” and the Connects to field to “Internet” and select [Done] (leave the other fields to the default values). Select [Done] until returning to the Connections menu.

From the Connections menu, select [Menu] | 1 (Advanced) and make sure all setting are set to “Automatic”, then select [Menu] | 1 (Options) and scroll down to the “My desktop connects to:” setting and change it to “The Interenet”. Note: if you only want to test services that are available on your workstation then this value should be set to “Work”. Select [Done] until you return to the Start menu. Then select Internet Explorer to test internet browsing.

That’s all there is to it! Of course, your could also cradle the emulator using Device Emulator Manager to connect via ActiveSync.

ASP.NET 2.0: Developing Rich UI Custom Web Controls

Here's the slides and demo code from my recent talk at the Huntsville Code Camp. In this presentation I focus on building rich custom web controls. The demo code shows how to build your own Outlook-style navigation pane.

Enjoy!

Windows Mobile 5.0: Techniques for Building Compelling Mobile Solution

Here's the slides and demo code from my recent talk at the Huntsville Code Camp. In this presentation I focus on usage patterns and key success factors for building great mobile applications. The demo code shows how to build your own custom controls to enhance the user experience.

Enjoy!

Sql Server Integration Service (SSIS) Execute SQL Task ODBC Result Set Bug/Workaround

Recently, I discovered an issue with SQL Server Integration Services (SSIS) regarding how the Execute SQL Task item handles returning a result set to the control flow. Lets start by demonstrating an existing issue with the Execute SQL Task using ODBC then I'll present a solution. First, create a new DSN that points to the database using the ODBC Data Sources Administrator (Control Panel | Administrator Tools | ODBC Data Sources). If you are only dealing with SQL Server you can still test this out by creating a DSN that uses the SQL Server ODBC driver.

Figure 1 shows our initial control flow that issues a query to an ODBC data source (in my initial case a DB2 database residing on a mainframe that needs to download data to a SQL Server 2005 and SQL Mobile database), iterates through the results, and carries out some additional data flow based on each row in the initial result set.

Figure 1. SSIS package control flow using Execute SQL Task

In Visual Studio 2005, create a new BI Integration Services project. In the Connection Managers window right-click and select New Connection... From the Add SSIS Connection Manager dialog, highlight ODBC and select the Add... button to continue. In the Configure ODBC Connection Manager dialog, Select the New... button, complete the necessary information in the Connection Manager dialog, select Test Connection to verify your settings, then select the OK button. Your ODBC Connection is now complete and should appear similar to the screen in Figure 2.

Figure 2. Configure ODBC Connection Manager dialog

Next, add an Execute SQL Task item to the package's control flow. Right-click the task, select the Edit... command. In the Execute SQL Task Editor dialog (Figure 3), set the necessary properties. Since we will be issuing a Select command and want to have access to the result set, begin by setting the Result set property to "Full result set". Next, set the ConnectionType to ODBC and assign the previously created ODBC connection to the Connection property. In the SQLStatement property, type the SQL for the select statement.

Figure 3. Execute SQL Task Editor - General Page

In the page list of the Execute SQL Task Editor, select the Result Set page (Figure 4). Select the Add... button to create a result set mapping. Change the Result Name to "0" (zero) and add a new variable to hold the result set. But sure the variable type is set to type Object and has package-level scope. Select OK to continue.

Figure 4. Execute SQL Task Editor - Result Set Page

Now we are ready to test the execution of the task. Simply right-click the task item and select Execute Task. The execution will produce the following error message:

[Execute SQL Task] Error: Executing the query "select locationid, name from production.location" failed with the following error: "Disconnected recordsets are not available from ODBC connections.". Possible failure reasons: Problems with the query, "ResultSet" property not set correctly, parameters not set correctly, or connection not established correctly.

According to feedback I received from Microsoft support, this is completely by design. The explanation I received, suggested that because the ODBC specs does support disconnected recordsets, the Execute SQL Task item is functioning as designed. What? Huh? Can't be? In .NET, a dataset is dataset is dataset, right?. It has no knowledge of the connection used to load it's data. That's ADO.NET 101 right? However, I must say that if you using an OLE provider the Execute SQL Task item functions as expected and returns the result set correctly, but not with ODBC and I haven't been able to get it to return the result set when the connection is SQL Mobile. So, how do we work around this when we need to have access to the result set using ODBC or other none OLE data providers? We begin by replacing the Execute SQL Task item with a Script Task (not an ActiveX Script Task, although you could use it also and write VBScript or JScript code). Right-click the Script Task and select the Edit... command. In the Script Task Editor (Figure 5), set the ReadWriteVariables property to include the variable (in this example the variable is named varDataset) that was previously defined to contain the result set using the Execute SQL Task.

Figure 5. Script Task Editor dialog

Next, select the Design Script... button to launch the Visual Basic for Application editor and enter the following code in Sub Main of the ScriptMain class:

Public Sub Main()
Dim connName As String = Dts.Connections(0).Name
Dim conn As Odbc.OdbcConnection = CType(Dts.Connections(0).AcquireConnection(Nothing), Odbc.OdbcConnection)
Dim da As Odbc.OdbcDataAdapter = New Odbc.OdbcDataAdapter("select locationid, name from production.location", conn)
Dim ds As Data.DataSet = New Data.DataSet()

Try
     da.Fill(ds)
     Dts.Variables("varDataset").Value = ds
Catch ex As Exception
     Dts.TaskResult = Dts.Results.Failure
     Return
Finally
     da.Dispose()
End Try

Dts.TaskResult = Dts.Results.Success
End Sub

Notice that this code can reference the current DTS package directly including the connections and variables defined in the package. Don't forget to make the variables available to the script as previously described or the code will throw an exception because the variable hasn't been exposed. Our final control flow (Figure 6) will look much like it did before only we have replaced the first Execute SQL Task item.

Close the script window, select OK to continue, then right-click the Script Task and select the Execute Task command. The Script Task will execute the SQL command and assign the result set to the varDataset variable. The varDataset variable can now be used to iterate the dataset in subsequent data flow like a Foreach Loop Task as demonstrated in this example. In my opinion, this is what the Execute SQL Task should do, and does do, except for ODBC connection types. Although we had to do a little more work than if the Execute SQL Task worked properly, the real power of SSIS is demonstrated by the fact we can jump right in and add the correct plumbing so that data control flow is unaffected. With the Script Task item and ActiveX Script Task item we can create some powerful BI integration solutions and work around some shortcoming that are sure to get corrected over time.

Ajax: Creating a rich user-experience for your web-based application

Here's the slides and demo code from my recent talk at MADEV. The topic is "Creating a rich user experience for your web-based application" and I focus on some techniques you can use to make your web-based application more responsive and fluid using the XmlHttpRequest object, XML, javascript (better known as Ajax) and ASP.NET.

Enjoy!

VSTO2 Code Camp Demo

Here's my demo solution and PPTs from the last MADEV meeting and Atlanta Code Camp. The demo is based VS2005 Beta 2. The solution hits all of the new VSTO 2 features (except schema-based programming). Enjoy!

My MSDN Article...

Here's a link to a recent article I did for Microsoft's Smart-Client Developer Center on MSDN. It's a very interesting topic or great sleep material, depending on your viewpoint. One thing is for sure, users are beginning to demand software that is; elegantly-simply with a range of choices on how to accomplish tasks. Enjoy!

http://msdn.microsoft.com/smartclient/default.aspx?pull=/library/en-us/dnwinforms/html/altinputdevices.asp

Programming for the '10 Foot Experience' via Remote Control (Part 2 of 2)

In part 1 of this post, we looked at how to capture two of the three messages generated by the remote control device. These two messages covered most of the buttons on the remote. The remaining buttons (e.g. Guide, Recorded TV, More, etc.) will generate a WM_INPUT message. The WM_INPUT message requires some additional steps to correctly interpret the button that was pressed. In order for your application to receive WM_INPUT messages, it must first register the raw input devices using the RegisterRawInputDevices function. Your application will not receive this message until this function is called.

We begin by defining a RAWINPUTDEVICE structure to pass into the RegisterRawInputDevices function. The first parameter of the RegisterRawInputDevices function accepts an array RAWINPUTDEVICES to denote the exact collection usage pages and usage collection (i.e. buttons) we want to register to receive the WM_INPUT message. In this case, I am registering two different usage pages containing three different usage collections.

  [StructLayout(LayoutKind.Sequential)]
  internal struct RAWINPUTDEVICE
  {
   [MarshalAs(UnmanagedType.U2)]
   public ushort usUsagePage;
   [MarshalAs(UnmanagedType.U2)]
   public ushort usUsage;
   [MarshalAs(UnmanagedType.U4)]
   public int dwFlags;
   public IntPtr hwndTarget;
  }

   [DllImport("User32.dll")]
  extern static bool RegisterRawInputDevices(RAWINPUTDEVICE[] pRawInputDevice, uint uiNumDevices, uint cbSize);

  private const int WM_INPUT  = 0x00FF;

// Buttons that generate the WM_INPUT message
  private const int RAWINPUT_DETAILS    = 0x209;
  private const int RAWINPUT_GUIDE    = 0x8D;
  private const int RAWINPUT_TVJUMP    = 0x25;
  private const int RAWINPUT_STANDBY    = 0x82;
  private const int RAWINPUT_OEM1     = 0x80;
  private const int RAWINPUT_OEM2     = 0x81;
  private const int RAWINPUT_MYTV     = 0x46;
  private const int RAWINPUT_MYVIDEOS    = 0x4A;
  private const int RAWINPUT_MYPICTURES   = 0x49;
  private const int RAWINPUT_MYMUSIC    = 0x47;
  private const int RAWINPUT_RECORDEDTV   = 0x48;
  private const int RAWINPUT_DVDANGLE    = 0x4B;
  private const int RAWINPUT_DVDAUDIO    = 0x4C;
  private const int RAWINPUT_DVDMENU    = 0x24;
  private const int RAWINPUT_DVDSUBTITLE   = 0x4D;

   ...

  //-------------------------------------------------------------
  // constructors
  //-------------------------------------------------------------

  public RemoteControlDevice()
  {
   // Register the input device to receive the commands from the
   // remote device. See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwmt/html/remote_control.asp
   // for the vendor defined usage page.

   RAWINPUTDEVICE[] rid = new RAWINPUTDEVICE[3];

   rid[0].usUsagePage = 0xFFBC;
   rid[0].usUsage = 0x88;
   rid[0].dwFlags = 0;

   rid[1].usUsagePage = 0x0C;
   rid[1].usUsage = 0x01;
   rid[1].dwFlags = 0;

   rid[2].usUsagePage = 0x0C;
   rid[2].usUsage = 0x80;
   rid[2].dwFlags = 0;

   if (!RegisterRawInputDevices(rid,
    (uint) rid.Length,
    (uint) Marshal.SizeOf(rid[0]))
    )
   {
    throw new ApplicationException("Failed to register raw input devices.");
   }

Once RegisterRawInputDevices is successfully called our application will now begin to receive the WM_INPUT message. Next, once a message is generated we must use the GetRawInputData function to determine the value of the button that was actually selected. You would think that this would be a straight-forward process, but it takes a little bit of work to the actually retrieve the data containing the button value.

[DllImport("User32.dll")]
extern static uint GetRawInputData(IntPtr hRawInput, uint uiCommand, IntPtr pData, ref uint pcbSize, uint cbSizeHeader);

  [StructLayout(LayoutKind.Sequential)]
  internal struct RAWINPUTHEADER
  {
   [MarshalAs(UnmanagedType.U4)]
   public int dwType;
   [MarshalAs(UnmanagedType.U4)]
   public int dwSize;
   public IntPtr hDevice;
   [MarshalAs(UnmanagedType.U4)]
   public int wParam;
  }

  [StructLayout(LayoutKind.Sequential)]
  internal struct RAWHID
  {
   [MarshalAs(UnmanagedType.U4)]
   public int dwSizHid;
   [MarshalAs(UnmanagedType.U4)]
   public int dwCount;
  }

  [StructLayout(LayoutKind.Explicit)]
  internal struct RAWINPUT
  {
   [FieldOffset (0)] public RAWINPUTHEADER header;
//   [FieldOffset (16)] public RAWMOUSE mouse;
//   [FieldOffset (16)] public RAWKEYBOARD keyboard;
   [FieldOffset (16)] public RAWHID hid;
  }

  private void ProcessInputCommand(ref Message message)
  {
   RemoteControlButton rcb = RemoteControlButton.Unknown;
   uint dwSize = 0;

   GetRawInputData(message.LParam,
    RID_INPUT,
    IntPtr.Zero,
    ref dwSize,
    (uint) Marshal.SizeOf(typeof(RAWINPUTHEADER)
    ));

   IntPtr buffer = Marshal.AllocHGlobal((int) dwSize);
   try
   {
    if(buffer == IntPtr.Zero)
     return;

    if (GetRawInputData(message.LParam,
     RID_INPUT,
     buffer,
     ref dwSize,
     (uint) Marshal.SizeOf(typeof(RAWINPUTHEADER))) != dwSize
     )
    {
     return;
    }

    RAWINPUT raw = (RAWINPUT) Marshal.PtrToStructure(buffer, typeof(RAWINPUT));
    if(raw.header.dwType == RIM_TYPEHID)
    {
     byte[] bRawData = new byte[raw.hid.dwSizHid];
     int pRawData = buffer.ToInt32() + Marshal.SizeOf(typeof(RAWINPUT)) + 1;

     Marshal.Copy(new IntPtr(pRawData), bRawData, 0, raw.hid.dwSizHid - 1);
     int rawData = bRawData[0] | bRawData[1] << 8;

     switch (rawData)
     {
      case RAWINPUT_DETAILS:
       rcb = RemoteControlButton.Details;
       break;
      case RAWINPUT_GUIDE:
       rcb = RemoteControlButton.Guide;
       break;
      case RAWINPUT_TVJUMP:
       rcb = RemoteControlButton.TVJump;
       break;
      case RAWINPUT_STANDBY:
       rcb = RemoteControlButton.StandBy;
       break;
      case RAWINPUT_OEM1:
       rcb = RemoteControlButton.OEM1;
       break;
    ...
}

     if (rcb != RemoteControlButton.Unknown && this.ButtonPressed != null)
      this.ButtonPressed(this, new RemoteControlEventArgs(rcb, GetDevice(message.LParam.ToInt32())));
    }
    else if(raw.header.dwType == RIM_TYPEMOUSE)
    {
     // do mouse handling...
    }
    else if(raw.header.dwType == RIM_TYPEKEYBOARD)
    {
     // do keyboard handling...
    }
   }
   finally
   {
    Marshal.FreeHGlobal(buffer);
   }
  }

We began by creating the appropriate structures required or use by the GetRawInputData function. The main structure is RAWINPUT, which contains a RAWINPUTHEADER and RAWHID structure. The RAWINPUTHEADER contains all sorts of useful information but the actually button value from the remote is stored in the RAWHID structure. Since the last member of the RAWHID structure actually expects an array of bytes, things get a little more complicated because we can't predict the actually size of bRawData member at definition. Fortunately, all this information is passed to us from the GetRawInputData function. The first call to the GetRawInputData function is purely informational; we need to determine the size of buffer needed to handle the entire RAWINPUT structure. This value is returned in the dwSize param of the GetRawInputData function. Once we know actually size of RAWINPUT we can allocate a buffer of the correct size and call GetRawInputData again this time passing in the buffer to get all the data for RAWINPUT. The buffer is casted to a RAWINPUT structure and then we must check the header to insure the input is of RIM_TYPEHID, which the type generated by remote control devices. Lastly, we need to create a byte array and copy the raw data based on the value of dwSizHid and do a little bit shifting to get the actually button value. This may seem like a long way to go the get the actual input, but if written correctly this code will work for any number of Human Inteface Devices (HIDs).

A remote control device is just one of many user-input devices to consider besides the traditional keyboard and mouse. User input can come from a joystick, touch screen, hand glove, microphone, or other specialize devices. Windows XP with Service Pack 1 or greater provides a stable and robust way for applications to leverage the flexibility of these devices.

Download remotecontrolsample.zip

Programming for the '10 Foot Experience' via Remote Control (Part 1 of 2)