android: add AndroidChannelBuilder

Author: ericgribkoff

android/build.gradle

@@ -0,0 +1,41 @@
+apply plugin: 'com.android.library'
+
+description = 'gRPC: Android'
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+        mavenCentral()
+    }
+    dependencies {
+        // TODO(ericgribkoff) Update this. Newer versions cause Gradle errors if build grpc-android
+        // as a subproject.
+        classpath 'com.android.tools.build:gradle:2.3.0'
+    }
+}
+
+android {
+    buildToolsVersion "25.0.2"
+    compileSdkVersion 27
+    defaultConfig {
+        minSdkVersion 14
+        targetSdkVersion 27
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+dependencies {
+    compile 'io.grpc:grpc-core:1.11.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    compile 'io.grpc:grpc-okhttp:1.11.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+}

android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.grpc.android" />

android/src/main/java/io/grpc/android/AndroidChannelBuilder.java

@@ -0,0 +1,212 @@
+package io.grpc.android;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkInfo;
+import android.os.Build;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ConnectivityState;
+import io.grpc.ForwardingChannelBuilder;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.MethodDescriptor;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.okhttp.OkHttpChannelBuilder;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Builds a {@link ManagedChannel} that automatically monitors the Android device's network state.
+ * Network changes are used to update the connectivity state of the underlying OkHttp-backed
+ * {@ManagedChannel} to smoothly handle intermittent network failures.
+ *
+ * <p>gRPC Cronet users should use {@code CronetChannelBuilder} directly, as Cronet itself monitors
+ * the device network state.
+ *
+ * <p>Requires the Android ACCESS_NETWORK_STATE permission.
+ */
+public final class AndroidChannelBuilder extends ForwardingChannelBuilder<AndroidChannelBuilder> {
+
+  private final ManagedChannelBuilder delegateBuilder;
+  private final Context context;
+
+  /** Always fails. Call {@link #forAddress(String, int, Context)} instead. */
+  public static AndroidChannelBuilder forTarget(String target) {
+    throw new UnsupportedOperationException("call forTarget(String, Context) instead");
+  }
+
+  /** Always fails. Call {@link #forAddress(String, int, Context)} instead. */
+  public static AndroidChannelBuilder forAddress(String name, int port) {
+    throw new UnsupportedOperationException("call forAddress(String, int, Context) instead");
+  }
+
+  /** Creates a new builder for the given target and Android context. */
+  public static final AndroidChannelBuilder forTarget(String target, Context context) {
+    return new AndroidChannelBuilder(target, context);
+  }
+
+  /** Creates a new builder for the given host, port, and Android context. */
+  public static AndroidChannelBuilder forAddress(String name, int port, Context context) {
+    return forTarget(GrpcUtil.authorityFromHostAndPort(name, port), context);
+  }
+
+  private AndroidChannelBuilder(String target, Context context) {
+    delegateBuilder = OkHttpChannelBuilder.forTarget(target);
+    this.context = context;
+  }
+
+  @Override
+  protected ManagedChannelBuilder<?> delegate() {
+    return delegateBuilder;
+  }
+
+  @Override
+  public ManagedChannel build() {
+    return new AndroidChannel(delegateBuilder.build(), context);
+  }
+
+  /**
+   * Wraps an OkHttp channel and handles invoking the appropriate methods (e.g., {@link
+   * ManagedChannel#resetConnectBackoff}) when the device network state changes.
+   */
+  private static final class AndroidChannel extends ManagedChannel {
+
+    private final ManagedChannel delegate;
+    private final Context context;
+    private final NetworkReceiver networkReceiver;
+    private final IntentFilter networkIntentFilter;
+    private final ConnectivityManager connectivityManager;
+    private DefaultNetworkCallback defaultNetworkCallback;
+
+    private AndroidChannel(final ManagedChannel delegate, Context context) {
+      this.delegate = delegate;
+      this.context = context;
+      networkReceiver = new NetworkReceiver();
+      networkIntentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
+      connectivityManager =
+          (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+      // Android N added the registerDefaultNetworkCallback API to listen to changes in the device's
+      // default network. For earlier Android API levels, use the BroadcastReceiver API.
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        defaultNetworkCallback =
+            new DefaultNetworkCallback(connectivityManager.getActiveNetworkInfo());
+        connectivityManager.registerDefaultNetworkCallback(defaultNetworkCallback);
+      } else {
+        context.registerReceiver(networkReceiver, networkIntentFilter);
+      }
+    }
+
+    @Override
+    public ManagedChannel shutdown() {
+      unregisterNetworkListener();
+      return delegate.shutdown();
+    }
+
+    @Override
+    public boolean isShutdown() {
+      return delegate.isShutdown();
+    }
+
+    @Override
+    public boolean isTerminated() {
+      return delegate.isTerminated();
+    }
+
+    @Override
+    public ManagedChannel shutdownNow() {
+      unregisterNetworkListener();
+      return delegate.shutdownNow();
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+      return delegate.awaitTermination(timeout, unit);
+    }
+
+    @Override
+    public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+        MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+      return delegate.newCall(methodDescriptor, callOptions);
+    }
+
+    @Override
+    public String authority() {
+      return delegate.authority();
+    }
+
+    @Override
+    public ConnectivityState getState(boolean requestConnection) {
+      return delegate.getState(requestConnection);
+    }
+
+    @Override
+    public void notifyWhenStateChanged(ConnectivityState source, Runnable callback) {
+      delegate.notifyWhenStateChanged(source, callback);
+    }
+
+    @Override
+    public void resetConnectBackoff() {
+      delegate.resetConnectBackoff();
+    }
+
+    @Override
+    public void prepareToLoseNetwork() {
+      delegate.prepareToLoseNetwork();
+    }
+
+    private void unregisterNetworkListener() {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        connectivityManager.unregisterNetworkCallback(defaultNetworkCallback);
+      } else {
+        context.unregisterReceiver(networkReceiver);
+      }
+    }
+
+    /** Respond to changes in the default network. Only used on API levels 24+. */
+    private class DefaultNetworkCallback extends ConnectivityManager.NetworkCallback {
+
+      private boolean isConnected;
+
+      DefaultNetworkCallback(NetworkInfo currentNetwork) {
+        isConnected = currentNetwork != null && currentNetwork.isConnected();
+      }
+
+      @Override
+      public void onAvailable(Network network) {
+        if (isConnected) {
+          delegate.prepareToLoseNetwork();
+        } else {
+          delegate.resetConnectBackoff();
+        }
+        isConnected = true;
+      }
+
+      @Override
+      public void onLost(Network network) {
+        isConnected = false;
+      }
+    }
+
+    /** Respond to network changes. Only used on API levels < 24. */
+    private class NetworkReceiver extends BroadcastReceiver {
+      private boolean isConnected = true;
+
+      @Override
+      public void onReceive(Context context, Intent intent) {
+        ConnectivityManager conn =
+            (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        NetworkInfo networkInfo = conn.getActiveNetworkInfo();
+        boolean connected = networkInfo != null && networkInfo.isConnected();
+        if (connected && !isConnected) {
+          delegate.resetConnectBackoff();
+        }
+        isConnected = connected;
+      }
+    }
+  }
+}