April, 2008

<configuration>
  <startup>
    <supportedRuntime version="v3.5.7283"/>
  </startup>
</configuration>

5x 
   $GPRMC - Recommended Minimum specific GPS/TRANSIT data
   $GPVTG - Track Made Good and Ground Speed
   $GPGGA - Global Positioning System fix data
   $GPGSA - GPS DOP and Satellites Active
3x
   $GPGSV - Satellites in View

/// <summary>
/// Show data details: takes a datatable (it could have been a hashtable or a dictionary), and depending on category, calculates ranges for X and Y
/// positions and creates a Points[] structure. Then use this.CreateGraphics to draw lines and polygons
/// </summary>
/// <param name="category">data category to show</param>
/// <param name="table">table containing data</param>
internal void Show(string category, DataTable table)
{
    Cursor.Current = Cursors.WaitCursor;

    //this is done at the beginning so that this.CreateGraphics can work
    this.Show();
    //let's make sure the Message Pump is not blocked
    Application.DoEvents();

    //table has 2 columns
    //when showing speed, distance, altitude, etc over time
    //Column1 is where relevant data is saved
    //Column2 is where time data is saved
    //when showing path, Column1 is the latitude and Column2 the longitude
    int Column1 = 0; 
    int Column2 = 0; 

    //when showing speed, distance, altitude a string will be drawn with max value
    string unit = string.Empty;
    
    //boolean values set depending on data to be shown
    //bool bSpeed = false;
    //bool bDistance = false;
    //bool bAltitude = false;
    bool bPosition = false;

    //depending on the category to "show", previous variables may assume different values
    #region switch (category)
    switch (category)
    {
        case "speed":
            Column1 = 1;
            Column2 = 0;
            unit = "kmph";
            //bSpeed = true;
            //bDistance = false;
            //bAltitude = false;
            bPosition = false;
            break;
        case "distance":
            Column1 = 1;
            Column2 = 0;
            unit = "km";
            //bSpeed = false;
            //bDistance = true;
            //bAltitude = false;
            bPosition = false;
            break;
        case "altitude":
            Column1 = 1;
            Column2 = 0;
            unit = "m";
            //bSpeed = false;
            //bDistance = false;
            //bAltitude = true;
            bPosition = false;
            break;
        case "position":
            Column1 = 0;
            Column2 = 1;
            //bSpeed = false;
            //bDistance = false;
            //bAltitude = false;
            bPosition = true;
            break;
        //default:
        //    //...
        //    break;
    }
    #endregion

    #region check if data was saved
    if (table.Rows.Count == 0) //no data has been saved
    {
        using (Graphics g = this.CreateGraphics())
        {
            Font f = new Font(FontFamily.GenericSansSerif, 16.0f, FontStyle.Bold);
            SolidBrush b = new SolidBrush(Color.Black);
            g.DrawString("NO DATA", f, b, 0.0f, 0.0f);
            b.Dispose();
            f.Dispose();
        }
        return;
    }
    #endregion

    //to maintain the code independent on the orientation of the device
    int ShortestSideOfTheDevice = Math.Min(this.ClientSize.Width, this.ClientSize.Height);

    //array to store points to be drawn
    Point[] points;

    //min,max, range values for latitude and longitude
    double minX, maxX, rangeX, minY, maxY, rangeY;

    #region fill points[] and calculate minX, maxX, rangeX, minY, maxY, rangeY when bPosition = false
    if (!bPosition)
    {
        //assume last row contains the total elapsed seconds
        maxX = double.Parse(table.Rows[count - 1][Column2].ToString(), frmMain.Instance.DataCultureInfo); 
        minX = 0;
        rangeX = maxX - minX;

        maxY = FindMax(table, Column1);
        minY = FindMin(table, Column1);
        rangeY = maxY - minY;

        //initialize Point array
        points = new Point[table.Rows.Count + 2];
        //adding 2 points [0, Height] and [Width, Height] because we want a polygon
        //first point
        points[0].X = 0;
        points[0].Y = this.ClientSize.Height;
        //last point
        points[table.Rows.Count + 1].X = this.ClientSize.Width;
        points[table.Rows.Count + 1].Y = this.ClientSize.Height;

        //fill Point array
        int i = 1;
        double percentX, percentY;
        foreach (DataRow row in table.Rows)
        {
            //handle range = 0, otherwise possible DivideByZeroException
            if (rangeX == 0.0f)
                percentX = 100.0f;
            else
                percentX = (double.Parse(row[Column2].ToString(), frmMain.Instance.DataCultureInfo) - minX) / rangeX;

            //handle range = 0, otherwise possible DivideByZeroException
            if (rangeY == 0.0f)
                percentY = 100.0f;
            else
                percentY = (double.Parse(row[Column1].ToString(), frmMain.Instance.DataCultureInfo) - minY) / rangeY;

            //discard the point if NaN
            if (!(double.IsNaN(percentX) || double.IsNaN(percentY)))
            {
                points[i].X = Convert.ToInt32(this.ClientSize.Width * percentX);
                points[i].Y = this.ClientSize.Height - Convert.ToInt32(this.ClientSize.Height * percentY);
                ++i;
            }
        }
    }
    #endregion

    #region fill points[] and calculate minX, maxX, rangeX, minY, maxY, rangeY when bPosition = true
    else //bPosition = true
    {
        //find Min\Max for latitude\longitude so that we can scale the path
        //note that coordinates may be negative, when represented by doubles
        //this applies to minX, minY, maxX, maxY as well
        maxX = FindMax(table, Column2);
        minX = FindMin(table, Column2);
        rangeX = maxX - minX;

        maxY = FindMax(table, Column1);
        minY = FindMin(table, Column1);
        rangeY = maxY - minY;

        //initialize Point array
        points = new Point[table.Rows.Count];

        //in order to put the "image" at the center:
        //1. calculate current center in terms of latitude\longitude
        double centerX = minX + rangeX / 2;
        double centerY = minY + rangeY / 2;

        //2. calculate position in pixel of the current center
        double percentCenterX = (centerX - minX) / Math.Max(rangeX, rangeY);
        double percentCenterY = (centerY - minY) / Math.Max(rangeX, rangeY);
        double PixelCenterX = Convert.ToInt32(ShortestSideOfTheDevice * percentCenterX);
        double PixelCenterY = ShortestSideOfTheDevice - Convert.ToInt32(ShortestSideOfTheDevice * percentCenterY);

        //3. shift to center screen
        double PixelToShiftX = (ShortestSideOfTheDevice / 2) - PixelCenterX;
        double PixelToShiftY = (ShortestSideOfTheDevice / 2) - PixelCenterY;

        //now for each point:
        //    points[j].X += Convert.ToInt32(PixelToShiftX);
        //    points[j].Y -= Convert.ToInt32(PixelToShiftY);        
        
        //calculate percentage of the positions respect to the range
        //note that max(rangeX, rangeY) will be "mapped" to the min(this.ClientSize.Width, this.ClientSize.Height)
        //so that we can handle different orientations 
        int i = 0;
        double percentX, percentY;

        //to make the calculations hemisphere-independent, calculate percentages with absolute values
        foreach (DataRow row in table.Rows)
        {
            percentX = Math.Abs(
                (Math.Abs(double.Parse(row[Column2].ToString(), frmMain.Instance.DataCultureInfo)) - Math.Abs(minX)) / 
                    Math.Max(rangeX, rangeY)
                );
            percentY = Math.Abs(
                (Math.Abs(double.Parse(row[Column1].ToString(), frmMain.Instance.DataCultureInfo)) - Math.Abs(minY)) / 
                    Math.Max(rangeX, rangeY)
                );

            //discard the point if NaN
            if (!(double.IsNaN(percentX) || double.IsNaN(percentY)))
            {
                //now fill the Point array: percentX and percentY are non-negative values
                //PixelToShiftX and PixelToShiftY allow to center the image
                points[i].X = Convert.ToInt32(ShortestSideOfTheDevice * percentX) + Convert.ToInt32(PixelToShiftX);
                points[i].Y = ShortestSideOfTheDevice - Convert.ToInt32(ShortestSideOfTheDevice * percentY) - Convert.ToInt32(PixelToShiftY);
                ++i;
            }
        }
    }
    #endregion

    #region ACTUAL DRAWING
    using (Graphics g = this.CreateGraphics())
    {
        using (SolidBrush b = new SolidBrush(Color.Indigo))
        {
            g.Clear(Color.White);
       
            //if showing speed, distance, altitude: draw a polygon
            if (!bPosition)
            {
                g.FillPolygon(b, points);
                using (Font f = new Font(FontFamily.GenericSansSerif, 10.0f, FontStyle.Bold))
                {
                    b.Color = Color.Black;
                    g.DrawString(string.Format("Max: {0} {1}", maxY.ToString("F3", frmMain.Instance.DataCultureInfo), unit), f, b, 0.0f, 0.0f);
                }
            }
            else //bPosition == true
            {
                //draw path area - this is a square independently on the device
                b.Color = Color.Honeydew;
                g.FillRectangle(b, 0, 0, ShortestSideOfTheDevice, ShortestSideOfTheDevice);
                
                //draw path grid, one line for each km (horizontal and vertical)
                double KmInRange = GpsLocation.CalculateLinearDistance(
                        new GpsLocation(0.0f, 0.0f, 0.0f, string.Empty, string.Empty),
                        new GpsLocation(0.0f, Math.Max(rangeX, rangeY), 0.0f, string.Empty, string.Empty));
        
                using (Pen p = new Pen(Color.PaleTurquoise, 0.2f))
                {
                    for (int i = 0; i < Math.Ceiling(KmInRange); i++)
                    {
                        g.DrawLine(p, 20 + i * Convert.ToInt32(ShortestSideOfTheDevice / KmInRange), 0, 20 + i * Convert.ToInt32(ShortestSideOfTheDevice / KmInRange), ShortestSideOfTheDevice);
                        g.DrawLine(p, 0, 20 + i * Convert.ToInt32(ShortestSideOfTheDevice / KmInRange), ShortestSideOfTheDevice, 20 + i * Convert.ToInt32(ShortestSideOfTheDevice / KmInRange));
                    }
                }
                
                //draw path
                using (Pen p = new Pen(Color.Blue, 1.0f))
                {
                    g.DrawLines(p, points);
                }

                //Start point
                b.Color = Color.Green;
                g.FillEllipse(b, points[0].X - 3, points[0].Y - 3, 6, 6); 
                
                //Stop point
                b.Color = Color.Red;
                g.FillEllipse(b, points[points.GetLength(0) - 1].X - 2, points[points.GetLength(0) - 1].Y - 2, 4, 4); 
            }
        }
    }
    #endregion

    Cursor.Current = Cursors.Default;
}

/// <summary> 
/// ArrayList needed to easily fill a ListControl-based control (such as a Combo) through its .DataSource property 
/// </summary> 
public ArrayList PairedDevicesArrayList 
{ 
    get 
    { 
        ArrayList temp = new ArrayList(); 
        foreach (BluetoothDevice dev in btRadio.PairedDevices) 
        { 
            temp.Add(new BluetoothDevice(dev.Name, dev.Address)); 
        } 
        return temp; 
    } 
}

cmbPairedDevices.DataSource = BtLayer.PairedDevicesArrayList; 
cmbPairedDevices.DisplayMember = "Name"; 
if (cmbPairedDevices.Items.Count != 0) 
    cmbPairedDevices.SelectedIndex = 0; 

/// <summary> 
/// A collection representing Bluetooth devices which have been previously paired with this device. 
/// </summary> 
public BluetoothDeviceCollection PairedDevices 
{ 
    get 
    { 
        BluetoothDeviceCollection pairedDevices = new BluetoothDeviceCollection(); 
        const string BT_DEVICE_KEY_NAME = "Software\\Microsoft\\Bluetooth\\Device"; 
        IntPtr btDeviceKey = Registry.OpenKey(Registry.GetRootKey(Registry.HKey.LOCAL_MACHINE), BT_DEVICE_KEY_NAME); 
        ArrayList subKeyNames = Registry.GetSubKeyNames(btDeviceKey); 
        foreach (string deviceAddr in subKeyNames) 
        { 
            string deviceName = ""; 
            byte[] deviceAddress = new byte[8]; 
            IntPtr currentDeviceKey = Registry.OpenKey(btDeviceKey, deviceAddr); 
            deviceName = (string)Registry.GetValue(currentDeviceKey, "name"); 
            //RAFFAEL 
            //2 possible checks: 
            //1. the key name has some numbers 
            //2. the key has a subkey "Services" <-- choose this, good enough for now (but this can be done better) 
            ArrayList subKeyCheckList = Registry.GetSubKeyNames(currentDeviceKey); 
            if (subKeyCheckList.Count != 0) //at least one subkey 
            { 
                foreach(object subkeyName in subKeyCheckList) 
                { 
                    if ((string)subkeyName != "Services") //Services is not there 
                        break; //exit foreach 
                    else //Service is there 
                    { 
                        long longDeviceAddress = long.Parse(deviceAddr, System.Globalization.NumberStyles.HexNumber); 
                        BitConverter.GetBytes(longDeviceAddress).CopyTo(deviceAddress, 0); 
                        BluetoothDevice currentDevice = new BluetoothDevice(deviceName, deviceAddress); 
                        pairedDevices.Add(currentDevice); 
                    } 
                } 
            } 
            Registry.CloseKey(currentDeviceKey); 
            //END RAFFAEL 
        } 
        Registry.CloseKey(btDeviceKey); 
        return pairedDevices; 
    } 
}

/// <summary> 
/// Connect to the Serial Port service of the paired device whose index within the Paired Devices collection is 'selectedIndex' 
/// </summary> 
/// <param name="selectedIndex">index of the paired devices collection</param> 
/// <returns></returns> 
public bool ConnectToSerialPortOfSelectedPairedDevice(int selectedIndex) 
{ 
    bool res = true; 

    //check if paired device is correctly opened 
    if (null == (gpsDevice = (BluetoothDevice)BtRadio.PairedDevices[selectedIndex])) 
    { 
        //MessageBox.Show("Can't find any paired device."); 
        //or throw an exception that is caught by upper layers
        return false; 
    } 

    //try to connect to the Serial Port service for MAX_RETRIES times 
    int count = 0; 
    while ((null == (gpsStream = gpsDevice.Connect(StandardServices.SerialPortServiceGuid))) && (count < MAX_RETRIES)) 
    { 
        ++count; 
        if (count >= MAX_RETRIES) 
        { 
            res = false; 
            break; 
        } 
    } 
    return res; 
}

//gpsStream is a NetworkStream object, representing the stream which reading data from. 
//BluetoothRadio and BluetoothDevice use WINSOCK to connect to the antenna 
...
bCanRead = this.gpsStream.CanRead; 
if (bCanRead) 
{ 
    //clean the buffer
    for (int i = 0; i<buffer.Length; ++i) 
        buffer[i] = 0; 

    //now read
    try 
    { 
        bRead0Bytes = (0 == this.gpsStream.Read(buffer, 0, BUFFERSIZE - 1)); 
    } 
    catch (System.IO.IOException ioex) 
    { 
        //If you receive an IOException, check the InnerException property to determine if it was caused by a SocketException. 
        //If so, use the ErrorCode property to obtain the specific error code, and refer to the Windows Sockets version 2 API 
        //error code documentation in MSDN for a detailed description of the error. 
        if (ioex.InnerException.GetType() == typeof(SocketException)) 
        { 
            int socketerr = ((SocketException)(ioex.InnerException)).ErrorCode; 
            throw new Exception(string.Format("SocketException - error code: {0}", socketerr)); 
        } 
        throw new Exception("IOException while trying to read from GPS"); 
    } 
    catch (Exception ex)
    {
        //throw exception to upper layers
    }
}

// Variables
HCERTSTORE hStoreHandle = NULL;
PCCERT_CONTEXT pSubjectCert = NULL;
HCRYPTKEY hPubKey = NULL;
wchar_t * SubjectName;
DWORD dwEncryptedLen = 0;
BYTE* pbData = NULL;

// Open the certificate store
hStoreHandle = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, NULL, CERT_SYSTEM_STORE_CURRENT_USER, NULL);

// Get a certificate that matches the search criteria
pSubjectCert = CertFindCertificateInStore(hStoreHandle, X509_ASN_ENCODING, 0, CERT_FIND_SUBJECT_STR, SubjectName, pSubjectCert);

// Get the CSP
bResult = CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);

// Get the public key from the certificate
bResult = CryptImportPublicKeyInfoEx(hCryptProv, X509_ASN_ENCODING, &pSubjectCert->pCertInfo->SubjectPublicKeyInfo, CALG_RSA_KEYX, 0, NULL, &hPubKey);

// Get lenght for encrypted data
bResult = CryptEncrypt(hPubKey, NULL, TRUE, 0, NULL, &dwEncryptedLen, 0);

// Create a buffer for encrypted data
pbData = (BYTE *)malloc(pbData, dwEncryptedLen);
    
// Encrypt data
bResult = CryptEncrypt(hPubKey, NULL, TRUE, 0, pbData, &dwEncryptedLen, dwEncryptedLen);

//CertFreeCertificateContext
//CertCloseStore

// Variables
HCERTSTORE hStoreHandle = NULL;
PCCERT_CONTEXT pSubjectCert = NULL;
wchar_t * SubjectName;
HCRYPTPROV* phCryptProv = NULL;
DWORD* pdwKeySpec = NULL;
BOOL* pfCallerFreeProv = NULL;
HCRYPTKEY* phPrivateKey;
DWORD dwEncryptedLen = 0;
BYTE* pbData = NULL;

// Open the certificate store
hStoreHandle = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, NULL, CERT_SYSTEM_STORE_CURRENT_USER, NULL);

// Get a certificate that matches the search criteria
pSubjectCert = CertFindCertificateInStore(hStoreHandle, X509_ASN_ENCODING, 0, CERT_FIND_SUBJECT_STR, SubjectName, pSubjectCert);

// Acquire the Private Key
bResult = CryptAcquireCertificatePrivateKey(pSubjectCert, CRYPT_ACQUIRE_COMPARE_KEY_FLAG, NULL, &phCryptProv, &pdwKeySpec, &pfCallerFreeProv);

// Get Private Key
bResult = CryptGetUserKey(phCryptProv, AT_KEYEXCHANGE, &phPrivateKey);
 
// Decrypt data
bResult = CryptDecrypt(phPrivateKey, 0, TRUE, 0, &pbData, &dwEncryptedLen);


//CertFreeCertificateContext
//CertCloseStore