Android: Jak uzyskać siłę sygnału GSM dla wszystkich dostępnych operatorów sieciowych

Question

Pracuję nad małą aplikacją, aby sprawdzić siłę sygnału różnych operatorów sieci w mojej okolicy. Mój obecny sygnał operatora jest dość niestabilny i chcę sprawdzić siłę innych operatorów GSM.

Sofar Korzystam z TelephonyManager i PhoneStateListener z wywołaniem onSignalStrengthsChanged, aby uzyskać moc sygnału GSM obecnego operatora sieci, ale wygląda na to, że ta klasa daje mi tylko informację o sile sygnału podłączonej sieci na moją kartę SIM.

Interesuje mnie pomiar siły sygnału GSM wszystkich dostępnych operatorów. Przeszukiwanie sieci dało niejasne wskazówki dotyczące korzystania z wewnętrznych klas Android, ale nie znalazłem jeszcze żadnych dobrych przykładów na ten temat.

Każda odpowiedź, która może mnie przenieść, aby uzyskać listę wszystkich dostępnych operatorów sieci i ich siłę sygnału, jest doceniana.

Answer 1

utworzyć PhoneStateListener i obsługiwać wywołania zwrotnego onSignalStrengthChanged. Gdy Twoja aplikacja zostanie zainicjalizowana, powinna przekazać Ci wstępne powiadomienie. To jest w 1.x. w wersji 2.x jest otwarty na ten temat issue.

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

Może te cytaty i linki mogą pomóc kodować własne rozwiązanie:

1.- aby otrzymać listę dostępnych operatorów sieci (cytowanie How to get a list of available network providers? w całości):

Od Androida jest open source Spojrzałem na źródła i wreszcie znalazłem coś o nazwie INetworkQueryService. Domyślam się, że możesz wykonać tak samo jak implementację ustawień Androida i korzystać z usługi . Niektóre wskazówki za pośrednictwem NetworkSettings.java:

• onCreate uruchamia NetworkQueryService i wiąże go.
• loadNetworksList() informuje usługę, aby wysłała zapytania do operatorów sieci.
• INetworkQueryServiceCallback jest oceniany, a jeśli wydarzenie "EVENT_NETWORK_SCAN_COMPLETED" zostało podniesione, networkListLoaded zostanie wywołany do iteracji po dostępnych sieciach.

2.- Nawet szybkie odczytu do NetworkSetting.java i INetworkQueryService interface daje nam pomysł, aby osiągnąć swój cel.

• Połącz usługę w deklaracji.

/** 
* 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 rozpoczyna NetworkQueryService i wiąże go.

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

• loadNetworksList() mówi, że obsługa zapytań dla operatorów sieciowych.

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

displayEmptyNetworkList(false); 
} 

• INetworkQueryServiceCallback jest oceniane:

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

• Jeśli zdarzenie "EVENT_NETWORK_SCAN_COMPLETED" został podniesiony, networ ksListLoaded zostanie wezwany do powtórzenia dostępnych Sieci.

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

Mam nadzieję, że to pomaga. Myślę, że to interesujące wyzwanie, więc może spróbuję następnym razem, gdy będę miał trochę wolnego czasu. Powodzenia!

Answer 4

Ponieważ nie mam 50 punktów reputacji, tutaj jest wynikiem moich poszukiwań na ten temat:

Rozwiązanie Alejandro Kolorado wydaje się być dobry. Problem polega jednak na tym, że klasy używane do jego osiągnięcia są zarezerwowane dla aplikacji systemu Android, tj. Aplikacji podpisanych tym samym kluczem podpisu, co system.

Jak to możliwe? Znalazłem dwa sposoby, aby to osiągnąć.

Pierwszym z nich jest zadanie pracy u dowolnego producenta i podpisanie umowy NDA, ale to nie jest dobre rozwiązanie. Zwłaszcza, że ​​aplikacja zaimplementowana i podpisana tym kluczem będzie działać tylko na urządzeniach z Compagny ...

Drugi, o wiele bardziej przyjemny, ale ostrzegam Cię, to nie będzie łatwe, to zrobić własny ROM . Będziesz musiał stworzyć swoją aplikację, wstawić ją do katalogu/system/app/w swoim ROM i przekompilować, aby urządzenie było flashowane z nowym systemem. Ale jest pytanie, na które jeszcze nie odpowiedziałem, to problem nierozpoznanej sygnatury ROM. Myślę, że najlepszym sposobem na uniknięcie tego problemu jest dodanie klucza podpisywania ROM w Recovery, którego będziesz używać.

To tam jestem w tym momencie, może moglibyście znaleźć te badania przydatne, mam nadzieję! Wrócę później, jeśli znajdę dla ciebie więcej informacji. PA.