Obtenga múltiples identificadores de celda para la ubicación usando Cellular Towers C#Windows Mobile

gps location

Question

Siguiendo la documentación de Microsoft sobre RIL, he podido implementar un código que recupera Cell ID, LAC, MCC, MNC y Signal Strength. Usando estos datos y http://www.opencellid.org/, puedo recuperar la latitud y la longitud de esa torre celular. El problema es que necesito implementar algún tipo de algoritmo de triangulación para obtener una posición más precisa. Pero antes de siquiera pensar en la triangulación, voy a necesitar más de una ID de torre para trabajar. ¿Cómo puedo obtenerlos? Traté de crear una matriz de towerIDs y llenarla en un bucle, mientras que una ID de torre no existe en la matriz y luego agregarla, pero si existe, entonces ignórela y siga buscando otra. Obviamente no funcionó, una vez que se pone uno lo conserva y si elimino el objeto y creo uno nuevo, obtiene la misma torre. ¿Cómo puedo obtener uno diferente?

Gracias por adelantado.

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace GPS_Test
{
    public class CellTower
    {
        public int CellID { get; set; }

        // LAC (Local Area Code)
        public int LAC { get; set; }

        // MCC (Mobile Country Code)
        public int MCC { get; set; }

        // MNC (Mobile Network Code)
        public int MNC { get; set; }

        // Received signal strength
        public int signalStrength { get; set; }

        // Base Station ID
        //public int baseStationID { get; set; }
    }


    public class RIL
    {
        public delegate void RILRESULTCALLBACK(uint dwCode,
            IntPtr hrCmdID, IntPtr lpData, uint cbData, uint dwParam);

        public delegate void RILNOTIFYCALLBACK(uint dwCode,
            IntPtr lpData, uint cbData, uint dwParam);

        [DllImport("ril.dll")]
        public static extern IntPtr RIL_Initialize(uint dwIndex,
            RILRESULTCALLBACK pfnResult,
            RILNOTIFYCALLBACK pfnNotify,
            uint dwNotificationClasses,
            uint dwParam,
            out IntPtr lphRil);

        [DllImport("ril.dll", EntryPoint = "RIL_GetCellTowerInfo")]
        public static extern IntPtr RIL_GetCellTowerInfo(IntPtr hril);

        [DllImport("ril.dll")]
        public static extern IntPtr RIL_Deinitialize(IntPtr hril);

        [DllImport("ril.dll", EntryPoint = "RIL_GetSignalQuality")]
        public static extern IntPtr RIL_GetSignalQuality(IntPtr hRil); 

        [StructLayout(LayoutKind.Explicit)]
        internal class RILCELLTOWERINFO
        {
            [FieldOffset(0)]
            uint dwSize;
            [FieldOffset(4)]
            uint dwParams;
            [FieldOffset(8)]
            public uint dwMobileCountryCode;
            [FieldOffset(12)]
            public uint dwMobileNetworkCode;
            [FieldOffset(16)]
            public uint dwLocationAreaCode;
            [FieldOffset(20)]
            public uint dwCellID;
            [FieldOffset(28)]
            public uint dwBaseStationID;
            [FieldOffset(36)]
            public uint dwRxLevel;
        }

        [StructLayout(LayoutKind.Explicit)]
        internal class RILSIGNALQUALITY
        {
            [FieldOffset(0)]
            uint dwSize;
            [FieldOffset(4)]
            uint dwParams;
            [FieldOffset(8)]
            public int nSignalStrength;
            [FieldOffset(12)]
            public uint nMinSignalStrength;
            [FieldOffset(16)]
            public uint nMaxSignalStrength;
            [FieldOffset(20)]
            public uint dwBitErrorRate;
            [FieldOffset(24)]
            public uint nLowSignalStrength;
            [FieldOffset(28)]
            public uint nHighSignalStrength;
        }
    }

    public class CellTowerInfo
    {
        private static AutoResetEvent dataReceived = new AutoResetEvent(false);
        private static AutoResetEvent whSignalQuality = new AutoResetEvent(false);

        private static RIL.RILCELLTOWERINFO towerInfo;
        private static RIL.RILSIGNALQUALITY signalQuality;

        public static CellTower GetCellTowerInfo()
        {
            IntPtr hRil = IntPtr.Zero;
            IntPtr hResult = IntPtr.Zero;

            hResult = RIL.RIL_Initialize(1,
                new RIL.RILRESULTCALLBACK(CellTowerData),
                null, 0, 0, out hRil);

            if (hResult != IntPtr.Zero)
                return null;

            hResult = RIL.RIL_GetCellTowerInfo(hRil);

            dataReceived.WaitOne();

            RIL.RIL_Deinitialize(hRil);

            CellTower ct = new CellTower();
            ct.LAC = (int)towerInfo.dwLocationAreaCode;
            ct.MCC = (int)towerInfo.dwMobileCountryCode;
            ct.MNC = (int)towerInfo.dwMobileNetworkCode;
            ct.CellID = (int)towerInfo.dwCellID;
            ct.signalStrength = GetSignalQuality();

            return ct;
        }


        public static int GetSignalQuality()
        {
            IntPtr hRes = IntPtr.Zero;
            IntPtr hSignalQ = IntPtr.Zero;

            hRes = RIL.RIL_Initialize(1, new RIL.RILRESULTCALLBACK(SignalQualityCallback),
                null, 0, 0, out hSignalQ);

            hRes = RIL.RIL_GetSignalQuality(hSignalQ);

            whSignalQuality.WaitOne();

            RIL.RIL_Deinitialize(hSignalQ);

            return signalQuality.nSignalStrength;
        }

        private static void CellTowerData(uint dwCode, IntPtr hrCmdID,
            IntPtr lpData, uint cbData, uint dwPara)
        {
            towerInfo = new RIL.RILCELLTOWERINFO();
            Marshal.PtrToStructure(lpData, (object)towerInfo);
            dataReceived.Set();
        }

        private static void SignalQualityCallback(uint dwCode, IntPtr hrCmdID,
            IntPtr lpData, uint cbData, uint dwPara)
        {
            signalQuality = new RIL.RILSIGNALQUALITY();
            Marshal.PtrToStructure(lpData, (object)signalQuality);
            whSignalQuality.Set();
        }
    }
}

Answer 1

Intente guardar toda la información con respecto a la señal actual, luego de hacerlo reinicie el servicio buscando otra señal pero primero verifique la que había almacenado, si es la misma indiferencia y siga buscando. ¡Buena suerte!