New Crowdin updates

apex/jobscheduler/service/java/com/android/server/job/JobServiceContext.java

@@ -1485,9 +1485,11 @@ void handleOpTimeoutLocked() {
                     } else {
                         Slog.i(TAG, "JS was waiting to stop this job."
                                 + " Sending onStop: " + getRunningJobNameLocked());
-                        mParams.setStopReason(mPendingStopReason, mPendingInternalStopReason,
-                                mPendingDebugStopReason);
-                        sendStopMessageLocked(mPendingDebugStopReason);
+                        if (mParams != null) {
+                            mParams.setStopReason(mPendingStopReason, mPendingInternalStopReason,
+                                    mPendingDebugStopReason);
+                            sendStopMessageLocked(mPendingDebugStopReason);
+                        }
                         mAnrTimer.discard();
                         break;
                     }

core/java/android/content/res/AssetManager.java

@@ -971,8 +971,14 @@ public boolean containsAllocatedTable() {
 
     @Nullable
     CharSequence getPooledStringForCookie(int cookie, int id) {
-        // Cookies map to ApkAssets starting at 1.
-        return getApkAssets()[cookie - 1].getStringFromPool(id);
+        ApkAssets[] apkAssets = getApkAssets();
+
+        if (cookie > 0 && cookie <= apkAssets.length) {
+            // map cookies starting at 1.
+            return apkAssets[cookie - 1].getStringFromPool(id);
+        }
+
+        return null;
     }
 
     /**

core/java/android/os/Process.java

@@ -1519,6 +1519,31 @@ public static final void killProcessQuiet(int pid) {
         sendSignalQuiet(pid, SIGNAL_KILL);
     }
 
+    /**
+     * @hide
+     * PID-reuse-safe variant of {@link #killProcessQuiet(int)} backed by
+     * pidfd_open + pidfd_send_signal. Pass {@code expectedUid < 0} to skip
+     * the uid check. Falls back to the legacy path on kernels without pidfd.
+     */
+    public static final void killProcessByPidfdQuiet(int pid, int expectedUid) {
+        if (pid <= 0) {
+            return;
+        }
+        if (supportsPidFd()) {
+            int rc = nativeKillProcessByPidfdQuiet(pid, SIGNAL_KILL, expectedUid);
+            if (rc >= 0) {
+                return;
+            }
+        }
+        // Fallback: re-check uid via /proc to avoid killing a recycled pid.
+        if (expectedUid >= 0 && getUidForPid(pid) != expectedUid) {
+            return;
+        }
+        sendSignalQuiet(pid, SIGNAL_KILL);
+    }
+
+    private static native int nativeKillProcessByPidfdQuiet(int pid, int signal, int expectedUid);
+
     /**
      * @hide
      * Private impl for avoiding a log message...  DO NOT USE without doing

core/java/android/provider/Settings.java

@@ -7032,6 +7032,13 @@ public static void setShowGTalkServiceStatusForUser(ContentResolver cr, boolean
          */
         public static final String DOZE_TRIGGER_DOUBLETAP = "doze_trigger_doubletap";
 
+        /**
+         * Whether to control brightness from status bar on lockscreen
+         * 0 = 0ff, 1 = on
+         * @hide
+         */
+        public static final String STATUS_BAR_BRIGHTNESS_CONTROL_LOCKSCREEN = "status_bar_brightness_control_lockscreen";
+
         /**
          * Whether to enable smart 5G mode
          * @hide
@@ -7374,6 +7381,13 @@ public static void setShowGTalkServiceStatusForUser(ContentResolver cr, boolean
          */
         public static final String FORCE_FULLSCREEN_CUTOUT_APPS = "force_full_screen_cutout_apps";
 
+        /**
+         * Whether to control brightness from status bar
+         * 0 = 0ff, 1 = on
+         * @hide
+         */
+        public static final String STATUS_BAR_BRIGHTNESS_CONTROL = "status_bar_brightness_control";
+
         /**
          * Keys we no longer back up under the current schema, but want to continue to
          * process when restoring historical backup datasets.

core/java/android/util/EventLog.java

@@ -334,16 +334,20 @@ public int hashCode() {
         }
     }
 
-    // We assume that the native methods deal with any concurrency issues.
-
     /**
      * Record an event log message.
      * @param tag The event type tag code
      * @param value A value to log
      * @return The number of bytes written
      */
     @RavenwoodRedirect
-    public static native int writeEvent(int tag, int value);
+    public static int writeEvent(int tag, int value) {
+        if (!Build.IS_ENG) {
+            return 0;
+        }
+
+        return nativeWriteEvent(tag, value);
+    }
 
     /**
      * Record an event log message.
@@ -352,7 +356,13 @@ public int hashCode() {
      * @return The number of bytes written
      */
     @RavenwoodRedirect
-    public static native int writeEvent(int tag, long value);
+    public static int writeEvent(int tag, long value) {
+        if (!Build.IS_ENG) {
+            return 0;
+        }
+
+        return nativeWriteEvent(tag, value);
+    }
 
     /**
      * Record an event log message.
@@ -361,7 +371,13 @@ public int hashCode() {
      * @return The number of bytes written
      */
     @RavenwoodRedirect
-    public static native int writeEvent(int tag, float value);
+    public static int writeEvent(int tag, float value) {
+        if (!Build.IS_ENG) {
+            return 0;
+        }
+
+        return nativeWriteEvent(tag, value);
+    }
 
     /**
      * Record an event log message.
@@ -370,7 +386,13 @@ public int hashCode() {
      * @return The number of bytes written
      */
     @RavenwoodRedirect
-    public static native int writeEvent(int tag, String str);
+    public static int writeEvent(int tag, String str) {
+        if (!Build.IS_ENG) {
+            return 0;
+        }
+
+        return nativeWriteEvent(tag, str);
+    }
 
     /**
      * Record an event log message.
@@ -379,7 +401,13 @@ public int hashCode() {
      * @return The number of bytes written
      */
     @RavenwoodRedirect
-    public static native int writeEvent(int tag, Object... list);
+    public static int writeEvent(int tag, Object... list) {
+        if (!Build.IS_ENG) {
+            return 0;
+        }
+
+        return nativeWriteEvent(tag, list);
+    }
 
     /**
      * Read events from the log, filtered by type.
@@ -388,8 +416,14 @@ public int hashCode() {
      * @throws IOException if something goes wrong reading events
      */
     @RavenwoodThrow
-    public static native void readEvents(int[] tags, Collection<Event> output)
-            throws IOException;
+    public static void readEvents(int[] tags, Collection<Event> output)
+            throws IOException {
+        if (!Build.IS_ENG) {
+            return;
+        }
+
+        nativeReadEvents(tags, output);
+    }
 
     /**
      * Read events from the log, filtered by type, blocking until logs are about to be overwritten.
@@ -401,7 +435,27 @@ public static native void readEvents(int[] tags, Collection<Event> output)
      */
     @SystemApi
     @RavenwoodThrow
-    public static native void readEventsOnWrapping(int[] tags, long timestamp,
+    public static void readEventsOnWrapping(int[] tags, long timestamp,
+            Collection<Event> output)
+            throws IOException {
+        if (!Build.IS_ENG) {
+            return;
+        }
+
+        nativeReadEventsOnWrapping(tags, timestamp, output);
+    }
+
+    // We assume that the native methods deal with any concurrency issues.
+
+    private static native int nativeWriteEvent(int tag, int value);
+    private static native int nativeWriteEvent(int tag, long value);
+    private static native int nativeWriteEvent(int tag, float value);
+    private static native int nativeWriteEvent(int tag, String str);
+    private static native int nativeWriteEvent(int tag, Object... list);
+
+    private static native void nativeReadEvents(int[] tags, Collection<Event> output)
+            throws IOException;
+    private static native void nativeReadEventsOnWrapping(int[] tags, long timestamp,
             Collection<Event> output)
             throws IOException;
 

core/java/android/view/Choreographer.java

@@ -1198,8 +1198,10 @@ void doFrame(long frameTimeNanos, int frame,
 
     void doCallbacks(int callbackType, long frameIntervalNanos) {
         CallbackRecord callbacks;
-        long frameTimeNanos = mFrameData.mFrameTimeNanos;
         synchronized (mLock) {
+            if (mCallbackQueues[callbackType].mHead == null) {
+                return;
+            }
             // We use "now" to determine when callbacks become due because it's possible
             // for earlier processing phases in a frame to post callbacks that should run
             // in a following phase, such as an input event that causes an animation to start.
@@ -1219,6 +1221,7 @@ void doCallbacks(int callbackType, long frameIntervalNanos) {
             // or equal to the previous frame's commit frame time.  Keep in mind that the
             // next frame has most likely already been scheduled by now so we play it
             // safe by ensuring the commit time is always at least one frame behind.
+            long frameTimeNanos = mFrameData.mFrameTimeNanos;
             if (callbackType == Choreographer.CALLBACK_COMMIT) {
                 final long jitterNanos = now - frameTimeNanos;
                 Trace.traceCounter(Trace.TRACE_TAG_VIEW, "jitterNanos", (int) jitterNanos);

core/java/com/android/internal/util/FileRotator.java

@@ -334,7 +334,15 @@ private String getActiveName(long currentTimeMillis) {
         long oldestActiveStart = Long.MAX_VALUE;
 
         final FileInfo info = new FileInfo(mPrefix);
-        for (String name : mBasePath.list()) {
+        String[] baseFiles = mBasePath.list();
+        if (baseFiles == null) {
+            // no file in the path and create one starting now
+            info.startMillis = currentTimeMillis;
+            info.endMillis = Long.MAX_VALUE;
+            return info.build();
+        }
+
+        for (String name : baseFiles) {
             if (!info.parse(name)) continue;
 
             // pick the oldest active file which covers current time

core/jni/android_util_EventLog.cpp

@@ -68,16 +68,16 @@ static void android_util_EventLog_readEventsOnWrapping(JNIEnv* env, jobject claz
  */
 static const JNINativeMethod gRegisterMethods[] = {
     /* name, signature, funcPtr */
-    { "writeEvent", "(II)I", (void*) ELog::writeEventInteger },
-    { "writeEvent", "(IJ)I", (void*) ELog::writeEventLong },
-    { "writeEvent", "(IF)I", (void*) ELog::writeEventFloat },
-    { "writeEvent", "(ILjava/lang/String;)I", (void*) ELog::writeEventString },
-    { "writeEvent", "(I[Ljava/lang/Object;)I", (void*) ELog::writeEventArray },
-    { "readEvents",
+    { "nativeWriteEvent", "(II)I", (void*) ELog::writeEventInteger },
+    { "nativeWriteEvent", "(IJ)I", (void*) ELog::writeEventLong },
+    { "nativeWriteEvent", "(IF)I", (void*) ELog::writeEventFloat },
+    { "nativeWriteEvent", "(ILjava/lang/String;)I", (void*) ELog::writeEventString },
+    { "nativeWriteEvent", "(I[Ljava/lang/Object;)I", (void*) ELog::writeEventArray },
+    { "nativeReadEvents",
       "([ILjava/util/Collection;)V",
       (void*) android_util_EventLog_readEvents
     },
-    { "readEventsOnWrapping",
+    { "nativeReadEventsOnWrapping",
       "([IJLjava/util/Collection;)V",
       (void*) android_util_EventLog_readEventsOnWrapping
     },

core/jni/android_util_Process.cpp

@@ -1332,6 +1332,47 @@ static jint android_os_Process_nativePidFdOpen(JNIEnv* env, jobject, jint pid, j
     return fd;
 }
 
+// Kill via pidfd to defeat PID-reuse races.
+// Returns: 0=delivered, 1=target gone, 2=uid mismatch (suppressed), -1=error.
+static jint android_os_Process_killProcessByPidfdQuiet(JNIEnv* /*env*/, jobject /*clazz*/,
+        jint pid, jint signal, jint expectedUid) {
+    if (pid <= 0) {
+        return -1;
+    }
+
+    int pfd = pidfd_open(pid, 0);
+    if (pfd < 0) {
+        if (errno == ESRCH) return 1;
+        if (errno == ENOSYS) {
+            ALOGW("pidfd_open(%d) ENOSYS, kernel too old for pidfd guard", pid);
+            return -1;
+        }
+        ALOGW("pidfd_open(%d) failed: %s", pid, strerror(errno));
+        return -1;
+    }
+
+    if (expectedUid >= 0) {
+        const int actualUid = uid_from_pid(pid);
+        if (actualUid != expectedUid) {
+            ALOGW("Skip kill: pid %d uid mismatch, expected=%d actual=%d (likely pid reuse)",
+                    pid, expectedUid, actualUid);
+            close(pfd);
+            return 2;
+        }
+    }
+
+    int rc = pidfd_send_signal(pfd, signal, nullptr, 0);
+    int saved_errno = errno;
+    close(pfd);
+
+    if (rc == 0) return 0;
+    if (saved_errno == ESRCH) return 1;
+    ALOGW("pidfd_send_signal(pid=%d, sig=%d) failed: %s",
+            pid, signal, strerror(saved_errno));
+    errno = saved_errno;
+    return -1;
+}
+
 void android_os_Process_freezeCgroupUID(JNIEnv* env, jobject clazz, jint uid, jboolean freeze) {
     if (uid < 0) {
         jniThrowExceptionFmt(env, "java/lang/IllegalArgumentException", "uid is negative: %d", uid);
@@ -1398,6 +1439,8 @@ static const JNINativeMethod methods[] = {
         {"sendSignalToProcessGroup", "(III)Z", (void*)android_os_Process_sendSignalToProcessGroup},
         {"removeAllProcessGroups", "()V", (void*)android_os_Process_removeAllProcessGroups},
         {"nativePidFdOpen", "(II)I", (void*)android_os_Process_nativePidFdOpen},
+        {"nativeKillProcessByPidfdQuiet", "(III)I",
+         (void*)android_os_Process_killProcessByPidfdQuiet},
         {"freezeCgroupUid", "(IZ)V", (void*)android_os_Process_freezeCgroupUID},
 };