Some commit from Pixel experience tree

apex/jobscheduler/service/java/com/android/server/AppStateTrackerImpl.java

@@ -1165,6 +1165,9 @@ public boolean areAlarmsRestricted(int uid, @NonNull String packageName) {
             return false;
         }
         synchronized (mLock) {
+            if (isAppRestricted(uid, packageName)) {
+                return true;
+            }
             final int appId = UserHandle.getAppId(uid);
             if (ArrayUtils.contains(mPowerExemptAllAppIds, appId)) {
                 return false;
@@ -1210,6 +1213,9 @@ public boolean areJobsRestricted(int uid, @NonNull String packageName,
             return false;
         }
         synchronized (mLock) {
+            if (isAppRestricted(uid, packageName)) {
+                return true;
+            }
             final int appId = UserHandle.getAppId(uid);
             if (ArrayUtils.contains(mPowerExemptAllAppIds, appId)
                     || ArrayUtils.contains(mTempExemptAppIds, appId)) {
@@ -1332,6 +1338,15 @@ public boolean isUidTempPowerSaveExempt(int uid) {
         }
     }
 
+    /**
+     * @return whether the app is restricted battery usage
+     */
+    public boolean isAppRestricted(int uid, String packageName) {
+        return mAppOpsManager.checkOpNoThrow(
+                AppOpsManager.OP_RUN_ANY_IN_BACKGROUND,
+                uid, packageName) != AppOpsManager.MODE_ALLOWED;
+    }
+
     /**
      * Dump the internal state to the given PrintWriter. Can be included in the dump
      * of a binder service to be output on the shell command "dumpsys".

apex/jobscheduler/service/java/com/android/server/usage/AppStandbyController.java

@@ -1797,7 +1797,7 @@ private void setAppStandbyBucket(String packageName, int userId, @StandbyBuckets
                     // shouldn't be surprising.
                     // Exclude REASON_SUB_FORCED_USER_FLAG_INTERACTION since the RESTRICTED bucket
                     // isn't directly visible in that flow.
-                    if (Build.IS_DEBUGGABLE
+                    if (Build.IS_ENG
                             && (reason & REASON_SUB_MASK)
                             != REASON_SUB_FORCED_USER_FLAG_INTERACTION) {
                         Toast.makeText(mContext,

cmds/bootanimation/BootAnimation.cpp

@@ -67,7 +67,6 @@ namespace android {
 using ui::DisplayMode;
 
 static const char OEM_BOOTANIMATION_FILE[] = "/oem/media/bootanimation.zip";
-static const char PRODUCT_BOOTANIMATION_DARK_FILE[] = "/product/media/bootanimation-dark.zip";
 static const char PRODUCT_BOOTANIMATION_FILE[] = "/product/media/bootanimation.zip";
 static const char SYSTEM_BOOTANIMATION_FILE[] = "/system/media/bootanimation.zip";
 static const char APEX_BOOTANIMATION_FILE[] = "/apex/com.android.bootanimation/etc/bootanimation.zip";
@@ -107,6 +106,7 @@ static const char PROGRESS_PROP_NAME[] = "service.bootanim.progress";
 static const char DISPLAYS_PROP_NAME[] = "persist.service.bootanim.displays";
 static const char CLOCK_ENABLED_PROP_NAME[] = "persist.sys.bootanim.clock.enabled";
 static const int ANIM_ENTRY_NAME_MAX = ANIM_PATH_MAX + 1;
+static const int MAX_CHECK_EXIT_INTERVAL_US = 50000;
 static constexpr size_t TEXT_POS_LEN_MAX = 16;
 static const int DYNAMIC_COLOR_COUNT = 4;
 static const char U_TEXTURE[] = "uTexture";
@@ -741,9 +741,8 @@ void BootAnimation::findBootAnimationFile() {
         }
     }
 
-    const bool playDarkAnim = android::base::GetIntProperty("ro.boot.theme", 0) == 1;
     static const std::vector<std::string> bootFiles = {
-        APEX_BOOTANIMATION_FILE, playDarkAnim ? PRODUCT_BOOTANIMATION_DARK_FILE : PRODUCT_BOOTANIMATION_FILE,
+        APEX_BOOTANIMATION_FILE, PRODUCT_BOOTANIMATION_FILE,
         OEM_BOOTANIMATION_FILE, SYSTEM_BOOTANIMATION_FILE
     };
     static const std::vector<std::string> shutdownFiles = {
@@ -1691,7 +1690,17 @@ bool BootAnimation::playAnimation(const Animation& animation) {
                 checkExit();
             }
 
-            usleep(part.pause * ns2us(frameDuration));
+            int pauseDuration = part.pause * ns2us(frameDuration);
+            while(pauseDuration > 0 && !exitPending()){
+                if (pauseDuration > MAX_CHECK_EXIT_INTERVAL_US) {
+                    usleep(MAX_CHECK_EXIT_INTERVAL_US);
+                    pauseDuration -= MAX_CHECK_EXIT_INTERVAL_US;
+                } else {
+                    usleep(pauseDuration);
+                    break;
+                }
+                checkExit();
+            }
 
             if (exitPending() && !part.count && mCurrentInset >= mTargetInset &&
                 !part.hasFadingPhase()) {

core/api/current.txt

@@ -87,6 +87,7 @@ package android {
     field public static final String DUMP = "android.permission.DUMP";
     field public static final String EXPAND_STATUS_BAR = "android.permission.EXPAND_STATUS_BAR";
     field public static final String FACTORY_TEST = "android.permission.FACTORY_TEST";
+    field public static final String FAKE_PACKAGE_SIGNATURE = "android.permission.FAKE_PACKAGE_SIGNATURE";
     field public static final String FOREGROUND_SERVICE = "android.permission.FOREGROUND_SERVICE";
     field public static final String GET_ACCOUNTS = "android.permission.GET_ACCOUNTS";
     field public static final String GET_ACCOUNTS_PRIVILEGED = "android.permission.GET_ACCOUNTS_PRIVILEGED";
@@ -222,6 +223,7 @@ package android {
     field public static final String CALL_LOG = "android.permission-group.CALL_LOG";
     field public static final String CAMERA = "android.permission-group.CAMERA";
     field public static final String CONTACTS = "android.permission-group.CONTACTS";
+    field public static final String FAKE_PACKAGE_SIGNATURE = "android.permission-group.FAKE_PACKAGE_SIGNATURE";
     field public static final String LOCATION = "android.permission-group.LOCATION";
     field public static final String MICROPHONE = "android.permission-group.MICROPHONE";
     field public static final String NEARBY_DEVICES = "android.permission-group.NEARBY_DEVICES";

core/java/android/app/Activity.java

@@ -5954,6 +5954,12 @@ public void startActivity(Intent intent) {
      */
     @Override
     public void startActivity(Intent intent, @Nullable Bundle options) {
+        if (intent != null && intent.getComponent() != null){
+            if (intent.getComponent().flattenToString().equals("com.google.android.permissioncontroller/com.android.permissioncontroller.permission.ui.ManagePermissionsActivity")){
+                intent = intent.setComponent(
+                    ComponentName.unflattenFromString("com.android.permissioncontroller/com.android.permissioncontroller.permission.ui.ManagePermissionsActivity"));
+            }
+        }
         getAutofillClientController().onStartActivity(intent, mIntent);
         if (options != null) {
             startActivityForResult(intent, -1, options);

core/java/android/app/ActivityManagerInternal.java

@@ -691,6 +691,9 @@ public abstract PendingIntent getPendingIntentActivityAsApp(
      */
     public abstract @TempAllowListType int getPushMessagingOverQuotaBehavior();
 
+    // Starts a process as empty.
+    public abstract int startActivityAsUserEmpty(Bundle options);
+
     /**
      * Return the startForeground() grace period after calling startForegroundService().
      */

core/java/android/app/ActivityThread.java

@@ -160,6 +160,7 @@
 import android.telephony.TelephonyFrameworkInitializer;
 import android.util.AndroidRuntimeException;
 import android.util.ArrayMap;
+import android.util.BoostFramework;
 import android.util.DisplayMetrics;
 import android.util.EventLog;
 import android.util.Log;
@@ -3427,8 +3428,13 @@ public void updateProcessState(int processState, boolean fromIpc) {
             if (mLastProcessState == processState) {
                 return;
             }
+            // Do not issue a transitional GC if we are transitioning between 2 cached states.
+            // Only update if the state flips between cached and uncached or vice versa
+            if (ActivityManager.isProcStateCached(mLastProcessState)
+                    != ActivityManager.isProcStateCached(processState)) {
+                updateVmProcessState(processState);
+            }
             mLastProcessState = processState;
-            updateVmProcessState(processState);
             if (localLOGV) {
                 Slog.i(TAG, "******************* PROCESS STATE CHANGED TO: " + processState
                         + (fromIpc ? " (from ipc" : ""));
@@ -3437,12 +3443,16 @@ public void updateProcessState(int processState, boolean fromIpc) {
     }
 
     /** Update VM state based on ActivityManager.PROCESS_STATE_* constants. */
+    // Currently ART VM only uses state updates for Transitional GC, and thus
+    // this function initiates a Transitional GC for transitions into Cached apps states.
     private void updateVmProcessState(int processState) {
-        // TODO: Tune this since things like gmail sync are important background but not jank
-        // perceptible.
-        final int state = processState <= ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND
-                ? VM_PROCESS_STATE_JANK_PERCEPTIBLE
-                : VM_PROCESS_STATE_JANK_IMPERCEPTIBLE;
+        // Only a transition into Cached state should result in a Transitional GC request
+        // to the ART runtime. Update VM state to JANK_IMPERCEPTIBLE in that case.
+        // Note that there are 4 possible cached states currently, all of which are
+        // JANK_IMPERCEPTIBLE from GC point of view.
+        final int state = ActivityManager.isProcStateCached(processState)
+                ? VM_PROCESS_STATE_JANK_IMPERCEPTIBLE
+                : VM_PROCESS_STATE_JANK_PERCEPTIBLE;
         VMRuntime.getRuntime().updateProcessState(state);
     }
 
@@ -6494,6 +6504,8 @@ private String getInstrumentationLibrary(ApplicationInfo appInfo, Instrumentatio
 
     @UnsupportedAppUsage
     private void handleBindApplication(AppBindData data) {
+        long st_bindApp = SystemClock.uptimeMillis();
+        BoostFramework ux_perf = null;
         // Register the UI Thread as a sensitive thread to the runtime.
         VMRuntime.registerSensitiveThread();
         // In the case the stack depth property exists, pass it down to the runtime.
@@ -6612,10 +6624,17 @@ private void handleBindApplication(AppBindData data) {
         /**
          * Switch this process to density compatibility mode if needed.
          */
-        if ((data.appInfo.flags&ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES)
+        if ((data.appInfo.flags & ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES)
                 == 0) {
             mDensityCompatMode = true;
             Bitmap.setDefaultDensity(DisplayMetrics.DENSITY_DEFAULT);
+        } else {
+            int overrideDensity = data.appInfo.getOverrideDensity();
+            if(overrideDensity != 0) {
+                Log.d(TAG, "override app density from " + DisplayMetrics.DENSITY_DEVICE + " to " + overrideDensity);
+                mDensityCompatMode = true;
+                Bitmap.setDefaultDensity(overrideDensity);
+            }
         }
         mConfigurationController.updateDefaultDensity(data.config.densityDpi);
 
@@ -6713,6 +6732,15 @@ private void handleBindApplication(AppBindData data) {
             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
         }
 
+        if (!Process.isIsolated()) {
+            final int old_mask = StrictMode.allowThreadDiskWritesMask();
+            try {
+                ux_perf = new BoostFramework(appContext);
+            } finally {
+                 StrictMode.setThreadPolicyMask(old_mask);
+            }
+        }
+
         if (!Process.isIsolated()) {
             final int oldMask = StrictMode.allowThreadDiskWritesMask();
             try {
@@ -6839,6 +6867,33 @@ private void handleBindApplication(AppBindData data) {
                 throw e.rethrowFromSystemServer();
             }
         }
+        long end_bindApp = SystemClock.uptimeMillis();
+        int bindApp_dur = (int) (end_bindApp - st_bindApp);
+        String pkg_name = null;
+        if (appContext != null) {
+            pkg_name = appContext.getPackageName();
+        }
+        if (ux_perf != null && !Process.isIsolated() && pkg_name != null) {
+            String pkgDir = null;
+            try
+            {
+                String codePath = appContext.getPackageCodePath();
+                pkgDir =  codePath.substring(0, codePath.lastIndexOf('/'));
+            }
+            catch(Exception e)
+            {
+                Slog.e(TAG, "HeavyGameThread () : Exception_1 = " + e);
+            }
+            if (ux_perf.board_first_api_lvl < BoostFramework.VENDOR_T_API_LEVEL &&
+                ux_perf.board_api_lvl < BoostFramework.VENDOR_T_API_LEVEL) {
+                ux_perf.perfUXEngine_events(BoostFramework.UXE_EVENT_BINDAPP, 0,
+                                               pkg_name,
+                                               bindApp_dur,
+                                               pkgDir);
+            } else {
+                ux_perf.perfEvent(BoostFramework.VENDOR_HINT_BINDAPP, pkg_name, 2, bindApp_dur, 0);
+            }
+        }
     }
 
     private void handleSetContentCaptureOptionsCallback(String packageName) {
@@ -7082,11 +7137,6 @@ public final IContentProvider acquireProvider(
             }
         }
         if (holder == null) {
-            if (UserManager.get(c).isUserUnlocked(userId)) {
-                Slog.e(TAG, "Failed to find provider info for " + auth);
-            } else {
-                Slog.w(TAG, "Failed to find provider info for " + auth + " (user not unlocked)");
-            }
             return null;
         }
 

core/java/android/app/AppLockData.aidl

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2022 FlamingoOS 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.app;
+
+parcelable AppLockData;

core/java/android/app/AppLockData.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2022 FlamingoOS 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.app;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * Class to hold package level information about an
+ * application for app lock.
+ *
+ * @hide
+ */
+public final class AppLockData implements Parcelable {
+
+    public static final Parcelable.Creator<AppLockData> CREATOR =
+            new Parcelable.Creator<AppLockData>() {
+
+        @Override
+        public AppLockData createFromParcel(Parcel in) {
+            return new AppLockData(in);
+        }
+
+        @Override
+        public AppLockData[] newArray(int size) {
+            return new AppLockData[size];
+        }
+    };
+
+    private final String mPackageName;
+    private final boolean mShouldProtectApp;
+    private final boolean mShouldRedactNotification;
+    private final boolean mHideFromLauncher;
+
+    /** @hide */
+    public AppLockData(
+        @NonNull final String packageName,
+        final boolean shouldProtectApp,
+        final boolean shouldRedactNotification,
+        final boolean hideFromLauncher
+    ) {
+        mPackageName = packageName;
+        mShouldProtectApp = shouldProtectApp;
+        mShouldRedactNotification = shouldRedactNotification;
+        mHideFromLauncher = hideFromLauncher;
+    }
+
+    private AppLockData(final Parcel in) {
+        mPackageName = in.readString();
+        mShouldProtectApp = in.readBoolean();
+        mShouldRedactNotification = in.readBoolean();
+        mHideFromLauncher = in.readBoolean();
+    }
+
+    @NonNull
+    public String getPackageName() {
+        return mPackageName;
+    }
+
+    public boolean getShouldProtectApp() {
+        return mShouldProtectApp;
+    }
+
+    public boolean getShouldRedactNotification() {
+        return mShouldRedactNotification;
+    }
+
+    public boolean getHideFromLauncher() {
+        return mHideFromLauncher;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(final Parcel parcel, final int flags) {
+        parcel.writeString(mPackageName);
+        parcel.writeBoolean(mShouldProtectApp);
+        parcel.writeBoolean(mShouldRedactNotification);
+        parcel.writeBoolean(mHideFromLauncher);
+    }
+
+    @Override
+    @NonNull
+    public String toString() {
+        return "AppLockData[ packageName = " + mPackageName +
+            ", shouldProtectApp = " + mShouldProtectApp +
+            ", shouldRedactNotification = " + mShouldRedactNotification +
+            ", hideFromLauncher = " + mHideFromLauncher + " ]";
+    }
+}