Add more preference controllers to network page.

- To support Mobile plan preference controller, extended
  LifecycleObserver pattern to also observe onCreate and onSaveInstance.

Bug: 31799836
Test: RunSettingsRoboTests
Change-Id: Ie98db7efa91f0a8b4c8a06a784d3351237e59fe0

src/com/android/settings/network/MobileNetworkPreferenceController.java

@@ -46,9 +46,9 @@ public class MobileNetworkPreferenceController extends PreferenceController {
 
     @Override
     protected boolean isAvailable() {
-        return mIsSecondaryUser
-                || Utils.isWifiOnly(mContext)
-                || hasBaseUserRestriction(mContext, DISALLOW_CONFIG_MOBILE_NETWORKS, myUserId());
+        return !mIsSecondaryUser
+                && !Utils.isWifiOnly(mContext)
+                && !hasBaseUserRestriction(mContext, DISALLOW_CONFIG_MOBILE_NETWORKS, myUserId());
     }
 
     @Override

src/com/android/settings/network/MobilePlanPreferenceController.java

@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.settings.network;
+
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.UserManager;
+import android.support.v7.preference.Preference;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.android.internal.telephony.TelephonyIntents;
+import com.android.settings.R;
+import com.android.settings.Utils;
+import com.android.settings.core.PreferenceController;
+import com.android.settings.core.lifecycle.LifecycleObserver;
+import com.android.settings.core.lifecycle.events.OnCreate;
+import com.android.settings.core.lifecycle.events.OnSaveInstanceState;
+
+import java.util.List;
+
+import static android.content.Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT;
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+import static android.os.UserHandle.myUserId;
+import static android.os.UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS;
+import static com.android.settingslib.RestrictedLockUtils.hasBaseUserRestriction;
+
+
+public class MobilePlanPreferenceController extends PreferenceController implements
+        LifecycleObserver, OnCreate, OnSaveInstanceState {
+
+    public interface MobilePlanPreferenceHost {
+        void showMobilePlanMessageDialog();
+    }
+
+    public static final int MANAGE_MOBILE_PLAN_DIALOG_ID = 1;
+
+    private static final String TAG = "MobilePlanPrefContr";
+    private static final String KEY_MANAGE_MOBILE_PLAN = "manage_mobile_plan";
+    private static final String SAVED_MANAGE_MOBILE_PLAN_MSG = "mManageMobilePlanMessage";
+
+    private final UserManager mUserManager;
+    private final boolean mIsSecondaryUser;
+    private final MobilePlanPreferenceHost mHost;
+
+    private ConnectivityManager mCm;
+    private TelephonyManager mTm;
+
+    private String mMobilePlanDialogMessage;
+
+    public MobilePlanPreferenceController(Context context,
+            MobilePlanPreferenceHost host) {
+        super(context);
+        mHost = host;
+        mCm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        mTm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
+        mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
+        mIsSecondaryUser = !mUserManager.isAdminUser();
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        if (mHost != null && KEY_MANAGE_MOBILE_PLAN.equals(preference.getKey())) {
+            mMobilePlanDialogMessage = null;
+            onManageMobilePlanClick();
+        }
+        return false;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        if (savedInstanceState != null) {
+            mMobilePlanDialogMessage = savedInstanceState.getString(SAVED_MANAGE_MOBILE_PLAN_MSG);
+        }
+        Log.d(TAG, "onCreate: mMobilePlanDialogMessage=" + mMobilePlanDialogMessage);
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        if (!TextUtils.isEmpty(mMobilePlanDialogMessage)) {
+            outState.putString(SAVED_MANAGE_MOBILE_PLAN_MSG, mMobilePlanDialogMessage);
+        }
+    }
+
+    public String getMobilePlanDialogMessage() {
+        return mMobilePlanDialogMessage;
+    }
+
+    public void setMobilePlanDialogMessage(String messasge) {
+        mMobilePlanDialogMessage = messasge;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+        final boolean isPrefAllowedOnDevice = mContext.getResources().getBoolean(
+                com.android.settings.R.bool.config_show_mobile_plan);
+        final boolean isPrefAllowedForUser = !mIsSecondaryUser
+                && !Utils.isWifiOnly(mContext)
+                && !hasBaseUserRestriction(mContext, DISALLOW_CONFIG_MOBILE_NETWORKS, myUserId());
+        return isPrefAllowedForUser && isPrefAllowedOnDevice;
+    }
+    @Override
+    protected String getPreferenceKey() {
+        return KEY_MANAGE_MOBILE_PLAN;
+    }
+
+    private void onManageMobilePlanClick() {
+        Resources resources = mContext.getResources();
+        NetworkInfo ni = mCm.getActiveNetworkInfo();
+        if (mTm.hasIccCard() && (ni != null)) {
+            // Check for carrier apps that can handle provisioning first
+            Intent provisioningIntent = new Intent(TelephonyIntents.ACTION_CARRIER_SETUP);
+            List<String> carrierPackages =
+                    mTm.getCarrierPackageNamesForIntent(provisioningIntent);
+            if (carrierPackages != null && !carrierPackages.isEmpty()) {
+                if (carrierPackages.size() != 1) {
+                    Log.w(TAG, "Multiple matching carrier apps found, launching the first.");
+                }
+                provisioningIntent.setPackage(carrierPackages.get(0));
+                mContext.startActivity(provisioningIntent);
+                return;
+            }
+
+            // Get provisioning URL
+            String url = mCm.getMobileProvisioningUrl();
+            if (!TextUtils.isEmpty(url)) {
+                Intent intent = Intent.makeMainSelectorActivity(Intent.ACTION_MAIN,
+                        Intent.CATEGORY_APP_BROWSER);
+                intent.setData(Uri.parse(url));
+                intent.setFlags(FLAG_ACTIVITY_BROUGHT_TO_FRONT | FLAG_ACTIVITY_NEW_TASK);
+                try {
+                    mContext.startActivity(intent);
+                } catch (ActivityNotFoundException e) {
+                    Log.w(TAG, "onManageMobilePlanClick: startActivity failed" + e);
+                }
+            } else {
+                // No provisioning URL
+                String operatorName = mTm.getSimOperatorName();
+                if (TextUtils.isEmpty(operatorName)) {
+                    // Use NetworkOperatorName as second choice in case there is no
+                    // SPN (Service Provider Name on the SIM). Such as with T-mobile.
+                    operatorName = mTm.getNetworkOperatorName();
+                    if (TextUtils.isEmpty(operatorName)) {
+                        mMobilePlanDialogMessage =
+                                resources.getString(R.string.mobile_unknown_sim_operator);
+                    } else {
+                        mMobilePlanDialogMessage = resources.getString(
+                                R.string.mobile_no_provisioning_url, operatorName);
+                    }
+                } else {
+                    mMobilePlanDialogMessage =
+                            resources.getString(R.string.mobile_no_provisioning_url, operatorName);
+                }
+            }
+        } else if (mTm.hasIccCard() == false) {
+            // No sim card
+            mMobilePlanDialogMessage = resources.getString(R.string.mobile_insert_sim_card);
+        } else {
+            // NetworkInfo is null, there is no connection
+            mMobilePlanDialogMessage = resources.getString(R.string.mobile_connect_to_internet);
+        }
+        if (!TextUtils.isEmpty(mMobilePlanDialogMessage)) {
+            Log.d(TAG, "onManageMobilePlanClick: message=" + mMobilePlanDialogMessage);
+            if (mHost != null) {
+                mHost.showMobilePlanMessageDialog();
+            } else {
+                Log.d(TAG, "Missing host fragment, cannot show message dialog.");
+            }
+        }
+    }
+}

src/com/android/settings/network/NetworkDashboardFragment.java

@@ -15,8 +15,12 @@
  */
 package com.android.settings.network;
 
+import android.app.AlertDialog;
+import android.app.Dialog;
 import android.content.Context;
+import android.util.Log;
 
+import com.android.internal.logging.MetricsProto;
 import com.android.settings.R;
 import com.android.settings.core.PreferenceController;
 import com.android.settings.dashboard.DashboardFragment;
@@ -25,7 +29,11 @@ import com.android.settingslib.drawer.CategoryKey;
 import java.util.ArrayList;
 import java.util.List;
 
-public class NetworkDashboardFragment extends DashboardFragment {
+import static com.android.settings.network.MobilePlanPreferenceController
+        .MANAGE_MOBILE_PLAN_DIALOG_ID;
+
+public class NetworkDashboardFragment extends DashboardFragment implements
+        MobilePlanPreferenceController.MobilePlanPreferenceHost {
 
     private static final String TAG = "NetworkDashboardFrag";
 
@@ -53,13 +61,50 @@ public class NetworkDashboardFragment extends DashboardFragment {
     protected List<PreferenceController> getPreferenceControllers(Context context) {
         final AirplaneModePreferenceController airplaneModePreferenceController =
                 new AirplaneModePreferenceController(context, this /* fragment */);
+        final MobilePlanPreferenceController mobilePlanPreferenceController =
+                new MobilePlanPreferenceController(context, this);
         getLifecycle().addObserver(airplaneModePreferenceController);
+        getLifecycle().addObserver(mobilePlanPreferenceController);
 
         final List<PreferenceController> controllers = new ArrayList<>();
         controllers.add(airplaneModePreferenceController);
-        controllers.add(new TetherPreferenceController(context));
         controllers.add(new MobileNetworkPreferenceController(context));
+        controllers.add(new TetherPreferenceController(context));
         controllers.add(new VpnPreferenceController(context));
+        controllers.add(new WifiCallingPreferenceController(context));
+        controllers.add(new NetworkResetPreferenceController(context));
+        controllers.add(new ProxyPreferenceController(context));
+        controllers.add(mobilePlanPreferenceController);
         return controllers;
     }
+
+    @Override
+    public void showMobilePlanMessageDialog() {
+        showDialog(MANAGE_MOBILE_PLAN_DIALOG_ID);
+    }
+
+    @Override
+    public Dialog onCreateDialog(int dialogId) {
+        Log.d(TAG, "onCreateDialog: dialogId=" + dialogId);
+        switch (dialogId) {
+            case MANAGE_MOBILE_PLAN_DIALOG_ID:
+                final MobilePlanPreferenceController controller =
+                        getPreferenceController(MobilePlanPreferenceController.class);
+                return new AlertDialog.Builder(getActivity())
+                        .setMessage(controller.getMobilePlanDialogMessage())
+                        .setCancelable(false)
+                        .setPositiveButton(com.android.internal.R.string.ok,
+                                (dialog, id) -> controller.setMobilePlanDialogMessage(null))
+                        .create();
+        }
+        return super.onCreateDialog(dialogId);
+    }
+
+    @Override
+    public int getDialogMetricsCategory(int dialogId) {
+        if (MANAGE_MOBILE_PLAN_DIALOG_ID == dialogId) {
+            return MetricsProto.MetricsEvent.DIALOG_MANAGE_MOBILE_PLAN;
+        }
+        return 0;
+    }
 }

src/com/android/settings/network/NetworkResetPreferenceController.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.settings.network;
+
+import android.content.Context;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.core.PreferenceController;
+import com.android.settingslib.RestrictedLockUtils;
+
+public class NetworkResetPreferenceController extends PreferenceController {
+
+    private static final String KEY_NETWORK_RESET = "network_reset";
+
+    public NetworkResetPreferenceController(Context context) {
+        super(context);
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        return false;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+        return !RestrictedLockUtils.hasBaseUserRestriction(mContext,
+                UserManager.DISALLOW_NETWORK_RESET, UserHandle.myUserId());
+    }
+
+    @Override
+    protected String getPreferenceKey() {
+        return KEY_NETWORK_RESET;
+    }
+}

src/com/android/settings/network/ProxyPreferenceController.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.settings.network;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.core.PreferenceController;
+
+public class ProxyPreferenceController extends PreferenceController {
+
+    private static final String KEY_PROXY_SETTINGS = "proxy_settings";
+
+    public ProxyPreferenceController(Context context) {
+        super(context);
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        return false;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+        // proxy UI disabled until we have better app support
+        return false;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        // Enable Proxy selector settings if allowed.
+        final Preference pref = screen.findPreference(KEY_PROXY_SETTINGS);
+        if (pref != null) {
+            final DevicePolicyManager dpm = (DevicePolicyManager)
+                    mContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
+            pref.setEnabled(dpm.getGlobalProxyAdmin() == null);
+        }
+    }
+
+    @Override
+    protected String getPreferenceKey() {
+        return KEY_PROXY_SETTINGS;
+    }
+}

src/com/android/settings/network/WifiCallingPreferenceController.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.settings.network;
+
+import android.content.Context;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+import android.telephony.TelephonyManager;
+
+import com.android.ims.ImsManager;
+import com.android.settings.WifiCallingSettings;
+import com.android.settings.core.PreferenceController;
+
+public class WifiCallingPreferenceController extends PreferenceController {
+
+    private static final String KEY_WFC_SETTINGS = "wifi_calling_settings";
+    private TelephonyManager mTm;
+
+    public WifiCallingPreferenceController(Context context) {
+        super(context);
+        mTm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        return false;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        final Preference pref = screen.findPreference(KEY_WFC_SETTINGS);
+        if (pref != null) {
+            pref.setSummary(WifiCallingSettings.getWfcModeSummary(
+                    mContext, ImsManager.getWfcMode(mContext, mTm.isNetworkRoaming())));
+        }
+    }
+
+    @Override
+    protected boolean isAvailable() {
+        return ImsManager.isWfcEnabledByPlatform(mContext)
+                && ImsManager.isWfcProvisionedOnDevice(mContext);
+    }
+
+    @Override
+    protected String getPreferenceKey() {
+        return KEY_WFC_SETTINGS;
+    }
+}