Android: fixed internal review points

Author: Sangamesh1997

binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java

@@ -17,13 +17,15 @@
 package io.grpc.binder;
 
 import static android.content.Intent.URI_ANDROID_APP_SCHEME;
+import static android.content.Intent.URI_INTENT_SCHEME;
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkState;
 
 import android.annotation.SuppressLint;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
+import android.os.Build;
 import android.os.UserHandle;
 import com.google.common.base.Objects;
 import io.grpc.ExperimentalApi;
@@ -166,15 +168,17 @@ public Intent asBindIntent() {
    *
    * <p>See {@link Intent#URI_ANDROID_APP_SCHEME} for details.
    */
-  @SuppressLint("InlinedApi")
   public String asAndroidAppUri() {
     Intent intentForUri = bindIntent;
     if (intentForUri.getPackage() == null) {
       // URI_ANDROID_APP_SCHEME requires an "explicit package name" which isn't set by any of our
       // factory methods. Oddly, a ComponentName is not enough.
       intentForUri = intentForUri.cloneFilter().setPackage(getComponent().getPackageName());
     }
-    return intentForUri.toUri(URI_ANDROID_APP_SCHEME);
+    return intentForUri.toUri(
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1
+            ? URI_ANDROID_APP_SCHEME
+            : URI_INTENT_SCHEME);
   }
 
   @Override

binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java

@@ -23,15 +23,22 @@
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
 import android.os.Build;
 import android.os.IBinder;
 import android.os.UserHandle;
 import androidx.annotation.AnyThread;
 import androidx.annotation.MainThread;
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.VerifyException;
 import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Status;
+import io.grpc.StatusException;
 import io.grpc.binder.BinderChannelCredentials;
+import java.lang.reflect.Method;
+import java.util.List;
 import java.util.concurrent.Executor;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -86,6 +93,8 @@ public String methodName() {
   private final Observer observer;
   private final Executor mainThreadExecutor;
 
+  private static volatile Method queryIntentServicesAsUserMethod;
+
   @GuardedBy("this")
   private State state;
 
@@ -252,6 +261,71 @@ void unbindInternal(Status reason) {
     }
   }
 
+  // Sadly the PackageManager#resolveServiceAsUser() API we need isn't part of the SDK or even a
+  // @SystemApi as of this writing. Modern Android prevents even system apps from calling it, by any
+  // means (https://developer.android.com/guide/app-compatibility/restrictions-non-sdk-interfaces).
+  // So instead we call queryIntentServicesAsUser(), which does more than we need but *is* a
+  // @SystemApi in all the SDK versions where we support cross-user Channels.
+  @Nullable
+  private static ResolveInfo resolveServiceAsUser(
+          PackageManager packageManager, Intent intent, int flags, UserHandle targetUserHandle) {
+    List<ResolveInfo> results =
+            queryIntentServicesAsUser(packageManager, intent, flags, targetUserHandle);
+    // The first query result is "what would be returned by resolveService", per the javadoc.
+    return (results != null && !results.isEmpty()) ? results.get(0) : null;
+  }
+
+  // The cross-user Channel feature requires the client to be a system app so we assume @SystemApi
+  // queryIntentServicesAsUser() is visible to us at runtime. It would be visible at build time too,
+  // if our host system app were written to call it directly. We only have to use reflection here
+  // because grpc-java is a library built outside the Android source tree where the compiler can't
+  // see the "non-SDK" @SystemApis that we need.
+  @Nullable
+  @SuppressWarnings("unchecked") // Safe by PackageManager#queryIntentServicesAsUser spec in AOSP.
+  private static List<ResolveInfo> queryIntentServicesAsUser(
+          PackageManager packageManager, Intent intent, int flags, UserHandle targetUserHandle) {
+    try {
+      if (queryIntentServicesAsUserMethod == null) {
+        synchronized (ServiceBinding.class) {
+          if (queryIntentServicesAsUserMethod == null) {
+            queryIntentServicesAsUserMethod =
+                    PackageManager.class.getMethod(
+                            "queryIntentServicesAsUser", Intent.class, int.class, UserHandle.class);
+          }
+        }
+      }
+      return (List<ResolveInfo>)
+              queryIntentServicesAsUserMethod.invoke(packageManager, intent, flags, targetUserHandle);
+    } catch (ReflectiveOperationException e) {
+      throw new VerifyException(e);
+    }
+  }
+
+  @AnyThread
+  @Override
+  public ServiceInfo resolve() throws StatusException {
+    checkState(sourceContext != null);
+    PackageManager packageManager = sourceContext.getPackageManager();
+    int flags = 0;
+    if (Build.VERSION.SDK_INT >= 29) {
+      // Filter out non-'directBootAware' <service>s when 'targetUserHandle' is locked. Here's why:
+      // Callers want 'bindIntent' to #resolve() to the same thing a follow-up call to #bind() will.
+      // But bindService() *always* ignores services that can't presently be created for lack of
+      // 'directBootAware'-ness. This flag explicitly tells resolveService() to act the same way.
+      flags |= PackageManager.MATCH_DIRECT_BOOT_AUTO;
+    }
+    ResolveInfo resolveInfo =
+            targetUserHandle != null
+                    ? resolveServiceAsUser(packageManager, bindIntent, flags, targetUserHandle)
+                    : packageManager.resolveService(bindIntent, flags);
+    if (resolveInfo == null) {
+      throw Status.UNIMPLEMENTED // Same status code as when bindService() returns false.
+              .withDescription("resolveService(" + bindIntent + " / " + targetUserHandle + ") was null")
+              .asException();
+    }
+    return resolveInfo.serviceInfo;
+  }
+
   @MainThread
   private void clearReferences() {
     sourceContext = null;