content: /*
   * Copyright (C) 2017 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.companion;
  
  
  import static com.android.internal.util.Preconditions.checkNotNull;
  
  import android.annotation.NonNull;
  import android.annotation.Nullable;
  import android.annotation.SystemService;
  import android.app.Activity;
  import android.app.Application;
  import android.app.PendingIntent;
  import android.content.ComponentName;
  import android.content.Context;
  import android.content.IntentSender;
  import android.content.pm.PackageManager;
  import android.os.Bundle;
  import android.os.Handler;
  import android.os.RemoteException;
  import android.service.notification.NotificationListenerService;
  import android.util.Log;
  
  import java.util.Collections;
  import java.util.List;
  import java.util.function.BiConsumer;
  
  /**
   * System level service for managing companion devices
   *
   * <p>To obtain an instance call {@link Context#getSystemService}({@link
   * Context#COMPANION_DEVICE_SERVICE}) Then, call {@link #associate(AssociationRequest,
   * Callback, Handler)} to initiate the flow of associating current package with a
   * device selected by user.</p>
   *
   * @see AssociationRequest
   */
  @SystemService(Context.COMPANION_DEVICE_SERVICE)
  public final class CompanionDeviceManager {
  
      private static final boolean DEBUG = false;
      private static final String LOG_TAG = "CompanionDeviceManager";
  
      /**
       * A device, returned in the activity result of the {@link IntentSender} received in
       * {@link Callback#onDeviceFound}
       */
      public static final String EXTRA_DEVICE = "android.companion.extra.DEVICE";
  
      /**
       * The package name of the companion device discovery component.
       *
       * @hide
       */
      public static final String COMPANION_DEVICE_DISCOVERY_PACKAGE_NAME =
              "com.android.companiondevicemanager";
  
      /**
       * A callback to receive once at least one suitable device is found, or the search failed
       * (e.g. timed out)
       */
      public abstract static class Callback {
  
          /**
           * Called once at least one suitable device is found
           *
           * @param chooserLauncher a {@link IntentSender} to launch the UI for user to select a
           *                        device
           */
          public abstract void onDeviceFound(IntentSender chooserLauncher);
  
          /**
           * Called if there was an error looking for device(s)
           *
           * @param error the cause of the error
           */
          public abstract void onFailure(CharSequence error);
      }
  
      private final ICompanionDeviceManager mService;
      private final Context mContext;
  
      /** @hide */
      public CompanionDeviceManager(
              @Nullable ICompanionDeviceManager service, @NonNull Context context) {
          mService = service;
          mContext = context;
      }
  
      /**
       * Associate this app with a companion device, selected by user
       *
       * <p>Once at least one appropriate device is found, {@code callback} will be called with a
       * {@link PendingIntent} that can be used to show the list of available devices for the user
       * to select.
       * It should be started for result (i.e. using
       * {@link android.app.Activity#startIntentSenderForResult}), as the resulting
       * {@link android.content.Intent} will contain extra {@link #EXTRA_DEVICE}, with the selected
       * device. (e.g. {@link android.bluetooth.BluetoothDevice})</p>
       *
       * <p>If your app needs to be excluded from battery optimizations (run in the background)
       * or to have unrestricted data access (use data in the background) you can declare that
       * you use the {@link android.Manifest.permission#REQUEST_COMPANION_RUN_IN_BACKGROUND} and {@link
       * android.Manifest.permission#REQUEST_COMPANION_USE_DATA_IN_BACKGROUND} respectively. Note that these
       * special capabilities have a negative effect on the device's battery and user's data
       * usage, therefore you should requested them when absolutely necessary.</p>
       *
       * <p>You can call {@link #getAssociations} to get the list of currently associated
       * devices, and {@link #disassociate} to remove an association. Consider doing so when the
       * association is no longer relevant to avoid unnecessary battery and/or data drain resulting
       * from special privileges that the association provides</p>
       *
       * <p>Calling this API requires a uses-feature
       * {@link PackageManager#FEATURE_COMPANION_DEVICE_SETUP} declaration in the manifest</p>
       *
       * @param request specific details about this request
       * @param callback will be called once there's at least one device found for user to choose from
       * @param handler A handler to control which thread the callback will be delivered on, or null,
       *                to deliver it on main thread
       *
       * @see AssociationRequest
       */
      public void associate(
              @NonNull AssociationRequest request,
              @NonNull Callback callback,
              @Nullable Handler handler) {
          if (!checkFeaturePresent()) {
              return;
          }
          checkNotNull(request, "Request cannot be null");
          checkNotNull(callback, "Callback cannot be null");
          try {
              mService.associate(
                      request,
                      new CallbackProxy(request, callback, Handler.mainIfNull(handler)),
                      getCallingPackage());
          } catch (RemoteException e) {
              throw e.rethrowFromSystemServer();
          }
      }
  
      /**
       * <p>Calling this API requires a uses-feature
       * {@link PackageManager#FEATURE_COMPANION_DEVICE_SETUP} declaration in the manifest</p>
       *
       * @return a list of MAC addresses of devices that have been previously associated with the
       * current app. You can use these with {@link #disassociate}
       */
      @NonNull
      public List<String> getAssociations() {
          if (!checkFeaturePresent()) {
              return Collections.emptyList();
          }
          try {
              return mService.getAssociations(getCallingPackage(), mContext.getUserId());
          } catch (RemoteException e) {
              throw e.rethrowFromSystemServer();
          }
      }
  
      /**
       * Remove the association between this app and the device with the given mac address.
       *
       * <p>Any privileges provided via being associated with a given device will be revoked</p>
       *
       * <p>Consider doing so when the
       * association is no longer relevant to avoid unnecessary battery and/or data drain resulting
       * from special privileges that the association provides</p>
       *
       * <p>Calling this API requires a uses-feature
       * {@link PackageManager#FEATURE_COMPANION_DEVICE_SETUP} declaration in the manifest</p>
       *
       * @param deviceMacAddress the MAC address of device to disassociate from this app
       */
      public void disassociate(@NonNull String deviceMacAddress) {
          if (!checkFeaturePresent()) {
              return;
          }
          try {
              mService.disassociate(deviceMacAddress, getCallingPackage());
          } catch (RemoteException e) {
              throw e.rethrowFromSystemServer();
          }
      }
  
      /**
       * Request notification access for the given component.
       *
       * The given component must follow the protocol specified in {@link NotificationListenerService}
       *
       * Only components from the same {@link ComponentName#getPackageName package} as the calling app
       * are allowed.
       *
       * Your app must have an association with a device before calling this API
       *
       * <p>Calling this API requires a uses-feature
       * {@link PackageManager#FEATURE_COMPANION_DEVICE_SETUP} declaration in the manifest</p>
       */
      public void requestNotificationAccess(ComponentName component) {
          if (!checkFeaturePresent()) {
              return;
          }
          try {
              IntentSender intentSender = mService.requestNotificationAccess(component)
                      .getIntentSender();
              mContext.startIntentSender(intentSender, null, 0, 0, 0);
          } catch (RemoteException e) {
              throw e.rethrowFromSystemServer();
          } catch (IntentSender.SendIntentException e) {
              throw new RuntimeException(e);
          }
      }
  
      /**
       * Check whether the given component can access the notifications via a
       * {@link NotificationListenerService}
       *
       * Your app must have an association with a device before calling this API
       *
       * <p>Calling this API requires a uses-feature
       * {@link PackageManager#FEATURE_COMPANION_DEVICE_SETUP} declaration in the manifest</p>
       *
       * @param component the name of the component
       * @return whether the given component has the notification listener permission
       */
      public boolean hasNotificationAccess(ComponentName component) {
          if (!checkFeaturePresent()) {
              return false;
          }
          try {
              return mService.hasNotificationAccess(component);
          } catch (RemoteException e) {
              throw e.rethrowFromSystemServer();
          }
      }
  
      private boolean checkFeaturePresent() {
          boolean featurePresent = mService != null;
          if (!featurePresent && DEBUG) {
              Log.d(LOG_TAG, "Feature " + PackageManager.FEATURE_COMPANION_DEVICE_SETUP
                      + " not available");
          }
          return featurePresent;
      }
  
      private Activity getActivity() {
          return (Activity) mContext;
      }
  
      private String getCallingPackage() {
          return mContext.getPackageName();
      }
  
      private class CallbackProxy extends IFindDeviceCallback.Stub
              implements Application.ActivityLifecycleCallbacks {
  
          private Callback mCallback;
          private Handler mHandler;
          private AssociationRequest mRequest;
  
          final Object mLock = new Object();
  
          private CallbackProxy(AssociationRequest request, Callback callback, Handler handler) {
              mCallback = callback;
              mHandler = handler;
              mRequest = request;
              getActivity().getApplication().registerActivityLifecycleCallbacks(this);
          }
  
          @Override
          public void onSuccess(PendingIntent launcher) {
              lockAndPost(Callback::onDeviceFound, launcher.getIntentSender());
          }
  
          @Override
          public void onFailure(CharSequence reason) {
              lockAndPost(Callback::onFailure, reason);
          }
  
          <T> void lockAndPost(BiConsumer<Callback, T> action, T payload) {
              synchronized (mLock) {
                  if (mHandler != null) {
                      mHandler.post(() -> {
                          Callback callback = null;
                          synchronized (mLock) {
                              callback = mCallback;
                          }
                          if (callback != null) {
                              action.accept(callback, payload);
                          }
                      });
                  }
              }
          }
  
          @Override
          public void onActivityDestroyed(Activity activity) {
              synchronized (mLock) {
                  if (activity != getActivity()) return;
                  try {
                      mService.stopScan(mRequest, this, getCallingPackage());
                  } catch (RemoteException e) {
                      e.rethrowFromSystemServer();
                  }
                  getActivity().getApplication().unregisterActivityLifecycleCallbacks(this);
                  mCallback = null;
                  mHandler = null;
                  mRequest = null;
              }
          }
  
          @Override public void onActivityCreated(Activity activity, Bundle savedInstanceState) {}
          @Override public void onActivityStarted(Activity activity) {}
          @Override public void onActivityResumed(Activity activity) {}
          @Override public void onActivityPaused(Activity activity) {}
          @Override public void onActivityStopped(Activity activity) {}
          @Override public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}
      }
  }
  