• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.settings.deviceinfo;
18 
19 import android.bluetooth.BluetoothAdapter;
20 import android.content.BroadcastReceiver;
21 import android.content.Context;
22 import android.content.Intent;
23 import android.content.IntentFilter;
24 import android.content.res.Resources;
25 import android.net.ConnectivityManager;
26 import android.net.NetworkInfo;
27 import android.net.wifi.WifiInfo;
28 import android.net.wifi.WifiManager;
29 import android.os.Build;
30 import android.os.Bundle;
31 import android.os.Handler;
32 import android.os.Message;
33 import android.os.SystemClock;
34 import android.os.SystemProperties;
35 import android.os.UserHandle;
36 import android.preference.Preference;
37 import android.preference.PreferenceActivity;
38 import android.preference.PreferenceScreen;
39 import android.telephony.CellBroadcastMessage;
40 import android.telephony.PhoneNumberUtils;
41 import android.telephony.PhoneStateListener;
42 import android.telephony.ServiceState;
43 import android.telephony.TelephonyManager;
44 import android.text.TextUtils;
45 
46 import com.android.internal.telephony.Phone;
47 import com.android.internal.telephony.PhoneConstants;
48 import com.android.internal.telephony.PhoneFactory;
49 import com.android.internal.telephony.PhoneStateIntentReceiver;
50 import com.android.settings.R;
51 import com.android.settings.Utils;
52 
53 import java.lang.ref.WeakReference;
54 
55 /**
56  * Display the following information
57  * # Phone Number
58  * # Network
59  * # Roaming
60  * # Device Id (IMEI in GSM and MEID in CDMA)
61  * # Network type
62  * # Operator info (area info cell broadcast for Brazil)
63  * # Signal Strength
64  * # Battery Strength  : TODO
65  * # Uptime
66  * # Awake Time
67  * # XMPP/buzz/tickle status : TODO
68  *
69  */
70 public class Status extends PreferenceActivity {
71 
72     private static final String KEY_DATA_STATE = "data_state";
73     private static final String KEY_SERVICE_STATE = "service_state";
74     private static final String KEY_OPERATOR_NAME = "operator_name";
75     private static final String KEY_ROAMING_STATE = "roaming_state";
76     private static final String KEY_NETWORK_TYPE = "network_type";
77     private static final String KEY_LATEST_AREA_INFO = "latest_area_info";
78     private static final String KEY_PHONE_NUMBER = "number";
79     private static final String KEY_IMEI_SV = "imei_sv";
80     private static final String KEY_IMEI = "imei";
81     private static final String KEY_PRL_VERSION = "prl_version";
82     private static final String KEY_MIN_NUMBER = "min_number";
83     private static final String KEY_MEID_NUMBER = "meid_number";
84     private static final String KEY_SIGNAL_STRENGTH = "signal_strength";
85     private static final String KEY_BATTERY_STATUS = "battery_status";
86     private static final String KEY_BATTERY_LEVEL = "battery_level";
87     private static final String KEY_IP_ADDRESS = "wifi_ip_address";
88     private static final String KEY_WIFI_MAC_ADDRESS = "wifi_mac_address";
89     private static final String KEY_BT_ADDRESS = "bt_address";
90     private static final String KEY_SERIAL_NUMBER = "serial_number";
91     private static final String KEY_ICC_ID = "icc_id";
92     private static final String KEY_WIMAX_MAC_ADDRESS = "wimax_mac_address";
93     private static final String[] PHONE_RELATED_ENTRIES = {
94         KEY_DATA_STATE,
95         KEY_SERVICE_STATE,
96         KEY_OPERATOR_NAME,
97         KEY_ROAMING_STATE,
98         KEY_NETWORK_TYPE,
99         KEY_LATEST_AREA_INFO,
100         KEY_PHONE_NUMBER,
101         KEY_IMEI,
102         KEY_IMEI_SV,
103         KEY_PRL_VERSION,
104         KEY_MIN_NUMBER,
105         KEY_MEID_NUMBER,
106         KEY_SIGNAL_STRENGTH,
107         KEY_ICC_ID
108     };
109 
110     static final String CB_AREA_INFO_RECEIVED_ACTION =
111             "android.cellbroadcastreceiver.CB_AREA_INFO_RECEIVED";
112 
113     static final String GET_LATEST_CB_AREA_INFO_ACTION =
114             "android.cellbroadcastreceiver.GET_LATEST_CB_AREA_INFO";
115 
116     // Require the sender to have this permission to prevent third-party spoofing.
117     static final String CB_AREA_INFO_SENDER_PERMISSION =
118             "android.permission.RECEIVE_EMERGENCY_BROADCAST";
119 
120     private static final int EVENT_SIGNAL_STRENGTH_CHANGED = 200;
121     private static final int EVENT_SERVICE_STATE_CHANGED = 300;
122 
123     private static final int EVENT_UPDATE_STATS = 500;
124 
125     private TelephonyManager mTelephonyManager;
126     private Phone mPhone = null;
127     private PhoneStateIntentReceiver mPhoneStateReceiver;
128     private Resources mRes;
129     private Preference mSignalStrength;
130     private Preference mUptime;
131     private boolean mShowLatestAreaInfo;
132 
133     private String sUnknown;
134 
135     private Preference mBatteryStatus;
136     private Preference mBatteryLevel;
137 
138     private Handler mHandler;
139 
140     private static class MyHandler extends Handler {
141         private WeakReference<Status> mStatus;
142 
MyHandler(Status activity)143         public MyHandler(Status activity) {
144             mStatus = new WeakReference<Status>(activity);
145         }
146 
147         @Override
handleMessage(Message msg)148         public void handleMessage(Message msg) {
149             Status status = mStatus.get();
150             if (status == null) {
151                 return;
152             }
153 
154             switch (msg.what) {
155                 case EVENT_SIGNAL_STRENGTH_CHANGED:
156                     status.updateSignalStrength();
157                     break;
158 
159                 case EVENT_SERVICE_STATE_CHANGED:
160                     ServiceState serviceState = status.mPhoneStateReceiver.getServiceState();
161                     status.updateServiceState(serviceState);
162                     break;
163 
164                 case EVENT_UPDATE_STATS:
165                     status.updateTimes();
166                     sendEmptyMessageDelayed(EVENT_UPDATE_STATS, 1000);
167                     break;
168             }
169         }
170     }
171 
172     private BroadcastReceiver mBatteryInfoReceiver = new BroadcastReceiver() {
173 
174         @Override
175         public void onReceive(Context context, Intent intent) {
176             String action = intent.getAction();
177             if (Intent.ACTION_BATTERY_CHANGED.equals(action)) {
178                 mBatteryLevel.setSummary(Utils.getBatteryPercentage(intent));
179                 mBatteryStatus.setSummary(Utils.getBatteryStatus(getResources(), intent));
180             }
181         }
182     };
183 
184     private PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
185         @Override
186         public void onDataConnectionStateChanged(int state) {
187             updateDataState();
188             updateNetworkType();
189         }
190     };
191 
192     private BroadcastReceiver mAreaInfoReceiver = new BroadcastReceiver() {
193         @Override
194         public void onReceive(Context context, Intent intent) {
195             String action = intent.getAction();
196             if (CB_AREA_INFO_RECEIVED_ACTION.equals(action)) {
197                 Bundle extras = intent.getExtras();
198                 if (extras == null) {
199                     return;
200                 }
201                 CellBroadcastMessage cbMessage = (CellBroadcastMessage) extras.get("message");
202                 if (cbMessage != null && cbMessage.getServiceCategory() == 50) {
203                     String latestAreaInfo = cbMessage.getMessageBody();
204                     updateAreaInfo(latestAreaInfo);
205                 }
206             }
207         }
208     };
209 
210     @Override
onCreate(Bundle icicle)211     protected void onCreate(Bundle icicle) {
212         super.onCreate(icicle);
213 
214         mHandler = new MyHandler(this);
215 
216         mTelephonyManager = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
217 
218         addPreferencesFromResource(R.xml.device_info_status);
219         mBatteryLevel = findPreference(KEY_BATTERY_LEVEL);
220         mBatteryStatus = findPreference(KEY_BATTERY_STATUS);
221 
222         mRes = getResources();
223         sUnknown = mRes.getString(R.string.device_info_default);
224         if (UserHandle.myUserId() == UserHandle.USER_OWNER) {
225             mPhone = PhoneFactory.getDefaultPhone();
226         }
227         // Note - missing in zaku build, be careful later...
228         mSignalStrength = findPreference(KEY_SIGNAL_STRENGTH);
229         mUptime = findPreference("up_time");
230 
231         if (mPhone == null || Utils.isWifiOnly(getApplicationContext())) {
232             for (String key : PHONE_RELATED_ENTRIES) {
233                 removePreferenceFromScreen(key);
234             }
235         } else {
236             // NOTE "imei" is the "Device ID" since it represents
237             //  the IMEI in GSM and the MEID in CDMA
238             if (mPhone.getPhoneName().equals("CDMA")) {
239                 setSummaryText(KEY_MEID_NUMBER, mPhone.getMeid());
240                 setSummaryText(KEY_MIN_NUMBER, mPhone.getCdmaMin());
241                 if (getResources().getBoolean(R.bool.config_msid_enable)) {
242                     findPreference(KEY_MIN_NUMBER).setTitle(R.string.status_msid_number);
243                 }
244                 setSummaryText(KEY_PRL_VERSION, mPhone.getCdmaPrlVersion());
245                 removePreferenceFromScreen(KEY_IMEI_SV);
246 
247                 if (mPhone.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE) {
248                     // Show ICC ID and IMEI for LTE device
249                     setSummaryText(KEY_ICC_ID, mPhone.getIccSerialNumber());
250                     setSummaryText(KEY_IMEI, mPhone.getImei());
251                 } else {
252                     // device is not GSM/UMTS, do not display GSM/UMTS features
253                     // check Null in case no specified preference in overlay xml
254                     removePreferenceFromScreen(KEY_IMEI);
255                     removePreferenceFromScreen(KEY_ICC_ID);
256                 }
257             } else {
258                 setSummaryText(KEY_IMEI, mPhone.getDeviceId());
259 
260                 setSummaryText(KEY_IMEI_SV,
261                         ((TelephonyManager) getSystemService(TELEPHONY_SERVICE))
262                             .getDeviceSoftwareVersion());
263 
264                 // device is not CDMA, do not display CDMA features
265                 // check Null in case no specified preference in overlay xml
266                 removePreferenceFromScreen(KEY_PRL_VERSION);
267                 removePreferenceFromScreen(KEY_MEID_NUMBER);
268                 removePreferenceFromScreen(KEY_MIN_NUMBER);
269                 removePreferenceFromScreen(KEY_ICC_ID);
270 
271                 // only show area info when SIM country is Brazil
272                 if ("br".equals(mTelephonyManager.getSimCountryIso())) {
273                     mShowLatestAreaInfo = true;
274                 }
275             }
276 
277             String rawNumber = mPhone.getLine1Number();  // may be null or empty
278             String formattedNumber = null;
279             if (!TextUtils.isEmpty(rawNumber)) {
280                 formattedNumber = PhoneNumberUtils.formatNumber(rawNumber);
281             }
282             // If formattedNumber is null or empty, it'll display as "Unknown".
283             setSummaryText(KEY_PHONE_NUMBER, formattedNumber);
284 
285             mPhoneStateReceiver = new PhoneStateIntentReceiver(this, mHandler);
286             mPhoneStateReceiver.notifySignalStrength(EVENT_SIGNAL_STRENGTH_CHANGED);
287             mPhoneStateReceiver.notifyServiceState(EVENT_SERVICE_STATE_CHANGED);
288 
289             if (!mShowLatestAreaInfo) {
290                 removePreferenceFromScreen(KEY_LATEST_AREA_INFO);
291             }
292         }
293 
294         setWimaxStatus();
295         setWifiStatus();
296         setBtStatus();
297         setIpAddressStatus();
298 
299         String serial = Build.SERIAL;
300         if (serial != null && !serial.equals("")) {
301             setSummaryText(KEY_SERIAL_NUMBER, serial);
302         } else {
303             removePreferenceFromScreen(KEY_SERIAL_NUMBER);
304         }
305     }
306 
307     @Override
onResume()308     protected void onResume() {
309         super.onResume();
310 
311         if (mPhone != null && !Utils.isWifiOnly(getApplicationContext())) {
312             mPhoneStateReceiver.registerIntent();
313 
314             updateSignalStrength();
315             updateServiceState(mPhone.getServiceState());
316             updateDataState();
317             mTelephonyManager.listen(mPhoneStateListener,
318                     PhoneStateListener.LISTEN_DATA_CONNECTION_STATE);
319             if (mShowLatestAreaInfo) {
320                 registerReceiver(mAreaInfoReceiver, new IntentFilter(CB_AREA_INFO_RECEIVED_ACTION),
321                         CB_AREA_INFO_SENDER_PERMISSION, null);
322                 // Ask CellBroadcastReceiver to broadcast the latest area info received
323                 Intent getLatestIntent = new Intent(GET_LATEST_CB_AREA_INFO_ACTION);
324                 sendBroadcastAsUser(getLatestIntent, UserHandle.ALL,
325                         CB_AREA_INFO_SENDER_PERMISSION);
326             }
327         }
328         registerReceiver(mBatteryInfoReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
329         mHandler.sendEmptyMessage(EVENT_UPDATE_STATS);
330     }
331 
332     @Override
onPause()333     public void onPause() {
334         super.onPause();
335 
336         if (mPhone != null && !Utils.isWifiOnly(getApplicationContext())) {
337             mPhoneStateReceiver.unregisterIntent();
338             mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
339         }
340         if (mShowLatestAreaInfo) {
341             unregisterReceiver(mAreaInfoReceiver);
342         }
343         unregisterReceiver(mBatteryInfoReceiver);
344         mHandler.removeMessages(EVENT_UPDATE_STATS);
345     }
346 
347     /**
348      * Removes the specified preference, if it exists.
349      * @param key the key for the Preference item
350      */
removePreferenceFromScreen(String key)351     private void removePreferenceFromScreen(String key) {
352         Preference pref = findPreference(key);
353         if (pref != null) {
354             getPreferenceScreen().removePreference(pref);
355         }
356     }
357 
358     /**
359      * @param preference The key for the Preference item
360      * @param property The system property to fetch
361      * @param alt The default value, if the property doesn't exist
362      */
setSummary(String preference, String property, String alt)363     private void setSummary(String preference, String property, String alt) {
364         try {
365             findPreference(preference).setSummary(
366                     SystemProperties.get(property, alt));
367         } catch (RuntimeException e) {
368 
369         }
370     }
371 
setSummaryText(String preference, String text)372     private void setSummaryText(String preference, String text) {
373             if (TextUtils.isEmpty(text)) {
374                text = sUnknown;
375              }
376              // some preferences may be missing
377              if (findPreference(preference) != null) {
378                  findPreference(preference).setSummary(text);
379              }
380     }
381 
updateNetworkType()382     private void updateNetworkType() {
383         // Whether EDGE, UMTS, etc...
384         String networktype = null;
385         if (TelephonyManager.NETWORK_TYPE_UNKNOWN != mTelephonyManager.getNetworkType()) {
386             networktype = mTelephonyManager.getNetworkTypeName();
387         }
388         setSummaryText(KEY_NETWORK_TYPE, networktype);
389     }
390 
updateDataState()391     private void updateDataState() {
392         int state = mTelephonyManager.getDataState();
393         String display = mRes.getString(R.string.radioInfo_unknown);
394 
395         switch (state) {
396             case TelephonyManager.DATA_CONNECTED:
397                 display = mRes.getString(R.string.radioInfo_data_connected);
398                 break;
399             case TelephonyManager.DATA_SUSPENDED:
400                 display = mRes.getString(R.string.radioInfo_data_suspended);
401                 break;
402             case TelephonyManager.DATA_CONNECTING:
403                 display = mRes.getString(R.string.radioInfo_data_connecting);
404                 break;
405             case TelephonyManager.DATA_DISCONNECTED:
406                 display = mRes.getString(R.string.radioInfo_data_disconnected);
407                 break;
408         }
409 
410         setSummaryText(KEY_DATA_STATE, display);
411     }
412 
updateServiceState(ServiceState serviceState)413     private void updateServiceState(ServiceState serviceState) {
414         int state = serviceState.getState();
415         String display = mRes.getString(R.string.radioInfo_unknown);
416 
417         switch (state) {
418             case ServiceState.STATE_IN_SERVICE:
419                 display = mRes.getString(R.string.radioInfo_service_in);
420                 break;
421             case ServiceState.STATE_OUT_OF_SERVICE:
422             case ServiceState.STATE_EMERGENCY_ONLY:
423                 display = mRes.getString(R.string.radioInfo_service_out);
424                 break;
425             case ServiceState.STATE_POWER_OFF:
426                 display = mRes.getString(R.string.radioInfo_service_off);
427                 break;
428         }
429 
430         setSummaryText(KEY_SERVICE_STATE, display);
431 
432         if (serviceState.getRoaming()) {
433             setSummaryText(KEY_ROAMING_STATE, mRes.getString(R.string.radioInfo_roaming_in));
434         } else {
435             setSummaryText(KEY_ROAMING_STATE, mRes.getString(R.string.radioInfo_roaming_not));
436         }
437         setSummaryText(KEY_OPERATOR_NAME, serviceState.getOperatorAlphaLong());
438     }
439 
updateAreaInfo(String areaInfo)440     private void updateAreaInfo(String areaInfo) {
441         if (areaInfo != null) {
442             setSummaryText(KEY_LATEST_AREA_INFO, areaInfo);
443         }
444     }
445 
updateSignalStrength()446     void updateSignalStrength() {
447         // TODO PhoneStateIntentReceiver is deprecated and PhoneStateListener
448         // should probably used instead.
449 
450         // not loaded in some versions of the code (e.g., zaku)
451         if (mSignalStrength != null) {
452             int state =
453                     mPhoneStateReceiver.getServiceState().getState();
454             Resources r = getResources();
455 
456             if ((ServiceState.STATE_OUT_OF_SERVICE == state) ||
457                     (ServiceState.STATE_POWER_OFF == state)) {
458                 mSignalStrength.setSummary("0");
459             }
460 
461             int signalDbm = mPhoneStateReceiver.getSignalStrengthDbm();
462 
463             if (-1 == signalDbm) signalDbm = 0;
464 
465             int signalAsu = mPhoneStateReceiver.getSignalStrengthLevelAsu();
466 
467             if (-1 == signalAsu) signalAsu = 0;
468 
469             mSignalStrength.setSummary(String.valueOf(signalDbm) + " "
470                         + r.getString(R.string.radioInfo_display_dbm) + "   "
471                         + String.valueOf(signalAsu) + " "
472                         + r.getString(R.string.radioInfo_display_asu));
473         }
474     }
475 
setWimaxStatus()476     private void setWimaxStatus() {
477         ConnectivityManager cm = (ConnectivityManager) getSystemService(CONNECTIVITY_SERVICE);
478         NetworkInfo ni = cm.getNetworkInfo(ConnectivityManager.TYPE_WIMAX);
479 
480         if (ni == null) {
481             PreferenceScreen root = getPreferenceScreen();
482             Preference ps = (Preference) findPreference(KEY_WIMAX_MAC_ADDRESS);
483             if (ps != null) root.removePreference(ps);
484         } else {
485             Preference wimaxMacAddressPref = findPreference(KEY_WIMAX_MAC_ADDRESS);
486             String macAddress = SystemProperties.get("net.wimax.mac.address",
487                     getString(R.string.status_unavailable));
488             wimaxMacAddressPref.setSummary(macAddress);
489         }
490     }
setWifiStatus()491     private void setWifiStatus() {
492         WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
493         WifiInfo wifiInfo = wifiManager.getConnectionInfo();
494 
495         Preference wifiMacAddressPref = findPreference(KEY_WIFI_MAC_ADDRESS);
496 
497         String macAddress = wifiInfo == null ? null : wifiInfo.getMacAddress();
498         wifiMacAddressPref.setSummary(!TextUtils.isEmpty(macAddress) ? macAddress
499                 : getString(R.string.status_unavailable));
500     }
501 
setIpAddressStatus()502     private void setIpAddressStatus() {
503         Preference ipAddressPref = findPreference(KEY_IP_ADDRESS);
504         String ipAddress = Utils.getDefaultIpAddresses(this);
505         if (ipAddress != null) {
506             ipAddressPref.setSummary(ipAddress);
507         } else {
508             ipAddressPref.setSummary(getString(R.string.status_unavailable));
509         }
510     }
511 
setBtStatus()512     private void setBtStatus() {
513         BluetoothAdapter bluetooth = BluetoothAdapter.getDefaultAdapter();
514         Preference btAddressPref = findPreference(KEY_BT_ADDRESS);
515 
516         if (bluetooth == null) {
517             // device not BT capable
518             getPreferenceScreen().removePreference(btAddressPref);
519         } else {
520             String address = bluetooth.isEnabled() ? bluetooth.getAddress() : null;
521             btAddressPref.setSummary(!TextUtils.isEmpty(address) ? address
522                     : getString(R.string.status_unavailable));
523         }
524     }
525 
updateTimes()526     void updateTimes() {
527         long at = SystemClock.uptimeMillis() / 1000;
528         long ut = SystemClock.elapsedRealtime() / 1000;
529 
530         if (ut == 0) {
531             ut = 1;
532         }
533 
534         mUptime.setSummary(convert(ut));
535     }
536 
pad(int n)537     private String pad(int n) {
538         if (n >= 10) {
539             return String.valueOf(n);
540         } else {
541             return "0" + String.valueOf(n);
542         }
543     }
544 
convert(long t)545     private String convert(long t) {
546         int s = (int)(t % 60);
547         int m = (int)((t / 60) % 60);
548         int h = (int)((t / 3600));
549 
550         return h + ":" + pad(m) + ":" + pad(s);
551     }
552 }
553