1/*
2 * Copyright (C) 2010 The Android 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
17package android.net;
18
19import android.content.Context;
20import android.os.Handler;
21import android.os.Message;
22import android.os.Messenger;
23import android.util.Slog;
24
25/**
26 * A dummy data state tracker for use when we don't have a real radio
27 * connection.  useful when bringing up a board or when you have network
28 * access through other means.
29 *
30 * {@hide}
31 */
32public class DummyDataStateTracker implements NetworkStateTracker {
33
34    private static final String TAG = "DummyDataStateTracker";
35    private static final boolean DBG = true;
36    private static final boolean VDBG = false;
37
38    private NetworkInfo mNetworkInfo;
39    private boolean mTeardownRequested = false;
40    private Handler mTarget;
41    private Context mContext;
42    private LinkProperties mLinkProperties;
43    private LinkCapabilities mLinkCapabilities;
44    private boolean mPrivateDnsRouteSet = false;
45    private boolean mDefaultRouteSet = false;
46
47    // DEFAULT and HIPRI are the same connection.  If we're one of these we need to check if
48    // the other is also disconnected before we reset sockets
49    private boolean mIsDefaultOrHipri = false;
50
51    /**
52     * Create a new DummyDataStateTracker
53     * @param netType the ConnectivityManager network type
54     * @param tag the name of this network
55     */
56    public DummyDataStateTracker(int netType, String tag) {
57        mNetworkInfo = new NetworkInfo(netType);
58    }
59
60    /**
61     * Begin monitoring data connectivity.
62     *
63     * @param context is the current Android context
64     * @param target is the Handler to which to return the events.
65     */
66    public void startMonitoring(Context context, Handler target) {
67        mTarget = target;
68        mContext = context;
69    }
70
71    public boolean isPrivateDnsRouteSet() {
72        return mPrivateDnsRouteSet;
73    }
74
75    public void privateDnsRouteSet(boolean enabled) {
76        mPrivateDnsRouteSet = enabled;
77    }
78
79    public NetworkInfo getNetworkInfo() {
80        return mNetworkInfo;
81    }
82
83    public boolean isDefaultRouteSet() {
84        return mDefaultRouteSet;
85    }
86
87    public void defaultRouteSet(boolean enabled) {
88        mDefaultRouteSet = enabled;
89    }
90
91    /**
92     * This is not implemented.
93     */
94    public void releaseWakeLock() {
95    }
96
97    /**
98     * Report whether data connectivity is possible.
99     */
100    public boolean isAvailable() {
101        return true;
102    }
103
104    /**
105     * Return the system properties name associated with the tcp buffer sizes
106     * for this network.
107     */
108    public String getTcpBufferSizesPropName() {
109        return "net.tcp.buffersize.unknown";
110    }
111
112    /**
113     * Tear down mobile data connectivity, i.e., disable the ability to create
114     * mobile data connections.
115     * TODO - make async and return nothing?
116     */
117    public boolean teardown() {
118        setDetailedState(NetworkInfo.DetailedState.DISCONNECTING, "disabled", null);
119        setDetailedState(NetworkInfo.DetailedState.DISCONNECTED, "disabled", null);
120        return true;
121    }
122
123    public void captivePortalCheckComplete() {
124        // not implemented
125    }
126
127    /**
128     * Record the detailed state of a network, and if it is a
129     * change from the previous state, send a notification to
130     * any listeners.
131     * @param state the new {@code DetailedState}
132     * @param reason a {@code String} indicating a reason for the state change,
133     * if one was supplied. May be {@code null}.
134     * @param extraInfo optional {@code String} providing extra information about the state change
135     */
136    private void setDetailedState(NetworkInfo.DetailedState state, String reason,
137            String extraInfo) {
138        if (DBG) log("setDetailed state, old ="
139                + mNetworkInfo.getDetailedState() + " and new state=" + state);
140        mNetworkInfo.setDetailedState(state, reason, extraInfo);
141        Message msg = mTarget.obtainMessage(EVENT_STATE_CHANGED, mNetworkInfo);
142        msg.sendToTarget();
143    }
144
145    public void setTeardownRequested(boolean isRequested) {
146        mTeardownRequested = isRequested;
147    }
148
149    public boolean isTeardownRequested() {
150        return mTeardownRequested;
151    }
152
153    /**
154     * Re-enable mobile data connectivity after a {@link #teardown()}.
155     * TODO - make async and always get a notification?
156     */
157    public boolean reconnect() {
158        setDetailedState(NetworkInfo.DetailedState.CONNECTING, "enabled", null);
159        setDetailedState(NetworkInfo.DetailedState.CONNECTED, "enabled", null);
160        setTeardownRequested(false);
161        return true;
162    }
163
164    /**
165     * Turn on or off the mobile radio. No connectivity will be possible while the
166     * radio is off. The operation is a no-op if the radio is already in the desired state.
167     * @param turnOn {@code true} if the radio should be turned on, {@code false} if
168     */
169    public boolean setRadio(boolean turnOn) {
170        return true;
171    }
172
173    @Override
174    public void setUserDataEnable(boolean enabled) {
175        // ignored
176    }
177
178    @Override
179    public void setPolicyDataEnable(boolean enabled) {
180        // ignored
181    }
182
183    @Override
184    public String toString() {
185        StringBuffer sb = new StringBuffer("Dummy data state: none, dummy!");
186        return sb.toString();
187    }
188
189    /**
190     * @see android.net.NetworkStateTracker#getLinkProperties()
191     */
192    public LinkProperties getLinkProperties() {
193        return new LinkProperties(mLinkProperties);
194    }
195
196    /**
197     * @see android.net.NetworkStateTracker#getLinkCapabilities()
198     */
199    public LinkCapabilities getLinkCapabilities() {
200        return new LinkCapabilities(mLinkCapabilities);
201    }
202
203    public void setDependencyMet(boolean met) {
204        // not supported on this network
205    }
206
207    @Override
208    public void addStackedLink(LinkProperties link) {
209        mLinkProperties.addStackedLink(link);
210    }
211
212    @Override
213    public void removeStackedLink(LinkProperties link) {
214        mLinkProperties.removeStackedLink(link);
215    }
216
217    @Override
218    public void supplyMessenger(Messenger messenger) {
219        // not supported on this network
220    }
221
222    static private void log(String s) {
223        Slog.d(TAG, s);
224    }
225
226    static private void loge(String s) {
227        Slog.e(TAG, s);
228    }
229}
230