एंड्रॉइड: मैं सभी उपलब्ध नेटवर्क ऑपरेटरों के लिए जीएसएम सिग्नल शक्ति कैसे प्राप्त करूं

Question

मैं अपने क्षेत्र में विभिन्न नेटवर्क ऑपरेटरों की सिग्नल शक्ति की जांच करने के लिए एक छोटे से ऐप पर काम कर रहा हूं। मेरा वर्तमान ऑपरेटर सिग्नल काफी अस्थिर है और मैं अन्य जीएसएम ऑपरेटरों की ताकत को देखना चाहता हूं।

सोफर मैं टेलीफ़ोनी मैनेजर और फोनस्टेट लिस्टनर का उपयोग कर रहा हूं, सिग्नलस्टेंथथ्स के साथ वर्तमान नेटवर्क ऑपरेटर की जीएसएम सिग्नल शक्ति प्राप्त करने के लिए वापस कॉल किया गया, लेकिन ऐसा लगता है कि यह वर्ग केवल मुझे संलग्न नेटवर्क की सिग्नल शक्ति पर जानकारी देता है मेरे सिम कार्ड में।

मुझे सभी उपलब्ध ऑपरेटरों की जीएसएम सिग्नल शक्ति के माप में रूचि है। नेट की तलाश में आंतरिक एंड्रॉइड कक्षाओं का उपयोग करने पर अस्पष्ट संकेत दिए गए हैं, लेकिन मुझे अभी तक इस पर कोई अच्छा उदाहरण नहीं मिला है।

कोई भी उत्तर जो मुझे सभी उपलब्ध नेटवर्क ऑपरेटरों की सूची प्राप्त करने के लिए स्थानांतरित कर सकता है और उनकी सिग्नल शक्ति की सराहना की जाती है।

Answer 1

फ़ोनस्टेट लिस्टनर बनाएं और ऑन सिग्नलस्टेंथ चेंज कॉलबैक को संभालें। जब आपका ऐप प्रारंभ होता है, तो आपको इसे प्रारंभिक अधिसूचना देना चाहिए। यह 1.x में है। 2.x में, इसके बारे में एक खुला 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

हो सकता है कि इन उद्धरण और लिंक आप अपने खुद के समाधान कोड कर सकते हैं:

1.- उपलब्ध नेटवर्क प्रदाताओं की एक सूची प्राप्त करने के लिए (पूरा How to get a list of available network providers? के हवाले से):

एंड्रॉयड के बाद से ओपन सोर्स है, मैंने स्रोतों पर एक नज़र डाली थी और अंत में को INetworkQueryService नामक कुछ मिला। मुझे लगता है कि आप एंड्रॉइड सेटिंग्स कार्यान्वयन के समान कर सकते हैं और इस सेवा के साथ सहभागिता कर सकते हैं। NetworkSettings.java के माध्यम से कुछ मार्गदर्शन:

• ऑनक्रेट नेटवर्कQuery सेवा शुरू करता है और इसे बांधता है।
• loadNetworksList() नेटवर्क ऑपरेटरों के लिए पूछताछ करने के लिए सेवा को बताता है।
• INetworkQueryServiceCallback का मूल्यांकन किया जाता है और यदि ईवेंट "EVENT_NETWORK_SCAN_COMPLETED" उठाया गया था, तो नेटवर्क लिस्टलोडेड उपलब्ध नेटवर्क पर पुनरावृत्त करने के लिए बुलाया जाएगा।

2.- भी NetworkSetting.java और INetworkQueryService interface के लिए एक त्वरित पढ़ा, हमें एक विचार अपने लक्ष्य को प्राप्त करने देता है।

• घोषणा में सेवा को कनेक्ट करें।

/** 
* 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 NetworkQueryService शुरू होता है और यह बांधता है।

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

• loadNetworksList() सेवा नेटवर्क ऑपरेटरों के लिए क्वेरी करने के लिए कहता है।

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

displayEmptyNetworkList(false); 
} 

• INetworkQueryServiceCallback मूल्यांकन किया जाता है:

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

• तो घटना "EVENT_NETWORK_SCAN_COMPLETED" उठाया गया था, networ ksListLoaded को उपलब्ध नेटवर्क पर पुनरावृत्त करने के लिए बुलाया जाएगा।

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

मुझे आशा है कि यह मदद करता है। मुझे लगता है कि यह एक दिलचस्प चुनौती है इसलिए शायद अगली बार मेरे पास कुछ अतिरिक्त समय लगेगा। सौभाग्य!

ऐलेजैंड्रो कोलोराडो के समाधान अच्छा एक लगता है:

Answer 4

मैं कोई 50 प्रतिष्ठा अंक के रूप में, यहाँ विषय के बारे में अपनी खोजों का परिणाम है। लेकिन समस्या यह है कि इसे प्राप्त करने के लिए प्रयोग किया जाता कक्षाएं एंड्रॉयड प्रणाली अनुप्रयोगों, अर्थात् क्षुधा जो प्रणाली के समान हस्ताक्षर कुंजी के साथ प्रवेश किया हुआ है के लिए आरक्षित हैं है।

कैसे यह संभव हो सकता है? मुझे इसे हासिल करने के दो तरीके मिले।

पहले एक किसी भी निर्माता compagny में नौकरी से पूछते हैं, और उनके एनडीए हस्ताक्षर करने के लिए है, लेकिन हाँ, कि एक बहुत अच्छा समाधान नहीं है। खासकर जब इस ऐप के साथ लागू और हस्ताक्षरित ऐप केवल कंपैनी से डिवाइस पर काम करेगा ...

दूसरा, अधिक आनंददायक, लेकिन मैं आपको चेतावनी देता हूं, यह आसान नहीं होगा, अपना खुद का रोम बनाना है । आपको अपना एप्लिकेशन बनाना होगा, इसे अपने सिस्टम की/system/app/निर्देशिका में डालें और अपने डिवाइस को अपने नए सिस्टम से फ्लैश करने के लिए इसे पुन: संकलित करें। लेकिन एक प्रश्न है जिसका मैंने अभी तक जवाब नहीं दिया है, अपरिचित ROM हस्ताक्षर की समस्या है। मुझे लगता है कि सबसे अच्छा तरीका है इस समस्या से बचने के लिए रिकवरी आप का उपयोग किया जाएगा में अपने रोम हस्ताक्षर कुंजी जोड़ना है।

यही वह जगह है जहां मैं इस बिंदु पर हूं, शायद आप इन शोधों को उपयोगी पा सकते हैं, मुझे उम्मीद है! अगर मैं आपके लिए कुछ और जानकारी पाता हूं तो मैं बाद में वापस आऊंगा। अलविदा।