Android: Comment puis-je obtenir la puissance de signal GSM pour tous les opérateurs de réseau disponibles

peut-être que ces citations et liens peuvent 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 aux sources et enfin trouvé quelque chose appelé INetworkQueryService . Je suppose que vous pouvez faire identique aux paramètres android la mise en œuvre et d'interagir avec ce service. Quelques conseils par le biais de NetworkSettings.java:

• une fois le réseau démarré, Lequeryservice se lie.
• loadNetworksList () indique au service d'interroger 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é à itérer sur les Réseau.

2.- Même une lecture rapide de mise en réseau.java et inetworkqueryservice interface , nous donne une idée pour atteindre votre objectif.

• se Connecter au service dans la 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;
    }
};

• une fois le réseau démarré, Lequeryservice se 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 à interroger 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é:

/**
 * 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é, networksListLoaded sera appelé à itérer sur tous 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 ça aidera. Je pense que c'est un défi intéressant alors peut-être que je vais essayer la prochaine fois que j'ai un peu de temps libre. Bonne chance!

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

};

comme je n'ai pas 50 points de réputation, voici le résultat de mes recherches sur le sujet:

la solution D'Alejandro Colorado semble être la bonne. Mais le problème est que les classes utilisées pour le réaliser sont réservées aux applications du système android, c'est-à-dire aux applications qui sont signées avec la même clé de signature que le système.

comment cela pourrait-il être possible? J'ai trouvé deux façon d'atteindre cet objectif.

le premier est de demandez un travail à n'importe quelle compagnie de fabricant, et signer leur NDA, mais eh, ce n'est pas une bonne solution. D'autant plus que l'application implémentée et signée avec cette clé ne fonctionnera que sur les appareils de la compagnie...

le deuxième, beaucoup plus agréable, mais je vous préviens, ce ne sera pas facile, c'est de faire votre propre ROM. Vous devrez créer votre application, l'insérer dans le répertoire /system/app/ de votre ROM et la recompiler pour flash votre appareil avec votre nouveau système. Mais il y a une question à laquelle je n'ai pas encore répondu, Est le problème de la signature non reconnue ROM. Je pense que la meilleure façon d'éviter ce problème est d'ajouter votre clé de signature ROM dans la récupération que vous utiliserez.

C'est là où je suis à ce point, peut-être que vous pourriez trouver ces recherches utiles, je l'espère! Je reviendrai plus tard si je trouve plus d'informations pour vous. Revoir.

créer un PhoneStateListener et gérer le callback onSignalStrengthChanged. Lorsque votre application est initialisé, il devrait vous donner un premier avis. C'est en 1.x. en 2.x, il y a un numéro ouvert à ce sujet.