src/com/android/settings/TetherSettings.java

   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 com.android.settings.wifi.WifiApEnabler;
  20
  21 import android.app.AlertDialog;
  22 import android.os.Bundle;
  23 import android.os.SystemProperties;
  24 import android.content.BroadcastReceiver;
  25 import android.content.Context;
  26 import android.content.Intent;
  27 import android.content.IntentFilter;
  28 import android.net.ConnectivityManager;
  29 import android.os.Environment;
  30 import android.preference.CheckBoxPreference;
  31 import android.preference.Preference;
  32 import android.preference.PreferenceActivity;
  33 import android.preference.PreferenceScreen;
  34 import android.provider.Settings;
  35 import android.util.Log;
  36 import android.webkit.WebView;
  37
  38 import java.util.ArrayList;
  39 import java.util.Locale;
  40
  41 /*
  42  * Displays preferences for Tethering.
  43  */
  44 public class TetherSettings extends PreferenceActivity {
  45     private static final String USB_TETHER_SETTINGS = "usb_tether_settings";
  46     private static final String ENABLE_WIFI_AP = "enable_wifi_ap";
  47     private static final String WIFI_AP_SETTINGS = "wifi_ap_settings";
  48     private static final String TETHERING_HELP = "tethering_help";
  49     private static final String USB_HELP_MODIFIER = "usb_";
  50     private static final String WIFI_HELP_MODIFIER = "wifi_";
  51     private static final String HELP_URL = "file:///android_asset/html/%y_%z/tethering_%xhelp.html";
  52
  53     private CheckBoxPreference mUsbTether;
  54
  55     private CheckBoxPreference mEnableWifiAp;
  56     private PreferenceScreen mWifiApSettings;
  57     private WifiApEnabler mWifiApEnabler;
  58     private PreferenceScreen mTetherHelp;
  59
  60     private BroadcastReceiver mTetherChangeReceiver;
  61
  62     private String[] mUsbRegexs;
  63     private ArrayList mUsbIfaces;
  64
  65     private String[] mWifiRegexs;
  66
  67     @Override
  68     protected void onCreate(Bundle icicle) {
  69         super.onCreate(icicle);
  70
  71         addPreferencesFromResource(R.xml.tether_prefs);
  72
  73         mEnableWifiAp = (CheckBoxPreference) findPreference(ENABLE_WIFI_AP);
  74         mWifiApSettings = (PreferenceScreen) findPreference(WIFI_AP_SETTINGS);
  75         mUsbTether = (CheckBoxPreference) findPreference(USB_TETHER_SETTINGS);
  76         mTetherHelp = (PreferenceScreen) findPreference(TETHERING_HELP);
  77
  78         ConnectivityManager cm =
  79                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
  80
  81         mUsbRegexs = cm.getTetherableUsbRegexs();
  82         if (mUsbRegexs.length == 0) {
  83             getPreferenceScreen().removePreference(mUsbTether);
  84         }
  85
  86         mWifiRegexs = cm.getTetherableWifiRegexs();
  87         if (mWifiRegexs.length == 0) {
  88             getPreferenceScreen().removePreference(mEnableWifiAp);
  89             getPreferenceScreen().removePreference(mWifiApSettings);
  90         }
  91         mWifiApEnabler = new WifiApEnabler(this, mEnableWifiAp);
  92     }
  93
  94
  95     private class TetherChangeReceiver extends BroadcastReceiver {
  96         public void onReceive(Context content, Intent intent) {
  97             if (intent.getAction().equals(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)) {
  98                 // TODO - this should understand the interface types
  99                 ArrayList<String> available = intent.getStringArrayListExtra(
 100                         ConnectivityManager.EXTRA_AVAILABLE_TETHER);
 101                 ArrayList<String> active = intent.getStringArrayListExtra(
 102                         ConnectivityManager.EXTRA_ACTIVE_TETHER);
 103                 ArrayList<String> errored = intent.getStringArrayListExtra(
 104                         ConnectivityManager.EXTRA_ERRORED_TETHER);
 105                 updateState(available.toArray(), active.toArray(), errored.toArray());
 106             } else if (intent.getAction().equals(Intent.ACTION_MEDIA_SHARED) ||
 107                        intent.getAction().equals(Intent.ACTION_MEDIA_UNSHARED)) {
 108                 updateState();
 109             }
 110         }
 111     }
 112
 113     @Override
 114     protected void onResume() {
 115         super.onResume();
 116
 117         IntentFilter filter = new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
 118         mTetherChangeReceiver = new TetherChangeReceiver();
 119         Intent intent = registerReceiver(mTetherChangeReceiver, filter);
 120
 121         filter = new IntentFilter();
 122         filter.addAction(Intent.ACTION_MEDIA_SHARED);
 123         filter.addAction(Intent.ACTION_MEDIA_UNSHARED);
 124         filter.addDataScheme("file");
 125         registerReceiver(mTetherChangeReceiver, filter);
 126
 127         if (intent != null) mTetherChangeReceiver.onReceive(this, intent);
 128         mWifiApEnabler.resume();
 129     }
 130
 131     @Override
 132     protected void onPause() {
 133         super.onPause();
 134         unregisterReceiver(mTetherChangeReceiver);
 135         mTetherChangeReceiver = null;
 136         mWifiApEnabler.pause();
 137     }
 138
 139     private void updateState() {
 140         ConnectivityManager cm =
 141                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
 142
 143         String[] available = cm.getTetherableIfaces();
 144         String[] tethered = cm.getTetheredIfaces();
 145         String[] errored = cm.getTetheringErroredIfaces();
 146         updateState(available, tethered, errored);
 147     }
 148
 149     private void updateState(Object[] available, Object[] tethered,
 150             Object[] errored) {
 151         ConnectivityManager cm =
 152                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
 153         boolean usbTethered = false;
 154         boolean usbAvailable = false;
 155         int usbError = ConnectivityManager.TETHER_ERROR_NO_ERROR;
 156         boolean usbErrored = false;
 157         boolean massStorageActive =
 158                 Environment.MEDIA_SHARED.equals(Environment.getExternalStorageState());
 159         for (Object o : available) {
 160             String s = (String)o;
 161             for (String regex : mUsbRegexs) {
 162                 if (s.matches(regex)) {
 163                     usbAvailable = true;
 164                     if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
 165                         usbError = cm.getLastTetherError(s);
 166                     }
 167                 }
 168             }
 169         }
 170         for (Object o : tethered) {
 171             String s = (String)o;
 172             for (String regex : mUsbRegexs) {
 173                 if (s.matches(regex)) usbTethered = true;
 174             }
 175         }
 176         for (Object o: errored) {
 177             String s = (String)o;
 178             for (String regex : mUsbRegexs) {
 179                 if (s.matches(regex)) usbErrored = true;
 180             }
 181         }
 182
 183         if (usbTethered) {
 184             mUsbTether.setSummary(R.string.usb_tethering_active_subtext);
 185             mUsbTether.setEnabled(true);
 186             mUsbTether.setChecked(true);
 187         } else if (usbAvailable) {
 188             if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
 189                 mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
 190             } else {
 191                 mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
 192             }
 193             mUsbTether.setEnabled(true);
 194             mUsbTether.setChecked(false);
 195         } else if (usbErrored) {
 196             mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
 197             mUsbTether.setEnabled(false);
 198             mUsbTether.setChecked(false);
 199         } else if (massStorageActive) {
 200             mUsbTether.setSummary(R.string.usb_tethering_storage_active_subtext);
 201             mUsbTether.setEnabled(false);
 202             mUsbTether.setChecked(false);
 203         } else {
 204             mUsbTether.setSummary(R.string.usb_tethering_unavailable_subtext);
 205             mUsbTether.setEnabled(false);
 206             mUsbTether.setChecked(false);
 207         }
 208     }
 209
 210     @Override
 211     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
 212         if (preference == mUsbTether) {
 213             boolean newState = mUsbTether.isChecked();
 214
 215             ConnectivityManager cm =
 216                     (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
 217
 218             if (newState) {
 219                 String[] available = cm.getTetherableIfaces();
 220
 221                 String usbIface = findIface(available, mUsbRegexs);
 222                 if (usbIface == null) {
 223                     updateState();
 224                     return true;
 225                 }
 226                 if (cm.tether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
 227                     mUsbTether.setChecked(false);
 228                     mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
 229                     return true;
 230                 }
 231                 mUsbTether.setSummary("");
 232             } else {
 233                 String [] tethered = cm.getTetheredIfaces();
 234
 235                 String usbIface = findIface(tethered, mUsbRegexs);
 236                 if (usbIface == null) {
 237                     updateState();
 238                     return true;
 239                 }
 240                 if (cm.untether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
 241                     mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
 242                     return true;
 243                 }
 244                 mUsbTether.setSummary("");
 245             }
 246         } else if (preference == mTetherHelp) {
 247             Locale locale = Locale.getDefault();
 248             String url = HELP_URL.replace("%y", locale.getLanguage().toLowerCase());
 249             url = url.replace("%z", locale.getCountry().toLowerCase());
 250
 251             if ((mUsbRegexs.length != 0) && (mWifiRegexs.length == 0)) {
 252                 url = url.replace("%x", USB_HELP_MODIFIER);
 253             } else if ((mWifiRegexs.length != 0) && (mUsbRegexs.length == 0)) {
 254                 url = url.replace("%x", WIFI_HELP_MODIFIER);
 255             } else {
 256                 // could assert that both wifi and usb have regexs, but the default
 257                 // is to use this anyway so no check is needed
 258                 url = url.replace("%x", "");
 259             }
 260             WebView view = new WebView(this);
 261             view.loadUrl(url);
 262
 263             AlertDialog.Builder builder = new AlertDialog.Builder(this);
 264             builder.setCancelable(true);
 265             builder.setTitle(R.string.tethering_help_button_text);
 266             builder.setView(view);
 267             builder.show();
 268         }
 269         return false;
 270     }
 271
 272     private String findIface(String[] ifaces, String[] regexes) {
 273         for (String iface : ifaces) {
 274             for (String regex : regexes) {
 275                 if (iface.matches(regex)) {
 276                     return iface;
 277                 }
 278             }
 279         }
 280         return null;
 281     }
 282 }