--- /dev/null
+package com.android.commands.svc;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.IConnectivityManager;
+import android.net.ethernet.IEthernetManager;
+import android.net.ethernet.EthernetManager;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.util.Log;
+
+public class EthernetCommand extends Svc.Command{
+ public static final String TAG = "Ethernet_SVC";
+ public EthernetCommand() {
+ super("ethernet");
+ // TODO Auto-generated constructor stub
+ }
+ public String shortHelp() {
+ return "Control the Ethernet manager";
+ }
+
+ public String longHelp() {
+ return shortHelp() + "\n"
+ + "\n"
+ + "usage: svc ethernet [enable|disable]\n"
+ + " Turn Ethernet on or off.\n\n"
+ + " svc wifi prefer\n"
+ + " Set Ethernet as the preferred data network\n";
+ }
+
+ public void run(String[] args) {
+ Log.i(TAG, "kick off etherent" + args);
+ boolean validCommand = false;
+ if (args.length >= 2) {
+ boolean flag = false;
+ if ("enable".equals(args[1])) {
+ flag = true;
+ validCommand = true;
+ } else if ("disable".equals(args[1])) {
+ flag = false;
+ validCommand = true;
+ } else if ("prefer".equals(args[1])) {
+ IConnectivityManager connMgr =
+ IConnectivityManager.Stub.asInterface(ServiceManager.getService(Context.CONNECTIVITY_SERVICE));
+ try {
+ connMgr.setNetworkPreference(ConnectivityManager.TYPE_ETH);
+ } catch (RemoteException e) {
+ System.err.println("Failed to set preferred network: " + e);
+ }
+ return;
+ }
+ if (validCommand) {
+ IEthernetManager ethMgr
+ = IEthernetManager.Stub.asInterface(ServiceManager.getService(Context.ETH_SERVICE));
+ try {
+ ethMgr.setEthState(flag ? EthernetManager.ETH_STATE_ENABLED:EthernetManager.ETH_STATE_DISABLED);
+ }
+ catch (RemoteException e) {
+ System.err.println("Wi-Fi operation failed: " + e);
+ }
+ return;
+ }
+ }
+ System.err.println(longHelp());
+ }
+}
COMMAND_HELP,
new PowerCommand(),
new DataCommand(),
- new WifiCommand()
+ new WifiCommand(),
+ new EthernetCommand()
};
}
public static final String EXTRA_ETH_STATE = "eth_state";
public static final String EXTRA_PREVIOUS_ETH_STATE = "previous_eth_state";
- public static final int ETH_STATE_DISABLING = 0;
public static final int ETH_STATE_DISABLED = 1;
- public static final int ETH_STATE_ENABLING = 2;
- public static final int ETH_STATE_ENABLED = 3;
- public static final int ETH_STATE_UNKNOWN = 4;
+ public static final int ETH_STATE_ENABLED = 2;
+ public static final int ETH_STATE_UNKNOWN = 0;
IEthernetManager mService;
Handler mHandler;
return mService.isEthConfigured();
} catch (RemoteException e) {
Log.i(TAG, "Can not check eth config state");
- }
+ }
return false;
}
}
public boolean ethConfigured() {
- return true;
+ try {
+ return mService.isEthConfigured();
+ } catch (RemoteException e) {
+ return false;
+ }
+
}
public int getTotalInterface() {
try {
return mService.getTotalInterface();
} catch (RemoteException e) {
- return 0;
+ return 0;
}
}
+
+ public void ethSetDefaultConf() {
+ try {
+ mService.setEthMode(EthernetDevInfo.ETH_CONN_MODE_DHCP);
+ } catch (RemoteException e) {
+ }
+ }
+
}
}
public boolean stopInteface() {
- EthernetDevInfo info = mEM.getSavedEthConfig();
- if (info != null && mEM.ethConfigured())
- {
- synchronized (mDhcpTarget) {
- mInterfaceStopped = true;
- Log.i(TAG, "stop dhcp and interface");
- mDhcpTarget.removeMessages(EVENT_DHCP_START);
- String ifname = info.getIfName();
-
- if (!NetworkUtils.stopDhcp(ifname)) {
- Log.e(TAG, "Could not stop DHCP");
- }
- NetworkUtils.resetConnections(ifname);
- NetworkUtils.disableInterface(ifname);
+ if (mEM != null) {
+ EthernetDevInfo info = mEM.getSavedEthConfig();
+ if (info != null && mEM.ethConfigured())
+ {
+ synchronized (mDhcpTarget) {
+ mInterfaceStopped = true;
+ Log.i(TAG, "stop dhcp and interface");
+ mDhcpTarget.removeMessages(EVENT_DHCP_START);
+ String ifname = info.getIfName();
+
+ if (!NetworkUtils.stopDhcp(ifname)) {
+ Log.e(TAG, "Could not stop DHCP");
+ }
+ NetworkUtils.resetConnections(ifname);
+ NetworkUtils.disableInterface(ifname);
+ }
}
}
}
@Override
public boolean isAvailable() {
- return (mEM.getTotalInterface() != 0);
+ //Only say available if we have interfaces and user did not disable us.
+ return ((mEM.getTotalInterface() != 0) && (mEM.getEthState() != EthernetManager.ETH_STATE_DISABLED));
}
@Override
public boolean reconnect() {
try {
- return resetInterface();
+ synchronized (this) {
+ if (mHWConnected && mStackConnected)
+ return true;
+ }
+ if (mEM.getEthState() != EthernetManager.ETH_STATE_DISABLED ) {
+ // maybe this is the first time we run, so set it to enabled
+ mEM.setEthEnabled(true);
+ if (!mEM.ethConfigured()) {
+ mEM.ethSetDefaultConf();
+ }
+ return resetInterface();
+ }
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
Log.i(TAG,"start to monitor the ethernet devices");
if (mServiceStarted ) {
mEM = (EthernetManager)mContext.getSystemService(Context.ETH_SERVICE);
- if (mEM.getEthState()==mEM.ETH_STATE_ENABLED) {
- try {
- resetInterface();
- } catch (UnknownHostException e) {
- Log.e(TAG, "Wrong ethernet configuration");
+ int state = mEM.getEthState();
+ if (state !=mEM.ETH_STATE_DISABLED) {
+ if (state == mEM.ETH_STATE_UNKNOWN){
+ // maybe this is the first time we run, so set it to enabled
+ mEM.setEthEnabled(true);
+ } else {
+ try {
+ resetInterface();
+ } catch (UnknownHostException e) {
+ Log.e(TAG, "Wrong ethernet configuration");
+ }
}
}
}
-
}
+
@Override
public int startUsingNetworkFeature(String feature, int callingPid,
int callingUid) {
boolean isEthConfigured();
EthernetDevInfo getSavedEthConfig();
int getTotalInterface();
-}
\ No newline at end of file
+ void setEthMode(String mode);
+}
mTestMode = SystemProperties.get("cm.test.mode").equals("true")
&& SystemProperties.get("ro.build.type").equals("eng");
-
+ if (DBG) Log.v(TAG, "set Ethernet Service as prefer service");
+ setNetworkPreference(ConnectivityManager.TYPE_ETH);
for (NetworkStateTracker t : mNetTrackers)
t.startMonitoring();
// Constructing this starts it too
mWifiWatchdogService = new WifiWatchdogService(context, mWifiStateTracker);
+
+ //if (DBG) Log.v(TAG, "Starting Ethernet connection by default");
+ //if (mEthernetStateTracker.isAvailable())
+ // mEthernetStateTracker.reconnect();
}
/**
* (see {@link #handleDisconnect(NetworkInfo)}).
*/
private void enforcePreference() {
- if (mActiveNetwork == null)
+ if (mActiveNetwork == null) {
+ Log.i(TAG, "no active networks");
return;
+ }
for (NetworkStateTracker t : mNetTrackers) {
if (t == mActiveNetwork) {
int netType = t.getNetworkInfo().getType();
if (t.getNetworkInfo().getType() != mNetworkPreference) {
- NetworkStateTracker otherTracker;
- switch (netType) {
- case ConnectivityManager.TYPE_WIFI:
- otherTracker = mNetTrackers[ConnectivityManager.TYPE_MOBILE];
- if (otherTracker.isAvailable()) {
- teardown(t);
- }
- otherTracker = mNetTrackers[ConnectivityManager.TYPE_ETH];
- if (otherTracker.isAvailable()) {
- teardown(t);
- }
- break;
- case ConnectivityManager.TYPE_MOBILE:
- otherTracker = mNetTrackers[ConnectivityManager.TYPE_WIFI];
- if (otherTracker.isAvailable()) {
- teardown(t);
- }
- otherTracker = mNetTrackers[ConnectivityManager.TYPE_ETH];
- if (otherTracker.isAvailable()) {
- teardown(t);
- }
- break;
- case ConnectivityManager.TYPE_ETH:
- otherTracker = mNetTrackers[ConnectivityManager.TYPE_MOBILE];
- if (otherTracker.isAvailable()) {
- teardown(t);
- }
- otherTracker = mNetTrackers[ConnectivityManager.TYPE_WIFI];
- if (otherTracker.isAvailable()) {
- teardown(t);
- }
- break;
- }
+ NetworkStateTracker otherTracker;
+ switch (netType) {
+ case ConnectivityManager.TYPE_WIFI:
+ otherTracker = mNetTrackers[ConnectivityManager.TYPE_MOBILE];
+ if (otherTracker.isAvailable()) {
+ teardown(t);
+ }
+ otherTracker = mNetTrackers[ConnectivityManager.TYPE_ETH];
+ if (otherTracker.isAvailable()) {
+ teardown(t);
+ }
+ break;
+ case ConnectivityManager.TYPE_MOBILE:
+ otherTracker = mNetTrackers[ConnectivityManager.TYPE_WIFI];
+ if (otherTracker.isAvailable()) {
+ teardown(t);
+ }
+ otherTracker = mNetTrackers[ConnectivityManager.TYPE_ETH];
+ if (otherTracker.isAvailable()) {
+ teardown(t);
+ }
+ break;
+ case ConnectivityManager.TYPE_ETH:
+ otherTracker = mNetTrackers[ConnectivityManager.TYPE_MOBILE];
+ if (otherTracker.isAvailable()) {
+ teardown(t);
+ }
+ otherTracker = mNetTrackers[ConnectivityManager.TYPE_WIFI];
+ if (otherTracker.isAvailable()) {
+ teardown(t);
+ }
+ break;
+ }
}
}
}
newNet = mWifiStateTracker;
break;
default:
- newNet=mWifiStateTracker;
+ newNet=mEthernetStateTracker;
}
// snapshot isFailover, because sendConnectedBroadcast() resets it
boolean isFailover = info.isFailover();
NetworkStateTracker thisNet = mNetTrackers[info.getType()];
- NetworkStateTracker deadnet = null;
+ NetworkStateTracker[] deadnet=null;
NetworkStateTracker otherNet;
if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
otherNet = mWifiStateTracker;
- } else /* info().getType() == TYPE_WIFI */ {
- otherNet = mMobileDataStateTracker;
+ } else if(info.getType() == ConnectivityManager.TYPE_WIFI ) {
+ otherNet = mEthernetStateTracker;
+ } else {
+ otherNet = mWifiStateTracker;
}
/*
* Check policy to see whether we are connected to a non-preferred
*/
NetworkInfo wifiInfo = mWifiStateTracker.getNetworkInfo();
NetworkInfo mobileInfo = mMobileDataStateTracker.getNetworkInfo();
- if (wifiInfo.isConnected() && mobileInfo.isConnected()) {
- if (mNetworkPreference == ConnectivityManager.TYPE_WIFI)
- deadnet = mMobileDataStateTracker;
- else
- deadnet = mWifiStateTracker;
+ NetworkInfo ethInfo = mEthernetStateTracker.getNetworkInfo();
+ int connected = 0 , i;
+ if (wifiInfo.isConnected()) connected++;
+ if (mobileInfo.isConnected()) connected++;
+ if (ethInfo.isConnected()) connected++;
+ if (connected >=2 ) {
+ deadnet = new NetworkStateTracker[2];
+ switch (mNetworkPreference) {
+ case ConnectivityManager.TYPE_WIFI:
+ deadnet[0] = mMobileDataStateTracker;
+ deadnet[1] = mEthernetStateTracker;
+ case ConnectivityManager.TYPE_MOBILE:
+ deadnet[0] = mWifiStateTracker;
+ deadnet[1] = mEthernetStateTracker;
+ case ConnectivityManager.TYPE_ETH:
+ deadnet[0] = mWifiStateTracker;
+ deadnet[1] = mMobileDataStateTracker;
+ }
}
boolean toredown = false;
thisNet.setTeardownRequested(false);
if (!mTestMode && deadnet != null) {
- if (DBG) Log.v(TAG, "Policy requires " +
- deadnet.getNetworkInfo().getTypeName() + " teardown");
- toredown = teardown(deadnet);
- if (DBG && !toredown) {
- Log.d(TAG, "Network declined teardown request");
+ for (i = 0 ; i < 2; i ++) {
+ if (DBG) Log.v(TAG, "Policy requires " +
+ deadnet[i].getNetworkInfo().getTypeName() + " teardown");
+ toredown = teardown(deadnet[i]);
+ if (DBG && !toredown) {
+ Log.d(TAG, "Network declined teardown request");
+ }
}
}
* Note that if toredown is true, deadnet cannot be null, so there is
* no danger of a null pointer exception here..
*/
- if (!toredown || deadnet.getNetworkInfo().getType() != info.getType()) {
+ if (!toredown || (deadnet[0].getNetworkInfo().getType() != info.getType() &&
+ deadnet[1].getNetworkInfo().getType() != info.getType())) {
mActiveNetwork = thisNet;
if (DBG) Log.v(TAG, "Sending CONNECT bcast for " + info.getTypeName());
thisNet.updateNetworkSettings();
private EthernetStateTracker mTracker;
private String[] DevName;
private static final String TAG = "EthernetService";
- private boolean isEthEnabled ;
- private int mEthState= EthernetManager.ETH_STATE_DISABLED;
+ private int isEthEnabled ;
+ private int mEthState= EthernetManager.ETH_STATE_UNKNOWN;
public EthernetService(Context context, EthernetStateTracker Tracker){
mTracker = Tracker;
mContext = context;
- isEthEnabled = getPersistedEthEnabled();
+ isEthEnabled = getPersistedState();
Log.i(TAG,"Ethernet dev enabled " + isEthEnabled );
- setEthState(isEthEnabled ? EthernetManager.ETH_STATE_ENABLED:EthernetManager.ETH_STATE_DISABLED);
+ getDeviceNameList();
+ setEthState(isEthEnabled);
Log.i(TAG, "Trigger the ethernet monitor");
mTracker.StartPolling();
}
public boolean isEthConfigured() {
final ContentResolver cr = mContext.getContentResolver();
- int x = Settings.Secure.getInt(cr, Settings.Secure.ETH_CONF,0);
+ int x = Settings.Secure.getInt(cr, Settings.Secure.ETH_CONF,0);
- if (x == 1)
- return true;
- return false;
+ if (x == 1)
+ return true;
+ return false;
}
public synchronized EthernetDevInfo getSavedEthConfig() {
}
+ public synchronized void setEthMode(String mode) {
+ final ContentResolver cr = mContext.getContentResolver();
+ if (DevName != null) {
+ Settings.Secure.putString(cr, Settings.Secure.ETH_IFNAME, DevName[0]);
+ Settings.Secure.putInt(cr, Settings.Secure.ETH_CONF,1);
+ Settings.Secure.putString(cr, Settings.Secure.ETH_MODE, mode);
+ }
+ }
+
public synchronized void UpdateEthDevInfo(EthernetDevInfo info) {
final ContentResolver cr = mContext.getContentResolver();
Settings.Secure.putInt(cr, Settings.Secure.ETH_CONF,1);
return null;
}
- private boolean getPersistedEthEnabled() {
+ private int getPersistedState() {
final ContentResolver cr = mContext.getContentResolver();
- try {
- return Settings.Secure.getInt(cr, Settings.Secure.ETH_ON) == 1;
- } catch (Settings.SettingNotFoundException e) {
- Settings.Secure.putInt(cr, Settings.Secure.ETH_ON, 0);
- return false;
- }
- }
+ try {
+ return Settings.Secure.getInt(cr, Settings.Secure.ETH_ON);
+ } catch (Settings.SettingNotFoundException e) {
+ return EthernetManager.ETH_STATE_UNKNOWN;
+ }
+ }
private synchronized void persistEthEnabled(boolean enabled) {
final ContentResolver cr = mContext.getContentResolver();
- Settings.Secure.putInt(cr, Settings.Secure.ETH_ON, enabled ? 1 : 0);
+ Settings.Secure.putInt(cr, Settings.Secure.ETH_ON,
+ enabled ? EthernetManager.ETH_STATE_ENABLED : EthernetManager.ETH_STATE_DISABLED);
}
public synchronized void setEthState(int state) {
mTracker.stopInteface();
} else {
persistEthEnabled(true);
+ if (!isEthConfigured()) {
+ // If user did not configure any interfaces yet, pick the first one
+ // and enable it.
+ setEthMode(EthernetDevInfo.ETH_CONN_MODE_DHCP);
+ }
try {
mTracker.resetInterface();
} catch (UnknownHostException e) {
public int getEthState( ) {
return mEthState;
}
+
}
OSDN Git Service
