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.service.resolver;
  
  import android.annotation.SdkConstant;
  import android.annotation.SystemApi;
  import android.app.Service;
  import android.content.ComponentName;
  import android.content.Intent;
  import android.os.IBinder;
  import android.os.Handler;
  import android.os.HandlerThread;
  import android.os.RemoteException;
  import android.service.resolver.ResolverTarget;
  import android.util.Log;
  
  import java.util.List;
  import java.util.Map;
  
  /**
   * A service to rank apps according to usage stats of apps, when the system is resolving targets for
   * an Intent.
   *
   * <p>To extend this class, you must declare the service in your manifest file with the
   * {@link android.Manifest.permission#BIND_RESOLVER_RANKER_SERVICE} permission, and include an
   * intent filter with the {@link #SERVICE_INTERFACE} action. For example:</p>
   * <pre>
   *     &lt;service android:name=".MyResolverRankerService"
   *             android:exported="true"
   *             android:priority="100"
   *             android:permission="android.permission.BIND_RESOLVER_RANKER_SERVICE"&gt;
   *         &lt;intent-filter&gt;
   *             &lt;action android:name="android.service.resolver.ResolverRankerService" /&gt;
   *         &lt;/intent-filter&gt;
   *     &lt;/service&gt;
   * </pre>
   * @hide
   */
  @SystemApi
  public abstract class ResolverRankerService extends Service {
  
      private static final String TAG = "ResolverRankerService";
  
      private static final boolean DEBUG = false;
  
      /**
       * The Intent action that a service must respond to. Add it to the intent filter of the service
       * in its manifest.
       */
      @SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION)
      public static final String SERVICE_INTERFACE = "android.service.resolver.ResolverRankerService";
  
      /**
       * The permission that a service must hold. If the service does not hold the permission, the
       * system will skip that service.
       */
      public static final String HOLD_PERMISSION = "android.permission.PROVIDE_RESOLVER_RANKER_SERVICE";
  
      /**
       * The permission that a service must require to ensure that only Android system can bind to it.
       * If this permission is not enforced in the AndroidManifest of the service, the system will
       * skip that service.
       */
      public static final String BIND_PERMISSION = "android.permission.BIND_RESOLVER_RANKER_SERVICE";
  
      private ResolverRankerServiceWrapper mWrapper = null;
  
      /**
       * Called by the system to retrieve a list of probabilities to rank apps/options. To implement
       * it, set selectProbability of each input {@link ResolverTarget}. The higher the
       * selectProbability is, the more likely the {@link ResolverTarget} will be selected by the
       * user. Override this function to provide prediction results.
       *
       * @param targets a list of {@link ResolverTarget}, for the list of apps to be ranked.
       *
       * @throws Exception when the prediction task fails.
       */
      public void onPredictSharingProbabilities(final List<ResolverTarget> targets) {}
  
      /**
       * Called by the system to train/update a ranking service, after the user makes a selection from
       * the ranked list of apps. Override this function to enable model updates.
       *
       * @param targets a list of {@link ResolverTarget}, for the list of apps to be ranked.
       * @param selectedPosition the position of the selected app in the list.
       *
       * @throws Exception when the training task fails.
       */
      public void onTrainRankingModel(
              final List<ResolverTarget> targets, final int selectedPosition) {}
  
      private static final String HANDLER_THREAD_NAME = "RESOLVER_RANKER_SERVICE";
      private volatile Handler mHandler;
      private HandlerThread mHandlerThread;
  
      @Override
      public IBinder onBind(Intent intent) {
          if (DEBUG) Log.d(TAG, "onBind " + intent);
          if (!SERVICE_INTERFACE.equals(intent.getAction())) {
              if (DEBUG) Log.d(TAG, "bad intent action " + intent.getAction() + "; returning null");
              return null;
          }
          if (mHandlerThread == null) {
              mHandlerThread = new HandlerThread(HANDLER_THREAD_NAME);
              mHandlerThread.start();
              mHandler = new Handler(mHandlerThread.getLooper());
          }
          if (mWrapper == null) {
              mWrapper = new ResolverRankerServiceWrapper();
          }
          return mWrapper;
      }
  
      @Override
      public void onDestroy() {
          mHandler = null;
          if (mHandlerThread != null) {
              mHandlerThread.quitSafely();
          }
          super.onDestroy();
      }
  
      private static void sendResult(List<ResolverTarget> targets, IResolverRankerResult result) {
          try {
              result.sendResult(targets);
          } catch (Exception e) {
              Log.e(TAG, "failed to send results: " + e);
          }
      }
  
      private class ResolverRankerServiceWrapper extends IResolverRankerService.Stub {
  
          @Override
          public void predict(final List<ResolverTarget> targets, final IResolverRankerResult result)
                  throws RemoteException {
              Runnable predictRunnable = new Runnable() {
                  @Override
                  public void run() {
                      try {
                          if (DEBUG) {
                              Log.d(TAG, "predict calls onPredictSharingProbabilities.");
                          }
                          onPredictSharingProbabilities(targets);
                          sendResult(targets, result);
                      } catch (Exception e) {
                          Log.e(TAG, "onPredictSharingProbabilities failed; send null results: " + e);
                          sendResult(null, result);
                      }
                  }
              };
              final Handler h = mHandler;
              if (h != null) {
                  h.post(predictRunnable);
              }
          }
  
          @Override
          public void train(final List<ResolverTarget> targets, final int selectedPosition)
                  throws RemoteException {
              Runnable trainRunnable = new Runnable() {
                  @Override
                  public void run() {
                      try {
                          if (DEBUG) {
                              Log.d(TAG, "train calls onTranRankingModel");
                          }
                          onTrainRankingModel(targets, selectedPosition);
                      } catch (Exception e) {
                          Log.e(TAG, "onTrainRankingModel failed; skip train: " + e);
                      }
                  }
              };
              final Handler h = mHandler;
              if (h != null) {
                  h.post(trainRunnable);
              }
          }
      }
  }
  