Follow API council suggest to modify API for SelfTargeting

Accept the suggestions from API council
* OverlayManager.commit instead of OverlayManagerTrasnaction.commit
* By using factory method rather than constructor
  * OverlayManagerTrasnaction.newInstance for SelfTargeting.
  * get an OverlayManagerTrasnaction instance without OverlayManager
  * Limit the impact range only in the caller app.

Fix: 265814842
Bug: 269197647
API-Coverage-Bug: 262232910
Test: make update-api ; make
Test: make online-sdk-docs offline-sdk-docs
Test: atest \
    OverlayHostTests \
    OverlayDeviceTests \
    SelfTargetingOverlayDeviceTests \
    OverlayRemountedTest \
    FrameworksServicesTests:com.android.server.om \
    CtsContentTestCases:android.content.om.cts \
    CtsContentTestCases:android.content.res.loader.cts \
    idmap2_tests # result is http://ab/I42700010129841043

Change-Id: I7e81cb3209e78c7fb8ea7ea2072ec88f33053570

core/api/current.txt

@@ -11610,13 +11610,13 @@ package android.content.om {
   }
 
   public class OverlayManager {
+    method public void commit(@NonNull android.content.om.OverlayManagerTransaction);
     method @NonNull @NonUiContext public java.util.List<android.content.om.OverlayInfo> getOverlayInfosForTarget(@NonNull String);
   }
 
   public final class OverlayManagerTransaction implements android.os.Parcelable {
-    ctor public OverlayManagerTransaction(@NonNull android.content.om.OverlayManager);
-    method @NonUiContext public void commit() throws java.io.IOException, android.content.pm.PackageManager.NameNotFoundException;
     method public int describeContents();
+    method @NonNull public static android.content.om.OverlayManagerTransaction newInstance();
     method @NonNull public void registerFabricatedOverlay(@NonNull android.content.om.FabricatedOverlay);
     method @NonNull public void unregisterFabricatedOverlay(@NonNull android.content.om.OverlayIdentifier);
     method public void writeToParcel(@NonNull android.os.Parcel, int);

core/java/android/content/om/OverlayManager.java

@@ -323,8 +323,27 @@ public class OverlayManager {
      *
      * @hide
      */
+    private void commitToSystemServer(@NonNull final OverlayManagerTransaction transaction) {
+        try {
+            mService.commit(transaction);
+        } catch (RemoteException e) {
+            throw e.rethrowFromSystemServer();
+        }
+    }
+
+    /**
+     * Commit the overlay manager transaction.
+     *
+     * <p>Applications can register overlays and unregister the registered overlays in an atomic
+     * operation via {@link OverlayManagerTransaction}.
+     *
+     * @see OverlayManagerTransaction
+     *
+     * @param transaction the series of overlay related requests to perform
+     * @throws Exception if not all the requests could be successfully
+     */
     public void commit(@NonNull final OverlayManagerTransaction transaction) {
-        if (transaction.isSelfTargetingTransaction()
+        if (transaction.isSelfTargeting()
                 || mService == null
                 || mService.asBinder() == null) {
             try {
@@ -335,11 +354,7 @@ public class OverlayManager {
             return;
         }
 
-        try {
-            mService.commit(transaction);
-        } catch (RemoteException e) {
-            throw e.rethrowFromSystemServer();
-        }
+        commitToSystemServer(transaction);
     }
 
     /**

core/java/android/content/om/OverlayManagerTransaction.java

@@ -16,20 +16,20 @@
 
 package android.content.om;
 
+import static android.annotation.SystemApi.Client.SYSTEM_SERVER;
+
 import static com.android.internal.util.Preconditions.checkNotNull;
 
 import android.annotation.IntDef;
 import android.annotation.NonNull;
-import android.annotation.NonUiContext;
 import android.annotation.Nullable;
 import android.annotation.SuppressLint;
-import android.content.pm.PackageManager;
+import android.annotation.SystemApi;
 import android.os.Bundle;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.os.UserHandle;
 
-import java.io.IOException;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.ArrayList;
@@ -63,7 +63,7 @@ public final class OverlayManagerTransaction implements Parcelable {
     // TODO: remove @hide from this class when OverlayManager is added to the
     // SDK, but keep OverlayManagerTransaction.Request @hidden
     private final List<Request> mRequests;
-    private final OverlayManager mOverlayManager;
+    private final boolean mSelfTargeting;
 
     /**
      * Container for a batch of requests to the OverlayManagerService.
@@ -79,21 +79,23 @@ public final class OverlayManagerTransaction implements Parcelable {
      * }</pre>
      */
     private OverlayManagerTransaction(
-            @NonNull final List<Request> requests, @Nullable OverlayManager overlayManager) {
+            @NonNull final List<Request> requests, boolean selfTargeting) {
         Objects.requireNonNull(requests);
         if (requests.contains(null)) {
             throw new IllegalArgumentException("null request");
         }
         mRequests = requests;
-        mOverlayManager = overlayManager;
+        mSelfTargeting = selfTargeting;
     }
 
     /**
-     * Get an overlay manager transaction with the specified handler.
-     * @param overlayManager handles this transaction.
+     * Get an overlay manager transaction.
+     *
+     * @return a new {@link OverlayManagerTransaction} instance.
      */
-    public OverlayManagerTransaction(@NonNull OverlayManager overlayManager) {
-        this(new ArrayList<>(), Objects.requireNonNull(overlayManager));
+    @NonNull
+    public static OverlayManagerTransaction newInstance() {
+        return new OverlayManagerTransaction(new ArrayList<>(), true /* selfTargeting */);
     }
 
     private OverlayManagerTransaction(@NonNull final Parcel source) {
@@ -106,7 +108,7 @@ public final class OverlayManagerTransaction implements Parcelable {
             final Bundle extras = source.readBundle(null);
             mRequests.add(new Request(request, overlay, userId, extras));
         }
-        mOverlayManager = null;
+        mSelfTargeting = false;
     }
 
     /**
@@ -117,6 +119,7 @@ public final class OverlayManagerTransaction implements Parcelable {
      */
     @SuppressLint("ReferencesHidden")
     @NonNull
+    @SystemApi(client = SYSTEM_SERVER)
     public Iterator<Request> getRequests() {
         return mRequests.iterator();
     }
@@ -137,6 +140,7 @@ public final class OverlayManagerTransaction implements Parcelable {
      *
      * @hide
      */
+    @SystemApi(client = SYSTEM_SERVER)
     public static final class Request {
         @IntDef(prefix = "TYPE_", value = {
                 TYPE_SET_ENABLED,
@@ -200,7 +204,7 @@ public final class OverlayManagerTransaction implements Parcelable {
 
     /**
      * Builder class for OverlayManagerTransaction objects.
-     *
+     * TODO(b/269197647): mark the API used by the systemUI.
      * @hide
      */
     public static final class Builder {
@@ -282,7 +286,7 @@ public final class OverlayManagerTransaction implements Parcelable {
          */
         @NonNull
         public OverlayManagerTransaction build() {
-            return new OverlayManagerTransaction(mRequests, null /* overlayManager */);
+            return new OverlayManagerTransaction(mRequests, false /* selfTargeting */);
         }
     }
 
@@ -325,20 +329,6 @@ public final class OverlayManagerTransaction implements Parcelable {
         }
     };
 
-    /**
-     * Commit the overlay manager transaction to register or unregister overlays for self-targeting.
-     *
-     * <p>Applications can register overlays and unregister the registered overlays via {@link
-     * OverlayManagerTransaction}.
-     *
-     * @throws IOException if there is a file operation error.
-     * @throws PackageManager.NameNotFoundException if the package name is not found.
-     */
-    @NonUiContext
-    public void commit() throws PackageManager.NameNotFoundException, IOException {
-        mOverlayManager.commitSelfTarget(this);
-    }
-
     private static Request generateRegisterFabricatedOverlayRequest(
             @NonNull FabricatedOverlay overlay) {
         Objects.requireNonNull(overlay);
@@ -385,7 +375,10 @@ public final class OverlayManagerTransaction implements Parcelable {
         mRequests.add(generateUnRegisterFabricatedOverlayRequest(overlay));
     }
 
-    boolean isSelfTargetingTransaction() {
-        return mOverlayManager != null;
+    /**
+     * Indicate whether the transaction is for self-targeting or not.
+     */
+    boolean isSelfTargeting() {
+        return mSelfTargeting;
     }
 }