DcTracker.java revision 96cce86cf08e37e0f09ed5057b1196e26b302743 
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
17package com.android.internal.telephony.dataconnection;
18
19import android.app.AlarmManager;
20import android.app.PendingIntent;
21import android.content.ActivityNotFoundException;
22import android.content.ContentResolver;
23import android.content.ContentValues;
24import android.content.Context;
25import android.content.Intent;
26import android.content.IntentFilter;
27import android.content.res.Resources;
28import android.database.ContentObserver;
29import android.database.Cursor;
30import android.net.ConnectivityManager;
31import android.net.LinkProperties;
32import android.net.NetworkCapabilities;
33import android.net.NetworkConfig;
34import android.net.NetworkUtils;
35import android.net.ProxyInfo;
36import android.net.Uri;
37import android.os.AsyncResult;
38import android.os.Build;
39import android.os.Message;
40import android.os.Messenger;
41import android.os.SystemClock;
42import android.os.SystemProperties;
43import android.os.UserHandle;
44import android.provider.Settings;
45import android.provider.Telephony;
46import android.telephony.CellLocation;
47import android.telephony.ServiceState;
48import android.telephony.TelephonyManager;
49import android.telephony.cdma.CdmaCellLocation;
50import android.telephony.gsm.GsmCellLocation;
51import android.text.TextUtils;
52import android.util.EventLog;
53import android.telephony.Rlog;
54
55import com.android.internal.telephony.Phone;
56import com.android.internal.telephony.PhoneBase;
57import com.android.internal.telephony.DctConstants;
58import com.android.internal.telephony.EventLogTags;
59import com.android.internal.telephony.TelephonyIntents;
60import com.android.internal.telephony.gsm.GSMPhone;
61import com.android.internal.telephony.PhoneConstants;
62import com.android.internal.telephony.RILConstants;
63import com.android.internal.telephony.uicc.IccRecords;
64import com.android.internal.telephony.uicc.UiccController;
65import com.android.internal.util.AsyncChannel;
66
67import java.io.FileDescriptor;
68import java.io.PrintWriter;
69import java.util.ArrayList;
70import java.util.concurrent.atomic.AtomicBoolean;
71import java.util.HashMap;
72
73/**
74 * {@hide}
75 */
76public final class DcTracker extends DcTrackerBase {
77    protected final String LOG_TAG = "DCT";
78
79    /**
80     * Handles changes to the APN db.
81     */
82    private class ApnChangeObserver extends ContentObserver {
83        public ApnChangeObserver () {
84            super(mDataConnectionTracker);
85        }
86
87        @Override
88        public void onChange(boolean selfChange) {
89            sendMessage(obtainMessage(DctConstants.EVENT_APN_CHANGED));
90        }
91    }
92
93    //***** Instance Variables
94
95    private boolean mReregisterOnReconnectFailure = false;
96
97
98    //***** Constants
99
100    // Used by puppetmaster/*/radio_stress.py
101    private static final String PUPPET_MASTER_RADIO_STRESS_TEST = "gsm.defaultpdpcontext.active";
102
103    private static final int POLL_PDP_MILLIS = 5 * 1000;
104
105    static final Uri PREFERAPN_NO_UPDATE_URI =
106                        Uri.parse("content://telephony/carriers/preferapn_no_update");
107    static final String APN_ID = "apn_id";
108
109    private boolean mCanSetPreferApn = false;
110
111    private AtomicBoolean mAttached = new AtomicBoolean(false);
112
113    /** Watches for changes to the APN db. */
114    private ApnChangeObserver mApnObserver;
115
116    //***** Constructor
117
118    public DcTracker(PhoneBase p) {
119        super(p);
120        if (DBG) log("GsmDCT.constructor");
121        p.mCi.registerForAvailable (this, DctConstants.EVENT_RADIO_AVAILABLE, null);
122        p.mCi.registerForOffOrNotAvailable(this, DctConstants.EVENT_RADIO_OFF_OR_NOT_AVAILABLE,
123                null);
124
125        p.getCallTracker().registerForVoiceCallEnded (this, DctConstants.EVENT_VOICE_CALL_ENDED,
126                null);
127        p.getCallTracker().registerForVoiceCallStarted (this, DctConstants.EVENT_VOICE_CALL_STARTED,
128                null);
129        p.getServiceStateTracker().registerForDataConnectionAttached(this,
130                DctConstants.EVENT_DATA_CONNECTION_ATTACHED, null);
131        p.getServiceStateTracker().registerForDataConnectionDetached(this,
132                DctConstants.EVENT_DATA_CONNECTION_DETACHED, null);
133        p.getServiceStateTracker().registerForRoamingOn(this, DctConstants.EVENT_ROAMING_ON, null);
134        p.getServiceStateTracker().registerForRoamingOff(this, DctConstants.EVENT_ROAMING_OFF,
135                null);
136        p.getServiceStateTracker().registerForPsRestrictedEnabled(this,
137                DctConstants.EVENT_PS_RESTRICT_ENABLED, null);
138        p.getServiceStateTracker().registerForPsRestrictedDisabled(this,
139                DctConstants.EVENT_PS_RESTRICT_DISABLED, null);
140
141        mDataConnectionTracker = this;
142
143        mApnObserver = new ApnChangeObserver();
144        p.getContext().getContentResolver().registerContentObserver(
145                Telephony.Carriers.CONTENT_URI, true, mApnObserver);
146
147        initApnContexts();
148
149        for (ApnContext apnContext : mApnContexts.values()) {
150            // Register the reconnect and restart actions.
151            IntentFilter filter = new IntentFilter();
152            filter.addAction(INTENT_RECONNECT_ALARM + '.' + apnContext.getApnType());
153            filter.addAction(INTENT_RESTART_TRYSETUP_ALARM + '.' + apnContext.getApnType());
154            mPhone.getContext().registerReceiver(mIntentReceiver, filter, null, mPhone);
155        }
156
157        ConnectivityManager cm = (ConnectivityManager)p.getContext().getSystemService(
158                Context.CONNECTIVITY_SERVICE);
159        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE, new Messenger(this));
160        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE_MMS, new Messenger(this));
161        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE_SUPL, new Messenger(this));
162        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE_DUN, new Messenger(this));
163        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE_HIPRI, new Messenger(this));
164        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE_FOTA, new Messenger(this));
165        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE_IMS, new Messenger(this));
166        cm.supplyMessenger(ConnectivityManager.TYPE_MOBILE_CBS, new Messenger(this));
167    }
168
169    @Override
170    public void dispose() {
171        if (DBG) log("GsmDCT.dispose");
172        cleanUpAllConnections(true, null);
173
174        super.dispose();
175
176        //Unregister for all events
177        mPhone.mCi.unregisterForAvailable(this);
178        mPhone.mCi.unregisterForOffOrNotAvailable(this);
179        IccRecords r = mIccRecords.get();
180        if (r != null) { r.unregisterForRecordsLoaded(this);}
181        mPhone.mCi.unregisterForDataNetworkStateChanged(this);
182        mPhone.getCallTracker().unregisterForVoiceCallEnded(this);
183        mPhone.getCallTracker().unregisterForVoiceCallStarted(this);
184        mPhone.getServiceStateTracker().unregisterForDataConnectionAttached(this);
185        mPhone.getServiceStateTracker().unregisterForDataConnectionDetached(this);
186        mPhone.getServiceStateTracker().unregisterForRoamingOn(this);
187        mPhone.getServiceStateTracker().unregisterForRoamingOff(this);
188        mPhone.getServiceStateTracker().unregisterForPsRestrictedEnabled(this);
189        mPhone.getServiceStateTracker().unregisterForPsRestrictedDisabled(this);
190
191        mPhone.getContext().getContentResolver().unregisterContentObserver(mApnObserver);
192        mApnContexts.clear();
193        mPrioritySortedApnContexts.clear();
194
195        destroyDataConnections();
196    }
197
198    @Override
199    public boolean isApnTypeActive(String type) {
200        ApnContext apnContext = mApnContexts.get(type);
201        if (apnContext == null) return false;
202
203        return (apnContext.getDcAc() != null);
204    }
205
206    @Override
207    public boolean isDataPossible(String apnType) {
208        ApnContext apnContext = mApnContexts.get(apnType);
209        if (apnContext == null) {
210            return false;
211        }
212        boolean apnContextIsEnabled = apnContext.isEnabled();
213        DctConstants.State apnContextState = apnContext.getState();
214        boolean apnTypePossible = !(apnContextIsEnabled &&
215                (apnContextState == DctConstants.State.FAILED));
216        boolean dataAllowed = isDataAllowed();
217        boolean possible = dataAllowed && apnTypePossible;
218
219        if (VDBG) {
220            log(String.format("isDataPossible(%s): possible=%b isDataAllowed=%b " +
221                    "apnTypePossible=%b apnContextisEnabled=%b apnContextState()=%s",
222                    apnType, possible, dataAllowed, apnTypePossible,
223                    apnContextIsEnabled, apnContextState));
224        }
225        return possible;
226    }
227
228    @Override
229    protected void finalize() {
230        if(DBG) log("finalize");
231    }
232
233    private ApnContext addApnContext(String type, NetworkConfig networkConfig) {
234        ApnContext apnContext = new ApnContext(mPhone.getContext(), type, LOG_TAG, networkConfig);
235        mApnContexts.put(type, apnContext);
236        mPrioritySortedApnContexts.add(apnContext);
237        return apnContext;
238    }
239
240    protected void initApnContexts() {
241        log("initApnContexts: E");
242        boolean defaultEnabled = SystemProperties.getBoolean(DEFALUT_DATA_ON_BOOT_PROP, true);
243        // Load device network attributes from resources
244        String[] networkConfigStrings = mPhone.getContext().getResources().getStringArray(
245                com.android.internal.R.array.networkAttributes);
246        for (String networkConfigString : networkConfigStrings) {
247            NetworkConfig networkConfig = new NetworkConfig(networkConfigString);
248            ApnContext apnContext = null;
249
250            switch (networkConfig.type) {
251            case ConnectivityManager.TYPE_MOBILE:
252                apnContext = addApnContext(PhoneConstants.APN_TYPE_DEFAULT, networkConfig);
253                apnContext.setEnabled(defaultEnabled);
254                break;
255            case ConnectivityManager.TYPE_MOBILE_MMS:
256                apnContext = addApnContext(PhoneConstants.APN_TYPE_MMS, networkConfig);
257                break;
258            case ConnectivityManager.TYPE_MOBILE_SUPL:
259                apnContext = addApnContext(PhoneConstants.APN_TYPE_SUPL, networkConfig);
260                break;
261            case ConnectivityManager.TYPE_MOBILE_DUN:
262                apnContext = addApnContext(PhoneConstants.APN_TYPE_DUN, networkConfig);
263                break;
264            case ConnectivityManager.TYPE_MOBILE_HIPRI:
265                apnContext = addApnContext(PhoneConstants.APN_TYPE_HIPRI, networkConfig);
266                break;
267            case ConnectivityManager.TYPE_MOBILE_FOTA:
268                apnContext = addApnContext(PhoneConstants.APN_TYPE_FOTA, networkConfig);
269                break;
270            case ConnectivityManager.TYPE_MOBILE_IMS:
271                apnContext = addApnContext(PhoneConstants.APN_TYPE_IMS, networkConfig);
272                break;
273            case ConnectivityManager.TYPE_MOBILE_CBS:
274                apnContext = addApnContext(PhoneConstants.APN_TYPE_CBS, networkConfig);
275                break;
276            case ConnectivityManager.TYPE_MOBILE_IA:
277                apnContext = addApnContext(PhoneConstants.APN_TYPE_IA, networkConfig);
278                break;
279            default:
280                log("initApnContexts: skipping unknown type=" + networkConfig.type);
281                continue;
282            }
283            log("initApnContexts: apnContext=" + apnContext);
284        }
285        log("initApnContexts: X mApnContexts=" + mApnContexts);
286    }
287
288    @Override
289    public LinkProperties getLinkProperties(String apnType) {
290        ApnContext apnContext = mApnContexts.get(apnType);
291        if (apnContext != null) {
292            DcAsyncChannel dcac = apnContext.getDcAc();
293            if (dcac != null) {
294                if (DBG) log("return link properites for " + apnType);
295                return dcac.getLinkPropertiesSync();
296            }
297        }
298        if (DBG) log("return new LinkProperties");
299        return new LinkProperties();
300    }
301
302    @Override
303    public NetworkCapabilities getNetworkCapabilities(String apnType) {
304        ApnContext apnContext = mApnContexts.get(apnType);
305        if (apnContext!=null) {
306            DcAsyncChannel dataConnectionAc = apnContext.getDcAc();
307            if (dataConnectionAc != null) {
308                if (DBG) {
309                    log("get active pdp is not null, return NetworkCapabilities for " + apnType);
310                }
311                return dataConnectionAc.getNetworkCapabilitiesSync();
312            }
313        }
314        if (DBG) log("return new NetworkCapabilities");
315        return new NetworkCapabilities();
316    }
317
318    @Override
319    // Return all active apn types
320    public String[] getActiveApnTypes() {
321        if (DBG) log("get all active apn types");
322        ArrayList<String> result = new ArrayList<String>();
323
324        for (ApnContext apnContext : mApnContexts.values()) {
325            if (mAttached.get() && apnContext.isReady()) {
326                result.add(apnContext.getApnType());
327            }
328        }
329
330        return result.toArray(new String[0]);
331    }
332
333    @Override
334    // Return active apn of specific apn type
335    public String getActiveApnString(String apnType) {
336        if (VDBG) log( "get active apn string for type:" + apnType);
337        ApnContext apnContext = mApnContexts.get(apnType);
338        if (apnContext != null) {
339            ApnSetting apnSetting = apnContext.getApnSetting();
340            if (apnSetting != null) {
341                return apnSetting.apn;
342            }
343        }
344        return null;
345    }
346
347    @Override
348    public boolean isApnTypeEnabled(String apnType) {
349        ApnContext apnContext = mApnContexts.get(apnType);
350        if (apnContext == null) {
351            return false;
352        }
353        return apnContext.isEnabled();
354    }
355
356    @Override
357    protected void setState(DctConstants.State s) {
358        if (DBG) log("setState should not be used in GSM" + s);
359    }
360
361    // Return state of specific apn type
362    @Override
363    public DctConstants.State getState(String apnType) {
364        ApnContext apnContext = mApnContexts.get(apnType);
365        if (apnContext != null) {
366            return apnContext.getState();
367        }
368        return DctConstants.State.FAILED;
369    }
370
371    // Return if apn type is a provisioning apn.
372    @Override
373    protected boolean isProvisioningApn(String apnType) {
374        ApnContext apnContext = mApnContexts.get(apnType);
375        if (apnContext != null) {
376            return apnContext.isProvisioningApn();
377        }
378        return false;
379    }
380
381    // Return state of overall
382    @Override
383    public DctConstants.State getOverallState() {
384        boolean isConnecting = false;
385        boolean isFailed = true; // All enabled Apns should be FAILED.
386        boolean isAnyEnabled = false;
387
388        for (ApnContext apnContext : mApnContexts.values()) {
389            if (apnContext.isEnabled()) {
390                isAnyEnabled = true;
391                switch (apnContext.getState()) {
392                case CONNECTED:
393                case DISCONNECTING:
394                    if (DBG) log("overall state is CONNECTED");
395                    return DctConstants.State.CONNECTED;
396                case RETRYING:
397                case CONNECTING:
398                    isConnecting = true;
399                    isFailed = false;
400                    break;
401                case IDLE:
402                case SCANNING:
403                    isFailed = false;
404                    break;
405                default:
406                    isAnyEnabled = true;
407                    break;
408                }
409            }
410        }
411
412        if (!isAnyEnabled) { // Nothing enabled. return IDLE.
413            if (DBG) log( "overall state is IDLE");
414            return DctConstants.State.IDLE;
415        }
416
417        if (isConnecting) {
418            if (DBG) log( "overall state is CONNECTING");
419            return DctConstants.State.CONNECTING;
420        } else if (!isFailed) {
421            if (DBG) log( "overall state is IDLE");
422            return DctConstants.State.IDLE;
423        } else {
424            if (DBG) log( "overall state is FAILED");
425            return DctConstants.State.FAILED;
426        }
427    }
428
429    /**
430     * Ensure that we are connected to an APN of the specified type.
431     *
432     * @param apnType the APN type
433     * @return Success is indicated by {@code PhoneConstants.APN_ALREADY_ACTIVE} or
434     *         {@code PhoneConstants.APN_REQUEST_STARTED}. In the latter case, a
435     *         broadcast will be sent by the ConnectivityManager when a
436     *         connection to the APN has been established.
437     */
438    @Override
439    public synchronized int enableApnType(String apnType) {
440        ApnContext apnContext = mApnContexts.get(apnType);
441        if (apnContext == null || !isApnTypeAvailable(apnType)) {
442            if (DBG) log("enableApnType: " + apnType + " is type not available");
443            return PhoneConstants.APN_TYPE_NOT_AVAILABLE;
444        }
445
446        // If already active, return
447        if (DBG) log("enableApnType: " + apnType + " mState(" + apnContext.getState() + ")");
448
449        if (apnContext.getState() == DctConstants.State.CONNECTED) {
450            if (DBG) log("enableApnType: return APN_ALREADY_ACTIVE");
451            return PhoneConstants.APN_ALREADY_ACTIVE;
452        }
453        setEnabled(apnTypeToId(apnType), true);
454        if (DBG) {
455            log("enableApnType: new apn request for type " + apnType +
456                    " return APN_REQUEST_STARTED");
457        }
458        return PhoneConstants.APN_REQUEST_STARTED;
459    }
460
461    @Override
462    public synchronized int disableApnType(String type) {
463        if (DBG) log("disableApnType:" + type);
464        ApnContext apnContext = mApnContexts.get(type);
465
466        if (apnContext != null) {
467            setEnabled(apnTypeToId(type), false);
468            if (apnContext.getState() != DctConstants.State.IDLE && apnContext.getState()
469                    != DctConstants.State.FAILED) {
470                if (DBG) log("diableApnType: return APN_REQUEST_STARTED");
471                return PhoneConstants.APN_REQUEST_STARTED;
472            } else {
473                if (DBG) log("disableApnType: return APN_ALREADY_INACTIVE");
474                return PhoneConstants.APN_ALREADY_INACTIVE;
475            }
476
477        } else {
478            if (DBG) {
479                log("disableApnType: no apn context was found, return APN_REQUEST_FAILED");
480            }
481            return PhoneConstants.APN_REQUEST_FAILED;
482        }
483    }
484
485    @Override
486    protected boolean isApnTypeAvailable(String type) {
487        if (type.equals(PhoneConstants.APN_TYPE_DUN) && fetchDunApn() != null) {
488            return true;
489        }
490
491        if (mAllApnSettings != null) {
492            for (ApnSetting apn : mAllApnSettings) {
493                if (apn.canHandleType(type)) {
494                    return true;
495                }
496            }
497        }
498        return false;
499    }
500
501    /**
502     * Report on whether data connectivity is enabled for any APN.
503     * @return {@code false} if data connectivity has been explicitly disabled,
504     * {@code true} otherwise.
505     */
506    @Override
507    public boolean getAnyDataEnabled() {
508        synchronized (mDataEnabledLock) {
509            if (!(mInternalDataEnabled && mUserDataEnabled && sPolicyDataEnabled)) return false;
510            for (ApnContext apnContext : mApnContexts.values()) {
511                // Make sure we don't have a context that is going down
512                // and is explicitly disabled.
513                if (isDataAllowed(apnContext)) {
514                    return true;
515                }
516            }
517            return false;
518        }
519    }
520
521    private boolean isDataAllowed(ApnContext apnContext) {
522        return apnContext.isReady() && isDataAllowed();
523    }
524
525    //****** Called from ServiceStateTracker
526    /**
527     * Invoked when ServiceStateTracker observes a transition from GPRS
528     * attach to detach.
529     */
530    protected void onDataConnectionDetached() {
531        /*
532         * We presently believe it is unnecessary to tear down the PDP context
533         * when GPRS detaches, but we should stop the network polling.
534         */
535        if (DBG) log ("onDataConnectionDetached: stop polling and notify detached");
536        stopNetStatPoll();
537        stopDataStallAlarm();
538        notifyDataConnection(Phone.REASON_DATA_DETACHED);
539        mAttached.set(false);
540    }
541
542    private void onDataConnectionAttached() {
543        if (DBG) log("onDataConnectionAttached");
544        mAttached.set(true);
545        if (getOverallState() == DctConstants.State.CONNECTED) {
546            if (DBG) log("onDataConnectionAttached: start polling notify attached");
547            startNetStatPoll();
548            startDataStallAlarm(DATA_STALL_NOT_SUSPECTED);
549            notifyDataConnection(Phone.REASON_DATA_ATTACHED);
550        } else {
551            // update APN availability so that APN can be enabled.
552            notifyOffApnsOfAvailability(Phone.REASON_DATA_ATTACHED);
553        }
554        mAutoAttachOnCreation = true;
555        setupDataOnConnectableApns(Phone.REASON_DATA_ATTACHED);
556    }
557
558    @Override
559    protected boolean isDataAllowed() {
560        final boolean internalDataEnabled;
561        synchronized (mDataEnabledLock) {
562            internalDataEnabled = mInternalDataEnabled;
563        }
564
565        boolean attachedState = mAttached.get();
566        boolean desiredPowerState = mPhone.getServiceStateTracker().getDesiredPowerState();
567        IccRecords r = mIccRecords.get();
568        boolean recordsLoaded = (r != null) ? r.getRecordsLoaded() : false;
569
570        boolean allowed =
571                    (attachedState || mAutoAttachOnCreation) &&
572                    recordsLoaded &&
573                    (mPhone.getState() == PhoneConstants.State.IDLE ||
574                     mPhone.getServiceStateTracker().isConcurrentVoiceAndDataAllowed()) &&
575                    internalDataEnabled &&
576                    (!mPhone.getServiceState().getRoaming() || getDataOnRoamingEnabled()) &&
577                    !mIsPsRestricted &&
578                    desiredPowerState;
579        if (!allowed && DBG) {
580            String reason = "";
581            if (!(attachedState || mAutoAttachOnCreation)) {
582                reason += " - Attached= " + attachedState;
583            }
584            if (!recordsLoaded) reason += " - SIM not loaded";
585            if (mPhone.getState() != PhoneConstants.State.IDLE &&
586                    !mPhone.getServiceStateTracker().isConcurrentVoiceAndDataAllowed()) {
587                reason += " - PhoneState= " + mPhone.getState();
588                reason += " - Concurrent voice and data not allowed";
589            }
590            if (!internalDataEnabled) reason += " - mInternalDataEnabled= false";
591            if (mPhone.getServiceState().getRoaming() && !getDataOnRoamingEnabled()) {
592                reason += " - Roaming and data roaming not enabled";
593            }
594            if (mIsPsRestricted) reason += " - mIsPsRestricted= true";
595            if (!desiredPowerState) reason += " - desiredPowerState= false";
596            if (DBG) log("isDataAllowed: not allowed due to" + reason);
597        }
598        return allowed;
599    }
600
601    private void setupDataOnConnectableApns(String reason) {
602        if (DBG) log("setupDataOnConnectableApns: " + reason);
603
604        for (ApnContext apnContext : mPrioritySortedApnContexts) {
605            if (DBG) log("setupDataOnConnectableApns: apnContext " + apnContext);
606            if (apnContext.getState() == DctConstants.State.FAILED) {
607                apnContext.setState(DctConstants.State.IDLE);
608            }
609            if (apnContext.isConnectable()) {
610                log("setupDataOnConnectableApns: isConnectable() call trySetupData");
611                apnContext.setReason(reason);
612                trySetupData(apnContext);
613            }
614        }
615    }
616
617    private boolean trySetupData(ApnContext apnContext) {
618        if (DBG) {
619            log("trySetupData for type:" + apnContext.getApnType() +
620                    " due to " + apnContext.getReason() + " apnContext=" + apnContext);
621            log("trySetupData with mIsPsRestricted=" + mIsPsRestricted);
622        }
623
624        if (mPhone.getSimulatedRadioControl() != null) {
625            // Assume data is connected on the simulator
626            // FIXME  this can be improved
627            apnContext.setState(DctConstants.State.CONNECTED);
628            mPhone.notifyDataConnection(apnContext.getReason(), apnContext.getApnType());
629
630            log("trySetupData: X We're on the simulator; assuming connected retValue=true");
631            return true;
632        }
633
634        boolean desiredPowerState = mPhone.getServiceStateTracker().getDesiredPowerState();
635
636        if (apnContext.isConnectable() &&
637                isDataAllowed(apnContext) && getAnyDataEnabled() && !isEmergency()) {
638            if (apnContext.getState() == DctConstants.State.FAILED) {
639                if (DBG) log("trySetupData: make a FAILED ApnContext IDLE so its reusable");
640                apnContext.setState(DctConstants.State.IDLE);
641            }
642            int radioTech = mPhone.getServiceState().getRilDataRadioTechnology();
643            if (apnContext.getState() == DctConstants.State.IDLE) {
644
645                ArrayList<ApnSetting> waitingApns = buildWaitingApns(apnContext.getApnType(),
646                        radioTech);
647                if (waitingApns.isEmpty()) {
648                    notifyNoData(DcFailCause.MISSING_UNKNOWN_APN, apnContext);
649                    notifyOffApnsOfAvailability(apnContext.getReason());
650                    if (DBG) log("trySetupData: X No APN found retValue=false");
651                    return false;
652                } else {
653                    apnContext.setWaitingApns(waitingApns);
654                    if (DBG) {
655                        log ("trySetupData: Create from mAllApnSettings : "
656                                    + apnListToString(mAllApnSettings));
657                    }
658                }
659            }
660
661            if (DBG) {
662                log("trySetupData: call setupData, waitingApns : "
663                        + apnListToString(apnContext.getWaitingApns()));
664            }
665            boolean retValue = setupData(apnContext, radioTech);
666            notifyOffApnsOfAvailability(apnContext.getReason());
667
668            if (DBG) log("trySetupData: X retValue=" + retValue);
669            return retValue;
670        } else {
671            if (!apnContext.getApnType().equals(PhoneConstants.APN_TYPE_DEFAULT)
672                    && apnContext.isConnectable()) {
673                mPhone.notifyDataConnectionFailed(apnContext.getReason(), apnContext.getApnType());
674            }
675            notifyOffApnsOfAvailability(apnContext.getReason());
676            if (DBG) log ("trySetupData: X apnContext not 'ready' retValue=false");
677            return false;
678        }
679    }
680
681    @Override
682    // Disabled apn's still need avail/unavail notificiations - send them out
683    protected void notifyOffApnsOfAvailability(String reason) {
684        for (ApnContext apnContext : mApnContexts.values()) {
685            if (!mAttached.get() || !apnContext.isReady()) {
686                if (VDBG) log("notifyOffApnOfAvailability type:" + apnContext.getApnType());
687                mPhone.notifyDataConnection(reason != null ? reason : apnContext.getReason(),
688                                            apnContext.getApnType(),
689                                            PhoneConstants.DataState.DISCONNECTED);
690            } else {
691                if (VDBG) {
692                    log("notifyOffApnsOfAvailability skipped apn due to attached && isReady " +
693                            apnContext.toString());
694                }
695            }
696        }
697    }
698
699    /**
700     * If tearDown is true, this only tears down a CONNECTED session. Presently,
701     * there is no mechanism for abandoning an CONNECTING session,
702     * but would likely involve cancelling pending async requests or
703     * setting a flag or new state to ignore them when they came in
704     * @param tearDown true if the underlying DataConnection should be
705     * disconnected.
706     * @param reason reason for the clean up.
707     * @return boolean - true if we did cleanup any connections, false if they
708     *                   were already all disconnected.
709     */
710    protected boolean cleanUpAllConnections(boolean tearDown, String reason) {
711        if (DBG) log("cleanUpAllConnections: tearDown=" + tearDown + " reason=" + reason);
712        boolean didDisconnect = false;
713
714        for (ApnContext apnContext : mApnContexts.values()) {
715            if (apnContext.isDisconnected() == false) didDisconnect = true;
716            // TODO - only do cleanup if not disconnected
717            apnContext.setReason(reason);
718            cleanUpConnection(tearDown, apnContext);
719        }
720
721        stopNetStatPoll();
722        stopDataStallAlarm();
723
724        // TODO: Do we need mRequestedApnType?
725        mRequestedApnType = PhoneConstants.APN_TYPE_DEFAULT;
726        return didDisconnect;
727    }
728
729    /**
730     * Cleanup all connections.
731     *
732     * TODO: Cleanup only a specified connection passed as a parameter.
733     *       Also, make sure when you clean up a conn, if it is last apply
734     *       logic as though it is cleanupAllConnections
735     *
736     * @param cause for the clean up.
737     */
738
739    @Override
740    protected void onCleanUpAllConnections(String cause) {
741        cleanUpAllConnections(true, cause);
742    }
743
744    private void cleanUpConnection(boolean tearDown, ApnContext apnContext) {
745
746        if (apnContext == null) {
747            if (DBG) log("cleanUpConnection: apn context is null");
748            return;
749        }
750
751        DcAsyncChannel dcac = apnContext.getDcAc();
752        if (DBG) {
753            log("cleanUpConnection: E tearDown=" + tearDown + " reason=" + apnContext.getReason() +
754                    " apnContext=" + apnContext);
755        }
756        if (tearDown) {
757            if (apnContext.isDisconnected()) {
758                // The request is tearDown and but ApnContext is not connected.
759                // If apnContext is not enabled anymore, break the linkage to the DCAC/DC.
760                apnContext.setState(DctConstants.State.IDLE);
761                if (!apnContext.isReady()) {
762                    if (dcac != null) {
763                        dcac.tearDown(apnContext, "", null);
764                    }
765                    apnContext.setDataConnectionAc(null);
766                }
767            } else {
768                // Connection is still there. Try to clean up.
769                if (dcac != null) {
770                    if (apnContext.getState() != DctConstants.State.DISCONNECTING) {
771                        boolean disconnectAll = false;
772                        if (PhoneConstants.APN_TYPE_DUN.equals(apnContext.getApnType())) {
773                            ApnSetting dunSetting = fetchDunApn();
774                            if (dunSetting != null &&
775                                    dunSetting.equals(apnContext.getApnSetting())) {
776                                if (DBG) log("tearing down dedicated DUN connection");
777                                // we need to tear it down - we brought it up just for dun and
778                                // other people are camped on it and now dun is done.  We need
779                                // to stop using it and let the normal apn list get used to find
780                                // connections for the remaining desired connections
781                                disconnectAll = true;
782                            }
783                        }
784                        if (DBG) {
785                            log("cleanUpConnection: tearing down" + (disconnectAll ? " all" :""));
786                        }
787                        Message msg = obtainMessage(DctConstants.EVENT_DISCONNECT_DONE, apnContext);
788                        if (disconnectAll) {
789                            apnContext.getDcAc().tearDownAll(apnContext.getReason(), msg);
790                        } else {
791                            apnContext.getDcAc()
792                                .tearDown(apnContext, apnContext.getReason(), msg);
793                        }
794                        apnContext.setState(DctConstants.State.DISCONNECTING);
795                    }
796                } else {
797                    // apn is connected but no reference to dcac.
798                    // Should not be happen, but reset the state in case.
799                    apnContext.setState(DctConstants.State.IDLE);
800                    mPhone.notifyDataConnection(apnContext.getReason(),
801                                                apnContext.getApnType());
802                }
803            }
804        } else {
805            // force clean up the data connection.
806            if (dcac != null) dcac.reqReset();
807            apnContext.setState(DctConstants.State.IDLE);
808            mPhone.notifyDataConnection(apnContext.getReason(), apnContext.getApnType());
809            apnContext.setDataConnectionAc(null);
810        }
811
812        // Make sure reconnection alarm is cleaned up if there is no ApnContext
813        // associated to the connection.
814        if (dcac != null) {
815            cancelReconnectAlarm(apnContext);
816        }
817        if (DBG) {
818            log("cleanUpConnection: X tearDown=" + tearDown + " reason=" + apnContext.getReason() +
819                    " apnContext=" + apnContext + " dcac=" + apnContext.getDcAc());
820        }
821    }
822
823    /**
824     * Cancels the alarm associated with apnContext.
825     *
826     * @param apnContext on which the alarm should be stopped.
827     */
828    private void cancelReconnectAlarm(ApnContext apnContext) {
829        if (apnContext == null) return;
830
831        PendingIntent intent = apnContext.getReconnectIntent();
832
833        if (intent != null) {
834                AlarmManager am =
835                    (AlarmManager) mPhone.getContext().getSystemService(Context.ALARM_SERVICE);
836                am.cancel(intent);
837                apnContext.setReconnectIntent(null);
838        }
839    }
840
841    /**
842     * @param types comma delimited list of APN types
843     * @return array of APN types
844     */
845    private String[] parseTypes(String types) {
846        String[] result;
847        // If unset, set to DEFAULT.
848        if (types == null || types.equals("")) {
849            result = new String[1];
850            result[0] = PhoneConstants.APN_TYPE_ALL;
851        } else {
852            result = types.split(",");
853        }
854        return result;
855    }
856
857   private boolean imsiMatches(String imsiDB, String imsiSIM) {
858        // Note: imsiDB value has digit number or 'x' character for seperating USIM information
859        // for MVNO operator. And then digit number is matched at same order and 'x' character
860        // could replace by any digit number.
861        // ex) if imsiDB inserted '310260x10xxxxxx' for GG Operator,
862        //     that means first 6 digits, 8th and 9th digit
863        //     should be set in USIM for GG Operator.
864        int len = imsiDB.length();
865        int idxCompare = 0;
866
867        if (len <= 0) return false;
868        if (len > imsiSIM.length()) return false;
869
870        for (int idx=0; idx<len; idx++) {
871            char c = imsiDB.charAt(idx);
872            if ((c == 'x') || (c == 'X') || (c == imsiSIM.charAt(idx))) {
873                continue;
874            } else {
875                return false;
876            }
877        }
878        return true;
879    }
880
881    private boolean mvnoMatches(IccRecords r, String mvno_type, String mvno_match_data) {
882        if (mvno_type.equalsIgnoreCase("spn")) {
883            if ((r.getServiceProviderName() != null) &&
884                    r.getServiceProviderName().equalsIgnoreCase(mvno_match_data)) {
885                return true;
886            }
887        } else if (mvno_type.equalsIgnoreCase("imsi")) {
888            String imsiSIM = r.getIMSI();
889            if ((imsiSIM != null) && imsiMatches(mvno_match_data, imsiSIM)) {
890                return true;
891            }
892        } else if (mvno_type.equalsIgnoreCase("gid")) {
893            String gid1 = r.getGid1();
894            int mvno_match_data_length = mvno_match_data.length();
895            if ((gid1 != null) && (gid1.length() >= mvno_match_data_length) &&
896                    gid1.substring(0, mvno_match_data_length).equalsIgnoreCase(mvno_match_data)) {
897                return true;
898            }
899        }
900        return false;
901    }
902
903    private ApnSetting makeApnSetting(Cursor cursor) {
904        String[] types = parseTypes(
905                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.TYPE)));
906        ApnSetting apn = new ApnSetting(
907                cursor.getInt(cursor.getColumnIndexOrThrow(Telephony.Carriers._ID)),
908                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.NUMERIC)),
909                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.NAME)),
910                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.APN)),
911                NetworkUtils.trimV4AddrZeros(
912                        cursor.getString(
913                        cursor.getColumnIndexOrThrow(Telephony.Carriers.PROXY))),
914                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.PORT)),
915                NetworkUtils.trimV4AddrZeros(
916                        cursor.getString(
917                        cursor.getColumnIndexOrThrow(Telephony.Carriers.MMSC))),
918                NetworkUtils.trimV4AddrZeros(
919                        cursor.getString(
920                        cursor.getColumnIndexOrThrow(Telephony.Carriers.MMSPROXY))),
921                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.MMSPORT)),
922                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.USER)),
923                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.PASSWORD)),
924                cursor.getInt(cursor.getColumnIndexOrThrow(Telephony.Carriers.AUTH_TYPE)),
925                types,
926                cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Carriers.PROTOCOL)),
927                cursor.getString(cursor.getColumnIndexOrThrow(
928                        Telephony.Carriers.ROAMING_PROTOCOL)),
929                cursor.getInt(cursor.getColumnIndexOrThrow(
930                        Telephony.Carriers.CARRIER_ENABLED)) == 1,
931                cursor.getInt(cursor.getColumnIndexOrThrow(Telephony.Carriers.BEARER)));
932        return apn;
933    }
934
935    private ArrayList<ApnSetting> createApnList(Cursor cursor) {
936        ArrayList<ApnSetting> result = new ArrayList<ApnSetting>();
937        IccRecords r = mIccRecords.get();
938
939        if (cursor.moveToFirst()) {
940            String mvnoType = null;
941            String mvnoMatchData = null;
942            do {
943                String cursorMvnoType = cursor.getString(
944                        cursor.getColumnIndexOrThrow(Telephony.Carriers.MVNO_TYPE));
945                String cursorMvnoMatchData = cursor.getString(
946                        cursor.getColumnIndexOrThrow(Telephony.Carriers.MVNO_MATCH_DATA));
947                if (mvnoType != null) {
948                    if (mvnoType.equals(cursorMvnoType) &&
949                            mvnoMatchData.equals(cursorMvnoMatchData)) {
950                        result.add(makeApnSetting(cursor));
951                    }
952                } else {
953                    // no mvno match yet
954                    if (mvnoMatches(r, cursorMvnoType, cursorMvnoMatchData)) {
955                        // first match - toss out non-mvno data
956                        result.clear();
957                        mvnoType = cursorMvnoType;
958                        mvnoMatchData = cursorMvnoMatchData;
959                        result.add(makeApnSetting(cursor));
960                    } else {
961                        // add only non-mvno data
962                        if (cursorMvnoType.equals("")) {
963                            result.add(makeApnSetting(cursor));
964                        }
965                    }
966                }
967            } while (cursor.moveToNext());
968        }
969        if (DBG) log("createApnList: X result=" + result);
970        return result;
971    }
972
973    private boolean dataConnectionNotInUse(DcAsyncChannel dcac) {
974        if (DBG) log("dataConnectionNotInUse: check if dcac is inuse dcac=" + dcac);
975        for (ApnContext apnContext : mApnContexts.values()) {
976            if (apnContext.getDcAc() == dcac) {
977                if (DBG) log("dataConnectionNotInUse: in use by apnContext=" + apnContext);
978                return false;
979            }
980        }
981        // TODO: Fix retry handling so free DataConnections have empty apnlists.
982        // Probably move retry handling into DataConnections and reduce complexity
983        // of DCT.
984        if (DBG) log("dataConnectionNotInUse: tearDownAll");
985        dcac.tearDownAll("No connection", null);
986        if (DBG) log("dataConnectionNotInUse: not in use return true");
987        return true;
988    }
989
990    private DcAsyncChannel findFreeDataConnection() {
991        for (DcAsyncChannel dcac : mDataConnectionAcHashMap.values()) {
992            if (dcac.isInactiveSync() && dataConnectionNotInUse(dcac)) {
993                if (DBG) {
994                    log("findFreeDataConnection: found free DataConnection=" +
995                        " dcac=" + dcac);
996                }
997                return dcac;
998            }
999        }
1000        log("findFreeDataConnection: NO free DataConnection");
1001        return null;
1002    }
1003
1004    private boolean setupData(ApnContext apnContext, int radioTech) {
1005        if (DBG) log("setupData: apnContext=" + apnContext);
1006        ApnSetting apnSetting;
1007        DcAsyncChannel dcac;
1008
1009        int profileId = getApnProfileID(apnContext.getApnType());
1010        apnSetting = apnContext.getNextWaitingApn();
1011        if (apnSetting == null) {
1012            if (DBG) log("setupData: return for no apn found!");
1013            return false;
1014        }
1015
1016        dcac = checkForCompatibleConnectedApnContext(apnContext);
1017        if (dcac != null) {
1018            // Get the dcacApnSetting for the connection we want to share.
1019            ApnSetting dcacApnSetting = dcac.getApnSettingSync();
1020            if (dcacApnSetting != null) {
1021                // Setting is good, so use it.
1022                apnSetting = dcacApnSetting;
1023            }
1024        }
1025        if (dcac == null) {
1026            if (isOnlySingleDcAllowed(radioTech)) {
1027                if (isHigherPriorityApnContextActive(apnContext)) {
1028                    if (DBG) {
1029                        log("setupData: Higher priority ApnContext active.  Ignoring call");
1030                    }
1031                    return false;
1032                }
1033
1034                // Only lower priority calls left.  Disconnect them all in this single PDP case
1035                // so that we can bring up the requested higher priority call (once we receive
1036                // repsonse for deactivate request for the calls we are about to disconnect
1037                if (cleanUpAllConnections(true, Phone.REASON_SINGLE_PDN_ARBITRATION)) {
1038                    // If any call actually requested to be disconnected, means we can't
1039                    // bring up this connection yet as we need to wait for those data calls
1040                    // to be disconnected.
1041                    if (DBG) log("setupData: Some calls are disconnecting first.  Wait and retry");
1042                    return false;
1043                }
1044
1045                // No other calls are active, so proceed
1046                if (DBG) log("setupData: Single pdp. Continue setting up data call.");
1047            }
1048
1049            dcac = findFreeDataConnection();
1050
1051            if (dcac == null) {
1052                dcac = createDataConnection();
1053            }
1054
1055            if (dcac == null) {
1056                if (DBG) log("setupData: No free DataConnection and couldn't create one, WEIRD");
1057                return false;
1058            }
1059        }
1060        if (DBG) log("setupData: dcac=" + dcac + " apnSetting=" + apnSetting);
1061
1062        apnContext.setDataConnectionAc(dcac);
1063        apnContext.setApnSetting(apnSetting);
1064        apnContext.setState(DctConstants.State.CONNECTING);
1065        mPhone.notifyDataConnection(apnContext.getReason(), apnContext.getApnType());
1066
1067        Message msg = obtainMessage();
1068        msg.what = DctConstants.EVENT_DATA_SETUP_COMPLETE;
1069        msg.obj = apnContext;
1070        dcac.bringUp(apnContext, getInitialMaxRetry(), profileId, radioTech, msg);
1071
1072        if (DBG) log("setupData: initing!");
1073        return true;
1074    }
1075
1076    /**
1077     * Handles changes to the APN database.
1078     */
1079    private void onApnChanged() {
1080        DctConstants.State overallState = getOverallState();
1081        boolean isDisconnected = (overallState == DctConstants.State.IDLE ||
1082                overallState == DctConstants.State.FAILED);
1083
1084        if (mPhone instanceof GSMPhone) {
1085            // The "current" may no longer be valid.  MMS depends on this to send properly. TBD
1086            ((GSMPhone)mPhone).updateCurrentCarrierInProvider();
1087        }
1088
1089        // TODO: It'd be nice to only do this if the changed entrie(s)
1090        // match the current operator.
1091        if (DBG) log("onApnChanged: createAllApnList and cleanUpAllConnections");
1092        createAllApnList();
1093        setInitialAttachApn();
1094        cleanUpAllConnections(!isDisconnected, Phone.REASON_APN_CHANGED);
1095        if (isDisconnected) {
1096            setupDataOnConnectableApns(Phone.REASON_APN_CHANGED);
1097        }
1098    }
1099
1100    /**
1101     * @param cid Connection id provided from RIL.
1102     * @return DataConnectionAc associated with specified cid.
1103     */
1104    private DcAsyncChannel findDataConnectionAcByCid(int cid) {
1105        for (DcAsyncChannel dcac : mDataConnectionAcHashMap.values()) {
1106            if (dcac.getCidSync() == cid) {
1107                return dcac;
1108            }
1109        }
1110        return null;
1111    }
1112
1113    // TODO: For multiple Active APNs not exactly sure how to do this.
1114    @Override
1115    protected void gotoIdleAndNotifyDataConnection(String reason) {
1116        if (DBG) log("gotoIdleAndNotifyDataConnection: reason=" + reason);
1117        notifyDataConnection(reason);
1118        mActiveApn = null;
1119    }
1120
1121    /**
1122     * "Active" here means ApnContext isEnabled() and not in FAILED state
1123     * @param apnContext to compare with
1124     * @return true if higher priority active apn found
1125     */
1126    private boolean isHigherPriorityApnContextActive(ApnContext apnContext) {
1127        for (ApnContext otherContext : mPrioritySortedApnContexts) {
1128            if (apnContext.getApnType().equalsIgnoreCase(otherContext.getApnType())) return false;
1129            if (otherContext.isEnabled() && otherContext.getState() != DctConstants.State.FAILED) {
1130                return true;
1131            }
1132        }
1133        return false;
1134    }
1135
1136    /**
1137     * Reports if we support multiple connections or not.
1138     * This is a combination of factors, based on carrier and RAT.
1139     * @param rilRadioTech the RIL Radio Tech currently in use
1140     * @return true if only single DataConnection is allowed
1141     */
1142    private boolean isOnlySingleDcAllowed(int rilRadioTech) {
1143        int[] singleDcRats = mPhone.getContext().getResources().getIntArray(
1144                com.android.internal.R.array.config_onlySingleDcAllowed);
1145        boolean onlySingleDcAllowed = false;
1146        if (Build.IS_DEBUGGABLE &&
1147                SystemProperties.getBoolean("persist.telephony.test.singleDc", false)) {
1148            onlySingleDcAllowed = true;
1149        }
1150        if (singleDcRats != null) {
1151            for (int i=0; i < singleDcRats.length && onlySingleDcAllowed == false; i++) {
1152                if (rilRadioTech == singleDcRats[i]) onlySingleDcAllowed = true;
1153            }
1154        }
1155
1156        if (DBG) log("isOnlySingleDcAllowed(" + rilRadioTech + "): " + onlySingleDcAllowed);
1157        return onlySingleDcAllowed;
1158    }
1159
1160    @Override
1161    protected void restartRadio() {
1162        if (DBG) log("restartRadio: ************TURN OFF RADIO**************");
1163        cleanUpAllConnections(true, Phone.REASON_RADIO_TURNED_OFF);
1164        mPhone.getServiceStateTracker().powerOffRadioSafely(this);
1165        /* Note: no need to call setRadioPower(true).  Assuming the desired
1166         * radio power state is still ON (as tracked by ServiceStateTracker),
1167         * ServiceStateTracker will call setRadioPower when it receives the
1168         * RADIO_STATE_CHANGED notification for the power off.  And if the
1169         * desired power state has changed in the interim, we don't want to
1170         * override it with an unconditional power on.
1171         */
1172
1173        int reset = Integer.parseInt(SystemProperties.get("net.ppp.reset-by-timeout", "0"));
1174        SystemProperties.set("net.ppp.reset-by-timeout", String.valueOf(reset+1));
1175    }
1176
1177    /**
1178     * Return true if data connection need to be setup after disconnected due to
1179     * reason.
1180     *
1181     * @param reason the reason why data is disconnected
1182     * @return true if try setup data connection is need for this reason
1183     */
1184    private boolean retryAfterDisconnected(ApnContext apnContext) {
1185        boolean retry = true;
1186        String reason = apnContext.getReason();
1187
1188        if ( Phone.REASON_RADIO_TURNED_OFF.equals(reason) ||
1189                (isOnlySingleDcAllowed(mPhone.getServiceState().getRilDataRadioTechnology())
1190                 && isHigherPriorityApnContextActive(apnContext))) {
1191            retry = false;
1192        }
1193        return retry;
1194    }
1195
1196    private void startAlarmForReconnect(int delay, ApnContext apnContext) {
1197        String apnType = apnContext.getApnType();
1198
1199        Intent intent = new Intent(INTENT_RECONNECT_ALARM + "." + apnType);
1200        intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_REASON, apnContext.getReason());
1201        intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_TYPE, apnType);
1202
1203        if (DBG) {
1204            log("startAlarmForReconnect: delay=" + delay + " action=" + intent.getAction()
1205                    + " apn=" + apnContext);
1206        }
1207
1208        PendingIntent alarmIntent = PendingIntent.getBroadcast (mPhone.getContext(), 0,
1209                                        intent, PendingIntent.FLAG_UPDATE_CURRENT);
1210        apnContext.setReconnectIntent(alarmIntent);
1211        mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
1212                SystemClock.elapsedRealtime() + delay, alarmIntent);
1213    }
1214
1215    private void startAlarmForRestartTrySetup(int delay, ApnContext apnContext) {
1216        String apnType = apnContext.getApnType();
1217        Intent intent = new Intent(INTENT_RESTART_TRYSETUP_ALARM + "." + apnType);
1218        intent.putExtra(INTENT_RESTART_TRYSETUP_ALARM_EXTRA_TYPE, apnType);
1219
1220        if (DBG) {
1221            log("startAlarmForRestartTrySetup: delay=" + delay + " action=" + intent.getAction()
1222                    + " apn=" + apnContext);
1223        }
1224        PendingIntent alarmIntent = PendingIntent.getBroadcast (mPhone.getContext(), 0,
1225                                        intent, PendingIntent.FLAG_UPDATE_CURRENT);
1226        apnContext.setReconnectIntent(alarmIntent);
1227        mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
1228                SystemClock.elapsedRealtime() + delay, alarmIntent);
1229    }
1230
1231    private void notifyNoData(DcFailCause lastFailCauseCode,
1232                              ApnContext apnContext) {
1233        if (DBG) log( "notifyNoData: type=" + apnContext.getApnType());
1234        if (lastFailCauseCode.isPermanentFail()
1235            && (!apnContext.getApnType().equals(PhoneConstants.APN_TYPE_DEFAULT))) {
1236            mPhone.notifyDataConnectionFailed(apnContext.getReason(), apnContext.getApnType());
1237        }
1238    }
1239
1240    private void onRecordsLoaded() {
1241        if (DBG) log("onRecordsLoaded: createAllApnList");
1242        createAllApnList();
1243        setInitialAttachApn();
1244        if (mPhone.mCi.getRadioState().isOn()) {
1245            if (DBG) log("onRecordsLoaded: notifying data availability");
1246            notifyOffApnsOfAvailability(Phone.REASON_SIM_LOADED);
1247        }
1248        setupDataOnConnectableApns(Phone.REASON_SIM_LOADED);
1249    }
1250
1251    @Override
1252    protected void onSetDependencyMet(String apnType, boolean met) {
1253        // don't allow users to tweak hipri to work around default dependency not met
1254        if (PhoneConstants.APN_TYPE_HIPRI.equals(apnType)) return;
1255
1256        ApnContext apnContext = mApnContexts.get(apnType);
1257        if (apnContext == null) {
1258            loge("onSetDependencyMet: ApnContext not found in onSetDependencyMet(" +
1259                    apnType + ", " + met + ")");
1260            return;
1261        }
1262        applyNewState(apnContext, apnContext.isEnabled(), met);
1263        if (PhoneConstants.APN_TYPE_DEFAULT.equals(apnType)) {
1264            // tie actions on default to similar actions on HIPRI regarding dependencyMet
1265            apnContext = mApnContexts.get(PhoneConstants.APN_TYPE_HIPRI);
1266            if (apnContext != null) applyNewState(apnContext, apnContext.isEnabled(), met);
1267        }
1268    }
1269
1270    private void applyNewState(ApnContext apnContext, boolean enabled, boolean met) {
1271        boolean cleanup = false;
1272        boolean trySetup = false;
1273        if (DBG) {
1274            log("applyNewState(" + apnContext.getApnType() + ", " + enabled +
1275                    "(" + apnContext.isEnabled() + "), " + met + "(" +
1276                    apnContext.getDependencyMet() +"))");
1277        }
1278        if (apnContext.isReady()) {
1279            if (enabled && met) {
1280                DctConstants.State state = apnContext.getState();
1281                switch(state) {
1282                    case CONNECTING:
1283                    case SCANNING:
1284                    case CONNECTED:
1285                    case DISCONNECTING:
1286                        // We're "READY" and active so just return
1287                        if (DBG) log("applyNewState: 'ready' so return");
1288                        return;
1289                    case IDLE:
1290                        // fall through: this is unexpected but if it happens cleanup and try setup
1291                    case FAILED:
1292                    case RETRYING: {
1293                        // We're "READY" but not active so disconnect (cleanup = true) and
1294                        // connect (trySetup = true) to be sure we retry the connection.
1295                        trySetup = true;
1296                        apnContext.setReason(Phone.REASON_DATA_ENABLED);
1297                        break;
1298                    }
1299                }
1300            } else if (!enabled) {
1301                apnContext.setReason(Phone.REASON_DATA_DISABLED);
1302            } else {
1303                apnContext.setReason(Phone.REASON_DATA_DEPENDENCY_UNMET);
1304            }
1305            cleanup = true;
1306        } else {
1307            if (enabled && met) {
1308                if (apnContext.isEnabled()) {
1309                    apnContext.setReason(Phone.REASON_DATA_DEPENDENCY_MET);
1310                } else {
1311                    apnContext.setReason(Phone.REASON_DATA_ENABLED);
1312                }
1313                if (apnContext.getState() == DctConstants.State.FAILED) {
1314                    apnContext.setState(DctConstants.State.IDLE);
1315                }
1316                trySetup = true;
1317            }
1318        }
1319        apnContext.setEnabled(enabled);
1320        apnContext.setDependencyMet(met);
1321        if (cleanup) cleanUpConnection(true, apnContext);
1322        if (trySetup) trySetupData(apnContext);
1323    }
1324
1325    private DcAsyncChannel checkForCompatibleConnectedApnContext(ApnContext apnContext) {
1326        String apnType = apnContext.getApnType();
1327        ApnSetting dunSetting = null;
1328
1329        if (PhoneConstants.APN_TYPE_DUN.equals(apnType)) {
1330            dunSetting = fetchDunApn();
1331        }
1332        if (DBG) {
1333            log("checkForCompatibleConnectedApnContext: apnContext=" + apnContext );
1334        }
1335
1336        DcAsyncChannel potentialDcac = null;
1337        ApnContext potentialApnCtx = null;
1338        for (ApnContext curApnCtx : mApnContexts.values()) {
1339            DcAsyncChannel curDcac = curApnCtx.getDcAc();
1340            if (curDcac != null) {
1341                ApnSetting apnSetting = curApnCtx.getApnSetting();
1342                if (dunSetting != null) {
1343                    if (dunSetting.equals(apnSetting)) {
1344                        switch (curApnCtx.getState()) {
1345                            case CONNECTED:
1346                                if (DBG) {
1347                                    log("checkForCompatibleConnectedApnContext:"
1348                                            + " found dun conn=" + curDcac
1349                                            + " curApnCtx=" + curApnCtx);
1350                                }
1351                                return curDcac;
1352                            case RETRYING:
1353                            case CONNECTING:
1354                                potentialDcac = curDcac;
1355                                potentialApnCtx = curApnCtx;
1356                            default:
1357                                // Not connected, potential unchanged
1358                                break;
1359                        }
1360                    }
1361                } else if (apnSetting != null && apnSetting.canHandleType(apnType)) {
1362                    switch (curApnCtx.getState()) {
1363                        case CONNECTED:
1364                            if (DBG) {
1365                                log("checkForCompatibleConnectedApnContext:"
1366                                        + " found canHandle conn=" + curDcac
1367                                        + " curApnCtx=" + curApnCtx);
1368                            }
1369                            return curDcac;
1370                        case RETRYING:
1371                        case CONNECTING:
1372                            potentialDcac = curDcac;
1373                            potentialApnCtx = curApnCtx;
1374                        default:
1375                            // Not connected, potential unchanged
1376                            break;
1377                    }
1378                }
1379            } else {
1380                if (VDBG) {
1381                    log("checkForCompatibleConnectedApnContext: not conn curApnCtx=" + curApnCtx);
1382                }
1383            }
1384        }
1385        if (potentialDcac != null) {
1386            if (DBG) {
1387                log("checkForCompatibleConnectedApnContext: found potential conn=" + potentialDcac
1388                        + " curApnCtx=" + potentialApnCtx);
1389            }
1390            return potentialDcac;
1391        }
1392
1393        if (DBG) log("checkForCompatibleConnectedApnContext: NO conn apnContext=" + apnContext);
1394        return null;
1395    }
1396
1397    @Override
1398    protected void onEnableApn(int apnId, int enabled) {
1399        ApnContext apnContext = mApnContexts.get(apnIdToType(apnId));
1400        if (apnContext == null) {
1401            loge("onEnableApn(" + apnId + ", " + enabled + "): NO ApnContext");
1402            return;
1403        }
1404        // TODO change our retry manager to use the appropriate numbers for the new APN
1405        if (DBG) log("onEnableApn: apnContext=" + apnContext + " call applyNewState");
1406        applyNewState(apnContext, enabled == DctConstants.ENABLED, apnContext.getDependencyMet());
1407    }
1408
1409    @Override
1410    // TODO: We shouldnt need this.
1411    protected boolean onTrySetupData(String reason) {
1412        if (DBG) log("onTrySetupData: reason=" + reason);
1413        setupDataOnConnectableApns(reason);
1414        return true;
1415    }
1416
1417    protected boolean onTrySetupData(ApnContext apnContext) {
1418        if (DBG) log("onTrySetupData: apnContext=" + apnContext);
1419        return trySetupData(apnContext);
1420    }
1421
1422    @Override
1423    protected void onRoamingOff() {
1424        if (DBG) log("onRoamingOff");
1425
1426        if (mUserDataEnabled == false) return;
1427
1428        if (getDataOnRoamingEnabled() == false) {
1429            notifyOffApnsOfAvailability(Phone.REASON_ROAMING_OFF);
1430            setupDataOnConnectableApns(Phone.REASON_ROAMING_OFF);
1431        } else {
1432            notifyDataConnection(Phone.REASON_ROAMING_OFF);
1433        }
1434    }
1435
1436    @Override
1437    protected void onRoamingOn() {
1438        if (mUserDataEnabled == false) return;
1439
1440        if (getDataOnRoamingEnabled()) {
1441            if (DBG) log("onRoamingOn: setup data on roaming");
1442            setupDataOnConnectableApns(Phone.REASON_ROAMING_ON);
1443            notifyDataConnection(Phone.REASON_ROAMING_ON);
1444        } else {
1445            if (DBG) log("onRoamingOn: Tear down data connection on roaming.");
1446            cleanUpAllConnections(true, Phone.REASON_ROAMING_ON);
1447            notifyOffApnsOfAvailability(Phone.REASON_ROAMING_ON);
1448        }
1449    }
1450
1451    @Override
1452    protected void onRadioAvailable() {
1453        if (DBG) log("onRadioAvailable");
1454        if (mPhone.getSimulatedRadioControl() != null) {
1455            // Assume data is connected on the simulator
1456            // FIXME  this can be improved
1457            // setState(DctConstants.State.CONNECTED);
1458            notifyDataConnection(null);
1459
1460            log("onRadioAvailable: We're on the simulator; assuming data is connected");
1461        }
1462
1463        IccRecords r = mIccRecords.get();
1464        if (r != null && r.getRecordsLoaded()) {
1465            notifyOffApnsOfAvailability(null);
1466        }
1467
1468        if (getOverallState() != DctConstants.State.IDLE) {
1469            cleanUpConnection(true, null);
1470        }
1471    }
1472
1473    @Override
1474    protected void onRadioOffOrNotAvailable() {
1475        // Make sure our reconnect delay starts at the initial value
1476        // next time the radio comes on
1477
1478        mReregisterOnReconnectFailure = false;
1479
1480        if (mPhone.getSimulatedRadioControl() != null) {
1481            // Assume data is connected on the simulator
1482            // FIXME  this can be improved
1483            log("We're on the simulator; assuming radio off is meaningless");
1484        } else {
1485            if (DBG) log("onRadioOffOrNotAvailable: is off and clean up all connections");
1486            cleanUpAllConnections(false, Phone.REASON_RADIO_TURNED_OFF);
1487        }
1488        notifyOffApnsOfAvailability(null);
1489    }
1490
1491    @Override
1492    protected void completeConnection(ApnContext apnContext) {
1493        boolean isProvApn = apnContext.isProvisioningApn();
1494
1495        if (DBG) log("completeConnection: successful, notify the world apnContext=" + apnContext);
1496
1497        if (mIsProvisioning && !TextUtils.isEmpty(mProvisioningUrl)) {
1498            if (DBG) {
1499                log("completeConnection: MOBILE_PROVISIONING_ACTION url="
1500                        + mProvisioningUrl);
1501            }
1502            Intent newIntent = Intent.makeMainSelectorActivity(Intent.ACTION_MAIN,
1503                    Intent.CATEGORY_APP_BROWSER);
1504            newIntent.setData(Uri.parse(mProvisioningUrl));
1505            newIntent.setFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT |
1506                    Intent.FLAG_ACTIVITY_NEW_TASK);
1507            try {
1508                mPhone.getContext().startActivity(newIntent);
1509            } catch (ActivityNotFoundException e) {
1510                loge("completeConnection: startActivityAsUser failed" + e);
1511            }
1512        }
1513        mIsProvisioning = false;
1514        mProvisioningUrl = null;
1515
1516        mPhone.notifyDataConnection(apnContext.getReason(), apnContext.getApnType());
1517        startNetStatPoll();
1518        startDataStallAlarm(DATA_STALL_NOT_SUSPECTED);
1519    }
1520
1521    /**
1522     * A SETUP (aka bringUp) has completed, possibly with an error. If
1523     * there is an error this method will call {@link #onDataSetupCompleteError}.
1524     */
1525    @Override
1526    protected void onDataSetupComplete(AsyncResult ar) {
1527
1528        DcFailCause cause = DcFailCause.UNKNOWN;
1529        boolean handleError = false;
1530        ApnContext apnContext = null;
1531
1532        if(ar.userObj instanceof ApnContext){
1533            apnContext = (ApnContext)ar.userObj;
1534        } else {
1535            throw new RuntimeException("onDataSetupComplete: No apnContext");
1536        }
1537
1538        if (ar.exception == null) {
1539            DcAsyncChannel dcac = apnContext.getDcAc();
1540
1541            if (RADIO_TESTS) {
1542                // Note: To change radio.test.onDSC.null.dcac from command line you need to
1543                // adb root and adb remount and from the command line you can only change the
1544                // value to 1 once. To change it a second time you can reboot or execute
1545                // adb shell stop and then adb shell start. The command line to set the value is:
1546                // adb shell sqlite3 /data/data/com.android.providers.settings/databases/settings.db "insert into system (name,value) values ('radio.test.onDSC.null.dcac', '1');"
1547                ContentResolver cr = mPhone.getContext().getContentResolver();
1548                String radioTestProperty = "radio.test.onDSC.null.dcac";
1549                if (Settings.System.getInt(cr, radioTestProperty, 0) == 1) {
1550                    log("onDataSetupComplete: " + radioTestProperty +
1551                            " is true, set dcac to null and reset property to false");
1552                    dcac = null;
1553                    Settings.System.putInt(cr, radioTestProperty, 0);
1554                    log("onDataSetupComplete: " + radioTestProperty + "=" +
1555                            Settings.System.getInt(mPhone.getContext().getContentResolver(),
1556                                    radioTestProperty, -1));
1557                }
1558            }
1559            if (dcac == null) {
1560                log("onDataSetupComplete: no connection to DC, handle as error");
1561                cause = DcFailCause.CONNECTION_TO_DATACONNECTIONAC_BROKEN;
1562                handleError = true;
1563            } else {
1564                ApnSetting apn = apnContext.getApnSetting();
1565                if (DBG) {
1566                    log("onDataSetupComplete: success apn=" + (apn == null ? "unknown" : apn.apn));
1567                }
1568                if (apn != null && apn.proxy != null && apn.proxy.length() != 0) {
1569                    try {
1570                        String port = apn.port;
1571                        if (TextUtils.isEmpty(port)) port = "8080";
1572                        ProxyInfo proxy = new ProxyInfo(apn.proxy,
1573                                Integer.parseInt(port), null);
1574                        dcac.setLinkPropertiesHttpProxySync(proxy);
1575                    } catch (NumberFormatException e) {
1576                        loge("onDataSetupComplete: NumberFormatException making ProxyProperties (" +
1577                                apn.port + "): " + e);
1578                    }
1579                }
1580
1581                // everything is setup
1582                if(TextUtils.equals(apnContext.getApnType(),PhoneConstants.APN_TYPE_DEFAULT)) {
1583                    SystemProperties.set(PUPPET_MASTER_RADIO_STRESS_TEST, "true");
1584                    if (mCanSetPreferApn && mPreferredApn == null) {
1585                        if (DBG) log("onDataSetupComplete: PREFERED APN is null");
1586                        mPreferredApn = apn;
1587                        if (mPreferredApn != null) {
1588                            setPreferredApn(mPreferredApn.id);
1589                        }
1590                    }
1591                } else {
1592                    SystemProperties.set(PUPPET_MASTER_RADIO_STRESS_TEST, "false");
1593                }
1594
1595                // A connection is setup
1596                apnContext.setState(DctConstants.State.CONNECTED);
1597                boolean isProvApn = apnContext.isProvisioningApn();
1598                if ((!isProvApn) || mIsProvisioning) {
1599                    // Complete the connection normally notifying the world we're connected.
1600                    // We do this if this isn't a special provisioning apn or if we've been
1601                    // told its time to provision.
1602                    completeConnection(apnContext);
1603                } else {
1604                    // This is a provisioning APN that we're reporting as connected. Later
1605                    // when the user desires to upgrade this to a "default" connection,
1606                    // mIsProvisioning == true, we'll go through the code path above.
1607                    // mIsProvisioning becomes true when CMD_ENABLE_MOBILE_PROVISIONING
1608                    // is sent to the DCT.
1609                    if (DBG) {
1610                        log("onDataSetupComplete: successful, BUT send connected to prov apn as"
1611                                + " mIsProvisioning:" + mIsProvisioning + " == false"
1612                                + " && (isProvisioningApn:" + isProvApn + " == true");
1613                    }
1614
1615                    Intent intent = new Intent(
1616                            TelephonyIntents.ACTION_DATA_CONNECTION_CONNECTED_TO_PROVISIONING_APN);
1617                    intent.putExtra(PhoneConstants.DATA_APN_KEY, apnContext.getApnSetting().apn);
1618                    intent.putExtra(PhoneConstants.DATA_APN_TYPE_KEY, apnContext.getApnType());
1619
1620                    String apnType = apnContext.getApnType();
1621                    LinkProperties linkProperties = getLinkProperties(apnType);
1622                    if (linkProperties != null) {
1623                        intent.putExtra(PhoneConstants.DATA_LINK_PROPERTIES_KEY, linkProperties);
1624                        String iface = linkProperties.getInterfaceName();
1625                        if (iface != null) {
1626                            intent.putExtra(PhoneConstants.DATA_IFACE_NAME_KEY, iface);
1627                        }
1628                    }
1629                    NetworkCapabilities networkCapabilities = getNetworkCapabilities(apnType);
1630                    if (networkCapabilities != null) {
1631                        intent.putExtra(PhoneConstants.DATA_NETWORK_CAPABILITIES_KEY,
1632                                networkCapabilities);
1633                    }
1634
1635                    mPhone.getContext().sendBroadcastAsUser(intent, UserHandle.ALL);
1636                }
1637                if (DBG) {
1638                    log("onDataSetupComplete: SETUP complete type=" + apnContext.getApnType()
1639                        + ", reason:" + apnContext.getReason());
1640                }
1641            }
1642        } else {
1643            cause = (DcFailCause) (ar.result);
1644            if (DBG) {
1645                ApnSetting apn = apnContext.getApnSetting();
1646                log(String.format("onDataSetupComplete: error apn=%s cause=%s",
1647                        (apn == null ? "unknown" : apn.apn), cause));
1648            }
1649            if (cause.isEventLoggable()) {
1650                // Log this failure to the Event Logs.
1651                int cid = getCellLocationId();
1652                EventLog.writeEvent(EventLogTags.PDP_SETUP_FAIL,
1653                        cause.ordinal(), cid, TelephonyManager.getDefault().getNetworkType());
1654            }
1655            ApnSetting apn = apnContext.getApnSetting();
1656            mPhone.notifyPreciseDataConnectionFailed(apnContext.getReason(),
1657                    apnContext.getApnType(), apn != null ? apn.apn : "unknown", cause.toString());
1658
1659            // Count permanent failures and remove the APN we just tried
1660            if (cause.isPermanentFail()) apnContext.decWaitingApnsPermFailCount();
1661
1662            apnContext.removeWaitingApn(apnContext.getApnSetting());
1663            if (DBG) {
1664                log(String.format("onDataSetupComplete: WaitingApns.size=%d" +
1665                        " WaitingApnsPermFailureCountDown=%d",
1666                        apnContext.getWaitingApns().size(),
1667                        apnContext.getWaitingApnsPermFailCount()));
1668            }
1669            handleError = true;
1670        }
1671
1672        if (handleError) {
1673            onDataSetupCompleteError(ar);
1674        }
1675    }
1676
1677    /**
1678     * @return number of milli-seconds to delay between trying apns'
1679     */
1680    private int getApnDelay() {
1681        if (mFailFast) {
1682            return SystemProperties.getInt("persist.radio.apn_ff_delay",
1683                    APN_FAIL_FAST_DELAY_DEFAULT_MILLIS);
1684        } else {
1685            return SystemProperties.getInt("persist.radio.apn_delay", APN_DELAY_DEFAULT_MILLIS);
1686        }
1687    }
1688
1689    /**
1690     * Error has occurred during the SETUP {aka bringUP} request and the DCT
1691     * should either try the next waiting APN or start over from the
1692     * beginning if the list is empty. Between each SETUP request there will
1693     * be a delay defined by {@link #getApnDelay()}.
1694     */
1695    @Override
1696    protected void onDataSetupCompleteError(AsyncResult ar) {
1697        String reason = "";
1698        ApnContext apnContext = null;
1699
1700        if(ar.userObj instanceof ApnContext){
1701            apnContext = (ApnContext)ar.userObj;
1702        } else {
1703            throw new RuntimeException("onDataSetupCompleteError: No apnContext");
1704        }
1705
1706        // See if there are more APN's to try
1707        if (apnContext.getWaitingApns().isEmpty()) {
1708            apnContext.setState(DctConstants.State.FAILED);
1709            mPhone.notifyDataConnection(Phone.REASON_APN_FAILED, apnContext.getApnType());
1710
1711            apnContext.setDataConnectionAc(null);
1712
1713            if (apnContext.getWaitingApnsPermFailCount() == 0) {
1714                if (DBG) {
1715                    log("onDataSetupCompleteError: All APN's had permanent failures, stop retrying");
1716                }
1717            } else {
1718                int delay = getApnDelay();
1719                if (DBG) {
1720                    log("onDataSetupCompleteError: Not all APN's had permanent failures delay="
1721                            + delay);
1722                }
1723                startAlarmForRestartTrySetup(delay, apnContext);
1724            }
1725        } else {
1726            if (DBG) log("onDataSetupCompleteError: Try next APN");
1727            apnContext.setState(DctConstants.State.SCANNING);
1728            // Wait a bit before trying the next APN, so that
1729            // we're not tying up the RIL command channel
1730            startAlarmForReconnect(getApnDelay(), apnContext);
1731        }
1732    }
1733
1734    /**
1735     * Called when EVENT_DISCONNECT_DONE is received.
1736     */
1737    @Override
1738    protected void onDisconnectDone(int connId, AsyncResult ar) {
1739        ApnContext apnContext = null;
1740
1741        if (ar.userObj instanceof ApnContext) {
1742            apnContext = (ApnContext) ar.userObj;
1743        } else {
1744            loge("onDisconnectDone: Invalid ar in onDisconnectDone, ignore");
1745            return;
1746        }
1747
1748        if(DBG) log("onDisconnectDone: EVENT_DISCONNECT_DONE apnContext=" + apnContext);
1749        apnContext.setState(DctConstants.State.IDLE);
1750
1751        mPhone.notifyDataConnection(apnContext.getReason(), apnContext.getApnType());
1752
1753        // if all data connection are gone, check whether Airplane mode request was
1754        // pending.
1755        if (isDisconnected()) {
1756            if (mPhone.getServiceStateTracker().processPendingRadioPowerOffAfterDataOff()) {
1757                if(DBG) log("onDisconnectDone: radio will be turned off, no retries");
1758                // Radio will be turned off. No need to retry data setup
1759                apnContext.setApnSetting(null);
1760                apnContext.setDataConnectionAc(null);
1761                return;
1762            }
1763        }
1764
1765        // If APN is still enabled, try to bring it back up automatically
1766        if (mAttached.get() && apnContext.isReady() && retryAfterDisconnected(apnContext)) {
1767            SystemProperties.set(PUPPET_MASTER_RADIO_STRESS_TEST, "false");
1768            // Wait a bit before trying the next APN, so that
1769            // we're not tying up the RIL command channel.
1770            // This also helps in any external dependency to turn off the context.
1771            if(DBG) log("onDisconnectDone: attached, ready and retry after disconnect");
1772            startAlarmForReconnect(getApnDelay(), apnContext);
1773        } else {
1774            boolean restartRadioAfterProvisioning = mPhone.getContext().getResources().getBoolean(
1775                    com.android.internal.R.bool.config_restartRadioAfterProvisioning);
1776
1777            if (apnContext.isProvisioningApn() && restartRadioAfterProvisioning) {
1778                log("onDisconnectDone: restartRadio after provisioning");
1779                restartRadio();
1780            }
1781            apnContext.setApnSetting(null);
1782            apnContext.setDataConnectionAc(null);
1783            if (isOnlySingleDcAllowed(mPhone.getServiceState().getRilDataRadioTechnology())) {
1784                if(DBG) log("onDisconnectDone: isOnlySigneDcAllowed true so setup single apn");
1785                setupDataOnConnectableApns(Phone.REASON_SINGLE_PDN_ARBITRATION);
1786            } else {
1787                if(DBG) log("onDisconnectDone: not retrying");
1788            }
1789        }
1790    }
1791
1792    /**
1793     * Called when EVENT_DISCONNECT_DC_RETRYING is received.
1794     */
1795    @Override
1796    protected void onDisconnectDcRetrying(int connId, AsyncResult ar) {
1797        // We could just do this in DC!!!
1798        ApnContext apnContext = null;
1799
1800        if (ar.userObj instanceof ApnContext) {
1801            apnContext = (ApnContext) ar.userObj;
1802        } else {
1803            loge("onDisconnectDcRetrying: Invalid ar in onDisconnectDone, ignore");
1804            return;
1805        }
1806
1807        apnContext.setState(DctConstants.State.RETRYING);
1808        if(DBG) log("onDisconnectDcRetrying: apnContext=" + apnContext);
1809
1810        mPhone.notifyDataConnection(apnContext.getReason(), apnContext.getApnType());
1811    }
1812
1813
1814    @Override
1815    protected void onVoiceCallStarted() {
1816        if (DBG) log("onVoiceCallStarted");
1817        mInVoiceCall = true;
1818        if (isConnected() && ! mPhone.getServiceStateTracker().isConcurrentVoiceAndDataAllowed()) {
1819            if (DBG) log("onVoiceCallStarted stop polling");
1820            stopNetStatPoll();
1821            stopDataStallAlarm();
1822            notifyDataConnection(Phone.REASON_VOICE_CALL_STARTED);
1823        }
1824    }
1825
1826    @Override
1827    protected void onVoiceCallEnded() {
1828        if (DBG) log("onVoiceCallEnded");
1829        mInVoiceCall = false;
1830        if (isConnected()) {
1831            if (!mPhone.getServiceStateTracker().isConcurrentVoiceAndDataAllowed()) {
1832                startNetStatPoll();
1833                startDataStallAlarm(DATA_STALL_NOT_SUSPECTED);
1834                notifyDataConnection(Phone.REASON_VOICE_CALL_ENDED);
1835            } else {
1836                // clean slate after call end.
1837                resetPollStats();
1838            }
1839        }
1840        // reset reconnect timer
1841        setupDataOnConnectableApns(Phone.REASON_VOICE_CALL_ENDED);
1842    }
1843
1844    @Override
1845    protected void onCleanUpConnection(boolean tearDown, int apnId, String reason) {
1846        if (DBG) log("onCleanUpConnection");
1847        ApnContext apnContext = mApnContexts.get(apnIdToType(apnId));
1848        if (apnContext != null) {
1849            apnContext.setReason(reason);
1850            cleanUpConnection(tearDown, apnContext);
1851        }
1852    }
1853
1854    @Override
1855    protected boolean isConnected() {
1856        for (ApnContext apnContext : mApnContexts.values()) {
1857            if (apnContext.getState() == DctConstants.State.CONNECTED) {
1858                // At least one context is connected, return true
1859                return true;
1860            }
1861        }
1862        // There are not any contexts connected, return false
1863        return false;
1864    }
1865
1866    @Override
1867    public boolean isDisconnected() {
1868        for (ApnContext apnContext : mApnContexts.values()) {
1869            if (!apnContext.isDisconnected()) {
1870                // At least one context was not disconnected return false
1871                return false;
1872            }
1873        }
1874        // All contexts were disconnected so return true
1875        return true;
1876    }
1877
1878    @Override
1879    protected void notifyDataConnection(String reason) {
1880        if (DBG) log("notifyDataConnection: reason=" + reason);
1881        for (ApnContext apnContext : mApnContexts.values()) {
1882            if (mAttached.get() && apnContext.isReady()) {
1883                if (DBG) log("notifyDataConnection: type:" + apnContext.getApnType());
1884                mPhone.notifyDataConnection(reason != null ? reason : apnContext.getReason(),
1885                        apnContext.getApnType());
1886            }
1887        }
1888        notifyOffApnsOfAvailability(reason);
1889    }
1890
1891    /**
1892     * Based on the sim operator numeric, create a list for all possible
1893     * Data Connections and setup the preferredApn.
1894     */
1895    private void createAllApnList() {
1896        mAllApnSettings = new ArrayList<ApnSetting>();
1897        IccRecords r = mIccRecords.get();
1898        String operator = (r != null) ? r.getOperatorNumeric() : "";
1899        if (operator != null) {
1900            String selection = "numeric = '" + operator + "'";
1901            // query only enabled apn.
1902            // carrier_enabled : 1 means enabled apn, 0 disabled apn.
1903            selection += " and carrier_enabled = 1";
1904            if (DBG) log("createAllApnList: selection=" + selection);
1905
1906            Cursor cursor = mPhone.getContext().getContentResolver().query(
1907                    Telephony.Carriers.CONTENT_URI, null, selection, null, null);
1908
1909            if (cursor != null) {
1910                if (cursor.getCount() > 0) {
1911                    mAllApnSettings = createApnList(cursor);
1912                }
1913                cursor.close();
1914            }
1915        }
1916
1917        if (mAllApnSettings.isEmpty()) {
1918            if (DBG) log("createAllApnList: No APN found for carrier: " + operator);
1919            mPreferredApn = null;
1920            // TODO: What is the right behavior?
1921            //notifyNoData(DataConnection.FailCause.MISSING_UNKNOWN_APN);
1922        } else {
1923            mPreferredApn = getPreferredApn();
1924            if (mPreferredApn != null && !mPreferredApn.numeric.equals(operator)) {
1925                mPreferredApn = null;
1926                setPreferredApn(-1);
1927            }
1928            if (DBG) log("createAllApnList: mPreferredApn=" + mPreferredApn);
1929        }
1930        if (DBG) log("createAllApnList: X mAllApnSettings=" + mAllApnSettings);
1931    }
1932
1933    /** Return the DC AsyncChannel for the new data connection */
1934    private DcAsyncChannel createDataConnection() {
1935        if (DBG) log("createDataConnection E");
1936
1937        int id = mUniqueIdGenerator.getAndIncrement();
1938        DataConnection conn = DataConnection.makeDataConnection(mPhone, id,
1939                                                this, mDcTesterFailBringUpAll, mDcc);
1940        mDataConnections.put(id, conn);
1941        DcAsyncChannel dcac = new DcAsyncChannel(conn, LOG_TAG);
1942        int status = dcac.fullyConnectSync(mPhone.getContext(), this, conn.getHandler());
1943        if (status == AsyncChannel.STATUS_SUCCESSFUL) {
1944            mDataConnectionAcHashMap.put(dcac.getDataConnectionIdSync(), dcac);
1945        } else {
1946            loge("createDataConnection: Could not connect to dcac=" + dcac + " status=" + status);
1947        }
1948
1949        if (DBG) log("createDataConnection() X id=" + id + " dc=" + conn);
1950        return dcac;
1951    }
1952
1953    private void destroyDataConnections() {
1954        if(mDataConnections != null) {
1955            if (DBG) log("destroyDataConnections: clear mDataConnectionList");
1956            mDataConnections.clear();
1957        } else {
1958            if (DBG) log("destroyDataConnections: mDataConnecitonList is empty, ignore");
1959        }
1960    }
1961
1962    /**
1963     * Build a list of APNs to be used to create PDP's.
1964     *
1965     * @param requestedApnType
1966     * @return waitingApns list to be used to create PDP
1967     *          error when waitingApns.isEmpty()
1968     */
1969    private ArrayList<ApnSetting> buildWaitingApns(String requestedApnType, int radioTech) {
1970        if (DBG) log("buildWaitingApns: E requestedApnType=" + requestedApnType);
1971        ArrayList<ApnSetting> apnList = new ArrayList<ApnSetting>();
1972
1973        if (requestedApnType.equals(PhoneConstants.APN_TYPE_DUN)) {
1974            ApnSetting dun = fetchDunApn();
1975            if (dun != null) {
1976                apnList.add(dun);
1977                if (DBG) log("buildWaitingApns: X added APN_TYPE_DUN apnList=" + apnList);
1978                return apnList;
1979            }
1980        }
1981
1982        IccRecords r = mIccRecords.get();
1983        String operator = (r != null) ? r.getOperatorNumeric() : "";
1984
1985        // This is a workaround for a bug (7305641) where we don't failover to other
1986        // suitable APNs if our preferred APN fails.  On prepaid ATT sims we need to
1987        // failover to a provisioning APN, but once we've used their default data
1988        // connection we are locked to it for life.  This change allows ATT devices
1989        // to say they don't want to use preferred at all.
1990        boolean usePreferred = true;
1991        try {
1992            usePreferred = ! mPhone.getContext().getResources().getBoolean(com.android.
1993                    internal.R.bool.config_dontPreferApn);
1994        } catch (Resources.NotFoundException e) {
1995            if (DBG) log("buildWaitingApns: usePreferred NotFoundException set to true");
1996            usePreferred = true;
1997        }
1998        if (DBG) {
1999            log("buildWaitingApns: usePreferred=" + usePreferred
2000                    + " canSetPreferApn=" + mCanSetPreferApn
2001                    + " mPreferredApn=" + mPreferredApn
2002                    + " operator=" + operator + " radioTech=" + radioTech
2003                    + " IccRecords r=" + r);
2004        }
2005
2006        if (usePreferred && mCanSetPreferApn && mPreferredApn != null &&
2007                mPreferredApn.canHandleType(requestedApnType)) {
2008            if (DBG) {
2009                log("buildWaitingApns: Preferred APN:" + operator + ":"
2010                        + mPreferredApn.numeric + ":" + mPreferredApn);
2011            }
2012            if (mPreferredApn.numeric.equals(operator)) {
2013                if (mPreferredApn.bearer == 0 || mPreferredApn.bearer == radioTech) {
2014                    apnList.add(mPreferredApn);
2015                    if (DBG) log("buildWaitingApns: X added preferred apnList=" + apnList);
2016                    return apnList;
2017                } else {
2018                    if (DBG) log("buildWaitingApns: no preferred APN");
2019                    setPreferredApn(-1);
2020                    mPreferredApn = null;
2021                }
2022            } else {
2023                if (DBG) log("buildWaitingApns: no preferred APN");
2024                setPreferredApn(-1);
2025                mPreferredApn = null;
2026            }
2027        }
2028        if (mAllApnSettings != null) {
2029            if (DBG) log("buildWaitingApns: mAllApnSettings=" + mAllApnSettings);
2030            for (ApnSetting apn : mAllApnSettings) {
2031                if (DBG) log("buildWaitingApns: apn=" + apn);
2032                if (apn.canHandleType(requestedApnType)) {
2033                    if (apn.bearer == 0 || apn.bearer == radioTech) {
2034                        if (DBG) log("buildWaitingApns: adding apn=" + apn.toString());
2035                        apnList.add(apn);
2036                    } else {
2037                        if (DBG) {
2038                            log("buildWaitingApns: bearer:" + apn.bearer + " != "
2039                                    + "radioTech:" + radioTech);
2040                        }
2041                    }
2042                } else {
2043                if (DBG) {
2044                    log("buildWaitingApns: couldn't handle requesedApnType="
2045                            + requestedApnType);
2046                }
2047            }
2048            }
2049        } else {
2050            loge("mAllApnSettings is empty!");
2051        }
2052        if (DBG) log("buildWaitingApns: X apnList=" + apnList);
2053        return apnList;
2054    }
2055
2056    private String apnListToString (ArrayList<ApnSetting> apns) {
2057        StringBuilder result = new StringBuilder();
2058        for (int i = 0, size = apns.size(); i < size; i++) {
2059            result.append('[')
2060                  .append(apns.get(i).toString())
2061                  .append(']');
2062        }
2063        return result.toString();
2064    }
2065
2066    private void setPreferredApn(int pos) {
2067        if (!mCanSetPreferApn) {
2068            log("setPreferredApn: X !canSEtPreferApn");
2069            return;
2070        }
2071
2072        log("setPreferredApn: delete");
2073        ContentResolver resolver = mPhone.getContext().getContentResolver();
2074        resolver.delete(PREFERAPN_NO_UPDATE_URI, null, null);
2075
2076        if (pos >= 0) {
2077            log("setPreferredApn: insert");
2078            ContentValues values = new ContentValues();
2079            values.put(APN_ID, pos);
2080            resolver.insert(PREFERAPN_NO_UPDATE_URI, values);
2081        }
2082    }
2083
2084    private ApnSetting getPreferredApn() {
2085        if (mAllApnSettings.isEmpty()) {
2086            log("getPreferredApn: X not found mAllApnSettings.isEmpty");
2087            return null;
2088        }
2089
2090        Cursor cursor = mPhone.getContext().getContentResolver().query(
2091                PREFERAPN_NO_UPDATE_URI, new String[] { "_id", "name", "apn" },
2092                null, null, Telephony.Carriers.DEFAULT_SORT_ORDER);
2093
2094        if (cursor != null) {
2095            mCanSetPreferApn = true;
2096        } else {
2097            mCanSetPreferApn = false;
2098        }
2099        log("getPreferredApn: mRequestedApnType=" + mRequestedApnType + " cursor=" + cursor
2100                + " cursor.count=" + ((cursor != null) ? cursor.getCount() : 0));
2101
2102        if (mCanSetPreferApn && cursor.getCount() > 0) {
2103            int pos;
2104            cursor.moveToFirst();
2105            pos = cursor.getInt(cursor.getColumnIndexOrThrow(Telephony.Carriers._ID));
2106            for(ApnSetting p : mAllApnSettings) {
2107                log("getPreferredApn: apnSetting=" + p);
2108                if (p.id == pos && p.canHandleType(mRequestedApnType)) {
2109                    log("getPreferredApn: X found apnSetting" + p);
2110                    cursor.close();
2111                    return p;
2112                }
2113            }
2114        }
2115
2116        if (cursor != null) {
2117            cursor.close();
2118        }
2119
2120        log("getPreferredApn: X not found");
2121        return null;
2122    }
2123
2124    @Override
2125    public void handleMessage (Message msg) {
2126        if (DBG) log("handleMessage msg=" + msg);
2127
2128        if (!mPhone.mIsTheCurrentActivePhone || mIsDisposed) {
2129            loge("handleMessage: Ignore GSM msgs since GSM phone is inactive");
2130            return;
2131        }
2132
2133        switch (msg.what) {
2134            case DctConstants.EVENT_RECORDS_LOADED:
2135                onRecordsLoaded();
2136                break;
2137
2138            case DctConstants.EVENT_DATA_CONNECTION_DETACHED:
2139                onDataConnectionDetached();
2140                break;
2141
2142            case DctConstants.EVENT_DATA_CONNECTION_ATTACHED:
2143                onDataConnectionAttached();
2144                break;
2145
2146            case DctConstants.EVENT_DO_RECOVERY:
2147                doRecovery();
2148                break;
2149
2150            case DctConstants.EVENT_APN_CHANGED:
2151                onApnChanged();
2152                break;
2153
2154            case DctConstants.EVENT_PS_RESTRICT_ENABLED:
2155                /**
2156                 * We don't need to explicitly to tear down the PDP context
2157                 * when PS restricted is enabled. The base band will deactive
2158                 * PDP context and notify us with PDP_CONTEXT_CHANGED.
2159                 * But we should stop the network polling and prevent reset PDP.
2160                 */
2161                if (DBG) log("EVENT_PS_RESTRICT_ENABLED " + mIsPsRestricted);
2162                stopNetStatPoll();
2163                stopDataStallAlarm();
2164                mIsPsRestricted = true;
2165                break;
2166
2167            case DctConstants.EVENT_PS_RESTRICT_DISABLED:
2168                /**
2169                 * When PS restrict is removed, we need setup PDP connection if
2170                 * PDP connection is down.
2171                 */
2172                if (DBG) log("EVENT_PS_RESTRICT_DISABLED " + mIsPsRestricted);
2173                mIsPsRestricted  = false;
2174                if (isConnected()) {
2175                    startNetStatPoll();
2176                    startDataStallAlarm(DATA_STALL_NOT_SUSPECTED);
2177                } else {
2178                    // TODO: Should all PDN states be checked to fail?
2179                    if (mState == DctConstants.State.FAILED) {
2180                        cleanUpAllConnections(false, Phone.REASON_PS_RESTRICT_ENABLED);
2181                        mReregisterOnReconnectFailure = false;
2182                    }
2183                    ApnContext apnContext = mApnContexts.get(PhoneConstants.APN_TYPE_DEFAULT);
2184                    if (apnContext != null) {
2185                        apnContext.setReason(Phone.REASON_PS_RESTRICT_ENABLED);
2186                        trySetupData(apnContext);
2187                    } else {
2188                        loge("**** Default ApnContext not found ****");
2189                        if (Build.IS_DEBUGGABLE) {
2190                            throw new RuntimeException("Default ApnContext not found");
2191                        }
2192                    }
2193                }
2194                break;
2195
2196            case DctConstants.EVENT_TRY_SETUP_DATA:
2197                if (msg.obj instanceof ApnContext) {
2198                    onTrySetupData((ApnContext)msg.obj);
2199                } else if (msg.obj instanceof String) {
2200                    onTrySetupData((String)msg.obj);
2201                } else {
2202                    loge("EVENT_TRY_SETUP request w/o apnContext or String");
2203                }
2204                break;
2205
2206            case DctConstants.EVENT_CLEAN_UP_CONNECTION:
2207                boolean tearDown = (msg.arg1 == 0) ? false : true;
2208                if (DBG) log("EVENT_CLEAN_UP_CONNECTION tearDown=" + tearDown);
2209                if (msg.obj instanceof ApnContext) {
2210                    cleanUpConnection(tearDown, (ApnContext)msg.obj);
2211                } else {
2212                    loge("EVENT_CLEAN_UP_CONNECTION request w/o apn context, call super");
2213                    super.handleMessage(msg);
2214                }
2215                break;
2216
2217            default:
2218                // handle the message in the super class DataConnectionTracker
2219                super.handleMessage(msg);
2220                break;
2221        }
2222    }
2223
2224    protected int getApnProfileID(String apnType) {
2225        if (TextUtils.equals(apnType, PhoneConstants.APN_TYPE_IMS)) {
2226            return RILConstants.DATA_PROFILE_IMS;
2227        } else if (TextUtils.equals(apnType, PhoneConstants.APN_TYPE_FOTA)) {
2228            return RILConstants.DATA_PROFILE_FOTA;
2229        } else if (TextUtils.equals(apnType, PhoneConstants.APN_TYPE_CBS)) {
2230            return RILConstants.DATA_PROFILE_CBS;
2231        } else if (TextUtils.equals(apnType, PhoneConstants.APN_TYPE_IA)) {
2232            return RILConstants.DATA_PROFILE_DEFAULT; // DEFAULT for now
2233        } else if (TextUtils.equals(apnType, PhoneConstants.APN_TYPE_DUN)) {
2234            return RILConstants.DATA_PROFILE_TETHERED;
2235        } else {
2236            return RILConstants.DATA_PROFILE_DEFAULT;
2237        }
2238    }
2239
2240    private int getCellLocationId() {
2241        int cid = -1;
2242        CellLocation loc = mPhone.getCellLocation();
2243
2244        if (loc != null) {
2245            if (loc instanceof GsmCellLocation) {
2246                cid = ((GsmCellLocation)loc).getCid();
2247            } else if (loc instanceof CdmaCellLocation) {
2248                cid = ((CdmaCellLocation)loc).getBaseStationId();
2249            }
2250        }
2251        return cid;
2252    }
2253
2254    @Override
2255    protected void onUpdateIcc() {
2256        if (mUiccController == null ) {
2257            return;
2258        }
2259
2260        IccRecords newIccRecords = mUiccController.getIccRecords(UiccController.APP_FAM_3GPP);
2261
2262        IccRecords r = mIccRecords.get();
2263        if (r != newIccRecords) {
2264            if (r != null) {
2265                log("Removing stale icc objects.");
2266                r.unregisterForRecordsLoaded(this);
2267                mIccRecords.set(null);
2268            }
2269            if (newIccRecords != null) {
2270                log("New records found");
2271                mIccRecords.set(newIccRecords);
2272                newIccRecords.registerForRecordsLoaded(
2273                        this, DctConstants.EVENT_RECORDS_LOADED, null);
2274            }
2275        }
2276    }
2277
2278    @Override
2279    protected void log(String s) {
2280        Rlog.d(LOG_TAG, s);
2281    }
2282
2283    @Override
2284    protected void loge(String s) {
2285        Rlog.e(LOG_TAG, s);
2286    }
2287
2288    @Override
2289    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
2290        pw.println("DataConnectionTracker extends:");
2291        super.dump(fd, pw, args);
2292        pw.println(" mReregisterOnReconnectFailure=" + mReregisterOnReconnectFailure);
2293        pw.println(" canSetPreferApn=" + mCanSetPreferApn);
2294        pw.println(" mApnObserver=" + mApnObserver);
2295        pw.println(" getOverallState=" + getOverallState());
2296        pw.println(" mDataConnectionAsyncChannels=%s\n" + mDataConnectionAcHashMap);
2297        pw.println(" mAttached=" + mAttached.get());
2298    }
2299}
2300