frameworks/base/telephony/java/com/android/internal/telephony/DataConnectionTracker.java

   1 /*
   2  * Copyright (C) 2006 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 com.android.internal.telephony;
  18
  19 import android.app.PendingIntent;
  20 import android.os.AsyncResult;
  21 import android.os.Handler;
  22 import android.os.Message;
  23 import android.os.RemoteException;
  24 import android.provider.Settings;
  25 import android.provider.Settings.SettingNotFoundException;
  26 import android.text.TextUtils;
  27 import android.util.Log;
  28
  29 import java.util.ArrayList;
  30
  31 /**
  32  * {@hide}
  33  *
  34  */
  35 public abstract class DataConnectionTracker extends Handler {
  36     protected static final boolean DBG = false;
  37     protected final String LOG_TAG = "DataConnectionTracker";
  38
  39     /**
  40      * IDLE: ready to start data connection setup, default state
  41      * INITING: state of issued setupDefaultPDP() but not finish yet
  42      * CONNECTING: state of issued startPppd() but not finish yet
  43      * SCANNING: data connection fails with one apn but other apns are available
  44      *           ready to start data connection on other apns (before INITING)
  45      * CONNECTED: IP connection is setup
  46      * DISCONNECTING: Connection.disconnect() has been called, but PDP
  47      *                context is not yet deactivated
  48      * FAILED: data connection fail for all apns settings
  49      *
  50      * getDataConnectionState() maps State to DataState
  51      *      FAILED or IDLE : DISCONNECTED
  52      *      INITING or CONNECTING or SCANNING: CONNECTING
  53      *      CONNECTED : CONNECTED or DISCONNECTING
  54      */
  55     public enum State {
  56         IDLE,
  57         INITING,
  58         CONNECTING,
  59         SCANNING,
  60         CONNECTED,
  61         DISCONNECTING,
  62         FAILED
  63     }
  64
  65     public enum Activity {
  66         NONE,
  67         DATAIN,
  68         DATAOUT,
  69         DATAINANDOUT,
  70         DORMANT
  71     }
  72
  73     /***** Event Codes *****/
  74     protected static final int EVENT_DATA_SETUP_COMPLETE = 1;
  75     protected static final int EVENT_RADIO_AVAILABLE = 3;
  76     protected static final int EVENT_RECORDS_LOADED = 4;
  77     protected static final int EVENT_TRY_SETUP_DATA = 5;
  78     protected static final int EVENT_DATA_STATE_CHANGED = 6;
  79     protected static final int EVENT_POLL_PDP = 7;
  80     protected static final int EVENT_GET_PDP_LIST_COMPLETE = 11;
  81     protected static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 12;
  82     protected static final int EVENT_VOICE_CALL_STARTED = 14;
  83     protected static final int EVENT_VOICE_CALL_ENDED = 15;
  84     protected static final int EVENT_GPRS_DETACHED = 19;
  85     protected static final int EVENT_LINK_STATE_CHANGED = 20;
  86     protected static final int EVENT_ROAMING_ON = 21;
  87     protected static final int EVENT_ROAMING_OFF = 22;
  88     protected static final int EVENT_ENABLE_NEW_APN = 23;
  89     protected static final int EVENT_RESTORE_DEFAULT_APN = 24;
  90     protected static final int EVENT_DISCONNECT_DONE = 25;
  91     protected static final int EVENT_GPRS_ATTACHED = 26;
  92     protected static final int EVENT_START_NETSTAT_POLL = 27;
  93     protected static final int EVENT_START_RECOVERY = 28;
  94     protected static final int EVENT_APN_CHANGED = 29;
  95     protected static final int EVENT_CDMA_DATA_DETACHED = 30;
  96     protected static final int EVENT_NV_READY = 31;
  97     protected static final int EVENT_PS_RESTRICT_ENABLED = 32;
  98     protected static final int EVENT_PS_RESTRICT_DISABLED = 33;
  99     public static final int EVENT_CLEAN_UP_CONNECTION = 34;
 100     protected static final int EVENT_CDMA_OTA_PROVISION = 35;
 101     protected static final int EVENT_RESTART_RADIO = 36;
 102     protected static final int EVENT_SET_MASTER_DATA_ENABLE = 37;
 103     protected static final int EVENT_RESET_DONE = 38;
 104
 105     /***** Constants *****/
 106
 107     protected static final int APN_INVALID_ID = -1;
 108     protected static final int APN_DEFAULT_ID = 0;
 109     protected static final int APN_MMS_ID = 1;
 110     protected static final int APN_SUPL_ID = 2;
 111     protected static final int APN_DUN_ID = 3;
 112     protected static final int APN_HIPRI_ID = 4;
 113     protected static final int APN_NUM_TYPES = 5;
 114
 115     protected static final int DISABLED = 0;
 116     protected static final int ENABLED = 1;
 117
 118     // responds to the setDataEnabled call - used independently from the APN requests
 119     protected boolean mMasterDataEnabled = true;
 120
 121     protected boolean[] dataEnabled = new boolean[APN_NUM_TYPES];
 122     protected int enabledCount = 0;
 123
 124     /* Currently requested APN type */
 125     protected String mRequestedApnType = Phone.APN_TYPE_DEFAULT;
 126
 127     /** Retry configuration: A doubling of retry times from 5secs to 30minutes */
 128     protected static final String DEFAULT_DATA_RETRY_CONFIG = "default_randomization=2000,"
 129         + "5000,10000,20000,40000,80000:5000,160000:5000,"
 130         + "320000:5000,640000:5000,1280000:5000,1800000:5000";
 131
 132     /** Retry configuration for secondary networks: 4 tries in 20 sec */
 133     protected static final String SECONDARY_DATA_RETRY_CONFIG =
 134             "max_retries=3, 5000, 5000, 5000";
 135
 136     /** Slow poll when attempting connection recovery. */
 137     protected static final int POLL_NETSTAT_SLOW_MILLIS = 5000;
 138     /** Default ping deadline, in seconds. */
 139     protected static final int DEFAULT_PING_DEADLINE = 5;
 140     /** Default max failure count before attempting to network re-registration. */
 141     protected static final int DEFAULT_MAX_PDP_RESET_FAIL = 3;
 142
 143     /**
 144      * After detecting a potential connection problem, this is the max number
 145      * of subsequent polls before attempting a radio reset.  At this point,
 146      * poll interval is 5 seconds (POLL_NETSTAT_SLOW_MILLIS), so set this to
 147      * poll for about 2 more minutes.
 148      */
 149     protected static final int NO_RECV_POLL_LIMIT = 24;
 150
 151     // 1 sec. default polling interval when screen is on.
 152     protected static final int POLL_NETSTAT_MILLIS = 1000;
 153     // 10 min. default polling interval when screen is off.
 154     protected static final int POLL_NETSTAT_SCREEN_OFF_MILLIS = 1000*60*10;
 155     // 2 min for round trip time
 156     protected static final int POLL_LONGEST_RTT = 120 * 1000;
 157     // 10 for packets without ack
 158     protected static final int NUMBER_SENT_PACKETS_OF_HANG = 10;
 159     // how long to wait before switching back to default APN
 160     protected static final int RESTORE_DEFAULT_APN_DELAY = 1 * 60 * 1000;
 161     // system property that can override the above value
 162     protected static final String APN_RESTORE_DELAY_PROP_NAME = "android.telephony.apn-restore";
 163     // represents an invalid IP address
 164     protected static final String NULL_IP = "0.0.0.0";
 165
 166
 167     // member variables
 168     protected PhoneBase phone;
 169     protected Activity activity = Activity.NONE;
 170     protected State state = State.IDLE;
 171     protected Handler mDataConnectionTracker = null;
 172
 173
 174     protected long txPkts, rxPkts, sentSinceLastRecv;
 175     protected int netStatPollPeriod;
 176     protected int mNoRecvPollCount = 0;
 177     protected boolean netStatPollEnabled = false;
 178
 179     /** Manage the behavior of data retry after failure */
 180     protected RetryManager mRetryMgr = new RetryManager();
 181
 182     // wifi connection status will be updated by sticky intent
 183     protected boolean mIsWifiConnected = false;
 184
 185     /** Intent sent when the reconnect alarm fires. */
 186     protected PendingIntent mReconnectIntent = null;
 187
 188     /** CID of active data connection */
 189     protected int cidActive;
 190
 191    /**
 192      * Default constructor
 193      */
 194     protected DataConnectionTracker(PhoneBase phone) {
 195         super();
 196         this.phone = phone;
 197     }
 198
 199     public abstract void dispose();
 200
 201     public Activity getActivity() {
 202         return activity;
 203     }
 204
 205     public State getState() {
 206         return state;
 207     }
 208
 209     public String getStateInString() {
 210         switch (state) {
 211             case IDLE:          return "IDLE";
 212             case INITING:       return "INIT";
 213             case CONNECTING:    return "CING";
 214             case SCANNING:      return "SCAN";
 215             case CONNECTED:     return "CNTD";
 216             case DISCONNECTING: return "DING";
 217             case FAILED:        return "FAIL";
 218             default:            return "ERRO";
 219         }
 220     }
 221
 222     /**
 223      * The data connection is expected to be setup while device
 224      *  1. has Icc card
 225      *  2. registered for data service
 226      *  3. user doesn't explicitly disable data service
 227      *  4. wifi is not on
 228      *
 229      * @return false while no data connection if all above requirements are met.
 230      */
 231     public abstract boolean isDataConnectionAsDesired();
 232
 233     //The data roaming setting is now located in the shared preferences.
 234     //  See if the requested preference value is the same as that stored in
 235     //  the shared values.  If it is not, then update it.
 236     public void setDataOnRoamingEnabled(boolean enabled) {
 237         if (getDataOnRoamingEnabled() != enabled) {
 238             Settings.Secure.putInt(phone.getContext().getContentResolver(),
 239                 Settings.Secure.DATA_ROAMING, enabled ? 1 : 0);
 240             if (phone.getServiceState().getRoaming()) {
 241                 if (enabled) {
 242                     mRetryMgr.resetRetryCount();
 243                 }
 244                 sendMessage(obtainMessage(EVENT_ROAMING_ON));
 245             }
 246         }
 247     }
 248
 249     //Retrieve the data roaming setting from the shared preferences.
 250     public boolean getDataOnRoamingEnabled() {
 251         try {
 252             return Settings.Secure.getInt(phone.getContext().getContentResolver(),
 253                 Settings.Secure.DATA_ROAMING) > 0;
 254         } catch (SettingNotFoundException snfe) {
 255             return false;
 256         }
 257     }
 258
 259     // abstract handler methods
 260     protected abstract boolean onTrySetupData(String reason);
 261     protected abstract void onRoamingOff();
 262     protected abstract void onRoamingOn();
 263     protected abstract void onRadioAvailable();
 264     protected abstract void onRadioOffOrNotAvailable();
 265     protected abstract void onDataSetupComplete(AsyncResult ar);
 266     protected abstract void onDisconnectDone(AsyncResult ar);
 267     protected abstract void onResetDone(AsyncResult ar);
 268     protected abstract void onVoiceCallStarted();
 269     protected abstract void onVoiceCallEnded();
 270     protected abstract void onCleanUpConnection(boolean tearDown, String reason);
 271
 272     @Override
 273     public void handleMessage (Message msg) {
 274         switch (msg.what) {
 275
 276             case EVENT_ENABLE_NEW_APN:
 277                 onEnableApn(msg.arg1, msg.arg2);
 278                 break;
 279
 280             case EVENT_TRY_SETUP_DATA:
 281                 String reason = null;
 282                 if (msg.obj instanceof String) {
 283                     reason = (String)msg.obj;
 284                 }
 285                 onTrySetupData(reason);
 286                 break;
 287
 288             case EVENT_ROAMING_OFF:
 289                 if (getDataOnRoamingEnabled() == false) {
 290                     mRetryMgr.resetRetryCount();
 291                 }
 292                 onRoamingOff();
 293                 break;
 294
 295             case EVENT_ROAMING_ON:
 296                 onRoamingOn();
 297                 break;
 298
 299             case EVENT_RADIO_AVAILABLE:
 300                 onRadioAvailable();
 301                 break;
 302
 303             case EVENT_RADIO_OFF_OR_NOT_AVAILABLE:
 304                 onRadioOffOrNotAvailable();
 305                 break;
 306
 307             case EVENT_DATA_SETUP_COMPLETE:
 308                 cidActive = msg.arg1;
 309                 onDataSetupComplete((AsyncResult) msg.obj);
 310                 break;
 311
 312             case EVENT_DISCONNECT_DONE:
 313                 onDisconnectDone((AsyncResult) msg.obj);
 314                 break;
 315
 316             case EVENT_VOICE_CALL_STARTED:
 317                 onVoiceCallStarted();
 318                 break;
 319
 320             case EVENT_VOICE_CALL_ENDED:
 321                 onVoiceCallEnded();
 322                 break;
 323
 324             case EVENT_CLEAN_UP_CONNECTION:
 325                 boolean tearDown = (msg.arg1 == 0) ? false : true;
 326                 onCleanUpConnection(tearDown, (String)msg.obj);
 327                 break;
 328
 329             case EVENT_SET_MASTER_DATA_ENABLE:
 330                 boolean enabled = (msg.arg1 == ENABLED) ? true : false;
 331                 onSetDataEnabled(enabled);
 332                 break;
 333
 334             case EVENT_RESET_DONE:
 335                 onResetDone((AsyncResult) msg.obj);
 336                 break;
 337
 338             default:
 339                 Log.e("DATA", "Unidentified event = " + msg.what);
 340                 break;
 341         }
 342     }
 343
 344     /**
 345      * Report the current state of data connectivity (enabled or disabled)
 346      * @return {@code false} if data connectivity has been explicitly disabled,
 347      * {@code true} otherwise.
 348      */
 349     public synchronized boolean getDataEnabled() {
 350         return dataEnabled[APN_DEFAULT_ID];
 351     }
 352
 353     /**
 354      * Report on whether data connectivity is enabled
 355      * @return {@code false} if data connectivity has been explicitly disabled,
 356      * {@code true} otherwise.
 357      */
 358     public boolean getAnyDataEnabled() {
 359         return (enabledCount != 0);
 360     }
 361
 362     protected abstract void startNetStatPoll();
 363
 364     protected abstract void stopNetStatPoll();
 365
 366     protected abstract void restartRadio();
 367
 368     protected abstract void log(String s);
 369
 370     protected int apnTypeToId(String type) {
 371         if (TextUtils.equals(type, Phone.APN_TYPE_DEFAULT)) {
 372             return APN_DEFAULT_ID;
 373         } else if (TextUtils.equals(type, Phone.APN_TYPE_MMS)) {
 374             return APN_MMS_ID;
 375         } else if (TextUtils.equals(type, Phone.APN_TYPE_SUPL)) {
 376             return APN_SUPL_ID;
 377         } else if (TextUtils.equals(type, Phone.APN_TYPE_DUN)) {
 378             return APN_DUN_ID;
 379         } else if (TextUtils.equals(type, Phone.APN_TYPE_HIPRI)) {
 380             return APN_HIPRI_ID;
 381         } else {
 382             return APN_INVALID_ID;
 383         }
 384     }
 385
 386     protected String apnIdToType(int id) {
 387         switch (id) {
 388         case APN_DEFAULT_ID:
 389             return Phone.APN_TYPE_DEFAULT;
 390         case APN_MMS_ID:
 391             return Phone.APN_TYPE_MMS;
 392         case APN_SUPL_ID:
 393             return Phone.APN_TYPE_SUPL;
 394         case APN_DUN_ID:
 395             return Phone.APN_TYPE_DUN;
 396         case APN_HIPRI_ID:
 397             return Phone.APN_TYPE_HIPRI;
 398         default:
 399             Log.e(LOG_TAG, "Unknown id (" + id + ") in apnIdToType");
 400             return Phone.APN_TYPE_DEFAULT;
 401         }
 402     }
 403
 404     protected abstract boolean isApnTypeActive(String type);
 405
 406     protected abstract boolean isApnTypeAvailable(String type);
 407
 408     protected abstract String[] getActiveApnTypes();
 409
 410     protected abstract String getActiveApnString();
 411
 412     public abstract ArrayList<DataConnection> getAllDataConnections();
 413
 414     protected abstract String getInterfaceName(String apnType);
 415
 416     protected abstract String getIpAddress(String apnType);
 417
 418     protected abstract String getGateway(String apnType);
 419
 420     protected abstract String[] getDnsServers(String apnType);
 421
 422     protected abstract void setState(State s);
 423
 424     protected synchronized boolean isEnabled(int id) {
 425         if (id != APN_INVALID_ID) {
 426             return dataEnabled[id];
 427         }
 428         return false;
 429     }
 430
 431     /**
 432      * Ensure that we are connected to an APN of the specified type.
 433      * @param type the APN type (currently the only valid values
 434      * are {@link Phone#APN_TYPE_MMS} and {@link Phone#APN_TYPE_SUPL})
 435      * @return the result of the operation. Success is indicated by
 436      * a return value of either {@code Phone.APN_ALREADY_ACTIVE} or
 437      * {@code Phone.APN_REQUEST_STARTED}. In the latter case, a broadcast
 438      * will be sent by the ConnectivityManager when a connection to
 439      * the APN has been established.
 440      */
 441     public synchronized int enableApnType(String type) {
 442         int id = apnTypeToId(type);
 443         if (id == APN_INVALID_ID) {
 444             return Phone.APN_REQUEST_FAILED;
 445         }
 446
 447         if (DBG) Log.d(LOG_TAG, "enableApnType("+type+"), isApnTypeActive = "
 448                 + isApnTypeActive(type) + " and state = " + state);
 449
 450         if (!isApnTypeAvailable(type)) {
 451             if (DBG) Log.d(LOG_TAG, "type not available");
 452             return Phone.APN_TYPE_NOT_AVAILABLE;
 453         }
 454
 455         // just because it's active doesn't mean we had it explicitly requested before
 456         // (a broad default may handle many types).  make sure we mark it enabled
 457         // so if the default is disabled we keep the connection for others
 458         setEnabled(id, true);
 459
 460         if (isApnTypeActive(type)) {
 461             if (state == State.INITING) return Phone.APN_REQUEST_STARTED;
 462             else if (state == State.CONNECTED) return Phone.APN_ALREADY_ACTIVE;
 463         }
 464         return Phone.APN_REQUEST_STARTED;
 465     }
 466
 467     /**
 468      * The APN of the specified type is no longer needed. Ensure that if
 469      * use of the default APN has not been explicitly disabled, we are connected
 470      * to the default APN.
 471      * @param type the APN type. The only valid values are currently
 472      * {@link Phone#APN_TYPE_MMS} and {@link Phone#APN_TYPE_SUPL}.
 473      * @return
 474      */
 475     public synchronized int disableApnType(String type) {
 476         if (DBG) Log.d(LOG_TAG, "disableApnType("+type+")");
 477         int id = apnTypeToId(type);
 478         if (id == APN_INVALID_ID) {
 479             return Phone.APN_REQUEST_FAILED;
 480         }
 481         if (isEnabled(id)) {
 482             setEnabled(id, false);
 483             if (isApnTypeActive(Phone.APN_TYPE_DEFAULT)) {
 484                 if (dataEnabled[APN_DEFAULT_ID]) {
 485                     return Phone.APN_ALREADY_ACTIVE;
 486                 } else {
 487                     return Phone.APN_REQUEST_STARTED;
 488                 }
 489             } else {
 490                 return Phone.APN_REQUEST_STARTED;
 491             }
 492         } else {
 493             return Phone.APN_REQUEST_FAILED;
 494         }
 495     }
 496
 497     private void setEnabled(int id, boolean enable) {
 498         if (DBG) Log.d(LOG_TAG, "setEnabled(" + id + ", " + enable + ") with old state = " +
 499                 dataEnabled[id] + " and enabledCount = " + enabledCount);
 500
 501         Message msg = obtainMessage(EVENT_ENABLE_NEW_APN);
 502         msg.arg1 = id;
 503         msg.arg2 = (enable ? ENABLED : DISABLED);
 504         sendMessage(msg);
 505     }
 506
 507     protected synchronized void onEnableApn(int apnId, int enabled) {
 508         if (DBG) {
 509             Log.d(LOG_TAG, "EVENT_APN_ENABLE_REQUEST " + apnId + ", " + enabled);
 510             Log.d(LOG_TAG, " dataEnabled = " + dataEnabled[apnId] +
 511                     ", enabledCount = " + enabledCount +
 512                     ", isApnTypeActive = " + isApnTypeActive(apnIdToType(apnId)));
 513         }
 514         if (enabled == ENABLED) {
 515             if (!dataEnabled[apnId]) {
 516                 dataEnabled[apnId] = true;
 517                 enabledCount++;
 518             }
 519             String type = apnIdToType(apnId);
 520             if (!isApnTypeActive(type)) {
 521                 mRequestedApnType = type;
 522                 onEnableNewApn();
 523             }
 524         } else {
 525             // disable
 526             if (dataEnabled[apnId]) {
 527                 dataEnabled[apnId] = false;
 528                 enabledCount--;
 529                 if (enabledCount == 0) {
 530                     onCleanUpConnection(true, Phone.REASON_DATA_DISABLED);
 531                 } else if (dataEnabled[APN_DEFAULT_ID] == true &&
 532                         !isApnTypeActive(Phone.APN_TYPE_DEFAULT)) {
 533                     mRequestedApnType = Phone.APN_TYPE_DEFAULT;
 534                     onEnableNewApn();
 535                 }
 536             }
 537         }
 538     }
 539
 540     /**
 541      * Called when we switch APNs.
 542      *
 543      * mRequestedApnType is set prior to call
 544      * To be overridden.
 545      */
 546     protected void onEnableNewApn() {
 547     }
 548
 549     /**
 550      * Prevent mobile data connections from being established,
 551      * or once again allow mobile data connections. If the state
 552      * toggles, then either tear down or set up data, as
 553      * appropriate to match the new state.
 554      * <p>This operation only affects the default APN, and if the same APN is
 555      * currently being used for MMS traffic, the teardown will not happen
 556      * even when {@code enable} is {@code false}.</p>
 557      * @param enable indicates whether to enable ({@code true}) or disable ({@code false}) data
 558      * @return {@code true} if the operation succeeded
 559      */
 560     public boolean setDataEnabled(boolean enable) {
 561         if (DBG) Log.d(LOG_TAG, "setDataEnabled(" + enable + ")");
 562
 563         Message msg = obtainMessage(EVENT_SET_MASTER_DATA_ENABLE);
 564         msg.arg1 = (enable ? ENABLED : DISABLED);
 565         sendMessage(msg);
 566         return true;
 567     }
 568
 569     protected void onSetDataEnabled(boolean enable) {
 570         if (mMasterDataEnabled != enable) {
 571             mMasterDataEnabled = enable;
 572             if (enable) {
 573                 mRetryMgr.resetRetryCount();
 574                 onTrySetupData(Phone.REASON_DATA_ENABLED);
 575             } else {
 576                 onCleanUpConnection(true, Phone.REASON_DATA_DISABLED);
 577            }
 578         }
 579     }
 580
 581
 582 }