Merge SP1A.210723.002

Change-Id: I220cdfc5cb9db40162fd33f400a54591018d54cf

24 files changed, 213 insertions, 180 deletions

diff --git a/core/java/Android.bp b/core/java/Android.bp
index 6c001f305ce7..26c83eeca508 100644
--- a/core/java/Android.bp
+++ b/core/java/Android.bp
@@ -112,6 +112,8 @@ filegroup {
     srcs: [
         "android/os/Temperature.aidl",
         "android/os/CoolingDevice.aidl",
+        "android/os/IHintManager.aidl",
+        "android/os/IHintSession.aidl",
         "android/os/IThermalEventListener.aidl",
         "android/os/IThermalStatusListener.aidl",
         "android/os/IThermalService.aidl",
diff --git a/core/java/android/app/ActivityManager.java b/core/java/android/app/ActivityManager.java
index 91e2d88ad7cb..4376d225e676 100644
--- a/core/java/android/app/ActivityManager.java
+++ b/core/java/android/app/ActivityManager.java
@@ -406,6 +406,12 @@ public class ActivityManager {
     public static final int BROADCAST_FAILED_USER_STOPPED = -2;
 
     /**
+     * Type for IActivityManaqer.getIntentSender: this PendingIntent type is unknown.
+     * @hide
+     */
+    public static final int INTENT_SENDER_UNKNOWN = 0;
+
+    /**
      * Type for IActivityManaqer.getIntentSender: this PendingIntent is
      * for a sendBroadcast operation.
      * @hide
@@ -4860,12 +4866,12 @@ public class ActivityManager {
      */
     public static final class PendingIntentInfo implements Parcelable {
 
-        private final String mCreatorPackage;
+        @Nullable private final String mCreatorPackage;
         private final int mCreatorUid;
         private final boolean mImmutable;
         private final int mIntentSenderType;
 
-        public PendingIntentInfo(String creatorPackage, int creatorUid, boolean immutable,
+        public PendingIntentInfo(@Nullable String creatorPackage, int creatorUid, boolean immutable,
                 int intentSenderType) {
             mCreatorPackage = creatorPackage;
             mCreatorUid = creatorUid;
@@ -4873,6 +4879,7 @@ public class ActivityManager {
             mIntentSenderType = intentSenderType;
         }
 
+        @Nullable
         public String getCreatorPackage() {
             return mCreatorPackage;
         }
diff --git a/core/java/android/app/AppOpsManagerInternal.java b/core/java/android/app/AppOpsManagerInternal.java
index 363b5a75b214..4d6e4aedba66 100644
--- a/core/java/android/app/AppOpsManagerInternal.java
+++ b/core/java/android/app/AppOpsManagerInternal.java
@@ -21,6 +21,7 @@ import android.annotation.Nullable;
 import android.app.AppOpsManager.AttributionFlags;
 import android.content.AttributionSource;
 import android.os.IBinder;
+import android.os.UserHandle;
 import android.util.SparseArray;
 import android.util.SparseIntArray;
 
@@ -215,4 +216,11 @@ public abstract class AppOpsManagerInternal {
      * Sets a global restriction on an op code.
      */
     public abstract void setGlobalRestriction(int code, boolean restricted, IBinder token);
+
+    /**
+     * Gets the number of tokens restricting the given appop for a user, package, and
+     * attributionTag.
+     */
+    public abstract int getOpRestrictionCount(int code, UserHandle user, String pkg,
+            String attributionTag);
 }
diff --git a/core/java/android/app/SystemServiceRegistry.java b/core/java/android/app/SystemServiceRegistry.java
index 871d48b07a20..32ea41b2c75f 100644
--- a/core/java/android/app/SystemServiceRegistry.java
+++ b/core/java/android/app/SystemServiceRegistry.java
@@ -158,7 +158,6 @@ import android.os.IBatteryPropertiesRegistrar;
 import android.os.IBinder;
 import android.os.IDumpstate;
 import android.os.IHardwarePropertiesManager;
-import android.os.IHintManager;
 import android.os.IPowerManager;
 import android.os.IRecoverySystem;
 import android.os.ISystemUpdateManager;
@@ -600,10 +599,7 @@ public final class SystemServiceRegistry {
             @Override
             public PerformanceHintManager createService(ContextImpl ctx)
                     throws ServiceNotFoundException {
-                IBinder hintBinder = ServiceManager.getServiceOrThrow(
-                        Context.PERFORMANCE_HINT_SERVICE);
-                IHintManager hintService = IHintManager.Stub.asInterface(hintBinder);
-                return new PerformanceHintManager(hintService);
+                return PerformanceHintManager.create();
             }});
 
         registerService(Context.RECOVERY_SERVICE, RecoverySystem.class,
diff --git a/core/java/android/app/TaskInfo.java b/core/java/android/app/TaskInfo.java
index 444cc4eedcb1..85758a92fa98 100644
--- a/core/java/android/app/TaskInfo.java
+++ b/core/java/android/app/TaskInfo.java
@@ -28,11 +28,13 @@ import android.content.LocusId;
 import android.content.pm.ActivityInfo;
 import android.content.res.Configuration;
 import android.graphics.Point;
+import android.graphics.Rect;
 import android.os.Build;
 import android.os.IBinder;
 import android.os.Parcel;
 import android.os.RemoteException;
 import android.util.Log;
+import android.view.DisplayCutout;
 import android.window.TaskSnapshot;
 import android.window.WindowContainerToken;
 
@@ -174,6 +176,15 @@ public class TaskInfo {
     public PictureInPictureParams pictureInPictureParams;
 
     /**
+     * The {@link Rect} copied from {@link DisplayCutout#getSafeInsets()} if the cutout is not of
+     * (LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES, LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS),
+     * {@code null} otherwise.
+     * @hide
+     */
+    @Nullable
+    public Rect displayCutoutInsets;
+
+    /**
      * The activity type of the top activity in this task.
      * @hide
      */
@@ -332,6 +343,7 @@ public class TaskInfo {
                 && supportsMultiWindow == that.supportsMultiWindow
                 && Objects.equals(positionInParent, that.positionInParent)
                 && Objects.equals(pictureInPictureParams, that.pictureInPictureParams)
+                && Objects.equals(displayCutoutInsets, that.displayCutoutInsets)
                 && getWindowingMode() == that.getWindowingMode()
                 && Objects.equals(taskDescription, that.taskDescription)
                 && isFocused == that.isFocused
@@ -382,6 +394,7 @@ public class TaskInfo {
         token = WindowContainerToken.CREATOR.createFromParcel(source);
         topActivityType = source.readInt();
         pictureInPictureParams = source.readTypedObject(PictureInPictureParams.CREATOR);
+        displayCutoutInsets = source.readTypedObject(Rect.CREATOR);
         topActivityInfo = source.readTypedObject(ActivityInfo.CREATOR);
         isResizeable = source.readBoolean();
         source.readBinderList(launchCookies);
@@ -419,6 +432,7 @@ public class TaskInfo {
         token.writeToParcel(dest, flags);
         dest.writeInt(topActivityType);
         dest.writeTypedObject(pictureInPictureParams, flags);
+        dest.writeTypedObject(displayCutoutInsets, flags);
         dest.writeTypedObject(topActivityInfo, flags);
         dest.writeBoolean(isResizeable);
         dest.writeBinderList(launchCookies);
@@ -447,6 +461,7 @@ public class TaskInfo {
                 + " token=" + token
                 + " topActivityType=" + topActivityType
                 + " pictureInPictureParams=" + pictureInPictureParams
+                + " displayCutoutSafeInsets=" + displayCutoutInsets
                 + " topActivityInfo=" + topActivityInfo
                 + " launchCookies=" + launchCookies
                 + " positionInParent=" + positionInParent
diff --git a/core/java/android/app/admin/DevicePolicyManager.java b/core/java/android/app/admin/DevicePolicyManager.java
index 6bc331d323ac..549ab6e2df83 100644
--- a/core/java/android/app/admin/DevicePolicyManager.java
+++ b/core/java/android/app/admin/DevicePolicyManager.java
@@ -10151,8 +10151,8 @@ public class DevicePolicyManager {
      * An example of a supported preferential network service is the Enterprise
      * slice on 5G networks.
      *
-     * By default, preferential network service is enabled on the work profile on supported
-     * carriers and devices. Admins can explicitly disable it with this API.
+     * By default, preferential network service is disabled on the work profile on supported
+     * carriers and devices. Admins can explicitly enable it with this API.
      * On fully-managed devices this method is unsupported because all traffic is considered
      * work traffic.
      *
diff --git a/core/java/android/bluetooth/BluetoothAdapter.java b/core/java/android/bluetooth/BluetoothAdapter.java
index cf9a6dc5cb96..019bd4493120 100644
--- a/core/java/android/bluetooth/BluetoothAdapter.java
+++ b/core/java/android/bluetooth/BluetoothAdapter.java
@@ -3740,22 +3740,22 @@ public final class BluetoothAdapter {
     }
 
     /**
-     * Determines whether a String Bluetooth address, such as "00:43:A8:23:10:F0"
+     * Determines whether a String Bluetooth address, such as "F0:43:A8:23:10:00"
      * is a RANDOM STATIC address.
      *
-     * RANDOM STATIC: (addr & 0b11) == 0b11
-     * RANDOM RESOLVABLE: (addr & 0b11) == 0b10
-     * RANDOM non-RESOLVABLE: (addr & 0b11) == 0b00
+     * RANDOM STATIC: (addr & 0xC0) == 0xC0
+     * RANDOM RESOLVABLE: (addr &  0xC0) == 0x40
+     * RANDOM non-RESOLVABLE: (addr &  0xC0) == 0x00
      *
      * @param address Bluetooth address as string
-     * @return true if the 2 Least Significant Bits of the address equals 0b11.
+     * @return true if the 2 Most Significant Bits of the address equals 0xC0.
      *
      * @hide
      */
     public static boolean isAddressRandomStatic(@NonNull String address) {
         requireNonNull(address);
         return checkBluetoothAddress(address)
-                && (Integer.parseInt(address.split(":")[5], 16) & 0b11) == 0b11;
+                && (Integer.parseInt(address.split(":")[0], 16) & 0xC0) == 0xC0;
     }
 
     /** {@hide} */
diff --git a/core/java/android/content/AttributionSource.java b/core/java/android/content/AttributionSource.java
index 0e22705146af..bdb7900b5bb9 100644
--- a/core/java/android/content/AttributionSource.java
+++ b/core/java/android/content/AttributionSource.java
@@ -252,7 +252,8 @@ public final class AttributionSource implements Parcelable {
      */
     public boolean checkCallingUid() {
         final int callingUid = Binder.getCallingUid();
-        if (callingUid != Process.SYSTEM_UID
+        if (callingUid != Process.ROOT_UID
+                && callingUid != Process.SYSTEM_UID
                 && callingUid != mAttributionSourceState.uid) {
             return false;
         }
diff --git a/core/java/android/hardware/camera2/CameraMetadata.java b/core/java/android/hardware/camera2/CameraMetadata.java
index 9501994fe38a..d9fa56e1cbaa 100644
--- a/core/java/android/hardware/camera2/CameraMetadata.java
+++ b/core/java/android/hardware/camera2/CameraMetadata.java
@@ -991,13 +991,27 @@ public abstract class CameraMetadata<TKey> {
      * camera's crop region is set to maximum size, the FOV of the physical streams for the
      * ultrawide lens will be the same as the logical stream, by making the crop region
      * smaller than its active array size to compensate for the smaller focal length.</p>
-     * <p>Even if the underlying physical cameras have different RAW characteristics (such as
-     * size or CFA pattern), a logical camera can still advertise RAW capability. In this
-     * case, when the application configures a RAW stream, the camera device will make sure
-     * the active physical camera will remain active to ensure consistent RAW output
-     * behavior, and not switch to other physical cameras.</p>
+     * <p>There are two ways for the application to capture RAW images from a logical camera
+     * with RAW capability:</p>
+     * <ul>
+     * <li>Because the underlying physical cameras may have different RAW capabilities (such
+     * as resolution or CFA pattern), to maintain backward compatibility, when a RAW stream
+     * is configured, the camera device makes sure the default active physical camera remains
+     * active and does not switch to other physical cameras. (One exception is that, if the
+     * logical camera consists of identical image sensors and advertises multiple focalLength
+     * due to different lenses, the camera device may generate RAW images from different
+     * physical cameras based on the focalLength being set by the application.) This
+     * backward-compatible approach usually results in loss of optical zoom, to telephoto
+     * lens or to ultrawide lens.</li>
+     * <li>Alternatively, to take advantage of the full zoomRatio range of the logical camera,
+     * the application should use {@link android.hardware.camera2.MultiResolutionImageReader }
+     * to capture RAW images from the currently active physical camera. Because different
+     * physical camera may have different RAW characteristics, the application needs to use
+     * the characteristics and result metadata of the active physical camera for the
+     * relevant RAW metadata.</li>
+     * </ul>
      * <p>The capture request and result metadata tags required for backward compatible camera
-     * functionalities will be solely based on the logical camera capabiltity. On the other
+     * functionalities will be solely based on the logical camera capability. On the other
      * hand, the use of manual capture controls (sensor or post-processing) with a
      * logical camera may result in unexpected behavior when the HAL decides to switch
      * between physical cameras with different characteristics under the hood. For example,
diff --git a/core/java/android/hardware/display/DisplayManager.java b/core/java/android/hardware/display/DisplayManager.java
index de32adb1f545..e13a7b6eac65 100644
--- a/core/java/android/hardware/display/DisplayManager.java
+++ b/core/java/android/hardware/display/DisplayManager.java
@@ -72,9 +72,6 @@ public final class DisplayManager {
      * {@link #EXTRA_WIFI_DISPLAY_STATUS} extra.
      * </p><p>
      * This broadcast is only sent to registered receivers and can only be sent by the system.
-     * </p><p>
-     * {@link android.Manifest.permission#ACCESS_FINE_LOCATION} permission is required to
-     * receive this broadcast.
      * </p>
      * @hide
      */
diff --git a/core/java/android/hardware/face/FaceManager.java b/core/java/android/hardware/face/FaceManager.java
index 12557f9b73eb..c2a2c4c0678c 100644
--- a/core/java/android/hardware/face/FaceManager.java
+++ b/core/java/android/hardware/face/FaceManager.java
@@ -74,7 +74,7 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
 
     private final IFaceService mService;
     private final Context mContext;
-    private IBinder mToken = new Binder();
+    private final IBinder mToken = new Binder();
     @Nullable private AuthenticationCallback mAuthenticationCallback;
     @Nullable private FaceDetectionCallback mFaceDetectionCallback;
     @Nullable private EnrollmentCallback mEnrollmentCallback;
@@ -86,7 +86,7 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
     private Face mRemovalFace;
     private Handler mHandler;
 
-    private IFaceServiceReceiver mServiceReceiver = new IFaceServiceReceiver.Stub() {
+    private final IFaceServiceReceiver mServiceReceiver = new IFaceServiceReceiver.Stub() {
 
         @Override // binder call
         public void onEnrollResult(Face face, int remaining) {
@@ -293,7 +293,7 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
 
     /**
      * Defaults to {@link FaceManager#enroll(int, byte[], CancellationSignal, EnrollmentCallback,
-     * int[], Surface)} with {@code surface} set to null.
+     * int[], Surface)} with {@code previewSurface} set to null.
      *
      * @see FaceManager#enroll(int, byte[], CancellationSignal, EnrollmentCallback, int[], Surface)
      * @hide
@@ -301,8 +301,8 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
     @RequiresPermission(MANAGE_BIOMETRIC)
     public void enroll(int userId, byte[] hardwareAuthToken, CancellationSignal cancel,
             EnrollmentCallback callback, int[] disabledFeatures) {
-        enroll(userId, hardwareAuthToken, cancel, callback, disabledFeatures, null /* surface */,
-                false /* debugConsent */);
+        enroll(userId, hardwareAuthToken, cancel, callback, disabledFeatures,
+                null /* previewSurface */, false /* debugConsent */);
     }
 
     /**
@@ -319,14 +319,14 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
      * @param cancel            an object that can be used to cancel enrollment
      * @param userId            the user to whom this face will belong to
      * @param callback          an object to receive enrollment events
-     * @param surface           optional camera preview surface for a single-camera device.
+     * @param previewSurface    optional camera preview surface for a single-camera device.
      *                          Must be null if not used.
      * @param debugConsent      a feature flag that the user has consented to debug.
      * @hide
      */
     @RequiresPermission(MANAGE_BIOMETRIC)
     public void enroll(int userId, byte[] hardwareAuthToken, CancellationSignal cancel,
-            EnrollmentCallback callback, int[] disabledFeatures, @Nullable Surface surface,
+            EnrollmentCallback callback, int[] disabledFeatures, @Nullable Surface previewSurface,
             boolean debugConsent) {
         if (callback == null) {
             throw new IllegalArgumentException("Must supply an enrollment callback");
@@ -346,7 +346,8 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
                 mEnrollmentCallback = callback;
                 Trace.beginSection("FaceManager#enroll");
                 mService.enroll(userId, mToken, hardwareAuthToken, mServiceReceiver,
-                        mContext.getOpPackageName(), disabledFeatures, surface, debugConsent);
+                        mContext.getOpPackageName(), disabledFeatures, previewSurface,
+                        debugConsent);
             } catch (RemoteException e) {
                 Slog.w(TAG, "Remote exception in enroll: ", e);
                 // Though this may not be a hardware issue, it will cause apps to give up or
@@ -853,10 +854,10 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
      * @hide
      */
     public static class AuthenticationResult {
-        private Face mFace;
-        private CryptoObject mCryptoObject;
-        private int mUserId;
-        private boolean mIsStrongBiometric;
+        private final Face mFace;
+        private final CryptoObject mCryptoObject;
+        private final int mUserId;
+        private final boolean mIsStrongBiometric;
 
         /**
          * Authentication result
@@ -1127,7 +1128,7 @@ public class FaceManager implements BiometricAuthenticator, BiometricFaceConstan
     }
 
     private class OnAuthenticationCancelListener implements OnCancelListener {
-        private CryptoObject mCrypto;
+        private final CryptoObject mCrypto;
 
         OnAuthenticationCancelListener(CryptoObject crypto) {
             mCrypto = crypto;
diff --git a/core/java/android/hardware/face/IFaceService.aidl b/core/java/android/hardware/face/IFaceService.aidl
index 270d662a02a0..b9a49c6ced09 100644
--- a/core/java/android/hardware/face/IFaceService.aidl
+++ b/core/java/android/hardware/face/IFaceService.aidl
@@ -75,7 +75,7 @@ interface IFaceService {
 
     // Start face enrollment
     void enroll(int userId, IBinder token, in byte [] hardwareAuthToken, IFaceServiceReceiver receiver,
-            String opPackageName, in int [] disabledFeatures, in Surface surface, boolean debugConsent);
+            String opPackageName, in int [] disabledFeatures, in Surface previewSurface, boolean debugConsent);
 
     // Start remote face enrollment
     void enrollRemotely(int userId, IBinder token, in byte [] hardwareAuthToken, IFaceServiceReceiver receiver,
diff --git a/core/java/android/net/nsd/NsdManager.java b/core/java/android/net/nsd/NsdManager.java
index 5a25cfc00cd4..ae8d0101947d 100644
--- a/core/java/android/net/nsd/NsdManager.java
+++ b/core/java/android/net/nsd/NsdManager.java
@@ -23,6 +23,9 @@ import static com.android.internal.util.Preconditions.checkStringNotEmpty;
 import android.annotation.SdkConstant;
 import android.annotation.SdkConstant.SdkConstantType;
 import android.annotation.SystemService;
+import android.app.compat.CompatChanges;
+import android.compat.annotation.ChangeId;
+import android.compat.annotation.EnabledSince;
 import android.content.Context;
 import android.os.Handler;
 import android.os.HandlerThread;
@@ -126,6 +129,24 @@ public final class NsdManager {
     private static final boolean DBG = false;
 
     /**
+     * When enabled, apps targeting < Android 12 are considered legacy for
+     * the NSD native daemon.
+     * The platform will only keep the daemon running as long as there are
+     * any legacy apps connected.
+     *
+     * After Android 12, directly communicate with native daemon might not
+     * work since the native damon won't always stay alive.
+     * Use the NSD APIs from NsdManager as the replacement is recommended.
+     * An another alternative could be bundling your own mdns solutions instead of
+     * depending on the system mdns native daemon.
+     *
+     * @hide
+     */
+    @ChangeId
+    @EnabledSince(targetSdkVersion = android.os.Build.VERSION_CODES.S)
+    public static final long RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS = 191844585L;
+
+    /**
      * Broadcast intent action to indicate whether network service discovery is
      * enabled or disabled. An extra {@link #EXTRA_NSD_STATE} provides the state
      * information as int.
@@ -203,6 +224,9 @@ public final class NsdManager {
     public static final int DAEMON_CLEANUP                          = BASE + 21;
 
     /** @hide */
+    public static final int DAEMON_STARTUP                          = BASE + 22;
+
+    /** @hide */
     public static final int ENABLE                                  = BASE + 24;
     /** @hide */
     public static final int DISABLE                                 = BASE + 25;
@@ -232,6 +256,8 @@ public final class NsdManager {
         EVENT_NAMES.put(RESOLVE_SERVICE, "RESOLVE_SERVICE");
         EVENT_NAMES.put(RESOLVE_SERVICE_FAILED, "RESOLVE_SERVICE_FAILED");
         EVENT_NAMES.put(RESOLVE_SERVICE_SUCCEEDED, "RESOLVE_SERVICE_SUCCEEDED");
+        EVENT_NAMES.put(DAEMON_CLEANUP, "DAEMON_CLEANUP");
+        EVENT_NAMES.put(DAEMON_STARTUP, "DAEMON_STARTUP");
         EVENT_NAMES.put(ENABLE, "ENABLE");
         EVENT_NAMES.put(DISABLE, "DISABLE");
         EVENT_NAMES.put(NATIVE_DAEMON_EVENT, "NATIVE_DAEMON_EVENT");
@@ -494,6 +520,12 @@ public final class NsdManager {
         } catch (InterruptedException e) {
             fatal("Interrupted wait at init");
         }
+        if (CompatChanges.isChangeEnabled(RUN_NATIVE_NSD_ONLY_IF_LEGACY_APPS)) {
+            return;
+        }
+        // Only proactively start the daemon if the target SDK < S, otherwise the internal service
+        // would automatically start/stop the native daemon as needed.
+        mAsyncChannel.sendMessage(DAEMON_STARTUP);
     }
 
     private static void fatal(String msg) {
diff --git a/core/java/android/os/Debug.java b/core/java/android/os/Debug.java
index d90e129d36f7..b4930fa931eb 100644
--- a/core/java/android/os/Debug.java
+++ b/core/java/android/os/Debug.java
@@ -2599,11 +2599,11 @@ public final class Debug
     public static native long getIonPoolsSizeKb();
 
     /**
-     * Return GPU DMA buffer usage in kB or -1 on error.
+     * Returns the global total GPU-private memory in kB or -1 on error.
      *
      * @hide
      */
-    public static native long getGpuDmaBufUsageKb();
+    public static native long getGpuPrivateMemoryKb();
 
     /**
      * Return DMA-BUF memory mapped by processes in kB.
diff --git a/core/java/android/os/DropBoxManager.java b/core/java/android/os/DropBoxManager.java
index 575fc4c8931f..f38271aad867 100644
--- a/core/java/android/os/DropBoxManager.java
+++ b/core/java/android/os/DropBoxManager.java
@@ -72,7 +72,7 @@ public class DropBoxManager {
     /** Flag value: Content is human-readable UTF-8 text (can be combined with IS_GZIPPED). */
     public static final int IS_TEXT = 2;
 
-    /** Flag value: Content can be decompressed with {@link java.util.zip.GZIPOutputStream}. */
+    /** Flag value: Content can be decompressed with java.util.zip.GZIPOutputStream. */
     public static final int IS_GZIPPED = 4;
 
     /** Flag value for serialization only: Value is a byte array, not a file descriptor */
diff --git a/core/java/android/os/PerformanceHintManager.java b/core/java/android/os/PerformanceHintManager.java
index 6791844a2a00..a75b5ef6d65e 100644
--- a/core/java/android/os/PerformanceHintManager.java
+++ b/core/java/android/os/PerformanceHintManager.java
@@ -24,24 +24,23 @@ import android.content.Context;
 import com.android.internal.util.Preconditions;
 
 import java.io.Closeable;
-import java.util.ArrayList;
 
 /** The PerformanceHintManager allows apps to send performance hint to system. */
 @SystemService(Context.PERFORMANCE_HINT_SERVICE)
 public final class PerformanceHintManager {
-    private static final String TAG = "PerformanceHintManager";
-    private final IHintManager mService;
-    // HAL preferred update rate
-    private final long mPreferredRate;
+    private final long mNativeManagerPtr;
 
     /** @hide */
-    public PerformanceHintManager(IHintManager service) {
-        mService = service;
-        try {
-            mPreferredRate = mService.getHintSessionPreferredRate();
-        } catch (RemoteException e) {
-            throw e.rethrowFromSystemServer();
+    public static PerformanceHintManager create() throws ServiceManager.ServiceNotFoundException {
+        long nativeManagerPtr = nativeAcquireManager();
+        if (nativeManagerPtr == 0) {
+            throw new ServiceManager.ServiceNotFoundException(Context.PERFORMANCE_HINT_SERVICE);
         }
+        return new PerformanceHintManager(nativeManagerPtr);
+    }
+
+    private PerformanceHintManager(long nativeManagerPtr) {
+        mNativeManagerPtr = nativeManagerPtr;
     }
 
     /**
@@ -57,16 +56,13 @@ public final class PerformanceHintManager {
      */
     @Nullable
     public Session createHintSession(@NonNull int[] tids, long initialTargetWorkDurationNanos) {
-        try {
-            IBinder token = new Binder();
-            IHintSession session = mService.createHintSession(token, tids,
-                    initialTargetWorkDurationNanos);
-            if (session == null) return null;
-            return new Session(session, sNanoClock, mPreferredRate,
-                    initialTargetWorkDurationNanos);
-        } catch (RemoteException e) {
-            throw e.rethrowFromSystemServer();
-        }
+        Preconditions.checkNotNull(tids, "tids cannot be null");
+        Preconditions.checkArgumentPositive(initialTargetWorkDurationNanos,
+                "the hint target duration should be positive.");
+        long nativeSessionPtr = nativeCreateSession(mNativeManagerPtr, tids,
+                initialTargetWorkDurationNanos);
+        if (nativeSessionPtr == 0) return null;
+        return new Session(nativeSessionPtr);
     }
 
     /**
@@ -75,7 +71,7 @@ public final class PerformanceHintManager {
      * @return the preferred update rate supported by device software.
      */
     public long getPreferredUpdateRateNanos() {
-        return mPreferredRate;
+        return nativeGetPreferredUpdateRateNanos(mNativeManagerPtr);
     }
 
     /**
@@ -101,28 +97,21 @@ public final class PerformanceHintManager {
      * <p>All timings should be in {@link SystemClock#elapsedRealtimeNanos()}.</p>
      */
     public static class Session implements Closeable {
-        private final IHintSession mSession;
-        private final NanoClock mElapsedRealtimeClock;
-        // Target duration for choosing update rate
-        private long mTargetDurationInNanos;
-        // HAL preferred update rate
-        private long mPreferredRate;
-        // Last update timestamp
-        private long mLastUpdateTimeStamp = -1L;
-        // Cached samples
-        private final ArrayList<Long> mActualDurationNanos;
-        private final ArrayList<Long> mTimeStampNanos;
+        private long mNativeSessionPtr;
+
+        /** @hide */
+        public Session(long nativeSessionPtr) {
+            mNativeSessionPtr = nativeSessionPtr;
+        }
 
         /** @hide */
-        public Session(IHintSession session, NanoClock elapsedRealtimeClock, long preferredRate,
-                long durationNanos) {
-            mSession = session;
-            mElapsedRealtimeClock = elapsedRealtimeClock;
-            mTargetDurationInNanos = durationNanos;
-            mPreferredRate = preferredRate;
-            mActualDurationNanos = new ArrayList<Long>();
-            mTimeStampNanos = new ArrayList<Long>();
-            mLastUpdateTimeStamp = mElapsedRealtimeClock.nanos();
+        @Override
+        protected void finalize() throws Throwable {
+            try {
+                close();
+            } finally {
+                super.finalize();
+            }
         }
 
         /**
@@ -133,19 +122,7 @@ public final class PerformanceHintManager {
         public void updateTargetWorkDuration(long targetDurationNanos) {
             Preconditions.checkArgumentPositive(targetDurationNanos, "the hint target duration"
                     + " should be positive.");
-            try {
-                mSession.updateTargetWorkDuration(targetDurationNanos);
-            } catch (RemoteException e) {
-                throw e.rethrowFromSystemServer();
-            }
-            mTargetDurationInNanos = targetDurationNanos;
-            /**
-             * Most of the workload is target_duration dependent, so now clear the cached samples
-             * as they are most likely obsolete.
-             */
-            mActualDurationNanos.clear();
-            mTimeStampNanos.clear();
-            mLastUpdateTimeStamp = mElapsedRealtimeClock.nanos();
+            nativeUpdateTargetWorkDuration(mNativeSessionPtr, targetDurationNanos);
         }
 
         /**
@@ -161,38 +138,7 @@ public final class PerformanceHintManager {
         public void reportActualWorkDuration(long actualDurationNanos) {
             Preconditions.checkArgumentPositive(actualDurationNanos, "the actual duration should"
                     + " be positive.");
-            final long now = mElapsedRealtimeClock.nanos();
-            mActualDurationNanos.add(actualDurationNanos);
-            mTimeStampNanos.add(now);
-
-            /**
-             * Use current sample to determine the rate limit. We can pick a shorter rate limit
-             * if any sample underperformed, however, it could be the lower level system is slow
-             * to react. So here we explicitly choose the rate limit with the latest sample.
-             */
-            long rateLimit =
-                    actualDurationNanos > mTargetDurationInNanos ? mPreferredRate
-                            : 10 * mPreferredRate;
-
-            if (now - mLastUpdateTimeStamp <= rateLimit) {
-                return;
-            }
-            Preconditions.checkState(mActualDurationNanos.size() == mTimeStampNanos.size());
-            final int size = mActualDurationNanos.size();
-            long[] actualDurationArray = new long[size];
-            long[] timeStampArray = new long[size];
-            for (int i = 0; i < size; i++) {
-                actualDurationArray[i] = mActualDurationNanos.get(i);
-                timeStampArray[i] = mTimeStampNanos.get(i);
-            }
-            try {
-                mSession.reportActualWorkDuration(actualDurationArray, timeStampArray);
-            } catch (RemoteException e) {
-                throw e.rethrowFromSystemServer();
-            }
-            mActualDurationNanos.clear();
-            mTimeStampNanos.clear();
-            mLastUpdateTimeStamp = now;
+            nativeReportActualWorkDuration(mNativeSessionPtr, actualDurationNanos);
         }
 
         /**
@@ -201,26 +147,20 @@ public final class PerformanceHintManager {
          * <p>Once called, you should not call anything else on this object.</p>
          */
         public void close() {
-            try {
-                mSession.close();
-            } catch (RemoteException e) {
-                throw e.rethrowFromSystemServer();
+            if (mNativeSessionPtr != 0) {
+                nativeCloseSession(mNativeSessionPtr);
+                mNativeSessionPtr = 0;
             }
         }
     }
 
-    /**
-     * The interface is to make the FakeClock for testing.
-     * @hide
-     */
-    public interface NanoClock {
-        /** Gets the current nanosecond instant of the clock. */
-        long nanos();
-    }
-
-    private static final NanoClock sNanoClock = new NanoClock() {
-        public long nanos() {
-            return SystemClock.elapsedRealtimeNanos();
-        }
-    };
+    private static native long nativeAcquireManager();
+    private static native long nativeGetPreferredUpdateRateNanos(long nativeManagerPtr);
+    private static native long nativeCreateSession(long nativeManagerPtr,
+            int[] tids, long initialTargetWorkDurationNanos);
+    private static native void nativeUpdateTargetWorkDuration(long nativeSessionPtr,
+            long targetDurationNanos);
+    private static native void nativeReportActualWorkDuration(long nativeSessionPtr,
+            long actualDurationNanos);
+    private static native void nativeCloseSession(long nativeSessionPtr);
 }
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 75e334277ddb..636911c5bd15 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -9671,13 +9671,6 @@ public final class Settings {
         public static final String QS_AUTO_ADDED_TILES = "qs_auto_tiles";
 
         /**
-         * Whether the Lockdown button should be shown in the power menu.
-         * @hide
-         */
-        @Readable
-        public static final String LOCKDOWN_IN_POWER_MENU = "lockdown_in_power_menu";
-
-        /**
          * Backup manager behavioral parameters.
          * This is encoded as a key=value list, separated by commas. Ex:
          *
diff --git a/core/java/android/speech/RecognitionService.java b/core/java/android/speech/RecognitionService.java
index a6ec399e7d30..362ea8c87f7f 100644
--- a/core/java/android/speech/RecognitionService.java
+++ b/core/java/android/speech/RecognitionService.java
@@ -115,18 +115,14 @@ public abstract class RecognitionService extends Service {
             @NonNull AttributionSource attributionSource) {
         try {
             if (mCurrentCallback == null) {
-                Context attributionContext = createContext(new ContextParams.Builder()
-                        .setNextAttributionSource(attributionSource)
-                        .build());
                 boolean preflightPermissionCheckPassed = checkPermissionForPreflight(
-                        attributionContext.getAttributionSource());
+                        attributionSource);
                 if (preflightPermissionCheckPassed) {
                     if (DBG) {
                         Log.d(TAG, "created new mCurrentCallback, listener = "
                                 + listener.asBinder());
                     }
-                    mCurrentCallback = new Callback(listener, attributionSource,
-                            attributionContext);
+                    mCurrentCallback = new Callback(listener, attributionSource);
                     RecognitionService.this.onStartListening(intent, mCurrentCallback);
                 }
 
@@ -293,15 +289,8 @@ public abstract class RecognitionService extends Service {
 
         private Callback(IRecognitionListener listener,
                 @NonNull AttributionSource attributionSource) {
-            this(listener, attributionSource, null);
-        }
-
-        private Callback(IRecognitionListener listener,
-                @NonNull AttributionSource attributionSource,
-                @Nullable Context attributionContext) {
             mListener = listener;
             mCallingAttributionSource = attributionSource;
-            mAttributionContext = attributionContext;
         }
 
         /**
diff --git a/core/java/android/telephony/TelephonyRegistryManager.java b/core/java/android/telephony/TelephonyRegistryManager.java
index 4b18c5aae614..bedad7344e9d 100644
--- a/core/java/android/telephony/TelephonyRegistryManager.java
+++ b/core/java/android/telephony/TelephonyRegistryManager.java
@@ -111,7 +111,12 @@ public class TelephonyRegistryManager {
         IOnSubscriptionsChangedListener callback = new IOnSubscriptionsChangedListener.Stub() {
             @Override
             public void onSubscriptionsChanged () {
-                executor.execute(() -> listener.onSubscriptionsChanged());
+                final long identity = Binder.clearCallingIdentity();
+                try {
+                    executor.execute(() -> listener.onSubscriptionsChanged());
+                } finally {
+                    Binder.restoreCallingIdentity(identity);
+                }
             }
         };
         mSubscriptionChangedListenerMap.put(listener, callback);
diff --git a/core/java/android/view/SurfaceView.java b/core/java/android/view/SurfaceView.java
index 2cefcc9db40e..283a0a1b11fa 100644
--- a/core/java/android/view/SurfaceView.java
+++ b/core/java/android/view/SurfaceView.java
@@ -1101,7 +1101,8 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
             || mWindowSpaceTop != mLocation[1];
         final boolean layoutSizeChanged = getWidth() != mScreenRect.width()
             || getHeight() != mScreenRect.height();
-        final boolean hintChanged = viewRoot.getSurfaceTransformHint() != mTransformHint;
+        final boolean hintChanged = (viewRoot.getSurfaceTransformHint() != mTransformHint)
+                && mRequestedVisible;
 
         if (creating || formatChanged || sizeChanged || visibleChanged ||
                 (mUseAlpha && alphaChanged) || windowVisibleChanged ||
@@ -1247,7 +1248,9 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
             // Therefore, we must explicitly recreate the {@link Surface} in these
             // cases.
             if (mUseBlastAdapter) {
-                mSurface.transferFrom(mBlastBufferQueue.createSurfaceWithHandle());
+                if (mBlastBufferQueue != null) {
+                    mSurface.transferFrom(mBlastBufferQueue.createSurfaceWithHandle());
+                }
             } else {
                 mSurface.createFrom(mSurfaceControl);
             }
@@ -1257,7 +1260,10 @@ public class SurfaceView extends View implements ViewRootImpl.SurfaceChangedCall
     private void setBufferSize(Transaction transaction) {
         if (mUseBlastAdapter) {
             mBlastSurfaceControl.setTransformHint(mTransformHint);
-            mBlastBufferQueue.update(mBlastSurfaceControl, mSurfaceWidth, mSurfaceHeight, mFormat);
+            if (mBlastBufferQueue != null) {
+                mBlastBufferQueue.update(mBlastSurfaceControl, mSurfaceWidth, mSurfaceHeight,
+                        mFormat);
+            }
         } else {
             transaction.setBufferSize(mSurfaceControl, mSurfaceWidth, mSurfaceHeight);
         }
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 7ec26b674310..a48cafcf74bb 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -10079,9 +10079,11 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
                 }
                 AccessibilityNodeInfo cinfo = provider.createAccessibilityNodeInfo(
                         AccessibilityNodeInfo.getVirtualDescendantId(info.getChildId(i)));
-                ViewStructure child = structure.newChild(i);
-                populateVirtualStructure(child, provider, cinfo, forAutofill);
-                cinfo.recycle();
+                if (cinfo != null) {
+                    ViewStructure child = structure.newChild(i);
+                    populateVirtualStructure(child, provider, cinfo, forAutofill);
+                    cinfo.recycle();
+                }
             }
         }
     }
diff --git a/core/java/com/android/internal/jank/FrameTracker.java b/core/java/com/android/internal/jank/FrameTracker.java
index f28c42a10978..8e7fae7aa061 100644
--- a/core/java/com/android/internal/jank/FrameTracker.java
+++ b/core/java/com/android/internal/jank/FrameTracker.java
@@ -251,7 +251,7 @@ public class FrameTracker extends SurfaceControl.OnJankDataListener
         // 2. The session never begun.
         if (mBeginVsyncId == INVALID_ID) {
             cancel(REASON_CANCEL_NOT_BEGUN);
-        } else if (mEndVsyncId == mBeginVsyncId) {
+        } else if (mEndVsyncId <= mBeginVsyncId) {
             cancel(REASON_CANCEL_SAME_VSYNC);
         } else {
             if (DEBUG) {
diff --git a/core/java/com/android/internal/os/BatteryStatsImpl.java b/core/java/com/android/internal/os/BatteryStatsImpl.java
index a68a007dad56..8c63f38494ea 100644
--- a/core/java/com/android/internal/os/BatteryStatsImpl.java
+++ b/core/java/com/android/internal/os/BatteryStatsImpl.java
@@ -1106,8 +1106,9 @@ public class BatteryStatsImpl extends BatteryStats {
     @VisibleForTesting
     protected PowerProfile mPowerProfile;
 
+    @VisibleForTesting
     @GuardedBy("this")
-    final Constants mConstants;
+    protected final Constants mConstants;
 
     /*
      * Holds a SamplingTimer associated with each Resource Power Manager state and voter,
diff --git a/core/java/com/android/server/SystemConfig.java b/core/java/com/android/server/SystemConfig.java
index a8dcbaffeeb5..6cbace4c65ba 100644
--- a/core/java/com/android/server/SystemConfig.java
+++ b/core/java/com/android/server/SystemConfig.java
@@ -241,7 +241,11 @@ public class SystemConfig {
 
     private final ArraySet<String> mRollbackWhitelistedPackages = new ArraySet<>();
     private final ArraySet<String> mWhitelistedStagedInstallers = new ArraySet<>();
-    private final ArraySet<String> mAllowedVendorApexes = new ArraySet<>();
+    // A map from package name of vendor APEXes that can be updated to an installer package name
+    // allowed to install updates for it.
+    private final ArrayMap<String, String> mAllowedVendorApexes = new ArrayMap<>();
+
+    private String mModulesInstallerPackageName;
 
     /**
      * Map of system pre-defined, uniquely named actors; keys are namespace,
@@ -412,10 +416,14 @@ public class SystemConfig {
         return mWhitelistedStagedInstallers;
     }
 
-    public Set<String> getAllowedVendorApexes() {
+    public Map<String, String> getAllowedVendorApexes() {
         return mAllowedVendorApexes;
     }
 
+    public String getModulesInstallerPackageName() {
+        return mModulesInstallerPackageName;
+    }
+
     public ArraySet<String> getAppDataIsolationWhitelistedApps() {
         return mAppDataIsolationWhitelistedApps;
     }
@@ -1210,12 +1218,21 @@ public class SystemConfig {
                     case "whitelisted-staged-installer": {
                         if (allowAppConfigs) {
                             String pkgname = parser.getAttributeValue(null, "package");
+                            boolean isModulesInstaller = XmlUtils.readBooleanAttribute(
+                                    parser, "isModulesInstaller", false);
                             if (pkgname == null) {
                                 Slog.w(TAG, "<" + name + "> without package in " + permFile
                                         + " at " + parser.getPositionDescription());
                             } else {
                                 mWhitelistedStagedInstallers.add(pkgname);
                             }
+                            if (isModulesInstaller) {
+                                if (mModulesInstallerPackageName != null) {
+                                    throw new IllegalStateException(
+                                            "Multiple modules installers");
+                                }
+                                mModulesInstallerPackageName = pkgname;
+                            }
                         } else {
                             logNotAllowedInPartition(name, permFile, parser);
                         }
@@ -1224,11 +1241,18 @@ public class SystemConfig {
                     case "allowed-vendor-apex": {
                         if (allowVendorApex) {
                             String pkgName = parser.getAttributeValue(null, "package");
+                            String installerPkgName = parser.getAttributeValue(
+                                    null, "installerPackage");
                             if (pkgName == null) {
                                 Slog.w(TAG, "<" + name + "> without package in " + permFile
                                         + " at " + parser.getPositionDescription());
-                            } else {
-                                mAllowedVendorApexes.add(pkgName);
+                            }
+                            if (installerPkgName == null) {
+                                Slog.w(TAG, "<" + name + "> without installerPackage in " + permFile
+                                        + " at " + parser.getPositionDescription());
+                            }
+                            if (pkgName != null && installerPkgName != null) {
+                                mAllowedVendorApexes.put(pkgName, installerPkgName);
                             }
                         } else {
                             logNotAllowedInPartition(name, permFile, parser);