41 votes

Android: comment obtenir la puissance du signal GSM pour tous les opérateurs de réseau disponibles

Je suis en train de travailler sur un petit soft pour vérifier la force du signal des différents opérateurs de réseau dans ma région. Mon exploitants actuels signal est assez instable et je veux regarder dans la force de l'autre les opérateurs GSM.

Dans la mesure où j'ai été en utilisant le TelephonyManager et un PhoneStateListener avec le onSignalStrengthsChanged de retour d'appel pour obtenir la qualité du Signal GSM de l'opérateur courant, mais il semble que cette classe ne me donne de l'info sur la puissance du signal du réseau attaché à ma carte SIM.

Je suis intéressé par la mesure de la qualité du signal GSM de TOUS les opérateurs disponibles. Recherche sur le net a donné de vagues soupçons sur l'utilisation interne android classes, mais je n'ai pas encore trouvé de bons exemples sur ce.

Toute réponse qui peut me déplacer pour obtenir une liste de tous les opérateurs de réseau et la force du signal sont appréciés.

23voto

Alejandro Colorado Points 3062

Peut-être que ces citations et des liens peut vous aider à coder votre propre solution:

1.- Pour obtenir une liste des fournisseurs de réseau disponible (en citant Comment obtenir une liste de fournisseurs de réseau disponible? dans son intégralité):

Depuis Android est open source, j'ai eu un coup d'oeil à la sources et enfin trouvé quelque chose qui s'appelle INetworkQueryService. Je suppose que vous pouvez faire de même que l'android les paramètres de mise en œuvre et d'interagir avec ce service. Quelques conseils par le biais de NetworkSettings.java:

  • onCreate commence le NetworkQueryService et le lie.
  • loadNetworksList() indique le service de requête pour les opérateurs de réseau.
  • INetworkQueryServiceCallback est évalué et, si l'événement "EVENT_NETWORK_SCAN_COMPLETED" a été soulevée, networksListLoaded sera appelé pour itérer sur tous les Réseaux disponibles.

2.- Même une lecture rapide de NetworkSetting.java et INetworkQueryService interface, nous donne une idée de la réalisation de votre objectif.

  • Connectez le service de déclaration.
/**
 * 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 commence le NetworkQueryService et le lie.
Intent intent = new Intent(this, NetworkQueryService.class);
...
startService (intent);
bindService (new Intent(this, NetworkQueryService.class), mNetworkQueryServiceConnection,
                        Context.BIND_AUTO_CREATE);
  • loadNetworksList() indique le service de requête pour les opérateurs de réseau.
private void loadNetworksList() {
...    
// delegate query request to the service.
try {
    mNetworkQueryService.startNetworkQuery(mCallback);
} catch (RemoteException e) {
}

displayEmptyNetworkList(false); 
}
  • INetworkQueryServiceCallback est évaluée:
/**
 * 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 l'événement "EVENT_NETWORK_SCAN_COMPLETED" a été soulevée, networksListLoaded sera appelé à effectuer une itération sur les Réseaux 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);
        }
    }
}

J'espère que cela aide. Je pense que c'est un défi intéressant, donc je vais peut-être lui donner un essai la prochaine fois que j'ai du temps libre. Bonne chance!

2voto

DeepSan Points 1130
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);
    }

};

0voto

créez un PhoneStateListener et gérez le rappel onSignalStrengthChanged. Lorsque votre application est initialisée, elle devrait vous envoyer une notification initiale. C'est en 1.x. dans 2.x, il y a un problème ouvert à ce sujet.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X