Android: ¿Cómo obtengo la intensidad de la señal GSM para todos los operadores de red disponibles?

Estoy trabajando en una pequeña aplicación para comprobar la intensidad de la señal de varios operadores de red en mi área. Mis actuales operadores señal es bastante inestable y quiero mirar en la fuerza de otros operadores GSM.

Sofar He estado usando el TelephonyManager y un PhoneStateListener con la llamada onSignalStrengthsChanged de nuevo para obtener la fuerza de la señal GSM del operador de red actual, pero parece que esta clase sólo me da información sobre la fuerza de la señal de la red conectada a mi tarjeta SIM .

Estoy interesado en la medición de la fuerza de la señal GSM de todos los operadores disponibles. Buscar en la red ha dado vagas pistas sobre el uso de clases de Android, pero todavía no he encontrado buenos ejemplos sobre esto.

Cualquier respuesta que me pueda mover para obtener una lista de todos los operadores de red disponibles y su intensidad de señal son appreaciated.

    Tal vez estas citas y enlaces pueden ayudarle a codificar su propia solución:

    1.- Para obtener una lista de los proveedores de red disponibles (citar Cómo obtener una lista de proveedores de red disponibles en su totalidad):

    Desde Android es de código abierto he echado un vistazo a las fuentes y finalmente encontré algo llamado INetworkQueryService . Supongo que puedes hacer lo mismo que la implementación de los ajustes de Android e interactuar con este servicio. Algunas orientaciones a través de NetworkSettings.java:

    • OnCreate inicia NetworkQueryService y lo enlaza.
    • LoadNetworksList () le indica al servicio que consulte a los operadores de red.
    • INetworkQueryServiceCallback se evalúa y si se ha aumentado el evento "EVENT_NETWORK_SCAN_COMPLETED", networksListLoaded se llamará para iterar sobre las redes disponibles.

    2.- Incluso una rápida lectura a NetworkSetting.java y la interfaz de INetworkQueryService , nos da una idea para lograr su objetivo.

    • Conecte el servicio en la declaración.
    /** * Service connection code for the NetworkQueryService. * Handles the work of binding to a local object so that we can make * the appropriate service calls. */ /** Local service interface */ private INetworkQueryService mNetworkQueryService = null; /** Service connection */ private final ServiceConnection mNetworkQueryServiceConnection = new ServiceConnection() { /** Handle the task of binding the local object to the service */ public void onServiceConnected(ComponentName className, IBinder service) { if (DBG) log("connection created, binding local service."); mNetworkQueryService = ((NetworkQueryService.LocalBinder) service).getService(); // as soon as it is bound, run a query. loadNetworksList(); } /** Handle the task of cleaning up the local binding */ public void onServiceDisconnected(ComponentName className) { if (DBG) log("connection disconnected, cleaning local binding."); mNetworkQueryService = null; } }; 
    • OnCreate inicia NetworkQueryService y lo enlaza.
     Intent intent = new Intent(this, NetworkQueryService.class); ... startService (intent); bindService (new Intent(this, NetworkQueryService.class), mNetworkQueryServiceConnection, Context.BIND_AUTO_CREATE); 
    • LoadNetworksList () le indica al servicio que consulte a los operadores de red.
     private void loadNetworksList() { ... // delegate query request to the service. try { mNetworkQueryService.startNetworkQuery(mCallback); } catch (RemoteException e) { } displayEmptyNetworkList(false); } 
    • Se evalúa INetworkQueryServiceCallback:
     /** * This implementation of INetworkQueryServiceCallback is used to receive * callback notifications from the network query service. */ private final INetworkQueryServiceCallback mCallback = new INetworkQueryServiceCallback.Stub() { /** place the message on the looper queue upon query completion. */ public void onQueryComplete(List<OperatorInfo> networkInfoArray, int status) { if (DBG) log("notifying message loop of query completion."); Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_COMPLETED, status, 0, networkInfoArray); msg.sendToTarget(); } }; 
    • Si se ha aumentado el evento "EVENT_NETWORK_SCAN_COMPLETED", se llamará a networksListLoaded para iterar sobre las redes disponibles.
     private void networksListLoaded(List<OperatorInfo> result, int status) { ... if (status != NetworkQueryService.QUERY_OK) { ... displayNetworkQueryFailed(status); displayEmptyNetworkList(true); } else { if (result != null){ displayEmptyNetworkList(false); ... } else { displayEmptyNetworkList(true); } } } 

    Espero que ayude. Creo que es un desafío interesante, así que tal vez lo intentaré la próxima vez que tenga algún tiempo libre. ¡Buena suerte!

     private final PhoneStateListener phoneStateListener = new PhoneStateListener() { @Override public void onCallForwardingIndicatorChanged(boolean cfi) { super.onCallForwardingIndicatorChanged(cfi); } @Override public void onCallStateChanged(int state, String incomingNumber) { //checkInternetConnection(); String callState = "UNKNOWN"; switch (state) { case TelephonyManager.CALL_STATE_IDLE: callState = "IDLE"; break; case TelephonyManager.CALL_STATE_RINGING: callState = "Ringing (" + incomingNumber + ")"; break; case TelephonyManager.CALL_STATE_OFFHOOK: callState = "Offhook"; break; } Log.i("Phone Stats", "onCallStateChanged " + callState); super.onCallStateChanged(state, incomingNumber); } @Override public void onCellLocationChanged(CellLocation location) { String cellLocationString = location.toString(); super.onCellLocationChanged(location); } @Override public void onDataActivity(int direction) { String directionString = "none"; switch (direction) { case TelephonyManager.DATA_ACTIVITY_IN: directionString = "IN"; break; case TelephonyManager.DATA_ACTIVITY_OUT: directionString = "OUT"; break; case TelephonyManager.DATA_ACTIVITY_INOUT: directionString = "INOUT"; break; case TelephonyManager.DATA_ACTIVITY_NONE: directionString = "NONE"; break; default: directionString = "UNKNOWN: " + direction; break; } Log.i("Phone Stats", "onDataActivity " + directionString); super.onDataActivity(direction); } @Override public void onDataConnectionStateChanged(int state,int networktype) { String connectionState = "Unknown"; switch (state ) { case TelephonyManager.DATA_CONNECTED : connectionState = "Connected"; break; case TelephonyManager.DATA_CONNECTING: connectionState = "Connecting"; break; case TelephonyManager.DATA_DISCONNECTED: connectionState = "Disconnected"; break; case TelephonyManager.DATA_SUSPENDED: connectionState = "Suspended"; break; default: connectionState = "Unknown: " + state; break; } super.onDataConnectionStateChanged(state); Log.i("Phone Stats", "onDataConnectionStateChanged " + connectionState); } @Override public void onMessageWaitingIndicatorChanged(boolean mwi) { super.onMessageWaitingIndicatorChanged(mwi); } @Override public void onServiceStateChanged(ServiceState serviceState) { String serviceStateString = "UNKNOWN"; switch (serviceState.getState()) { case ServiceState.STATE_IN_SERVICE: serviceStateString = "IN SERVICE"; break; case ServiceState.STATE_EMERGENCY_ONLY: serviceStateString = "EMERGENCY ONLY"; break; case ServiceState.STATE_OUT_OF_SERVICE: serviceStateString = "OUT OF SERVICE"; break; case ServiceState.STATE_POWER_OFF: serviceStateString = "POWER OFF"; break; default: serviceStateString = "UNKNOWN"; break; } Log.i("Phone Stats", "onServiceStateChanged " + serviceStateString); super.onServiceStateChanged(serviceState); } @Override public void onSignalStrengthChanged(int asu) { Log.i("Phone Stats", "onSignalStrengthChanged " + asu); setSignalLevel( asu); super.onSignalStrengthChanged(asu); } private void setSignalLevel(int level) { int sLevel = (int) ((level / 31.0) * 100); Log.i("signalLevel ", "" + sLevel); } }; 

    Como no tengo 50 puntos de reputación, aquí está el resultado de mis búsquedas sobre el tema:

    La solución de Alejandro Colorado parece ser la buena. Pero el problema es que las clases usadas para lograrlo están reservadas para las aplicaciones del sistema android, es decir, las aplicaciones que están firmadas con la misma clave de firma que el sistema.

    ¿Cómo podría ser posible? Encontré dos formas de lograr esto.

    La primera es pedir un trabajo en cualquier compañía fabricante, y firmar su NDA, pero eh, que no es una solución realmente buena. Especialmente como la aplicación implementada y firmada con esta clave sólo funcionará en dispositivos de la compañía …

    La segunda, mucho más agradable, pero te advierto, no va a ser fácil, es hacer tu propia ROM. Tendrás que crear tu aplicación, insertarla en el directorio / system / app / de tu ROM y volver a compilarla para que tu dispositivo se ilumine con tu nuevo sistema. Pero hay una pregunta que no he contestado todavía, es el problema de la firma ROM no reconocida. Creo que la mejor manera de evitar este problema es agregar su clave de firma ROM en la recuperación que va a utilizar.

    Ahí es donde estoy en este momento, tal vez usted podría encontrar esta investigación útil, espero que sí! Volveré más tarde si encuentro más información para ustedes. Adiós.

    Crear un PhoneStateListener y manejar la devolución de llamada onSignalStrengthChanged. Cuando la aplicación se inicialice, debería darle una notificación inicial. Esto es en 1.x. En 2.x, hay un problema abierto sobre esto.

    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.