android-35/android/service/smartspace/SmartspaceService.java - platform/prebuilts/fullsdk/sources - Git at Google

 /*
  * Copyright (C) 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 android.service.smartspace;

 import static com.android.internal.util.function.pooled.PooledLambda.obtainMessage;

 import android.annotation.CallSuper;
 import android.annotation.MainThread;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.SystemApi;
 import android.app.Service;
 import android.app.smartspace.ISmartspaceCallback;
 import android.app.smartspace.SmartspaceConfig;
 import android.app.smartspace.SmartspaceSessionId;
 import android.app.smartspace.SmartspaceTarget;
 import android.app.smartspace.SmartspaceTargetEvent;
 import android.content.Intent;
 import android.content.pm.ParceledListSlice;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Looper;
 import android.os.RemoteException;
 import android.service.smartspace.ISmartspaceService.Stub;
 import android.util.ArrayMap;
 import android.util.Log;
 import android.util.Slog;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;

 /**
  * A service used to share the lifecycle of smartspace UI (open, close, interaction)
  * and also to return smartspace result on a query.
  *
  * @hide
  */
 @SystemApi
 public abstract class SmartspaceService extends Service {

     /**
      * The {@link Intent} that must be declared as handled by the service.
      *
      * <p>The service must also require the {@link android.permission#MANAGE_SMARTSPACE}
      * permission.
      *
      * @hide
      */
     public static final String SERVICE_INTERFACE =
             "android.service.smartspace.SmartspaceService";
     private static final boolean DEBUG = false;
     private static final String TAG = "SmartspaceService";
     private final ArrayMap<SmartspaceSessionId, ArrayList<CallbackWrapper>> mSessionCallbacks =
             new ArrayMap<>();
     private Handler mHandler;

     private final android.service.smartspace.ISmartspaceService mInterface = new Stub() {

         @Override
         public void onCreateSmartspaceSession(SmartspaceConfig smartspaceConfig,
                 SmartspaceSessionId sessionId) {
             mHandler.sendMessage(
                     obtainMessage(SmartspaceService::doCreateSmartspaceSession,
                             SmartspaceService.this, smartspaceConfig, sessionId));
         }

         @Override
         public void notifySmartspaceEvent(SmartspaceSessionId sessionId,
                 SmartspaceTargetEvent event) {
             mHandler.sendMessage(
                     obtainMessage(SmartspaceService::notifySmartspaceEvent,
                             SmartspaceService.this, sessionId, event));
         }

         @Override
         public void requestSmartspaceUpdate(SmartspaceSessionId sessionId) {
             mHandler.sendMessage(
                     obtainMessage(SmartspaceService::doRequestPredictionUpdate,
                             SmartspaceService.this, sessionId));
         }

         @Override
         public void registerSmartspaceUpdates(SmartspaceSessionId sessionId,
                 ISmartspaceCallback callback) {
             mHandler.sendMessage(
                     obtainMessage(SmartspaceService::doRegisterSmartspaceUpdates,
                             SmartspaceService.this, sessionId, callback));
         }

         @Override
         public void unregisterSmartspaceUpdates(SmartspaceSessionId sessionId,
                 ISmartspaceCallback callback) {
             mHandler.sendMessage(
                     obtainMessage(SmartspaceService::doUnregisterSmartspaceUpdates,
                             SmartspaceService.this, sessionId, callback));
         }

         @Override
         public void onDestroySmartspaceSession(SmartspaceSessionId sessionId) {

             mHandler.sendMessage(
                     obtainMessage(SmartspaceService::doDestroy,
                             SmartspaceService.this, sessionId));
         }
     };

     @CallSuper
     @Override
     public void onCreate() {
         super.onCreate();
         if (DEBUG) {
             Log.d(TAG, "onCreate mSessionCallbacks: " + mSessionCallbacks);
         }
         mHandler = new Handler(Looper.getMainLooper(), null, true);
     }

     @Override
     @NonNull
     public final IBinder onBind(@NonNull Intent intent) {
         if (DEBUG) {
             Log.d(TAG, "onBind mSessionCallbacks: " + mSessionCallbacks);
         }
         if (SERVICE_INTERFACE.equals(intent.getAction())) {
             return mInterface.asBinder();
         }
         Slog.w(TAG, "Tried to bind to wrong intent (should be "
                 + SERVICE_INTERFACE + ": " + intent);
         return null;
     }

     private void doCreateSmartspaceSession(@NonNull SmartspaceConfig config,
             @NonNull SmartspaceSessionId sessionId) {
         if (DEBUG) {
             Log.d(TAG, "doCreateSmartspaceSession mSessionCallbacks: " + mSessionCallbacks);
         }
         mSessionCallbacks.put(sessionId, new ArrayList<>());
         onCreateSmartspaceSession(config, sessionId);
     }

     /**
      * Gets called when the client calls <code> SmartspaceManager#createSmartspaceSession </code>.
      */
     public abstract void onCreateSmartspaceSession(@NonNull SmartspaceConfig config,
             @NonNull SmartspaceSessionId sessionId);

     /**
      * Gets called when the client calls <code> SmartspaceSession#notifySmartspaceEvent </code>.
      */
     @MainThread
     public abstract void notifySmartspaceEvent(@NonNull SmartspaceSessionId sessionId,
             @NonNull SmartspaceTargetEvent event);

     /**
      * Gets called when the client calls <code> SmartspaceSession#requestSmartspaceUpdate </code>.
      */
     @MainThread
     public abstract void onRequestSmartspaceUpdate(@NonNull SmartspaceSessionId sessionId);

     private void doRegisterSmartspaceUpdates(@NonNull SmartspaceSessionId sessionId,
             @NonNull ISmartspaceCallback callback) {
         if (DEBUG) {
             Log.d(TAG, "doRegisterSmartspaceUpdates mSessionCallbacks: " + mSessionCallbacks);
         }
         final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
         if (callbacks == null) {
             Slog.e(TAG, "Failed to register for updates for unknown session: " + sessionId);
             return;
         }

         final CallbackWrapper wrapper = findCallbackWrapper(callbacks, callback);
         if (wrapper == null) {
             callbacks.add(new CallbackWrapper(callback,
                     callbackWrapper ->
                             mHandler.post(
                                     () -> removeCallbackWrapper(callbacks, callbackWrapper))));
         }
     }

     private void doUnregisterSmartspaceUpdates(@NonNull SmartspaceSessionId sessionId,
             @NonNull ISmartspaceCallback callback) {
         if (DEBUG) {
             Log.d(TAG, "doUnregisterSmartspaceUpdates mSessionCallbacks: " + mSessionCallbacks);
         }
         final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
         if (callbacks == null) {
             Slog.e(TAG, "Failed to unregister for updates for unknown session: " + sessionId);
             return;
         }

         final CallbackWrapper wrapper = findCallbackWrapper(callbacks, callback);
         removeCallbackWrapper(callbacks, wrapper);
     }

     private void doRequestPredictionUpdate(@NonNull SmartspaceSessionId sessionId) {
         if (DEBUG) {
             Log.d(TAG, "doRequestPredictionUpdate mSessionCallbacks: " + mSessionCallbacks);
         }
         // Just an optimization, if there are no callbacks, then don't bother notifying the service
         final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
         if (callbacks != null && !callbacks.isEmpty()) {
             onRequestSmartspaceUpdate(sessionId);
         }
     }

     /**
      * Finds the callback wrapper for the given callback.
      */
     private CallbackWrapper findCallbackWrapper(ArrayList<CallbackWrapper> callbacks,
             ISmartspaceCallback callback) {
         for (int i = callbacks.size() - 1; i >= 0; i--) {
             if (callbacks.get(i).isCallback(callback)) {
                 return callbacks.get(i);
             }
         }
         return null;
     }

     private void removeCallbackWrapper(@Nullable ArrayList<CallbackWrapper> callbacks,
             @Nullable CallbackWrapper wrapper) {
         if (callbacks == null || wrapper == null) {
             return;
         }
         callbacks.remove(wrapper);
         wrapper.destroy();
     }

     /**
      * Gets called when the client calls <code> SmartspaceManager#destroy() </code>.
      */
     public abstract void onDestroySmartspaceSession(@NonNull SmartspaceSessionId sessionId);

     private void doDestroy(@NonNull SmartspaceSessionId sessionId) {
         if (DEBUG) {
             Log.d(TAG, "doDestroy mSessionCallbacks: " + mSessionCallbacks);
         }
         super.onDestroy();

         final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.remove(sessionId);
         if (callbacks != null) callbacks.forEach(CallbackWrapper::destroy);
         onDestroySmartspaceSession(sessionId);
     }

     /**
      * Used by the prediction factory to send back results the client app. The can be called
      * in response to {@link #onRequestSmartspaceUpdate(SmartspaceSessionId)} or proactively as
      * a result of changes in predictions.
      */
     public final void updateSmartspaceTargets(@NonNull SmartspaceSessionId sessionId,
             @NonNull List<SmartspaceTarget> targets) {
         if (DEBUG) {
             Log.d(TAG, "updateSmartspaceTargets mSessionCallbacks: " + mSessionCallbacks);
         }
         List<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
         if (callbacks != null) {
             for (CallbackWrapper callback : callbacks) {
                 callback.accept(targets);
             }
         }
     }

     /**
      * Destroys a smartspace session.
      */
     @MainThread
     public abstract void onDestroy(@NonNull SmartspaceSessionId sessionId);

     private static final class CallbackWrapper implements Consumer<List<SmartspaceTarget>>,
             IBinder.DeathRecipient {

         private final Consumer<CallbackWrapper> mOnBinderDied;
         private ISmartspaceCallback mCallback;

         CallbackWrapper(ISmartspaceCallback callback,
                 @Nullable Consumer<CallbackWrapper> onBinderDied) {
             mCallback = callback;
             mOnBinderDied = onBinderDied;
             if (mOnBinderDied != null) {
                 try {
                     mCallback.asBinder().linkToDeath(this, 0);
                 } catch (RemoteException e) {
                     Slog.e(TAG, "Failed to link to death: " + e);
                 }
             }
         }

         public boolean isCallback(@NonNull ISmartspaceCallback callback) {
             if (mCallback == null) {
                 Slog.e(TAG, "Callback is null, likely the binder has died.");
                 return false;
             }
             return mCallback.asBinder().equals(callback.asBinder());
         }

         @Override
         public void accept(List<SmartspaceTarget> smartspaceTargets) {
             try {
                 if (mCallback != null) {
                     if (DEBUG) {
                         Slog.d(TAG,
                                 "CallbackWrapper.accept smartspaceTargets=" + smartspaceTargets);
                     }
                     mCallback.onResult(new ParceledListSlice(smartspaceTargets));
                 }
             } catch (RemoteException e) {
                 Slog.e(TAG, "Error sending result:" + e);
             }
         }

         public void destroy() {
             if (mCallback != null && mOnBinderDied != null) {
                 mCallback.asBinder().unlinkToDeath(this, 0);
             }
         }

         @Override
         public void binderDied() {
             destroy();
             mCallback = null;
             if (mOnBinderDied != null) {
                 mOnBinderDied.accept(this);
             }
         }
     }
 }
	/*
	* Copyright (C) 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 android.service.smartspace;

	import static com.android.internal.util.function.pooled.PooledLambda.obtainMessage;

	import android.annotation.CallSuper;
	import android.annotation.MainThread;
	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.annotation.SystemApi;
	import android.app.Service;
	import android.app.smartspace.ISmartspaceCallback;
	import android.app.smartspace.SmartspaceConfig;
	import android.app.smartspace.SmartspaceSessionId;
	import android.app.smartspace.SmartspaceTarget;
	import android.app.smartspace.SmartspaceTargetEvent;
	import android.content.Intent;
	import android.content.pm.ParceledListSlice;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Looper;
	import android.os.RemoteException;
	import android.service.smartspace.ISmartspaceService.Stub;
	import android.util.ArrayMap;
	import android.util.Log;
	import android.util.Slog;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.function.Consumer;

	/**
	* A service used to share the lifecycle of smartspace UI (open, close, interaction)
	* and also to return smartspace result on a query.
	*
	* @hide
	*/
	@SystemApi
	public abstract class SmartspaceService extends Service {

	/**
	* The {@link Intent} that must be declared as handled by the service.
	*
	* <p>The service must also require the {@link android.permission#MANAGE_SMARTSPACE}
	* permission.
	*
	* @hide
	*/
	public static final String SERVICE_INTERFACE =
	"android.service.smartspace.SmartspaceService";
	private static final boolean DEBUG = false;
	private static final String TAG = "SmartspaceService";
	private final ArrayMap<SmartspaceSessionId, ArrayList<CallbackWrapper>> mSessionCallbacks =
	new ArrayMap<>();
	private Handler mHandler;

	private final android.service.smartspace.ISmartspaceService mInterface = new Stub() {

	@Override
	public void onCreateSmartspaceSession(SmartspaceConfig smartspaceConfig,
	SmartspaceSessionId sessionId) {
	mHandler.sendMessage(
	obtainMessage(SmartspaceService::doCreateSmartspaceSession,
	SmartspaceService.this, smartspaceConfig, sessionId));
	}

	@Override
	public void notifySmartspaceEvent(SmartspaceSessionId sessionId,
	SmartspaceTargetEvent event) {
	mHandler.sendMessage(
	obtainMessage(SmartspaceService::notifySmartspaceEvent,
	SmartspaceService.this, sessionId, event));
	}

	@Override
	public void requestSmartspaceUpdate(SmartspaceSessionId sessionId) {
	mHandler.sendMessage(
	obtainMessage(SmartspaceService::doRequestPredictionUpdate,
	SmartspaceService.this, sessionId));
	}

	@Override
	public void registerSmartspaceUpdates(SmartspaceSessionId sessionId,
	ISmartspaceCallback callback) {
	mHandler.sendMessage(
	obtainMessage(SmartspaceService::doRegisterSmartspaceUpdates,
	SmartspaceService.this, sessionId, callback));
	}

	@Override
	public void unregisterSmartspaceUpdates(SmartspaceSessionId sessionId,
	ISmartspaceCallback callback) {
	mHandler.sendMessage(
	obtainMessage(SmartspaceService::doUnregisterSmartspaceUpdates,
	SmartspaceService.this, sessionId, callback));
	}

	@Override
	public void onDestroySmartspaceSession(SmartspaceSessionId sessionId) {

	mHandler.sendMessage(
	obtainMessage(SmartspaceService::doDestroy,
	SmartspaceService.this, sessionId));
	}
	};

	@CallSuper
	@Override
	public void onCreate() {
	super.onCreate();
	if (DEBUG) {
	Log.d(TAG, "onCreate mSessionCallbacks: " + mSessionCallbacks);
	}
	mHandler = new Handler(Looper.getMainLooper(), null, true);
	}

	@Override
	@NonNull
	public final IBinder onBind(@NonNull Intent intent) {
	if (DEBUG) {
	Log.d(TAG, "onBind mSessionCallbacks: " + mSessionCallbacks);
	}
	if (SERVICE_INTERFACE.equals(intent.getAction())) {
	return mInterface.asBinder();
	}
	Slog.w(TAG, "Tried to bind to wrong intent (should be "
	+ SERVICE_INTERFACE + ": " + intent);
	return null;
	}

	private void doCreateSmartspaceSession(@NonNull SmartspaceConfig config,
	@NonNull SmartspaceSessionId sessionId) {
	if (DEBUG) {
	Log.d(TAG, "doCreateSmartspaceSession mSessionCallbacks: " + mSessionCallbacks);
	}
	mSessionCallbacks.put(sessionId, new ArrayList<>());
	onCreateSmartspaceSession(config, sessionId);
	}

	/**
	* Gets called when the client calls <code> SmartspaceManager#createSmartspaceSession </code>.
	*/
	public abstract void onCreateSmartspaceSession(@NonNull SmartspaceConfig config,
	@NonNull SmartspaceSessionId sessionId);

	/**
	* Gets called when the client calls <code> SmartspaceSession#notifySmartspaceEvent </code>.
	*/
	@MainThread
	public abstract void notifySmartspaceEvent(@NonNull SmartspaceSessionId sessionId,
	@NonNull SmartspaceTargetEvent event);

	/**
	* Gets called when the client calls <code> SmartspaceSession#requestSmartspaceUpdate </code>.
	*/
	@MainThread
	public abstract void onRequestSmartspaceUpdate(@NonNull SmartspaceSessionId sessionId);

	private void doRegisterSmartspaceUpdates(@NonNull SmartspaceSessionId sessionId,
	@NonNull ISmartspaceCallback callback) {
	if (DEBUG) {
	Log.d(TAG, "doRegisterSmartspaceUpdates mSessionCallbacks: " + mSessionCallbacks);
	}
	final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
	if (callbacks == null) {
	Slog.e(TAG, "Failed to register for updates for unknown session: " + sessionId);
	return;
	}

	final CallbackWrapper wrapper = findCallbackWrapper(callbacks, callback);
	if (wrapper == null) {
	callbacks.add(new CallbackWrapper(callback,
	callbackWrapper ->
	mHandler.post(
	() -> removeCallbackWrapper(callbacks, callbackWrapper))));
	}
	}

	private void doUnregisterSmartspaceUpdates(@NonNull SmartspaceSessionId sessionId,
	@NonNull ISmartspaceCallback callback) {
	if (DEBUG) {
	Log.d(TAG, "doUnregisterSmartspaceUpdates mSessionCallbacks: " + mSessionCallbacks);
	}
	final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
	if (callbacks == null) {
	Slog.e(TAG, "Failed to unregister for updates for unknown session: " + sessionId);
	return;
	}

	final CallbackWrapper wrapper = findCallbackWrapper(callbacks, callback);
	removeCallbackWrapper(callbacks, wrapper);
	}

	private void doRequestPredictionUpdate(@NonNull SmartspaceSessionId sessionId) {
	if (DEBUG) {
	Log.d(TAG, "doRequestPredictionUpdate mSessionCallbacks: " + mSessionCallbacks);
	}
	// Just an optimization, if there are no callbacks, then don't bother notifying the service
	final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
	if (callbacks != null && !callbacks.isEmpty()) {
	onRequestSmartspaceUpdate(sessionId);
	}
	}

	/**
	* Finds the callback wrapper for the given callback.
	*/
	private CallbackWrapper findCallbackWrapper(ArrayList<CallbackWrapper> callbacks,
	ISmartspaceCallback callback) {
	for (int i = callbacks.size() - 1; i >= 0; i--) {
	if (callbacks.get(i).isCallback(callback)) {
	return callbacks.get(i);
	}
	}
	return null;
	}

	private void removeCallbackWrapper(@Nullable ArrayList<CallbackWrapper> callbacks,
	@Nullable CallbackWrapper wrapper) {
	if (callbacks == null \|\| wrapper == null) {
	return;
	}
	callbacks.remove(wrapper);
	wrapper.destroy();
	}

	/**
	* Gets called when the client calls <code> SmartspaceManager#destroy() </code>.
	*/
	public abstract void onDestroySmartspaceSession(@NonNull SmartspaceSessionId sessionId);

	private void doDestroy(@NonNull SmartspaceSessionId sessionId) {
	if (DEBUG) {
	Log.d(TAG, "doDestroy mSessionCallbacks: " + mSessionCallbacks);
	}
	super.onDestroy();

	final ArrayList<CallbackWrapper> callbacks = mSessionCallbacks.remove(sessionId);
	if (callbacks != null) callbacks.forEach(CallbackWrapper::destroy);
	onDestroySmartspaceSession(sessionId);
	}

	/**
	* Used by the prediction factory to send back results the client app. The can be called
	* in response to {@link #onRequestSmartspaceUpdate(SmartspaceSessionId)} or proactively as
	* a result of changes in predictions.
	*/
	public final void updateSmartspaceTargets(@NonNull SmartspaceSessionId sessionId,
	@NonNull List<SmartspaceTarget> targets) {
	if (DEBUG) {
	Log.d(TAG, "updateSmartspaceTargets mSessionCallbacks: " + mSessionCallbacks);
	}
	List<CallbackWrapper> callbacks = mSessionCallbacks.get(sessionId);
	if (callbacks != null) {
	for (CallbackWrapper callback : callbacks) {
	callback.accept(targets);
	}
	}
	}

	/**
	* Destroys a smartspace session.
	*/
	@MainThread
	public abstract void onDestroy(@NonNull SmartspaceSessionId sessionId);

	private static final class CallbackWrapper implements Consumer<List<SmartspaceTarget>>,
	IBinder.DeathRecipient {

	private final Consumer<CallbackWrapper> mOnBinderDied;
	private ISmartspaceCallback mCallback;

	CallbackWrapper(ISmartspaceCallback callback,
	@Nullable Consumer<CallbackWrapper> onBinderDied) {
	mCallback = callback;
	mOnBinderDied = onBinderDied;
	if (mOnBinderDied != null) {
	try {
	mCallback.asBinder().linkToDeath(this, 0);
	} catch (RemoteException e) {
	Slog.e(TAG, "Failed to link to death: " + e);
	}
	}
	}

	public boolean isCallback(@NonNull ISmartspaceCallback callback) {
	if (mCallback == null) {
	Slog.e(TAG, "Callback is null, likely the binder has died.");
	return false;
	}
	return mCallback.asBinder().equals(callback.asBinder());
	}

	@Override
	public void accept(List<SmartspaceTarget> smartspaceTargets) {
	try {
	if (mCallback != null) {
	if (DEBUG) {
	Slog.d(TAG,
	"CallbackWrapper.accept smartspaceTargets=" + smartspaceTargets);
	}
	mCallback.onResult(new ParceledListSlice(smartspaceTargets));
	}
	} catch (RemoteException e) {
	Slog.e(TAG, "Error sending result:" + e);
	}
	}

	public void destroy() {
	if (mCallback != null && mOnBinderDied != null) {
	mCallback.asBinder().unlinkToDeath(this, 0);
	}
	}

	@Override
	public void binderDied() {
	destroy();
	mCallback = null;
	if (mOnBinderDied != null) {
	mOnBinderDied.accept(this);
	}
	}
	}
	}