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

operators signal-strength

Question

Estoy trabajando en una pequeña aplicación para verificar la intensidad de la señal de varios operadores de red en mi área. La señal de mi operador actual es bastante inestable y quiero analizar la fortaleza de otros operadores GSM.

Sofar He estado usando TelephonyManager y PhoneStateListener con onSignalStrengthsChanged Call back para obtener la intensidad de la señal GSM del operador de red actual, pero parece que esta clase solo me da información sobre la intensidad de la señal de la red conectada a mi tarjeta SIM .

Estoy interesado en medir la intensidad de la señal GSM de TODOS los operadores disponibles. La búsqueda en la red ha dado pistas vagas sobre el uso de clases internas de Android, pero todavía no he encontrado ningún buen ejemplo sobre esto.

Se incluye cualquier respuesta que me pueda ayudar a obtener una lista de todos los operadores de red disponibles y su intensidad de señal.

Answer 1

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 utilizadas 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.

Como podría ser posible? He encontrado dos formas de lograr esto.

El primero es pedir un trabajo en cualquier empresa fabricante y firmar su NDA, pero eh, esa no es una solución realmente buena. Especialmente ya que la aplicación implementada y firmada con esta clave solo funcionará en dispositivos de la compagny ...

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

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

Answer 2

Tal vez estas citas y enlaces pueden ayudarte a codificar tu propia solución:

1.- Para obtener una lista de los proveedores de la red disponibles (citando ¿Cómo obtener una lista completa de los proveedores de la red disponibles? )

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

• onCreate inicia el NetworkQueryService y lo enlaza.
• loadNetworksList () le dice al servicio que consulte los operadores de red.
• Se evalúa INetworkQueryServiceCallback y, si se provoca el evento "EVENT_NETWORK_SCAN_COMPLETED", se llamará a redListLoaded para iterar sobre las redes disponibles.

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

• Conecta el servicio en 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 el 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 dice al servicio que consulte los operadores de red.

private void loadNetworksList() {
...    
// delegate query request to the service.
try {
    mNetworkQueryService.startNetworkQuery(mCallback);
} catch (RemoteException e) {
}

displayEmptyNetworkList(false); 
}

• INetworkQueryServiceCallback es evaluado:

/**
 * 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 generó 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 quizás lo intente la próxima vez que tenga algo de tiempo libre. ¡Buena suerte!

Answer 3

cree un PhoneStateListener y maneje la devolución de llamada onSignalStrengthChanged. Cuando se inicializa su aplicación, debería darle una notificación inicial. Esto está en 1.x. en 2.x, hay un issue abierto sobre esto.

Answer 4

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);
    }

};