core/java/android/net/DummyDataStateTracker.java

   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
  17 package android.net;
  18
  19 import android.content.Context;
  20 import android.os.Handler;
  21 import android.os.Message;
  22 import android.os.Messenger;
  23 import 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  */
  32 public 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 }