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