Find the Device ID of your Windows Mobile device.

Before going into finding a Device ID, it's good to know a few things in detail about what a Device ID actually is.




A Device ID is basically a unique identifier that is necessary for the device identification as well as security.


The Device ID basically comprises of two parts.


1. platform ID
2. handset ID or preset ID


The 'platform ID' is the ID for a particular manufacturer,i.e., handsets from a particular manufacturer would have this part of the Device ID same.


The 'handset ID' is an identifier that is preset with every handset. This identifier is unique for each handset that is manufactured by a particular manufacturer.


So, both the platform ID and the handset ID are not unique individually. 
It's only the combination of the 'Platform ID' and the 'Handset ID' that is unique.


OK. Now lets go on to the code.




The code below is a C# .NET CF code with Platform Invoking some native methods.


I've included some comments which might be useful.





using System;


using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.Diagnostics;
using System.Runtime.InteropServices;


namespace DeviceID
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private static Int32 METHOD_BUFFERED = 0;
        private static Int32 FILE_ANY_ACCESS = 0;
        private static Int32 FILE_DEVICE_HAL = 0x00000101;


        private const Int32 ERROR_NOT_SUPPORTED = 0x32;
        private const Int32 ERROR_INSUFFICIENT_BUFFER = 0x7A;


        private static Int32 IOCTL_HAL_GET_DEVICEID =
            ((FILE_DEVICE_HAL) << 16) | ((FILE_ANY_ACCESS) << 14)
            | ((21) << 2) | (METHOD_BUFFERED);


        [DllImport("coredll.dll", SetLastError = true)]
        private static extern bool KernelIoControl(Int32 dwIoControlCode,
            IntPtr lpInBuf, Int32 nInBufSize, byte[] lpOutBuf,
            Int32 nOutBufSize, ref Int32 lpBytesReturned);




        private void Form1_Load(object sender, EventArgs e)
        {
            try
            {
                // Show the device ID.
                string strDeviceID = GetDeviceID();
                MessageBox.Show("Device ID: " + strDeviceID);


                // Show the device name.
                string deviceName = System.Net.Dns.GetHostName();
                MessageBox.Show("Device Name: " + deviceName);
            }


            catch (Exception ex)
            {
                MessageBox.Show(ex.Message.ToString());
            }


        }


        private static string GetDeviceID()
        {
            // Initialize the output buffer to the size of a 
            // Win32 DEVICE_ID structure.
            byte[] outbuff = new byte[20];
            Int32 dwOutBytes;
            bool done = false;


            Int32 nBuffSize = outbuff.Length;


            // Set DEVICEID.dwSize to size of buffer.  Some platforms look at
            // this field rather than the nOutBufSize param of KernelIoControl
            // when determining if the buffer is large enough.
            BitConverter.GetBytes(nBuffSize).CopyTo(outbuff, 0);
            dwOutBytes = 0;


            // Loop until the device ID is retrieved or an error occurs.
            while (!done)
            {
                if (KernelIoControl(IOCTL_HAL_GET_DEVICEID, IntPtr.Zero,
                    0, outbuff, nBuffSize, ref dwOutBytes))
                {
                    done = true;
                }
                else
                {
                    int error = Marshal.GetLastWin32Error();
                    switch (error)
                    {
                        case ERROR_NOT_SUPPORTED:
                            throw new NotSupportedException(
                                "IOCTL_HAL_GET_DEVICEID is not supported on this device",
                                new Win32Exception(error));


                        case ERROR_INSUFFICIENT_BUFFER:


                            // The buffer is not big enough for the data.  The
                            // required size is in the first 4 bytes of the output
                            // buffer (DEVICE_ID.dwSize).
                            nBuffSize = BitConverter.ToInt32(outbuff, 0);
                            outbuff = new byte[nBuffSize];


                            // Set DEVICEID.dwSize to size of buffer.  Some
                            // platforms look at this field rather than the
                            // nOutBufSize param of KernelIoControl when
                            // determining if the buffer is large enough.
                            BitConverter.GetBytes(nBuffSize).CopyTo(outbuff, 0);
                            break;


                        default:
                            throw new Win32Exception(error, "Unexpected error");
                    }
                }
            }


            // Copy the elements of the DEVICE_ID structure.
            Int32 dwPresetIDOffset = BitConverter.ToInt32(outbuff, 0x4);
            Int32 dwPresetIDSize = BitConverter.ToInt32(outbuff, 0x8);
            Int32 dwPlatformIDOffset = BitConverter.ToInt32(outbuff, 0xc);
            Int32 dwPlatformIDSize = BitConverter.ToInt32(outbuff, 0x10);
            StringBuilder sb = new StringBuilder();


            for (int i = dwPresetIDOffset;
                i < dwPresetIDOffset + dwPresetIDSize; i++)
            {
                sb.Append(String.Format("{0:X2}", outbuff[i]));
            }


            sb.Append("-");


            for (int i = dwPlatformIDOffset;
                i < dwPlatformIDOffset + dwPlatformIDSize; i++)
            {
                sb.Append(String.Format("{0:X2}", outbuff[i]));
            }
            return sb.ToString();
        }


    }
}




The above code is what I used to find out the Device ID and it worked perfectly fine for me.

Please Note: The length of the Device ID in bytes would be around 32 bytes, but it could vary depending on the manufacturer.

Try it out, and don't forget to post back any comments.