Examples with NetworkStateTracker android.net.NetworkStateTracker used on opensource projects

Example 1 with NetworkStateTracker

use of android.net.NetworkStateTracker in project android_frameworks_base by ParanoidAndroid.

the class ConnectivityService method handleCaptivePortalTrackerCheck.

private void handleCaptivePortalTrackerCheck(NetworkInfo info) {
    if (DBG)
        log("Captive portal check " + info);
    int type = info.getType();
    final NetworkStateTracker thisNet = mNetTrackers[type];
    if (mNetConfigs[type].isDefault()) {
        if (mActiveDefaultNetwork != -1 && mActiveDefaultNetwork != type) {
            if (isNewNetTypePreferredOverCurrentNetType(type)) {
                if (DBG)
                    log("Captive check on " + info.getTypeName());
                mCaptivePortalTracker.detectCaptivePortal(new NetworkInfo(info));
                return;
            } else {
                if (DBG)
                    log("Tear down low priority net " + info.getTypeName());
                teardown(thisNet);
                return;
            }
        }
    }
    if (DBG)
        log("handleCaptivePortalTrackerCheck: call captivePortalCheckComplete ni=" + info);
    thisNet.captivePortalCheckComplete();
}

Example 2 with NetworkStateTracker

use of android.net.NetworkStateTracker in project android_frameworks_base by ParanoidAndroid.

the class ConnectivityService method tryFailover.

private void tryFailover(int prevNetType) {
    /*
         * If this is a default network, check if other defaults are available.
         * Try to reconnect on all available and let them hash it out when
         * more than one connects.
         */
    if (mNetConfigs[prevNetType].isDefault()) {
        if (mActiveDefaultNetwork == prevNetType) {
            if (DBG) {
                log("tryFailover: set mActiveDefaultNetwork=-1, prevNetType=" + prevNetType);
            }
            mActiveDefaultNetwork = -1;
        }
        //            }
        for (int checkType = 0; checkType <= ConnectivityManager.MAX_NETWORK_TYPE; checkType++) {
            if (checkType == prevNetType)
                continue;
            if (mNetConfigs[checkType] == null)
                continue;
            if (!mNetConfigs[checkType].isDefault())
                continue;
            if (mNetTrackers[checkType] == null)
                continue;
            // Enabling the isAvailable() optimization caused mobile to not get
            // selected if it was in the middle of error handling. Specifically
            // a moble connection that took 30 seconds to complete the DEACTIVATE_DATA_CALL
            // would not be available and we wouldn't get connected to anything.
            // So removing the isAvailable() optimization below for now. TODO: This
            // optimization should work and we need to investigate why it doesn't work.
            // This could be related to how DEACTIVATE_DATA_CALL is reporting its
            // complete before it is really complete.
            //                if (!mNetTrackers[checkType].isAvailable()) continue;
            //                if (currentPriority >= mNetConfigs[checkType].mPriority) continue;
            NetworkStateTracker checkTracker = mNetTrackers[checkType];
            NetworkInfo checkInfo = checkTracker.getNetworkInfo();
            if (!checkInfo.isConnectedOrConnecting() || checkTracker.isTeardownRequested()) {
                checkInfo.setFailover(true);
                checkTracker.reconnect();
            }
            if (DBG)
                log("Attempting to switch to " + checkInfo.getTypeName());
        }
    }
}

Example 3 with NetworkStateTracker

use of android.net.NetworkStateTracker in project android_frameworks_base by ParanoidAndroid.

the class ConnectivityService method setupDataActivityTracking.

/**
     * Setup data activity tracking for the given network interface.
     *
     * Every {@code setupDataActivityTracking} should be paired with a
     * {@link removeDataActivityTracking} for cleanup.
     */
private void setupDataActivityTracking(int type) {
    final NetworkStateTracker thisNet = mNetTrackers[type];
    final String iface = thisNet.getLinkProperties().getInterfaceName();
    final int timeout;
    if (ConnectivityManager.isNetworkTypeMobile(type)) {
        timeout = Settings.Global.getInt(mContext.getContentResolver(), Settings.Global.DATA_ACTIVITY_TIMEOUT_MOBILE, 0);
        // Canonicalize mobile network type
        type = ConnectivityManager.TYPE_MOBILE;
    } else if (ConnectivityManager.TYPE_WIFI == type) {
        timeout = Settings.Global.getInt(mContext.getContentResolver(), Settings.Global.DATA_ACTIVITY_TIMEOUT_WIFI, 0);
    } else {
        // do not track any other networks
        timeout = 0;
    }
    if (timeout > 0 && iface != null) {
        try {
            mNetd.addIdleTimer(iface, timeout, Integer.toString(type));
        } catch (RemoteException e) {
        }
    }
}

Example 4 with NetworkStateTracker

use of android.net.NetworkStateTracker in project android_frameworks_base by ParanoidAndroid.

the class ConnectivityService method getAllNetworkState.

@Override
public NetworkState[] getAllNetworkState() {
    enforceAccessPermission();
    final int uid = Binder.getCallingUid();
    final ArrayList<NetworkState> result = Lists.newArrayList();
    synchronized (mRulesLock) {
        for (NetworkStateTracker tracker : mNetTrackers) {
            if (tracker != null) {
                final NetworkInfo info = getFilteredNetworkInfo(tracker, uid);
                result.add(new NetworkState(info, tracker.getLinkProperties(), tracker.getLinkCapabilities()));
            }
        }
    }
    return result.toArray(new NetworkState[result.size()]);
}

Example 5 with NetworkStateTracker

use of android.net.NetworkStateTracker in project android_frameworks_base by ParanoidAndroid.

the class ConnectivityService method handleDisconnect.

/**
     * Handle a {@code DISCONNECTED} event. If this pertains to the non-active
     * network, we ignore it. If it is for the active network, we send out a
     * broadcast. But first, we check whether it might be possible to connect
     * to a different network.
     * @param info the {@code NetworkInfo} for the network
     */
private void handleDisconnect(NetworkInfo info) {
    int prevNetType = info.getType();
    mNetTrackers[prevNetType].setTeardownRequested(false);
    // Remove idletimer previously setup in {@code handleConnect}
    removeDataActivityTracking(prevNetType);
    /*
         * If the disconnected network is not the active one, then don't report
         * this as a loss of connectivity. What probably happened is that we're
         * getting the disconnect for a network that we explicitly disabled
         * in accordance with network preference policies.
         */
    if (!mNetConfigs[prevNetType].isDefault()) {
        List<Integer> pids = mNetRequestersPids[prevNetType];
        for (Integer pid : pids) {
            // will remove them because the net's no longer connected
            // need to do this now as only now do we know the pids and
            // can properly null things that are no longer referenced.
            reassessPidDns(pid.intValue(), false);
        }
    }
    Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
    intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, new NetworkInfo(info));
    intent.putExtra(ConnectivityManager.EXTRA_NETWORK_TYPE, info.getType());
    if (info.isFailover()) {
        intent.putExtra(ConnectivityManager.EXTRA_IS_FAILOVER, true);
        info.setFailover(false);
    }
    if (info.getReason() != null) {
        intent.putExtra(ConnectivityManager.EXTRA_REASON, info.getReason());
    }
    if (info.getExtraInfo() != null) {
        intent.putExtra(ConnectivityManager.EXTRA_EXTRA_INFO, info.getExtraInfo());
    }
    if (mNetConfigs[prevNetType].isDefault()) {
        tryFailover(prevNetType);
        if (mActiveDefaultNetwork != -1) {
            NetworkInfo switchTo = mNetTrackers[mActiveDefaultNetwork].getNetworkInfo();
            intent.putExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO, switchTo);
        } else {
            // we're not connected anymore
            mDefaultInetConditionPublished = 0;
            intent.putExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, true);
        }
    }
    intent.putExtra(ConnectivityManager.EXTRA_INET_CONDITION, mDefaultInetConditionPublished);
    // Reset interface if no other connections are using the same interface
    boolean doReset = true;
    LinkProperties linkProperties = mNetTrackers[prevNetType].getLinkProperties();
    if (linkProperties != null) {
        String oldIface = linkProperties.getInterfaceName();
        if (TextUtils.isEmpty(oldIface) == false) {
            for (NetworkStateTracker networkStateTracker : mNetTrackers) {
                if (networkStateTracker == null)
                    continue;
                NetworkInfo networkInfo = networkStateTracker.getNetworkInfo();
                if (networkInfo.isConnected() && networkInfo.getType() != prevNetType) {
                    LinkProperties l = networkStateTracker.getLinkProperties();
                    if (l == null)
                        continue;
                    if (oldIface.equals(l.getInterfaceName())) {
                        doReset = false;
                        break;
                    }
                }
            }
        }
    }
    // do this before we broadcast the change
    handleConnectivityChange(prevNetType, doReset);
    final Intent immediateIntent = new Intent(intent);
    immediateIntent.setAction(CONNECTIVITY_ACTION_IMMEDIATE);
    sendStickyBroadcast(immediateIntent);
    sendStickyBroadcastDelayed(intent, getConnectivityChangeDelay());
    /*
         * If the failover network is already connected, then immediately send
         * out a followup broadcast indicating successful failover
         */
    if (mActiveDefaultNetwork != -1) {
        sendConnectedBroadcastDelayed(mNetTrackers[mActiveDefaultNetwork].getNetworkInfo(), getConnectivityChangeDelay());
    }
}