Home | History | Annotate | Download | only in util 
      1 /*
      2  * Copyright (C) 2016 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.net.util;
     18 
     19 import android.content.BroadcastReceiver;
     20 import android.content.ContentResolver;
     21 import android.content.Context;
     22 import android.content.Intent;
     23 import android.content.IntentFilter;
     24 import android.database.ContentObserver;
     25 import android.net.ConnectivityManager;
     26 import android.net.Uri;
     27 import android.os.Handler;
     28 import android.os.Message;
     29 import android.os.UserHandle;
     30 import android.provider.Settings;
     31 import android.util.Slog;
     32 
     33 import java.util.Arrays;
     34 import java.util.List;
     35 
     36 import com.android.internal.annotations.VisibleForTesting;
     37 import com.android.internal.R;
     38 
     39 import static android.provider.Settings.Global.NETWORK_AVOID_BAD_WIFI;
     40 import static android.provider.Settings.Global.NETWORK_METERED_MULTIPATH_PREFERENCE;
     41 
     42 /**
     43  * A class to encapsulate management of the "Smart Networking" capability of
     44  * avoiding bad Wi-Fi when, for example upstream connectivity is lost or
     45  * certain critical link failures occur.
     46  *
     47  * This enables the device to switch to another form of connectivity, like
     48  * mobile, if it's available and working.
     49  *
     50  * The Runnable |avoidBadWifiCallback|, if given, is posted to the supplied
     51  * Handler' whenever the computed "avoid bad wifi" value changes.
     52  *
     53  * Disabling this reverts the device to a level of networking sophistication
     54  * circa 2012-13 by disabling disparate code paths each of which contribute to
     55  * maintaining continuous, working Internet connectivity.
     56  *
     57  * @hide
     58  */
     59 public class MultinetworkPolicyTracker {
     60     private static String TAG = MultinetworkPolicyTracker.class.getSimpleName();
     61 
     62     private final Context mContext;
     63     private final Handler mHandler;
     64     private final Runnable mReevaluateRunnable;
     65     private final List<Uri> mSettingsUris;
     66     private final ContentResolver mResolver;
     67     private final SettingObserver mSettingObserver;
     68     private final BroadcastReceiver mBroadcastReceiver;
     69 
     70     private volatile boolean mAvoidBadWifi = true;
     71     private volatile int mMeteredMultipathPreference;
     72 
     73     public MultinetworkPolicyTracker(Context ctx, Handler handler) {
     74         this(ctx, handler, null);
     75     }
     76 
     77     public MultinetworkPolicyTracker(Context ctx, Handler handler, Runnable avoidBadWifiCallback) {
     78         mContext = ctx;
     79         mHandler = handler;
     80         mReevaluateRunnable = () -> {
     81             if (updateAvoidBadWifi() && avoidBadWifiCallback != null) {
     82                 avoidBadWifiCallback.run();
     83             }
     84             updateMeteredMultipathPreference();
     85         };
     86         mSettingsUris = Arrays.asList(
     87             Settings.Global.getUriFor(NETWORK_AVOID_BAD_WIFI),
     88             Settings.Global.getUriFor(NETWORK_METERED_MULTIPATH_PREFERENCE));
     89         mResolver = mContext.getContentResolver();
     90         mSettingObserver = new SettingObserver();
     91         mBroadcastReceiver = new BroadcastReceiver() {
     92             @Override
     93             public void onReceive(Context context, Intent intent) {
     94                 reevaluate();
     95             }
     96         };
     97 
     98         updateAvoidBadWifi();
     99         updateMeteredMultipathPreference();
    100     }
    101 
    102     public void start() {
    103         for (Uri uri : mSettingsUris) {
    104             mResolver.registerContentObserver(uri, false, mSettingObserver);
    105         }
    106 
    107         final IntentFilter intentFilter = new IntentFilter();
    108         intentFilter.addAction(Intent.ACTION_CONFIGURATION_CHANGED);
    109         mContext.registerReceiverAsUser(
    110                 mBroadcastReceiver, UserHandle.ALL, intentFilter, null, null);
    111 
    112         reevaluate();
    113     }
    114 
    115     public void shutdown() {
    116         mResolver.unregisterContentObserver(mSettingObserver);
    117 
    118         mContext.unregisterReceiver(mBroadcastReceiver);
    119     }
    120 
    121     public boolean getAvoidBadWifi() {
    122         return mAvoidBadWifi;
    123     }
    124 
    125     // TODO: move this to MultipathPolicyTracker.
    126     public int getMeteredMultipathPreference() {
    127         return mMeteredMultipathPreference;
    128     }
    129 
    130     /**
    131      * Whether the device or carrier configuration disables avoiding bad wifi by default.
    132      */
    133     public boolean configRestrictsAvoidBadWifi() {
    134         return (mContext.getResources().getInteger(R.integer.config_networkAvoidBadWifi) == 0);
    135     }
    136 
    137     /**
    138      * Whether we should display a notification when wifi becomes unvalidated.
    139      */
    140     public boolean shouldNotifyWifiUnvalidated() {
    141         return configRestrictsAvoidBadWifi() && getAvoidBadWifiSetting() == null;
    142     }
    143 
    144     public String getAvoidBadWifiSetting() {
    145         return Settings.Global.getString(mResolver, NETWORK_AVOID_BAD_WIFI);
    146     }
    147 
    148     @VisibleForTesting
    149     public void reevaluate() {
    150         mHandler.post(mReevaluateRunnable);
    151     }
    152 
    153     public boolean updateAvoidBadWifi() {
    154         final boolean settingAvoidBadWifi = "1".equals(getAvoidBadWifiSetting());
    155         final boolean prev = mAvoidBadWifi;
    156         mAvoidBadWifi = settingAvoidBadWifi || !configRestrictsAvoidBadWifi();
    157         return mAvoidBadWifi != prev;
    158     }
    159 
    160     /**
    161      * The default (device and carrier-dependent) value for metered multipath preference.
    162      */
    163     public int configMeteredMultipathPreference() {
    164         return mContext.getResources().getInteger(
    165                 R.integer.config_networkMeteredMultipathPreference);
    166     }
    167 
    168     public void updateMeteredMultipathPreference() {
    169         String setting = Settings.Global.getString(mResolver, NETWORK_METERED_MULTIPATH_PREFERENCE);
    170         try {
    171             mMeteredMultipathPreference = Integer.parseInt(setting);
    172         } catch (NumberFormatException e) {
    173             mMeteredMultipathPreference = configMeteredMultipathPreference();
    174         }
    175     }
    176 
    177     private class SettingObserver extends ContentObserver {
    178         public SettingObserver() {
    179             super(null);
    180         }
    181 
    182         @Override
    183         public void onChange(boolean selfChange) {
    184             Slog.wtf(TAG, "Should never be reached.");
    185         }
    186 
    187         @Override
    188         public void onChange(boolean selfChange, Uri uri) {
    189             if (!mSettingsUris.contains(uri)) {
    190                 Slog.wtf(TAG, "Unexpected settings observation: " + uri);
    191             }
    192             reevaluate();
    193         }
    194     }
    195 }
    196