src/com/android/settings/TetherSettings.java - platform/packages/apps/Settings - Git at Google

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.settings;

 import com.android.settings.wifi.WifiApEnabler;

 import android.app.AlertDialog;
 import android.app.Dialog;
 import android.os.Bundle;
 import android.os.SystemProperties;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.res.AssetManager;
 import android.net.ConnectivityManager;
 import android.os.Environment;
 import android.preference.CheckBoxPreference;
 import android.preference.Preference;
 import android.preference.PreferenceActivity;
 import android.preference.PreferenceScreen;
 import android.provider.Settings;
 import android.util.Log;
 import android.webkit.WebView;

 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Locale;

 /*
  * Displays preferences for Tethering.
  */
 public class TetherSettings extends PreferenceActivity {
     private static final String USB_TETHER_SETTINGS = "usb_tether_settings";
     private static final String ENABLE_WIFI_AP = "enable_wifi_ap";
     private static final String WIFI_AP_SETTINGS = "wifi_ap_settings";
     private static final String TETHERING_HELP = "tethering_help";
     private static final String USB_HELP_MODIFIER = "usb_";
     private static final String WIFI_HELP_MODIFIER = "wifi_";
     private static final String HELP_URL = "file:///android_asset/html/%y%z/tethering_%xhelp.html";
     private static final String HELP_PATH = "html/%y%z/tethering_help.html";

     private static final int DIALOG_TETHER_HELP = 1;

     private WebView mView;
     private CheckBoxPreference mUsbTether;

     private CheckBoxPreference mEnableWifiAp;
     private PreferenceScreen mWifiApSettings;
     private WifiApEnabler mWifiApEnabler;
     private PreferenceScreen mTetherHelp;

     private BroadcastReceiver mTetherChangeReceiver;

     private String[] mUsbRegexs;
     private ArrayList mUsbIfaces;

     private String[] mWifiRegexs;

     @Override
     protected void onCreate(Bundle icicle) {
         super.onCreate(icicle);

         addPreferencesFromResource(R.xml.tether_prefs);

         mEnableWifiAp = (CheckBoxPreference) findPreference(ENABLE_WIFI_AP);
         mWifiApSettings = (PreferenceScreen) findPreference(WIFI_AP_SETTINGS);
         mUsbTether = (CheckBoxPreference) findPreference(USB_TETHER_SETTINGS);
         mTetherHelp = (PreferenceScreen) findPreference(TETHERING_HELP);

         ConnectivityManager cm =
                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);

         mUsbRegexs = cm.getTetherableUsbRegexs();
         if (mUsbRegexs.length == 0) {
             getPreferenceScreen().removePreference(mUsbTether);

             setTitle(R.string.tether_settings_title_wifi);
         }

         mWifiRegexs = cm.getTetherableWifiRegexs();
         if (mWifiRegexs.length == 0) {
             getPreferenceScreen().removePreference(mEnableWifiAp);
             getPreferenceScreen().removePreference(mWifiApSettings);

             setTitle(R.string.tether_settings_title_usb);
         } else if (mUsbRegexs.length != 0) {
             // have both
             setTitle(R.string.tether_settings_title_both);
         }
         mWifiApEnabler = new WifiApEnabler(this, mEnableWifiAp);
         mView = new WebView(this);
     }

     @Override
     protected Dialog onCreateDialog(int id) {
         if (id == DIALOG_TETHER_HELP) {
             Locale locale = Locale.getDefault();

             // check for the full language + country resource, if not there, try just language
             AssetManager am = getAssets();
             String path = HELP_PATH.replace("%y", locale.getLanguage().toLowerCase());
             path = path.replace("%z", "_"+locale.getCountry().toLowerCase());
             boolean useCountry = true;
             InputStream is = null;
             try {
                 is = am.open(path);
             } catch (Exception e) {
                 useCountry = false;
             } finally {
                 if (is != null) {
                     try {
                         is.close();
                     } catch (Exception e) {}
                 }
             }
             String url = HELP_URL.replace("%y", locale.getLanguage().toLowerCase());
             url = url.replace("%z", (useCountry ? "_"+locale.getCountry().toLowerCase() : ""));
             if ((mUsbRegexs.length != 0) && (mWifiRegexs.length == 0)) {
                 url = url.replace("%x", USB_HELP_MODIFIER);
             } else if ((mWifiRegexs.length != 0) && (mUsbRegexs.length == 0)) {
                 url = url.replace("%x", WIFI_HELP_MODIFIER);
             } else {
                 // could assert that both wifi and usb have regexs, but the default
                 // is to use this anyway so no check is needed
                 url = url.replace("%x", "");
             }

             mView.loadUrl(url);

             return new AlertDialog.Builder(this)
                 .setCancelable(true)
                 .setTitle(R.string.tethering_help_button_text)
                 .setView(mView)
                 .create();
         }
         return null;
     }

     private class TetherChangeReceiver extends BroadcastReceiver {
         public void onReceive(Context content, Intent intent) {
             if (intent.getAction().equals(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)) {
                 // TODO - this should understand the interface types
                 ArrayList<String> available = intent.getStringArrayListExtra(
                         ConnectivityManager.EXTRA_AVAILABLE_TETHER);
                 ArrayList<String> active = intent.getStringArrayListExtra(
                         ConnectivityManager.EXTRA_ACTIVE_TETHER);
                 ArrayList<String> errored = intent.getStringArrayListExtra(
                         ConnectivityManager.EXTRA_ERRORED_TETHER);
                 updateState(available.toArray(), active.toArray(), errored.toArray());
             } else if (intent.getAction().equals(Intent.ACTION_MEDIA_SHARED) ||
                        intent.getAction().equals(Intent.ACTION_MEDIA_UNSHARED)) {
                 updateState();
             }
         }
     }

     @Override
     protected void onResume() {
         super.onResume();

         IntentFilter filter = new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
         mTetherChangeReceiver = new TetherChangeReceiver();
         Intent intent = registerReceiver(mTetherChangeReceiver, filter);

         filter = new IntentFilter();
         filter.addAction(Intent.ACTION_MEDIA_SHARED);
         filter.addAction(Intent.ACTION_MEDIA_UNSHARED);
         filter.addDataScheme("file");
         registerReceiver(mTetherChangeReceiver, filter);

         if (intent != null) mTetherChangeReceiver.onReceive(this, intent);
         mWifiApEnabler.resume();
     }

     @Override
     protected void onPause() {
         super.onPause();
         unregisterReceiver(mTetherChangeReceiver);
         mTetherChangeReceiver = null;
         mWifiApEnabler.pause();
     }

     private void updateState() {
         ConnectivityManager cm =
                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);

         String[] available = cm.getTetherableIfaces();
         String[] tethered = cm.getTetheredIfaces();
         String[] errored = cm.getTetheringErroredIfaces();
         updateState(available, tethered, errored);
     }

     private void updateState(Object[] available, Object[] tethered,
             Object[] errored) {
         ConnectivityManager cm =
                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
         boolean usbTethered = false;
         boolean usbAvailable = false;
         int usbError = ConnectivityManager.TETHER_ERROR_NO_ERROR;
         boolean usbErrored = false;
         boolean massStorageActive =
                 Environment.MEDIA_SHARED.equals(Environment.getExternalStorageState());
         for (Object o : available) {
             String s = (String)o;
             for (String regex : mUsbRegexs) {
                 if (s.matches(regex)) {
                     usbAvailable = true;
                     if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
                         usbError = cm.getLastTetherError(s);
                     }
                 }
             }
         }
         for (Object o : tethered) {
             String s = (String)o;
             for (String regex : mUsbRegexs) {
                 if (s.matches(regex)) usbTethered = true;
             }
         }
         for (Object o: errored) {
             String s = (String)o;
             for (String regex : mUsbRegexs) {
                 if (s.matches(regex)) usbErrored = true;
             }
         }

         if (usbTethered) {
             mUsbTether.setSummary(R.string.usb_tethering_active_subtext);
             mUsbTether.setEnabled(true);
             mUsbTether.setChecked(true);
         } else if (usbAvailable) {
             if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
                 mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
             } else {
                 mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
             }
             mUsbTether.setEnabled(true);
             mUsbTether.setChecked(false);
         } else if (usbErrored) {
             mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
             mUsbTether.setEnabled(false);
             mUsbTether.setChecked(false);
         } else if (massStorageActive) {
             mUsbTether.setSummary(R.string.usb_tethering_storage_active_subtext);
             mUsbTether.setEnabled(false);
             mUsbTether.setChecked(false);
         } else {
             mUsbTether.setSummary(R.string.usb_tethering_unavailable_subtext);
             mUsbTether.setEnabled(false);
             mUsbTether.setChecked(false);
         }
     }

     @Override
     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
         if (preference == mUsbTether) {
             boolean newState = mUsbTether.isChecked();

             ConnectivityManager cm =
                     (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);

             if (newState) {
                 String[] available = cm.getTetherableIfaces();

                 String usbIface = findIface(available, mUsbRegexs);
                 if (usbIface == null) {
                     updateState();
                     return true;
                 }
                 if (cm.tether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
                     mUsbTether.setChecked(false);
                     mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
                     return true;
                 }
                 mUsbTether.setSummary("");
             } else {
                 String [] tethered = cm.getTetheredIfaces();

                 String usbIface = findIface(tethered, mUsbRegexs);
                 if (usbIface == null) {
                     updateState();
                     return true;
                 }
                 if (cm.untether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
                     mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
                     return true;
                 }
                 mUsbTether.setSummary("");
             }
         } else if (preference == mTetherHelp) {

             showDialog(DIALOG_TETHER_HELP);
         }
         return false;
     }

     private String findIface(String[] ifaces, String[] regexes) {
         for (String iface : ifaces) {
             for (String regex : regexes) {
                 if (iface.matches(regex)) {
                     return iface;
                 }
             }
         }
         return null;
     }
 }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.settings;

	import com.android.settings.wifi.WifiApEnabler;

	import android.app.AlertDialog;
	import android.app.Dialog;
	import android.os.Bundle;
	import android.os.SystemProperties;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.content.res.AssetManager;
	import android.net.ConnectivityManager;
	import android.os.Environment;
	import android.preference.CheckBoxPreference;
	import android.preference.Preference;
	import android.preference.PreferenceActivity;
	import android.preference.PreferenceScreen;
	import android.provider.Settings;
	import android.util.Log;
	import android.webkit.WebView;

	import java.io.InputStream;
	import java.util.ArrayList;
	import java.util.Locale;

	/*
	* Displays preferences for Tethering.
	*/
	public class TetherSettings extends PreferenceActivity {
	private static final String USB_TETHER_SETTINGS = "usb_tether_settings";
	private static final String ENABLE_WIFI_AP = "enable_wifi_ap";
	private static final String WIFI_AP_SETTINGS = "wifi_ap_settings";
	private static final String TETHERING_HELP = "tethering_help";
	private static final String USB_HELP_MODIFIER = "usb_";
	private static final String WIFI_HELP_MODIFIER = "wifi_";
	private static final String HELP_URL = "file:///android_asset/html/%y%z/tethering_%xhelp.html";
	private static final String HELP_PATH = "html/%y%z/tethering_help.html";

	private static final int DIALOG_TETHER_HELP = 1;

	private WebView mView;
	private CheckBoxPreference mUsbTether;

	private CheckBoxPreference mEnableWifiAp;
	private PreferenceScreen mWifiApSettings;
	private WifiApEnabler mWifiApEnabler;
	private PreferenceScreen mTetherHelp;

	private BroadcastReceiver mTetherChangeReceiver;

	private String[] mUsbRegexs;
	private ArrayList mUsbIfaces;

	private String[] mWifiRegexs;

	@Override
	protected void onCreate(Bundle icicle) {
	super.onCreate(icicle);

	addPreferencesFromResource(R.xml.tether_prefs);

	mEnableWifiAp = (CheckBoxPreference) findPreference(ENABLE_WIFI_AP);
	mWifiApSettings = (PreferenceScreen) findPreference(WIFI_AP_SETTINGS);
	mUsbTether = (CheckBoxPreference) findPreference(USB_TETHER_SETTINGS);
	mTetherHelp = (PreferenceScreen) findPreference(TETHERING_HELP);

	ConnectivityManager cm =
	(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);

	mUsbRegexs = cm.getTetherableUsbRegexs();
	if (mUsbRegexs.length == 0) {
	getPreferenceScreen().removePreference(mUsbTether);

	setTitle(R.string.tether_settings_title_wifi);
	}

	mWifiRegexs = cm.getTetherableWifiRegexs();
	if (mWifiRegexs.length == 0) {
	getPreferenceScreen().removePreference(mEnableWifiAp);
	getPreferenceScreen().removePreference(mWifiApSettings);

	setTitle(R.string.tether_settings_title_usb);
	} else if (mUsbRegexs.length != 0) {
	// have both
	setTitle(R.string.tether_settings_title_both);
	}
	mWifiApEnabler = new WifiApEnabler(this, mEnableWifiAp);
	mView = new WebView(this);
	}

	@Override
	protected Dialog onCreateDialog(int id) {
	if (id == DIALOG_TETHER_HELP) {
	Locale locale = Locale.getDefault();

	// check for the full language + country resource, if not there, try just language
	AssetManager am = getAssets();
	String path = HELP_PATH.replace("%y", locale.getLanguage().toLowerCase());
	path = path.replace("%z", "_"+locale.getCountry().toLowerCase());
	boolean useCountry = true;
	InputStream is = null;
	try {
	is = am.open(path);
	} catch (Exception e) {
	useCountry = false;
	} finally {
	if (is != null) {
	try {
	is.close();
	} catch (Exception e) {}
	}
	}
	String url = HELP_URL.replace("%y", locale.getLanguage().toLowerCase());
	url = url.replace("%z", (useCountry ? "_"+locale.getCountry().toLowerCase() : ""));
	if ((mUsbRegexs.length != 0) && (mWifiRegexs.length == 0)) {
	url = url.replace("%x", USB_HELP_MODIFIER);
	} else if ((mWifiRegexs.length != 0) && (mUsbRegexs.length == 0)) {
	url = url.replace("%x", WIFI_HELP_MODIFIER);
	} else {
	// could assert that both wifi and usb have regexs, but the default
	// is to use this anyway so no check is needed
	url = url.replace("%x", "");
	}

	mView.loadUrl(url);

	return new AlertDialog.Builder(this)
	.setCancelable(true)
	.setTitle(R.string.tethering_help_button_text)
	.setView(mView)
	.create();
	}
	return null;
	}

	private class TetherChangeReceiver extends BroadcastReceiver {
	public void onReceive(Context content, Intent intent) {
	if (intent.getAction().equals(ConnectivityManager.ACTION_TETHER_STATE_CHANGED)) {
	// TODO - this should understand the interface types
	ArrayList<String> available = intent.getStringArrayListExtra(
	ConnectivityManager.EXTRA_AVAILABLE_TETHER);
	ArrayList<String> active = intent.getStringArrayListExtra(
	ConnectivityManager.EXTRA_ACTIVE_TETHER);
	ArrayList<String> errored = intent.getStringArrayListExtra(
	ConnectivityManager.EXTRA_ERRORED_TETHER);
	updateState(available.toArray(), active.toArray(), errored.toArray());
	} else if (intent.getAction().equals(Intent.ACTION_MEDIA_SHARED) \|\|
	intent.getAction().equals(Intent.ACTION_MEDIA_UNSHARED)) {
	updateState();
	}
	}
	}

	@Override
	protected void onResume() {
	super.onResume();

	IntentFilter filter = new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED);
	mTetherChangeReceiver = new TetherChangeReceiver();
	Intent intent = registerReceiver(mTetherChangeReceiver, filter);

	filter = new IntentFilter();
	filter.addAction(Intent.ACTION_MEDIA_SHARED);
	filter.addAction(Intent.ACTION_MEDIA_UNSHARED);
	filter.addDataScheme("file");
	registerReceiver(mTetherChangeReceiver, filter);

	if (intent != null) mTetherChangeReceiver.onReceive(this, intent);
	mWifiApEnabler.resume();
	}

	@Override
	protected void onPause() {
	super.onPause();
	unregisterReceiver(mTetherChangeReceiver);
	mTetherChangeReceiver = null;
	mWifiApEnabler.pause();
	}

	private void updateState() {
	ConnectivityManager cm =
	(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);

	String[] available = cm.getTetherableIfaces();
	String[] tethered = cm.getTetheredIfaces();
	String[] errored = cm.getTetheringErroredIfaces();
	updateState(available, tethered, errored);
	}

	private void updateState(Object[] available, Object[] tethered,
	Object[] errored) {
	ConnectivityManager cm =
	(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
	boolean usbTethered = false;
	boolean usbAvailable = false;
	int usbError = ConnectivityManager.TETHER_ERROR_NO_ERROR;
	boolean usbErrored = false;
	boolean massStorageActive =
	Environment.MEDIA_SHARED.equals(Environment.getExternalStorageState());
	for (Object o : available) {
	String s = (String)o;
	for (String regex : mUsbRegexs) {
	if (s.matches(regex)) {
	usbAvailable = true;
	if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
	usbError = cm.getLastTetherError(s);
	}
	}
	}
	}
	for (Object o : tethered) {
	String s = (String)o;
	for (String regex : mUsbRegexs) {
	if (s.matches(regex)) usbTethered = true;
	}
	}
	for (Object o: errored) {
	String s = (String)o;
	for (String regex : mUsbRegexs) {
	if (s.matches(regex)) usbErrored = true;
	}
	}

	if (usbTethered) {
	mUsbTether.setSummary(R.string.usb_tethering_active_subtext);
	mUsbTether.setEnabled(true);
	mUsbTether.setChecked(true);
	} else if (usbAvailable) {
	if (usbError == ConnectivityManager.TETHER_ERROR_NO_ERROR) {
	mUsbTether.setSummary(R.string.usb_tethering_available_subtext);
	} else {
	mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
	}
	mUsbTether.setEnabled(true);
	mUsbTether.setChecked(false);
	} else if (usbErrored) {
	mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
	mUsbTether.setEnabled(false);
	mUsbTether.setChecked(false);
	} else if (massStorageActive) {
	mUsbTether.setSummary(R.string.usb_tethering_storage_active_subtext);
	mUsbTether.setEnabled(false);
	mUsbTether.setChecked(false);
	} else {
	mUsbTether.setSummary(R.string.usb_tethering_unavailable_subtext);
	mUsbTether.setEnabled(false);
	mUsbTether.setChecked(false);
	}
	}

	@Override
	public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
	if (preference == mUsbTether) {
	boolean newState = mUsbTether.isChecked();

	ConnectivityManager cm =
	(ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);

	if (newState) {
	String[] available = cm.getTetherableIfaces();

	String usbIface = findIface(available, mUsbRegexs);
	if (usbIface == null) {
	updateState();
	return true;
	}
	if (cm.tether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
	mUsbTether.setChecked(false);
	mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
	return true;
	}
	mUsbTether.setSummary("");
	} else {
	String [] tethered = cm.getTetheredIfaces();

	String usbIface = findIface(tethered, mUsbRegexs);
	if (usbIface == null) {
	updateState();
	return true;
	}
	if (cm.untether(usbIface) != ConnectivityManager.TETHER_ERROR_NO_ERROR) {
	mUsbTether.setSummary(R.string.usb_tethering_errored_subtext);
	return true;
	}
	mUsbTether.setSummary("");
	}
	} else if (preference == mTetherHelp) {

	showDialog(DIALOG_TETHER_HELP);
	}
	return false;
	}

	private String findIface(String[] ifaces, String[] regexes) {
	for (String iface : ifaces) {
	for (String regex : regexes) {
	if (iface.matches(regex)) {
	return iface;
	}
	}
	}
	return null;
	}
	}