Status.java revision de2d9f5f109265873196f1615e1f3546b114aaa7 
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
17package com.android.settings.deviceinfo;
18
19import android.bluetooth.BluetoothDevice;
20import android.content.BroadcastReceiver;
21import android.content.Context;
22import android.content.Intent;
23import android.content.IntentFilter;
24import android.content.res.Resources;
25import android.net.wifi.WifiInfo;
26import android.net.wifi.WifiManager;
27import android.os.BatteryManager;
28import android.os.Bundle;
29import android.os.Handler;
30import android.os.Message;
31import android.os.SystemClock;
32import android.os.SystemProperties;
33import android.preference.Preference;
34import android.preference.PreferenceActivity;
35import android.telephony.PhoneStateListener;
36import android.telephony.ServiceState;
37import android.telephony.TelephonyManager;
38import android.text.TextUtils;
39
40import com.android.internal.telephony.Phone;
41import com.android.internal.telephony.PhoneFactory;
42import com.android.internal.telephony.PhoneStateIntentReceiver;
43import com.android.internal.telephony.TelephonyProperties;
44import com.android.settings.R;
45
46import java.lang.ref.WeakReference;
47
48/**
49 * Display the following information
50 * # Phone Number
51 * # Network
52 * # Roaming
53 * # IMEI
54 * # IMSI
55 * # Network type
56 * # Signal Strength
57 * # Battery Strength  : TODO
58 * # Uptime
59 * # Awake Time
60 * # XMPP/buzz/tickle status : TODO
61 *
62 */
63public class Status extends PreferenceActivity {
64
65    private static final String KEY_WIFI_MAC_ADDRESS = "wifi_mac_address";
66    private static final String KEY_BT_ADDRESS = "bt_address";
67    private static final int EVENT_SIGNAL_STRENGTH_CHANGED = 200;
68    private static final int EVENT_SERVICE_STATE_CHANGED = 300;
69
70    private static final int EVENT_FIX_UPTIME = 500;
71
72    private TelephonyManager mTelephonyManager;
73    private Phone mPhone = null;
74    private PhoneStateIntentReceiver mPhoneStateReceiver;
75    private Resources mRes;
76    private Preference mSignalStrength;
77    private Preference mUptime;
78    private Preference mAwakeTime;
79
80    private static String sUnknown;
81
82    private Preference mBatteryStatus;
83    private Preference mBatteryLevel;
84
85    private Handler mHandler;
86
87    private static class MyHandler extends Handler {
88        private WeakReference<Status> mStatus;
89
90        public MyHandler(Status activity) {
91            mStatus = new WeakReference<Status>(activity);
92        }
93
94        @Override
95        public void handleMessage(Message msg) {
96            Status status = mStatus.get();
97            if (status == null) {
98                return;
99            }
100
101            switch (msg.what) {
102                case EVENT_SIGNAL_STRENGTH_CHANGED:
103                    status.updateSignalStrength();
104                    break;
105
106                case EVENT_SERVICE_STATE_CHANGED:
107                    ServiceState serviceState = status.mPhoneStateReceiver.getServiceState();
108                    status.updateServiceState(serviceState);
109                    break;
110
111                case EVENT_FIX_UPTIME:
112                    status.updateTimes();
113                    sendMessageDelayed(obtainMessage(EVENT_FIX_UPTIME), 1000);
114                    break;
115            }
116        }
117    }
118
119    private BroadcastReceiver mBatteryInfoReceiver = new BroadcastReceiver() {
120
121        @Override
122        public void onReceive(Context context, Intent intent) {
123            String action = intent.getAction();
124            if (Intent.ACTION_BATTERY_CHANGED.equals(action)) {
125
126                int level = intent.getIntExtra("level", 0);
127                int scale = intent.getIntExtra("scale", 100);
128
129                mBatteryLevel.setSummary(String.valueOf(level * 100 / scale) + "%");
130
131                int plugType = intent.getIntExtra("plugged", 0);
132                int status = intent.getIntExtra("status", BatteryManager.BATTERY_STATUS_UNKNOWN);
133                String statusString;
134                if (status == BatteryManager.BATTERY_STATUS_CHARGING) {
135                    statusString = getString(R.string.battery_info_status_charging);
136                    if (plugType > 0) {
137                        statusString = statusString + " " + getString(
138                                (plugType == BatteryManager.BATTERY_PLUGGED_AC)
139                                        ? R.string.battery_info_status_charging_ac
140                                        : R.string.battery_info_status_charging_usb);
141                    }
142                } else if (status == BatteryManager.BATTERY_STATUS_DISCHARGING) {
143                    statusString = getString(R.string.battery_info_status_discharging);
144                } else if (status == BatteryManager.BATTERY_STATUS_NOT_CHARGING) {
145                    statusString = getString(R.string.battery_info_status_not_charging);
146                } else if (status == BatteryManager.BATTERY_STATUS_FULL) {
147                    statusString = getString(R.string.battery_info_status_full);
148                } else {
149                    statusString = getString(R.string.battery_info_status_unknown);
150                }
151                mBatteryStatus.setSummary(statusString);
152            }
153        }
154    };
155
156    private PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
157        @Override
158        public void onDataConnectionStateChanged(int state) {
159            updateDataState();
160            updateNetworkType();
161        }
162    };
163
164    @Override
165    protected void onCreate(Bundle icicle) {
166        super.onCreate(icicle);
167
168        mHandler = new MyHandler(this);
169
170        mTelephonyManager = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
171
172        addPreferencesFromResource(R.xml.device_info_status);
173        mBatteryLevel = findPreference("battery_level");
174        mBatteryStatus = findPreference("battery_status");
175
176        mRes = getResources();
177        if (sUnknown == null) {
178            sUnknown = mRes.getString(R.string.device_info_default);
179        }
180
181        mPhone = PhoneFactory.getDefaultPhone();
182        mSignalStrength = findPreference("signal_strength");
183        mUptime = findPreference("up_time");
184        mAwakeTime = findPreference("awake_time");
185
186        setSummaryText("imei", mPhone.getDeviceId());
187        setSummaryText("imei_sv",
188                ((TelephonyManager) getSystemService(TELEPHONY_SERVICE))
189                        .getDeviceSoftwareVersion());
190        setSummaryText("imsi", mPhone.getSubscriberId());
191        setSummaryText("number", mPhone.getLine1Number());
192
193        mPhoneStateReceiver = new PhoneStateIntentReceiver(this, mHandler);
194        mPhoneStateReceiver.notifySignalStrength(EVENT_SIGNAL_STRENGTH_CHANGED);
195        mPhoneStateReceiver.notifyServiceState(EVENT_SERVICE_STATE_CHANGED);
196
197        setWifiStatus();
198        setBtStatus();
199    }
200
201    @Override
202    protected void onResume() {
203        super.onResume();
204
205        mPhoneStateReceiver.registerIntent();
206        registerReceiver(mBatteryInfoReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
207
208        updateSignalStrength();
209        updateServiceState(mPhone.getServiceState());
210        updateDataState();
211
212        mTelephonyManager.listen(mPhoneStateListener,
213                  PhoneStateListener.LISTEN_DATA_CONNECTION_STATE);
214
215        mHandler.sendMessageDelayed(mHandler.obtainMessage(EVENT_FIX_UPTIME), 0);
216    }
217
218    @Override
219    public void onPause() {
220        super.onPause();
221
222        mPhoneStateReceiver.unregisterIntent();
223        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
224        unregisterReceiver(mBatteryInfoReceiver);
225        mHandler.removeMessages(EVENT_FIX_UPTIME);
226    }
227
228    /**
229     * @param preference The key for the Preference item
230     * @param property The system property to fetch
231     * @param alt The default value, if the property doesn't exist
232     */
233    private void setSummary(String preference, String property, String alt) {
234        try {
235            findPreference(preference).setSummary(
236                    SystemProperties.get(property, alt));
237        } catch (RuntimeException e) {
238
239        }
240    }
241
242    private void setSummaryText(String preference, String text) {
243        if (text != null) {
244            findPreference(preference).setSummary(text);
245        }
246    }
247
248    private void updateNetworkType() {
249        // Whether EDGE, UMTS, etc...
250        setSummary("network_type", TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, sUnknown);
251    }
252
253    private void updateDataState() {
254        int state = mTelephonyManager.getDataState();
255        String display = mRes.getString(R.string.radioInfo_unknown);
256
257        switch (state) {
258            case TelephonyManager.DATA_CONNECTED:
259                display = mRes.getString(R.string.radioInfo_data_connected);
260                break;
261            case TelephonyManager.DATA_SUSPENDED:
262                display = mRes.getString(R.string.radioInfo_data_suspended);
263                break;
264            case TelephonyManager.DATA_CONNECTING:
265                display = mRes.getString(R.string.radioInfo_data_connecting);
266                break;
267            case TelephonyManager.DATA_DISCONNECTED:
268                display = mRes.getString(R.string.radioInfo_data_disconnected);
269                break;
270        }
271
272        setSummaryText("data_state", display);
273    }
274
275    private void updateServiceState(ServiceState serviceState) {
276        int state = serviceState.getState();
277        String display = mRes.getString(R.string.radioInfo_unknown);
278
279        switch (state) {
280            case ServiceState.STATE_IN_SERVICE:
281                display = mRes.getString(R.string.radioInfo_service_in);
282                break;
283            case ServiceState.STATE_OUT_OF_SERVICE:
284            case ServiceState.STATE_EMERGENCY_ONLY:
285                display = mRes.getString(R.string.radioInfo_service_out);
286                break;
287            case ServiceState.STATE_POWER_OFF:
288                display = mRes.getString(R.string.radioInfo_service_off);
289                break;
290        }
291
292        setSummaryText("service_state", display);
293
294        if (serviceState.getRoaming()) {
295            setSummaryText("roaming_state", mRes.getString(R.string.radioInfo_roaming_in));
296        } else {
297            setSummaryText("roaming_state", mRes.getString(R.string.radioInfo_roaming_not));
298        }
299        setSummaryText("operator_name", serviceState.getOperatorAlphaLong());
300    }
301
302    void updateSignalStrength() {
303        int state =
304                mPhoneStateReceiver.getServiceState().getState();
305        Resources r = getResources();
306
307        if ((ServiceState.STATE_OUT_OF_SERVICE == state) ||
308                (ServiceState.STATE_POWER_OFF == state)) {
309            mSignalStrength.setSummary("0");
310        }
311
312        int signalDbm = mPhoneStateReceiver.getSignalStrengthDbm();
313
314        if (-1 == signalDbm) signalDbm = 0;
315
316        int signalAsu = mPhoneStateReceiver.getSignalStrength();
317
318        if (-1 == signalAsu) signalAsu = 0;
319
320        mSignalStrength.setSummary(String.valueOf(signalDbm) + " "
321                    + r.getString(R.string.radioInfo_display_dbm) + "   "
322                    + String.valueOf(signalAsu) + " "
323                    + r.getString(R.string.radioInfo_display_asu));
324    }
325
326    private void setWifiStatus() {
327        WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
328        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
329
330        Preference wifiMacAddressPref = findPreference(KEY_WIFI_MAC_ADDRESS);
331        String macAddress = wifiInfo == null ? null : wifiInfo.getMacAddress();
332        wifiMacAddressPref.setSummary(!TextUtils.isEmpty(macAddress) ? macAddress
333                : getString(R.string.status_unavailable));
334    }
335
336    private void setBtStatus() {
337        BluetoothDevice bluetooth = (BluetoothDevice) getSystemService(BLUETOOTH_SERVICE);
338        Preference btAddressPref = findPreference(KEY_BT_ADDRESS);
339
340        if (bluetooth == null) {
341            // device not BT capable
342            getPreferenceScreen().removePreference(btAddressPref);
343        } else {
344            String address = bluetooth.isEnabled() ? bluetooth.getAddress() : null;
345            btAddressPref.setSummary(!TextUtils.isEmpty(address) ? address
346                    : getString(R.string.status_unavailable));
347        }
348    }
349
350    void updateTimes() {
351        long at = SystemClock.uptimeMillis() / 1000;
352        long ut = SystemClock.elapsedRealtime() / 1000;
353        long st = ut - at;
354
355        if (ut == 0) {
356            ut = 1;
357        }
358
359        mUptime.setSummary(convert(ut));
360        mAwakeTime.setSummary(convert(at) + " (" + (((1000 * at / ut) + 5) / 10) + "%)");
361    }
362
363    private String pad(int n) {
364        if (n >= 10) {
365            return String.valueOf(n);
366        } else {
367            return "0" + String.valueOf(n);
368        }
369    }
370
371    private String convert(long t) {
372        int s = (int)(t % 60);
373        int m = (int)((t / 60) % 60);
374        int h = (int)((t / 3600));
375
376        return h + ":" + pad(m) + ":" + pad(s);
377    }
378}
379