1 /* 2 * Copyright (C) 2006 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; 18 19 import android.app.Activity; 20 import android.app.AlertDialog; 21 import android.app.Dialog; 22 import android.app.QueuedWork; 23 import android.content.Intent; 24 import android.content.pm.PackageManager; 25 import android.content.pm.ResolveInfo; 26 import android.content.res.Resources; 27 import android.graphics.Typeface; 28 import android.net.TrafficStats; 29 import android.net.Uri; 30 import android.os.AsyncResult; 31 import android.os.Bundle; 32 import android.os.Handler; 33 import android.os.Message; 34 import android.telephony.CellInfo; 35 import android.telephony.CellInfoCdma; 36 import android.telephony.CellInfoGsm; 37 import android.telephony.CellInfoLte; 38 import android.telephony.CellInfoWcdma; 39 import android.telephony.CellIdentityCdma; 40 import android.telephony.CellIdentityGsm; 41 import android.telephony.CellIdentityLte; 42 import android.telephony.CellIdentityWcdma; 43 import android.telephony.CellLocation; 44 import android.telephony.CellSignalStrengthCdma; 45 import android.telephony.CellSignalStrengthGsm; 46 import android.telephony.CellSignalStrengthLte; 47 import android.telephony.CellSignalStrengthWcdma; 48 import android.telephony.DataConnectionRealTimeInfo; 49 import android.telephony.NeighboringCellInfo; 50 import android.telephony.PreciseCallState; 51 import android.telephony.PhoneStateListener; 52 import android.telephony.ServiceState; 53 import android.telephony.SignalStrength; 54 import android.telephony.SubscriptionManager; 55 import android.telephony.TelephonyManager; 56 import android.telephony.cdma.CdmaCellLocation; 57 import android.telephony.gsm.GsmCellLocation; 58 import android.util.Log; 59 import android.view.Menu; 60 import android.view.MenuItem; 61 import android.view.View; 62 import android.view.View.OnClickListener; 63 import android.widget.AdapterView; 64 import android.widget.ArrayAdapter; 65 import android.widget.Button; 66 import android.widget.CompoundButton; 67 import android.widget.CompoundButton.OnCheckedChangeListener; 68 import android.widget.EditText; 69 import android.widget.Spinner; 70 import android.widget.Switch; 71 import android.widget.TextView; 72 73 import com.android.ims.ImsConfig; 74 import com.android.ims.ImsException; 75 import com.android.ims.ImsManager; 76 import com.android.internal.telephony.Phone; 77 import com.android.internal.telephony.PhoneConstants; 78 import com.android.internal.telephony.PhoneFactory; 79 import com.android.internal.telephony.RILConstants; 80 import com.android.internal.telephony.TelephonyProperties; 81 82 import java.io.IOException; 83 import java.net.HttpURLConnection; 84 import java.net.URL; 85 import java.net.UnknownHostException; 86 import java.util.ArrayList; 87 import java.util.List; 88 89 public class RadioInfo extends Activity { 90 private static final String TAG = "RadioInfo"; 91 92 private static final String[] mPreferredNetworkLabels = { 93 "WCDMA preferred", 94 "GSM only", 95 "WCDMA only", 96 "GSM auto (PRL)", 97 "CDMA auto (PRL)", 98 "CDMA only", 99 "EvDo only", 100 "Global auto (PRL)", 101 "LTE/CDMA auto (PRL)", 102 "LTE/UMTS auto (PRL)", 103 "LTE/CDMA/UMTS auto (PRL)", 104 "LTE only", 105 "LTE/WCDMA", 106 "TD-SCDMA only", 107 "TD-SCDMA/WCDMA", 108 "LTE/TD-SCDMA", 109 "TD-SCDMA/GSM", 110 "TD-SCDMA/UMTS", 111 "LTE/TD-SCDMA/WCDMA", 112 "LTE/TD-SCDMA/UMTS", 113 "TD-SCDMA/CDMA/UMTS", 114 "Global/TD-SCDMA", 115 "Unknown" 116 }; 117 118 119 private static final int CELL_INFO_LIST_RATE_DISABLED = Integer.MAX_VALUE; 120 private static final int CELL_INFO_LIST_RATE_MAX = 0; 121 122 123 private static final int IMS_VOLTE_PROVISIONED_CONFIG_ID = 124 ImsConfig.ConfigConstants.VLT_SETTING_ENABLED; 125 126 private static final int IMS_VT_PROVISIONED_CONFIG_ID = 127 ImsConfig.ConfigConstants.LVC_SETTING_ENABLED; 128 129 private static final int IMS_WFC_PROVISIONED_CONFIG_ID = 130 ImsConfig.ConfigConstants.VOICE_OVER_WIFI_SETTING_ENABLED; 131 132 //Values in must match mCellInfoRefreshRates 133 private static final String[] mCellInfoRefreshRateLabels = { 134 "Disabled", 135 "Immediate", 136 "Min 5s", 137 "Min 10s", 138 "Min 60s" 139 }; 140 141 //Values in seconds, must match mCellInfoRefreshRateLabels 142 private static final int mCellInfoRefreshRates[] = { 143 CELL_INFO_LIST_RATE_DISABLED, 144 CELL_INFO_LIST_RATE_MAX, 145 5000, 146 10000, 147 60000 148 }; 149 150 private void log(String s) { 151 Log.d(TAG, s); 152 } 153 154 private static final int EVENT_CFI_CHANGED = 302; 155 156 private static final int EVENT_QUERY_PREFERRED_TYPE_DONE = 1000; 157 private static final int EVENT_SET_PREFERRED_TYPE_DONE = 1001; 158 private static final int EVENT_QUERY_SMSC_DONE = 1005; 159 private static final int EVENT_UPDATE_SMSC_DONE = 1006; 160 161 private static final int MENU_ITEM_SELECT_BAND = 0; 162 private static final int MENU_ITEM_VIEW_ADN = 1; 163 private static final int MENU_ITEM_VIEW_FDN = 2; 164 private static final int MENU_ITEM_VIEW_SDN = 3; 165 private static final int MENU_ITEM_GET_IMS_STATUS = 4; 166 private static final int MENU_ITEM_TOGGLE_DATA = 5; 167 168 private TextView mDeviceId; //DeviceId is the IMEI in GSM and the MEID in CDMA 169 private TextView number; 170 private TextView callState; 171 private TextView operatorName; 172 private TextView roamingState; 173 private TextView gsmState; 174 private TextView gprsState; 175 private TextView voiceNetwork; 176 private TextView dataNetwork; 177 private TextView dBm; 178 private TextView mMwi; 179 private TextView mCfi; 180 private TextView mLocation; 181 private TextView mNeighboringCids; 182 private TextView mCellInfo; 183 private TextView mDcRtInfoTv; 184 private TextView sent; 185 private TextView received; 186 private TextView mPingHostnameV4; 187 private TextView mPingHostnameV6; 188 private TextView mHttpClientTest; 189 private TextView dnsCheckState; 190 private EditText smsc; 191 private Switch radioPowerOnSwitch; 192 private Button cellInfoRefreshRateButton; 193 private Button dnsCheckToggleButton; 194 private Button pingTestButton; 195 private Button updateSmscButton; 196 private Button refreshSmscButton; 197 private Button oemInfoButton; 198 private Switch imsVolteProvisionedSwitch; 199 private Switch imsVtProvisionedSwitch; 200 private Switch imsWfcProvisionedSwitch; 201 private Spinner preferredNetworkType; 202 private Spinner cellInfoRefreshRateSpinner; 203 204 private TelephonyManager mTelephonyManager; 205 private ImsManager mImsManager = null; 206 private Phone phone = null; 207 208 private String mPingHostnameResultV4; 209 private String mPingHostnameResultV6; 210 private String mHttpClientTestResult; 211 private boolean mMwiValue = false; 212 private boolean mCfiValue = false; 213 214 private List<CellInfo> mCellInfoResult = null; 215 private CellLocation mCellLocationResult = null; 216 private List<NeighboringCellInfo> mNeighboringCellResult = null; 217 218 private int mPreferredNetworkTypeResult; 219 private int mCellInfoRefreshRateIndex; 220 221 private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() { 222 @Override 223 public void onDataConnectionStateChanged(int state) { 224 updateDataState(); 225 updateNetworkType(); 226 } 227 228 @Override 229 public void onDataActivity(int direction) { 230 updateDataStats2(); 231 } 232 233 @Override 234 public void onCallStateChanged(int state, String incomingNumber) { 235 updateNetworkType(); 236 updatePhoneState(state); 237 } 238 239 @Override 240 public void onPreciseCallStateChanged(PreciseCallState preciseState) { 241 updateNetworkType(); 242 } 243 244 @Override 245 public void onCellLocationChanged(CellLocation location) { 246 updateLocation(location); 247 } 248 249 @Override 250 public void onMessageWaitingIndicatorChanged(boolean mwi) { 251 mMwiValue = mwi; 252 updateMessageWaiting(); 253 } 254 255 @Override 256 public void onCallForwardingIndicatorChanged(boolean cfi) { 257 mCfiValue = cfi; 258 updateCallRedirect(); 259 } 260 261 @Override 262 public void onCellInfoChanged(List<CellInfo> arrayCi) { 263 log("onCellInfoChanged: arrayCi=" + arrayCi); 264 mCellInfoResult = arrayCi; 265 updateCellInfo(mCellInfoResult); 266 } 267 268 @Override 269 public void onDataConnectionRealTimeInfoChanged(DataConnectionRealTimeInfo dcRtInfo) { 270 log("onDataConnectionRealTimeInfoChanged: dcRtInfo=" + dcRtInfo); 271 updateDcRtInfoTv(dcRtInfo); 272 } 273 274 @Override 275 public void onSignalStrengthsChanged(SignalStrength signalStrength) { 276 log("onSignalStrengthChanged: SignalStrength=" +signalStrength); 277 updateSignalStrength(signalStrength); 278 } 279 280 @Override 281 public void onServiceStateChanged(ServiceState serviceState) { 282 log("onServiceStateChanged: ServiceState=" + serviceState); 283 updateServiceState(serviceState); 284 updateRadioPowerState(); 285 updateNetworkType(); 286 updateImsProvisionedState(); 287 } 288 }; 289 290 private void updatePreferredNetworkType(int type) { 291 if (type >= mPreferredNetworkLabels.length || type < 0) { 292 log("EVENT_QUERY_PREFERRED_TYPE_DONE: unknown " + 293 "type=" + type); 294 type = mPreferredNetworkLabels.length - 1; //set to Unknown 295 } 296 mPreferredNetworkTypeResult = type; 297 298 preferredNetworkType.setSelection(mPreferredNetworkTypeResult, true); 299 } 300 301 private Handler mHandler = new Handler() { 302 @Override 303 public void handleMessage(Message msg) { 304 AsyncResult ar; 305 switch (msg.what) { 306 case EVENT_QUERY_PREFERRED_TYPE_DONE: 307 ar= (AsyncResult) msg.obj; 308 if (ar.exception == null && ar.result != null) { 309 updatePreferredNetworkType(((int[])ar.result)[0]); 310 } else { 311 //In case of an exception, we will set this to unknown 312 updatePreferredNetworkType(mPreferredNetworkLabels.length-1); 313 } 314 break; 315 case EVENT_SET_PREFERRED_TYPE_DONE: 316 ar= (AsyncResult) msg.obj; 317 if (ar.exception != null) { 318 log("Set preferred network type failed."); 319 } 320 break; 321 case EVENT_QUERY_SMSC_DONE: 322 ar= (AsyncResult) msg.obj; 323 if (ar.exception != null) { 324 smsc.setText("refresh error"); 325 } else { 326 smsc.setText((String)ar.result); 327 } 328 break; 329 case EVENT_UPDATE_SMSC_DONE: 330 updateSmscButton.setEnabled(true); 331 ar= (AsyncResult) msg.obj; 332 if (ar.exception != null) { 333 smsc.setText("update error"); 334 } 335 break; 336 default: 337 super.handleMessage(msg); 338 break; 339 340 } 341 } 342 }; 343 344 @Override 345 public void onCreate(Bundle icicle) { 346 super.onCreate(icicle); 347 if (!android.os.Process.myUserHandle().isSystem()) { 348 Log.e(TAG, "Not run from system user, don't do anything."); 349 finish(); 350 return; 351 } 352 353 setContentView(R.layout.radio_info); 354 355 log("Started onCreate"); 356 357 mTelephonyManager = (TelephonyManager)getSystemService(TELEPHONY_SERVICE); 358 phone = PhoneFactory.getDefaultPhone(); 359 360 //TODO: Need to update this if the default phoneId changes? 361 // Better to have an instance per phone? 362 mImsManager = ImsManager.getInstance(getApplicationContext(), 363 SubscriptionManager.getDefaultVoicePhoneId()); 364 365 mDeviceId= (TextView) findViewById(R.id.imei); 366 number = (TextView) findViewById(R.id.number); 367 callState = (TextView) findViewById(R.id.call); 368 operatorName = (TextView) findViewById(R.id.operator); 369 roamingState = (TextView) findViewById(R.id.roaming); 370 gsmState = (TextView) findViewById(R.id.gsm); 371 gprsState = (TextView) findViewById(R.id.gprs); 372 voiceNetwork = (TextView) findViewById(R.id.voice_network); 373 dataNetwork = (TextView) findViewById(R.id.data_network); 374 dBm = (TextView) findViewById(R.id.dbm); 375 mMwi = (TextView) findViewById(R.id.mwi); 376 mCfi = (TextView) findViewById(R.id.cfi); 377 mLocation = (TextView) findViewById(R.id.location); 378 mNeighboringCids = (TextView) findViewById(R.id.neighboring); 379 mCellInfo = (TextView) findViewById(R.id.cellinfo); 380 mCellInfo.setTypeface(Typeface.MONOSPACE); 381 mDcRtInfoTv = (TextView) findViewById(R.id.dcrtinfo); 382 383 sent = (TextView) findViewById(R.id.sent); 384 received = (TextView) findViewById(R.id.received); 385 smsc = (EditText) findViewById(R.id.smsc); 386 dnsCheckState = (TextView) findViewById(R.id.dnsCheckState); 387 mPingHostnameV4 = (TextView) findViewById(R.id.pingHostnameV4); 388 mPingHostnameV6 = (TextView) findViewById(R.id.pingHostnameV6); 389 mHttpClientTest = (TextView) findViewById(R.id.httpClientTest); 390 391 preferredNetworkType = (Spinner) findViewById(R.id.preferredNetworkType); 392 ArrayAdapter<String> adapter = new ArrayAdapter<String> (this, 393 android.R.layout.simple_spinner_item, mPreferredNetworkLabels); 394 adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); 395 preferredNetworkType.setAdapter(adapter); 396 397 cellInfoRefreshRateSpinner = (Spinner) findViewById(R.id.cell_info_rate_select); 398 ArrayAdapter<String> cellInfoAdapter = new ArrayAdapter<String>(this, 399 android.R.layout.simple_spinner_item, mCellInfoRefreshRateLabels); 400 cellInfoAdapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); 401 cellInfoRefreshRateSpinner.setAdapter(cellInfoAdapter); 402 403 imsVolteProvisionedSwitch = (Switch) findViewById(R.id.volte_provisioned_switch); 404 imsVtProvisionedSwitch = (Switch) findViewById(R.id.vt_provisioned_switch); 405 imsWfcProvisionedSwitch = (Switch) findViewById(R.id.wfc_provisioned_switch); 406 407 radioPowerOnSwitch = (Switch) findViewById(R.id.radio_power); 408 409 pingTestButton = (Button) findViewById(R.id.ping_test); 410 pingTestButton.setOnClickListener(mPingButtonHandler); 411 updateSmscButton = (Button) findViewById(R.id.update_smsc); 412 updateSmscButton.setOnClickListener(mUpdateSmscButtonHandler); 413 refreshSmscButton = (Button) findViewById(R.id.refresh_smsc); 414 refreshSmscButton.setOnClickListener(mRefreshSmscButtonHandler); 415 dnsCheckToggleButton = (Button) findViewById(R.id.dns_check_toggle); 416 dnsCheckToggleButton.setOnClickListener(mDnsCheckButtonHandler); 417 418 oemInfoButton = (Button) findViewById(R.id.oem_info); 419 oemInfoButton.setOnClickListener(mOemInfoButtonHandler); 420 PackageManager pm = getPackageManager(); 421 Intent oemInfoIntent = new Intent("com.android.settings.OEM_RADIO_INFO"); 422 List<ResolveInfo> oemInfoIntentList = pm.queryIntentActivities(oemInfoIntent, 0); 423 if (oemInfoIntentList.size() == 0) { 424 oemInfoButton.setEnabled(false); 425 } 426 427 mCellInfoRefreshRateIndex = 0; //disabled 428 mPreferredNetworkTypeResult = mPreferredNetworkLabels.length - 1; //Unknown 429 430 //FIXME: Replace with TelephonyManager call 431 phone.getPreferredNetworkType( 432 mHandler.obtainMessage(EVENT_QUERY_PREFERRED_TYPE_DONE)); 433 434 restoreFromBundle(icicle); 435 } 436 437 @Override 438 protected void onResume() { 439 super.onResume(); 440 441 log("Started onResume"); 442 443 updateMessageWaiting(); 444 updateCallRedirect(); 445 updateDataState(); 446 updateDataStats2(); 447 updateRadioPowerState(); 448 updateImsProvisionedState(); 449 updateProperties(); 450 updateDnsCheckState(); 451 updateNetworkType(); 452 453 updateNeighboringCids(mNeighboringCellResult); 454 updateLocation(mCellLocationResult); 455 updateCellInfo(mCellInfoResult); 456 457 mPingHostnameV4.setText(mPingHostnameResultV4); 458 mPingHostnameV6.setText(mPingHostnameResultV6); 459 mHttpClientTest.setText(mHttpClientTestResult); 460 461 cellInfoRefreshRateSpinner.setOnItemSelectedListener(mCellInfoRefreshRateHandler); 462 //set selection after registering listener to force update 463 cellInfoRefreshRateSpinner.setSelection(mCellInfoRefreshRateIndex); 464 465 //set selection before registering to prevent update 466 preferredNetworkType.setSelection(mPreferredNetworkTypeResult, true); 467 preferredNetworkType.setOnItemSelectedListener(mPreferredNetworkHandler); 468 469 radioPowerOnSwitch.setOnCheckedChangeListener(mRadioPowerOnChangeListener); 470 imsVolteProvisionedSwitch.setOnCheckedChangeListener(mImsVolteCheckedChangeListener); 471 imsVtProvisionedSwitch.setOnCheckedChangeListener(mImsVtCheckedChangeListener); 472 imsWfcProvisionedSwitch.setOnCheckedChangeListener(mImsWfcCheckedChangeListener); 473 474 mTelephonyManager.listen(mPhoneStateListener, 475 PhoneStateListener.LISTEN_CALL_STATE 476 //b/27803938 - RadioInfo currently cannot read PRECISE_CALL_STATE 477 // | PhoneStateListener.LISTEN_PRECISE_CALL_STATE 478 | PhoneStateListener.LISTEN_DATA_CONNECTION_STATE 479 | PhoneStateListener.LISTEN_DATA_ACTIVITY 480 | PhoneStateListener.LISTEN_CELL_LOCATION 481 | PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR 482 | PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR 483 | PhoneStateListener.LISTEN_CELL_INFO 484 | PhoneStateListener.LISTEN_SERVICE_STATE 485 | PhoneStateListener.LISTEN_SIGNAL_STRENGTHS 486 | PhoneStateListener.LISTEN_DATA_CONNECTION_REAL_TIME_INFO); 487 488 smsc.clearFocus(); 489 } 490 491 @Override 492 protected void onPause() { 493 super.onPause(); 494 495 log("onPause: unregister phone & data intents"); 496 497 mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE); 498 mTelephonyManager.setCellInfoListRate(CELL_INFO_LIST_RATE_DISABLED); 499 } 500 501 private void restoreFromBundle(Bundle b) { 502 if(b == null) { 503 return; 504 } 505 506 mPingHostnameResultV4 = b.getString("mPingHostnameResultV4",""); 507 mPingHostnameResultV6 = b.getString("mPingHostnameResultV6",""); 508 mHttpClientTestResult = b.getString("mHttpClientTestResult",""); 509 510 mPingHostnameV4.setText(mPingHostnameResultV4); 511 mPingHostnameV6.setText(mPingHostnameResultV6); 512 mHttpClientTest.setText(mHttpClientTestResult); 513 514 mPreferredNetworkTypeResult = b.getInt("mPreferredNetworkTypeResult", 515 mPreferredNetworkLabels.length - 1); 516 517 mCellInfoRefreshRateIndex = b.getInt("mCellInfoRefreshRateIndex", 0); 518 } 519 520 @Override 521 protected void onSaveInstanceState(Bundle outState) { 522 outState.putString("mPingHostnameResultV4", mPingHostnameResultV4); 523 outState.putString("mPingHostnameResultV6", mPingHostnameResultV6); 524 outState.putString("mHttpClientTestResult", mHttpClientTestResult); 525 526 outState.putInt("mPreferredNetworkTypeResult", mPreferredNetworkTypeResult); 527 outState.putInt("mCellInfoRefreshRateIndex", mCellInfoRefreshRateIndex); 528 529 } 530 531 @Override 532 public boolean onCreateOptionsMenu(Menu menu) { 533 menu.add(0, MENU_ITEM_SELECT_BAND, 0, R.string.radio_info_band_mode_label) 534 .setOnMenuItemClickListener(mSelectBandCallback) 535 .setAlphabeticShortcut('b'); 536 menu.add(1, MENU_ITEM_VIEW_ADN, 0, 537 R.string.radioInfo_menu_viewADN).setOnMenuItemClickListener(mViewADNCallback); 538 menu.add(1, MENU_ITEM_VIEW_FDN, 0, 539 R.string.radioInfo_menu_viewFDN).setOnMenuItemClickListener(mViewFDNCallback); 540 menu.add(1, MENU_ITEM_VIEW_SDN, 0, 541 R.string.radioInfo_menu_viewSDN).setOnMenuItemClickListener(mViewSDNCallback); 542 menu.add(1, MENU_ITEM_GET_IMS_STATUS, 543 0, R.string.radioInfo_menu_getIMS).setOnMenuItemClickListener(mGetImsStatus); 544 menu.add(1, MENU_ITEM_TOGGLE_DATA, 545 0, R.string.radio_info_data_connection_disable).setOnMenuItemClickListener(mToggleData); 546 return true; 547 } 548 549 @Override 550 public boolean onPrepareOptionsMenu(Menu menu) { 551 // Get the TOGGLE DATA menu item in the right state. 552 MenuItem item = menu.findItem(MENU_ITEM_TOGGLE_DATA); 553 int state = mTelephonyManager.getDataState(); 554 boolean visible = true; 555 556 switch (state) { 557 case TelephonyManager.DATA_CONNECTED: 558 case TelephonyManager.DATA_SUSPENDED: 559 item.setTitle(R.string.radio_info_data_connection_disable); 560 break; 561 case TelephonyManager.DATA_DISCONNECTED: 562 item.setTitle(R.string.radio_info_data_connection_enable); 563 break; 564 default: 565 visible = false; 566 break; 567 } 568 item.setVisible(visible); 569 return true; 570 } 571 572 private void updateDnsCheckState() { 573 //FIXME: Replace with a TelephonyManager call 574 dnsCheckState.setText(phone.isDnsCheckDisabled() ? 575 "0.0.0.0 allowed" :"0.0.0.0 not allowed"); 576 } 577 578 private final void 579 updateSignalStrength(SignalStrength signalStrength) { 580 Resources r = getResources(); 581 582 int signalDbm = signalStrength.getDbm(); 583 584 int signalAsu = signalStrength.getAsuLevel(); 585 586 if (-1 == signalAsu) signalAsu = 0; 587 588 dBm.setText(String.valueOf(signalDbm) + " " 589 + r.getString(R.string.radioInfo_display_dbm) + " " 590 + String.valueOf(signalAsu) + " " 591 + r.getString(R.string.radioInfo_display_asu)); 592 } 593 594 private final void updateLocation(CellLocation location) { 595 Resources r = getResources(); 596 if (location instanceof GsmCellLocation) { 597 GsmCellLocation loc = (GsmCellLocation)location; 598 int lac = loc.getLac(); 599 int cid = loc.getCid(); 600 mLocation.setText(r.getString(R.string.radioInfo_lac) + " = " 601 + ((lac == -1) ? "unknown" : Integer.toHexString(lac)) 602 + " " 603 + r.getString(R.string.radioInfo_cid) + " = " 604 + ((cid == -1) ? "unknown" : Integer.toHexString(cid))); 605 } else if (location instanceof CdmaCellLocation) { 606 CdmaCellLocation loc = (CdmaCellLocation)location; 607 int bid = loc.getBaseStationId(); 608 int sid = loc.getSystemId(); 609 int nid = loc.getNetworkId(); 610 int lat = loc.getBaseStationLatitude(); 611 int lon = loc.getBaseStationLongitude(); 612 mLocation.setText("BID = " 613 + ((bid == -1) ? "unknown" : Integer.toHexString(bid)) 614 + " " 615 + "SID = " 616 + ((sid == -1) ? "unknown" : Integer.toHexString(sid)) 617 + " " 618 + "NID = " 619 + ((nid == -1) ? "unknown" : Integer.toHexString(nid)) 620 + "\n" 621 + "LAT = " 622 + ((lat == -1) ? "unknown" : Integer.toHexString(lat)) 623 + " " 624 + "LONG = " 625 + ((lon == -1) ? "unknown" : Integer.toHexString(lon))); 626 } else { 627 mLocation.setText("unknown"); 628 } 629 630 631 } 632 633 private final void updateNeighboringCids(List<NeighboringCellInfo> cids) { 634 StringBuilder sb = new StringBuilder(); 635 636 if (cids != null) { 637 if (cids.isEmpty()) { 638 sb.append("no neighboring cells"); 639 } else { 640 for (NeighboringCellInfo cell : cids) { 641 sb.append(cell.toString()).append(" "); 642 } 643 } 644 } else { 645 sb.append("unknown"); 646 } 647 mNeighboringCids.setText(sb.toString()); 648 } 649 650 private final String getCellInfoDisplayString(int i) { 651 return (i != Integer.MAX_VALUE) ? Integer.toString(i) : ""; 652 } 653 654 private final String getCellInfoDisplayString(long i) { 655 return (i != Long.MAX_VALUE) ? Long.toString(i) : ""; 656 } 657 658 private final String buildCdmaInfoString(CellInfoCdma ci) { 659 CellIdentityCdma cidCdma = ci.getCellIdentity(); 660 CellSignalStrengthCdma ssCdma = ci.getCellSignalStrength(); 661 662 return String.format("%-3.3s %-5.5s %-5.5s %-5.5s %-6.6s %-6.6s %-6.6s %-6.6s %-5.5s", 663 ci.isRegistered() ? "S " : " ", 664 getCellInfoDisplayString(cidCdma.getSystemId()), 665 getCellInfoDisplayString(cidCdma.getNetworkId()), 666 getCellInfoDisplayString(cidCdma.getBasestationId()), 667 getCellInfoDisplayString(ssCdma.getCdmaDbm()), 668 getCellInfoDisplayString(ssCdma.getCdmaEcio()), 669 getCellInfoDisplayString(ssCdma.getEvdoDbm()), 670 getCellInfoDisplayString(ssCdma.getEvdoEcio()), 671 getCellInfoDisplayString(ssCdma.getEvdoSnr())); 672 } 673 674 private final String buildGsmInfoString(CellInfoGsm ci) { 675 CellIdentityGsm cidGsm = ci.getCellIdentity(); 676 CellSignalStrengthGsm ssGsm = ci.getCellSignalStrength(); 677 678 return String.format("%-3.3s %-3.3s %-3.3s %-5.5s %-5.5s %-6.6s %-4.4s %-4.4s\n", 679 ci.isRegistered() ? "S " : " ", 680 getCellInfoDisplayString(cidGsm.getMcc()), 681 getCellInfoDisplayString(cidGsm.getMnc()), 682 getCellInfoDisplayString(cidGsm.getLac()), 683 getCellInfoDisplayString(cidGsm.getCid()), 684 getCellInfoDisplayString(cidGsm.getArfcn()), 685 getCellInfoDisplayString(cidGsm.getBsic()), 686 getCellInfoDisplayString(ssGsm.getDbm())); 687 } 688 689 private final String buildLteInfoString(CellInfoLte ci) { 690 CellIdentityLte cidLte = ci.getCellIdentity(); 691 CellSignalStrengthLte ssLte = ci.getCellSignalStrength(); 692 693 return String.format( 694 "%-3.3s %-3.3s %-3.3s %-5.5s %-5.5s %-3.3s %-6.6s %-4.4s %-4.4s %-2.2s\n", 695 ci.isRegistered() ? "S " : " ", 696 getCellInfoDisplayString(cidLte.getMcc()), 697 getCellInfoDisplayString(cidLte.getMnc()), 698 getCellInfoDisplayString(cidLte.getTac()), 699 getCellInfoDisplayString(cidLte.getCi()), 700 getCellInfoDisplayString(cidLte.getPci()), 701 getCellInfoDisplayString(cidLte.getEarfcn()), 702 getCellInfoDisplayString(ssLte.getDbm()), 703 getCellInfoDisplayString(ssLte.getRsrq()), 704 getCellInfoDisplayString(ssLte.getTimingAdvance())); 705 } 706 707 private final String buildWcdmaInfoString(CellInfoWcdma ci) { 708 CellIdentityWcdma cidWcdma = ci.getCellIdentity(); 709 CellSignalStrengthWcdma ssWcdma = ci.getCellSignalStrength(); 710 711 return String.format("%-3.3s %-3.3s %-3.3s %-5.5s %-5.5s %-6.6s %-3.3s %-4.4s\n", 712 ci.isRegistered() ? "S " : " ", 713 getCellInfoDisplayString(cidWcdma.getMcc()), 714 getCellInfoDisplayString(cidWcdma.getMnc()), 715 getCellInfoDisplayString(cidWcdma.getLac()), 716 getCellInfoDisplayString(cidWcdma.getCid()), 717 getCellInfoDisplayString(cidWcdma.getUarfcn()), 718 getCellInfoDisplayString(cidWcdma.getPsc()), 719 getCellInfoDisplayString(ssWcdma.getDbm())); 720 } 721 722 private final String buildCellInfoString(List<CellInfo> arrayCi) { 723 String value = new String(); 724 StringBuilder cdmaCells = new StringBuilder(), 725 gsmCells = new StringBuilder(), 726 lteCells = new StringBuilder(), 727 wcdmaCells = new StringBuilder(); 728 729 if (arrayCi != null) { 730 for (CellInfo ci : arrayCi) { 731 732 if (ci instanceof CellInfoLte) { 733 lteCells.append(buildLteInfoString((CellInfoLte) ci)); 734 } else if (ci instanceof CellInfoWcdma) { 735 wcdmaCells.append(buildWcdmaInfoString((CellInfoWcdma) ci)); 736 } else if (ci instanceof CellInfoGsm) { 737 gsmCells.append(buildGsmInfoString((CellInfoGsm) ci)); 738 } else if (ci instanceof CellInfoCdma) { 739 cdmaCells.append(buildCdmaInfoString((CellInfoCdma) ci)); 740 } 741 } 742 if (lteCells.length() != 0) { 743 value += String.format( 744 "LTE\n%-3.3s %-3.3s %-3.3s %-5.5s %-5.5s %-3.3s %-6.6s %-4.4s %-4.4s %-2.2s\n", 745 "SRV", "MCC", "MNC", "TAC", "CID", "PCI", "EARFCN", "RSRP", "RSRQ", "TA"); 746 value += lteCells.toString(); 747 } 748 if (wcdmaCells.length() != 0) { 749 value += String.format("WCDMA\n%-3.3s %-3.3s %-3.3s %-5.5s %-5.5s %-6.6s %-3.3s %-4.4s\n", 750 "SRV", "MCC", "MNC", "LAC", "CID", "UARFCN", "PSC", "RSCP"); 751 value += wcdmaCells.toString(); 752 } 753 if (gsmCells.length() != 0) { 754 value += String.format("GSM\n%-3.3s %-3.3s %-3.3s %-5.5s %-5.5s %-6.6s %-4.4s %-4.4s\n", 755 "SRV", "MCC", "MNC", "LAC", "CID", "ARFCN", "BSIC", "RSSI"); 756 value += gsmCells.toString(); 757 } 758 if (cdmaCells.length() != 0) { 759 value += String.format( 760 "CDMA/EVDO\n%-3.3s %-5.5s %-5.5s %-5.5s %-6.6s %-6.6s %-6.6s %-6.6s %-5.5s\n", 761 "SRV", "SID", "NID", "BSID", "C-RSSI", "C-ECIO", "E-RSSI", "E-ECIO", "E-SNR"); 762 value += cdmaCells.toString(); 763 } 764 } else { 765 value ="unknown"; 766 } 767 768 return value.toString(); 769 } 770 771 private final void updateCellInfo(List<CellInfo> arrayCi) { 772 mCellInfo.setText(buildCellInfoString(arrayCi)); 773 } 774 775 private final void updateDcRtInfoTv(DataConnectionRealTimeInfo dcRtInfo) { 776 mDcRtInfoTv.setText(dcRtInfo.toString()); 777 } 778 779 private final void 780 updateMessageWaiting() { 781 mMwi.setText(String.valueOf(mMwiValue)); 782 } 783 784 private final void 785 updateCallRedirect() { 786 mCfi.setText(String.valueOf(mCfiValue)); 787 } 788 789 790 private final void 791 updateServiceState(ServiceState serviceState) { 792 int state = serviceState.getState(); 793 Resources r = getResources(); 794 String display = r.getString(R.string.radioInfo_unknown); 795 796 switch (state) { 797 case ServiceState.STATE_IN_SERVICE: 798 display = r.getString(R.string.radioInfo_service_in); 799 break; 800 case ServiceState.STATE_OUT_OF_SERVICE: 801 case ServiceState.STATE_EMERGENCY_ONLY: 802 display = r.getString(R.string.radioInfo_service_emergency); 803 break; 804 case ServiceState.STATE_POWER_OFF: 805 display = r.getString(R.string.radioInfo_service_off); 806 break; 807 } 808 809 gsmState.setText(display); 810 811 if (serviceState.getRoaming()) { 812 roamingState.setText(R.string.radioInfo_roaming_in); 813 } else { 814 roamingState.setText(R.string.radioInfo_roaming_not); 815 } 816 817 operatorName.setText(serviceState.getOperatorAlphaLong()); 818 } 819 820 private final void 821 updatePhoneState(int state) { 822 Resources r = getResources(); 823 String display = r.getString(R.string.radioInfo_unknown); 824 825 switch (state) { 826 case TelephonyManager.CALL_STATE_IDLE: 827 display = r.getString(R.string.radioInfo_phone_idle); 828 break; 829 case TelephonyManager.CALL_STATE_RINGING: 830 display = r.getString(R.string.radioInfo_phone_ringing); 831 break; 832 case TelephonyManager.CALL_STATE_OFFHOOK: 833 display = r.getString(R.string.radioInfo_phone_offhook); 834 break; 835 } 836 837 callState.setText(display); 838 } 839 840 private final void 841 updateDataState() { 842 int state = mTelephonyManager.getDataState(); 843 Resources r = getResources(); 844 String display = r.getString(R.string.radioInfo_unknown); 845 846 switch (state) { 847 case TelephonyManager.DATA_CONNECTED: 848 display = r.getString(R.string.radioInfo_data_connected); 849 break; 850 case TelephonyManager.DATA_CONNECTING: 851 display = r.getString(R.string.radioInfo_data_connecting); 852 break; 853 case TelephonyManager.DATA_DISCONNECTED: 854 display = r.getString(R.string.radioInfo_data_disconnected); 855 break; 856 case TelephonyManager.DATA_SUSPENDED: 857 display = r.getString(R.string.radioInfo_data_suspended); 858 break; 859 } 860 861 gprsState.setText(display); 862 } 863 864 private final void updateNetworkType() { 865 if(phone != null) { 866 ServiceState ss = phone.getServiceState(); 867 dataNetwork.setText(ServiceState.rilRadioTechnologyToString( 868 phone.getServiceState().getRilDataRadioTechnology())); 869 voiceNetwork.setText(ServiceState.rilRadioTechnologyToString( 870 phone.getServiceState().getRilVoiceRadioTechnology())); 871 } 872 } 873 874 private final void 875 updateProperties() { 876 String s; 877 Resources r = getResources(); 878 879 s = phone.getDeviceId(); 880 if (s == null) s = r.getString(R.string.radioInfo_unknown); 881 mDeviceId.setText(s); 882 883 //FIXME: Replace with a TelephonyManager call 884 s = phone.getLine1Number(); 885 if (s == null) s = r.getString(R.string.radioInfo_unknown); 886 number.setText(s); 887 } 888 889 private final void updateDataStats2() { 890 Resources r = getResources(); 891 892 long txPackets = TrafficStats.getMobileTxPackets(); 893 long rxPackets = TrafficStats.getMobileRxPackets(); 894 long txBytes = TrafficStats.getMobileTxBytes(); 895 long rxBytes = TrafficStats.getMobileRxBytes(); 896 897 String packets = r.getString(R.string.radioInfo_display_packets); 898 String bytes = r.getString(R.string.radioInfo_display_bytes); 899 900 sent.setText(txPackets + " " + packets + ", " + txBytes + " " + bytes); 901 received.setText(rxPackets + " " + packets + ", " + rxBytes + " " + bytes); 902 } 903 904 /** 905 * Ping a host name 906 */ 907 private final void pingHostname() { 908 try { 909 try { 910 Process p4 = Runtime.getRuntime().exec("ping -c 1 www.google.com"); 911 int status4 = p4.waitFor(); 912 if (status4 == 0) { 913 mPingHostnameResultV4 = "Pass"; 914 } else { 915 mPingHostnameResultV4 = String.format("Fail(%d)", status4); 916 } 917 } catch (IOException e) { 918 mPingHostnameResultV4 = "Fail: IOException"; 919 } 920 try { 921 Process p6 = Runtime.getRuntime().exec("ping6 -c 1 www.google.com"); 922 int status6 = p6.waitFor(); 923 if (status6 == 0) { 924 mPingHostnameResultV6 = "Pass"; 925 } else { 926 mPingHostnameResultV6 = String.format("Fail(%d)", status6); 927 } 928 } catch (IOException e) { 929 mPingHostnameResultV6 = "Fail: IOException"; 930 } 931 } catch (InterruptedException e) { 932 mPingHostnameResultV4 = mPingHostnameResultV6 = "Fail: InterruptedException"; 933 } 934 } 935 936 /** 937 * This function checks for basic functionality of HTTP Client. 938 */ 939 private void httpClientTest() { 940 HttpURLConnection urlConnection = null; 941 try { 942 // TODO: Hardcoded for now, make it UI configurable 943 URL url = new URL("https://www.google.com"); 944 urlConnection = (HttpURLConnection) url.openConnection(); 945 if (urlConnection.getResponseCode() == 200) { 946 mHttpClientTestResult = "Pass"; 947 } else { 948 mHttpClientTestResult = "Fail: Code: " + urlConnection.getResponseMessage(); 949 } 950 } catch (IOException e) { 951 mHttpClientTestResult = "Fail: IOException"; 952 } finally { 953 if (urlConnection != null) { 954 urlConnection.disconnect(); 955 } 956 } 957 } 958 959 private void refreshSmsc() { 960 //FIXME: Replace with a TelephonyManager call 961 phone.getSmscAddress(mHandler.obtainMessage(EVENT_QUERY_SMSC_DONE)); 962 } 963 964 private final void updateAllCellInfo() { 965 966 mCellInfo.setText(""); 967 mNeighboringCids.setText(""); 968 mLocation.setText(""); 969 970 final Runnable updateAllCellInfoResults = new Runnable() { 971 public void run() { 972 updateNeighboringCids(mNeighboringCellResult); 973 updateLocation(mCellLocationResult); 974 updateCellInfo(mCellInfoResult); 975 } 976 }; 977 978 Thread locThread = new Thread() { 979 @Override 980 public void run() { 981 mCellInfoResult = mTelephonyManager.getAllCellInfo(); 982 mCellLocationResult = mTelephonyManager.getCellLocation(); 983 mNeighboringCellResult = mTelephonyManager.getNeighboringCellInfo(); 984 985 mHandler.post(updateAllCellInfoResults); 986 } 987 }; 988 locThread.start(); 989 } 990 991 private final void updatePingState() { 992 // Set all to unknown since the threads will take a few secs to update. 993 mPingHostnameResultV4 = getResources().getString(R.string.radioInfo_unknown); 994 mPingHostnameResultV6 = getResources().getString(R.string.radioInfo_unknown); 995 mHttpClientTestResult = getResources().getString(R.string.radioInfo_unknown); 996 997 mPingHostnameV4.setText(mPingHostnameResultV4); 998 mPingHostnameV6.setText(mPingHostnameResultV6); 999 mHttpClientTest.setText(mHttpClientTestResult); 1000 1001 final Runnable updatePingResults = new Runnable() { 1002 public void run() { 1003 mPingHostnameV4.setText(mPingHostnameResultV4); 1004 mPingHostnameV6.setText(mPingHostnameResultV6); 1005 mHttpClientTest.setText(mHttpClientTestResult); 1006 } 1007 }; 1008 1009 Thread hostname = new Thread() { 1010 @Override 1011 public void run() { 1012 pingHostname(); 1013 mHandler.post(updatePingResults); 1014 } 1015 }; 1016 hostname.start(); 1017 1018 Thread httpClient = new Thread() { 1019 @Override 1020 public void run() { 1021 httpClientTest(); 1022 mHandler.post(updatePingResults); 1023 } 1024 }; 1025 httpClient.start(); 1026 } 1027 1028 private MenuItem.OnMenuItemClickListener mViewADNCallback = new MenuItem.OnMenuItemClickListener() { 1029 public boolean onMenuItemClick(MenuItem item) { 1030 Intent intent = new Intent(Intent.ACTION_VIEW); 1031 // XXX We need to specify the component here because if we don't 1032 // the activity manager will try to resolve the type by calling 1033 // the content provider, which causes it to be loaded in a process 1034 // other than the Dialer process, which causes a lot of stuff to 1035 // break. 1036 intent.setClassName("com.android.phone", 1037 "com.android.phone.SimContacts"); 1038 startActivity(intent); 1039 return true; 1040 } 1041 }; 1042 1043 private MenuItem.OnMenuItemClickListener mViewFDNCallback = new MenuItem.OnMenuItemClickListener() { 1044 public boolean onMenuItemClick(MenuItem item) { 1045 Intent intent = new Intent(Intent.ACTION_VIEW); 1046 // XXX We need to specify the component here because if we don't 1047 // the activity manager will try to resolve the type by calling 1048 // the content provider, which causes it to be loaded in a process 1049 // other than the Dialer process, which causes a lot of stuff to 1050 // break. 1051 intent.setClassName("com.android.phone", 1052 "com.android.phone.settings.fdn.FdnList"); 1053 startActivity(intent); 1054 return true; 1055 } 1056 }; 1057 1058 private MenuItem.OnMenuItemClickListener mViewSDNCallback = new MenuItem.OnMenuItemClickListener() { 1059 public boolean onMenuItemClick(MenuItem item) { 1060 Intent intent = new Intent( 1061 Intent.ACTION_VIEW, Uri.parse("content://icc/sdn")); 1062 // XXX We need to specify the component here because if we don't 1063 // the activity manager will try to resolve the type by calling 1064 // the content provider, which causes it to be loaded in a process 1065 // other than the Dialer process, which causes a lot of stuff to 1066 // break. 1067 intent.setClassName("com.android.phone", 1068 "com.android.phone.ADNList"); 1069 startActivity(intent); 1070 return true; 1071 } 1072 }; 1073 1074 private MenuItem.OnMenuItemClickListener mGetImsStatus = new MenuItem.OnMenuItemClickListener() { 1075 public boolean onMenuItemClick(MenuItem item) { 1076 boolean isImsRegistered = phone.isImsRegistered(); 1077 boolean availableVolte = phone.isVolteEnabled(); 1078 boolean availableWfc = phone.isWifiCallingEnabled(); 1079 boolean availableVt = phone.isVideoEnabled(); 1080 boolean availableUt = phone.isUtEnabled(); 1081 1082 final String imsRegString = isImsRegistered ? 1083 getString(R.string.radio_info_ims_reg_status_registered) : 1084 getString(R.string.radio_info_ims_reg_status_not_registered); 1085 1086 final String available = getString(R.string.radio_info_ims_feature_status_available); 1087 final String unavailable = getString( 1088 R.string.radio_info_ims_feature_status_unavailable); 1089 1090 String imsStatus = getString(R.string.radio_info_ims_reg_status, 1091 imsRegString, 1092 availableVolte ? available : unavailable, 1093 availableWfc ? available : unavailable, 1094 availableVt ? available : unavailable, 1095 availableUt ? available : unavailable); 1096 1097 AlertDialog imsDialog = new AlertDialog.Builder(RadioInfo.this) 1098 .setMessage(imsStatus) 1099 .setTitle(getString(R.string.radio_info_ims_reg_status_title)) 1100 .create(); 1101 1102 imsDialog.show(); 1103 1104 return true; 1105 } 1106 }; 1107 1108 private MenuItem.OnMenuItemClickListener mSelectBandCallback = new MenuItem.OnMenuItemClickListener() { 1109 public boolean onMenuItemClick(MenuItem item) { 1110 Intent intent = new Intent(); 1111 intent.setClass(RadioInfo.this, BandMode.class); 1112 startActivity(intent); 1113 return true; 1114 } 1115 }; 1116 1117 private MenuItem.OnMenuItemClickListener mToggleData = new MenuItem.OnMenuItemClickListener() { 1118 public boolean onMenuItemClick(MenuItem item) { 1119 int state = mTelephonyManager.getDataState(); 1120 switch (state) { 1121 case TelephonyManager.DATA_CONNECTED: 1122 //FIXME: Replace with a TelephonyManager call 1123 phone.setDataEnabled(false); 1124 break; 1125 case TelephonyManager.DATA_DISCONNECTED: 1126 //FIXME: Replace with a TelephonyManager call 1127 phone.setDataEnabled(true); 1128 break; 1129 default: 1130 // do nothing 1131 break; 1132 } 1133 return true; 1134 } 1135 }; 1136 1137 private boolean isRadioOn() { 1138 //FIXME: Replace with a TelephonyManager call 1139 return phone.getServiceState().getState() != ServiceState.STATE_POWER_OFF; 1140 } 1141 1142 private void updateRadioPowerState() { 1143 //delightful hack to prevent on-checked-changed calls from 1144 //actually forcing the radio preference to its transient/current value. 1145 radioPowerOnSwitch.setOnCheckedChangeListener(null); 1146 radioPowerOnSwitch.setChecked(isRadioOn()); 1147 radioPowerOnSwitch.setOnCheckedChangeListener(mRadioPowerOnChangeListener); 1148 } 1149 1150 void setImsVolteProvisionedState(boolean state) { 1151 Log.d(TAG, "setImsVolteProvisioned state: " + ((state)? "on":"off")); 1152 setImsConfigProvisionedState(IMS_VOLTE_PROVISIONED_CONFIG_ID, state); 1153 } 1154 1155 void setImsVtProvisionedState(boolean state) { 1156 Log.d(TAG, "setImsVtProvisioned() state: " + ((state)? "on":"off")); 1157 setImsConfigProvisionedState(IMS_VT_PROVISIONED_CONFIG_ID, state); 1158 } 1159 1160 void setImsWfcProvisionedState(boolean state) { 1161 Log.d(TAG, "setImsWfcProvisioned() state: " + ((state)? "on":"off")); 1162 setImsConfigProvisionedState(IMS_WFC_PROVISIONED_CONFIG_ID, state); 1163 } 1164 1165 void setImsConfigProvisionedState(int configItem, boolean state) { 1166 if (phone != null && mImsManager != null) { 1167 QueuedWork.queue(new Runnable() { 1168 public void run() { 1169 try { 1170 mImsManager.getConfigInterface().setProvisionedValue( 1171 configItem, 1172 state? 1 : 0); 1173 } catch (ImsException e) { 1174 Log.e(TAG, "setImsConfigProvisioned() exception:", e); 1175 } 1176 } 1177 }, false); 1178 } 1179 } 1180 1181 OnCheckedChangeListener mRadioPowerOnChangeListener = new OnCheckedChangeListener() { 1182 @Override 1183 public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { 1184 log("toggle radio power: currently " + (isRadioOn()?"on":"off")); 1185 phone.setRadioPower(isChecked); 1186 } 1187 }; 1188 1189 private boolean isImsVolteProvisioned() { 1190 if (phone != null && mImsManager != null) { 1191 return mImsManager.isVolteEnabledByPlatform(phone.getContext()) 1192 && mImsManager.isVolteProvisionedOnDevice(phone.getContext()); 1193 } 1194 return false; 1195 } 1196 1197 OnCheckedChangeListener mImsVolteCheckedChangeListener = new OnCheckedChangeListener() { 1198 @Override 1199 public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { 1200 setImsVolteProvisionedState(isChecked); 1201 } 1202 }; 1203 1204 private boolean isImsVtProvisioned() { 1205 if (phone != null && mImsManager != null) { 1206 return mImsManager.isVtEnabledByPlatform(phone.getContext()) 1207 && mImsManager.isVtProvisionedOnDevice(phone.getContext()); 1208 } 1209 return false; 1210 } 1211 1212 OnCheckedChangeListener mImsVtCheckedChangeListener = new OnCheckedChangeListener() { 1213 @Override 1214 public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { 1215 setImsVtProvisionedState(isChecked); 1216 } 1217 }; 1218 1219 private boolean isImsWfcProvisioned() { 1220 if (phone != null && mImsManager != null) { 1221 return mImsManager.isWfcEnabledByPlatform(phone.getContext()) 1222 && mImsManager.isWfcProvisionedOnDevice(phone.getContext()); 1223 } 1224 return false; 1225 } 1226 1227 OnCheckedChangeListener mImsWfcCheckedChangeListener = new OnCheckedChangeListener() { 1228 @Override 1229 public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { 1230 setImsWfcProvisionedState(isChecked); 1231 } 1232 }; 1233 1234 private void updateImsProvisionedState() { 1235 log("updateImsProvisionedState isImsVolteProvisioned()=" + isImsVolteProvisioned()); 1236 //delightful hack to prevent on-checked-changed calls from 1237 //actually forcing the ims provisioning to its transient/current value. 1238 imsVolteProvisionedSwitch.setOnCheckedChangeListener(null); 1239 imsVolteProvisionedSwitch.setChecked(isImsVolteProvisioned()); 1240 imsVolteProvisionedSwitch.setOnCheckedChangeListener(mImsVolteCheckedChangeListener); 1241 imsVolteProvisionedSwitch.setEnabled( 1242 mImsManager.isVolteEnabledByPlatform(phone.getContext())); 1243 1244 imsVtProvisionedSwitch.setOnCheckedChangeListener(null); 1245 imsVtProvisionedSwitch.setChecked(isImsVtProvisioned()); 1246 imsVtProvisionedSwitch.setOnCheckedChangeListener(mImsVtCheckedChangeListener); 1247 imsVtProvisionedSwitch.setEnabled( 1248 mImsManager.isVtEnabledByPlatform(phone.getContext())); 1249 1250 imsWfcProvisionedSwitch.setOnCheckedChangeListener(null); 1251 imsWfcProvisionedSwitch.setChecked(isImsWfcProvisioned()); 1252 imsWfcProvisionedSwitch.setOnCheckedChangeListener(mImsWfcCheckedChangeListener); 1253 imsWfcProvisionedSwitch.setEnabled( 1254 mImsManager.isWfcEnabledByPlatform(phone.getContext())); 1255 } 1256 1257 OnClickListener mDnsCheckButtonHandler = new OnClickListener() { 1258 public void onClick(View v) { 1259 //FIXME: Replace with a TelephonyManager call 1260 phone.disableDnsCheck(!phone.isDnsCheckDisabled()); 1261 updateDnsCheckState(); 1262 } 1263 }; 1264 1265 OnClickListener mOemInfoButtonHandler = new OnClickListener() { 1266 public void onClick(View v) { 1267 Intent intent = new Intent("com.android.settings.OEM_RADIO_INFO"); 1268 try { 1269 startActivity(intent); 1270 } catch (android.content.ActivityNotFoundException ex) { 1271 log("OEM-specific Info/Settings Activity Not Found : " + ex); 1272 // If the activity does not exist, there are no OEM 1273 // settings, and so we can just do nothing... 1274 } 1275 } 1276 }; 1277 1278 OnClickListener mPingButtonHandler = new OnClickListener() { 1279 public void onClick(View v) { 1280 updatePingState(); 1281 } 1282 }; 1283 1284 OnClickListener mUpdateSmscButtonHandler = new OnClickListener() { 1285 public void onClick(View v) { 1286 updateSmscButton.setEnabled(false); 1287 phone.setSmscAddress(smsc.getText().toString(), 1288 mHandler.obtainMessage(EVENT_UPDATE_SMSC_DONE)); 1289 } 1290 }; 1291 1292 OnClickListener mRefreshSmscButtonHandler = new OnClickListener() { 1293 public void onClick(View v) { 1294 refreshSmsc(); 1295 } 1296 }; 1297 1298 AdapterView.OnItemSelectedListener mPreferredNetworkHandler = 1299 new AdapterView.OnItemSelectedListener() { 1300 1301 public void onItemSelected(AdapterView parent, View v, int pos, long id) { 1302 if (mPreferredNetworkTypeResult != pos && pos >= 0 1303 && pos <= mPreferredNetworkLabels.length - 2) { 1304 mPreferredNetworkTypeResult = pos; 1305 Message msg = mHandler.obtainMessage(EVENT_SET_PREFERRED_TYPE_DONE); 1306 phone.setPreferredNetworkType(mPreferredNetworkTypeResult, msg); 1307 } 1308 } 1309 1310 public void onNothingSelected(AdapterView parent) { 1311 } 1312 }; 1313 1314 AdapterView.OnItemSelectedListener mCellInfoRefreshRateHandler = 1315 new AdapterView.OnItemSelectedListener() { 1316 1317 public void onItemSelected(AdapterView parent, View v, int pos, long id) { 1318 mCellInfoRefreshRateIndex = pos; 1319 mTelephonyManager.setCellInfoListRate(mCellInfoRefreshRates[pos]); 1320 updateAllCellInfo(); 1321 } 1322 1323 public void onNothingSelected(AdapterView parent) { 1324 } 1325 }; 1326 1327 } 1328
