1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
* Copyright (C) 2010 The Android-x86 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.
*
* Author: Yi Sun <beyounn@gmail.com>
*/
package com.android.server;
import java.net.UnknownHostException;
import android.net.ethernet.EthernetNative;
import android.net.ethernet.IEthernetManager;
import android.net.ethernet.EthernetManager;
import android.net.ethernet.EthernetStateTracker;
import android.net.ethernet.EthernetDevInfo;
import android.net.ethernet.EthernetStateMachine;
import android.provider.Settings;
import android.util.Slog;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.SystemProperties;
/**
* EthernetService handles remote Ethernet operation requests by implementing
* the IEthernetManager interface. It also creates a EtherentMonitor to listen
* for Etherent-related events.
*
* @hide
*/
public class EthernetService<syncronized> extends IEthernetManager.Stub {
private static final String TAG = "EthernetService";
private static final int ETHERNET_HAS_CONFIG = 1;
private static final boolean localLOGV = true;
private final EthernetStateMachine mEthernetStateMachine;
private int mEthState= EthernetManager.ETHERNET_STATE_UNKNOWN;
private Context mContext;
private String[] DevName;
private int isEnabled ;
private String mInterfaceName;
public EthernetService(Context context) {
mContext = context;
mInterfaceName = SystemProperties.get("ethernet.interface", "eth0");
mEthernetStateMachine = new EthernetStateMachine(mContext, mInterfaceName);
}
/**
* Check if Wi-Fi needs to be enabled and start
* if needed
*
* This function is used only at boot time
*/
public void checkAndStartEthernet() {
isEnabled = getPersistedState();
if (localLOGV == true) Slog.i(TAG, "Ethernet dev enabled " + isEnabled);
getDeviceNameList();
setState(isEnabled);
mEthernetStateMachine.startMonitoring(mContext);
}
/**
* check if the ethernet service has been configured.
* @return {@code true} if configured {@code false} otherwise
*/
public boolean isConfigured() {
final ContentResolver cr = mContext.getContentResolver();
return (Settings.Secure.getInt(cr, Settings.Secure.ETHERNET_CONF, 0) == ETHERNET_HAS_CONFIG);
}
/**
* Return the saved ethernet configuration
* @return ethernet interface configuration on success, {@code null} on failure
*/
public synchronized EthernetDevInfo getSavedConfig() {
if (!isConfigured())
return null;
final ContentResolver cr = mContext.getContentResolver();
EthernetDevInfo info = new EthernetDevInfo();
info.setConnectMode(Settings.Secure.getString(cr, Settings.Secure.ETHERNET_MODE));
info.setIfName(Settings.Secure.getString(cr, Settings.Secure.ETHERNET_IFNAME));
info.setIpAddress(Settings.Secure.getString(cr, Settings.Secure.ETHERNET_IP));
info.setDnsAddr(Settings.Secure.getString(cr, Settings.Secure.ETHERNET_DNS));
info.setNetMask(Settings.Secure.getString(cr, Settings.Secure.ETHERNET_MASK));
info.setRouteAddr(Settings.Secure.getString(cr, Settings.Secure.ETHERNET_ROUTE));
return info;
}
/**
* Set the ethernet interface configuration mode
* @param mode {@code ETHERNET_CONN_MODE_DHCP} for dhcp {@code ETHERNET_CONN_MODE_MANUAL} for manual configure
*/
public synchronized void setMode(String mode) {
final ContentResolver cr = mContext.getContentResolver();
if (DevName != null) {
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_IFNAME, DevName[0]);
Settings.Secure.putInt(cr, Settings.Secure.ETHERNET_CONF, 1);
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_MODE, mode);
}
}
/**
* update a ethernet interface information
* @param info the interface infomation
*/
public synchronized void updateDevInfo(EthernetDevInfo info) {
final ContentResolver cr = mContext.getContentResolver();
Settings.Secure.putInt(cr, Settings.Secure.ETHERNET_CONF, 1);
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_IFNAME, info.getIfName());
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_IP, info.getIpAddress());
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_MODE, info.getConnectMode());
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_DNS, info.getDnsAddr());
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_ROUTE, info.getRouteAddr());
Settings.Secure.putString(cr, Settings.Secure.ETHERNET_MASK, info.getNetMask());
if (mEthState == EthernetManager.ETHERNET_STATE_ENABLED) {
try {
mEthernetStateMachine.resetInterface();
} catch (UnknownHostException e) {
Slog.e(TAG, "Wrong ethernet configuration");
}
}
}
/**
* get the number of ethernet interfaces in the system
* @return the number of ethernet interfaces
*/
public int getTotalInterface() {
return EthernetNative.getInterfaceCnt();
}
private int scanDevice() {
int i, j;
if ((i = EthernetNative.getInterfaceCnt()) == 0)
return 0;
DevName = new String[i];
for (j = 0; j < i; j++) {
DevName[j] = EthernetNative.getInterfaceName(j);
if (DevName[j] == null)
break;
if (localLOGV) Slog.v(TAG, "device " + j + " name " + DevName[j]);
}
return i;
}
/**
* get all the ethernet device names
* @return interface name list on success, {@code null} on failure
*/
public String[] getDeviceNameList() {
return (scanDevice() > 0) ? DevName : null;
}
private int getPersistedState() {
final ContentResolver cr = mContext.getContentResolver();
try {
return Settings.Secure.getInt(cr, Settings.Secure.ETHERNET_ON);
} catch (Settings.SettingNotFoundException e) {
return EthernetManager.ETHERNET_STATE_UNKNOWN;
}
}
private synchronized void persistEnabled(boolean enabled) {
final ContentResolver cr = mContext.getContentResolver();
Settings.Secure.putInt(cr, Settings.Secure.ETHERNET_ON, enabled ? EthernetManager.ETHERNET_STATE_ENABLED : EthernetManager.ETHERNET_STATE_DISABLED);
}
/**
* Enable or Disable a ethernet service
* @param enable {@code true} to enable, {@code false} to disable
*/
public synchronized void setState(int state) {
if (mEthState != state) {
mEthState = state;
if (state == EthernetManager.ETHERNET_STATE_DISABLED) {
Slog.e(TAG, "EthernetManager.ETHERNET_STATE_DISABLED");
persistEnabled(false);
mEthernetStateMachine.stopInterface(false);
} else {
Slog.e(TAG, "EthernetManager.ETHERNET_STATE_ENABLED");
persistEnabled(true);
if (!isConfigured()) {
// If user did not configure any interfaces yet, pick the first one
// and enable it.
setMode(EthernetDevInfo.ETHERNET_CONN_MODE_DHCP);
}
try {
mEthernetStateMachine.resetInterface();
} catch (UnknownHostException e) {
Slog.e(TAG, "Wrong ethernet configuration");
}
}
}
}
public void reconnect() {
mEthernetStateMachine.reconnectCommand();
}
/**
* Get ethernet service state
* @return the state of the ethernet service
*/
public int getState( ) {
return mEthState;
}
public void startEthernet() {
}
public void stopEthernet() {
}
}
|
