Android: Come ottengo la potenza del segnale GSM per tutti gli operatori di rete disponibili

Question

Sto lavorando su una piccola app per controllare la potenza del segnale di vari operatori di rete nella mia zona. Il mio attuale segnale degli operatori è piuttosto instabile e voglio esaminare la forza degli altri operatori GSM.

Sofar Utilizzo il TelephonyManager e un PhoneStateListener con la richiamata di OnSignalStrengthsChanged per ottenere la potenza del segnale GSM dell'attuale operatore di rete, ma sembra che questa classe mi fornisca solo informazioni sulla potenza del segnale della rete collegata alla mia carta SIM.

Sono interessato alla misurazione della potenza del segnale GSM di TUTTI gli operatori disponibili. La ricerca in rete ha fornito vaghi indizi sull'uso delle classi interne di Android, ma non ho ancora trovato alcun buon esempio su questo.

Qualsiasi risposta che possa spostarmi per ottenere un elenco di tutti gli operatori di rete disponibili e la loro potenza del segnale è accresciuta.

Answer 1

creare un PhoneStateListener e gestire il callback onSignalStrengthChanged. Quando la tua app è inizializzata, dovrebbe darti una notifica iniziale. Questo è in 1.x. in 2.x, c'è uno issue aperto su questo.

Answer 2

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

}; 

Answer 3

Forse queste citazioni e link può aiutare a codificare la vostra soluzione:

1.- Per ottenere un elenco di provider di rete disponibili (citando How to get a list of available network providers? completi):

Dal Android è open source Ho dato un'occhiata alle fonti e finalmente trovato qualcosa chiamato InetworkQueryService. Immagino che tu possa fare lo come l'implementazione delle impostazioni Android e interagire con questo servizio . Alcune indicazioni tramite NetworkSettings.java:

• onCreate avvia NetworkQueryService e lo associa.
• loadNetworksList() indica al servizio di interrogare gli operatori di rete.
• InetworkQueryServiceCallback viene valutato e se è stato generato l'evento "EVENT_NETWORK_SCAN_COMPLETED", networkListLoaded sarà chiamato per iterare sulle reti disponibili.

2.- Anche una rapida lettura a NetworkSetting.java e INetworkQueryService interface, ci dà un'idea per raggiungere il tuo obiettivo.

• Collegare il servizio in dichiarazione.

/** 
* 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 avvia il NetworkQueryService e lo associa.

Intent intent = new Intent(this, NetworkQueryService.class); 
... 
startService (intent); 
bindService (new Intent(this, NetworkQueryService.class), mNetworkQueryServiceConnection, 
         Context.BIND_AUTO_CREATE); 

• loadNetworksList() viene comunicato al servizio di query per gli operatori di rete.

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

displayEmptyNetworkList(false); 
} 

• INetworkQueryServiceCallback viene valutata:

/** 
* 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(); 
    } 
}; 

• Se è stata sollevata l'evento "EVENT_NETWORK_SCAN_COMPLETED", networ ksListLoaded sarà chiamato per iterare sulle reti disponibili.

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

spero che aiuta. Penso che sia una sfida interessante quindi forse farò un tentativo la prossima volta che avrò del tempo libero. In bocca al lupo!

Answer 4

come non ho 50 punti reputazione, ecco il risultato delle mie ricerche sull'argomento:

La soluzione di Alejandro Colorado sembra essere quella buona. Ma il problema è che le classi utilizzate per ottenerlo sono riservate alle applicazioni di sistema Android, ad esempio app che sono firmate con la stessa chiave di firma del sistema.

Come potrebbe essere possibile? Ho trovato due modi per raggiungere questo obiettivo.

Il primo è quello di chiedere un lavoro in qualsiasi compagny produttore, e firmare la loro NDA, ma eh, che non è davvero una buona soluzione. Soprattutto quando l'app implementata e firmata con questa chiave funzionerà solo su dispositivi dalla compagnia ...

Il secondo, molto più divertente, ma ti avverto, non sarà facile, è quello di creare la tua ROM . Dovrai creare la tua applicazione, inserirla nella directory/system/app/della tua ROM e ricompilarla per far lampeggiare il tuo dispositivo con il tuo nuovo sistema. Ma c'è una domanda a cui non ho ancora risposto, è il problema della firma ROM non riconosciuta. Penso che il modo migliore per evitare questo problema è quello di aggiungere la chiave di firma ROM nel Recovery che userete.

che è dove io sono a questo punto, forse si potrebbe trovare questi utile la ricerca, lo spero! Tornerò più tardi se troverò qualche informazione in più per voi ragazzi. Ciao.