framework/src/android/net/ConnectivitySettingsManager.java

/*
 * Copyright (C) 2021 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 android.net;

import static android.net.ConnectivityManager.MULTIPATH_PREFERENCE_HANDOVER;
import static android.net.ConnectivityManager.MULTIPATH_PREFERENCE_PERFORMANCE;
import static android.net.ConnectivityManager.MULTIPATH_PREFERENCE_RELIABILITY;

import android.annotation.IntDef;
import android.annotation.IntRange;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.content.ContentResolver;
import android.content.Context;
import android.net.ConnectivityManager.MultipathPreference;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Range;

import com.android.net.module.util.ProxyUtils;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.time.Duration;
import java.util.List;
import java.util.Set;
import java.util.StringJoiner;
import java.util.regex.Pattern;

/**
 * A manager class for connectivity module settings.
 *
 * @hide
 */
@SystemApi(client = SystemApi.Client.MODULE_LIBRARIES)
public class ConnectivitySettingsManager {

    private ConnectivitySettingsManager() {}

    /** Data activity timeout settings */

    /**
     * Inactivity timeout to track mobile data activity.
     *
     * If set to a positive integer, it indicates the inactivity timeout value in seconds to
     * infer the data activity of mobile network. After a period of no activity on mobile
     * networks with length specified by the timeout, an {@code ACTION_DATA_ACTIVITY_CHANGE}
     * intent is fired to indicate a transition of network status from "active" to "idle". Any
     * subsequent activity on mobile networks triggers the firing of {@code
     * ACTION_DATA_ACTIVITY_CHANGE} intent indicating transition from "idle" to "active".
     *
     * Network activity refers to transmitting or receiving data on the network interfaces.
     *
     * Tracking is disabled if set to zero or negative value.
     *
     * @hide
     */
    public static final String DATA_ACTIVITY_TIMEOUT_MOBILE = "data_activity_timeout_mobile";

    /**
     * Timeout to tracking Wifi data activity. Same as {@code DATA_ACTIVITY_TIMEOUT_MOBILE}
     * but for Wifi network.
     *
     * @hide
     */
    public static final String DATA_ACTIVITY_TIMEOUT_WIFI = "data_activity_timeout_wifi";

    /** Dns resolver settings */

    /**
     * Sample validity in seconds to configure for the system DNS resolver.
     *
     * @hide
     */
    public static final String DNS_RESOLVER_SAMPLE_VALIDITY_SECONDS =
            "dns_resolver_sample_validity_seconds";

    /**
     * Success threshold in percent for use with the system DNS resolver.
     *
     * @hide
     */
    public static final String DNS_RESOLVER_SUCCESS_THRESHOLD_PERCENT =
            "dns_resolver_success_threshold_percent";

    /**
     * Minimum number of samples needed for statistics to be considered meaningful in the
     * system DNS resolver.
     *
     * @hide
     */
    public static final String DNS_RESOLVER_MIN_SAMPLES = "dns_resolver_min_samples";

    /**
     * Maximum number taken into account for statistics purposes in the system DNS resolver.
     *
     * @hide
     */
    public static final String DNS_RESOLVER_MAX_SAMPLES = "dns_resolver_max_samples";

    private static final int DNS_RESOLVER_DEFAULT_MIN_SAMPLES = 8;
    private static final int DNS_RESOLVER_DEFAULT_MAX_SAMPLES = 64;

    /** Network switch notification settings */

    /**
     * The maximum number of notifications shown in 24 hours when switching networks.
     *
     * @hide
     */
    public static final String NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT =
            "network_switch_notification_daily_limit";

    /**
     * The minimum time in milliseconds between notifications when switching networks.
     *
     * @hide
     */
    public static final String NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS =
            "network_switch_notification_rate_limit_millis";

    /** Captive portal settings */

    /**
     * The URL used for HTTP captive portal detection upon a new connection.
     * A 204 response code from the server is used for validation.
     *
     * @hide
     */
    public static final String CAPTIVE_PORTAL_HTTP_URL = "captive_portal_http_url";

    /**
     * What to do when connecting a network that presents a captive portal.
     * Must be one of the CAPTIVE_PORTAL_MODE_* constants below.
     *
     * The default for this setting is CAPTIVE_PORTAL_MODE_PROMPT.
     *
     * @hide
     */
    public static final String CAPTIVE_PORTAL_MODE = "captive_portal_mode";

    /**
     * Don't attempt to detect captive portals.
     */
    public static final int CAPTIVE_PORTAL_MODE_IGNORE = 0;

    /**
     * When detecting a captive portal, display a notification that
     * prompts the user to sign in.
     */
    public static final int CAPTIVE_PORTAL_MODE_PROMPT = 1;

    /**
     * When detecting a captive portal, immediately disconnect from the
     * network and do not reconnect to that network in the future.
     */
    public static final int CAPTIVE_PORTAL_MODE_AVOID = 2;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(value = {
            CAPTIVE_PORTAL_MODE_IGNORE,
            CAPTIVE_PORTAL_MODE_PROMPT,
            CAPTIVE_PORTAL_MODE_AVOID,
    })
    public @interface CaptivePortalMode {}

    /** Global http proxy settings */

    /**
     * Host name for global http proxy. Set via ConnectivityManager.
     *
     * @hide
     */
    public static final String GLOBAL_HTTP_PROXY_HOST = "global_http_proxy_host";

    /**
     * Integer host port for global http proxy. Set via ConnectivityManager.
     *
     * @hide
     */
    public static final String GLOBAL_HTTP_PROXY_PORT = "global_http_proxy_port";

    /**
     * Exclusion list for global proxy. This string contains a list of
     * comma-separated domains where the global proxy does not apply.
     * Domains should be listed in a comma- separated list. Example of
     * acceptable formats: ".domain1.com,my.domain2.com" Use
     * ConnectivityManager to set/get.
     *
     * @hide
     */
    public static final String GLOBAL_HTTP_PROXY_EXCLUSION_LIST =
            "global_http_proxy_exclusion_list";

    /**
     * The location PAC File for the proxy.
     *
     * @hide
     */
    public static final String GLOBAL_HTTP_PROXY_PAC = "global_proxy_pac_url";

    /** Private dns settings */

    /**
     * The requested Private DNS mode (string), and an accompanying specifier (string).
     *
     * Currently, the specifier holds the chosen provider name when the mode requests
     * a specific provider. It may be used to store the provider name even when the
     * mode changes so that temporarily disabling and re-enabling the specific
     * provider mode does not necessitate retyping the provider hostname.
     *
     * @hide
     */
    public static final String PRIVATE_DNS_MODE = "private_dns_mode";

    /**
     * The specific Private DNS provider name.
     *
     * @hide
     */
    public static final String PRIVATE_DNS_SPECIFIER = "private_dns_specifier";

    /**
     * Forced override of the default mode (hardcoded as "automatic", nee "opportunistic").
     * This allows changing the default mode without effectively disabling other modes,
     * all of which require explicit user action to enable/configure. See also b/79719289.
     *
     * Value is a string, suitable for assignment to PRIVATE_DNS_MODE above.
     *
     * @hide
     */
    public static final String PRIVATE_DNS_DEFAULT_MODE = "private_dns_default_mode";

    /** Other settings */

    /**
     * The number of milliseconds to hold on to a PendingIntent based request. This delay gives
     * the receivers of the PendingIntent an opportunity to make a new network request before
     * the Network satisfying the request is potentially removed.
     *
     * @hide
     */
    public static final String CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS =
            "connectivity_release_pending_intent_delay_ms";

    /**
     * Whether the mobile data connection should remain active even when higher
     * priority networks like WiFi are active, to help make network switching faster.
     *
     * See ConnectivityService for more info.
     *
     * (0 = disabled, 1 = enabled)
     *
     * @hide
     */
    public static final String MOBILE_DATA_ALWAYS_ON = "mobile_data_always_on";

    /**
     * Whether the wifi data connection should remain active even when higher
     * priority networks like Ethernet are active, to keep both networks.
     * In the case where higher priority networks are connected, wifi will be
     * unused unless an application explicitly requests to use it.
     *
     * See ConnectivityService for more info.
     *
     * (0 = disabled, 1 = enabled)
     *
     * @hide
     */
    public static final String WIFI_ALWAYS_REQUESTED = "wifi_always_requested";

    /**
     * Whether to automatically switch away from wifi networks that lose Internet access.
     * Only meaningful if config_networkAvoidBadWifi is set to 0, otherwise the system always
     * avoids such networks. Valid values are:
     *
     * 0: Don't avoid bad wifi, don't prompt the user. Get stuck on bad wifi like it's 2013.
     * null: Ask the user whether to switch away from bad wifi.
     * 1: Avoid bad wifi.
     *
     * @hide
     */
    public static final String NETWORK_AVOID_BAD_WIFI = "network_avoid_bad_wifi";

    /**
     * Don't avoid bad wifi, don't prompt the user. Get stuck on bad wifi like it's 2013.
     */
    public static final int NETWORK_AVOID_BAD_WIFI_IGNORE = 0;

    /**
     * Ask the user whether to switch away from bad wifi.
     */
    public static final int NETWORK_AVOID_BAD_WIFI_PROMPT = 1;

    /**
     * Avoid bad wifi.
     */
    public static final int NETWORK_AVOID_BAD_WIFI_AVOID = 2;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(value = {
            NETWORK_AVOID_BAD_WIFI_IGNORE,
            NETWORK_AVOID_BAD_WIFI_PROMPT,
            NETWORK_AVOID_BAD_WIFI_AVOID,
    })
    public @interface NetworkAvoidBadWifi {}

    /**
     * User setting for ConnectivityManager.getMeteredMultipathPreference(). This value may be
     * overridden by the system based on device or application state. If null, the value
     * specified by config_networkMeteredMultipathPreference is used.
     *
     * @hide
     */
    public static final String NETWORK_METERED_MULTIPATH_PREFERENCE =
            "network_metered_multipath_preference";

    /**
     * A list of apps that should go on cellular networks in preference even when higher-priority
     * networks are connected.
     *
     * @hide
     */
    public static final String MOBILE_DATA_PREFERRED_APPS = "mobile_data_preferred_apps";

    /**
     * One of the private DNS modes that indicates the private DNS mode is off.
     */
    public static final int PRIVATE_DNS_MODE_OFF = 1;

    /**
     * One of the private DNS modes that indicates the private DNS mode is automatic, which
     * will try to use the current DNS as private DNS.
     */
    public static final int PRIVATE_DNS_MODE_OPPORTUNISTIC = 2;

    /**
     * One of the private DNS modes that indicates the private DNS mode is strict and the
     * {@link #PRIVATE_DNS_SPECIFIER} is required, which will try to use the value of
     * {@link #PRIVATE_DNS_SPECIFIER} as private DNS.
     */
    public static final int PRIVATE_DNS_MODE_PROVIDER_HOSTNAME = 3;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(value = {
            PRIVATE_DNS_MODE_OFF,
            PRIVATE_DNS_MODE_OPPORTUNISTIC,
            PRIVATE_DNS_MODE_PROVIDER_HOSTNAME,
    })
    public @interface PrivateDnsMode {}

    private static final String PRIVATE_DNS_MODE_OFF_STRING = "off";
    private static final String PRIVATE_DNS_MODE_OPPORTUNISTIC_STRING = "opportunistic";
    private static final String PRIVATE_DNS_MODE_PROVIDER_HOSTNAME_STRING = "hostname";

    /**
     * A list of apps that should be granted netd system permission for using restricted networks.
     *
     * @hide
     */
    public static final String RESTRICTED_ALLOWED_APPS = "restricted_allowed_apps";

    /**
     * Get mobile data activity timeout from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default timeout if no setting value.
     * @return The {@link Duration} of timeout to track mobile data activity.
     */
    @NonNull
    public static Duration getMobileDataActivityTimeout(@NonNull Context context,
            @NonNull Duration def) {
        final int timeout = Settings.Global.getInt(
                context.getContentResolver(), DATA_ACTIVITY_TIMEOUT_MOBILE, (int) def.getSeconds());
        return Duration.ofSeconds(timeout);
    }

    /**
     * Set mobile data activity timeout to {@link Settings}.
     * Tracking is disabled if set to zero or negative value.
     *
     * Note: Only use the number of seconds in this duration, lower second(nanoseconds) will be
     * ignored.
     *
     * @param context The {@link Context} to set the setting.
     * @param timeout The mobile data activity timeout.
     */
    public static void setMobileDataActivityTimeout(@NonNull Context context,
            @NonNull Duration timeout) {
        Settings.Global.putInt(context.getContentResolver(), DATA_ACTIVITY_TIMEOUT_MOBILE,
                (int) timeout.getSeconds());
    }

    /**
     * Get wifi data activity timeout from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default timeout if no setting value.
     * @return The {@link Duration} of timeout to track wifi data activity.
     */
    @NonNull
    public static Duration getWifiDataActivityTimeout(@NonNull Context context,
            @NonNull Duration def) {
        final int timeout = Settings.Global.getInt(
                context.getContentResolver(), DATA_ACTIVITY_TIMEOUT_WIFI, (int) def.getSeconds());
        return Duration.ofSeconds(timeout);
    }

    /**
     * Set wifi data activity timeout to {@link Settings}.
     * Tracking is disabled if set to zero or negative value.
     *
     * Note: Only use the number of seconds in this duration, lower second(nanoseconds) will be
     * ignored.
     *
     * @param context The {@link Context} to set the setting.
     * @param timeout The wifi data activity timeout.
     */
    public static void setWifiDataActivityTimeout(@NonNull Context context,
            @NonNull Duration timeout) {
        Settings.Global.putInt(context.getContentResolver(), DATA_ACTIVITY_TIMEOUT_WIFI,
                (int) timeout.getSeconds());
    }

    /**
     * Get dns resolver sample validity duration from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default duration if no setting value.
     * @return The {@link Duration} of sample validity duration to configure for the system DNS
     *         resolver.
     */
    @NonNull
    public static Duration getDnsResolverSampleValidityDuration(@NonNull Context context,
            @NonNull Duration def) {
        final int duration = Settings.Global.getInt(context.getContentResolver(),
                DNS_RESOLVER_SAMPLE_VALIDITY_SECONDS, (int) def.getSeconds());
        return Duration.ofSeconds(duration);
    }

    /**
     * Set dns resolver sample validity duration to {@link Settings}. The duration must be a
     * positive number of seconds.
     *
     * @param context The {@link Context} to set the setting.
     * @param duration The sample validity duration.
     */
    public static void setDnsResolverSampleValidityDuration(@NonNull Context context,
            @NonNull Duration duration) {
        final int time = (int) duration.getSeconds();
        if (time <= 0) {
            throw new IllegalArgumentException("Invalid duration");
        }
        Settings.Global.putInt(
                context.getContentResolver(), DNS_RESOLVER_SAMPLE_VALIDITY_SECONDS, time);
    }

    /**
     * Get dns resolver success threshold percent from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default value if no setting value.
     * @return The success threshold in percent for use with the system DNS resolver.
     */
    public static int getDnsResolverSuccessThresholdPercent(@NonNull Context context, int def) {
        return Settings.Global.getInt(
                context.getContentResolver(), DNS_RESOLVER_SUCCESS_THRESHOLD_PERCENT, def);
    }

    /**
     * Set dns resolver success threshold percent to {@link Settings}. The threshold percent must
     * be 0~100.
     *
     * @param context The {@link Context} to set the setting.
     * @param percent The success threshold percent.
     */
    public static void setDnsResolverSuccessThresholdPercent(@NonNull Context context,
            @IntRange(from = 0, to = 100) int percent) {
        if (percent < 0 || percent > 100) {
            throw new IllegalArgumentException("Percent must be 0~100");
        }
        Settings.Global.putInt(
                context.getContentResolver(), DNS_RESOLVER_SUCCESS_THRESHOLD_PERCENT, percent);
    }

    /**
     * Get dns resolver samples range from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @return The {@link Range<Integer>} of samples needed for statistics to be considered
     *         meaningful in the system DNS resolver.
     */
    @NonNull
    public static Range<Integer> getDnsResolverSampleRanges(@NonNull Context context) {
        final int minSamples = Settings.Global.getInt(context.getContentResolver(),
                DNS_RESOLVER_MIN_SAMPLES, DNS_RESOLVER_DEFAULT_MIN_SAMPLES);
        final int maxSamples = Settings.Global.getInt(context.getContentResolver(),
                DNS_RESOLVER_MAX_SAMPLES, DNS_RESOLVER_DEFAULT_MAX_SAMPLES);
        return new Range<>(minSamples, maxSamples);
    }

    /**
     * Set dns resolver samples range to {@link Settings}.
     *
     * @param context The {@link Context} to set the setting.
     * @param range The samples range. The minimum number should be more than 0 and the maximum
     *              number should be less that 64.
     */
    public static void setDnsResolverSampleRanges(@NonNull Context context,
            @NonNull Range<Integer> range) {
        if (range.getLower() < 0 || range.getUpper() > 64) {
            throw new IllegalArgumentException("Argument must be 0~64");
        }
        Settings.Global.putInt(
                context.getContentResolver(), DNS_RESOLVER_MIN_SAMPLES, range.getLower());
        Settings.Global.putInt(
                context.getContentResolver(), DNS_RESOLVER_MAX_SAMPLES, range.getUpper());
    }

    /**
     * Get maximum count (from {@link Settings}) of switching network notifications shown in 24
     * hours.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default value if no setting value.
     * @return The maximum count of notifications shown in 24 hours when switching networks.
     */
    public static int getNetworkSwitchNotificationMaximumDailyCount(@NonNull Context context,
            int def) {
        return Settings.Global.getInt(
                context.getContentResolver(), NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT, def);
    }

    /**
     * Set maximum count (to {@link Settings}) of switching network notifications shown in 24 hours.
     * The count must be at least 0.
     *
     * @param context The {@link Context} to set the setting.
     * @param count The maximum count of switching network notifications shown in 24 hours.
     */
    public static void setNetworkSwitchNotificationMaximumDailyCount(@NonNull Context context,
            @IntRange(from = 0) int count) {
        if (count < 0) {
            throw new IllegalArgumentException("Count must be 0~10.");
        }
        Settings.Global.putInt(
                context.getContentResolver(), NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT, count);
    }

    /**
     * Get minimum duration (from {@link Settings}) between each switching network notifications.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default time if no setting value.
     * @return The minimum duration between notifications when switching networks.
     */
    @NonNull
    public static Duration getNetworkSwitchNotificationRateDuration(@NonNull Context context,
            @NonNull Duration def) {
        final int duration = Settings.Global.getInt(context.getContentResolver(),
                NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS, (int) def.toMillis());
        return Duration.ofMillis(duration);
    }

    /**
     * Set minimum duration (to {@link Settings}) between each switching network notifications.
     *
     * @param context The {@link Context} to set the setting.
     * @param duration The minimum duration between notifications when switching networks.
     */
    public static void setNetworkSwitchNotificationRateDuration(@NonNull Context context,
            @NonNull Duration duration) {
        final int time = (int) duration.toMillis();
        if (time < 0) {
            throw new IllegalArgumentException("Invalid duration.");
        }
        Settings.Global.putInt(context.getContentResolver(),
                NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS, time);
    }

    /**
     * Get URL (from {@link Settings}) used for HTTP captive portal detection upon a new connection.
     *
     * @param context The {@link Context} to query the setting.
     * @return The URL used for HTTP captive portal detection upon a new connection.
     */
    @Nullable
    public static String getCaptivePortalHttpUrl(@NonNull Context context) {
        return Settings.Global.getString(context.getContentResolver(), CAPTIVE_PORTAL_HTTP_URL);
    }

    /**
     * Set URL (to {@link Settings}) used for HTTP captive portal detection upon a new connection.
     * This URL should respond with a 204 response to a GET request to indicate no captive portal is
     * present. And this URL must be HTTP as redirect responses are used to find captive portal
     * sign-in pages. If the URL set to null or be incorrect, it will result in captive portal
     * detection failed and lost the connection.
     *
     * @param context The {@link Context} to set the setting.
     * @param url The URL used for HTTP captive portal detection upon a new connection.
     */
    public static void setCaptivePortalHttpUrl(@NonNull Context context, @Nullable String url) {
        Settings.Global.putString(context.getContentResolver(), CAPTIVE_PORTAL_HTTP_URL, url);
    }

    /**
     * Get mode (from {@link Settings}) when connecting a network that presents a captive portal.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default mode if no setting value.
     * @return The mode when connecting a network that presents a captive portal.
     */
    @CaptivePortalMode
    public static int getCaptivePortalMode(@NonNull Context context,
            @CaptivePortalMode int def) {
        return Settings.Global.getInt(context.getContentResolver(), CAPTIVE_PORTAL_MODE, def);
    }

    /**
     * Set mode (to {@link Settings}) when connecting a network that presents a captive portal.
     *
     * @param context The {@link Context} to set the setting.
     * @param mode The mode when connecting a network that presents a captive portal.
     */
    public static void setCaptivePortalMode(@NonNull Context context, @CaptivePortalMode int mode) {
        if (!(mode == CAPTIVE_PORTAL_MODE_IGNORE
                || mode == CAPTIVE_PORTAL_MODE_PROMPT
                || mode == CAPTIVE_PORTAL_MODE_AVOID)) {
            throw new IllegalArgumentException("Invalid captive portal mode");
        }
        Settings.Global.putInt(context.getContentResolver(), CAPTIVE_PORTAL_MODE, mode);
    }

    /**
     * Get the global HTTP proxy applied to the device, or null if none.
     *
     * @param context The {@link Context} to query the setting.
     * @return The {@link ProxyInfo} which build from global http proxy settings.
     */
    @Nullable
    public static ProxyInfo getGlobalProxy(@NonNull Context context) {
        final String host = Settings.Global.getString(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_HOST);
        final int port = Settings.Global.getInt(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_PORT, 0 /* def */);
        final String exclusionList = Settings.Global.getString(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_EXCLUSION_LIST);
        final String pacFileUrl = Settings.Global.getString(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_PAC);

        if (TextUtils.isEmpty(host) && TextUtils.isEmpty(pacFileUrl)) {
            return null; // No global proxy.
        }

        if (TextUtils.isEmpty(pacFileUrl)) {
            return ProxyInfo.buildDirectProxy(
                    host, port, ProxyUtils.exclusionStringAsList(exclusionList));
        } else {
            return ProxyInfo.buildPacProxy(Uri.parse(pacFileUrl));
        }
    }

    /**
     * Set global http proxy settings from given {@link ProxyInfo}.
     *
     * @param context The {@link Context} to set the setting.
     * @param proxyInfo The {@link ProxyInfo} for global http proxy settings which build from
     *                    {@link ProxyInfo#buildPacProxy(Uri)} or
     *                    {@link ProxyInfo#buildDirectProxy(String, int, List)}
     */
    public static void setGlobalProxy(@NonNull Context context, @NonNull ProxyInfo proxyInfo) {
        final String host = proxyInfo.getHost();
        final int port = proxyInfo.getPort();
        final String exclusionList = proxyInfo.getExclusionListAsString();
        final String pacFileUrl = proxyInfo.getPacFileUrl().toString();

        if (TextUtils.isEmpty(pacFileUrl)) {
            Settings.Global.putString(context.getContentResolver(), GLOBAL_HTTP_PROXY_HOST, host);
            Settings.Global.putInt(context.getContentResolver(), GLOBAL_HTTP_PROXY_PORT, port);
            Settings.Global.putString(
                    context.getContentResolver(), GLOBAL_HTTP_PROXY_EXCLUSION_LIST, exclusionList);
            Settings.Global.putString(
                    context.getContentResolver(), GLOBAL_HTTP_PROXY_PAC, "" /* value */);
        } else {
            Settings.Global.putString(
                    context.getContentResolver(), GLOBAL_HTTP_PROXY_PAC, pacFileUrl);
            Settings.Global.putString(
                    context.getContentResolver(), GLOBAL_HTTP_PROXY_HOST, "" /* value */);
            Settings.Global.putInt(
                    context.getContentResolver(), GLOBAL_HTTP_PROXY_PORT, 0 /* value */);
            Settings.Global.putString(
                    context.getContentResolver(), GLOBAL_HTTP_PROXY_EXCLUSION_LIST, "" /* value */);
        }
    }

    /**
     * Clear all global http proxy settings.
     *
     * @param context The {@link Context} to set the setting.
     */
    public static void clearGlobalProxy(@NonNull Context context) {
        Settings.Global.putString(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_HOST, "" /* value */);
        Settings.Global.putInt(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_PORT, 0 /* value */);
        Settings.Global.putString(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_EXCLUSION_LIST, "" /* value */);
        Settings.Global.putString(
                context.getContentResolver(), GLOBAL_HTTP_PROXY_PAC, "" /* value */);
    }

    private static String getPrivateDnsModeAsString(@PrivateDnsMode int mode) {
        switch (mode) {
            case PRIVATE_DNS_MODE_OFF:
                return PRIVATE_DNS_MODE_OFF_STRING;
            case PRIVATE_DNS_MODE_OPPORTUNISTIC:
                return PRIVATE_DNS_MODE_OPPORTUNISTIC_STRING;
            case PRIVATE_DNS_MODE_PROVIDER_HOSTNAME:
                return PRIVATE_DNS_MODE_PROVIDER_HOSTNAME_STRING;
            default:
                throw new IllegalArgumentException("Invalid private dns mode: " + mode);
        }
    }

    private static int getPrivateDnsModeAsInt(String mode) {
        switch (mode) {
            case "off":
                return PRIVATE_DNS_MODE_OFF;
            case "hostname":
                return PRIVATE_DNS_MODE_PROVIDER_HOSTNAME;
            case "opportunistic":
                return PRIVATE_DNS_MODE_OPPORTUNISTIC;
            default:
                throw new IllegalArgumentException("Invalid private dns mode: " + mode);
        }
    }

    /**
     * Get private DNS mode from settings.
     *
     * @param context The Context to query the private DNS mode from settings.
     * @return A string of private DNS mode.
     */
    @PrivateDnsMode
    public static int getPrivateDnsMode(@NonNull Context context) {
        final ContentResolver cr = context.getContentResolver();
        String mode = Settings.Global.getString(cr, PRIVATE_DNS_MODE);
        if (TextUtils.isEmpty(mode)) mode = Settings.Global.getString(cr, PRIVATE_DNS_DEFAULT_MODE);
        // If both PRIVATE_DNS_MODE and PRIVATE_DNS_DEFAULT_MODE are not set, choose
        // PRIVATE_DNS_MODE_OPPORTUNISTIC as default mode.
        if (TextUtils.isEmpty(mode)) return PRIVATE_DNS_MODE_OPPORTUNISTIC;
        return getPrivateDnsModeAsInt(mode);
    }

    /**
     * Set private DNS mode to settings.
     *
     * @param context The {@link Context} to set the private DNS mode.
     * @param mode The private dns mode. This should be one of the PRIVATE_DNS_MODE_* constants.
     */
    public static void setPrivateDnsMode(@NonNull Context context, @PrivateDnsMode int mode) {
        if (!(mode == PRIVATE_DNS_MODE_OFF
                || mode == PRIVATE_DNS_MODE_OPPORTUNISTIC
                || mode == PRIVATE_DNS_MODE_PROVIDER_HOSTNAME)) {
            throw new IllegalArgumentException("Invalid private dns mode: " + mode);
        }
        Settings.Global.putString(context.getContentResolver(), PRIVATE_DNS_MODE,
                getPrivateDnsModeAsString(mode));
    }

    /**
     * Get specific private dns provider name from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @return The specific private dns provider name, or null if no setting value.
     */
    @Nullable
    public static String getPrivateDnsHostname(@NonNull Context context) {
        return Settings.Global.getString(context.getContentResolver(), PRIVATE_DNS_SPECIFIER);
    }

    /**
     * Set specific private dns provider name to {@link Settings}.
     *
     * @param context The {@link Context} to set the setting.
     * @param specifier The specific private dns provider name.
     */
    public static void setPrivateDnsHostname(@NonNull Context context,
            @Nullable String specifier) {
        Settings.Global.putString(context.getContentResolver(), PRIVATE_DNS_SPECIFIER, specifier);
    }

    /**
     * Get default private dns mode from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @return The default private dns mode.
     */
    @PrivateDnsMode
    @NonNull
    public static String getPrivateDnsDefaultMode(@NonNull Context context) {
        return Settings.Global.getString(context.getContentResolver(), PRIVATE_DNS_DEFAULT_MODE);
    }

    /**
     * Set default private dns mode to {@link Settings}.
     *
     * @param context The {@link Context} to set the setting.
     * @param mode The default private dns mode. This should be one of the PRIVATE_DNS_MODE_*
     *             constants.
     */
    public static void setPrivateDnsDefaultMode(@NonNull Context context,
            @NonNull @PrivateDnsMode int mode) {
        if (!(mode == PRIVATE_DNS_MODE_OFF
                || mode == PRIVATE_DNS_MODE_OPPORTUNISTIC
                || mode == PRIVATE_DNS_MODE_PROVIDER_HOSTNAME)) {
            throw new IllegalArgumentException("Invalid private dns mode");
        }
        Settings.Global.putString(context.getContentResolver(), PRIVATE_DNS_DEFAULT_MODE,
                getPrivateDnsModeAsString(mode));
    }

    /**
     * Get duration (from {@link Settings}) to keep a PendingIntent-based request.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default duration if no setting value.
     * @return The duration to keep a PendingIntent-based request.
     */
    @NonNull
    public static Duration getConnectivityKeepPendingIntentDuration(@NonNull Context context,
            @NonNull Duration def) {
        final int duration = Settings.Secure.getInt(context.getContentResolver(),
                CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS, (int) def.toMillis());
        return Duration.ofMillis(duration);
    }

    /**
     * Set duration (to {@link Settings}) to keep a PendingIntent-based request.
     *
     * @param context The {@link Context} to set the setting.
     * @param duration The duration to keep a PendingIntent-based request.
     */
    public static void setConnectivityKeepPendingIntentDuration(@NonNull Context context,
            @NonNull Duration duration) {
        final int time = (int) duration.toMillis();
        if (time < 0) {
            throw new IllegalArgumentException("Invalid duration.");
        }
        Settings.Secure.putInt(
                context.getContentResolver(), CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS, time);
    }

    /**
     * Read from {@link Settings} whether the mobile data connection should remain active
     * even when higher priority networks are active.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default value if no setting value.
     * @return Whether the mobile data connection should remain active even when higher
     *         priority networks are active.
     */
    public static boolean getMobileDataAlwaysOn(@NonNull Context context, boolean def) {
        final int enable = Settings.Global.getInt(
                context.getContentResolver(), MOBILE_DATA_ALWAYS_ON, (def ? 1 : 0));
        return (enable != 0) ? true : false;
    }

    /**
     * Write into {@link Settings} whether the mobile data connection should remain active
     * even when higher priority networks are active.
     *
     * @param context The {@link Context} to set the setting.
     * @param enable Whether the mobile data connection should remain active even when higher
     *               priority networks are active.
     */
    public static void setMobileDataAlwaysOn(@NonNull Context context, boolean enable) {
        Settings.Global.putInt(
                context.getContentResolver(), MOBILE_DATA_ALWAYS_ON, (enable ? 1 : 0));
    }

    /**
     * Read from {@link Settings} whether the wifi data connection should remain active
     * even when higher priority networks are active.
     *
     * @param context The {@link Context} to query the setting.
     * @param def The default value if no setting value.
     * @return Whether the wifi data connection should remain active even when higher
     *         priority networks are active.
     */
    public static boolean getWifiAlwaysRequested(@NonNull Context context, boolean def) {
        final int enable = Settings.Global.getInt(
                context.getContentResolver(), WIFI_ALWAYS_REQUESTED, (def ? 1 : 0));
        return (enable != 0) ? true : false;
    }

    /**
     * Write into {@link Settings} whether the wifi data connection should remain active
     * even when higher priority networks are active.
     *
     * @param context The {@link Context} to set the setting.
     * @param enable Whether the wifi data connection should remain active even when higher
     *               priority networks are active
     */
    public static void setWifiAlwaysRequested(@NonNull Context context, boolean enable) {
        Settings.Global.putInt(
                context.getContentResolver(), WIFI_ALWAYS_REQUESTED, (enable ? 1 : 0));
    }

    /**
     * Get avoid bad wifi setting from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @return The setting whether to automatically switch away from wifi networks that lose
     *         internet access.
     */
    @NetworkAvoidBadWifi
    public static int getNetworkAvoidBadWifi(@NonNull Context context) {
        final String setting =
                Settings.Global.getString(context.getContentResolver(), NETWORK_AVOID_BAD_WIFI);
        if ("0".equals(setting)) {
            return NETWORK_AVOID_BAD_WIFI_IGNORE;
        } else if ("1".equals(setting)) {
            return NETWORK_AVOID_BAD_WIFI_AVOID;
        } else {
            return NETWORK_AVOID_BAD_WIFI_PROMPT;
        }
    }

    /**
     * Set avoid bad wifi setting to {@link Settings}.
     *
     * @param context The {@link Context} to set the setting.
     * @param value Whether to automatically switch away from wifi networks that lose internet
     *              access.
     */
    public static void setNetworkAvoidBadWifi(@NonNull Context context,
            @NetworkAvoidBadWifi int value) {
        final String setting;
        if (value == NETWORK_AVOID_BAD_WIFI_IGNORE) {
            setting = "0";
        } else if (value == NETWORK_AVOID_BAD_WIFI_AVOID) {
            setting = "1";
        } else if (value == NETWORK_AVOID_BAD_WIFI_PROMPT) {
            setting = null;
        } else {
            throw new IllegalArgumentException("Invalid avoid bad wifi setting");
        }
        Settings.Global.putString(context.getContentResolver(), NETWORK_AVOID_BAD_WIFI, setting);
    }

    /**
     * Get network metered multipath preference from {@link Settings}.
     *
     * @param context The {@link Context} to query the setting.
     * @return The network metered multipath preference which should be one of
     *         ConnectivityManager#MULTIPATH_PREFERENCE_* value or null if the value specified
     *         by config_networkMeteredMultipathPreference is used.
     */
    @Nullable
    public static String getNetworkMeteredMultipathPreference(@NonNull Context context) {
        return Settings.Global.getString(
                context.getContentResolver(), NETWORK_METERED_MULTIPATH_PREFERENCE);
    }

    /**
     * Set network metered multipath preference to {@link Settings}.
     *
     * @param context The {@link Context} to set the setting.
     * @param preference The network metered multipath preference which should be one of
     *                   ConnectivityManager#MULTIPATH_PREFERENCE_* value or null if the value
     *                   specified by config_networkMeteredMultipathPreference is used.
     */
    public static void setNetworkMeteredMultipathPreference(@NonNull Context context,
            @NonNull @MultipathPreference String preference) {
        if (!(Integer.valueOf(preference) == MULTIPATH_PREFERENCE_HANDOVER
                || Integer.valueOf(preference) == MULTIPATH_PREFERENCE_RELIABILITY
                || Integer.valueOf(preference) == MULTIPATH_PREFERENCE_PERFORMANCE)) {
            throw new IllegalArgumentException("Invalid private dns mode");
        }
        Settings.Global.putString(
                context.getContentResolver(), NETWORK_METERED_MULTIPATH_PREFERENCE, preference);
    }

    /**
     * Get the list of apps(from {@link Settings}) that should go on cellular networks in preference
     * even when higher-priority networks are connected.
     *
     * @param context The {@link Context} to query the setting.
     * @return A list of apps that should go on cellular networks in preference even when
     *         higher-priority networks are connected or null if no setting value.
     */
    @Nullable
    public static String getMobileDataPreferredApps(@NonNull Context context) {
        return Settings.Secure.getString(context.getContentResolver(), MOBILE_DATA_PREFERRED_APPS);
    }

    /**
     * Set the list of apps(to {@link Settings}) that should go on cellular networks in preference
     * even when higher-priority networks are connected.
     *
     * @param context The {@link Context} to set the setting.
     * @param list A list of apps that should go on cellular networks in preference even when
     *             higher-priority networks are connected.
     */
    public static void setMobileDataPreferredApps(@NonNull Context context, @Nullable String list) {
        Settings.Secure.putString(context.getContentResolver(), MOBILE_DATA_PREFERRED_APPS, list);
    }

    /**
     * Get the list of apps(from {@link Settings}) that should be granted netd system permission for
     * using restricted networks.
     *
     * @param context The {@link Context} to query the setting.
     * @return A list of apps that should be granted netd system permission for using restricted
     *         networks or null if no setting value.
     */
    @NonNull
    public static Set<String> getRestrictedAllowedApps(@NonNull Context context) {
        final String appList = Settings.Secure.getString(
                context.getContentResolver(), RESTRICTED_ALLOWED_APPS);
        if (TextUtils.isEmpty(appList)) {
            return new ArraySet<>();
        }
        return new ArraySet<>(appList.split(";"));
    }

    /**
     * Set the list of apps(from {@link Settings}) that should be granted netd system permission for
     * using restricted networks.
     *
     * Note: Please refer to android developer guidelines for valid app(package name).
     * https://developer.android.com/guide/topics/manifest/manifest-element.html#package
     *
     * @param context The {@link Context} to set the setting.
     * @param list A list of apps that should be granted netd system permission for using
     *             restricted networks.
     */
    public static void setRestrictedAllowedApps(@NonNull Context context,
            @NonNull Set<String> list) {
        final Pattern appPattern = Pattern.compile("[a-zA-Z_0-9]+([.][a-zA-Z_0-9]+)*");
        final StringJoiner joiner = new StringJoiner(";");
        for (String app : list) {
            if (!appPattern.matcher(app).matches()) {
                throw new IllegalArgumentException("Invalid app(package name)");
            }
            joiner.add(app);
        }
        Settings.Secure.putString(
                context.getContentResolver(), RESTRICTED_ALLOWED_APPS, joiner.toString());
    }
}