android-12.0.0_r2/s

// Copyright 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 com.google.android.downloader;

import static android.Manifest.permission.ACCESS_NETWORK_STATE;
import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
import static androidx.core.content.ContextCompat.checkSelfPermission;
import static androidx.core.content.ContextCompat.getSystemService;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
import static java.util.concurrent.TimeUnit.MILLISECONDS;

import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import androidx.annotation.RequiresPermission;
import androidx.core.net.ConnectivityManagerCompat;
import com.google.android.downloader.DownloadConstraints.NetworkType;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.flogger.GoogleLogger;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListenableFutureTask;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeoutException;
import javax.annotation.Nullable;

/**
 * Default implementation of {@link ConnectivityHandler}, relying on Android's {@link
 * ConnectivityManager}.
 */
public class AndroidConnectivityHandler implements ConnectivityHandler {
  private static final GoogleLogger logger = GoogleLogger.forEnclosingClass();

  private final Context context;
  private final ScheduledExecutorService scheduledExecutorService;
  private final ConnectivityManager connectivityManager;
  private final long timeoutMillis;

  /**
   * Creates a new AndroidConnectivityHandler to handle connectivity checks for the Downloader.
   *
   * @param context the context to use for perform Android API checks. Will be retained, so should
   *     not be a UI context.
   * @param scheduledExecutorService a scheduled executor used to timeout operations waiting for
   *     connectivity. Beware that there are problems with this, see go/executors-timing for
   *     details.
   * @param timeoutMillis how long to wait before timing out a connectivity check. If more than this
   *     amount of time elapses, the connectivity check will timeout, and the {@link
   *     ListenableFuture} returned by {@link #checkConnectivity} will resolve with a {@link
   *     TimeoutException}.
   */
  public AndroidConnectivityHandler(
      Context context, ScheduledExecutorService scheduledExecutorService, long timeoutMillis) {
    if (PackageManager.PERMISSION_GRANTED != checkSelfPermission(context, ACCESS_NETWORK_STATE)) {
      throw new IllegalStateException(
          "AndroidConnectivityHandler requires the ACCESS_NETWORK_STATE permission.");
    }

    this.context = context;
    this.scheduledExecutorService = scheduledExecutorService;
    this.connectivityManager = checkNotNull(getSystemService(context, ConnectivityManager.class));
    this.timeoutMillis = timeoutMillis;
  }

  @Override
  @RequiresPermission(ACCESS_NETWORK_STATE)
  public ListenableFuture<Void> checkConnectivity(DownloadConstraints constraints) {
    if (connectivitySatisfied(constraints)) {
      return Futures.immediateVoidFuture();
    }

    ListenableFutureTask<Void> futureTask = ListenableFutureTask.create(() -> null);
    // TODO: Using a receiver here isn't great. Ideally we'd use
    // ConnectivityManager.requestNetwork(request, callback, timeout), but that's only available
    // on SDK 26+, so we'd still need a fallback on older versions of Android.
    NetworkBroadcastReceiver receiver = new NetworkBroadcastReceiver(constraints, futureTask);
    context.registerReceiver(receiver, new IntentFilter(CONNECTIVITY_ACTION));
    futureTask.addListener(() -> context.unregisterReceiver(receiver), directExecutor());
    return Futures.withTimeout(futureTask, timeoutMillis, MILLISECONDS, scheduledExecutorService);
  }

  @RequiresPermission(ACCESS_NETWORK_STATE)
  private boolean connectivitySatisfied(DownloadConstraints downloadConstraints) {
    // Special case the NONE value - if that is specified then skip all further checks.
    if (downloadConstraints == DownloadConstraints.NONE) {
      return true;
    }

    NetworkType networkType;

    if (VERSION.SDK_INT >= VERSION_CODES.M) {
      Network network = connectivityManager.getActiveNetwork();
      if (network == null) {
        logger.atFine().log("No current network, connectivity cannot be satisfied.");
        return false;
      }

      NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(network);
      if (networkCapabilities == null) {
        logger.atFine().log(
            "Can't determine network capabilities, connectivity cannot be satisfied");
        return false;
      }

      if (!networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
        logger.atFine().log(
            "Network does not have internet capabilities, connectivity cannot be satisfied.");
        return false;
      }

      if (downloadConstraints.requireUnmeteredNetwork()
          && ConnectivityManagerCompat.isActiveNetworkMetered(connectivityManager)) {
        logger.atFine().log("Network is metered, connectivity cannot be satisfied.");
        return false;
      }

      if (downloadConstraints.requiredNetworkTypes().contains(NetworkType.ANY)) {
        // If the request doesn't care about the network type (by way of having NetworkType.ANY in
        // its set of allowed network types), then stop checking now.
        return true;
      }

      networkType = computeNetworkType(networkCapabilities);
    } else {
      @SuppressLint("MissingPermission") // We just checked the permission above.
      NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
      if (networkInfo == null) {
        logger.atFine().log("No current network, connectivity cannot be satisfied.");
        return false;
      }

      if (!networkInfo.isConnected()) {
        // Regardless of which type of network we have right now, if it's not connected then all
        // downloads will fail, so just queue up all downloads in this case.
        logger.atFine().log("Network disconnected, connectivity cannot be satisfied.");
        return false;
      }

      if (downloadConstraints.requireUnmeteredNetwork()
          && ConnectivityManagerCompat.isActiveNetworkMetered(connectivityManager)) {
        logger.atFine().log("Network is metered, connectivity cannot be satisfied.");
        return false;
      }

      if (downloadConstraints.requiredNetworkTypes().contains(NetworkType.ANY)) {
        // If the request doesn't care about the network type (by way of having NetworkType.ANY in
        // its set of allowed network types), then stop checking now.
        return true;
      }

      networkType = computeNetworkType(networkInfo.getType());
    }

    if (networkType == null) {
      // If for some reason we couldn't determine the network type from Android (unexpected value?),
      // then we can't validate it against the set of constraints, so fail the check.
      return false;
    }

    // Otherwise, just make sure that the current network type is allowed by this request.
    return downloadConstraints.requiredNetworkTypes().contains(networkType);
  }

  @Nullable
  private static NetworkType computeNetworkType(int networkType) {
    if (VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB_MR2
        && networkType == ConnectivityManager.TYPE_BLUETOOTH) {
      return NetworkType.BLUETOOTH;
    } else if (VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB_MR2
        && networkType == ConnectivityManager.TYPE_ETHERNET) {
      return NetworkType.ETHERNET;
    } else if (networkType == ConnectivityManager.TYPE_MOBILE
        || networkType == ConnectivityManager.TYPE_MOBILE_MMS
        || networkType == ConnectivityManager.TYPE_MOBILE_SUPL
        || networkType == ConnectivityManager.TYPE_MOBILE_DUN
        || networkType == ConnectivityManager.TYPE_MOBILE_HIPRI) {
      return NetworkType.CELLULAR;
    } else if (VERSION.SDK_INT >= VERSION_CODES.LOLLIPOP
        && networkType == ConnectivityManager.TYPE_VPN) {
      // There's no way to determine the underlying transport used by a VPN, so it's best to
      // be conservative and treat it is a cellular network.
      return NetworkType.CELLULAR;
    } else if (networkType == ConnectivityManager.TYPE_WIFI) {
      return NetworkType.WIFI;
    } else if (networkType == ConnectivityManager.TYPE_WIMAX) {
      // WiMAX and Cellular aren't really the same thing, but in practice they can be treated
      // the same, as they are both typically available over long distances and are often metered.
      return NetworkType.CELLULAR;
    }

    return null;
  }

  @Nullable
  @TargetApi(VERSION_CODES.LOLLIPOP)
  private static NetworkType computeNetworkType(NetworkCapabilities networkCapabilities) {
    if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
      return NetworkType.CELLULAR;
    } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
      return NetworkType.WIFI;
    } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH)) {
      return NetworkType.BLUETOOTH;
    } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET)) {
      return NetworkType.ETHERNET;
    } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN)) {
      // There's no way to determine the underlying transport used by a VPN, so it's best to
      // be conservative and treat it is a cellular network.
      return NetworkType.CELLULAR;
    }
    return null;
  }

  @VisibleForTesting
  class NetworkBroadcastReceiver extends BroadcastReceiver {
    private final DownloadConstraints constraints;
    private final Runnable completionRunnable;

    public NetworkBroadcastReceiver(DownloadConstraints constraints, Runnable completionRunnable) {
      this.constraints = constraints;
      this.completionRunnable = completionRunnable;
    }

    @Override
    @RequiresPermission(ACCESS_NETWORK_STATE)
    public void onReceive(Context context, Intent intent) {
      if (!CONNECTIVITY_ACTION.equals(intent.getAction())) {
        logger.atSevere().log(
            "NetworkBroadcastReceiver received an unexpected intent action: %s",
            intent.getAction());
        return;
      }

      if (intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false)) {
        logger.atInfo().log("NetworkBroadcastReceiver updated but NO_CONNECTIVITY extra set");
        return;
      }

      logger.atInfo().log(
          "NetworkBroadcastReceiver received intent: %s %s",
          intent.getAction(), intent.getExtras());

      if (connectivitySatisfied(constraints)) {
        logger.atInfo().log("Connectivity satisfied in BroadcastReceiver, running completion");
        completionRunnable.run();
      } else {
        logger.atInfo().log("Connectivity NOT satisfied in BroadcastReceiver");
      }
    }
  }
}