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; 18 19 import android.app.Activity; 20 import android.app.Dialog; 21 import android.bluetooth.BluetoothAdapter; 22 import android.bluetooth.BluetoothPan; 23 import android.bluetooth.BluetoothProfile; 24 import android.content.BroadcastReceiver; 25 import android.content.Context; 26 import android.content.DialogInterface; 27 import android.content.Intent; 28 import android.content.IntentFilter; 29 import android.content.pm.PackageManager; 30 import android.hardware.usb.UsbManager; 31 import android.net.ConnectivityManager; 32 import android.net.wifi.WifiConfiguration; 33 import android.net.wifi.WifiManager; 34 import android.os.Bundle; 35 import android.os.Environment; 36 import android.os.Handler; 37 import android.os.UserManager; 38 import android.support.v14.preference.SwitchPreference; 39 import android.support.v7.preference.Preference; 40 import android.util.Log; 41 42 import com.android.internal.logging.nano.MetricsProto.MetricsEvent; 43 import com.android.settings.datausage.DataSaverBackend; 44 import com.android.settings.wifi.WifiApDialog; 45 import com.android.settings.wifi.WifiApEnabler; 46 import com.android.settings.wifi.tether.WifiTetherPreferenceController; 47 import com.android.settings.wifi.tether.WifiTetherSettings; 48 import com.android.settingslib.TetherUtil; 49 50 import java.lang.ref.WeakReference; 51 import java.util.ArrayList; 52 import java.util.concurrent.atomic.AtomicReference; 53 54 import static android.net.ConnectivityManager.TETHERING_BLUETOOTH; 55 import static android.net.ConnectivityManager.TETHERING_USB; 56 import static android.net.ConnectivityManager.TETHERING_WIFI; 57 58 /* 59 * Displays preferences for Tethering. 60 */ 61 public class TetherSettings extends RestrictedSettingsFragment 62 implements DialogInterface.OnClickListener, Preference.OnPreferenceChangeListener, 63 DataSaverBackend.Listener { 64 65 private static final String USB_TETHER_SETTINGS = "usb_tether_settings"; 66 private static final String ENABLE_WIFI_AP = "enable_wifi_ap"; 67 private static final String ENABLE_BLUETOOTH_TETHERING = "enable_bluetooth_tethering"; 68 private static final String DATA_SAVER_FOOTER = "disabled_on_data_saver"; 69 70 private static final int DIALOG_AP_SETTINGS = 1; 71 72 private static final String TAG = "TetheringSettings"; 73 74 private SwitchPreference mUsbTether; 75 76 private WifiApEnabler mWifiApEnabler; 77 private SwitchPreference mEnableWifiAp; 78 79 private SwitchPreference mBluetoothTether; 80 81 private BroadcastReceiver mTetherChangeReceiver; 82 83 private String[] mUsbRegexs; 84 85 private String[] mWifiRegexs; 86 87 private String[] mBluetoothRegexs; 88 private AtomicReference<BluetoothPan> mBluetoothPan = new AtomicReference<BluetoothPan>(); 89 90 private Handler mHandler = new Handler(); 91 private OnStartTetheringCallback mStartTetheringCallback; 92 93 private static final String WIFI_AP_SSID_AND_SECURITY = "wifi_ap_ssid_and_security"; 94 private static final int CONFIG_SUBTEXT = R.string.wifi_tether_configure_subtext; 95 96 private String[] mSecurityType; 97 private Preference mCreateNetwork; 98 99 private WifiApDialog mDialog; 100 private WifiManager mWifiManager; 101 private WifiConfiguration mWifiConfig = null; 102 private ConnectivityManager mCm; 103 104 private WifiTetherPreferenceController mWifiTetherPreferenceController; 105 106 private boolean mRestartWifiApAfterConfigChange; 107 108 private boolean mUsbConnected; 109 private boolean mMassStorageActive; 110 111 private boolean mBluetoothEnableForTether; 112 private boolean mUnavailable; 113 114 private DataSaverBackend mDataSaverBackend; 115 private boolean mDataSaverEnabled; 116 private Preference mDataSaverFooter; 117 118 @Override 119 public int getMetricsCategory() { 120 return MetricsEvent.TETHER; 121 } 122 123 public TetherSettings() { 124 super(UserManager.DISALLOW_CONFIG_TETHERING); 125 } 126 127 @Override 128 public void onAttach(Context context) { 129 super.onAttach(context); 130 mWifiTetherPreferenceController = 131 new WifiTetherPreferenceController(context, getLifecycle()); 132 } 133 134 @Override 135 public void onCreate(Bundle icicle) { 136 super.onCreate(icicle); 137 138 addPreferencesFromResource(R.xml.tether_prefs); 139 mFooterPreferenceMixin.createFooterPreference() 140 .setTitle(R.string.tethering_footer_info); 141 142 mDataSaverBackend = new DataSaverBackend(getContext()); 143 mDataSaverEnabled = mDataSaverBackend.isDataSaverEnabled(); 144 mDataSaverFooter = findPreference(DATA_SAVER_FOOTER); 145 146 setIfOnlyAvailableForAdmins(true); 147 if (isUiRestricted()) { 148 mUnavailable = true; 149 getPreferenceScreen().removeAll(); 150 return; 151 } 152 153 final Activity activity = getActivity(); 154 BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter(); 155 if (adapter != null) { 156 adapter.getProfileProxy(activity.getApplicationContext(), mProfileServiceListener, 157 BluetoothProfile.PAN); 158 } 159 160 mEnableWifiAp = 161 (SwitchPreference) findPreference(ENABLE_WIFI_AP); 162 163 Preference wifiApSettings = findPreference(WIFI_AP_SSID_AND_SECURITY); 164 mUsbTether = (SwitchPreference) findPreference(USB_TETHER_SETTINGS); 165 mBluetoothTether = (SwitchPreference) findPreference(ENABLE_BLUETOOTH_TETHERING); 166 167 mDataSaverBackend.addListener(this); 168 169 mCm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); 170 mWifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE); 171 172 mUsbRegexs = mCm.getTetherableUsbRegexs(); 173 mWifiRegexs = mCm.getTetherableWifiRegexs(); 174 mBluetoothRegexs = mCm.getTetherableBluetoothRegexs(); 175 176 final boolean usbAvailable = mUsbRegexs.length != 0; 177 final boolean wifiAvailable = mWifiRegexs.length != 0; 178 final boolean bluetoothAvailable = mBluetoothRegexs.length != 0; 179 180 if (!usbAvailable || Utils.isMonkeyRunning()) { 181 getPreferenceScreen().removePreference(mUsbTether); 182 } 183 184 mWifiTetherPreferenceController.displayPreference(getPreferenceScreen()); 185 if (WifiTetherSettings.isTetherSettingPageEnabled()) { 186 removePreference(ENABLE_WIFI_AP); 187 removePreference(WIFI_AP_SSID_AND_SECURITY); 188 } else { 189 if (wifiAvailable && !Utils.isMonkeyRunning()) { 190 mWifiApEnabler = new WifiApEnabler(activity, mDataSaverBackend, mEnableWifiAp); 191 initWifiTethering(); 192 } else { 193 getPreferenceScreen().removePreference(mEnableWifiAp); 194 getPreferenceScreen().removePreference(wifiApSettings); 195 } 196 } 197 198 if (!bluetoothAvailable) { 199 getPreferenceScreen().removePreference(mBluetoothTether); 200 } else { 201 BluetoothPan pan = mBluetoothPan.get(); 202 if (pan != null && pan.isTetheringOn()) { 203 mBluetoothTether.setChecked(true); 204 } else { 205 mBluetoothTether.setChecked(false); 206 } 207 } 208 // Set initial state based on Data Saver mode. 209 onDataSaverChanged(mDataSaverBackend.isDataSaverEnabled()); 210 } 211 212 @Override 213 public void onDestroy() { 214 mDataSaverBackend.remListener(this); 215 216 BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter(); 217 BluetoothProfile profile = mBluetoothPan.getAndSet(null); 218 if (profile != null && adapter != null) { 219 adapter.closeProfileProxy(BluetoothProfile.PAN, profile); 220 } 221 222 super.onDestroy(); 223 } 224 225 @Override 226 public void onDataSaverChanged(boolean isDataSaving) { 227 mDataSaverEnabled = isDataSaving; 228 mEnableWifiAp.setEnabled(!mDataSaverEnabled); 229 mUsbTether.setEnabled(!mDataSaverEnabled); 230 mBluetoothTether.setEnabled(!mDataSaverEnabled); 231 mDataSaverFooter.setVisible(mDataSaverEnabled); 232 } 233 234 @Override 235 public void onWhitelistStatusChanged(int uid, boolean isWhitelisted) { 236 } 237 238 @Override 239 public void onBlacklistStatusChanged(int uid, boolean isBlacklisted) { 240 } 241 242 private void initWifiTethering() { 243 final Activity activity = getActivity(); 244 mWifiConfig = mWifiManager.getWifiApConfiguration(); 245 mSecurityType = getResources().getStringArray(R.array.wifi_ap_security); 246 247 mCreateNetwork = findPreference(WIFI_AP_SSID_AND_SECURITY); 248 249 mRestartWifiApAfterConfigChange = false; 250 251 if (mWifiConfig == null) { 252 final String s = activity.getString( 253 com.android.internal.R.string.wifi_tether_configure_ssid_default); 254 mCreateNetwork.setSummary(String.format(activity.getString(CONFIG_SUBTEXT), 255 s, mSecurityType[WifiApDialog.OPEN_INDEX])); 256 } else { 257 int index = WifiApDialog.getSecurityTypeIndex(mWifiConfig); 258 mCreateNetwork.setSummary(String.format(activity.getString(CONFIG_SUBTEXT), 259 mWifiConfig.SSID, 260 mSecurityType[index])); 261 } 262 } 263 264 @Override 265 public Dialog onCreateDialog(int id) { 266 if (id == DIALOG_AP_SETTINGS) { 267 final Activity activity = getActivity(); 268 mDialog = new WifiApDialog(activity, this, mWifiConfig); 269 return mDialog; 270 } 271 272 return null; 273 } 274 275 @Override 276 public int getDialogMetricsCategory(int dialogId) { 277 if (dialogId == DIALOG_AP_SETTINGS) { 278 return MetricsEvent.DIALOG_AP_SETTINGS; 279 } 280 return 0; 281 } 282 283 private class TetherChangeReceiver extends BroadcastReceiver { 284 @Override 285 public void onReceive(Context content, Intent intent) { 286 String action = intent.getAction(); 287 if (action.equals(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)) { 288 // TODO - this should understand the interface types 289 ArrayList<String> available = intent.getStringArrayListExtra( 290 ConnectivityManager.EXTRA_AVAILABLE_TETHER); 291 ArrayList<String> active = intent.getStringArrayListExtra( 292 ConnectivityManager.EXTRA_ACTIVE_TETHER); 293 ArrayList<String> errored = intent.getStringArrayListExtra( 294 ConnectivityManager.EXTRA_ERRORED_TETHER); 295 updateState(available.toArray(new String[available.size()]), 296 active.toArray(new String[active.size()]), 297 errored.toArray(new String[errored.size()])); 298 if (mWifiManager.getWifiApState() == WifiManager.WIFI_AP_STATE_DISABLED 299 && mRestartWifiApAfterConfigChange) { 300 mRestartWifiApAfterConfigChange = false; 301 Log.d(TAG, "Restarting WifiAp due to prior config change."); 302 startTethering(TETHERING_WIFI); 303 } 304 } else if (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)) { 305 int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_AP_STATE, 0); 306 if (state == WifiManager.WIFI_AP_STATE_DISABLED 307 && mRestartWifiApAfterConfigChange) { 308 mRestartWifiApAfterConfigChange = false; 309 Log.d(TAG, "Restarting WifiAp due to prior config change."); 310 startTethering(TETHERING_WIFI); 311 } 312 } else if (action.equals(Intent.ACTION_MEDIA_SHARED)) { 313 mMassStorageActive = true; 314 updateState(); 315 } else if (action.equals(Intent.ACTION_MEDIA_UNSHARED)) { 316 mMassStorageActive = false; 317 updateState(); 318 } else if (action.equals(UsbManager.ACTION_USB_STATE)) { 319 mUsbConnected = intent.getBooleanExtra(UsbManager.USB_CONNECTED, false); 320 updateState(); 321 } else if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) { 322 if (mBluetoothEnableForTether) { 323 switch (intent 324 .getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)) { 325 case BluetoothAdapter.STATE_ON: 326 startTethering(TETHERING_BLUETOOTH); 327 mBluetoothEnableForTether = false; 328 break; 329 330 case BluetoothAdapter.STATE_OFF: 331 case BluetoothAdapter.ERROR: 332 mBluetoothEnableForTether = false; 333 break; 334 335 default: 336 // ignore transition states 337 } 338 } 339 updateState(); 340 } 341 } 342 } 343 344 @Override 345 public void onStart() { 346 super.onStart(); 347 348 if (mUnavailable) { 349 if (!isUiRestrictedByOnlyAdmin()) { 350 getEmptyTextView().setText(R.string.tethering_settings_not_available); 351 } 352 getPreferenceScreen().removeAll(); 353 return; 354 } 355 356 final Activity activity = getActivity(); 357 358 mStartTetheringCallback = new OnStartTetheringCallback(this); 359 360 mMassStorageActive = Environment.MEDIA_SHARED.equals(Environment.getExternalStorageState()); 361 mTetherChangeReceiver = new TetherChangeReceiver(); 362 IntentFilter filter = new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED); 363 filter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION); 364 Intent intent = activity.registerReceiver(mTetherChangeReceiver, filter); 365 366 filter = new IntentFilter(); 367 filter.addAction(UsbManager.ACTION_USB_STATE); 368 activity.registerReceiver(mTetherChangeReceiver, filter); 369 370 filter = new IntentFilter(); 371 filter.addAction(Intent.ACTION_MEDIA_SHARED); 372 filter.addAction(Intent.ACTION_MEDIA_UNSHARED); 373 filter.addDataScheme("file"); 374 activity.registerReceiver(mTetherChangeReceiver, filter); 375 376 filter = new IntentFilter(); 377 filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED); 378 activity.registerReceiver(mTetherChangeReceiver, filter); 379 380 if (intent != null) mTetherChangeReceiver.onReceive(activity, intent); 381 if (mWifiApEnabler != null) { 382 mEnableWifiAp.setOnPreferenceChangeListener(this); 383 mWifiApEnabler.resume(); 384 } 385 386 updateState(); 387 } 388 389 @Override 390 public void onStop() { 391 super.onStop(); 392 393 if (mUnavailable) { 394 return; 395 } 396 getActivity().unregisterReceiver(mTetherChangeReceiver); 397 mTetherChangeReceiver = null; 398 mStartTetheringCallback = null; 399 if (mWifiApEnabler != null) { 400 mEnableWifiAp.setOnPreferenceChangeListener(null); 401 mWifiApEnabler.pause(); 402 } 403 } 404 405 private void updateState() { 406 String[] available = mCm.getTetherableIfaces(); 407 String[] tethered = mCm.getTetheredIfaces(); 408 String[] errored = mCm.getTetheringErroredIfaces(); 409 updateState(available, tethered, errored); 410 } 411 412 private void updateState(String[] available, String[] tethered, 413 String[] errored) { 414 updateUsbState(available, tethered, errored); 415 updateBluetoothState(); 416 } 417 418 419 private void updateUsbState(String[] available, String[] tethered, 420 String[] errored) { 421 boolean usbAvailable = mUsbConnected && !mMassStorageActive; 422 int usbError = ConnectivityManager.TETHER_ERROR_NO_ERROR; 423 for (String s : available) { 424 for (String regex : mUsbRegexs) { 425 if (s.matches(regex)) { 426 if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) { 427 usbError = mCm.getLastTetherError(s); 428 } 429 } 430 } 431 } 432 boolean usbTethered = false; 433 for (String s : tethered) { 434 for (String regex : mUsbRegexs) { 435 if (s.matches(regex)) usbTethered = true; 436 } 437 } 438 boolean usbErrored = false; 439 for (String s: errored) { 440 for (String regex : mUsbRegexs) { 441 if (s.matches(regex)) usbErrored = true; 442 } 443 } 444 445 if (usbTethered) { 446 mUsbTether.setEnabled(!mDataSaverEnabled); 447 mUsbTether.setChecked(true); 448 } else if (usbAvailable) { 449 mUsbTether.setEnabled(!mDataSaverEnabled); 450 mUsbTether.setChecked(false); 451 } else { 452 mUsbTether.setEnabled(false); 453 mUsbTether.setChecked(false); 454 } 455 } 456 457 private void updateBluetoothState() { 458 BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter(); 459 if (adapter == null) { 460 return; 461 } 462 int btState = adapter.getState(); 463 if (btState == BluetoothAdapter.STATE_TURNING_OFF) { 464 mBluetoothTether.setEnabled(false); 465 } else if (btState == BluetoothAdapter.STATE_TURNING_ON) { 466 mBluetoothTether.setEnabled(false); 467 } else { 468 BluetoothPan bluetoothPan = mBluetoothPan.get(); 469 if (btState == BluetoothAdapter.STATE_ON && bluetoothPan != null 470 && bluetoothPan.isTetheringOn()) { 471 mBluetoothTether.setChecked(true); 472 mBluetoothTether.setEnabled(!mDataSaverEnabled); 473 } else { 474 mBluetoothTether.setEnabled(!mDataSaverEnabled); 475 mBluetoothTether.setChecked(false); 476 } 477 } 478 } 479 480 @Override 481 public boolean onPreferenceChange(Preference preference, Object value) { 482 boolean enable = (Boolean) value; 483 484 if (enable) { 485 startTethering(TETHERING_WIFI); 486 } else { 487 mCm.stopTethering(TETHERING_WIFI); 488 } 489 return false; 490 } 491 492 public static boolean isProvisioningNeededButUnavailable(Context context) { 493 return (TetherUtil.isProvisioningNeeded(context) 494 && !isIntentAvailable(context)); 495 } 496 497 private static boolean isIntentAvailable(Context context) { 498 String[] provisionApp = context.getResources().getStringArray( 499 com.android.internal.R.array.config_mobile_hotspot_provision_app); 500 if (provisionApp.length < 2) { 501 return false; 502 } 503 final PackageManager packageManager = context.getPackageManager(); 504 Intent intent = new Intent(Intent.ACTION_MAIN); 505 intent.setClassName(provisionApp[0], provisionApp[1]); 506 507 return (packageManager.queryIntentActivities(intent, 508 PackageManager.MATCH_DEFAULT_ONLY).size() > 0); 509 } 510 511 private void startTethering(int choice) { 512 if (choice == TETHERING_BLUETOOTH) { 513 // Turn on Bluetooth first. 514 BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter(); 515 if (adapter.getState() == BluetoothAdapter.STATE_OFF) { 516 mBluetoothEnableForTether = true; 517 adapter.enable(); 518 mBluetoothTether.setSummary(R.string.bluetooth_turning_on); 519 mBluetoothTether.setEnabled(false); 520 return; 521 } 522 } 523 524 mCm.startTethering(choice, true, mStartTetheringCallback, mHandler); 525 } 526 527 @Override 528 public boolean onPreferenceTreeClick(Preference preference) { 529 if (preference == mUsbTether) { 530 if (mUsbTether.isChecked()) { 531 startTethering(TETHERING_USB); 532 } else { 533 mCm.stopTethering(TETHERING_USB); 534 } 535 } else if (preference == mBluetoothTether) { 536 if (mBluetoothTether.isChecked()) { 537 startTethering(TETHERING_BLUETOOTH); 538 } else { 539 mCm.stopTethering(TETHERING_BLUETOOTH); 540 // No ACTION_TETHER_STATE_CHANGED is fired or bluetooth unless a device is 541 // connected. Need to update state manually. 542 updateState(); 543 } 544 } else if (preference == mCreateNetwork) { 545 showDialog(DIALOG_AP_SETTINGS); 546 } 547 548 return super.onPreferenceTreeClick(preference); 549 } 550 551 public void onClick(DialogInterface dialogInterface, int button) { 552 if (button == DialogInterface.BUTTON_POSITIVE) { 553 mWifiConfig = mDialog.getConfig(); 554 if (mWifiConfig != null) { 555 /** 556 * if soft AP is stopped, bring up 557 * else restart with new config 558 * TODO: update config on a running access point when framework support is added 559 */ 560 if (mWifiManager.getWifiApState() == WifiManager.WIFI_AP_STATE_ENABLED) { 561 Log.d("TetheringSettings", 562 "Wifi AP config changed while enabled, stop and restart"); 563 mRestartWifiApAfterConfigChange = true; 564 mCm.stopTethering(TETHERING_WIFI); 565 } 566 mWifiManager.setWifiApConfiguration(mWifiConfig); 567 int index = WifiApDialog.getSecurityTypeIndex(mWifiConfig); 568 mCreateNetwork.setSummary(String.format(getActivity().getString(CONFIG_SUBTEXT), 569 mWifiConfig.SSID, 570 mSecurityType[index])); 571 } 572 } 573 } 574 575 @Override 576 public int getHelpResource() { 577 return R.string.help_url_tether; 578 } 579 580 private BluetoothProfile.ServiceListener mProfileServiceListener = 581 new BluetoothProfile.ServiceListener() { 582 public void onServiceConnected(int profile, BluetoothProfile proxy) { 583 mBluetoothPan.set((BluetoothPan) proxy); 584 } 585 public void onServiceDisconnected(int profile) { 586 mBluetoothPan.set(null); 587 } 588 }; 589 590 private static final class OnStartTetheringCallback extends 591 ConnectivityManager.OnStartTetheringCallback { 592 final WeakReference<TetherSettings> mTetherSettings; 593 594 OnStartTetheringCallback(TetherSettings settings) { 595 mTetherSettings = new WeakReference<TetherSettings>(settings); 596 } 597 598 @Override 599 public void onTetheringStarted() { 600 update(); 601 } 602 603 @Override 604 public void onTetheringFailed() { 605 update(); 606 } 607 608 private void update() { 609 TetherSettings settings = mTetherSettings.get(); 610 if (settings != null) { 611 settings.updateState(); 612 } 613 } 614 } 615 } 616
