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