Make change and version bump to r_aml_300900200 for mainline module file: packages/Tethering/apex/manifest.json

Change-Id: Ic32f7f6c83b8bc61d3ef93c03857ea205c6b0dbe

15 files changed, 63 insertions, 56 deletions

diff --git a/apex/Android.bp b/apex/Android.bp
index 371bd7fc9479..992648b04ef0 100644
--- a/apex/Android.bp
+++ b/apex/Android.bp
@@ -94,10 +94,8 @@ java_defaults {
 
     annotations_enabled: true,
 
-    // The stub libraries must be visible to frameworks/base so they can be combined
-    // into API specific libraries.
     stubs_library_visibility: [
-        "//frameworks/base", // Framework
+        "//visibility:public",
     ],
 
     // Set the visibility of the modules creating the stubs source.
diff --git a/apex/extservices/apex_manifest.json b/apex/extservices/apex_manifest.json
index c59bc4c549a6..b64409fc93c4 100644
--- a/apex/extservices/apex_manifest.json
+++ b/apex/extservices/apex_manifest.json
@@ -1,4 +1,4 @@
 {
   "name": "com.android.extservices",
-  "version": 300900100
+  "version": 300900200
 }
diff --git a/apex/media/framework/java/android/media/MediaSession2.java b/apex/media/framework/java/android/media/MediaSession2.java
index 081e76ab0215..6560afedab0f 100644
--- a/apex/media/framework/java/android/media/MediaSession2.java
+++ b/apex/media/framework/java/android/media/MediaSession2.java
@@ -404,7 +404,7 @@ public class MediaSession2 implements AutoCloseable {
                 mCallback.onPostConnect(MediaSession2.this, controllerInfo);
                 connected = true;
             } finally {
-                if (!connected) {
+                if (!connected || isClosed()) {
                     if (DEBUG) {
                         Log.d(TAG, "Rejecting connection or notifying that session is closed"
                                 + ", controllerInfo=" + controllerInfo);
diff --git a/apex/permission/apex_manifest.json b/apex/permission/apex_manifest.json
index d08ca8a47e2f..dc8972d49ab5 100644
--- a/apex/permission/apex_manifest.json
+++ b/apex/permission/apex_manifest.json
@@ -1,4 +1,4 @@
 {
   "name": "com.android.permission",
-  "version": 300900100
+  "version": 300900200
 }
diff --git a/apex/statsd/apex_manifest.json b/apex/statsd/apex_manifest.json
index 06848fefe1f9..37e3e92ce630 100644
--- a/apex/statsd/apex_manifest.json
+++ b/apex/statsd/apex_manifest.json
@@ -1,5 +1,5 @@
 {
   "name": "com.android.os.statsd",
-  "version": 300900100
+  "version": 300900200
 }
 
diff --git a/core/java/android/view/WindowManager.java b/core/java/android/view/WindowManager.java
index 76071278edf8..5c6269421a1f 100644
--- a/core/java/android/view/WindowManager.java
+++ b/core/java/android/view/WindowManager.java
@@ -1454,11 +1454,22 @@ public interface WindowManager extends ViewManager {
         @Deprecated
         public static final int FLAG_LAYOUT_INSET_DECOR = 0x00010000;
 
-        /** Window flag: When set, input method can't interact with the focusable window
-         * and can be placed to use more space and cover the input method.
-         * Note: When combined with {@link #FLAG_NOT_FOCUSABLE}, this flag has no
-         * effect since input method cannot interact with windows having {@link #FLAG_NOT_FOCUSABLE}
-         * flag set.
+        /** Window flag: when set, inverts the input method focusability of the window.
+         *
+         * The effect of setting this flag depends on whether {@link #FLAG_NOT_FOCUSABLE} is set:
+         * <p>
+         * If {@link #FLAG_NOT_FOCUSABLE} is <em>not</em> set, i.e. when the window is focusable,
+         * setting this flag prevents this window from becoming the target of the input method.
+         * Consequently, it will <em>not</em> be able to interact with the input method,
+         * and will be layered above the input method (unless there is another input method
+         * target above it).
+         *
+         * <p>
+         * If {@link #FLAG_NOT_FOCUSABLE} <em>is</em> set, setting this flag requests for the window
+         * to be the input method target even though  the window is <em>not</em> focusable.
+         * Consequently, it will be layered below the input method.
+         * Note: Windows that set {@link #FLAG_NOT_FOCUSABLE} cannot interact with the input method,
+         * regardless of this flag.
          */
         public static final int FLAG_ALT_FOCUSABLE_IM = 0x00020000;
 
@@ -2142,13 +2153,12 @@ public interface WindowManager extends ViewManager {
          * focus.  In particular, this checks the
          * {@link #FLAG_NOT_FOCUSABLE} and {@link #FLAG_ALT_FOCUSABLE_IM}
          * flags and returns true if the combination of the two corresponds
-         * to a window that needs to be behind the input method so that the
-         * user can type into it.
+         * to a window that can use the input method.
          *
          * @param flags The current window manager flags.
          *
-         * @return Returns {@code true} if such a window should be behind/interact
-         * with an input method, {@code false} if not.
+         * @return Returns {@code true} if a window with the given flags would be able to
+         * use the input method, {@code false} if not.
          */
         public static boolean mayUseInputMethod(int flags) {
             return (flags & FLAG_NOT_FOCUSABLE) != FLAG_NOT_FOCUSABLE
diff --git a/packages/Tethering/apex/manifest.json b/packages/Tethering/apex/manifest.json
index 9ec7abdcc6e3..60be19b88b13 100644
--- a/packages/Tethering/apex/manifest.json
+++ b/packages/Tethering/apex/manifest.json
@@ -1,4 +1,4 @@
 {
   "name": "com.android.tethering",
-  "version": 300900100
+  "version": 300900200
 }
diff --git a/services/core/java/com/android/server/StorageManagerService.java b/services/core/java/com/android/server/StorageManagerService.java
index 6e8eca3f46cf..678387c540ed 100644
--- a/services/core/java/com/android/server/StorageManagerService.java
+++ b/services/core/java/com/android/server/StorageManagerService.java
@@ -4736,7 +4736,7 @@ class StorageManagerService extends IStorageManager.Stub
             return true;
         }
 
-        private void killAppForOpChange(int code, int uid, String packageName) {
+        private void killAppForOpChange(int code, int uid) {
             final IActivityManager am = ActivityManager.getService();
             try {
                 am.killUid(UserHandle.getAppId(uid), UserHandle.USER_ALL,
@@ -4753,7 +4753,7 @@ class StorageManagerService extends IStorageManager.Stub
                     switch(code) {
                         case OP_REQUEST_INSTALL_PACKAGES:
                             // Always kill regardless of op change, to remount apps /storage
-                            killAppForOpChange(code, uid, packageName);
+                            killAppForOpChange(code, uid);
                             return;
                         case OP_MANAGE_EXTERNAL_STORAGE:
                             if (mode != MODE_ALLOWED) {
@@ -4762,12 +4762,7 @@ class StorageManagerService extends IStorageManager.Stub
                                 // results in a bad UX, especially since the gid only gives access
                                 // to unreliable volumes, USB OTGs that are rarely mounted. The app
                                 // will get the external_storage gid on next organic restart.
-                                if (packageName != null) {
-                                    killAppForOpChange(code, uid, packageName);
-                                } else {
-                                    // TODO(b/158283222) this can happen, figure out if we need
-                                    // to kill in this case as well.
-                                }
+                                killAppForOpChange(code, uid);
                             }
                             return;
                         case OP_LEGACY_STORAGE:
diff --git a/services/core/java/com/android/server/media/MediaSessionService.java b/services/core/java/com/android/server/media/MediaSessionService.java
index b45d450cd200..9b356f0e8eef 100644
--- a/services/core/java/com/android/server/media/MediaSessionService.java
+++ b/services/core/java/com/android/server/media/MediaSessionService.java
@@ -2099,7 +2099,7 @@ public class MediaSessionService extends SystemService implements Monitor {
                 boolean asSystemService, KeyEvent keyEvent, boolean needWakeLock) {
             if (mCurrentFullUserRecord.getMediaButtonSessionLocked()
                     instanceof MediaSession2Record) {
-                // TODO(jaewan): Implement
+                // TODO(jaewan): Make MediaSession2 to receive media key event
                 return;
             }
             MediaSessionRecord session = null;
diff --git a/services/core/java/com/android/server/media/MediaSessionStack.java b/services/core/java/com/android/server/media/MediaSessionStack.java
index 402355a0161a..b678c8962a21 100644
--- a/services/core/java/com/android/server/media/MediaSessionStack.java
+++ b/services/core/java/com/android/server/media/MediaSessionStack.java
@@ -244,6 +244,10 @@ class MediaSessionStack {
     private MediaSessionRecordImpl findMediaButtonSession(int uid) {
         MediaSessionRecordImpl mediaButtonSession = null;
         for (MediaSessionRecordImpl session : mSessions) {
+            if (session instanceof MediaSession2Record) {
+                // TODO(jaewan): Make MediaSession2 to receive media key event
+                continue;
+            }
             if (uid == session.getUid()) {
                 if (session.checkPlaybackActiveState(
                         mAudioPlayerStateMonitor.isPlaybackActive(session.getUid()))) {
diff --git a/services/core/java/com/android/server/uri/UriGrantsManagerService.java b/services/core/java/com/android/server/uri/UriGrantsManagerService.java
index 5f6323369d0a..c38d649ada9b 100644
--- a/services/core/java/com/android/server/uri/UriGrantsManagerService.java
+++ b/services/core/java/com/android/server/uri/UriGrantsManagerService.java
@@ -115,7 +115,7 @@ public class UriGrantsManagerService extends IUriGrantsManager.Stub {
     private static final String TAG = "UriGrantsManagerService";
     // Maximum number of persisted Uri grants a package is allowed
     private static final int MAX_PERSISTED_URI_GRANTS = 128;
-    private static final boolean ENABLE_DYNAMIC_PERMISSIONS = true;
+    private static final boolean ENABLE_DYNAMIC_PERMISSIONS = false;
 
     private final Object mLock = new Object();
     private final H mH;
diff --git a/services/core/java/com/android/server/wm/TaskSnapshotController.java b/services/core/java/com/android/server/wm/TaskSnapshotController.java
index 51cf858715b4..c2021303c11c 100644
--- a/services/core/java/com/android/server/wm/TaskSnapshotController.java
+++ b/services/core/java/com/android/server/wm/TaskSnapshotController.java
@@ -40,6 +40,7 @@ import android.util.ArraySet;
 import android.util.Slog;
 import android.view.InsetsSource;
 import android.view.InsetsState;
+import android.view.InsetsState.InternalInsetsType;
 import android.view.SurfaceControl;
 import android.view.ThreadedRenderer;
 import android.view.WindowInsets;
@@ -480,7 +481,9 @@ class TaskSnapshotController {
                 task.getTaskDescription().getBackgroundColor(), 255);
         final LayoutParams attrs = mainWindow.getAttrs();
         final InsetsPolicy insetsPolicy = mainWindow.getDisplayContent().getInsetsPolicy();
-        final InsetsState insetsState = insetsPolicy.getInsetsForDispatch(mainWindow);
+        final InsetsState insetsState =
+                new InsetsState(insetsPolicy.getInsetsForDispatch(mainWindow));
+        mergeInsetsSources(insetsState, mainWindow.getRequestedInsetsState());
         final Rect systemBarInsets = getSystemBarInsets(mainWindow.getFrameLw(), insetsState);
         final SystemBarBackgroundPainter decorPainter = new SystemBarBackgroundPainter(attrs.flags,
                 attrs.privateFlags, attrs.systemUiVisibility, task.getTaskDescription(),
@@ -600,6 +603,15 @@ class TaskSnapshotController {
         return 0;
     }
 
+    static void mergeInsetsSources(InsetsState base, InsetsState other) {
+        for (@InternalInsetsType int type = 0; type < InsetsState.SIZE; type++) {
+            final InsetsSource source = other.peekSource(type);
+            if (source != null) {
+                base.addSource(source);
+            }
+        }
+    }
+
     static Rect getSystemBarInsets(Rect frame, InsetsState state) {
         return state.calculateInsets(frame, null /* ignoringVisibilityState */,
                 false /* isScreenRound */, false /* alwaysConsumeSystemBars */,
diff --git a/services/core/java/com/android/server/wm/TaskSnapshotSurface.java b/services/core/java/com/android/server/wm/TaskSnapshotSurface.java
index 3fc09c93550c..448b4aae7a88 100644
--- a/services/core/java/com/android/server/wm/TaskSnapshotSurface.java
+++ b/services/core/java/com/android/server/wm/TaskSnapshotSurface.java
@@ -42,6 +42,7 @@ import static com.android.internal.policy.DecorView.STATUS_BAR_COLOR_VIEW_ATTRIB
 import static com.android.internal.policy.DecorView.getNavigationBarRect;
 import static com.android.server.wm.ProtoLogGroup.WM_DEBUG_STARTING_WINDOW;
 import static com.android.server.wm.TaskSnapshotController.getSystemBarInsets;
+import static com.android.server.wm.TaskSnapshotController.mergeInsetsSources;
 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME;
 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM;
 
@@ -243,7 +244,9 @@ class TaskSnapshotSurface implements StartingSurface {
 
             final InsetsPolicy insetsPolicy = topFullscreenOpaqueWindow.getDisplayContent()
                     .getInsetsPolicy();
-            insetsState = insetsPolicy.getInsetsForDispatch(topFullscreenOpaqueWindow);
+            insetsState =
+                    new InsetsState(insetsPolicy.getInsetsForDispatch(topFullscreenOpaqueWindow));
+            mergeInsetsSources(insetsState, topFullscreenOpaqueWindow.getRequestedInsetsState());
         }
         try {
             final int res = session.addToDisplay(window, window.mSeq, layoutParams,
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index d4d2f4d7a492..b65020d7eaa6 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -2394,12 +2394,15 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP
         if (mAttrs.type == TYPE_APPLICATION_STARTING) {
             // Ignore mayUseInputMethod for starting window for now.
             // TODO(b/159911356): Remove this special casing (originally added in commit e75d872).
-        } else if (PixelFormat.formatHasAlpha(mAttrs.format)) {
-            // Support legacy use cases where transparent windows can still be ime target with
-            // FLAG_NOT_FOCUSABLE and ALT_FOCUSABLE_IM set.
-            // Certain apps listen for IME insets using transparent windows and ADJUST_NOTHING to
-            // manually synchronize app content to IME animation b/144619551.
-            // TODO(b/145812508): remove this once new focus management is complete b/141738570
+        } else {
+            // TODO(b/145812508): Clean this up in S, may depend on b/141738570
+            //  The current logic lets windows become the "ime target" even though they are
+            //  not-focusable and can thus never actually start input.
+            //  Ideally, this would reject windows where mayUseInputMethod() == false, but this
+            //  also impacts Z-ordering of and delivery of IME insets to child windows, which means
+            //  that simply disallowing non-focusable windows would break apps.
+            //  See b/159438771, b/144619551.
+
             final int fl = mAttrs.flags & (FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM);
 
             // Can only be an IME target if both FLAG_NOT_FOCUSABLE and FLAG_ALT_FOCUSABLE_IM are
@@ -2407,12 +2410,6 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP
             if (fl != 0 && fl != (FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM)) {
                 return false;
             }
-        } else if (!WindowManager.LayoutParams.mayUseInputMethod(mAttrs.flags)) {
-            // Can be an IME target only if:
-            // 1. FLAG_NOT_FOCUSABLE is not set
-            // 2. FLAG_ALT_FOCUSABLE_IM is not set
-            // 3. not a starting window.
-            return false;
         }
 
         if (DEBUG_INPUT_METHOD) {
diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
index 4a0f48cf2ccb..360d73b5bd87 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
@@ -67,7 +67,6 @@ import static org.mockito.Mockito.when;
 
 import android.graphics.Insets;
 import android.graphics.Matrix;
-import android.graphics.PixelFormat;
 import android.graphics.Rect;
 import android.os.RemoteException;
 import android.platform.test.annotations.Presubmit;
@@ -229,21 +228,10 @@ public class WindowStateTests extends WindowTestsBase {
         appWindow.mAttrs.flags |= (FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM);
         imeWindow.mAttrs.flags |= (FLAG_NOT_FOCUSABLE | FLAG_ALT_FOCUSABLE_IM);
 
-        // Visible app window with flags FLAG_NOT_FOCUSABLE or FLAG_ALT_FOCUSABLE_IM can't be IME
-        // target while an IME window can never be an IME target regardless of its visibility
-        // or flags.
-        assertFalse(appWindow.canBeImeTarget());
-        assertFalse(imeWindow.canBeImeTarget());
-
-        // b/145812508: special legacy use-case for transparent/translucent windows.
-        appWindow.mAttrs.format = PixelFormat.TRANSPARENT;
-        assertTrue(appWindow.canBeImeTarget());
-
-        appWindow.mAttrs.format = PixelFormat.OPAQUE;
-        appWindow.mAttrs.flags &= ~FLAG_ALT_FOCUSABLE_IM;
-        assertFalse(appWindow.canBeImeTarget());
-        appWindow.mAttrs.flags &= ~FLAG_NOT_FOCUSABLE;
+        // Visible app window with flags can be IME target while an IME window can never be an IME
+        // target regardless of its visibility or flags.
         assertTrue(appWindow.canBeImeTarget());
+        assertFalse(imeWindow.canBeImeTarget());
 
         // Verify PINNED windows can't be IME target.
         int initialMode = appWindow.mActivityRecord.getWindowingMode();