Initial implementation of the IntelligenceService pipeline.
It's still full of TODOs, but at leats it now provides an end-to-end
workflow from the activity creation / destruction to the service implementation.
Test: mmm -j packages/experimental/FillService && \
adb install -r ${OUT}/data/app/FillService/FillService.apk && \
adb shell settings put secure intel_service foo.bar.fill/.AiaiService
Bug: 111276913
Change-Id: Id5daf7b8b51e97c74d9b6ec00f953ddb02b48e46
diff --git a/services/autofill/java/com/android/server/intelligence/IntelligencePerUserService.java b/services/autofill/java/com/android/server/intelligence/IntelligencePerUserService.java
new file mode 100644
index 0000000..b62b239
--- /dev/null
+++ b/services/autofill/java/com/android/server/intelligence/IntelligencePerUserService.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2018 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 com.android.server.intelligence;
+
+import android.Manifest;
+import android.annotation.NonNull;
+import android.app.AppGlobals;
+import android.content.ComponentName;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.pm.ServiceInfo;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.ArrayMap;
+import android.util.Slog;
+
+import com.android.internal.annotations.GuardedBy;
+import com.android.internal.os.IResultReceiver;
+import com.android.server.AbstractPerUserSystemService;
+
+import java.io.PrintWriter;
+
+/**
+ * Per-user instance of {@link IntelligenceManagerService}.
+ */
+final class IntelligencePerUserService
+ extends AbstractPerUserSystemService<IntelligencePerUserService> {
+
+ private static final String TAG = "IntelligencePerUserService";
+
+ private static int sNextSessionId;
+
+ // TODO(b/111276913): should key by componentName + taskId or ActivityToken
+ @GuardedBy("mLock")
+ private final ArrayMap<ComponentName, ContentCaptureSession> mSessions = new ArrayMap<>();
+
+ // TODO(b/111276913): add mechanism to prune stale sessions, similar to Autofill's
+
+ protected IntelligencePerUserService(
+ IntelligenceManagerService master, Object lock, int userId) {
+ super(master, lock, userId);
+ }
+
+ @Override // from PerUserSystemService
+ protected ServiceInfo newServiceInfo(@NonNull ComponentName serviceComponent)
+ throws NameNotFoundException {
+
+ ServiceInfo si;
+ try {
+ // TODO(b/111276913): must check that either the service is from a system component,
+ // or it matches a service set by shell cmd (so it can be used on CTS tests and when
+ // OEMs are implementing the real service
+ si = AppGlobals.getPackageManager().getServiceInfo(serviceComponent,
+ PackageManager.GET_META_DATA, mUserId);
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Could not get service for " + serviceComponent + ": " + e);
+ return null;
+ }
+ if (!Manifest.permission.BIND_INTELLIGENCE_SERVICE.equals(si.permission)) {
+ Slog.w(TAG, "IntelligenceService from '" + si.packageName
+ + "' does not require permission "
+ + Manifest.permission.BIND_INTELLIGENCE_SERVICE);
+ throw new SecurityException("Service does not require permission "
+ + Manifest.permission.BIND_INTELLIGENCE_SERVICE);
+ }
+ return si;
+ }
+
+ // TODO(b/111276913): log metrics
+ @GuardedBy("mLock")
+ public void startSessionLocked(@NonNull IBinder activityToken,
+ @NonNull ComponentName componentName, int taskId, int displayId, int localSessionId,
+ int flags, @NonNull IResultReceiver resultReceiver) {
+ final ComponentName serviceComponentName = getServiceComponentName();
+ if (serviceComponentName == null) {
+ // TODO(b/111276913): this happens when the system service is starting, we should
+ // probably handle it in a more elegant way (like waiting for boot_complete or
+ // something like that
+ Slog.w(TAG, "startSession(" + activityToken + "): hold your horses");
+ return;
+ }
+
+ ContentCaptureSession session = mSessions.get(componentName);
+ if (session != null) {
+ if (mMaster.debug) {
+ Slog.d(TAG, "startSession(): reusing session " + session.getGlobalSessionId()
+ + " for " + componentName);
+ }
+ // TODO(b/111276913): check if local ids match and decide what to do if they don't
+ // TODO(b/111276913): should we call session.notifySessionStartedLocked() again??
+ // if not, move notifySessionStartedLocked() into session constructor
+ sendToClient(resultReceiver, session.getGlobalSessionId());
+ return;
+ }
+
+ // TODO(b/117779333): get from mMaster once it's moved to superclass
+ final boolean bindInstantServiceAllowed = false;
+
+ session = new ContentCaptureSession(getContext(), mUserId, mLock, activityToken,
+ this, serviceComponentName, componentName, taskId, displayId, localSessionId,
+ ++sNextSessionId, flags, bindInstantServiceAllowed, mMaster.verbose);
+ if (mMaster.verbose) {
+ Slog.v(TAG, "startSession(): new session for " + componentName + "; globalId ="
+ + session.getGlobalSessionId());
+ }
+ mSessions.put(componentName, session);
+ session.notifySessionStartedLocked();
+ sendToClient(resultReceiver, session.getGlobalSessionId());
+ }
+
+ // TODO(b/111276913): log metrics
+ @GuardedBy("mLock")
+ public void finishSessionLocked(@NonNull IBinder activityToken,
+ @NonNull ComponentName componentName, int localSessionId, int globalSessionId) {
+ final ContentCaptureSession session = mSessions.get(componentName);
+ if (session == null) {
+ Slog.w(TAG, "finishSession(): no session for " + componentName);
+ return;
+ }
+ if (mMaster.verbose) {
+ Slog.v(TAG, "finishSession(): comp=" + componentName + "; globalId ="
+ + session.getGlobalSessionId());
+ }
+ // TODO(b/111276913): check if all arguments match existing session and throw exception if
+ // not. Or just use componentName if we change AIDL to pass just ApplicationToken and
+ // retrieve componentName from AMInternal
+ session.removeSelfLocked(true);
+ }
+
+ @GuardedBy("mLock")
+ public void removeSessionLocked(@NonNull ComponentName key) {
+ mSessions.remove(key);
+ }
+
+ @Override
+ protected void dumpLocked(String prefix, PrintWriter pw) {
+ super.dumpLocked(prefix, pw);
+ pw.print(prefix); pw.print("next id: "); pw.println(sNextSessionId);
+ if (mSessions.isEmpty()) {
+ pw.print(prefix); pw.println("no sessions");
+ } else {
+ final int size = mSessions.size();
+ pw.print(prefix); pw.print("number sessions: "); pw.println(size);
+ final String prefix2 = prefix + " ";
+ for (int i = 0; i < size; i++) {
+ pw.print(prefix); pw.print("session@"); pw.println(i);
+ final ContentCaptureSession session = mSessions.valueAt(i);
+ session.dumpLocked(prefix2, pw);
+ }
+ }
+ }
+
+ private static void sendToClient(@NonNull IResultReceiver resultReceiver, int value) {
+ try {
+ resultReceiver.send(value, null);
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Error async reporting result to client: " + e);
+ }
+ }
+}