core/java/android/net/MobileDataStateTracker.java - platform/frameworks/base - 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 android.net;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.RemoteException;
 import android.os.Handler;
 import android.os.ServiceManager;
 import android.os.SystemProperties;
 import com.android.internal.telephony.ITelephony;
 import com.android.internal.telephony.Phone;
 import com.android.internal.telephony.TelephonyIntents;
 import android.net.NetworkInfo.DetailedState;
 import android.telephony.TelephonyManager;
 import android.util.Log;
 import android.text.TextUtils;

 import java.util.List;
 import java.util.ArrayList;

 /**
  * Track the state of mobile data connectivity. This is done by
  * receiving broadcast intents from the Phone process whenever
  * the state of data connectivity changes.
  *
  * {@hide}
  */
 public class MobileDataStateTracker extends NetworkStateTracker {

     private static final String TAG = "MobileDataStateTracker";
     private static final boolean DBG = false;

     private Phone.DataState mMobileDataState;
     private ITelephony mPhoneService;
     private static final String[] sDnsPropNames = {
           "net.rmnet0.dns1",
           "net.rmnet0.dns2",
           "net.eth0.dns1",
           "net.eth0.dns2",
           "net.eth0.dns3",
           "net.eth0.dns4",
           "net.gprs.dns1",
           "net.gprs.dns2"
     };
     private List<String> mDnsServers;
     private String mInterfaceName;
     private int mDefaultGatewayAddr;
     private int mLastCallingPid = -1;

     /**
      * Create a new MobileDataStateTracker
      * @param context the application context of the caller
      * @param target a message handler for getting callbacks about state changes
      */
     public MobileDataStateTracker(Context context, Handler target) {
         super(context, target, ConnectivityManager.TYPE_MOBILE,
               TelephonyManager.getDefault().getNetworkType(), "MOBILE",
               TelephonyManager.getDefault().getNetworkTypeName());
         mPhoneService = null;
         mDnsServers = new ArrayList<String>();
     }

     /**
      * Begin monitoring mobile data connectivity.
      */
     public void startMonitoring() {
         IntentFilter filter =
                 new IntentFilter(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED);
         filter.addAction(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED);
         filter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED);

         Intent intent = mContext.registerReceiver(new MobileDataStateReceiver(), filter);
         if (intent != null)
             mMobileDataState = getMobileDataState(intent);
         else
             mMobileDataState = Phone.DataState.DISCONNECTED;
     }

     private static Phone.DataState getMobileDataState(Intent intent) {
         String str = intent.getStringExtra(Phone.STATE_KEY);
         if (str != null)
             return Enum.valueOf(Phone.DataState.class, str);
         else
             return Phone.DataState.DISCONNECTED;
     }

     private class MobileDataStateReceiver extends BroadcastReceiver {
         public void onReceive(Context context, Intent intent) {
             if (intent.getAction().equals(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) {
                 Phone.DataState state = getMobileDataState(intent);
                 String reason = intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY);
                 String apnName = intent.getStringExtra(Phone.DATA_APN_KEY);
                 boolean unavailable = intent.getBooleanExtra(Phone.NETWORK_UNAVAILABLE_KEY, false);
                 if (DBG) Log.d(TAG, "Received " + intent.getAction() +
                     " broadcast - state = " + state
                     + ", unavailable = " + unavailable
                     + ", reason = " + (reason == null ? "(unspecified)" : reason));
                 mNetworkInfo.setIsAvailable(!unavailable);
                 if (mMobileDataState != state) {
                     mMobileDataState = state;

                     switch (state) {
                         case DISCONNECTED:
                             setDetailedState(DetailedState.DISCONNECTED, reason, apnName);
                             if (mInterfaceName != null) {
                                 NetworkUtils.resetConnections(mInterfaceName);
                             }
                             mInterfaceName = null;
                             mDefaultGatewayAddr = 0;
                             break;
                         case CONNECTING:
                             setDetailedState(DetailedState.CONNECTING, reason, apnName);
                             break;
                         case SUSPENDED:
                             setDetailedState(DetailedState.SUSPENDED, reason, apnName);
                             break;
                         case CONNECTED:
                             mInterfaceName = intent.getStringExtra(Phone.DATA_IFACE_NAME_KEY);
                             if (mInterfaceName == null) {
                                 Log.d(TAG, "CONNECTED event did not supply interface name.");
                             }
                             setupDnsProperties();
                             setDetailedState(DetailedState.CONNECTED, reason, apnName);
                             break;
                     }
                 }
             } else if (intent.getAction().equals(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED)) {
                 String reason = intent.getStringExtra(Phone.FAILURE_REASON_KEY);
                 String apnName = intent.getStringExtra(Phone.DATA_APN_KEY);
                 if (DBG) Log.d(TAG, "Received " + intent.getAction() + " broadcast" +
                     reason == null ? "" : "(" + reason + ")");
                 setDetailedState(DetailedState.FAILED, reason, apnName);
             }
             TelephonyManager tm = TelephonyManager.getDefault();
             setRoamingStatus(tm.isNetworkRoaming());
             setSubtype(tm.getNetworkType(), tm.getNetworkTypeName());
         }
     }

     /**
      * Make sure that route(s) exist to the carrier DNS server(s).
      */
     public void addPrivateRoutes() {
         if (mInterfaceName != null) {
             for (String addrString : mDnsServers) {
                 int addr = NetworkUtils.lookupHost(addrString);
                 if (addr != -1) {
                     NetworkUtils.addHostRoute(mInterfaceName, addr);
                 }
             }
         }
     }

     public void removePrivateRoutes() {
         if(mInterfaceName != null) {
             NetworkUtils.removeHostRoutes(mInterfaceName);
         }
     }

     public void removeDefaultRoute() {
         if(mInterfaceName != null) {
             mDefaultGatewayAddr = NetworkUtils.getDefaultRoute(mInterfaceName);
             NetworkUtils.removeDefaultRoute(mInterfaceName);
         }
     }

     public void restoreDefaultRoute() {
         // 0 is not a valid address for a gateway
         if (mInterfaceName != null && mDefaultGatewayAddr != 0) {
             NetworkUtils.setDefaultRoute(mInterfaceName, mDefaultGatewayAddr);
         }
     }

     private void getPhoneService(boolean forceRefresh) {
         if ((mPhoneService == null) || forceRefresh) {
             mPhoneService = ITelephony.Stub.asInterface(ServiceManager.getService("phone"));
         }
     }

     /**
      * Report whether data connectivity is possible.
      */
     public boolean isAvailable() {
         getPhoneService(false);

         /*
          * If the phone process has crashed in the past, we'll get a
          * RemoteException and need to re-reference the service.
          */
         for (int retry = 0; retry < 2; retry++) {
             if (mPhoneService == null) break;

             try {
                 return mPhoneService.isDataConnectivityPossible();
             } catch (RemoteException e) {
                 // First-time failed, get the phone service again
                 if (retry == 0) getPhoneService(true);
             }
         }

         return false;
     }

     /**
      * Return the IP addresses of the DNS servers available for the mobile data
      * network interface.
      * @return a list of DNS addresses, with no holes.
      */
     public String[] getNameServers() {
         return getNameServerList(sDnsPropNames);
     }

     /**
      * {@inheritDoc}
      * The mobile data network subtype indicates what generation network technology is in effect,
      * e.g., GPRS, EDGE, UMTS, etc.
      */
     public int getNetworkSubtype() {
         return TelephonyManager.getDefault().getNetworkType();
     }

     /**
      * Return the system properties name associated with the tcp buffer sizes
      * for this network.
      */
     public String getTcpBufferSizesPropName() {
       String networkTypeStr = "unknown";
         TelephonyManager tm = new TelephonyManager(mContext);
         switch(tm.getNetworkType()) {
           case TelephonyManager.NETWORK_TYPE_GPRS:
             networkTypeStr = "gprs";
             break;
           case TelephonyManager.NETWORK_TYPE_EDGE:
             networkTypeStr = "edge";
             break;
           case TelephonyManager.NETWORK_TYPE_UMTS:
             networkTypeStr = "umts";
             break;
         }
         return "net.tcp.buffersize." + networkTypeStr;
     }

     /**
      * Tear down mobile data connectivity, i.e., disable the ability to create
      * mobile data connections.
      */
     @Override
     public boolean teardown() {
         getPhoneService(false);
         /*
          * If the phone process has crashed in the past, we'll get a
          * RemoteException and need to re-reference the service.
          */
         for (int retry = 0; retry < 2; retry++) {
             if (mPhoneService == null) {
                 Log.w(TAG,
                     "Ignoring mobile data teardown request because could not acquire PhoneService");
                 break;
             }

             try {
                 return mPhoneService.disableDataConnectivity();
             } catch (RemoteException e) {
                 if (retry == 0) getPhoneService(true);
             }
         }

         Log.w(TAG, "Failed to tear down mobile data connectivity");
         return false;
     }

     /**
      * Re-enable mobile data connectivity after a {@link #teardown()}.
      */
     public boolean reconnect() {
         getPhoneService(false);
         /*
          * If the phone process has crashed in the past, we'll get a
          * RemoteException and need to re-reference the service.
          */
         for (int retry = 0; retry < 2; retry++) {
             if (mPhoneService == null) {
                 Log.w(TAG,
                     "Ignoring mobile data connect request because could not acquire PhoneService");
                 break;
             }

             try {
                 return mPhoneService.enableDataConnectivity();
             } catch (RemoteException e) {
                 if (retry == 0) getPhoneService(true);
             }
         }

         Log.w(TAG, "Failed to set up mobile data connectivity");
         return false;
     }

     /**
      * Turn on or off the mobile radio. No connectivity will be possible while the
      * radio is off. The operation is a no-op if the radio is already in the desired state.
      * @param turnOn {@code true} if the radio should be turned on, {@code false} if
      */
     public boolean setRadio(boolean turnOn) {
         getPhoneService(false);
         /*
          * If the phone process has crashed in the past, we'll get a
          * RemoteException and need to re-reference the service.
          */
         for (int retry = 0; retry < 2; retry++) {
             if (mPhoneService == null) {
                 Log.w(TAG,
                     "Ignoring mobile radio request because could not acquire PhoneService");
                 break;
             }

             try {
                 return mPhoneService.setRadio(turnOn);
             } catch (RemoteException e) {
                 if (retry == 0) getPhoneService(true);
             }
         }

         Log.w(TAG, "Could not set radio power to " + (turnOn ? "on" : "off"));
         return false;
     }

     /**
      * Tells the phone sub-system that the caller wants to
      * begin using the named feature. The only supported feature at
      * this time is {@code Phone.FEATURE_ENABLE_MMS}, which allows an application
      * to specify that it wants to send and/or receive MMS data.
      * @param feature the name of the feature to be used
      * @param callingPid the process ID of the process that is issuing this request
      * @param callingUid the user ID of the process that is issuing this request
      * @return an integer value representing the outcome of the request.
      * The interpretation of this value is feature-specific.
      * specific, except that the value {@code -1}
      * always indicates failure. For {@code Phone.FEATURE_ENABLE_MMS},
      * the other possible return values are
      * <ul>
      * <li>{@code Phone.APN_ALREADY_ACTIVE}</li>
      * <li>{@code Phone.APN_REQUEST_STARTED}</li>
      * <li>{@code Phone.APN_TYPE_NOT_AVAILABLE}</li>
      * <li>{@code Phone.APN_REQUEST_FAILED}</li>
      * </ul>
      */
     public int startUsingNetworkFeature(String feature, int callingPid, int callingUid) {
         if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_MMS)) {
             mLastCallingPid = callingPid;
             return setEnableApn(Phone.APN_TYPE_MMS, true);
         } else {
             return -1;
         }
     }

     /**
      * Tells the phone sub-system that the caller is finished
      * using the named feature. The only supported feature at
      * this time is {@code Phone.FEATURE_ENABLE_MMS}, which allows an application
      * to specify that it wants to send and/or receive MMS data.
      * @param feature the name of the feature that is no longer needed
      * @param callingPid the process ID of the process that is issuing this request
      * @param callingUid the user ID of the process that is issuing this request
      * @return an integer value representing the outcome of the request.
      * The interpretation of this value is feature-specific, except that
      * the value {@code -1} always indicates failure.
      */
     public int stopUsingNetworkFeature(String feature, int callingPid, int callingUid) {
         if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_MMS)) {
             return setEnableApn(Phone.APN_TYPE_MMS, false);
         } else {
             return -1;
         }
     }

     /**
      * Ensure that a network route exists to deliver traffic to the specified
      * host via the mobile data network.
      * @param hostAddress the IP address of the host to which the route is desired,
      * in network byte order.
      * @return {@code true} on success, {@code false} on failure
      */
     @Override
     public boolean requestRouteToHost(int hostAddress) {
         if (mInterfaceName != null && hostAddress != -1) {
             if (DBG) {
                 Log.d(TAG, "Requested host route to " + Integer.toHexString(hostAddress));
             }
             return NetworkUtils.addHostRoute(mInterfaceName, hostAddress) == 0;
         } else {
             return false;
         }
     }

     @Override
     public String toString() {
         StringBuffer sb = new StringBuffer("Mobile data state: ");

         sb.append(mMobileDataState);
         return sb.toString();
     }

     private void setupDnsProperties() {
         mDnsServers.clear();
         // Set up per-process DNS server list on behalf of the MMS process
         int i = 1;
         if (mInterfaceName != null) {
             for (String propName : sDnsPropNames) {
                 if (propName.indexOf(mInterfaceName) != -1) {
                     String propVal = SystemProperties.get(propName);
                     if (propVal != null && propVal.length() != 0 && !propVal.equals("0.0.0.0")) {
                         mDnsServers.add(propVal);
                         if (mLastCallingPid != -1) {
                             SystemProperties.set("net.dns"  + i + "." + mLastCallingPid, propVal);
                         }
                         ++i;
                     }
                 }
             }
         }
         if (i == 1) {
             Log.d(TAG, "DNS server addresses are not known.");
         } else if (mLastCallingPid != -1) {
             /*
             * Bump the property that tells the name resolver library
             * to reread the DNS server list from the properties.
             */
             String propVal = SystemProperties.get("net.dnschange");
             if (propVal.length() != 0) {
                 try {
                     int n = Integer.parseInt(propVal);
                     SystemProperties.set("net.dnschange", "" + (n+1));
                 } catch (NumberFormatException e) {
                 }
             }
         }
         mLastCallingPid = -1;
     }

    /**
      * Internal method supporting the ENABLE_MMS feature.
      * @param apnType the type of APN to be enabled or disabled (e.g., mms)
      * @param enable {@code true} to enable the specified APN type,
      * {@code false} to disable it.
      * @return an integer value representing the outcome of the request.
      */
     private int setEnableApn(String apnType, boolean enable) {
         getPhoneService(false);
         /*
          * If the phone process has crashed in the past, we'll get a
          * RemoteException and need to re-reference the service.
          */
         for (int retry = 0; retry < 2; retry++) {
             if (mPhoneService == null) {
                 Log.w(TAG,
                     "Ignoring feature request because could not acquire PhoneService");
                 break;
             }

             try {
                 if (enable) {
                     return mPhoneService.enableApnType(apnType);
                 } else {
                     return mPhoneService.disableApnType(apnType);
                 }
             } catch (RemoteException e) {
                 if (retry == 0) getPhoneService(true);
             }
         }

         Log.w(TAG, "Could not " + (enable ? "enable" : "disable")
                 + " APN type \"" + apnType + "\"");
         return Phone.APN_REQUEST_FAILED;
     }
 }
	/*
	* 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 android.net;

	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.os.RemoteException;
	import android.os.Handler;
	import android.os.ServiceManager;
	import android.os.SystemProperties;
	import com.android.internal.telephony.ITelephony;
	import com.android.internal.telephony.Phone;
	import com.android.internal.telephony.TelephonyIntents;
	import android.net.NetworkInfo.DetailedState;
	import android.telephony.TelephonyManager;
	import android.util.Log;
	import android.text.TextUtils;

	import java.util.List;
	import java.util.ArrayList;

	/**
	* Track the state of mobile data connectivity. This is done by
	* receiving broadcast intents from the Phone process whenever
	* the state of data connectivity changes.
	*
	* {@hide}
	*/
	public class MobileDataStateTracker extends NetworkStateTracker {

	private static final String TAG = "MobileDataStateTracker";
	private static final boolean DBG = false;

	private Phone.DataState mMobileDataState;
	private ITelephony mPhoneService;
	private static final String[] sDnsPropNames = {
	"net.rmnet0.dns1",
	"net.rmnet0.dns2",
	"net.eth0.dns1",
	"net.eth0.dns2",
	"net.eth0.dns3",
	"net.eth0.dns4",
	"net.gprs.dns1",
	"net.gprs.dns2"
	};
	private List<String> mDnsServers;
	private String mInterfaceName;
	private int mDefaultGatewayAddr;
	private int mLastCallingPid = -1;

	/**
	* Create a new MobileDataStateTracker
	* @param context the application context of the caller
	* @param target a message handler for getting callbacks about state changes
	*/
	public MobileDataStateTracker(Context context, Handler target) {
	super(context, target, ConnectivityManager.TYPE_MOBILE,
	TelephonyManager.getDefault().getNetworkType(), "MOBILE",
	TelephonyManager.getDefault().getNetworkTypeName());
	mPhoneService = null;
	mDnsServers = new ArrayList<String>();
	}

	/**
	* Begin monitoring mobile data connectivity.
	*/
	public void startMonitoring() {
	IntentFilter filter =
	new IntentFilter(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED);
	filter.addAction(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED);
	filter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED);

	Intent intent = mContext.registerReceiver(new MobileDataStateReceiver(), filter);
	if (intent != null)
	mMobileDataState = getMobileDataState(intent);
	else
	mMobileDataState = Phone.DataState.DISCONNECTED;
	}

	private static Phone.DataState getMobileDataState(Intent intent) {
	String str = intent.getStringExtra(Phone.STATE_KEY);
	if (str != null)
	return Enum.valueOf(Phone.DataState.class, str);
	else
	return Phone.DataState.DISCONNECTED;
	}

	private class MobileDataStateReceiver extends BroadcastReceiver {
	public void onReceive(Context context, Intent intent) {
	if (intent.getAction().equals(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) {
	Phone.DataState state = getMobileDataState(intent);
	String reason = intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY);
	String apnName = intent.getStringExtra(Phone.DATA_APN_KEY);
	boolean unavailable = intent.getBooleanExtra(Phone.NETWORK_UNAVAILABLE_KEY, false);
	if (DBG) Log.d(TAG, "Received " + intent.getAction() +
	" broadcast - state = " + state
	+ ", unavailable = " + unavailable
	+ ", reason = " + (reason == null ? "(unspecified)" : reason));
	mNetworkInfo.setIsAvailable(!unavailable);
	if (mMobileDataState != state) {
	mMobileDataState = state;

	switch (state) {
	case DISCONNECTED:
	setDetailedState(DetailedState.DISCONNECTED, reason, apnName);
	if (mInterfaceName != null) {
	NetworkUtils.resetConnections(mInterfaceName);
	}
	mInterfaceName = null;
	mDefaultGatewayAddr = 0;
	break;
	case CONNECTING:
	setDetailedState(DetailedState.CONNECTING, reason, apnName);
	break;
	case SUSPENDED:
	setDetailedState(DetailedState.SUSPENDED, reason, apnName);
	break;
	case CONNECTED:
	mInterfaceName = intent.getStringExtra(Phone.DATA_IFACE_NAME_KEY);
	if (mInterfaceName == null) {
	Log.d(TAG, "CONNECTED event did not supply interface name.");
	}
	setupDnsProperties();
	setDetailedState(DetailedState.CONNECTED, reason, apnName);
	break;
	}
	}
	} else if (intent.getAction().equals(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED)) {
	String reason = intent.getStringExtra(Phone.FAILURE_REASON_KEY);
	String apnName = intent.getStringExtra(Phone.DATA_APN_KEY);
	if (DBG) Log.d(TAG, "Received " + intent.getAction() + " broadcast" +
	reason == null ? "" : "(" + reason + ")");
	setDetailedState(DetailedState.FAILED, reason, apnName);
	}
	TelephonyManager tm = TelephonyManager.getDefault();
	setRoamingStatus(tm.isNetworkRoaming());
	setSubtype(tm.getNetworkType(), tm.getNetworkTypeName());
	}
	}

	/**
	* Make sure that route(s) exist to the carrier DNS server(s).
	*/
	public void addPrivateRoutes() {
	if (mInterfaceName != null) {
	for (String addrString : mDnsServers) {
	int addr = NetworkUtils.lookupHost(addrString);
	if (addr != -1) {
	NetworkUtils.addHostRoute(mInterfaceName, addr);
	}
	}
	}
	}

	public void removePrivateRoutes() {
	if(mInterfaceName != null) {
	NetworkUtils.removeHostRoutes(mInterfaceName);
	}
	}

	public void removeDefaultRoute() {
	if(mInterfaceName != null) {
	mDefaultGatewayAddr = NetworkUtils.getDefaultRoute(mInterfaceName);
	NetworkUtils.removeDefaultRoute(mInterfaceName);
	}
	}

	public void restoreDefaultRoute() {
	// 0 is not a valid address for a gateway
	if (mInterfaceName != null && mDefaultGatewayAddr != 0) {
	NetworkUtils.setDefaultRoute(mInterfaceName, mDefaultGatewayAddr);
	}
	}

	private void getPhoneService(boolean forceRefresh) {
	if ((mPhoneService == null) \|\| forceRefresh) {
	mPhoneService = ITelephony.Stub.asInterface(ServiceManager.getService("phone"));
	}
	}

	/**
	* Report whether data connectivity is possible.
	*/
	public boolean isAvailable() {
	getPhoneService(false);

	/*
	* If the phone process has crashed in the past, we'll get a
	* RemoteException and need to re-reference the service.
	*/
	for (int retry = 0; retry < 2; retry++) {
	if (mPhoneService == null) break;

	try {
	return mPhoneService.isDataConnectivityPossible();
	} catch (RemoteException e) {
	// First-time failed, get the phone service again
	if (retry == 0) getPhoneService(true);
	}
	}

	return false;
	}

	/**
	* Return the IP addresses of the DNS servers available for the mobile data
	* network interface.
	* @return a list of DNS addresses, with no holes.
	*/
	public String[] getNameServers() {
	return getNameServerList(sDnsPropNames);
	}

	/**
	* {@inheritDoc}
	* The mobile data network subtype indicates what generation network technology is in effect,
	* e.g., GPRS, EDGE, UMTS, etc.
	*/
	public int getNetworkSubtype() {
	return TelephonyManager.getDefault().getNetworkType();
	}

	/**
	* Return the system properties name associated with the tcp buffer sizes
	* for this network.
	*/
	public String getTcpBufferSizesPropName() {
	String networkTypeStr = "unknown";
	TelephonyManager tm = new TelephonyManager(mContext);
	switch(tm.getNetworkType()) {
	case TelephonyManager.NETWORK_TYPE_GPRS:
	networkTypeStr = "gprs";
	break;
	case TelephonyManager.NETWORK_TYPE_EDGE:
	networkTypeStr = "edge";
	break;
	case TelephonyManager.NETWORK_TYPE_UMTS:
	networkTypeStr = "umts";
	break;
	}
	return "net.tcp.buffersize." + networkTypeStr;
	}

	/**
	* Tear down mobile data connectivity, i.e., disable the ability to create
	* mobile data connections.
	*/
	@Override
	public boolean teardown() {
	getPhoneService(false);
	/*
	* If the phone process has crashed in the past, we'll get a
	* RemoteException and need to re-reference the service.
	*/
	for (int retry = 0; retry < 2; retry++) {
	if (mPhoneService == null) {
	Log.w(TAG,
	"Ignoring mobile data teardown request because could not acquire PhoneService");
	break;
	}

	try {
	return mPhoneService.disableDataConnectivity();
	} catch (RemoteException e) {
	if (retry == 0) getPhoneService(true);
	}
	}

	Log.w(TAG, "Failed to tear down mobile data connectivity");
	return false;
	}

	/**
	* Re-enable mobile data connectivity after a {@link #teardown()}.
	*/
	public boolean reconnect() {
	getPhoneService(false);
	/*
	* If the phone process has crashed in the past, we'll get a
	* RemoteException and need to re-reference the service.
	*/
	for (int retry = 0; retry < 2; retry++) {
	if (mPhoneService == null) {
	Log.w(TAG,
	"Ignoring mobile data connect request because could not acquire PhoneService");
	break;
	}

	try {
	return mPhoneService.enableDataConnectivity();
	} catch (RemoteException e) {
	if (retry == 0) getPhoneService(true);
	}
	}

	Log.w(TAG, "Failed to set up mobile data connectivity");
	return false;
	}

	/**
	* Turn on or off the mobile radio. No connectivity will be possible while the
	* radio is off. The operation is a no-op if the radio is already in the desired state.
	* @param turnOn {@code true} if the radio should be turned on, {@code false} if
	*/
	public boolean setRadio(boolean turnOn) {
	getPhoneService(false);
	/*
	* If the phone process has crashed in the past, we'll get a
	* RemoteException and need to re-reference the service.
	*/
	for (int retry = 0; retry < 2; retry++) {
	if (mPhoneService == null) {
	Log.w(TAG,
	"Ignoring mobile radio request because could not acquire PhoneService");
	break;
	}

	try {
	return mPhoneService.setRadio(turnOn);
	} catch (RemoteException e) {
	if (retry == 0) getPhoneService(true);
	}
	}

	Log.w(TAG, "Could not set radio power to " + (turnOn ? "on" : "off"));
	return false;
	}

	/**
	* Tells the phone sub-system that the caller wants to
	* begin using the named feature. The only supported feature at
	* this time is {@code Phone.FEATURE_ENABLE_MMS}, which allows an application
	* to specify that it wants to send and/or receive MMS data.
	* @param feature the name of the feature to be used
	* @param callingPid the process ID of the process that is issuing this request
	* @param callingUid the user ID of the process that is issuing this request
	* @return an integer value representing the outcome of the request.
	* The interpretation of this value is feature-specific.
	* specific, except that the value {@code -1}
	* always indicates failure. For {@code Phone.FEATURE_ENABLE_MMS},
	* the other possible return values are
	* <ul>
	* <li>{@code Phone.APN_ALREADY_ACTIVE}</li>
	* <li>{@code Phone.APN_REQUEST_STARTED}</li>
	* <li>{@code Phone.APN_TYPE_NOT_AVAILABLE}</li>
	* <li>{@code Phone.APN_REQUEST_FAILED}</li>
	* </ul>
	*/
	public int startUsingNetworkFeature(String feature, int callingPid, int callingUid) {
	if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_MMS)) {
	mLastCallingPid = callingPid;
	return setEnableApn(Phone.APN_TYPE_MMS, true);
	} else {
	return -1;
	}
	}

	/**
	* Tells the phone sub-system that the caller is finished
	* using the named feature. The only supported feature at
	* this time is {@code Phone.FEATURE_ENABLE_MMS}, which allows an application
	* to specify that it wants to send and/or receive MMS data.
	* @param feature the name of the feature that is no longer needed
	* @param callingPid the process ID of the process that is issuing this request
	* @param callingUid the user ID of the process that is issuing this request
	* @return an integer value representing the outcome of the request.
	* The interpretation of this value is feature-specific, except that
	* the value {@code -1} always indicates failure.
	*/
	public int stopUsingNetworkFeature(String feature, int callingPid, int callingUid) {
	if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_MMS)) {
	return setEnableApn(Phone.APN_TYPE_MMS, false);
	} else {
	return -1;
	}
	}

	/**
	* Ensure that a network route exists to deliver traffic to the specified
	* host via the mobile data network.
	* @param hostAddress the IP address of the host to which the route is desired,
	* in network byte order.
	* @return {@code true} on success, {@code false} on failure
	*/
	@Override
	public boolean requestRouteToHost(int hostAddress) {
	if (mInterfaceName != null && hostAddress != -1) {
	if (DBG) {
	Log.d(TAG, "Requested host route to " + Integer.toHexString(hostAddress));
	}
	return NetworkUtils.addHostRoute(mInterfaceName, hostAddress) == 0;
	} else {
	return false;
	}
	}

	@Override
	public String toString() {
	StringBuffer sb = new StringBuffer("Mobile data state: ");

	sb.append(mMobileDataState);
	return sb.toString();
	}

	private void setupDnsProperties() {
	mDnsServers.clear();
	// Set up per-process DNS server list on behalf of the MMS process
	int i = 1;
	if (mInterfaceName != null) {
	for (String propName : sDnsPropNames) {
	if (propName.indexOf(mInterfaceName) != -1) {
	String propVal = SystemProperties.get(propName);
	if (propVal != null && propVal.length() != 0 && !propVal.equals("0.0.0.0")) {
	mDnsServers.add(propVal);
	if (mLastCallingPid != -1) {
	SystemProperties.set("net.dns" + i + "." + mLastCallingPid, propVal);
	}
	++i;
	}
	}
	}
	}
	if (i == 1) {
	Log.d(TAG, "DNS server addresses are not known.");
	} else if (mLastCallingPid != -1) {
	/*
	* Bump the property that tells the name resolver library
	* to reread the DNS server list from the properties.
	*/
	String propVal = SystemProperties.get("net.dnschange");
	if (propVal.length() != 0) {
	try {
	int n = Integer.parseInt(propVal);
	SystemProperties.set("net.dnschange", "" + (n+1));
	} catch (NumberFormatException e) {
	}
	}
	}
	mLastCallingPid = -1;
	}

	/**
	* Internal method supporting the ENABLE_MMS feature.
	* @param apnType the type of APN to be enabled or disabled (e.g., mms)
	* @param enable {@code true} to enable the specified APN type,
	* {@code false} to disable it.
	* @return an integer value representing the outcome of the request.
	*/
	private int setEnableApn(String apnType, boolean enable) {
	getPhoneService(false);
	/*
	* If the phone process has crashed in the past, we'll get a
	* RemoteException and need to re-reference the service.
	*/
	for (int retry = 0; retry < 2; retry++) {
	if (mPhoneService == null) {
	Log.w(TAG,
	"Ignoring feature request because could not acquire PhoneService");
	break;
	}

	try {
	if (enable) {
	return mPhoneService.enableApnType(apnType);
	} else {
	return mPhoneService.disableApnType(apnType);
	}
	} catch (RemoteException e) {
	if (retry == 0) getPhoneService(true);
	}
	}

	Log.w(TAG, "Could not " + (enable ? "enable" : "disable")
	+ " APN type \"" + apnType + "\"");
	return Phone.APN_REQUEST_FAILED;
	}
	}