Merge "Add new APIs to support RegionInScreen in A11yWindowInfo"
diff --git a/api/current.txt b/api/current.txt
index f10d05d..e855596 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -5842,12 +5842,19 @@
method public boolean updateAutomaticZenRule(String, android.app.AutomaticZenRule);
field public static final String ACTION_APP_BLOCK_STATE_CHANGED = "android.app.action.APP_BLOCK_STATE_CHANGED";
field public static final String ACTION_AUTOMATIC_ZEN_RULE = "android.app.action.AUTOMATIC_ZEN_RULE";
+ field public static final String ACTION_AUTOMATIC_ZEN_RULE_STATUS_CHANGED = "android.app.action.AUTOMATIC_ZEN_RULE_STATUS_CHANGED";
field public static final String ACTION_INTERRUPTION_FILTER_CHANGED = "android.app.action.INTERRUPTION_FILTER_CHANGED";
field public static final String ACTION_NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED = "android.app.action.NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED";
field public static final String ACTION_NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED = "android.app.action.NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED";
field public static final String ACTION_NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED = "android.app.action.NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED";
field public static final String ACTION_NOTIFICATION_POLICY_CHANGED = "android.app.action.NOTIFICATION_POLICY_CHANGED";
+ field public static final int AUTOMATIC_RULE_STATUS_DISABLED = 2; // 0x2
+ field public static final int AUTOMATIC_RULE_STATUS_ENABLED = 1; // 0x1
+ field public static final int AUTOMATIC_RULE_STATUS_REMOVED = 3; // 0x3
+ field public static final int AUTOMATIC_RULE_STATUS_UNKNOWN = -1; // 0xffffffff
field public static final String EXTRA_AUTOMATIC_RULE_ID = "android.app.extra.AUTOMATIC_RULE_ID";
+ field public static final String EXTRA_AUTOMATIC_ZEN_RULE_ID = "android.app.extra.AUTOMATIC_ZEN_RULE_ID";
+ field public static final String EXTRA_AUTOMATIC_ZEN_RULE_STATUS = "android.app.extra.AUTOMATIC_ZEN_RULE_STATUS";
field public static final String EXTRA_BLOCKED_STATE = "android.app.extra.BLOCKED_STATE";
field public static final String EXTRA_NOTIFICATION_CHANNEL_GROUP_ID = "android.app.extra.NOTIFICATION_CHANNEL_GROUP_ID";
field public static final String EXTRA_NOTIFICATION_CHANNEL_ID = "android.app.extra.NOTIFICATION_CHANNEL_ID";
diff --git a/api/test-current.txt b/api/test-current.txt
index 050ec52..d2179d3 100644
--- a/api/test-current.txt
+++ b/api/test-current.txt
@@ -54,6 +54,7 @@
method @RequiresPermission(android.Manifest.permission.PACKAGE_USAGE_STATS) public int getPackageImportance(String);
method public long getTotalRam();
method @RequiresPermission(android.Manifest.permission.PACKAGE_USAGE_STATS) public int getUidImportance(int);
+ method public static boolean isHighEndGfx();
method @RequiresPermission(android.Manifest.permission.PACKAGE_USAGE_STATS) public void removeOnUidImportanceListener(android.app.ActivityManager.OnUidImportanceListener);
method public static void resumeAppSwitches() throws android.os.RemoteException;
method @RequiresPermission(android.Manifest.permission.CHANGE_CONFIGURATION) public void scheduleApplicationInfoChanged(java.util.List<java.lang.String>, int);
@@ -3492,11 +3493,6 @@
method public boolean isInputMethodPickerShown();
}
- public class InputMethodSystemProperty {
- ctor public InputMethodSystemProperty();
- field public static final boolean MULTI_CLIENT_IME_ENABLED;
- }
-
}
package android.view.inspector {
diff --git a/cmds/bootanimation/Android.bp b/cmds/bootanimation/Android.bp
index 31bd612..c1f8654 100644
--- a/cmds/bootanimation/Android.bp
+++ b/cmds/bootanimation/Android.bp
@@ -79,7 +79,6 @@
"libEGL",
"libGLESv1_CM",
"libgui",
- "libtinyalsa",
],
product_variables: {
diff --git a/cmds/statsd/Android.bp b/cmds/statsd/Android.bp
index 2f0dc3c..6df0a8e 100644
--- a/cmds/statsd/Android.bp
+++ b/cmds/statsd/Android.bp
@@ -71,7 +71,6 @@
"src/config/ConfigManager.cpp",
"src/external/GpuStatsPuller.cpp",
"src/external/Perfetto.cpp",
- "src/external/Perfprofd.cpp",
"src/external/StatsPuller.cpp",
"src/external/StatsCallbackPuller.cpp",
"src/external/StatsCompanionServicePuller.cpp",
@@ -109,8 +108,6 @@
"src/socket/StatsSocketListener.cpp",
"src/shell/ShellSubscriber.cpp",
"src/shell/shell_config.proto",
-
- ":perfprofd_aidl",
],
local_include_dirs: [
diff --git a/cmds/statsd/src/anomaly/subscriber_util.cpp b/cmds/statsd/src/anomaly/subscriber_util.cpp
index 548a686..e09d575 100644
--- a/cmds/statsd/src/anomaly/subscriber_util.cpp
+++ b/cmds/statsd/src/anomaly/subscriber_util.cpp
@@ -22,7 +22,6 @@
#include <binder/IServiceManager.h>
#include "external/Perfetto.h"
-#include "external/Perfprofd.h"
#include "subscriber/IncidentdReporter.h"
#include "subscriber/SubscriberReporter.h"
@@ -64,12 +63,6 @@
SubscriberReporter::getInstance().alertBroadcastSubscriber(configKey, subscription,
dimensionKey);
break;
- case Subscription::SubscriberInformationCase::kPerfprofdDetails:
- if (!CollectPerfprofdTraceAndUploadToDropbox(subscription.perfprofd_details(),
- ruleId, configKey)) {
- ALOGW("Failed to generate perfprofd traces.");
- }
- break;
default:
break;
}
diff --git a/cmds/statsd/src/external/Perfprofd.cpp b/cmds/statsd/src/external/Perfprofd.cpp
deleted file mode 100644
index 1678f10..0000000
--- a/cmds/statsd/src/external/Perfprofd.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source 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.
- */
-
-#include "Perfprofd.h"
-
-#define DEBUG false // STOPSHIP if true
-#include "config/ConfigKey.h"
-#include "Log.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-#include <string>
-
-#include <binder/IServiceManager.h>
-
-#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" // Alert
-
-#include "android/os/IPerfProfd.h"
-
-namespace android {
-namespace os {
-namespace statsd {
-
-bool CollectPerfprofdTraceAndUploadToDropbox(const PerfprofdDetails& config,
- int64_t alert_id,
- const ConfigKey& configKey) {
- VLOG("Starting trace collection through perfprofd");
-
- if (!config.has_perfprofd_config()) {
- ALOGE("The perfprofd trace config is empty, aborting");
- return false;
- }
-
- sp<IPerfProfd> service = interface_cast<IPerfProfd>(
- defaultServiceManager()->getService(android::String16("perfprofd")));
- if (service == NULL) {
- ALOGE("Could not find perfprofd service");
- return false;
- }
-
- auto* data = reinterpret_cast<const uint8_t*>(config.perfprofd_config().data());
- std::vector<uint8_t> proto_serialized(data, data + config.perfprofd_config().size());
-
- // TODO: alert-id etc?
-
- binder::Status status = service->startProfilingProtobuf(proto_serialized);
- if (status.isOk()) {
- return true;
- }
-
- ALOGE("Error starting perfprofd profiling: %s", status.toString8().c_str());
- return false;
-}
-
-} // namespace statsd
-} // namespace os
-} // namespace android
diff --git a/cmds/statsd/src/external/Perfprofd.h b/cmds/statsd/src/external/Perfprofd.h
deleted file mode 100644
index b93fdf8..0000000
--- a/cmds/statsd/src/external/Perfprofd.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2018 The Android Open Source 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.
- */
-
-#pragma once
-
-#include <inttypes.h>
-
-namespace android {
-namespace os {
-namespace statsd {
-
-class ConfigKey;
-class PerfprofdDetails; // Declared in statsd_config.pb.h
-
-// Starts the collection of a Perfprofd trace with the given |config|.
-// The trace is uploaded to Dropbox by the perfprofd service once done.
-// This method returns immediately after passing the config and does NOT wait
-// for the full duration of the trace.
-bool CollectPerfprofdTraceAndUploadToDropbox(const PerfprofdDetails& config,
- int64_t alert_id,
- const ConfigKey& configKey);
-
-} // namespace statsd
-} // namespace os
-} // namespace android
diff --git a/cmds/statsd/src/statsd_config.proto b/cmds/statsd/src/statsd_config.proto
index a2fd9d4..79c06b9 100644
--- a/cmds/statsd/src/statsd_config.proto
+++ b/cmds/statsd/src/statsd_config.proto
@@ -343,15 +343,6 @@
optional bytes trace_config = 1;
}
-message PerfprofdDetails {
- // The |perfprofd_config| field is a proto-encoded message of type
- // android.perfprofd.ProfilingConfig defined in
- // //system/extras/perfprofd/. On device, statsd doesn't need to
- // deserialize the message as it's just passed binary-encoded to
- // the perfprofd service.
- optional bytes perfprofd_config = 1;
-}
-
message BroadcastSubscriberDetails {
optional int64 subscriber_id = 1;
repeated string cookie = 2;
@@ -373,10 +364,12 @@
IncidentdDetails incidentd_details = 4;
PerfettoDetails perfetto_details = 5;
BroadcastSubscriberDetails broadcast_subscriber_details = 6;
- PerfprofdDetails perfprofd_details = 8;
}
optional float probability_of_informing = 7 [default = 1.1];
+
+ // This was used for perfprofd historically.
+ reserved 8;
}
enum ActivationType {
diff --git a/core/java/android/app/ActivityManager.java b/core/java/android/app/ActivityManager.java
index 17368b7..91b98c7 100644
--- a/core/java/android/app/ActivityManager.java
+++ b/core/java/android/app/ActivityManager.java
@@ -925,7 +925,7 @@
* (which tends to consume a lot more RAM).
* @hide
*/
- @UnsupportedAppUsage
+ @TestApi
static public boolean isHighEndGfx() {
return !isLowRamDeviceStatic()
&& !RoSystemProperties.CONFIG_AVOID_GFX_ACCEL
diff --git a/core/java/android/app/ActivityManagerInternal.java b/core/java/android/app/ActivityManagerInternal.java
index f8e6ae5..69e7118 100644
--- a/core/java/android/app/ActivityManagerInternal.java
+++ b/core/java/android/app/ActivityManagerInternal.java
@@ -26,6 +26,7 @@
import android.content.pm.ActivityPresentationInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.UserInfo;
+import android.net.Uri;
import android.os.Bundle;
import android.os.IBinder;
import android.os.TransactionTooLargeException;
@@ -52,6 +53,12 @@
*/
public abstract String checkContentProviderAccess(String authority, int userId);
+ /**
+ * Verify that calling UID has access to the given provider.
+ */
+ public abstract int checkContentProviderUriPermission(Uri uri, int userId,
+ int callingUid, int modeFlags);
+
// Called by the power manager.
public abstract void onWakefulnessChanged(int wakefulness);
diff --git a/core/java/android/app/NotificationManager.java b/core/java/android/app/NotificationManager.java
index c1cee77..316cab8 100644
--- a/core/java/android/app/NotificationManager.java
+++ b/core/java/android/app/NotificationManager.java
@@ -171,6 +171,78 @@
"android.app.action.NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED";
/**
+ * Intent that is broadcast when the status of an {@link AutomaticZenRule} has changed.
+ *
+ * <p>Use this to know whether you need to continue monitor to device state in order to
+ * provide up-to-date states (with {@link #setAutomaticZenRuleState(String, Condition)}) for
+ * this rule.</p>
+ *
+ * Input: nothing
+ * Output: {@link #EXTRA_AUTOMATIC_ZEN_RULE_ID}
+ * Output: {@link #EXTRA_AUTOMATIC_ZEN_RULE_STATUS}
+ */
+ @SdkConstant(SdkConstant.SdkConstantType.BROADCAST_INTENT_ACTION)
+ public static final String ACTION_AUTOMATIC_ZEN_RULE_STATUS_CHANGED =
+ "android.app.action.AUTOMATIC_ZEN_RULE_STATUS_CHANGED";
+
+ /**
+ * Integer extra for {@link #ACTION_AUTOMATIC_ZEN_RULE_STATUS_CHANGED} containing the state of
+ * the {@link AutomaticZenRule}.
+ *
+ * <p>
+ * The value will be one of {@link #AUTOMATIC_RULE_STATUS_ENABLED},
+ * {@link #AUTOMATIC_RULE_STATUS_DISABLED}, {@link #AUTOMATIC_RULE_STATUS_REMOVED},
+ * {@link #AUTOMATIC_RULE_STATUS_UNKNOWN}.
+ * </p>
+ */
+ public static final String EXTRA_AUTOMATIC_ZEN_RULE_STATUS =
+ "android.app.extra.AUTOMATIC_ZEN_RULE_STATUS";
+
+ /**
+ * String extra for {@link #ACTION_AUTOMATIC_ZEN_RULE_STATUS_CHANGED} containing the id of the
+ * {@link AutomaticZenRule} (see {@link #addAutomaticZenRule(AutomaticZenRule)}) that has
+ * changed.
+ */
+ public static final String EXTRA_AUTOMATIC_ZEN_RULE_ID =
+ "android.app.extra.AUTOMATIC_ZEN_RULE_ID";
+
+ /** @hide */
+ @IntDef(prefix = { "AUTOMATIC_RULE_STATUS" }, value = {
+ AUTOMATIC_RULE_STATUS_ENABLED, AUTOMATIC_RULE_STATUS_DISABLED,
+ AUTOMATIC_RULE_STATUS_REMOVED, AUTOMATIC_RULE_STATUS_UNKNOWN
+ })
+ @Retention(RetentionPolicy.SOURCE)
+ public @interface AutomaticZenRuleStatus {}
+
+ /**
+ * Constant value for {@link #EXTRA_AUTOMATIC_ZEN_RULE_STATUS} - the current status of the
+ * rule is unknown at your target sdk version, and you should continue to provide state changes
+ * via {@link #setAutomaticZenRuleState(String, Condition)}.
+ */
+ public static final int AUTOMATIC_RULE_STATUS_UNKNOWN = -1;
+
+ /**
+ * Constant value for {@link #EXTRA_AUTOMATIC_ZEN_RULE_STATUS} - the given rule currently
+ * exists and is enabled. You should continue to provide state changes via
+ * {@link #setAutomaticZenRuleState(String, Condition)}.
+ */
+ public static final int AUTOMATIC_RULE_STATUS_ENABLED = 1;
+
+ /**
+ * Constant value for {@link #EXTRA_AUTOMATIC_ZEN_RULE_STATUS} - the given rule currently
+ * exists but is disabled. You do not need to continue to provide state changes via
+ * {@link #setAutomaticZenRuleState(String, Condition)} until the rule is reenabled.
+ */
+ public static final int AUTOMATIC_RULE_STATUS_DISABLED = 2;
+
+ /**
+ * Constant value for {@link #EXTRA_AUTOMATIC_ZEN_RULE_STATUS} - the given rule has been
+ * deleted. Further calls to {@link #setAutomaticZenRuleState(String, Condition)} will be
+ * ignored.
+ */
+ public static final int AUTOMATIC_RULE_STATUS_REMOVED = 3;
+
+ /**
* Intent that is broadcast when the state of {@link #getEffectsSuppressor()} changes.
* This broadcast is only sent to registered receivers.
*
diff --git a/core/java/android/content/ContentInterface.java b/core/java/android/content/ContentInterface.java
index d41d8d9..197de97 100644
--- a/core/java/android/content/ContentInterface.java
+++ b/core/java/android/content/ContentInterface.java
@@ -56,6 +56,9 @@
public boolean refresh(@NonNull Uri uri, @Nullable Bundle args,
@Nullable CancellationSignal cancellationSignal) throws RemoteException;
+ public int checkUriPermission(@NonNull Uri uri, int uid, @Intent.AccessUriMode int modeFlags)
+ throws RemoteException;
+
public @Nullable Uri insert(@NonNull Uri uri, @Nullable ContentValues initialValues)
throws RemoteException;
diff --git a/core/java/android/content/ContentProvider.java b/core/java/android/content/ContentProvider.java
index 7cdd268..3c79991 100644
--- a/core/java/android/content/ContentProvider.java
+++ b/core/java/android/content/ContentProvider.java
@@ -28,6 +28,7 @@
import android.annotation.Nullable;
import android.annotation.UnsupportedAppUsage;
import android.app.AppOpsManager;
+import android.content.pm.PackageManager;
import android.content.pm.PathPermission;
import android.content.pm.ProviderInfo;
import android.content.res.AssetFileDescriptor;
@@ -582,6 +583,22 @@
}
}
+ @Override
+ public int checkUriPermission(String callingPkg, Uri uri, int uid, int modeFlags) {
+ uri = validateIncomingUri(uri);
+ uri = maybeGetUriWithoutUserId(uri);
+ Trace.traceBegin(TRACE_TAG_DATABASE, "checkUriPermission");
+ final String original = setCallingPackage(callingPkg);
+ try {
+ return mInterface.checkUriPermission(uri, uid, modeFlags);
+ } catch (RemoteException e) {
+ throw e.rethrowAsRuntimeException();
+ } finally {
+ setCallingPackage(original);
+ Trace.traceEnd(TRACE_TAG_DATABASE);
+ }
+ }
+
private void enforceFilePermission(String callingPkg, Uri uri, String mode,
IBinder callerToken) throws FileNotFoundException, SecurityException {
if (mode != null && mode.indexOf('w') != -1) {
@@ -1416,6 +1433,12 @@
return false;
}
+ /** {@hide} */
+ @Override
+ public int checkUriPermission(@NonNull Uri uri, int uid, @Intent.AccessUriMode int modeFlags) {
+ return PackageManager.PERMISSION_DENIED;
+ }
+
/**
* @hide
* Implementation when a caller has performed an insert on the content
diff --git a/core/java/android/content/ContentProviderClient.java b/core/java/android/content/ContentProviderClient.java
index 93bf518..8a4330e 100644
--- a/core/java/android/content/ContentProviderClient.java
+++ b/core/java/android/content/ContentProviderClient.java
@@ -307,6 +307,25 @@
}
}
+ /** {@hide} */
+ @Override
+ public int checkUriPermission(@NonNull Uri uri, int uid, @Intent.AccessUriMode int modeFlags)
+ throws RemoteException {
+ Preconditions.checkNotNull(uri, "uri");
+
+ beforeRemote();
+ try {
+ return mContentProvider.checkUriPermission(mPackageName, uri, uid, modeFlags);
+ } catch (DeadObjectException e) {
+ if (!mStable) {
+ mContentResolver.unstableProviderDied(mContentProvider);
+ }
+ throw e;
+ } finally {
+ afterRemote();
+ }
+ }
+
/** See {@link ContentProvider#insert ContentProvider.insert} */
@Override
public @Nullable Uri insert(@NonNull Uri url, @Nullable ContentValues initialValues)
diff --git a/core/java/android/content/ContentProviderNative.java b/core/java/android/content/ContentProviderNative.java
index 9948338..cd735d4 100644
--- a/core/java/android/content/ContentProviderNative.java
+++ b/core/java/android/content/ContentProviderNative.java
@@ -363,6 +363,19 @@
reply.writeInt(out ? 0 : -1);
return true;
}
+
+ case CHECK_URI_PERMISSION_TRANSACTION: {
+ data.enforceInterface(IContentProvider.descriptor);
+ String callingPkg = data.readString();
+ Uri uri = Uri.CREATOR.createFromParcel(data);
+ int uid = data.readInt();
+ int modeFlags = data.readInt();
+
+ int out = checkUriPermission(callingPkg, uri, uid, modeFlags);
+ reply.writeNoException();
+ reply.writeInt(out);
+ return true;
+ }
}
} catch (Exception e) {
DatabaseUtils.writeExceptionToParcel(reply, e);
@@ -800,6 +813,29 @@
}
}
+ @Override
+ public int checkUriPermission(String callingPkg, Uri url, int uid, int modeFlags)
+ throws RemoteException {
+ Parcel data = Parcel.obtain();
+ Parcel reply = Parcel.obtain();
+ try {
+ data.writeInterfaceToken(IContentProvider.descriptor);
+
+ data.writeString(callingPkg);
+ url.writeToParcel(data, 0);
+ data.writeInt(uid);
+ data.writeInt(modeFlags);
+
+ mRemote.transact(IContentProvider.CHECK_URI_PERMISSION_TRANSACTION, data, reply, 0);
+
+ DatabaseUtils.readExceptionFromParcel(reply);
+ return reply.readInt();
+ } finally {
+ data.recycle();
+ reply.recycle();
+ }
+ }
+
@UnsupportedAppUsage
private IBinder mRemote;
}
diff --git a/core/java/android/content/ContentResolver.java b/core/java/android/content/ContentResolver.java
index 0a1bc85..9c86359 100644
--- a/core/java/android/content/ContentResolver.java
+++ b/core/java/android/content/ContentResolver.java
@@ -31,6 +31,7 @@
import android.app.ActivityThread;
import android.app.AppGlobals;
import android.app.UriGrantsManager;
+import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.res.AssetFileDescriptor;
import android.content.res.Resources;
@@ -1146,6 +1147,24 @@
}
}
+ /** {@hide} */
+ @Override
+ public int checkUriPermission(@NonNull Uri uri, int uid, @Intent.AccessUriMode int modeFlags) {
+ Preconditions.checkNotNull(uri, "uri");
+
+ try {
+ if (mWrapped != null) return mWrapped.checkUriPermission(uri, uid, modeFlags);
+ } catch (RemoteException e) {
+ return PackageManager.PERMISSION_DENIED;
+ }
+
+ try (ContentProviderClient client = acquireUnstableContentProviderClient(uri)) {
+ return client.checkUriPermission(uri, uid, modeFlags);
+ } catch (RemoteException e) {
+ return PackageManager.PERMISSION_DENIED;
+ }
+ }
+
/**
* Open a stream on to the content associated with a content URI. If there
* is no data associated with the URI, FileNotFoundException is thrown.
diff --git a/core/java/android/content/IContentProvider.java b/core/java/android/content/IContentProvider.java
index 0427c2f..fade0ab 100644
--- a/core/java/android/content/IContentProvider.java
+++ b/core/java/android/content/IContentProvider.java
@@ -16,6 +16,7 @@
package android.content;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.UnsupportedAppUsage;
import android.content.res.AssetFileDescriptor;
@@ -82,6 +83,9 @@
public Bundle call(String callingPkg, String authority, String method,
@Nullable String arg, @Nullable Bundle extras) throws RemoteException;
+ public int checkUriPermission(String callingPkg, Uri uri, int uid, int modeFlags)
+ throws RemoteException;
+
public ICancellationSignal createCancellationSignal() throws RemoteException;
public Uri canonicalize(String callingPkg, Uri uri) throws RemoteException;
@@ -116,4 +120,5 @@
static final int CANONICALIZE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 24;
static final int UNCANONICALIZE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 25;
static final int REFRESH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 26;
+ static final int CHECK_URI_PERMISSION_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 27;
}
diff --git a/core/java/android/content/LoggingContentInterface.java b/core/java/android/content/LoggingContentInterface.java
index 83c0c91..1df1c4f 100644
--- a/core/java/android/content/LoggingContentInterface.java
+++ b/core/java/android/content/LoggingContentInterface.java
@@ -165,6 +165,19 @@
}
@Override
+ public int checkUriPermission(@NonNull Uri uri, int uid, @Intent.AccessUriMode int modeFlags)
+ throws RemoteException {
+ try (Logger l = new Logger("checkUriPermission", uri, uid, modeFlags)) {
+ try {
+ return l.setResult(delegate.checkUriPermission(uri, uid, modeFlags));
+ } catch (Exception res) {
+ l.setResult(res);
+ throw res;
+ }
+ }
+ }
+
+ @Override
public @Nullable Uri insert(@NonNull Uri uri, @Nullable ContentValues initialValues)
throws RemoteException {
try (Logger l = new Logger("insert", uri, initialValues)) {
diff --git a/core/java/android/view/DisplayCutout.java b/core/java/android/view/DisplayCutout.java
index 715181f..797c128 100644
--- a/core/java/android/view/DisplayCutout.java
+++ b/core/java/android/view/DisplayCutout.java
@@ -319,18 +319,23 @@
sortedBounds[i] = ZERO_RECT;
}
if (safeInsets != null && boundingRects != null) {
+ // There is at most one non-functional area per short edge of the device, but none
+ // on the long edges, so either a) safeInsets.top and safeInsets.bottom is 0, or
+ // b) safeInsets.left and safeInset.right is 0.
+ final boolean topBottomInset = safeInsets.top > 0 || safeInsets.bottom > 0;
for (Rect bound : boundingRects) {
- // There is at most one non-functional area per short edge of the device, but none
- // on the long edges, so either safeInsets.right or safeInsets.bottom must be 0.
- // TODO(b/117199965): Refine the logic to handle edge cases.
- if (bound.left == 0) {
- sortedBounds[BOUNDS_POSITION_LEFT] = bound;
- } else if (bound.top == 0) {
- sortedBounds[BOUNDS_POSITION_TOP] = bound;
- } else if (safeInsets.right > 0) {
- sortedBounds[BOUNDS_POSITION_RIGHT] = bound;
- } else if (safeInsets.bottom > 0) {
- sortedBounds[BOUNDS_POSITION_BOTTOM] = bound;
+ if (topBottomInset) {
+ if (bound.top == 0) {
+ sortedBounds[BOUNDS_POSITION_TOP] = bound;
+ } else {
+ sortedBounds[BOUNDS_POSITION_BOTTOM] = bound;
+ }
+ } else {
+ if (bound.left == 0) {
+ sortedBounds[BOUNDS_POSITION_LEFT] = bound;
+ } else {
+ sortedBounds[BOUNDS_POSITION_RIGHT] = bound;
+ }
}
}
}
diff --git a/core/java/android/view/IWindowSession.aidl b/core/java/android/view/IWindowSession.aidl
index 4bfd138..f73f28a 100644
--- a/core/java/android/view/IWindowSession.aidl
+++ b/core/java/android/view/IWindowSession.aidl
@@ -308,7 +308,7 @@
/**
* Called when the system gesture exclusion has changed.
*/
- void reportSystemGestureExclusionChanged(IWindow window, in List<Rect> exclusionRects);
+ oneway void reportSystemGestureExclusionChanged(IWindow window, in List<Rect> exclusionRects);
/**
* Request the server to call setInputWindowInfo on a given Surface, and return
diff --git a/core/java/android/view/inputmethod/InputMethodSystemProperty.java b/core/java/android/view/inputmethod/InputMethodSystemProperty.java
index 0689806..e20c2fd 100644
--- a/core/java/android/view/inputmethod/InputMethodSystemProperty.java
+++ b/core/java/android/view/inputmethod/InputMethodSystemProperty.java
@@ -17,7 +17,6 @@
package android.view.inputmethod;
import android.annotation.Nullable;
-import android.annotation.TestApi;
import android.content.ComponentName;
import android.os.Build;
import android.os.SystemProperties;
@@ -27,7 +26,6 @@
*
* @hide
*/
-@TestApi
public class InputMethodSystemProperty {
/**
* System property key for the production use. The value must be either empty or a valid
@@ -78,6 +76,5 @@
*
* @hide
*/
- @TestApi
public static final boolean MULTI_CLIENT_IME_ENABLED = (sMultiClientImeComponentName != null);
}
diff --git a/core/java/com/android/internal/os/Zygote.java b/core/java/com/android/internal/os/Zygote.java
index 9b51c12..9d4cdc7 100644
--- a/core/java/com/android/internal/os/Zygote.java
+++ b/core/java/com/android/internal/os/Zygote.java
@@ -106,6 +106,14 @@
*/
public static final int USE_APP_IMAGE_STARTUP_CACHE = 1 << 16;
+ /**
+ * When set, application specified signal handlers are not chained (i.e, ignored)
+ * by the runtime.
+ *
+ * Used for debugging only. Usage: set debug.ignoreappsignalhandler to 1.
+ */
+ public static final int DEBUG_IGNORE_APP_SIGNAL_HANDLER = 1 << 17;
+
/** No external storage should be mounted. */
public static final int MOUNT_EXTERNAL_NONE = IVold.REMOUNT_MODE_NONE;
/** Default external storage should be mounted. */
diff --git a/core/java/com/android/internal/policy/DecorView.java b/core/java/com/android/internal/policy/DecorView.java
index fe66cf9..480ff4d 100644
--- a/core/java/com/android/internal/policy/DecorView.java
+++ b/core/java/com/android/internal/policy/DecorView.java
@@ -983,14 +983,7 @@
@Override
public void setBackgroundDrawable(Drawable background) {
-
- // TODO: This should route through setWindowBackground, but late in the release to make this
- // change.
- if (mOriginalBackgroundDrawable != background) {
- mOriginalBackgroundDrawable = background;
- updateBackgroundDrawable();
- drawableChanged();
- }
+ setWindowBackground(background);
}
public void setWindowFrame(Drawable drawable) {
diff --git a/core/jni/android_util_Binder.cpp b/core/jni/android_util_Binder.cpp
index df98cdc..0afbaa0e 100644
--- a/core/jni/android_util_Binder.cpp
+++ b/core/jni/android_util_Binder.cpp
@@ -99,7 +99,9 @@
static struct error_offsets_t
{
- jclass mClass;
+ jclass mError;
+ jclass mOutOfMemory;
+ jclass mStackOverflow;
} gErrorOffsets;
// ----------------------------------------------------------------------------
@@ -207,6 +209,16 @@
return vm->GetEnv((void **)&env, JNI_VERSION_1_4) >= 0 ? env : NULL;
}
+static const char* GetErrorTypeName(JNIEnv* env, jthrowable error) {
+ if (env->IsInstanceOf(error, gErrorOffsets.mOutOfMemory)) {
+ return "OutOfMemoryError";
+ }
+ if (env->IsInstanceOf(error, gErrorOffsets.mStackOverflow)) {
+ return "StackOverflowError";
+ }
+ return nullptr;
+}
+
// Report a java.lang.Error (or subclass). This will terminate the runtime by
// calling FatalError with a message derived from the given error.
static void report_java_lang_error_fatal_error(JNIEnv* env, jthrowable error,
@@ -216,7 +228,7 @@
// Try to get the exception string. Sometimes logcat isn't available,
// so try to add it to the abort message.
- std::string exc_msg = "(Unknown exception message)";
+ std::string exc_msg;
{
ScopedLocalRef<jclass> exc_class(env, env->GetObjectClass(error));
jmethodID method_id = env->GetMethodID(exc_class.get(), "toString",
@@ -225,15 +237,36 @@
env,
reinterpret_cast<jstring>(
env->CallObjectMethod(error, method_id)));
- env->ExceptionClear(); // Just for good measure.
+ ScopedLocalRef<jthrowable> new_error(env, nullptr);
+ bool got_jstr = false;
+ if (env->ExceptionCheck()) {
+ new_error = ScopedLocalRef<jthrowable>(env, env->ExceptionOccurred());
+ env->ExceptionClear();
+ }
if (jstr.get() != nullptr) {
ScopedUtfChars jstr_utf(env, jstr.get());
if (jstr_utf.c_str() != nullptr) {
exc_msg = jstr_utf.c_str();
+ got_jstr = true;
} else {
+ new_error = ScopedLocalRef<jthrowable>(env, env->ExceptionOccurred());
env->ExceptionClear();
}
}
+ if (!got_jstr) {
+ exc_msg = "(Unknown exception message)";
+ const char* orig_type = GetErrorTypeName(env, error);
+ if (orig_type != nullptr) {
+ exc_msg = base::StringPrintf("%s (Error was %s)", exc_msg.c_str(), orig_type);
+ }
+ const char* new_type =
+ new_error == nullptr ? nullptr : GetErrorTypeName(env, new_error.get());
+ if (new_type != nullptr) {
+ exc_msg = base::StringPrintf("%s (toString() error was %s)",
+ exc_msg.c_str(),
+ new_type);
+ }
+ }
}
env->Throw(error);
@@ -291,7 +324,7 @@
ALOGE("%s", msg);
}
- if (env->IsInstanceOf(excep, gErrorOffsets.mClass)) {
+ if (env->IsInstanceOf(excep, gErrorOffsets.mError)) {
report_java_lang_error(env, excep, msg);
}
}
@@ -1440,10 +1473,13 @@
static int int_register_android_os_BinderProxy(JNIEnv* env)
{
- jclass clazz = FindClassOrDie(env, "java/lang/Error");
- gErrorOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
+ gErrorOffsets.mError = MakeGlobalRefOrDie(env, FindClassOrDie(env, "java/lang/Error"));
+ gErrorOffsets.mOutOfMemory =
+ MakeGlobalRefOrDie(env, FindClassOrDie(env, "java/lang/OutOfMemoryError"));
+ gErrorOffsets.mStackOverflow =
+ MakeGlobalRefOrDie(env, FindClassOrDie(env, "java/lang/StackOverflowError"));
- clazz = FindClassOrDie(env, kBinderProxyPathName);
+ jclass clazz = FindClassOrDie(env, kBinderProxyPathName);
gBinderProxyOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
gBinderProxyOffsets.mGetInstance = GetStaticMethodIDOrDie(env, clazz, "getInstance",
"(JJ)Landroid/os/BinderProxy;");
diff --git a/core/proto/android/server/jobscheduler.proto b/core/proto/android/server/jobscheduler.proto
index 784e854..c534aa4 100644
--- a/core/proto/android/server/jobscheduler.proto
+++ b/core/proto/android/server/jobscheduler.proto
@@ -231,15 +231,6 @@
// will use heartbeats, false will use a rolling window.
optional bool use_heartbeats = 23;
- message TimeController {
- option (.android.msg_privacy).dest = DEST_AUTOMATIC;
-
- // Whether or not TimeController should skip setting wakeup alarms for jobs that aren't
- // ready now.
- optional bool skip_not_ready_jobs = 1;
- }
- optional TimeController time_controller = 25;
-
message QuotaController {
option (.android.msg_privacy).dest = DEST_AUTOMATIC;
@@ -304,6 +295,15 @@
}
optional QuotaController quota_controller = 24;
+ message TimeController {
+ option (.android.msg_privacy).dest = DEST_AUTOMATIC;
+
+ // Whether or not TimeController should skip setting wakeup alarms for jobs that aren't
+ // ready now.
+ reserved 1; // skip_not_ready_jobs
+ }
+ optional TimeController time_controller = 25;
+
// Max number of jobs, when screen is ON.
optional MaxJobCountsPerMemoryTrimLevelProto max_job_counts_screen_on = 26;
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index 119d5ea..ebf5b93 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -536,6 +536,7 @@
<protected-broadcast android:name="android.app.action.INTERRUPTION_FILTER_CHANGED_INTERNAL" />
<protected-broadcast android:name="android.app.action.NOTIFICATION_POLICY_CHANGED" />
<protected-broadcast android:name="android.app.action.NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED" />
+ <protected-broadcast android:name="android.app.action.AUTOMATIC_ZEN_RULE_STATUS_CHANGED" />
<protected-broadcast android:name="android.os.action.ACTION_EFFECTS_SUPPRESSOR_CHANGED" />
<protected-broadcast android:name="android.app.action.NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED" />
<protected-broadcast android:name="android.app.action.NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED" />
diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml
index bc7e3b7..3b12753 100644
--- a/core/res/res/values/config.xml
+++ b/core/res/res/values/config.xml
@@ -1115,6 +1115,22 @@
regularly selected color mode will be used if this value is negative. -->
<integer name="config_accessibilityColorMode">-1</integer>
+ <!-- The following two arrays specify which color space to use for display composition when a
+ certain color mode is active.
+ Composition color spaces are defined in android.view.Display.COLOR_MODE_xxx, and color
+ modes are defined in ColorDisplayManager.COLOR_MODE_xxx and
+ ColorDisplayManager.VENDOR_COLOR_MODE_xxx.
+ The color space COLOR_MODE_DEFAULT (0) lets the system select the most appropriate
+ composition color space for currently displayed content. Other values (e.g.,
+ COLOR_MODE_SRGB) override system selection; these other color spaces must be supported by
+ the device for for display composition.
+ If a color mode does not have a corresponding color space specified in this array, the
+ currently set composition color space will not be modified.-->
+ <integer-array name="config_displayCompositionColorModes">
+ </integer-array>
+ <integer-array name="config_displayCompositionColorSpaces">
+ </integer-array>
+
<!-- Indicate whether to allow the device to suspend when the screen is off
due to the proximity sensor. This resource should only be set to true
if the sensor HAL correctly handles the proximity sensor as a wake-up source.
@@ -4133,8 +4149,27 @@
for higher refresh rates to be automatically used out of the box -->
<integer name="config_defaultPeakRefreshRate">60</integer>
- <!-- The default brightness threshold that allows to switch to higher refresh rate -->
- <integer name="config_brightnessThresholdOfPeakRefreshRate">-1</integer>
+ <!-- The display uses different gamma curves for different refresh rates. It's hard for panel
+ vendor to tune the curves to have exact same brightness for different refresh rate. So
+ flicker could be observed at switch time. The issue is worse at the gamma lower end.
+ In addition, human eyes are more sensitive to the flicker at darker environment.
+ To prevent flicker, we only support higher refresh rates if the display brightness is above
+ a threshold. And the darker environment could have higher threshold.
+ For example, no higher refresh rate if
+ display brightness <= disp0 && ambient brightness <= amb0
+ || display brightness <= disp1 && ambient brightness <= amb1 -->
+ <integer-array translatable="false" name="config_brightnessThresholdsOfPeakRefreshRate">
+ <!--
+ <item>disp0</item>
+ <item>disp1</item>
+ -->
+ </integer-array>
+ <integer-array translatable="false" name="config_ambientThresholdsOfPeakRefreshRate">
+ <!--
+ <item>amb0</item>
+ <item>amb1</item>
+ -->
+ </integer-array>
<!-- The type of the light sensor to be used by the display framework for things like
auto-brightness. If unset, then it just gets the default sensor of type TYPE_LIGHT. -->
diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml
index b3b1b9f..c49092e 100644
--- a/core/res/res/values/symbols.xml
+++ b/core/res/res/values/symbols.xml
@@ -3196,6 +3196,8 @@
<java-symbol type="array" name="config_nightDisplayColorTemperatureCoefficientsNative" />
<java-symbol type="array" name="config_availableColorModes" />
<java-symbol type="integer" name="config_accessibilityColorMode" />
+ <java-symbol type="array" name="config_displayCompositionColorModes" />
+ <java-symbol type="array" name="config_displayCompositionColorSpaces" />
<java-symbol type="bool" name="config_displayWhiteBalanceAvailable" />
<java-symbol type="bool" name="config_displayWhiteBalanceEnabledDefault" />
<java-symbol type="integer" name="config_displayWhiteBalanceColorTemperatureMin" />
@@ -3793,7 +3795,8 @@
<!-- For high refresh rate displays -->
<java-symbol type="integer" name="config_defaultPeakRefreshRate" />
- <java-symbol type="integer" name="config_brightnessThresholdOfPeakRefreshRate" />
+ <java-symbol type="array" name="config_brightnessThresholdsOfPeakRefreshRate" />
+ <java-symbol type="array" name="config_ambientThresholdsOfPeakRefreshRate" />
<!-- For Auto-Brightness -->
<java-symbol type="string" name="config_displayLightSensorType" />
diff --git a/core/tests/coretests/src/android/view/DisplayCutoutTest.java b/core/tests/coretests/src/android/view/DisplayCutoutTest.java
index 182fe78..d5a0dfa 100644
--- a/core/tests/coretests/src/android/view/DisplayCutoutTest.java
+++ b/core/tests/coretests/src/android/view/DisplayCutoutTest.java
@@ -104,8 +104,8 @@
@Test
public void testExtractBoundsFromList_top_and_bottom() {
- Rect safeInsets = new Rect(0, 1, 0, 10);
- Rect boundTop = new Rect(80, 0, 120, 10);
+ Rect safeInsets = new Rect(0, 10, 0, 10);
+ Rect boundTop = new Rect(0, 0, 120, 10);
Rect boundBottom = new Rect(80, 190, 120, 200);
assertThat(extractBoundsFromList(safeInsets,
Arrays.asList(new Rect[]{boundTop, boundBottom})),
diff --git a/core/tests/coretests/src/com/android/internal/policy/DecorViewTest.java b/core/tests/coretests/src/com/android/internal/policy/DecorViewTest.java
new file mode 100644
index 0000000..f66717e
--- /dev/null
+++ b/core/tests/coretests/src/com/android/internal/policy/DecorViewTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2019 The Android Open Source 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 com.android.internal.policy;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.drawable.Drawable;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.android.frameworks.coretests.R;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+public class DecorViewTest {
+
+ private Context mContext;
+ private DecorView mDecorView;
+
+ @Before
+ public void setUp() {
+ mContext = InstrumentationRegistry.getInstrumentation().getContext();
+ PhoneWindow phoneWindow = new PhoneWindow(mContext);
+ mDecorView = (DecorView) phoneWindow.getDecorView();
+ }
+
+ @Test
+ public void setBackgroundDrawableSameAsSetWindowBackground() {
+ Drawable bitmapDrawable = mContext.getResources()
+ .getDrawable(R.drawable.test16x12, mContext.getTheme());
+ int w = 16;
+ int h = 12;
+ Bitmap expectedBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
+
+ mDecorView.setWindowBackground(bitmapDrawable);
+ Canvas testCanvas = new Canvas(expectedBitmap);
+ mDecorView.draw(testCanvas);
+ testCanvas.release();
+
+ Drawable expectedBackground = mDecorView.getBackground();
+
+ mDecorView.setBackgroundDrawable(bitmapDrawable);
+ Bitmap resultBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
+ Canvas resCanvas = new Canvas(resultBitmap);
+ mDecorView.draw(resCanvas);
+ resCanvas.release();
+
+ // Check that the drawable is the same.
+ assertThat(mDecorView.getBackground()).isEqualTo(expectedBackground);
+ assertThat(mDecorView.getBackground()).isEqualTo(bitmapDrawable);
+
+ // Check that canvas is the same.
+ int[] expPixels = new int[w * h];
+ int[] resPixels = new int[w * h];
+ resultBitmap.getPixels(resPixels, 0, w, 0, 0, w, h);
+ expectedBitmap.getPixels(expPixels, 0, w, 0, 0, w, h);
+ assertThat(Arrays.toString(expPixels)).isEqualTo(Arrays.toString(resPixels));
+ }
+}
diff --git a/libs/hwui/RecordingCanvas.cpp b/libs/hwui/RecordingCanvas.cpp
index e58fbbe..c8eb1ca 100644
--- a/libs/hwui/RecordingCanvas.cpp
+++ b/libs/hwui/RecordingCanvas.cpp
@@ -274,7 +274,12 @@
}
sk_sp<SkDrawable> drawable;
SkMatrix matrix = SkMatrix::I();
- void draw(SkCanvas* c, const SkMatrix&) const { c->drawDrawable(drawable.get(), &matrix); }
+ // It is important that we call drawable->draw(c) here instead of c->drawDrawable(drawable).
+ // Drawables are mutable and in cases, like RenderNodeDrawable, are not expected to produce the
+ // same content if retained outside the duration of the frame. Therefore we resolve
+ // them now and do not allow the canvas to take a reference to the drawable and potentially
+ // keep it alive for longer than the frames duration (e.g. SKP serialization).
+ void draw(SkCanvas* c, const SkMatrix&) const { drawable->draw(c, &matrix); }
};
struct DrawPicture final : Op {
static const auto kType = Type::DrawPicture;
diff --git a/libs/hwui/pipeline/skia/LayerDrawable.cpp b/libs/hwui/pipeline/skia/LayerDrawable.cpp
index eed1942..96b17e1 100644
--- a/libs/hwui/pipeline/skia/LayerDrawable.cpp
+++ b/libs/hwui/pipeline/skia/LayerDrawable.cpp
@@ -33,21 +33,47 @@
}
}
-// This is a less-strict matrix.isTranslate() that will still report being translate-only
-// on imperceptibly small scaleX & scaleY values.
-static bool isBasicallyTranslate(const SkMatrix& matrix) {
- if (!matrix.isScaleTranslate()) return false;
- return MathUtils::isOne(matrix.getScaleX()) && MathUtils::isOne(matrix.getScaleY());
-}
-
-static bool shouldFilter(const SkMatrix& matrix) {
- if (!matrix.isScaleTranslate()) return true;
-
- // We only care about meaningful scale here
- bool noScale = MathUtils::isOne(matrix.getScaleX()) && MathUtils::isOne(matrix.getScaleY());
- bool pixelAligned =
- SkScalarIsInt(matrix.getTranslateX()) && SkScalarIsInt(matrix.getTranslateY());
- return !(noScale && pixelAligned);
+// Disable filtering when there is no scaling in screen coordinates and the corners have the same
+// fraction (for translate) or zero fraction (for any other rect-to-rect transform).
+static bool shouldFilterRect(const SkMatrix& matrix, const SkRect& srcRect, const SkRect& dstRect) {
+ if (!matrix.rectStaysRect()) return true;
+ SkRect dstDevRect = matrix.mapRect(dstRect);
+ float dstW, dstH;
+ bool requiresIntegerTranslate = false;
+ if (MathUtils::isZero(matrix.getScaleX()) && MathUtils::isZero(matrix.getScaleY())) {
+ // Has a 90 or 270 degree rotation, although total matrix may also have scale factors
+ // in m10 and m01. Those scalings are automatically handled by mapRect so comparing
+ // dimensions is sufficient, but swap width and height comparison.
+ dstW = dstDevRect.height();
+ dstH = dstDevRect.width();
+ requiresIntegerTranslate = true;
+ } else {
+ // Handle H/V flips or 180 rotation matrices. Axes may have been mirrored, but
+ // dimensions are still safe to compare directly.
+ dstW = dstDevRect.width();
+ dstH = dstDevRect.height();
+ requiresIntegerTranslate =
+ matrix.getScaleX() < -NON_ZERO_EPSILON || matrix.getScaleY() < -NON_ZERO_EPSILON;
+ }
+ if (!(MathUtils::areEqual(dstW, srcRect.width()) &&
+ MathUtils::areEqual(dstH, srcRect.height()))) {
+ return true;
+ }
+ if (requiresIntegerTranslate) {
+ // Device rect and source rect should be integer aligned to ensure there's no difference
+ // in how nearest-neighbor sampling is resolved.
+ return !(MathUtils::isZero(SkScalarFraction(srcRect.x())) &&
+ MathUtils::isZero(SkScalarFraction(srcRect.y())) &&
+ MathUtils::isZero(SkScalarFraction(dstDevRect.x())) &&
+ MathUtils::isZero(SkScalarFraction(dstDevRect.y())));
+ } else {
+ // As long as src and device rects are translated by the same fractional amount,
+ // filtering won't be needed
+ return !(MathUtils::areEqual(SkScalarFraction(srcRect.x()),
+ SkScalarFraction(dstDevRect.x())) &&
+ MathUtils::areEqual(SkScalarFraction(srcRect.y()),
+ SkScalarFraction(dstDevRect.y())));
+ }
}
bool LayerDrawable::DrawLayer(GrContext* context, SkCanvas* canvas, Layer* layer,
@@ -114,24 +140,21 @@
skiaDestRect = SkRect::MakeIWH(layerWidth, layerHeight);
}
matrixInv.mapRect(&skiaDestRect);
- // If (matrix is identity or an integer translation) and (src/dst buffers size match),
+ // If (matrix is a rect-to-rect transform)
+ // and (src/dst buffers size match in screen coordinates)
+ // and (src/dst corners align fractionally),
// then use nearest neighbor, otherwise use bilerp sampling.
- // Integer translation is defined as when src rect and dst rect align fractionally.
// Skia TextureOp has the above logic build-in, but not NonAAFillRectOp. TextureOp works
// only for SrcOver blending and without color filter (readback uses Src blending).
- bool isIntegerTranslate =
- isBasicallyTranslate(totalMatrix) &&
- SkScalarFraction(skiaDestRect.fLeft + totalMatrix[SkMatrix::kMTransX]) ==
- SkScalarFraction(skiaSrcRect.fLeft) &&
- SkScalarFraction(skiaDestRect.fTop + totalMatrix[SkMatrix::kMTransY]) ==
- SkScalarFraction(skiaSrcRect.fTop);
- if (layer->getForceFilter() || !isIntegerTranslate) {
+ if (layer->getForceFilter() ||
+ shouldFilterRect(totalMatrix, skiaSrcRect, skiaDestRect)) {
paint.setFilterQuality(kLow_SkFilterQuality);
}
canvas->drawImageRect(layerImage.get(), skiaSrcRect, skiaDestRect, &paint,
SkCanvas::kFast_SrcRectConstraint);
} else {
- if (layer->getForceFilter() || shouldFilter(totalMatrix)) {
+ SkRect imageRect = SkRect::MakeIWH(layerImage->width(), layerImage->height());
+ if (layer->getForceFilter() || shouldFilterRect(totalMatrix, imageRect, imageRect)) {
paint.setFilterQuality(kLow_SkFilterQuality);
}
canvas->drawImage(layerImage.get(), 0, 0, &paint);
diff --git a/libs/hwui/pipeline/skia/SkiaPipeline.cpp b/libs/hwui/pipeline/skia/SkiaPipeline.cpp
index 84c0d13..530926b 100644
--- a/libs/hwui/pipeline/skia/SkiaPipeline.cpp
+++ b/libs/hwui/pipeline/skia/SkiaPipeline.cpp
@@ -313,8 +313,7 @@
case CaptureMode::CallbackAPI:
case CaptureMode::SingleFrameSKP:
mRecorder.reset(new SkPictureRecorder());
- pictureCanvas = mRecorder->beginRecording(surface->width(), surface->height(),
- nullptr, SkPictureRecorder::kPlaybackDrawPicture_RecordFlag);
+ pictureCanvas = mRecorder->beginRecording(surface->width(), surface->height());
break;
case CaptureMode::MultiFrameSKP:
// If a multi frame recording is active, initialize recording for a single frame of a
diff --git a/libs/hwui/tests/unit/RenderNodeDrawableTests.cpp b/libs/hwui/tests/unit/RenderNodeDrawableTests.cpp
index c813cd9..e70378b 100644
--- a/libs/hwui/tests/unit/RenderNodeDrawableTests.cpp
+++ b/libs/hwui/tests/unit/RenderNodeDrawableTests.cpp
@@ -1096,10 +1096,8 @@
int getDrawCounter() { return mDrawCounter; }
virtual void onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) override {
- // expect to draw 2 RenderNodeDrawable, 1 StartReorderBarrierDrawable,
- // 1 EndReorderBarrierDrawable
- mDrawCounter++;
- SkCanvas::onDrawDrawable(drawable, matrix);
+ // Do not expect this to be called. See RecordingCanvas.cpp DrawDrawable for context.
+ EXPECT_TRUE(false);
}
virtual void didTranslate(SkScalar dx, SkScalar dy) override {
@@ -1159,8 +1157,8 @@
// create a canvas not backed by any device/pixels, but with dimensions to avoid quick rejection
ShadowTestCanvas canvas(CANVAS_WIDTH, CANVAS_HEIGHT);
RenderNodeDrawable drawable(parent.get(), &canvas, false);
- canvas.drawDrawable(&drawable);
- EXPECT_EQ(9, canvas.getDrawCounter());
+ drawable.draw(&canvas);
+ EXPECT_EQ(5, canvas.getDrawCounter());
}
// Draw a vector drawable twice but with different bounds and verify correct bounds are used.
diff --git a/media/java/android/media/AudioRecord.java b/media/java/android/media/AudioRecord.java
index ce9b07d..0254c97 100644
--- a/media/java/android/media/AudioRecord.java
+++ b/media/java/android/media/AudioRecord.java
@@ -1788,6 +1788,9 @@
* @hide
*/
public int getPortId() {
+ if (mNativeRecorderInJavaObj == 0) {
+ return 0;
+ }
return native_getPortId();
}
diff --git a/media/java/android/media/MediaRecorder.java b/media/java/android/media/MediaRecorder.java
index 63b22df..bc3de74 100644
--- a/media/java/android/media/MediaRecorder.java
+++ b/media/java/android/media/MediaRecorder.java
@@ -1624,6 +1624,9 @@
* @hide
*/
public int getPortId() {
+ if (mNativeContext == 0) {
+ return 0;
+ }
return native_getPortId();
}
diff --git a/media/jni/android_media_ImageReader.cpp b/media/jni/android_media_ImageReader.cpp
index 77878f8..0a02156 100644
--- a/media/jni/android_media_ImageReader.cpp
+++ b/media/jni/android_media_ImageReader.cpp
@@ -416,11 +416,13 @@
if (res != OK) {
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
"Failed to set buffer consumer default format 0x%x", nativeFormat);
+ return;
}
res = bufferConsumer->setDefaultBufferDataSpace(nativeDataspace);
if (res != OK) {
jniThrowExceptionFmt(env, "java/lang/IllegalStateException",
"Failed to set buffer consumer default dataSpace 0x%x", nativeDataspace);
+ return;
}
}
@@ -704,7 +706,7 @@
// and we don't set them here.
}
-static void Image_getLockedImageInfo(JNIEnv* env, LockedImage* buffer, int idx,
+static bool Image_getLockedImageInfo(JNIEnv* env, LockedImage* buffer, int idx,
int32_t writerFormat, uint8_t **base, uint32_t *size, int *pixelStride, int *rowStride) {
ALOGV("%s", __FUNCTION__);
@@ -713,7 +715,9 @@
if (res != OK) {
jniThrowExceptionFmt(env, "java/lang/UnsupportedOperationException",
"Pixel format: 0x%x is unsupported", buffer->flexFormat);
+ return false;
}
+ return true;
}
static jobjectArray Image_createSurfacePlanes(JNIEnv* env, jobject thiz,
@@ -756,8 +760,10 @@
}
// Create all SurfacePlanes
for (int i = 0; i < numPlanes; i++) {
- Image_getLockedImageInfo(env, &lockedImg, i, halReaderFormat,
- &pData, &dataSize, &pixelStride, &rowStride);
+ if (!Image_getLockedImageInfo(env, &lockedImg, i, halReaderFormat,
+ &pData, &dataSize, &pixelStride, &rowStride)) {
+ return NULL;
+ }
byteBuffer = env->NewDirectByteBuffer(pData, dataSize);
if ((byteBuffer == NULL) && (env->ExceptionCheck() == false)) {
jniThrowException(env, "java/lang/IllegalStateException",
diff --git a/media/jni/android_media_ImageWriter.cpp b/media/jni/android_media_ImageWriter.cpp
index 728c55e..6d8b966 100644
--- a/media/jni/android_media_ImageWriter.cpp
+++ b/media/jni/android_media_ImageWriter.cpp
@@ -777,6 +777,7 @@
status_t res = buffer->unlock();
if (res != OK) {
jniThrowRuntimeException(env, "unlock buffer failed");
+ return;
}
ALOGV("Successfully unlocked the image");
}
@@ -872,7 +873,7 @@
// and we don't set them here.
}
-static void Image_getLockedImageInfo(JNIEnv* env, LockedImage* buffer, int idx,
+static bool Image_getLockedImageInfo(JNIEnv* env, LockedImage* buffer, int idx,
int32_t writerFormat, uint8_t **base, uint32_t *size, int *pixelStride, int *rowStride) {
ALOGV("%s", __FUNCTION__);
@@ -880,8 +881,10 @@
pixelStride, rowStride);
if (res != OK) {
jniThrowExceptionFmt(env, "java/lang/UnsupportedOperationException",
- "Pixel format: 0x%x is unsupported", buffer->flexFormat);
+ "Pixel format: 0x%x is unsupported", writerFormat);
+ return false;
}
+ return true;
}
static jobjectArray Image_createSurfacePlanes(JNIEnv* env, jobject thiz,
@@ -920,8 +923,10 @@
PublicFormat publicWriterFormat = static_cast<PublicFormat>(writerFormat);
writerFormat = mapPublicFormatToHalFormat(publicWriterFormat);
for (int i = 0; i < numPlanes; i++) {
- Image_getLockedImageInfo(env, &lockedImg, i, writerFormat,
- &pData, &dataSize, &pixelStride, &rowStride);
+ if (!Image_getLockedImageInfo(env, &lockedImg, i, writerFormat,
+ &pData, &dataSize, &pixelStride, &rowStride)) {
+ return NULL;
+ }
byteBuffer = env->NewDirectByteBuffer(pData, dataSize);
if ((byteBuffer == NULL) && (env->ExceptionCheck() == false)) {
jniThrowException(env, "java/lang/IllegalStateException",
diff --git a/packages/SettingsProvider/src/com/android/providers/settings/GenerationRegistry.java b/packages/SettingsProvider/src/com/android/providers/settings/GenerationRegistry.java
index 044ec86..5617331 100644
--- a/packages/SettingsProvider/src/com/android/providers/settings/GenerationRegistry.java
+++ b/packages/SettingsProvider/src/com/android/providers/settings/GenerationRegistry.java
@@ -22,14 +22,16 @@
import android.util.MemoryIntArray;
import android.util.Slog;
import android.util.SparseIntArray;
+
import com.android.internal.annotations.GuardedBy;
import java.io.IOException;
/**
- * This class tracks changes for global/secure/system tables on a
- * per user basis and updates a shared memory region which client
- * processes can read to determine if their local caches are stale,
+ * This class tracks changes for config/global/secure/system tables
+ * on a per user basis and updates a shared memory region which
+ * client processes can read to determine if their local caches are
+ * stale.
*/
final class GenerationRegistry {
private static final String LOG_TAG = "GenerationRegistry";
@@ -114,11 +116,12 @@
@GuardedBy("mLock")
private MemoryIntArray getBackingStoreLocked() {
if (mBackingStore == null) {
- // One for the global table, two for system and secure tables for a
- // managed profile (managed profile is not included in the max user
- // count), ten for partially deleted users if users are quickly removed,
- // and twice max user count for system and secure.
- final int size = 1 + 2 + 10 + 2 * UserManager.getMaxSupportedUsers();
+ // One for the config table, one for the global table, two for system
+ // and secure tables for a managed profile (managed profile is not
+ // included in the max user count), ten for partially deleted users if
+ // users are quickly removed, and twice max user count for system and
+ // secure.
+ final int size = 1 + 1 + 2 + 10 + 2 * UserManager.getMaxSupportedUsers();
try {
mBackingStore = new MemoryIntArray(size);
if (DEBUG) {
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
index 69630c4..c7c648c 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
@@ -237,6 +237,7 @@
MIN_DRAG_SIZE, getResources().getDisplayMetrics())
&& !mUpdateMonitor.isFaceDetectionRunning()) {
mUpdateMonitor.requestFaceAuth();
+ mCallback.userActivity();
showMessage(null, null);
}
}
diff --git a/packages/SystemUI/src/com/android/systemui/colorextraction/SysuiColorExtractor.java b/packages/SystemUI/src/com/android/systemui/colorextraction/SysuiColorExtractor.java
index 0e93f42..d3e8b3d 100644
--- a/packages/SystemUI/src/com/android/systemui/colorextraction/SysuiColorExtractor.java
+++ b/packages/SystemUI/src/com/android/systemui/colorextraction/SysuiColorExtractor.java
@@ -77,7 +77,7 @@
protected void extractWallpaperColors() {
super.extractWallpaperColors();
// mTonal is final but this method will be invoked by the base class during its ctor.
- if (mTonal == null) {
+ if (mTonal == null || mNeutralColorsLock == null) {
return;
}
mTonal.applyFallback(mLockColors == null ? mSystemColors : mLockColors, mNeutralColorsLock);
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeSensors.java b/packages/SystemUI/src/com/android/systemui/doze/DozeSensors.java
index cf04b7f..6918501 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeSensors.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeSensors.java
@@ -198,7 +198,10 @@
updateListening();
}
- private void updateListening() {
+ /**
+ * Registers/unregisters sensors based on internal state.
+ */
+ public void updateListening() {
boolean anyListening = false;
for (TriggerSensor s : mSensors) {
// We don't want to be listening while we're PAUSED (prox sensor is covered)
@@ -231,7 +234,7 @@
public void onUserSwitched() {
for (TriggerSensor s : mSensors) {
- s.updateListener();
+ s.updateListening();
}
}
@@ -246,7 +249,7 @@
return;
}
for (TriggerSensor s : mSensors) {
- s.updateListener();
+ s.updateListening();
}
}
};
@@ -409,22 +412,22 @@
public void setListening(boolean listen) {
if (mRequested == listen) return;
mRequested = listen;
- updateListener();
+ updateListening();
}
public void setDisabled(boolean disabled) {
if (mDisabled == disabled) return;
mDisabled = disabled;
- updateListener();
+ updateListening();
}
public void ignoreSetting(boolean ignored) {
if (mIgnoresSetting == ignored) return;
mIgnoresSetting = ignored;
- updateListener();
+ updateListening();
}
- public void updateListener() {
+ public void updateListening() {
if (!mConfigured || mSensor == null) return;
if (mRequested && !mDisabled && (enabledBySetting() || mIgnoresSetting)
&& !mRegistered) {
@@ -480,7 +483,7 @@
mCallback.onSensorPulse(mPulseReason, mSensorPerformsProxCheck, screenX, screenY,
event.values);
if (!mRegistered) {
- updateListener(); // reregister, this sensor only fires once
+ updateListening(); // reregister, this sensor only fires once
}
}));
}
@@ -541,7 +544,7 @@
}
@Override
- public void updateListener() {
+ public void updateListening() {
if (!mConfigured) return;
AsyncSensorManager asyncSensorManager = (AsyncSensorManager) mSensorManager;
if (mRequested && !mDisabled && (enabledBySetting() || mIgnoresSetting)
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeTriggers.java b/packages/SystemUI/src/com/android/systemui/doze/DozeTriggers.java
index 97b08d5..63de960 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeTriggers.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeTriggers.java
@@ -314,6 +314,9 @@
break;
case DOZE_PULSE_DONE:
mDozeSensors.requestTemporaryDisable();
+ // A pulse will temporarily disable sensors that require a touch screen.
+ // Let's make sure that they are re-enabled when the pulse is over.
+ mDozeSensors.updateListening();
break;
case FINISH:
mBroadcastReceiver.unregister(mContext);
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/StackScrollAlgorithm.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/StackScrollAlgorithm.java
index 35ba801..01e2b28 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/StackScrollAlgorithm.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/StackScrollAlgorithm.java
@@ -514,11 +514,11 @@
for (int i = 0; i < childCount; i++) {
View child = algorithmState.visibleChildren.get(i);
if (!(child instanceof ExpandableNotificationRow)) {
- break;
+ continue;
}
ExpandableNotificationRow row = (ExpandableNotificationRow) child;
if (!row.isHeadsUp()) {
- break;
+ continue;
}
ExpandableViewState childState = row.getViewState();
if (topHeadsUpEntry == null && row.mustStayOnScreen() && !childState.headsUpIsVisible) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/BiometricUnlockController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/BiometricUnlockController.java
index bc7174d..6a0d6e1 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/BiometricUnlockController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/BiometricUnlockController.java
@@ -260,6 +260,7 @@
boolean unlockAllowed = mKeyguardBypassController.onBiometricAuthenticated(
biometricSourceType);
if (unlockAllowed) {
+ mKeyguardViewMediator.userActivity();
startWakeAndUnlock(biometricSourceType);
} else {
Log.d(TAG, "onBiometricAuthenticated aborted by bypass controller");
@@ -466,8 +467,11 @@
}
if (mStatusBarKeyguardViewManager.isShowing()) {
if (mStatusBarKeyguardViewManager.bouncerIsOrWillBeShowing() && unlockingAllowed) {
- return bypass && !mKeyguardBypassController.canPlaySubtleWindowAnimations()
- ? MODE_UNLOCK_COLLAPSING : MODE_UNLOCK_FADING;
+ if (bypass && mKeyguardBypassController.canPlaySubtleWindowAnimations()) {
+ return MODE_UNLOCK_FADING;
+ } else {
+ return MODE_DISMISS_BOUNCER;
+ }
} else if (unlockingAllowed) {
return bypass ? MODE_UNLOCK_FADING : MODE_NONE;
} else {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationGroupManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationGroupManager.java
index 0bbfbef..195870b 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationGroupManager.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationGroupManager.java
@@ -464,7 +464,7 @@
if (!sbn.isGroup() || sbn.getNotification().isGroupSummary()) {
return false;
}
- if (!mHeadsUpManager.isAlerting(entry.key)) {
+ if (mHeadsUpManager != null && !mHeadsUpManager.isAlerting(entry.key)) {
return false;
}
return (sbn.getNotification().fullScreenIntent != null
diff --git a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeConfigurationUtil.java b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeConfigurationUtil.java
index 2d6ae26..2ed0970 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeConfigurationUtil.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeConfigurationUtil.java
@@ -24,6 +24,7 @@
import static org.mockito.Mockito.withSettings;
import com.android.systemui.statusbar.phone.DozeParameters;
+import com.android.systemui.utils.hardware.FakeSensorManager;
import org.mockito.Answers;
import org.mockito.MockSettings;
@@ -39,6 +40,7 @@
when(params.getPickupPerformsProxCheck()).thenReturn(true);
when(params.getPolicy()).thenReturn(mock(AlwaysOnDisplayPolicy.class));
when(params.doubleTapReportsTouchCoordinates()).thenReturn(false);
+ when(params.getDisplayNeedsBlanking()).thenReturn(false);
doneHolder[0] = true;
return params;
@@ -52,11 +54,17 @@
when(config.pickupGestureEnabled(anyInt())).thenReturn(false);
when(config.pulseOnNotificationEnabled(anyInt())).thenReturn(true);
when(config.alwaysOnEnabled(anyInt())).thenReturn(false);
+ when(config.enabled(anyInt())).thenReturn(true);
+ when(config.getWakeLockScreenDebounce()).thenReturn(0L);
when(config.doubleTapSensorType()).thenReturn(null);
when(config.tapSensorType()).thenReturn(null);
when(config.longPressSensorType()).thenReturn(null);
+ when(config.tapGestureEnabled(anyInt())).thenReturn(true);
+ when(config.tapSensorAvailable()).thenReturn(true);
+ when(config.tapSensorType()).thenReturn(FakeSensorManager.TAP_SENSOR_TYPE);
+
when(config.dozePickupSensorAvailable()).thenReturn(false);
when(config.wakeScreenGestureAvailable()).thenReturn(false);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeTriggersTest.java b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeTriggersTest.java
index 6979fd8..6feff9c 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeTriggersTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeTriggersTest.java
@@ -19,6 +19,7 @@
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
@@ -27,18 +28,17 @@
import static org.mockito.Mockito.when;
import android.app.AlarmManager;
-import android.app.Instrumentation;
+import android.hardware.Sensor;
import android.hardware.display.AmbientDisplayConfiguration;
import android.os.Handler;
import android.os.Looper;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper.RunWithLooper;
-import androidx.test.InstrumentationRegistry;
import androidx.test.filters.SmallTest;
import com.android.systemui.SysuiTestCase;
-import com.android.systemui.dock.DockManagerFake;
+import com.android.systemui.dock.DockManager;
import com.android.systemui.statusbar.phone.DozeParameters;
import com.android.systemui.util.wakelock.WakeLock;
import com.android.systemui.util.wakelock.WakeLockFake;
@@ -46,14 +46,12 @@
import org.junit.Before;
import org.junit.BeforeClass;
-import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
@SmallTest
-@Ignore("failing")
@RunWith(AndroidTestingRunner.class)
-@RunWithLooper
+@RunWithLooper(setAsMainLooper = true)
public class DozeTriggersTest extends SysuiTestCase {
private DozeTriggers mTriggers;
private DozeMachine mMachine;
@@ -61,10 +59,10 @@
private AmbientDisplayConfiguration mConfig;
private DozeParameters mParameters;
private FakeSensorManager mSensors;
+ private Sensor mTapSensor;
private WakeLock mWakeLock;
- private Instrumentation mInstrumentation;
private AlarmManager mAlarmManager;
- private DockManagerFake mDockManagerFake;
+ private DockManager mDockManagerFake;
@BeforeClass
public static void setupSuite() {
@@ -74,15 +72,15 @@
@Before
public void setUp() throws Exception {
- mInstrumentation = InstrumentationRegistry.getInstrumentation();
mMachine = mock(DozeMachine.class);
mAlarmManager = mock(AlarmManager.class);
- mHost = new DozeHostFake();
+ mHost = spy(new DozeHostFake());
mConfig = DozeConfigurationUtil.createMockConfig();
mParameters = DozeConfigurationUtil.createMockParameters();
- mSensors = new FakeSensorManager(mContext);
+ mSensors = spy(new FakeSensorManager(mContext));
+ mTapSensor = mSensors.getFakeTapSensor().getSensor();
mWakeLock = new WakeLockFake();
- mDockManagerFake = spy(new DockManagerFake());
+ mDockManagerFake = mock(DockManager.class);
mTriggers = new DozeTriggers(mContext, mMachine, mHost, mAlarmManager, mConfig, mParameters,
mSensors, Handler.createAsync(Looper.myLooper()), mWakeLock, true,
@@ -95,29 +93,45 @@
mTriggers.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
mTriggers.transitionTo(DozeMachine.State.INITIALIZED, DozeMachine.State.DOZE);
+ clearInvocations(mMachine);
mHost.callback.onNotificationAlerted();
-
mSensors.getMockProximitySensor().sendProximityResult(false); /* Near */
verify(mMachine, never()).requestState(any());
verify(mMachine, never()).requestPulse(anyInt());
mHost.callback.onNotificationAlerted();
-
mSensors.getMockProximitySensor().sendProximityResult(true); /* Far */
verify(mMachine).requestPulse(anyInt());
}
@Test
+ public void testTransitionTo_disablesAndEnablesTouchSensors() {
+ when(mMachine.getState()).thenReturn(DozeMachine.State.DOZE);
+
+ mTriggers.transitionTo(DozeMachine.State.INITIALIZED, DozeMachine.State.DOZE);
+ verify(mSensors).requestTriggerSensor(any(), eq(mTapSensor));
+
+ clearInvocations(mSensors);
+ mTriggers.transitionTo(DozeMachine.State.DOZE,
+ DozeMachine.State.DOZE_REQUEST_PULSE);
+ mTriggers.transitionTo(DozeMachine.State.DOZE_REQUEST_PULSE,
+ DozeMachine.State.DOZE_PULSING);
+ verify(mSensors).cancelTriggerSensor(any(), eq(mTapSensor));
+
+ clearInvocations(mSensors);
+ mTriggers.transitionTo(DozeMachine.State.DOZE_PULSING, DozeMachine.State.DOZE_PULSE_DONE);
+ verify(mSensors).requestTriggerSensor(any(), eq(mTapSensor));
+ }
+
+ @Test
public void testDockEventListener_registerAndUnregister() {
mTriggers.transitionTo(DozeMachine.State.UNINITIALIZED, DozeMachine.State.INITIALIZED);
-
verify(mDockManagerFake).addListener(any());
mTriggers.transitionTo(DozeMachine.State.DOZE, DozeMachine.State.FINISH);
-
verify(mDockManagerFake).removeListener(any());
}
@@ -128,7 +142,6 @@
mTriggers.onSensor(DozeLog.REASON_SENSOR_DOUBLE_TAP,
false /* sensorPerformedProxCheck */, 50 /* screenX */, 50 /* screenY */,
null /* rawValues */);
-
verify(mMachine, never()).wakeUp();
}
@@ -142,7 +155,7 @@
false /* sensorPerformedProxCheck */, 50 /* screenX */, 50 /* screenY */,
null /* rawValues */);
- verify(mHost).setAodDimmingScrim(eq(255));
+ verify(mHost).setAodDimmingScrim(eq(255f));
verify(mMachine).wakeUp();
}
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/BiometricsUnlockControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/BiometricsUnlockControllerTest.java
index a99dc7f..7d9920d 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/BiometricsUnlockControllerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/BiometricsUnlockControllerTest.java
@@ -16,6 +16,8 @@
package com.android.systemui.statusbar.phone;
+import static com.google.common.truth.Truth.assertThat;
+
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyFloat;
@@ -192,6 +194,34 @@
}
@Test
+ public void onBiometricAuthenticated_whenBypassOnBouncer_dismissBouncer() {
+ reset(mKeyguardBypassController);
+ when(mUpdateMonitor.isUnlockingWithBiometricAllowed()).thenReturn(true);
+ when(mKeyguardBypassController.getBypassEnabled()).thenReturn(true);
+ when(mKeyguardBypassController.onBiometricAuthenticated(any())).thenReturn(true);
+ when(mStatusBarKeyguardViewManager.bouncerIsOrWillBeShowing()).thenReturn(true);
+ mBiometricUnlockController.onBiometricAuthenticated(UserHandle.USER_CURRENT,
+ BiometricSourceType.FACE);
+
+ verify(mStatusBarKeyguardViewManager).notifyKeyguardAuthenticated(eq(false));
+ assertThat(mBiometricUnlockController.getMode())
+ .isEqualTo(BiometricUnlockController.MODE_DISMISS_BOUNCER);
+ }
+
+ @Test
+ public void onBiometricAuthenticated_whenBypassOnBouncer_respectsCanPlaySubtleAnim() {
+ when(mUpdateMonitor.isUnlockingWithBiometricAllowed()).thenReturn(true);
+ when(mKeyguardBypassController.getBypassEnabled()).thenReturn(true);
+ when(mStatusBarKeyguardViewManager.bouncerIsOrWillBeShowing()).thenReturn(true);
+ mBiometricUnlockController.onBiometricAuthenticated(UserHandle.USER_CURRENT,
+ BiometricSourceType.FACE);
+
+ verify(mStatusBarKeyguardViewManager).notifyKeyguardAuthenticated(eq(false));
+ assertThat(mBiometricUnlockController.getMode())
+ .isEqualTo(BiometricUnlockController.MODE_UNLOCK_FADING);
+ }
+
+ @Test
public void onBiometricAuthenticated_whenFaceAndPulsing_dontDismissKeyguard() {
reset(mUpdateMonitor);
reset(mStatusBarKeyguardViewManager);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/utils/hardware/FakeSensorManager.java b/packages/SystemUI/tests/src/com/android/systemui/utils/hardware/FakeSensorManager.java
index a4ae166..29b8ab60 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/utils/hardware/FakeSensorManager.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/utils/hardware/FakeSensorManager.java
@@ -40,18 +40,23 @@
import java.util.List;
import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+
/**
* Rudimentary fake for SensorManager
*
- * Currently only supports the proximity sensor.
+ * Currently only supports proximity, light and tap sensors.
*
* Note that this class ignores the "Handler" argument, so the test is responsible for calling the
* listener on the right thread.
*/
public class FakeSensorManager extends SensorManager {
+ public static final String TAP_SENSOR_TYPE = "tapSensorType";
+
private final MockProximitySensor mMockProximitySensor;
private final FakeGenericSensor mFakeLightSensor;
+ private final FakeGenericSensor mFakeTapSensor;
private final FakeGenericSensor[] mSensors;
public FakeSensorManager(Context context) throws Exception {
@@ -59,12 +64,13 @@
.getDefaultSensor(Sensor.TYPE_PROXIMITY);
if (proxSensor == null) {
// No prox? Let's create a fake one!
- proxSensor = createSensor(Sensor.TYPE_PROXIMITY);
+ proxSensor = createSensor(Sensor.TYPE_PROXIMITY, null);
}
mSensors = new FakeGenericSensor[]{
mMockProximitySensor = new MockProximitySensor(proxSensor),
- mFakeLightSensor = new FakeGenericSensor(createSensor(Sensor.TYPE_LIGHT)),
+ mFakeLightSensor = new FakeGenericSensor(createSensor(Sensor.TYPE_LIGHT, null)),
+ mFakeTapSensor = new FakeGenericSensor(createSensor(99, TAP_SENSOR_TYPE))
};
}
@@ -76,6 +82,10 @@
return mFakeLightSensor;
}
+ public FakeGenericSensor getFakeTapSensor() {
+ return mFakeTapSensor;
+ }
+
@Override
public Sensor getDefaultSensor(int type) {
Sensor s = super.getDefaultSensor(type);
@@ -160,13 +170,13 @@
@Override
protected boolean requestTriggerSensorImpl(TriggerEventListener listener, Sensor sensor) {
- return false;
+ return true;
}
@Override
protected boolean cancelTriggerSensorImpl(TriggerEventListener listener, Sensor sensor,
boolean disable) {
- return false;
+ return true;
}
@Override
@@ -185,12 +195,15 @@
return false;
}
- private Sensor createSensor(int type) throws Exception {
+ private Sensor createSensor(int type, @Nullable String stringType) throws Exception {
Constructor<Sensor> constr = Sensor.class.getDeclaredConstructor();
constr.setAccessible(true);
Sensor sensor = constr.newInstance();
setSensorType(sensor, type);
+ if (stringType != null) {
+ setSensorField(sensor, "mStringType", stringType);
+ }
setSensorField(sensor, "mName", "Mock " + sensor.getStringType() + "/" + type);
setSensorField(sensor, "mVendor", "Mock Vendor");
setSensorField(sensor, "mVersion", 1);
diff --git a/services/backup/java/com/android/server/backup/FullBackupJob.java b/services/backup/java/com/android/server/backup/FullBackupJob.java
index f62a875..088e1f9 100644
--- a/services/backup/java/com/android/server/backup/FullBackupJob.java
+++ b/services/backup/java/com/android/server/backup/FullBackupJob.java
@@ -16,6 +16,8 @@
package com.android.server.backup;
+import static com.android.server.pm.PackageManagerService.PLATFORM_PACKAGE_NAME;
+
import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
@@ -37,7 +39,7 @@
public static final int MAX_JOB_ID = 52419896;
private static ComponentName sIdleService =
- new ComponentName("android", FullBackupJob.class.getName());
+ new ComponentName(PLATFORM_PACKAGE_NAME, FullBackupJob.class.getName());
@GuardedBy("mParamsForUser")
private final SparseArray<JobParameters> mParamsForUser = new SparseArray<>();
diff --git a/services/backup/java/com/android/server/backup/KeyValueBackupJob.java b/services/backup/java/com/android/server/backup/KeyValueBackupJob.java
index 72d81d3..ac43fc3 100644
--- a/services/backup/java/com/android/server/backup/KeyValueBackupJob.java
+++ b/services/backup/java/com/android/server/backup/KeyValueBackupJob.java
@@ -17,6 +17,7 @@
package com.android.server.backup;
import static com.android.server.backup.BackupManagerService.DEBUG_SCHEDULING;
+import static com.android.server.pm.PackageManagerService.PLATFORM_PACKAGE_NAME;
import android.app.AlarmManager;
import android.app.job.JobInfo;
@@ -43,7 +44,7 @@
public class KeyValueBackupJob extends JobService {
private static final String TAG = "KeyValueBackupJob";
private static ComponentName sKeyValueJobService =
- new ComponentName("android", KeyValueBackupJob.class.getName());
+ new ComponentName(PLATFORM_PACKAGE_NAME, KeyValueBackupJob.class.getName());
private static final String USER_ID_EXTRA_KEY = "userId";
diff --git a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
index a45f0c0..675a6eb 100644
--- a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
+++ b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
@@ -26,6 +26,7 @@
import static com.android.server.backup.internal.BackupHandler.MSG_BACKUP_RESTORE_STEP;
import static com.android.server.backup.internal.BackupHandler.MSG_RESTORE_OPERATION_TIMEOUT;
import static com.android.server.backup.internal.BackupHandler.MSG_RESTORE_SESSION_TIMEOUT;
+import static com.android.server.pm.PackageManagerService.PLATFORM_PACKAGE_NAME;
import android.annotation.Nullable;
import android.app.ApplicationThreadConstants;
@@ -222,7 +223,7 @@
try {
PackageManager pm = backupManagerService.getPackageManager();
PackageInfo info = pm.getPackageInfoAsUser(filterSet[i], 0, mUserId);
- if ("android".equals(info.packageName)) {
+ if (PLATFORM_PACKAGE_NAME.equals(info.packageName)) {
hasSystem = true;
continue;
}
@@ -241,7 +242,7 @@
if (hasSystem) {
try {
mAcceptSet.add(0, backupManagerService.getPackageManager().getPackageInfoAsUser(
- "android", 0, mUserId));
+ PLATFORM_PACKAGE_NAME, 0, mUserId));
} catch (NameNotFoundException e) {
// won't happen; we know a priori that it's valid
}
@@ -681,7 +682,7 @@
// an optimization: we know there's no widget data hosted/published by that
// package, and this way we avoid doing a spurious copy of MB-sized wallpaper
// data following the download.
- boolean staging = !packageName.equals("android");
+ boolean staging = !packageName.equals(PLATFORM_PACKAGE_NAME);
ParcelFileDescriptor stage;
File downloadFile = (staging) ? mStageName : mBackupDataName;
boolean startedAgentRestore = false;
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index adb0909..54fc739 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -392,7 +392,9 @@
import java.util.Map;
import java.util.Objects;
import java.util.Set;
+import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
@@ -7706,6 +7708,34 @@
return null;
}
+ int checkContentProviderUriPermission(Uri uri, int userId, int callingUid, int modeFlags) {
+ final String name = uri.getAuthority();
+ final long ident = Binder.clearCallingIdentity();
+ ContentProviderHolder holder = null;
+ try {
+ holder = getContentProviderExternalUnchecked(name, null, callingUid,
+ "*checkContentProviderUriPermission*", userId);
+ if (holder != null) {
+ return holder.provider.checkUriPermission(null, uri, callingUid, modeFlags);
+ }
+ } catch (RemoteException e) {
+ Log.w(TAG, "Content provider dead retrieving " + uri, e);
+ return PackageManager.PERMISSION_DENIED;
+ } catch (Exception e) {
+ Log.w(TAG, "Exception while determining type of " + uri, e);
+ return PackageManager.PERMISSION_DENIED;
+ } finally {
+ try {
+ if (holder != null) {
+ removeContentProviderExternalUnchecked(name, null, userId);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+ return PackageManager.PERMISSION_DENIED;
+ }
+
private boolean canClearIdentity(int callingPid, int callingUid, int userId) {
if (UserHandle.getUserId(callingUid) == userId) {
return true;
@@ -17826,6 +17856,35 @@
}
@Override
+ public int checkContentProviderUriPermission(Uri uri, int userId,
+ int callingUid, int modeFlags) {
+ // We can find ourselves needing to check Uri permissions while
+ // already holding the WM lock, which means reaching back here for
+ // the AM lock would cause an inversion. The WM team has requested
+ // that we use the strategy below instead of shifting where Uri
+ // grants are calculated.
+
+ // Since we could also arrive here while holding the AM lock, we
+ // can't always delegate the call through the handler, and we need
+ // to delicately dance between the deadlocks.
+ if (Thread.currentThread().holdsLock(ActivityManagerService.this)) {
+ return ActivityManagerService.this.checkContentProviderUriPermission(uri,
+ userId, callingUid, modeFlags);
+ } else {
+ final CompletableFuture<Integer> res = new CompletableFuture<>();
+ mHandler.post(() -> {
+ res.complete(ActivityManagerService.this.checkContentProviderUriPermission(uri,
+ userId, callingUid, modeFlags));
+ });
+ try {
+ return res.get();
+ } catch (InterruptedException | ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ @Override
public void onWakefulnessChanged(int wakefulness) {
ActivityManagerService.this.onWakefulnessChanged(wakefulness);
}
diff --git a/services/core/java/com/android/server/am/EventLogTags.logtags b/services/core/java/com/android/server/am/EventLogTags.logtags
index 421b755..cf0de06 100644
--- a/services/core/java/com/android/server/am/EventLogTags.logtags
+++ b/services/core/java/com/android/server/am/EventLogTags.logtags
@@ -146,4 +146,7 @@
30065 am_on_top_resumed_lost_called (Token|1|5),(Component Name|3),(Reason|3)
# An activity been add into stopping list
-30066 am_add_to_stopping (User|1|5),(Token|1|5),(Component Name|3),(Reason|3)
\ No newline at end of file
+30066 am_add_to_stopping (User|1|5),(Token|1|5),(Component Name|3),(Reason|3)
+
+# Keyguard status changed
++30067 am_set_keyguard_shown (keyguardShowing|1),(aodShowing|1),(keyguardGoingAway|1),(Reason|3)
\ No newline at end of file
diff --git a/services/core/java/com/android/server/am/ProcessList.java b/services/core/java/com/android/server/am/ProcessList.java
index ffbc6b3..5465309 100644
--- a/services/core/java/com/android/server/am/ProcessList.java
+++ b/services/core/java/com/android/server/am/ProcessList.java
@@ -1526,6 +1526,9 @@
if ("1".equals(SystemProperties.get("debug.assert"))) {
runtimeFlags |= Zygote.DEBUG_ENABLE_ASSERT;
}
+ if ("1".equals(SystemProperties.get("debug.ignoreappsignalhandler"))) {
+ runtimeFlags |= Zygote.DEBUG_IGNORE_APP_SIGNAL_HANDLER;
+ }
if (mService.mNativeDebuggingApp != null
&& mService.mNativeDebuggingApp.equals(app.processName)) {
// Enable all debug flags required by the native debugger.
diff --git a/services/core/java/com/android/server/audio/AudioDeviceBroker.java b/services/core/java/com/android/server/audio/AudioDeviceBroker.java
index 4d09c3b..cb6cf74 100644
--- a/services/core/java/com/android/server/audio/AudioDeviceBroker.java
+++ b/services/core/java/com/android/server/audio/AudioDeviceBroker.java
@@ -125,6 +125,8 @@
/*package*/ void onAudioServerDied() {
// Restore forced usage for communications and record
synchronized (mDeviceStateLock) {
+ AudioSystem.setParameters(
+ "BT_SCO=" + (mForcedUseForComm == AudioSystem.FORCE_BT_SCO ? "on" : "off"));
onSetForceUse(AudioSystem.FOR_COMMUNICATION, mForcedUseForComm, "onAudioServerDied");
onSetForceUse(AudioSystem.FOR_RECORD, mForcedUseForComm, "onAudioServerDied");
}
diff --git a/services/core/java/com/android/server/audio/AudioService.java b/services/core/java/com/android/server/audio/AudioService.java
index 6c57be8..7458bee 100644
--- a/services/core/java/com/android/server/audio/AudioService.java
+++ b/services/core/java/com/android/server/audio/AudioService.java
@@ -5181,6 +5181,7 @@
/**
* @return true if there is currently a registered dynamic mixing policy that affects media
+ * and is not a render + loopback policy
*/
/*package*/ boolean hasMediaDynamicPolicy() {
synchronized (mAudioPolicies) {
@@ -5189,7 +5190,8 @@
}
final Collection<AudioPolicyProxy> appColl = mAudioPolicies.values();
for (AudioPolicyProxy app : appColl) {
- if (app.hasMixAffectingUsage(AudioAttributes.USAGE_MEDIA)) {
+ if (app.hasMixAffectingUsage(AudioAttributes.USAGE_MEDIA,
+ AudioMix.ROUTE_FLAG_LOOP_BACK_RENDER)) {
return true;
}
}
@@ -6961,9 +6963,10 @@
Binder.restoreCallingIdentity(identity);
}
- boolean hasMixAffectingUsage(int usage) {
+ boolean hasMixAffectingUsage(int usage, int excludedFlags) {
for (AudioMix mix : mMixes) {
- if (mix.isAffectingUsage(usage)) {
+ if (mix.isAffectingUsage(usage)
+ && ((mix.getRouteFlags() & excludedFlags) != excludedFlags)) {
return true;
}
}
diff --git a/services/core/java/com/android/server/display/DisplayManagerService.java b/services/core/java/com/android/server/display/DisplayManagerService.java
index 99341d1..4f33ebb0 100644
--- a/services/core/java/com/android/server/display/DisplayManagerService.java
+++ b/services/core/java/com/android/server/display/DisplayManagerService.java
@@ -303,6 +303,8 @@
private final Spline mMinimumBrightnessSpline;
private final ColorSpace mWideColorSpace;
+ private SensorManager mSensorManager;
+
public DisplayManagerService(Context context) {
this(context, new Injector());
}
@@ -430,7 +432,7 @@
}
mDisplayModeDirector.setListener(new AllowedDisplayModeObserver());
- mDisplayModeDirector.start();
+ mDisplayModeDirector.start(mSensorManager);
mHandler.sendEmptyMessage(MSG_REGISTER_ADDITIONAL_DISPLAY_ADAPTERS);
}
@@ -2358,6 +2360,7 @@
};
mDisplayPowerController = new DisplayPowerController(
mContext, callbacks, handler, sensorManager, blanker);
+ mSensorManager = sensorManager;
}
mHandler.sendEmptyMessage(MSG_LOAD_BRIGHTNESS_CONFIGURATION);
diff --git a/services/core/java/com/android/server/display/DisplayModeDirector.java b/services/core/java/com/android/server/display/DisplayModeDirector.java
index 14bd2d8..78a48da 100644
--- a/services/core/java/com/android/server/display/DisplayModeDirector.java
+++ b/services/core/java/com/android/server/display/DisplayModeDirector.java
@@ -18,26 +18,41 @@
import android.annotation.NonNull;
import android.annotation.Nullable;
+import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.Resources;
import android.database.ContentObserver;
import android.hardware.display.DisplayManager;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.UserHandle;
+import android.os.PowerManager;
+import android.os.SystemClock;
import android.provider.Settings;
+import android.text.TextUtils;
import android.util.Slog;
import android.util.SparseArray;
import android.view.Display;
import android.view.DisplayInfo;
import com.android.internal.R;
+import com.android.server.display.whitebalance.DisplayWhiteBalanceFactory;
+import com.android.server.display.whitebalance.AmbientFilter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.List;
import java.util.Objects;
/**
@@ -74,7 +89,7 @@
private final AppRequestObserver mAppRequestObserver;
private final SettingsObserver mSettingsObserver;
private final DisplayObserver mDisplayObserver;
-
+ private final BrightnessObserver mBrightnessObserver;
private Listener mListener;
@@ -87,6 +102,8 @@
mAppRequestObserver = new AppRequestObserver();
mSettingsObserver = new SettingsObserver(context, handler);
mDisplayObserver = new DisplayObserver(context, handler);
+ mBrightnessObserver = new BrightnessObserver(context, handler);
+
}
/**
@@ -96,15 +113,17 @@
* This has to be deferred because the object may be constructed before the rest of the system
* is ready.
*/
- public void start() {
+ public void start(SensorManager sensorManager) {
mSettingsObserver.observe();
mDisplayObserver.observe();
mSettingsObserver.observe();
+ mBrightnessObserver.observe(sensorManager);
synchronized (mLock) {
// We may have a listener already registered before the call to start, so go ahead and
// notify them to pick up our newly initialized state.
notifyAllowedModesChangedLocked();
}
+
}
/**
@@ -315,6 +334,7 @@
}
mSettingsObserver.dumpLocked(pw);
mAppRequestObserver.dumpLocked(pw);
+ mBrightnessObserver.dumpLocked(pw);
}
}
@@ -486,20 +506,15 @@
Settings.System.getUriFor(Settings.System.PEAK_REFRESH_RATE);
private final Uri mLowPowerModeSetting =
Settings.Global.getUriFor(Settings.Global.LOW_POWER_MODE);
- private final Uri mBrightnessSetting =
- Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS);
private final Context mContext;
private final float mDefaultPeakRefreshRate;
- private final int mBrightnessThreshold;
SettingsObserver(@NonNull Context context, @NonNull Handler handler) {
super(handler);
mContext = context;
mDefaultPeakRefreshRate = (float) context.getResources().getInteger(
R.integer.config_defaultPeakRefreshRate);
- mBrightnessThreshold = context.getResources().getInteger(
- R.integer.config_brightnessThresholdOfPeakRefreshRate);
}
public void observe() {
@@ -508,14 +523,9 @@
UserHandle.USER_SYSTEM);
cr.registerContentObserver(mLowPowerModeSetting, false /*notifyDescendants*/, this,
UserHandle.USER_SYSTEM);
- if (mBrightnessThreshold >= 0) {
- cr.registerContentObserver(mBrightnessSetting, false /*notifyDescendants*/, this,
- UserHandle.USER_SYSTEM);
- }
synchronized (mLock) {
updateRefreshRateSettingLocked();
updateLowPowerModeSettingLocked();
- updateBrightnessSettingLocked();
}
}
@@ -526,8 +536,6 @@
updateRefreshRateSettingLocked();
} else if (mLowPowerModeSetting.equals(uri)) {
updateLowPowerModeSettingLocked();
- } else if (mBrightnessThreshold >=0 && mBrightnessSetting.equals(uri)) {
- updateBrightnessSettingLocked();
}
}
}
@@ -542,6 +550,7 @@
vote = null;
}
updateVoteLocked(Vote.PRIORITY_LOW_POWER_MODE, vote);
+ mBrightnessObserver.onLowPowerModeEnabled(inLowPowerMode);
}
private void updateRefreshRateSettingLocked() {
@@ -549,23 +558,7 @@
Settings.System.PEAK_REFRESH_RATE, mDefaultPeakRefreshRate);
Vote vote = Vote.forRefreshRates(0f, peakRefreshRate);
updateVoteLocked(Vote.PRIORITY_USER_SETTING_REFRESH_RATE, vote);
- }
-
- private void updateBrightnessSettingLocked() {
- int brightness = Settings.System.getInt(mContext.getContentResolver(),
- Settings.System.SCREEN_BRIGHTNESS, -1);
-
- if (brightness < 0) {
- return;
- }
-
- final Vote vote;
- if (brightness <= mBrightnessThreshold) {
- vote = Vote.forRefreshRates(0f, 60f);
- } else {
- vote = null;
- }
- updateVoteLocked(Vote.PRIORITY_LOW_BRIGHTNESS, vote);
+ mBrightnessObserver.onPeakRefreshRateEnabled(peakRefreshRate > 60f);
}
public void dumpLocked(PrintWriter pw) {
@@ -715,4 +708,240 @@
}
}
}
+
+ /**
+ * This class manages brightness threshold for switching between 60 hz and higher refresh rate.
+ * See more information at the definition of
+ * {@link R.array#config_brightnessThresholdsOfPeakRefreshRate} and
+ * {@link R.array#config_ambientThresholdsOfPeakRefreshRate}.
+ */
+ private class BrightnessObserver extends ContentObserver {
+ private final Uri mDisplayBrightnessSetting =
+ Settings.System.getUriFor(Settings.System.SCREEN_BRIGHTNESS);
+
+ private final static int LIGHT_SENSOR_RATE_MS = 250;
+ private final int[] mDisplayBrightnessThresholds;
+ private final int[] mAmbientBrightnessThresholds;
+ // valid threshold if any item from the array >= 0
+ private boolean mShouldObserveDisplayChange;
+ private boolean mShouldObserveAmbientChange;
+
+ private SensorManager mSensorManager;
+ private Sensor mLightSensor;
+ // Take it as low brightness before valid sensor data comes
+ private float mAmbientLux = -1.0f;
+ private AmbientFilter mAmbientFilter;
+
+ private final Context mContext;
+ private ScreenStateReceiver mScreenStateReceiver;
+
+ // Enable light sensor only when screen is on, peak refresh rate enabled and low power mode
+ // off. After initialization, these states will be updated from the same handler thread.
+ private boolean mScreenOn = false;
+ private boolean mPeakRefreshRateEnabled = false;
+ private boolean mLowPowerModeEnabled = false;
+
+ BrightnessObserver(Context context, Handler handler) {
+ super(handler);
+ mContext = context;
+ mDisplayBrightnessThresholds = context.getResources().getIntArray(
+ R.array.config_brightnessThresholdsOfPeakRefreshRate);
+ mAmbientBrightnessThresholds = context.getResources().getIntArray(
+ R.array.config_ambientThresholdsOfPeakRefreshRate);
+ if (mDisplayBrightnessThresholds.length != mAmbientBrightnessThresholds.length) {
+ throw new RuntimeException("display brightness threshold array and ambient "
+ + "brightness threshold array have different length");
+ }
+
+ mShouldObserveDisplayChange = checkShouldObserve(mDisplayBrightnessThresholds);
+ mShouldObserveAmbientChange = checkShouldObserve(mAmbientBrightnessThresholds);
+ }
+
+ public void observe(SensorManager sensorManager) {
+ if (mShouldObserveDisplayChange) {
+ final ContentResolver cr = mContext.getContentResolver();
+ cr.registerContentObserver(mDisplayBrightnessSetting,
+ false /*notifyDescendants*/, this, UserHandle.USER_SYSTEM);
+ }
+
+ if (mShouldObserveAmbientChange) {
+ Resources resources = mContext.getResources();
+ String lightSensorType = resources.getString(
+ com.android.internal.R.string.config_displayLightSensorType);
+
+ Sensor lightSensor = null;
+ if (!TextUtils.isEmpty(lightSensorType)) {
+ List<Sensor> sensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
+ for (int i = 0; i < sensors.size(); i++) {
+ Sensor sensor = sensors.get(i);
+ if (lightSensorType.equals(sensor.getStringType())) {
+ lightSensor = sensor;
+ break;
+ }
+ }
+ }
+
+ if (lightSensor == null) {
+ lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
+ }
+
+ if (lightSensor != null) {
+ final Resources res = mContext.getResources();
+
+ mAmbientFilter = DisplayWhiteBalanceFactory.createBrightnessFilter(res);
+ mSensorManager = sensorManager;
+ mLightSensor = lightSensor;
+
+ // Intent.ACTION_SCREEN_ON is not sticky. Check current screen status.
+ if (mContext.getSystemService(PowerManager.class).isInteractive()) {
+ onScreenOn(true);
+ }
+ mScreenStateReceiver = new ScreenStateReceiver(mContext);
+ }
+ }
+
+ if (mShouldObserveDisplayChange || mShouldObserveAmbientChange) {
+ synchronized (mLock) {
+ onBrightnessChangedLocked();
+ }
+ }
+ }
+
+ public void onPeakRefreshRateEnabled(boolean b) {
+ if (mShouldObserveAmbientChange && mPeakRefreshRateEnabled != b) {
+ mPeakRefreshRateEnabled = b;
+ updateSensorStatus();
+ }
+ }
+
+ public void onLowPowerModeEnabled(boolean b) {
+ if (mShouldObserveAmbientChange && mLowPowerModeEnabled != b) {
+ mLowPowerModeEnabled = b;
+ updateSensorStatus();
+ }
+ }
+
+ public void dumpLocked(PrintWriter pw) {
+ pw.println(" BrightnessObserver");
+
+ for (int d: mDisplayBrightnessThresholds) {
+ pw.println(" mDisplayBrightnessThreshold: " + d);
+ }
+
+ for (int d: mAmbientBrightnessThresholds) {
+ pw.println(" mAmbientBrightnessThreshold: " + d);
+ }
+ }
+
+ @Override
+ public void onChange(boolean selfChange, Uri uri, int userId) {
+ synchronized (mLock) {
+ onBrightnessChangedLocked();
+ }
+ }
+
+ /**
+ * Checks to see if at least one value is positive, in which case it is necessary to listen
+ * to value changes.
+ */
+ private boolean checkShouldObserve(int[] a) {
+ for (int d: a) {
+ if (d >= 0) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private void onBrightnessChangedLocked() {
+ int brightness = Settings.System.getInt(mContext.getContentResolver(),
+ Settings.System.SCREEN_BRIGHTNESS, -1);
+
+ Vote vote = null;
+ for (int i = 0; i < mDisplayBrightnessThresholds.length; i++) {
+ int disp = mDisplayBrightnessThresholds[i];
+ int ambi = mAmbientBrightnessThresholds[i];
+
+ if (disp >= 0 && ambi >= 0) {
+ if (brightness <= disp && mAmbientLux <= ambi) {
+ vote = Vote.forRefreshRates(0f, 60f);
+ }
+ } else if (disp >= 0) {
+ if (brightness <= disp) {
+ vote = Vote.forRefreshRates(0f, 60f);
+ }
+ } else if (ambi >= 0) {
+ if (mAmbientLux <= ambi) {
+ vote = Vote.forRefreshRates(0f, 60f);
+ }
+ }
+
+ if (vote != null) {
+ break;
+ }
+ }
+
+ if (DEBUG) {
+ Slog.d(TAG, "Display brightness " + brightness + ", ambient lux " + mAmbientLux +
+ (vote != null ? " 60hz only" : " no refresh rate limit"));
+ }
+ updateVoteLocked(Vote.PRIORITY_LOW_BRIGHTNESS, vote);
+ }
+
+ private void onScreenOn(boolean on) {
+ // Not check mShouldObserveAmbientChange because Screen status receiver is registered
+ // only when it is true.
+ if (mScreenOn != on) {
+ mScreenOn = on;
+ updateSensorStatus();
+ }
+ }
+
+ private void updateSensorStatus() {
+ if (mSensorManager == null || mLightSensorListener == null) {
+ return;
+ }
+
+ if (mScreenOn && !mLowPowerModeEnabled && mPeakRefreshRateEnabled) {
+ mSensorManager.registerListener(mLightSensorListener,
+ mLightSensor, LIGHT_SENSOR_RATE_MS * 1000, mHandler);
+ } else {
+ mSensorManager.unregisterListener(mLightSensorListener);
+ }
+ }
+
+ private final SensorEventListener mLightSensorListener = new SensorEventListener() {
+ @Override
+ public void onSensorChanged(SensorEvent event) {
+ long now = SystemClock.uptimeMillis();
+ mAmbientFilter.addValue(now, event.values[0]);
+ mAmbientLux = mAmbientFilter.getEstimate(now);
+
+ synchronized (mLock) {
+ onBrightnessChangedLocked();
+ }
+ }
+
+ @Override
+ public void onAccuracyChanged(Sensor sensor, int accuracy) {
+ // Not used.
+ }
+ };
+
+ private final class ScreenStateReceiver extends BroadcastReceiver {
+ public ScreenStateReceiver(Context context) {
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(Intent.ACTION_SCREEN_OFF);
+ filter.addAction(Intent.ACTION_SCREEN_ON);
+ filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
+ context.registerReceiver(this, filter, null, mHandler);
+ }
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ onScreenOn(Intent.ACTION_SCREEN_ON.equals(intent.getAction()));
+ }
+ }
+ }
}
diff --git a/services/core/java/com/android/server/display/color/ColorDisplayService.java b/services/core/java/com/android/server/display/color/ColorDisplayService.java
index 2e5aafe..7fb5b19 100644
--- a/services/core/java/com/android/server/display/color/ColorDisplayService.java
+++ b/services/core/java/com/android/server/display/color/ColorDisplayService.java
@@ -63,6 +63,8 @@
import android.provider.Settings.System;
import android.util.MathUtils;
import android.util.Slog;
+import android.util.SparseIntArray;
+import android.view.Display;
import android.view.SurfaceControl;
import android.view.accessibility.AccessibilityManager;
import android.view.animation.AnimationUtils;
@@ -171,6 +173,11 @@
private NightDisplayAutoMode mNightDisplayAutoMode;
+ /**
+ * Map of color modes -> display composition colorspace
+ */
+ private SparseIntArray mColorModeCompositionColorSpaces = null;
+
public ColorDisplayService(Context context) {
super(context);
mHandler = new TintHandler(DisplayThread.get().getLooper());
@@ -267,6 +274,30 @@
return Secure.getIntForUser(cr, Secure.USER_SETUP_COMPLETE, 0, userHandle) == 1;
}
+ private void setUpDisplayCompositionColorSpaces(Resources res) {
+ mColorModeCompositionColorSpaces = null;
+
+ final int[] colorModes = res.getIntArray(R.array.config_displayCompositionColorModes);
+ if (colorModes == null) {
+ return;
+ }
+
+ final int[] compSpaces = res.getIntArray(R.array.config_displayCompositionColorSpaces);
+ if (compSpaces == null) {
+ return;
+ }
+
+ if (colorModes.length != compSpaces.length) {
+ Slog.e(TAG, "Number of composition color spaces doesn't match specified color modes");
+ return;
+ }
+
+ mColorModeCompositionColorSpaces = new SparseIntArray(colorModes.length);
+ for (int i = 0; i < colorModes.length; i++) {
+ mColorModeCompositionColorSpaces.put(colorModes[i], compSpaces[i]);
+ }
+ }
+
private void setUp() {
Slog.d(TAG, "setUp: currentUser=" + mCurrentUser);
@@ -359,6 +390,8 @@
onAccessibilityInversionChanged();
onAccessibilityDaltonizerChanged();
+ setUpDisplayCompositionColorSpaces(getContext().getResources());
+
// Set the color mode, if valid, and immediately apply the updated tint matrix based on the
// existing activated state. This ensures consistency of tint across the color mode change.
onDisplayColorModeChanged(getColorModeInternal());
@@ -450,6 +483,14 @@
}
}
+ private int getCompositionColorSpace(int mode) {
+ if (mColorModeCompositionColorSpaces == null) {
+ return Display.COLOR_MODE_INVALID;
+ }
+
+ return mColorModeCompositionColorSpaces.get(mode, Display.COLOR_MODE_INVALID);
+ }
+
private void onDisplayColorModeChanged(int mode) {
if (mode == NOT_SET) {
return;
@@ -470,7 +511,8 @@
// DisplayTransformManager.needsLinearColorMatrix(), therefore it is dependent
// on the state of DisplayTransformManager.
final DisplayTransformManager dtm = getLocalService(DisplayTransformManager.class);
- dtm.setColorMode(mode, mNightDisplayTintController.getMatrix());
+ dtm.setColorMode(mode, mNightDisplayTintController.getMatrix(),
+ getCompositionColorSpace(mode));
if (mDisplayWhiteBalanceTintController.isAvailable(getContext())) {
updateDisplayWhiteBalanceStatus();
diff --git a/services/core/java/com/android/server/display/color/DisplayTransformManager.java b/services/core/java/com/android/server/display/color/DisplayTransformManager.java
index 5ff45a9..d5706a5 100644
--- a/services/core/java/com/android/server/display/color/DisplayTransformManager.java
+++ b/services/core/java/com/android/server/display/color/DisplayTransformManager.java
@@ -26,6 +26,7 @@
import android.os.SystemProperties;
import android.util.Slog;
import android.util.SparseArray;
+import android.view.Display;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
@@ -77,6 +78,8 @@
@VisibleForTesting
static final String PERSISTENT_PROPERTY_SATURATION = "persist.sys.sf.color_saturation";
@VisibleForTesting
+ static final String PERSISTENT_PROPERTY_COMPOSITION_COLOR_MODE = "persist.sys.sf.color_mode";
+ @VisibleForTesting
static final String PERSISTENT_PROPERTY_DISPLAY_COLOR = "persist.sys.sf.native_mode";
private static final float COLOR_SATURATION_NATURAL = 1.0f;
@@ -251,23 +254,24 @@
/**
* Sets color mode and updates night display transform values.
*/
- public boolean setColorMode(int colorMode, float[] nightDisplayMatrix) {
+ public boolean setColorMode(int colorMode, float[] nightDisplayMatrix,
+ int compositionColorMode) {
if (colorMode == ColorDisplayManager.COLOR_MODE_NATURAL) {
applySaturation(COLOR_SATURATION_NATURAL);
- setDisplayColor(DISPLAY_COLOR_MANAGED);
+ setDisplayColor(DISPLAY_COLOR_MANAGED, compositionColorMode);
} else if (colorMode == ColorDisplayManager.COLOR_MODE_BOOSTED) {
applySaturation(COLOR_SATURATION_BOOSTED);
- setDisplayColor(DISPLAY_COLOR_MANAGED);
+ setDisplayColor(DISPLAY_COLOR_MANAGED, compositionColorMode);
} else if (colorMode == ColorDisplayManager.COLOR_MODE_SATURATED) {
applySaturation(COLOR_SATURATION_NATURAL);
- setDisplayColor(DISPLAY_COLOR_UNMANAGED);
+ setDisplayColor(DISPLAY_COLOR_UNMANAGED, compositionColorMode);
} else if (colorMode == ColorDisplayManager.COLOR_MODE_AUTOMATIC) {
applySaturation(COLOR_SATURATION_NATURAL);
- setDisplayColor(DISPLAY_COLOR_ENHANCED);
+ setDisplayColor(DISPLAY_COLOR_ENHANCED, compositionColorMode);
} else if (colorMode >= ColorDisplayManager.VENDOR_COLOR_MODE_RANGE_MIN
&& colorMode <= ColorDisplayManager.VENDOR_COLOR_MODE_RANGE_MAX) {
applySaturation(COLOR_SATURATION_NATURAL);
- setDisplayColor(colorMode);
+ setDisplayColor(colorMode, compositionColorMode);
}
setColorMatrix(LEVEL_COLOR_MATRIX_NIGHT_DISPLAY, nightDisplayMatrix);
@@ -323,13 +327,21 @@
/**
* Toggles native mode on/off in SurfaceFlinger.
*/
- private void setDisplayColor(int color) {
+ private void setDisplayColor(int color, int compositionColorMode) {
SystemProperties.set(PERSISTENT_PROPERTY_DISPLAY_COLOR, Integer.toString(color));
+ if (compositionColorMode != Display.COLOR_MODE_INVALID) {
+ SystemProperties.set(PERSISTENT_PROPERTY_COMPOSITION_COLOR_MODE,
+ Integer.toString(compositionColorMode));
+ }
+
final IBinder flinger = ServiceManager.getService(SURFACE_FLINGER);
if (flinger != null) {
final Parcel data = Parcel.obtain();
data.writeInterfaceToken("android.ui.ISurfaceComposer");
data.writeInt(color);
+ if (compositionColorMode != Display.COLOR_MODE_INVALID) {
+ data.writeInt(compositionColorMode);
+ }
try {
flinger.transact(SURFACE_FLINGER_TRANSACTION_DISPLAY_COLOR, data, null, 0);
} catch (RemoteException ex) {
diff --git a/services/core/java/com/android/server/display/whitebalance/AmbientFilter.java b/services/core/java/com/android/server/display/whitebalance/AmbientFilter.java
index 123cd73..3580897 100644
--- a/services/core/java/com/android/server/display/whitebalance/AmbientFilter.java
+++ b/services/core/java/com/android/server/display/whitebalance/AmbientFilter.java
@@ -36,7 +36,7 @@
* - {@link WeightedMovingAverageAmbientFilter}
* A weighted average prioritising recent changes.
*/
-abstract class AmbientFilter {
+abstract public class AmbientFilter {
protected static final boolean DEBUG = false; // Enable for verbose logs.
@@ -156,8 +156,7 @@
/**
* A weighted average prioritising recent changes.
*/
- @VisibleForTesting
- public static class WeightedMovingAverageAmbientFilter extends AmbientFilter {
+ static class WeightedMovingAverageAmbientFilter extends AmbientFilter {
// How long the latest ambient value change is predicted to last.
private static final int PREDICTION_TIME = 100; // Milliseconds
diff --git a/services/core/java/com/android/server/display/whitebalance/DisplayWhiteBalanceFactory.java b/services/core/java/com/android/server/display/whitebalance/DisplayWhiteBalanceFactory.java
index 4df7d6b..bf0a1d1 100644
--- a/services/core/java/com/android/server/display/whitebalance/DisplayWhiteBalanceFactory.java
+++ b/services/core/java/com/android/server/display/whitebalance/DisplayWhiteBalanceFactory.java
@@ -115,8 +115,7 @@
* Creates a BrightnessFilter which functions as a weighted moving average buffer for recent
* brightness values.
*/
- @VisibleForTesting
- static AmbientFilter createBrightnessFilter(Resources resources) {
+ public static AmbientFilter createBrightnessFilter(Resources resources) {
final int horizon = resources.getInteger(
com.android.internal.R.integer.config_displayWhiteBalanceBrightnessFilterHorizon);
final float intercept = getFloat(resources,
@@ -129,7 +128,6 @@
+ "expected config_displayWhiteBalanceBrightnessFilterIntercept");
}
-
/**
* Creates an ambient color sensor instance to redirect sensor data to callbacks.
*/
diff --git a/services/core/java/com/android/server/job/controllers/TimeController.java b/services/core/java/com/android/server/job/controllers/TimeController.java
index ababad9..4c11947 100644
--- a/services/core/java/com/android/server/job/controllers/TimeController.java
+++ b/services/core/java/com/android/server/job/controllers/TimeController.java
@@ -18,20 +18,13 @@
import static com.android.server.job.JobSchedulerService.sElapsedRealtimeClock;
-import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.AlarmManager;
import android.app.AlarmManager.OnAlarmListener;
-import android.content.ContentResolver;
import android.content.Context;
-import android.database.ContentObserver;
-import android.net.Uri;
-import android.os.Handler;
import android.os.Process;
import android.os.UserHandle;
import android.os.WorkSource;
-import android.provider.Settings;
-import android.util.KeyValueListParser;
import android.util.Log;
import android.util.Slog;
import android.util.TimeUtils;
@@ -39,7 +32,6 @@
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IndentingPrintWriter;
-import com.android.server.job.ConstantsProto;
import com.android.server.job.JobSchedulerService;
import com.android.server.job.StateControllerProto;
@@ -63,9 +55,6 @@
/** Delay alarm tag for logging purposes */
private final String DELAY_TAG = "*job.delay*";
- private final Handler mHandler;
- private final TcConstants mTcConstants;
-
private long mNextJobExpiredElapsedMillis;
private long mNextDelayExpiredElapsedMillis;
@@ -81,14 +70,6 @@
mNextJobExpiredElapsedMillis = Long.MAX_VALUE;
mNextDelayExpiredElapsedMillis = Long.MAX_VALUE;
mChainedAttributionEnabled = mService.isChainedAttributionEnabled();
-
- mHandler = new Handler(mContext.getMainLooper());
- mTcConstants = new TcConstants(mHandler);
- }
-
- @Override
- public void onSystemServicesReady() {
- mTcConstants.start(mContext.getContentResolver());
}
/**
@@ -133,20 +114,16 @@
job.setTrackingController(JobStatus.TRACKING_TIME);
WorkSource ws = deriveWorkSource(job.getSourceUid(), job.getSourcePackageName());
- final long deadlineExpiredElapsed =
- job.hasDeadlineConstraint() ? job.getLatestRunTimeElapsed() : Long.MAX_VALUE;
- final long delayExpiredElapsed =
- job.hasTimingDelayConstraint() ? job.getEarliestRunTime() : Long.MAX_VALUE;
- if (mTcConstants.SKIP_NOT_READY_JOBS) {
- if (wouldBeReadyWithConstraintLocked(job, JobStatus.CONSTRAINT_TIMING_DELAY)) {
- maybeUpdateDelayAlarmLocked(delayExpiredElapsed, ws);
- }
- if (wouldBeReadyWithConstraintLocked(job, JobStatus.CONSTRAINT_DEADLINE)) {
- maybeUpdateDeadlineAlarmLocked(deadlineExpiredElapsed, ws);
- }
- } else {
- maybeUpdateDelayAlarmLocked(delayExpiredElapsed, ws);
- maybeUpdateDeadlineAlarmLocked(deadlineExpiredElapsed, ws);
+
+ // Only update alarms if the job would be ready with the relevant timing constraint
+ // satisfied.
+ if (job.hasTimingDelayConstraint()
+ && wouldBeReadyWithConstraintLocked(job, JobStatus.CONSTRAINT_TIMING_DELAY)) {
+ maybeUpdateDelayAlarmLocked(job.getEarliestRunTime(), ws);
+ }
+ if (job.hasDeadlineConstraint()
+ && wouldBeReadyWithConstraintLocked(job, JobStatus.CONSTRAINT_DEADLINE)) {
+ maybeUpdateDeadlineAlarmLocked(job.getLatestRunTimeElapsed(), ws);
}
}
}
@@ -168,10 +145,6 @@
@Override
public void evaluateStateLocked(JobStatus job) {
- if (!mTcConstants.SKIP_NOT_READY_JOBS) {
- return;
- }
-
final long nowElapsedMillis = sElapsedRealtimeClock.millis();
// Check deadline constraint first because if it's satisfied, we avoid a little bit of
@@ -261,9 +234,7 @@
}
it.remove();
} else { // Sorted by expiry time, so take the next one and stop.
- if (mTcConstants.SKIP_NOT_READY_JOBS
- && !wouldBeReadyWithConstraintLocked(
- job, JobStatus.CONSTRAINT_DEADLINE)) {
+ if (!wouldBeReadyWithConstraintLocked(job, JobStatus.CONSTRAINT_DEADLINE)) {
if (DEBUG) {
Slog.i(TAG,
"Skipping " + job + " because deadline won't make it ready.");
@@ -321,9 +292,7 @@
ready = true;
}
} else {
- if (mTcConstants.SKIP_NOT_READY_JOBS
- && !wouldBeReadyWithConstraintLocked(
- job, JobStatus.CONSTRAINT_TIMING_DELAY)) {
+ if (!wouldBeReadyWithConstraintLocked(job, JobStatus.CONSTRAINT_TIMING_DELAY)) {
if (DEBUG) {
Slog.i(TAG,
"Skipping " + job + " because delay won't make it ready.");
@@ -458,81 +427,6 @@
checkExpiredDelaysAndResetAlarm();
}
- @VisibleForTesting
- class TcConstants extends ContentObserver {
- private ContentResolver mResolver;
- private final KeyValueListParser mParser = new KeyValueListParser(',');
-
- private static final String KEY_SKIP_NOT_READY_JOBS = "skip_not_ready_jobs";
-
- private static final boolean DEFAULT_SKIP_NOT_READY_JOBS = true;
-
- /**
- * Whether or not TimeController should skip setting wakeup alarms for jobs that aren't
- * ready now.
- */
- public boolean SKIP_NOT_READY_JOBS = DEFAULT_SKIP_NOT_READY_JOBS;
-
- /**
- * Creates a content observer.
- *
- * @param handler The handler to run {@link #onChange} on, or null if none.
- */
- TcConstants(Handler handler) {
- super(handler);
- }
-
- private void start(ContentResolver resolver) {
- mResolver = resolver;
- mResolver.registerContentObserver(Settings.Global.getUriFor(
- Settings.Global.JOB_SCHEDULER_TIME_CONTROLLER_CONSTANTS), false, this);
- onChange(true, null);
- }
-
- @Override
- public void onChange(boolean selfChange, Uri uri) {
- final String constants = Settings.Global.getString(
- mResolver, Settings.Global.JOB_SCHEDULER_TIME_CONTROLLER_CONSTANTS);
-
- try {
- mParser.setString(constants);
- } catch (Exception e) {
- // Failed to parse the settings string, log this and move on with defaults.
- Slog.e(TAG, "Bad jobscheduler time controller settings", e);
- }
-
- final boolean oldVal = SKIP_NOT_READY_JOBS;
- SKIP_NOT_READY_JOBS = mParser.getBoolean(
- KEY_SKIP_NOT_READY_JOBS, DEFAULT_SKIP_NOT_READY_JOBS);
-
- if (oldVal != SKIP_NOT_READY_JOBS) {
- synchronized (mLock) {
- recheckAlarmsLocked();
- }
- }
- }
-
- private void dump(IndentingPrintWriter pw) {
- pw.println();
- pw.println("TimeController:");
- pw.increaseIndent();
- pw.printPair(KEY_SKIP_NOT_READY_JOBS, SKIP_NOT_READY_JOBS).println();
- pw.decreaseIndent();
- }
-
- private void dump(ProtoOutputStream proto) {
- final long tcToken = proto.start(ConstantsProto.TIME_CONTROLLER);
- proto.write(ConstantsProto.TimeController.SKIP_NOT_READY_JOBS, SKIP_NOT_READY_JOBS);
- proto.end(tcToken);
- }
- }
-
- @VisibleForTesting
- @NonNull
- TcConstants getTcConstants() {
- return mTcConstants;
- }
-
@Override
public void dumpControllerStateLocked(IndentingPrintWriter pw,
Predicate<JobStatus> predicate) {
@@ -607,14 +501,4 @@
proto.end(mToken);
proto.end(token);
}
-
- @Override
- public void dumpConstants(IndentingPrintWriter pw) {
- mTcConstants.dump(pw);
- }
-
- @Override
- public void dumpConstants(ProtoOutputStream proto) {
- mTcConstants.dump(proto);
- }
}
diff --git a/services/core/java/com/android/server/locksettings/PasswordSlotManager.java b/services/core/java/com/android/server/locksettings/PasswordSlotManager.java
index 5cbd237..4ef63c0 100644
--- a/services/core/java/com/android/server/locksettings/PasswordSlotManager.java
+++ b/services/core/java/com/android/server/locksettings/PasswordSlotManager.java
@@ -122,7 +122,7 @@
*/
public void markSlotDeleted(int slot) throws RuntimeException {
ensureSlotMapLoaded();
- if (mSlotMap.containsKey(slot) && mSlotMap.get(slot) != getMode()) {
+ if (mSlotMap.containsKey(slot) && !mSlotMap.get(slot).equals(getMode())) {
throw new RuntimeException("password slot " + slot + " cannot be deleted");
}
mSlotMap.remove(slot);
diff --git a/services/core/java/com/android/server/media/MediaRouter2ServiceImpl.java b/services/core/java/com/android/server/media/MediaRouter2ServiceImpl.java
index 01936c9..12137fe 100644
--- a/services/core/java/com/android/server/media/MediaRouter2ServiceImpl.java
+++ b/services/core/java/com/android/server/media/MediaRouter2ServiceImpl.java
@@ -32,16 +32,15 @@
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
-import android.os.Message;
import android.os.RemoteException;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.Log;
-import android.util.Pair;
import android.util.Slog;
import android.util.SparseArray;
import com.android.internal.annotations.GuardedBy;
+import com.android.internal.util.function.pooled.PooledLambda;
import java.io.PrintWriter;
import java.lang.ref.WeakReference;
@@ -204,13 +203,15 @@
UserRecord oldUser = mUserRecords.get(oldUserId);
if (oldUser != null) {
- oldUser.mHandler.sendEmptyMessage(MediaRouterService.UserHandler.MSG_STOP);
+ oldUser.mHandler.sendMessage(
+ obtainMessage(UserHandler::stop, oldUser.mHandler));
disposeUserIfNeededLocked(oldUser); // since no longer current user
}
UserRecord newUser = mUserRecords.get(userId);
if (newUser != null) {
- newUser.mHandler.sendEmptyMessage(MediaRouterService.UserHandler.MSG_START);
+ newUser.mHandler.sendMessage(
+ obtainMessage(UserHandler::start, newUser.mHandler));
}
}
}
@@ -296,8 +297,9 @@
if (clientRecord != null) {
clientRecord.mControlCategories = categories;
- clientRecord.mUserRecord.mHandler.obtainMessage(
- UserHandler.MSG_UPDATE_CLIENT_USAGE, clientRecord).sendToTarget();
+ clientRecord.mUserRecord.mHandler.sendMessage(
+ obtainMessage(UserHandler::updateClientUsage,
+ clientRecord.mUserRecord.mHandler, clientRecord));
}
}
@@ -307,9 +309,9 @@
ClientRecord clientRecord = mAllClientRecords.get(binder);
if (clientRecord != null) {
- Pair<MediaRoute2Info, Intent> obj = new Pair<>(route, request);
- clientRecord.mUserRecord.mHandler.obtainMessage(
- UserHandler.MSG_SEND_CONTROL_REQUEST, obj).sendToTarget();
+ clientRecord.mUserRecord.mHandler.sendMessage(
+ obtainMessage(UserHandler::sendControlRequest,
+ clientRecord.mUserRecord.mHandler, route, request));
}
}
@@ -346,8 +348,9 @@
final int count = userRecord.mClientRecords.size();
for (int i = 0; i < count; i++) {
ClientRecord clientRecord = userRecord.mClientRecords.get(i);
- clientRecord.mUserRecord.mHandler.obtainMessage(
- UserHandler.MSG_UPDATE_CLIENT_USAGE, clientRecord).sendToTarget();
+ clientRecord.mUserRecord.mHandler.sendMessage(
+ obtainMessage(UserHandler::updateClientUsage,
+ clientRecord.mUserRecord.mHandler, clientRecord));
}
}
}
@@ -381,7 +384,8 @@
Slog.d(TAG, userRecord + ": Initialized");
}
if (userRecord.mUserId == mCurrentUserId) {
- userRecord.mHandler.sendEmptyMessage(UserHandler.MSG_START);
+ userRecord.mHandler.sendMessage(
+ obtainMessage(UserHandler::start, userRecord.mHandler));
}
}
@@ -497,13 +501,6 @@
MediaRoute2ProviderWatcher.Callback,
MediaRoute2ProviderProxy.Callback {
- //TODO: Use PooledLambda instead.
- static final int MSG_START = 1;
- static final int MSG_STOP = 2;
-
- static final int MSG_UPDATE_CLIENT_USAGE = 11;
- static final int MSG_SEND_CONTROL_REQUEST = 12;
-
private final WeakReference<MediaRouter2ServiceImpl> mServiceRef;
private final UserRecord mUserRecord;
private final MediaRoute2ProviderWatcher mWatcher;
@@ -524,28 +521,6 @@
this, mUserRecord.mUserId);
}
- @Override
- public void handleMessage(Message msg) {
- switch (msg.what) {
- case MSG_START: {
- start();
- break;
- }
- case MSG_STOP: {
- stop();
- break;
- }
- case MSG_UPDATE_CLIENT_USAGE: {
- updateClientUsage((ClientRecord) msg.obj);
- break;
- }
- case MSG_SEND_CONTROL_REQUEST: {
- Pair<MediaRoute2Info, Intent> obj = (Pair<MediaRoute2Info, Intent>) msg.obj;
- sendControlRequest(obj.first, obj.second);
- }
- }
- }
-
private void start() {
if (!mRunning) {
mRunning = true;
@@ -613,7 +588,7 @@
private void scheduleUpdateManagerState() {
if (!mManagerStateUpdateScheduled) {
mManagerStateUpdateScheduled = true;
- post(this::updateManagerState);
+ sendMessage(PooledLambda.obtainMessage(UserHandler::updateManagerState, this));
}
}
diff --git a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
index d3346cd..5530b51 100644
--- a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
+++ b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
@@ -403,8 +403,10 @@
private IConnectivityManager mConnManager;
private PowerManagerInternal mPowerManagerInternal;
private IDeviceIdleController mDeviceIdleController;
+
+ /** Current cached value of the current Battery Saver mode's setting for restrict background. */
@GuardedBy("mUidRulesFirstLock")
- private PowerSaveState mRestrictBackgroundPowerState;
+ private boolean mRestrictBackgroundLowPowerMode;
// Store the status of restrict background before turning on battery saver.
// Used to restore mRestrictBackground when battery saver is turned off.
@@ -771,11 +773,9 @@
// Update the restrictBackground if battery saver is turned on
mRestrictBackgroundBeforeBsm = mLoadedRestrictBackground;
- mRestrictBackgroundPowerState = mPowerManagerInternal
- .getLowPowerState(ServiceType.DATA_SAVER);
- final boolean localRestrictBackground =
- mRestrictBackgroundPowerState.batterySaverEnabled;
- if (localRestrictBackground && !mLoadedRestrictBackground) {
+ mRestrictBackgroundLowPowerMode = mPowerManagerInternal
+ .getLowPowerState(ServiceType.DATA_SAVER).batterySaverEnabled;
+ if (mRestrictBackgroundLowPowerMode && !mLoadedRestrictBackground) {
mLoadedRestrictBackground = true;
}
mPowerManagerInternal.registerLowPowerModeObserver(
@@ -2900,7 +2900,7 @@
sendRestrictBackgroundChangedMsg();
mLogger.restrictBackgroundChanged(oldRestrictBackground, mRestrictBackground);
- if (mRestrictBackgroundPowerState.globalBatterySaverEnabled) {
+ if (mRestrictBackgroundLowPowerMode) {
mRestrictBackgroundChangedInBsm = true;
}
synchronized (mNetworkPoliciesSecondLock) {
@@ -4907,17 +4907,21 @@
@GuardedBy("mUidRulesFirstLock")
@VisibleForTesting
void updateRestrictBackgroundByLowPowerModeUL(final PowerSaveState result) {
- mRestrictBackgroundPowerState = result;
+ if (mRestrictBackgroundLowPowerMode == result.batterySaverEnabled) {
+ // Nothing changed. Nothing to do.
+ return;
+ }
+ mRestrictBackgroundLowPowerMode = result.batterySaverEnabled;
- boolean restrictBackground = result.batterySaverEnabled;
+ boolean restrictBackground = mRestrictBackgroundLowPowerMode;
boolean shouldInvokeRestrictBackground;
- // store the temporary mRestrictBackgroundChangedInBsm and update it at last
+ // store the temporary mRestrictBackgroundChangedInBsm and update it at the end.
boolean localRestrictBgChangedInBsm = mRestrictBackgroundChangedInBsm;
- if (result.globalBatterySaverEnabled) {
+ if (mRestrictBackgroundLowPowerMode) {
// Try to turn on restrictBackground if (1) it is off and (2) batter saver need to
// turn it on.
- shouldInvokeRestrictBackground = !mRestrictBackground && result.batterySaverEnabled;
+ shouldInvokeRestrictBackground = !mRestrictBackground;
mRestrictBackgroundBeforeBsm = mRestrictBackground;
localRestrictBgChangedInBsm = false;
} else {
diff --git a/services/core/java/com/android/server/notification/NotificationManagerService.java b/services/core/java/com/android/server/notification/NotificationManagerService.java
index 976931c..d30895e 100644
--- a/services/core/java/com/android/server/notification/NotificationManagerService.java
+++ b/services/core/java/com/android/server/notification/NotificationManagerService.java
@@ -25,9 +25,12 @@
import static android.app.Notification.FLAG_ONGOING_EVENT;
import static android.app.Notification.FLAG_ONLY_ALERT_ONCE;
import static android.app.NotificationManager.ACTION_APP_BLOCK_STATE_CHANGED;
+import static android.app.NotificationManager.ACTION_AUTOMATIC_ZEN_RULE_STATUS_CHANGED;
import static android.app.NotificationManager.ACTION_NOTIFICATION_CHANNEL_BLOCK_STATE_CHANGED;
import static android.app.NotificationManager.ACTION_NOTIFICATION_CHANNEL_GROUP_BLOCK_STATE_CHANGED;
import static android.app.NotificationManager.ACTION_NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED;
+import static android.app.NotificationManager.EXTRA_AUTOMATIC_ZEN_RULE_ID;
+import static android.app.NotificationManager.EXTRA_AUTOMATIC_ZEN_RULE_STATUS;
import static android.app.NotificationManager.IMPORTANCE_LOW;
import static android.app.NotificationManager.IMPORTANCE_MIN;
import static android.app.NotificationManager.IMPORTANCE_NONE;
@@ -398,7 +401,7 @@
// for enabling and disabling notification pulse behavior
boolean mScreenOn = true;
- protected boolean mInCall = false;
+ protected boolean mInCallStateOffHook = false;
boolean mNotificationPulseEnabled;
private Uri mInCallNotificationUri;
@@ -1296,7 +1299,7 @@
mScreenOn = false;
updateNotificationPulse();
} else if (action.equals(TelephonyManager.ACTION_PHONE_STATE_CHANGED)) {
- mInCall = TelephonyManager.EXTRA_STATE_OFFHOOK
+ mInCallStateOffHook = TelephonyManager.EXTRA_STATE_OFFHOOK
.equals(intent.getStringExtra(TelephonyManager.EXTRA_STATE));
updateNotificationPulse();
} else if (action.equals(Intent.ACTION_USER_STOPPED)) {
@@ -1645,6 +1648,15 @@
sendRegisteredOnlyBroadcast(NotificationManager.ACTION_NOTIFICATION_POLICY_CHANGED);
mRankingHandler.requestSort();
}
+
+ @Override
+ void onAutomaticRuleStatusChanged(int userId, String pkg, String id, int status) {
+ Intent intent = new Intent(ACTION_AUTOMATIC_ZEN_RULE_STATUS_CHANGED);
+ intent.setPackage(pkg);
+ intent.putExtra(EXTRA_AUTOMATIC_ZEN_RULE_ID, id);
+ intent.putExtra(EXTRA_AUTOMATIC_ZEN_RULE_STATUS, status);
+ getContext().sendBroadcastAsUser(intent, UserHandle.of(userId));
+ }
});
mPreferencesHelper = new PreferencesHelper(getContext(),
mPackageManagerClient,
@@ -5812,7 +5824,7 @@
}
if (DBG) Slog.v(TAG, "Interrupting!");
if (hasValidSound) {
- if (mInCall) {
+ if (isInCall()) {
playInCallNotification();
beep = true;
} else {
@@ -5826,7 +5838,7 @@
final boolean ringerModeSilent =
mAudioManager.getRingerModeInternal()
== AudioManager.RINGER_MODE_SILENT;
- if (!mInCall && hasValidVibrate && !ringerModeSilent) {
+ if (!isInCall() && hasValidVibrate && !ringerModeSilent) {
buzz = playVibration(record, vibration, hasValidSound);
if(buzz) {
mVibrateNotificationKey = key;
@@ -5914,7 +5926,7 @@
return false;
}
// not if in call or the screen's on
- if (mInCall || mScreenOn) {
+ if (isInCall() || mScreenOn) {
return false;
}
@@ -7015,7 +7027,7 @@
}
// Don't flash while we are in a call or screen is on
- if (ledNotification == null || mInCall || mScreenOn) {
+ if (ledNotification == null || isInCall() || mScreenOn) {
mNotificationLight.turnOff();
} else {
NotificationRecord.Light light = ledNotification.getLight();
@@ -7483,6 +7495,18 @@
}
}
+ private boolean isInCall() {
+ if (mInCallStateOffHook) {
+ return true;
+ }
+ int audioMode = mAudioManager.getMode();
+ if (audioMode == AudioManager.MODE_IN_CALL
+ || audioMode == AudioManager.MODE_IN_COMMUNICATION) {
+ return true;
+ }
+ return false;
+ }
+
public class NotificationAssistants extends ManagedServices {
static final String TAG_ENABLED_NOTIFICATION_ASSISTANTS = "enabled_assistants";
diff --git a/services/core/java/com/android/server/notification/ZenModeHelper.java b/services/core/java/com/android/server/notification/ZenModeHelper.java
index f81015d..ee948b2 100644
--- a/services/core/java/com/android/server/notification/ZenModeHelper.java
+++ b/services/core/java/com/android/server/notification/ZenModeHelper.java
@@ -16,6 +16,10 @@
package com.android.server.notification;
+import static android.app.NotificationManager.AUTOMATIC_RULE_STATUS_DISABLED;
+import static android.app.NotificationManager.AUTOMATIC_RULE_STATUS_ENABLED;
+import static android.app.NotificationManager.AUTOMATIC_RULE_STATUS_REMOVED;
+
import android.app.AppOpsManager;
import android.app.AutomaticZenRule;
import android.app.Notification;
@@ -351,6 +355,12 @@
"Cannot update rules not owned by your condition provider");
}
}
+ if (rule.enabled != automaticZenRule.isEnabled()) {
+ dispatchOnAutomaticRuleStatusChanged(mConfig.user, rule.pkg, ruleId,
+ automaticZenRule.isEnabled()
+ ? AUTOMATIC_RULE_STATUS_ENABLED : AUTOMATIC_RULE_STATUS_DISABLED);
+ }
+
populateZenRule(automaticZenRule, rule, false);
return setConfigLocked(newConfig, reason, rule.component, true);
}
@@ -370,6 +380,8 @@
throw new SecurityException(
"Cannot delete rules not owned by your condition provider");
}
+ dispatchOnAutomaticRuleStatusChanged(
+ mConfig.user, rule.pkg, id, AUTOMATIC_RULE_STATUS_REMOVED);
return setConfigLocked(newConfig, reason, null, true);
}
}
@@ -1120,6 +1132,13 @@
}
}
+ private void dispatchOnAutomaticRuleStatusChanged(int userId, String pkg, String id,
+ int status) {
+ for (Callback callback : mCallbacks) {
+ callback.onAutomaticRuleStatusChanged(userId, pkg, id, status);
+ }
+ }
+
private ZenModeConfig readDefaultConfig(Resources resources) {
XmlResourceParser parser = null;
try {
@@ -1509,5 +1528,6 @@
void onZenModeChanged() {}
void onPolicyChanged() {}
void onConsolidatedPolicyChanged() {}
+ void onAutomaticRuleStatusChanged(int userId, String pkg, String id, int status) {}
}
}
diff --git a/services/core/java/com/android/server/pm/StagingManager.java b/services/core/java/com/android/server/pm/StagingManager.java
index 42b65c3..bf141a0 100644
--- a/services/core/java/com/android/server/pm/StagingManager.java
+++ b/services/core/java/com/android/server/pm/StagingManager.java
@@ -242,11 +242,11 @@
}
if (sessionContainsApk(session)) {
- if (!installApksInSession(session, /* preReboot */ true)) {
- session.setStagedSessionFailed(SessionInfo.STAGED_SESSION_VERIFICATION_FAILED,
- "APK verification failed. Check logcat messages for "
- + "more information.");
+ try {
+ installApksInSession(session, /* preReboot */ true);
// TODO(b/118865310): abort the session on apexd.
+ } catch (PackageManagerException e) {
+ session.setStagedSessionFailed(e.error, e.getMessage());
return;
}
}
@@ -315,7 +315,7 @@
}
private void resumeSession(@NonNull PackageInstallerSession session) {
- boolean hasApex = sessionContainsApex(session);
+ final boolean hasApex = sessionContainsApex(session);
if (hasApex) {
// Check with apexservice whether the apex packages have been activated.
ApexSessionInfo apexSessionInfo = mApexManager.getStagedSessionInfo(session.sessionId);
@@ -350,10 +350,10 @@
}
}
// The APEX part of the session is activated, proceed with the installation of APKs.
- if (!installApksInSession(session, /* preReboot */ false)) {
- session.setStagedSessionFailed(SessionInfo.STAGED_SESSION_ACTIVATION_FAILED,
- "Staged installation of APKs failed. Check logcat messages for"
- + "more information.");
+ try {
+ installApksInSession(session, /* preReboot */ false);
+ } catch (PackageManagerException e) {
+ session.setStagedSessionFailed(e.error, e.getMessage());
if (!hasApex) {
return;
@@ -388,16 +388,22 @@
return ret;
}
+ @NonNull
private PackageInstallerSession createAndWriteApkSession(
- @NonNull PackageInstallerSession originalSession, boolean preReboot) {
+ @NonNull PackageInstallerSession originalSession, boolean preReboot)
+ throws PackageManagerException {
+ final int errorCode = preReboot ? SessionInfo.STAGED_SESSION_VERIFICATION_FAILED
+ : SessionInfo.STAGED_SESSION_ACTIVATION_FAILED;
if (originalSession.stageDir == null) {
Slog.wtf(TAG, "Attempting to install a staged APK session with no staging dir");
- return null;
+ throw new PackageManagerException(errorCode,
+ "Attempting to install a staged APK session with no staging dir");
}
List<String> apkFilePaths = findAPKsInDir(originalSession.stageDir);
if (apkFilePaths.isEmpty()) {
Slog.w(TAG, "Can't find staged APK in " + originalSession.stageDir.getAbsolutePath());
- return null;
+ throw new PackageManagerException(errorCode,
+ "Can't find staged APK in " + originalSession.stageDir.getAbsolutePath());
}
PackageInstaller.SessionParams params = originalSession.params.copy();
@@ -424,20 +430,22 @@
long sizeBytes = pfd.getStatSize();
if (sizeBytes < 0) {
Slog.e(TAG, "Unable to get size of: " + apkFilePath);
- return null;
+ throw new PackageManagerException(errorCode,
+ "Unable to get size of: " + apkFilePath);
}
apkSession.write(apkFile.getName(), 0, sizeBytes, pfd);
}
} catch (IOException e) {
Slog.e(TAG, "Failure to install APK staged session " + originalSession.sessionId, e);
- return null;
+ throw new PackageManagerException(errorCode, "Failed to write APK session", e);
}
return apkSession;
}
- private boolean commitApkSession(@NonNull PackageInstallerSession apkSession,
- int originalSessionId, boolean preReboot) {
-
+ private void commitApkSession(@NonNull PackageInstallerSession apkSession,
+ int originalSessionId, boolean preReboot) throws PackageManagerException {
+ final int errorCode = preReboot ? SessionInfo.STAGED_SESSION_VERIFICATION_FAILED
+ : SessionInfo.STAGED_SESSION_ACTIVATION_FAILED;
if (!preReboot) {
if ((apkSession.params.installFlags & PackageManager.INSTALL_ENABLE_ROLLBACK) != 0) {
// If rollback is available for this session, notify the rollback
@@ -457,23 +465,24 @@
final Intent result = receiver.getResult();
final int status = result.getIntExtra(PackageInstaller.EXTRA_STATUS,
PackageInstaller.STATUS_FAILURE);
- if (status == PackageInstaller.STATUS_SUCCESS) {
- return true;
+ if (status != PackageInstaller.STATUS_SUCCESS) {
+
+ final String errorMessage = result.getStringExtra(
+ PackageInstaller.EXTRA_STATUS_MESSAGE);
+ Slog.e(TAG, "Failure to install APK staged session " + originalSessionId + " ["
+ + errorMessage + "]");
+ throw new PackageManagerException(errorCode, errorMessage);
}
- Slog.e(TAG, "Failure to install APK staged session " + originalSessionId + " ["
- + result.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE) + "]");
- return false;
}
- private boolean installApksInSession(@NonNull PackageInstallerSession session,
- boolean preReboot) {
+ private void installApksInSession(@NonNull PackageInstallerSession session,
+ boolean preReboot) throws PackageManagerException {
+ final int errorCode = preReboot ? SessionInfo.STAGED_SESSION_VERIFICATION_FAILED
+ : SessionInfo.STAGED_SESSION_ACTIVATION_FAILED;
if (!session.isMultiPackage() && !isApexSession(session)) {
// APK single-packaged staged session. Do a regular install.
PackageInstallerSession apkSession = createAndWriteApkSession(session, preReboot);
- if (apkSession == null) {
- return false;
- }
- return commitApkSession(apkSession, session.sessionId, preReboot);
+ commitApkSession(apkSession, session.sessionId, preReboot);
} else if (session.isMultiPackage()) {
// For multi-package staged sessions containing APKs, we identify which child sessions
// contain an APK, and with those then create a new multi-package group of sessions,
@@ -491,7 +500,7 @@
}
if (childSessions.isEmpty()) {
// APEX-only multi-package staged session, nothing to do.
- return true;
+ return;
}
PackageInstaller.SessionParams params = session.params.copy();
params.isStaged = false;
@@ -508,26 +517,24 @@
} catch (IOException e) {
Slog.e(TAG, "Unable to prepare multi-package session for staged session "
+ session.sessionId);
- return false;
+ throw new PackageManagerException(errorCode,
+ "Unable to prepare multi-package session for staged session");
}
for (PackageInstallerSession sessionToClone : childSessions) {
PackageInstallerSession apkChildSession =
createAndWriteApkSession(sessionToClone, preReboot);
- if (apkChildSession == null) {
- return false;
- }
try {
apkParentSession.addChildSessionId(apkChildSession.sessionId);
} catch (IllegalStateException e) {
Slog.e(TAG, "Failed to add a child session for installing the APK files", e);
- return false;
+ throw new PackageManagerException(errorCode,
+ "Failed to add a child session " + apkChildSession.sessionId);
}
}
- return commitApkSession(apkParentSession, session.sessionId, preReboot);
+ commitApkSession(apkParentSession, session.sessionId, preReboot);
}
// APEX single-package staged session, nothing to do.
- return true;
}
void commitSession(@NonNull PackageInstallerSession session) {
diff --git a/services/core/java/com/android/server/uri/UriGrantsManagerService.java b/services/core/java/com/android/server/uri/UriGrantsManagerService.java
index 55f062b..b2f1153 100644
--- a/services/core/java/com/android/server/uri/UriGrantsManagerService.java
+++ b/services/core/java/com/android/server/uri/UriGrantsManagerService.java
@@ -949,7 +949,25 @@
return false;
}
- return readMet && writeMet;
+ // If this provider says that grants are always required, we need to
+ // consult it directly to determine if the UID has permission
+ final boolean forceMet;
+ if (pi.forceUriPermissions) {
+ final int providerUserId = UserHandle.getUserId(pi.applicationInfo.uid);
+ final int clientUserId = UserHandle.getUserId(uid);
+ if (providerUserId == clientUserId) {
+ forceMet = (mAmInternal.checkContentProviderUriPermission(grantUri.uri,
+ providerUserId, uid, modeFlags) == PackageManager.PERMISSION_GRANTED);
+ } else {
+ // The provider can't track cross-user permissions, so we have
+ // to assume they're always denied
+ forceMet = false;
+ }
+ } else {
+ forceMet = true;
+ }
+
+ return readMet && writeMet && forceMet;
}
private void removeUriPermissionIfNeeded(UriPermission perm) {
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
index 971a24d..c37ced5 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@@ -4912,7 +4912,7 @@
}
void dumpActivityContainersLocked(PrintWriter pw) {
- pw.println("ACTIVITY MANAGER STARTER (dumpsys activity containers)");
+ pw.println("ACTIVITY MANAGER CONTAINERS (dumpsys activity containers)");
mRootActivityContainer.dumpChildrenNames(pw, " ");
pw.println(" ");
}
@@ -4928,6 +4928,9 @@
* - the cmd arg isn't the flattened component name of an existing activity:
* dump all activity whose component contains the cmd as a substring
* - A hex number of the ActivityRecord object instance.
+ * <p>
+ * The caller should not hold lock when calling this method because it will wait for the
+ * activities to complete the dump.
*
* @param dumpVisibleStacksOnly dump activity with {@param name} only if in a visible stack
* @param dumpFocusedStackOnly dump activity with {@param name} only if in the focused stack
@@ -4980,29 +4983,28 @@
private void dumpActivity(String prefix, FileDescriptor fd, PrintWriter pw,
final ActivityRecord r, String[] args, boolean dumpAll) {
String innerPrefix = prefix + " ";
+ IApplicationThread appThread = null;
synchronized (mGlobalLock) {
pw.print(prefix); pw.print("ACTIVITY "); pw.print(r.shortComponentName);
pw.print(" "); pw.print(Integer.toHexString(System.identityHashCode(r)));
pw.print(" pid=");
- if (r.hasProcess()) pw.println(r.app.getPid());
- else pw.println("(not running)");
+ if (r.hasProcess()) {
+ pw.println(r.app.getPid());
+ appThread = r.app.getThread();
+ } else {
+ pw.println("(not running)");
+ }
if (dumpAll) {
r.dump(pw, innerPrefix);
}
}
- if (r.attachedToProcess()) {
+ if (appThread != null) {
// flush anything that is already in the PrintWriter since the thread is going
// to write to the file descriptor directly
pw.flush();
- try {
- TransferPipe tp = new TransferPipe();
- try {
- r.app.getThread().dumpActivity(tp.getWriteFd(),
- r.appToken, innerPrefix, args);
- tp.go(fd);
- } finally {
- tp.kill();
- }
+ try (TransferPipe tp = new TransferPipe()) {
+ appThread.dumpActivity(tp.getWriteFd(), r.appToken, innerPrefix, args);
+ tp.go(fd);
} catch (IOException e) {
pw.println(innerPrefix + "Failure while dumping the activity: " + e);
} catch (RemoteException e) {
@@ -7063,10 +7065,8 @@
public boolean dumpActivity(FileDescriptor fd, PrintWriter pw, String name,
String[] args, int opti, boolean dumpAll, boolean dumpVisibleStacksOnly,
boolean dumpFocusedStackOnly) {
- synchronized (mGlobalLock) {
- return ActivityTaskManagerService.this.dumpActivity(fd, pw, name, args, opti,
- dumpAll, dumpVisibleStacksOnly, dumpFocusedStackOnly);
- }
+ return ActivityTaskManagerService.this.dumpActivity(fd, pw, name, args, opti, dumpAll,
+ dumpVisibleStacksOnly, dumpFocusedStackOnly);
}
@Override
diff --git a/services/core/java/com/android/server/wm/AppWindowToken.java b/services/core/java/com/android/server/wm/AppWindowToken.java
index 8007c0f..d15081c 100644
--- a/services/core/java/com/android/server/wm/AppWindowToken.java
+++ b/services/core/java/com/android/server/wm/AppWindowToken.java
@@ -260,9 +260,9 @@
ActivityRecord mActivityRecord;
/**
- * See {@link #canTurnScreenOn()}
+ * @see #currentLaunchCanTurnScreenOn()
*/
- private boolean mCanTurnScreenOn = true;
+ private boolean mCurrentLaunchCanTurnScreenOn = true;
/**
* If we are running an animation, this determines the transition type. Must be one of
@@ -1002,7 +1002,7 @@
+ " " + this);
mAppStopped = false;
// Allow the window to turn the screen on once the app is resumed again.
- setCanTurnScreenOn(true);
+ setCurrentLaunchCanTurnScreenOn(true);
if (!wasStopped) {
destroySurfaces(true /*cleanupOnResume*/);
}
@@ -2420,21 +2420,25 @@
}
/**
- * Sets whether the current launch can turn the screen on. See {@link #canTurnScreenOn()}
+ * Sets whether the current launch can turn the screen on.
+ * @see #currentLaunchCanTurnScreenOn()
*/
- void setCanTurnScreenOn(boolean canTurnScreenOn) {
- mCanTurnScreenOn = canTurnScreenOn;
+ void setCurrentLaunchCanTurnScreenOn(boolean currentLaunchCanTurnScreenOn) {
+ mCurrentLaunchCanTurnScreenOn = currentLaunchCanTurnScreenOn;
}
/**
* Indicates whether the current launch can turn the screen on. This is to prevent multiple
* relayouts from turning the screen back on. The screen should only turn on at most
* once per activity resume.
+ * <p>
+ * Note this flag is only meaningful when {@link WindowManager.LayoutParams#FLAG_TURN_SCREEN_ON}
+ * or {@link ActivityRecord#canTurnScreenOn} is set.
*
- * @return true if the screen can be turned on.
+ * @return {@code true} if the activity is ready to turn on the screen.
*/
- boolean canTurnScreenOn() {
- return mCanTurnScreenOn;
+ boolean currentLaunchCanTurnScreenOn() {
+ return mCurrentLaunchCanTurnScreenOn;
}
/**
diff --git a/services/core/java/com/android/server/wm/DisplayPolicy.java b/services/core/java/com/android/server/wm/DisplayPolicy.java
index cf87203..61ba69f 100644
--- a/services/core/java/com/android/server/wm/DisplayPolicy.java
+++ b/services/core/java/com/android/server/wm/DisplayPolicy.java
@@ -284,6 +284,8 @@
/** See {@link #getNavigationBarFrameHeight} */
private int[] mNavigationBarFrameHeightForRotationDefault = new int[4];
+ private boolean mIsFreeformWindowOverlappingWithNavBar;
+
/** Cached value of {@link ScreenShapeHelper#getWindowOutsetBottomPx} */
@Px private int mWindowOutsetBottom;
@@ -2379,6 +2381,7 @@
mAllowLockscreenWhenOn = false;
mShowingDream = false;
mWindowSleepTokenNeeded = false;
+ mIsFreeformWindowOverlappingWithNavBar = false;
}
/**
@@ -2478,6 +2481,13 @@
}
}
+ // Check if the freeform window overlaps with the navigation bar area.
+ final WindowState navBarWin = hasNavigationBar() ? mNavigationBar : null;
+ if (!mIsFreeformWindowOverlappingWithNavBar && win.inFreeformWindowingMode()
+ && isOverlappingWithNavBar(win, navBarWin)) {
+ mIsFreeformWindowOverlappingWithNavBar = true;
+ }
+
// Also keep track of any windows that are dimming but not necessarily fullscreen in the
// docked stack.
if (mTopDockedOpaqueOrDimmingWindowState == null && affectsSystemUi && win.isDimming()
@@ -3458,7 +3468,11 @@
}
} else if (mNavBarOpacityMode == NAV_BAR_OPAQUE_WHEN_FREEFORM_OR_DOCKED) {
if (dockedStackVisible || freeformStackVisible || isDockedDividerResizing) {
- visibility = setNavBarOpaqueFlag(visibility);
+ if (mIsFreeformWindowOverlappingWithNavBar) {
+ visibility = setNavBarTranslucentFlag(visibility);
+ } else {
+ visibility = setNavBarOpaqueFlag(visibility);
+ }
} else if (fullscreenDrawsBackground) {
visibility = setNavBarTransparentFlag(visibility);
}
@@ -3747,4 +3761,14 @@
wm.removeView(mPointerLocationView);
mPointerLocationView = null;
}
+
+ @VisibleForTesting
+ static boolean isOverlappingWithNavBar(WindowState targetWindow, WindowState navBarWindow) {
+ if (navBarWindow == null || !navBarWindow.isVisibleLw()
+ || targetWindow.mAppToken == null || !targetWindow.isVisibleLw()) {
+ return false;
+ }
+
+ return Rect.intersects(targetWindow.getFrameLw(), navBarWindow.getFrameLw());
+ }
}
diff --git a/services/core/java/com/android/server/wm/KeyguardController.java b/services/core/java/com/android/server/wm/KeyguardController.java
index ca4749f..422b6e5 100644
--- a/services/core/java/com/android/server/wm/KeyguardController.java
+++ b/services/core/java/com/android/server/wm/KeyguardController.java
@@ -43,11 +43,13 @@
import android.os.IBinder;
import android.os.RemoteException;
import android.os.Trace;
+import android.util.EventLog;
import android.util.Slog;
import android.util.SparseArray;
import android.util.proto.ProtoOutputStream;
import com.android.internal.policy.IKeyguardDismissCallback;
+import com.android.server.am.EventLogTags;
import com.android.server.policy.WindowManagerPolicy;
import com.android.server.wm.ActivityTaskManagerInternal.SleepToken;
@@ -142,6 +144,11 @@
if (!keyguardChanged && !aodChanged) {
return;
}
+ EventLog.writeEvent(EventLogTags.AM_SET_KEYGUARD_SHOWN,
+ keyguardShowing ? 1 : 0,
+ aodShowing ? 1 : 0,
+ mKeyguardGoingAway ? 1 : 0,
+ "setKeyguardShown");
mKeyguardShowing = keyguardShowing;
mAodShowing = aodShowing;
mWindowManager.setAodShowing(aodShowing);
@@ -178,6 +185,11 @@
mWindowManager.deferSurfaceLayout();
try {
setKeyguardGoingAway(true);
+ EventLog.writeEvent(EventLogTags.AM_SET_KEYGUARD_SHOWN,
+ 1 /* keyguardShowing */,
+ mAodShowing ? 1 : 0,
+ 1 /* keyguardGoingAway */,
+ "keyguardGoingAway");
mRootActivityContainer.getDefaultDisplay().mDisplayContent
.prepareAppTransition(TRANSIT_KEYGUARD_GOING_AWAY,
false /* alwaysKeepCurrent */, convertTransitFlags(flags),
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index 8b1baeb..a3ee1088 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -2393,10 +2393,11 @@
void prepareWindowToDisplayDuringRelayout(boolean wasVisible) {
// We need to turn on screen regardless of visibility.
- boolean hasTurnScreenOnFlag = (mAttrs.flags & FLAG_TURN_SCREEN_ON) != 0;
+ final boolean hasTurnScreenOnFlag = (mAttrs.flags & FLAG_TURN_SCREEN_ON) != 0
+ || (mAppToken != null && mAppToken.mActivityRecord.canTurnScreenOn());
// The screen will turn on if the following conditions are met
- // 1. The window has the flag FLAG_TURN_SCREEN_ON
+ // 1. The window has the flag FLAG_TURN_SCREEN_ON or ActivityRecord#canTurnScreenOn.
// 2. The WMS allows theater mode.
// 3. No AWT or the AWT allows the screen to be turned on. This should only be true once
// per resume to prevent the screen getting getting turned on for each relayout. Set
@@ -2410,7 +2411,7 @@
boolean allowTheaterMode = mWmService.mAllowTheaterModeWakeFromLayout
|| Settings.Global.getInt(mWmService.mContext.getContentResolver(),
Settings.Global.THEATER_MODE_ON, 0) == 0;
- boolean canTurnScreenOn = mAppToken == null || mAppToken.canTurnScreenOn();
+ boolean canTurnScreenOn = mAppToken == null || mAppToken.currentLaunchCanTurnScreenOn();
if (allowTheaterMode && canTurnScreenOn && !mPowerManagerWrapper.isInteractive()) {
if (DEBUG_VISIBILITY || DEBUG_POWER) {
@@ -2421,7 +2422,7 @@
}
if (mAppToken != null) {
- mAppToken.setCanTurnScreenOn(false);
+ mAppToken.setCurrentLaunchCanTurnScreenOn(false);
}
}
diff --git a/services/tests/mockingservicestests/src/com/android/server/display/color/DisplayTransformManagerTest.java b/services/tests/mockingservicestests/src/com/android/server/display/color/DisplayTransformManagerTest.java
index 73b3b8b..a785300 100644
--- a/services/tests/mockingservicestests/src/com/android/server/display/color/DisplayTransformManagerTest.java
+++ b/services/tests/mockingservicestests/src/com/android/server/display/color/DisplayTransformManagerTest.java
@@ -19,6 +19,7 @@
import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyString;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.doAnswer;
import static com.android.server.display.color.DisplayTransformManager.LEVEL_COLOR_MATRIX_NIGHT_DISPLAY;
+import static com.android.server.display.color.DisplayTransformManager.PERSISTENT_PROPERTY_COMPOSITION_COLOR_MODE;
import static com.android.server.display.color.DisplayTransformManager.PERSISTENT_PROPERTY_DISPLAY_COLOR;
import static com.android.server.display.color.DisplayTransformManager.PERSISTENT_PROPERTY_SATURATION;
@@ -28,6 +29,7 @@
import android.hardware.display.ColorDisplayManager;
import android.os.SystemProperties;
+import android.view.Display;
import androidx.test.runner.AndroidJUnit4;
@@ -79,7 +81,7 @@
@Test
public void setColorMode_natural() {
- mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL, mNightDisplayMatrix);
+ mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL, mNightDisplayMatrix, -1);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_DISPLAY_COLOR))
.isEqualTo("0" /* managed */);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_SATURATION))
@@ -88,7 +90,7 @@
@Test
public void setColorMode_boosted() {
- mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED, mNightDisplayMatrix);
+ mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED, mNightDisplayMatrix, -1);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_DISPLAY_COLOR))
.isEqualTo("0" /* managed */);
@@ -98,7 +100,7 @@
@Test
public void setColorMode_saturated() {
- mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_SATURATED, mNightDisplayMatrix);
+ mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_SATURATED, mNightDisplayMatrix, -1);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_DISPLAY_COLOR))
.isEqualTo("1" /* unmanaged */);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_SATURATION))
@@ -107,7 +109,7 @@
@Test
public void setColorMode_automatic() {
- mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC, mNightDisplayMatrix);
+ mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_AUTOMATIC, mNightDisplayMatrix, -1);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_DISPLAY_COLOR))
.isEqualTo("2" /* enhanced */);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_SATURATION))
@@ -116,7 +118,7 @@
@Test
public void setColorMode_vendor() {
- mDtm.setColorMode(0x100, mNightDisplayMatrix);
+ mDtm.setColorMode(0x100, mNightDisplayMatrix, -1);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_DISPLAY_COLOR))
.isEqualTo(Integer.toString(0x100) /* pass-through */);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_SATURATION))
@@ -125,10 +127,38 @@
@Test
public void setColorMode_outOfBounds() {
- mDtm.setColorMode(0x50, mNightDisplayMatrix);
+ mDtm.setColorMode(0x50, mNightDisplayMatrix, -1);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_DISPLAY_COLOR))
.isEqualTo(null);
assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_SATURATION))
.isEqualTo(null);
}
+
+ @Test
+ public void setColorMode_withoutColorSpace() {
+ String magicPropertyValue = "magic";
+
+ // Start with a known state, which we expect to remain unmodified
+ SystemProperties.set(PERSISTENT_PROPERTY_COMPOSITION_COLOR_MODE, magicPropertyValue);
+
+ mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL, mNightDisplayMatrix,
+ Display.COLOR_MODE_INVALID);
+ assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_COMPOSITION_COLOR_MODE))
+ .isEqualTo(magicPropertyValue);
+ }
+
+ @Test
+ public void setColorMode_withColorSpace() {
+ String magicPropertyValue = "magic";
+ int testPropertyValue = Display.COLOR_MODE_SRGB;
+
+ // Start with a known state, which we expect to get modified
+ SystemProperties.set(PERSISTENT_PROPERTY_COMPOSITION_COLOR_MODE, magicPropertyValue);
+
+ mDtm.setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL, mNightDisplayMatrix,
+ testPropertyValue);
+ assertThat(mSystemProperties.get(PERSISTENT_PROPERTY_COMPOSITION_COLOR_MODE))
+ .isEqualTo(Integer.toString(testPropertyValue));
+ }
+
}
diff --git a/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java b/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java
index 70b7bb6..3614763 100644
--- a/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java
+++ b/services/tests/mockingservicestests/src/com/android/server/job/controllers/TimeControllerTest.java
@@ -71,7 +71,6 @@
private static final String SOURCE_PACKAGE = "com.android.frameworks.mockingservicestests";
private static final int SOURCE_USER_ID = 0;
- private TimeController.TcConstants mConstants;
private TimeController mTimeController;
private MockitoSession mMockingSession;
@@ -111,7 +110,6 @@
// Initialize real objects.
mTimeController = new TimeController(mJobSchedulerService);
- mConstants = mTimeController.getTcConstants();
spyOn(mTimeController);
}
@@ -159,18 +157,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DelayInOrder_NoSkipping() {
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.onConstantsUpdatedLocked();
-
- runTestMaybeStartTrackingJobLocked_DelayInOrder();
- }
-
- @Test
- public void testMaybeStartTrackingJobLocked_DelayInOrder_WithSkipping_AllReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
-
+ public void testMaybeStartTrackingJobLocked_DelayInOrder_AllReady() {
doReturn(true).when(mTimeController).wouldBeReadyWithConstraintLocked(any(), anyInt());
runTestMaybeStartTrackingJobLocked_DelayInOrder();
@@ -201,9 +188,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DelayInOrder_WithSkipping_SomeNotReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
+ public void testMaybeStartTrackingJobLocked_DelayInOrder_SomeNotReady() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
JobStatus jobLatest = createJobStatus("testMaybeStartTrackingJobLocked_DelayInOrder",
@@ -235,18 +220,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DelayReverseOrder_NoSkipping() {
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.onConstantsUpdatedLocked();
-
- runTestMaybeStartTrackingJobLocked_DelayReverseOrder();
- }
-
- @Test
- public void testMaybeStartTrackingJobLocked_DelayReverseOrder_WithSkipping_AllReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
-
+ public void testMaybeStartTrackingJobLocked_DelayReverseOrder_AllReady() {
doReturn(true).when(mTimeController).wouldBeReadyWithConstraintLocked(any(), anyInt());
runTestMaybeStartTrackingJobLocked_DelayReverseOrder();
@@ -279,9 +253,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DelayReverseOrder_WithSkipping_SomeNotReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
+ public void testMaybeStartTrackingJobLocked_DelayReverseOrder_SomeNotReady() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
JobStatus jobLatest = createJobStatus("testMaybeStartTrackingJobLocked_DelayReverseOrder",
@@ -315,18 +287,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DeadlineInOrder_NoSkipping() {
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.onConstantsUpdatedLocked();
-
- runTestMaybeStartTrackingJobLocked_DeadlineInOrder();
- }
-
- @Test
- public void testMaybeStartTrackingJobLocked_DeadlineInOrder_WithSkipping_AllReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
-
+ public void testMaybeStartTrackingJobLocked_DeadlineInOrder_AllReady() {
doReturn(true).when(mTimeController).wouldBeReadyWithConstraintLocked(any(), anyInt());
runTestMaybeStartTrackingJobLocked_DeadlineInOrder();
@@ -357,9 +318,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DeadlineInOrder_WithSkipping_SomeNotReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
+ public void testMaybeStartTrackingJobLocked_DeadlineInOrder_SomeNotReady() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
JobStatus jobLatest = createJobStatus("testMaybeStartTrackingJobLocked_DeadlineInOrder",
@@ -391,18 +350,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DeadlineReverseOrder_NoSkipping() {
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.onConstantsUpdatedLocked();
-
- runTestMaybeStartTrackingJobLocked_DeadlineReverseOrder();
- }
-
- @Test
- public void testMaybeStartTrackingJobLocked_DeadlineReverseOrder_WithSkipping_AllReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
-
+ public void testMaybeStartTrackingJobLocked_DeadlineReverseOrder_AllReady() {
doReturn(true).when(mTimeController).wouldBeReadyWithConstraintLocked(any(), anyInt());
runTestMaybeStartTrackingJobLocked_DeadlineReverseOrder();
@@ -438,9 +386,7 @@
}
@Test
- public void testMaybeStartTrackingJobLocked_DeadlineReverseOrder_WithSkipping_SomeNotReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.onConstantsUpdatedLocked();
+ public void testMaybeStartTrackingJobLocked_DeadlineReverseOrder_SomeNotReady() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
JobStatus jobLatest = createJobStatus(
@@ -478,62 +424,7 @@
}
@Test
- public void testJobSkipToggling() {
- final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
-
- JobStatus jobLatest = createJobStatus(
- "testMaybeStartTrackingJobLocked_DeadlineReverseOrder",
- createJob().setOverrideDeadline(HOUR_IN_MILLIS));
- JobStatus jobEarliest = createJobStatus(
- "testMaybeStartTrackingJobLocked_DeadlineReverseOrder",
- createJob().setOverrideDeadline(5 * MINUTE_IN_MILLIS));
-
- doReturn(true).when(mTimeController)
- .wouldBeReadyWithConstraintLocked(eq(jobLatest), anyInt());
- doReturn(false).when(mTimeController)
- .wouldBeReadyWithConstraintLocked(eq(jobEarliest), anyInt());
-
- // Starting off with the skipping off, we should still set an alarm for the earlier job.
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.recheckAlarmsLocked();
- InOrder inOrder = inOrder(mAlarmManager);
-
- mTimeController.maybeStartTrackingJobLocked(jobEarliest, null);
- mTimeController.maybeStartTrackingJobLocked(jobLatest, null);
- inOrder.verify(mAlarmManager, times(1))
- .set(anyInt(), eq(now + 5 * MINUTE_IN_MILLIS), anyLong(), anyLong(),
- eq(TAG_DEADLINE), any(), any(), any());
-
- // Turn it on, use alarm for later job.
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.recheckAlarmsLocked();
-
- inOrder.verify(mAlarmManager, times(1))
- .set(anyInt(), eq(now + HOUR_IN_MILLIS), anyLong(), anyLong(), eq(TAG_DEADLINE),
- any(), any(), any());
-
- // Back off, use alarm for earlier job.
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.recheckAlarmsLocked();
-
- inOrder.verify(mAlarmManager, times(1))
- .set(anyInt(), eq(now + 5 * MINUTE_IN_MILLIS), anyLong(), anyLong(),
- eq(TAG_DEADLINE), any(), any(), any());
- }
-
- @Test
- public void testCheckExpiredDelaysAndResetAlarm_NoSkipping() {
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.recheckAlarmsLocked();
-
- runTestCheckExpiredDelaysAndResetAlarm();
- }
-
- @Test
- public void testCheckExpiredDelaysAndResetAlarm_WithSkipping_AllReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.recheckAlarmsLocked();
-
+ public void testCheckExpiredDelaysAndResetAlarm_AllReady() {
doReturn(true).when(mTimeController).wouldBeReadyWithConstraintLocked(any(), anyInt());
runTestCheckExpiredDelaysAndResetAlarm();
@@ -589,9 +480,7 @@
}
@Test
- public void testCheckExpiredDelaysAndResetAlarm_WithSkipping_SomeNotReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.recheckAlarmsLocked();
+ public void testCheckExpiredDelaysAndResetAlarm_SomeNotReady() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
JobStatus jobLatest = createJobStatus("testCheckExpiredDelaysAndResetAlarm",
@@ -639,18 +528,7 @@
}
@Test
- public void testCheckExpiredDeadlinesAndResetAlarm_NoSkipping() {
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.recheckAlarmsLocked();
-
- runTestCheckExpiredDeadlinesAndResetAlarm();
- }
-
- @Test
- public void testCheckExpiredDeadlinesAndResetAlarm_WithSkipping_AllReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.recheckAlarmsLocked();
-
+ public void testCheckExpiredDeadlinesAndResetAlarm_AllReady() {
doReturn(true).when(mTimeController).wouldBeReadyWithConstraintLocked(any(), anyInt());
runTestCheckExpiredDeadlinesAndResetAlarm();
@@ -706,9 +584,7 @@
}
@Test
- public void testCheckExpiredDeadlinesAndResetAlarm_WithSkipping_SomeNotReady() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.recheckAlarmsLocked();
+ public void testCheckExpiredDeadlinesAndResetAlarm_SomeNotReady() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
JobStatus jobLatest = createJobStatus("testCheckExpiredDeadlinesAndResetAlarm",
@@ -756,28 +632,14 @@
}
@Test
- public void testEvaluateStateLocked_SkippingOff() {
- mConstants.SKIP_NOT_READY_JOBS = false;
- mTimeController.recheckAlarmsLocked();
- JobStatus job = createJobStatus("testEvaluateStateLocked_SkippingOff",
- createJob().setOverrideDeadline(HOUR_IN_MILLIS));
-
- mTimeController.evaluateStateLocked(job);
- verify(mAlarmManager, never())
- .set(anyInt(), anyLong(), anyLong(), anyLong(), anyString(), any(), any(), any());
- }
-
- @Test
- public void testEvaluateStateLocked_SkippingOn_Delay() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.recheckAlarmsLocked();
+ public void testEvaluateStateLocked_Delay() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
- JobStatus jobLatest = createJobStatus("testEvaluateStateLocked_SkippingOn_Delay",
+ JobStatus jobLatest = createJobStatus("testEvaluateStateLocked_Delay",
createJob().setMinimumLatency(HOUR_IN_MILLIS));
- JobStatus jobMiddle = createJobStatus("testEvaluateStateLocked_SkippingOn_Delay",
+ JobStatus jobMiddle = createJobStatus("testEvaluateStateLocked_Delay",
createJob().setMinimumLatency(30 * MINUTE_IN_MILLIS));
- JobStatus jobEarliest = createJobStatus("testEvaluateStateLocked_SkippingOn_Delay",
+ JobStatus jobEarliest = createJobStatus("testEvaluateStateLocked_Delay",
createJob().setMinimumLatency(5 * MINUTE_IN_MILLIS));
doReturn(false).when(mTimeController)
@@ -827,16 +689,14 @@
}
@Test
- public void testEvaluateStateLocked_SkippingOn_Deadline() {
- mConstants.SKIP_NOT_READY_JOBS = true;
- mTimeController.recheckAlarmsLocked();
+ public void testEvaluateStateLocked_Deadline() {
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
- JobStatus jobLatest = createJobStatus("testEvaluateStateLocked_SkippingOn_Deadline",
+ JobStatus jobLatest = createJobStatus("testEvaluateStateLocked_Deadline",
createJob().setOverrideDeadline(HOUR_IN_MILLIS));
- JobStatus jobMiddle = createJobStatus("testEvaluateStateLocked_SkippingOn_Deadline",
+ JobStatus jobMiddle = createJobStatus("testEvaluateStateLocked_Deadline",
createJob().setOverrideDeadline(30 * MINUTE_IN_MILLIS));
- JobStatus jobEarliest = createJobStatus("testEvaluateStateLocked_SkippingOn_Deadline",
+ JobStatus jobEarliest = createJobStatus("testEvaluateStateLocked_Deadline",
createJob().setOverrideDeadline(5 * MINUTE_IN_MILLIS));
doReturn(false).when(mTimeController)
diff --git a/services/tests/servicestests/src/com/android/server/display/color/ColorDisplayServiceTest.java b/services/tests/servicestests/src/com/android/server/display/color/ColorDisplayServiceTest.java
index fb2913b..a19b387 100644
--- a/services/tests/servicestests/src/com/android/server/display/color/ColorDisplayServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/display/color/ColorDisplayServiceTest.java
@@ -18,13 +18,19 @@
import static com.google.common.truth.Truth.assertWithMessage;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
import android.annotation.NonNull;
import android.app.ActivityManager;
import android.app.AlarmManager;
import android.content.Context;
import android.content.ContextWrapper;
+import android.content.res.Resources;
import android.hardware.display.ColorDisplayManager;
import android.hardware.display.Time;
import android.os.Handler;
@@ -33,6 +39,7 @@
import android.provider.Settings.Secure;
import android.provider.Settings.System;
import android.test.mock.MockContentResolver;
+import android.view.Display;
import androidx.test.InstrumentationRegistry;
import androidx.test.runner.AndroidJUnit4;
@@ -73,6 +80,8 @@
private ColorDisplayService mCds;
private ColorDisplayService.BinderService mBinderService;
+ private Resources mResourcesSpy;
+
@BeforeClass
public static void setDtm() {
final DisplayTransformManager dtm = Mockito.mock(DisplayTransformManager.class);
@@ -84,6 +93,9 @@
mContext = Mockito.spy(new ContextWrapper(InstrumentationRegistry.getTargetContext()));
doReturn(mContext).when(mContext).getApplicationContext();
+ mResourcesSpy = Mockito.spy(mContext.getResources());
+ when(mContext.getResources()).thenReturn(mResourcesSpy);
+
mUserId = ActivityManager.getCurrentUser();
final MockContentResolver cr = new MockContentResolver(mContext);
@@ -1050,6 +1062,80 @@
assertDwbActive(true);
}
+ @Test
+ public void compositionColorSpaces_noResources() {
+ final DisplayTransformManager dtm = LocalServices.getService(DisplayTransformManager.class);
+ reset(dtm);
+
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorModes))
+ .thenReturn(new int[] {});
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorSpaces))
+ .thenReturn(new int[] {});
+ setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL);
+ startService();
+ verify(dtm).setColorMode(eq(ColorDisplayManager.COLOR_MODE_NATURAL), any(),
+ eq(Display.COLOR_MODE_INVALID));
+ }
+
+ @Test
+ public void compositionColorSpaces_invalidResources() {
+ final DisplayTransformManager dtm = LocalServices.getService(DisplayTransformManager.class);
+ reset(dtm);
+
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorModes))
+ .thenReturn(new int[] {
+ ColorDisplayManager.COLOR_MODE_NATURAL,
+ // Missing second color mode
+ });
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorSpaces))
+ .thenReturn(new int[] {
+ Display.COLOR_MODE_SRGB,
+ Display.COLOR_MODE_DISPLAY_P3
+ });
+ setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL);
+ startService();
+ verify(dtm).setColorMode(eq(ColorDisplayManager.COLOR_MODE_NATURAL), any(),
+ eq(Display.COLOR_MODE_INVALID));
+ }
+
+ @Test
+ public void compositionColorSpaces_validResources_validColorMode() {
+ final DisplayTransformManager dtm = LocalServices.getService(DisplayTransformManager.class);
+ reset(dtm);
+
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorModes))
+ .thenReturn(new int[] {
+ ColorDisplayManager.COLOR_MODE_NATURAL
+ });
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorSpaces))
+ .thenReturn(new int[] {
+ Display.COLOR_MODE_SRGB,
+ });
+ setColorMode(ColorDisplayManager.COLOR_MODE_NATURAL);
+ startService();
+ verify(dtm).setColorMode(eq(ColorDisplayManager.COLOR_MODE_NATURAL), any(),
+ eq(Display.COLOR_MODE_SRGB));
+ }
+
+ @Test
+ public void compositionColorSpaces_validResources_invalidColorMode() {
+ final DisplayTransformManager dtm = LocalServices.getService(DisplayTransformManager.class);
+ reset(dtm);
+
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorModes))
+ .thenReturn(new int[] {
+ ColorDisplayManager.COLOR_MODE_NATURAL
+ });
+ when(mResourcesSpy.getIntArray(R.array.config_displayCompositionColorSpaces))
+ .thenReturn(new int[] {
+ Display.COLOR_MODE_SRGB,
+ });
+ setColorMode(ColorDisplayManager.COLOR_MODE_BOOSTED);
+ startService();
+ verify(dtm).setColorMode(eq(ColorDisplayManager.COLOR_MODE_BOOSTED), any(),
+ eq(Display.COLOR_MODE_INVALID));
+ }
+
/**
* Configures Night display to use a custom schedule.
*
diff --git a/services/tests/servicestests/src/com/android/server/net/NetworkPolicyManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/net/NetworkPolicyManagerServiceTest.java
index ce1edcd..09ae3a2 100644
--- a/services/tests/servicestests/src/com/android/server/net/NetworkPolicyManagerServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/net/NetworkPolicyManagerServiceTest.java
@@ -559,7 +559,25 @@
.build();
mService.updateRestrictBackgroundByLowPowerModeUL(stateOff);
- // RestrictBackground should be on, following its previous state
+ // RestrictBackground should be on, as before.
+ assertTrue(mService.getRestrictBackground());
+
+ stateOn = new PowerSaveState.Builder()
+ .setGlobalBatterySaverEnabled(true)
+ .setBatterySaverEnabled(true)
+ .build();
+ mService.updateRestrictBackgroundByLowPowerModeUL(stateOn);
+
+ // RestrictBackground should be on.
+ assertTrue(mService.getRestrictBackground());
+
+ stateOff = new PowerSaveState.Builder()
+ .setGlobalBatterySaverEnabled(false)
+ .setBatterySaverEnabled(false)
+ .build();
+ mService.updateRestrictBackgroundByLowPowerModeUL(stateOff);
+
+ // RestrictBackground should be on, as it was enabled manually before battery saver.
assertTrue(mService.getRestrictBackground());
}
@@ -585,6 +603,20 @@
// RestrictBackground should be off, following its previous state
assertFalse(mService.getRestrictBackground());
+
+ PowerSaveState stateOnRestrictOff = new PowerSaveState.Builder()
+ .setGlobalBatterySaverEnabled(true)
+ .setBatterySaverEnabled(false)
+ .build();
+
+ mService.updateRestrictBackgroundByLowPowerModeUL(stateOnRestrictOff);
+
+ assertFalse(mService.getRestrictBackground());
+
+ mService.updateRestrictBackgroundByLowPowerModeUL(stateOff);
+
+ // RestrictBackground should still be off.
+ assertFalse(mService.getRestrictBackground());
}
@Test
@@ -602,11 +634,49 @@
// User turns off RestrictBackground manually
setRestrictBackground(false);
- PowerSaveState stateOff = new PowerSaveState.Builder().setBatterySaverEnabled(
- false).build();
+ // RestrictBackground should be off because user changed it manually
+ assertFalse(mService.getRestrictBackground());
+
+ PowerSaveState stateOff = new PowerSaveState.Builder()
+ .setGlobalBatterySaverEnabled(false)
+ .setBatterySaverEnabled(false)
+ .build();
mService.updateRestrictBackgroundByLowPowerModeUL(stateOff);
- // RestrictBackground should be off because user changes it manually
+ // RestrictBackground should remain off.
+ assertFalse(mService.getRestrictBackground());
+ }
+
+ @Test
+ public void updateRestrictBackgroundByLowPowerMode_RestrictOnWithGlobalOff()
+ throws Exception {
+ setRestrictBackground(false);
+ PowerSaveState stateOn = new PowerSaveState.Builder()
+ .setGlobalBatterySaverEnabled(false)
+ .setBatterySaverEnabled(true)
+ .build();
+
+ mService.updateRestrictBackgroundByLowPowerModeUL(stateOn);
+
+ // RestrictBackground should be turned on because of battery saver.
+ assertTrue(mService.getRestrictBackground());
+
+ PowerSaveState stateRestrictOff = new PowerSaveState.Builder()
+ .setGlobalBatterySaverEnabled(true)
+ .setBatterySaverEnabled(false)
+ .build();
+ mService.updateRestrictBackgroundByLowPowerModeUL(stateRestrictOff);
+
+ // RestrictBackground should be off, returning to its state before battery saver's change.
+ assertFalse(mService.getRestrictBackground());
+
+ PowerSaveState stateOff = new PowerSaveState.Builder()
+ .setGlobalBatterySaverEnabled(false)
+ .setBatterySaverEnabled(false)
+ .build();
+ mService.updateRestrictBackgroundByLowPowerModeUL(stateOff);
+
+ // RestrictBackground should still be off, back in its pre-battery saver state.
assertFalse(mService.getRestrictBackground());
}
diff --git a/services/tests/uiservicestests/src/com/android/server/notification/BuzzBeepBlinkTest.java b/services/tests/uiservicestests/src/com/android/server/notification/BuzzBeepBlinkTest.java
index 6061d51..8c3373f 100644
--- a/services/tests/uiservicestests/src/com/android/server/notification/BuzzBeepBlinkTest.java
+++ b/services/tests/uiservicestests/src/com/android/server/notification/BuzzBeepBlinkTest.java
@@ -156,7 +156,7 @@
mService.setUsageStats(mUsageStats);
mService.setAccessibilityManager(accessibilityManager);
mService.mScreenOn = false;
- mService.mInCall = false;
+ mService.mInCallStateOffHook = false;
mService.mNotificationPulseEnabled = true;
}
@@ -681,7 +681,7 @@
mService.buzzBeepBlinkLocked(r);
Mockito.reset(mRingtonePlayer);
- mService.mInCall = true;
+ mService.mInCallStateOffHook = true;
mService.buzzBeepBlinkLocked(r);
verify(mService, times(1)).playInCallNotification();
@@ -1137,7 +1137,7 @@
@Test
public void testLightsInCall() {
- mService.mInCall = true;
+ mService.mInCallStateOffHook = true;
NotificationRecord r = getLightsNotification();
mService.buzzBeepBlinkLocked(r);
verifyNeverLights();
diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayPolicyTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayPolicyTests.java
index 1684f97..6a3c81a 100644
--- a/services/tests/wmtests/src/com/android/server/wm/DisplayPolicyTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/DisplayPolicyTests.java
@@ -32,6 +32,7 @@
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION;
import static android.view.WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD;
+import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR;
import static android.view.WindowManager.LayoutParams.TYPE_TOAST;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
@@ -49,10 +50,12 @@
import static org.mockito.Mockito.when;
import android.graphics.PixelFormat;
+import android.graphics.Rect;
import android.platform.test.annotations.Presubmit;
import android.view.Surface;
import android.view.WindowManager;
+import androidx.test.filters.FlakyTest;
import androidx.test.filters.SmallTest;
import org.junit.Test;
@@ -273,4 +276,37 @@
win.mHasSurface = true;
return win;
}
+
+ @Test
+ @FlakyTest(bugId = 131005232)
+ public void testOverlappingWithNavBar() {
+ final WindowState targetWin = createApplicationWindow();
+ final WindowFrames winFrame = targetWin.getWindowFrames();
+ winFrame.mFrame.set(new Rect(100, 100, 200, 200));
+
+ final WindowState navigationBar = createNavigationBarWindow();
+
+ navigationBar.getFrameLw().set(new Rect(100, 200, 200, 300));
+
+ assertFalse("Freeform is overlapping with navigation bar",
+ DisplayPolicy.isOverlappingWithNavBar(targetWin, navigationBar));
+
+ winFrame.mFrame.set(new Rect(100, 101, 200, 201));
+ assertTrue("Freeform should be overlapping with navigation bar (bottom)",
+ DisplayPolicy.isOverlappingWithNavBar(targetWin, navigationBar));
+
+ winFrame.mFrame.set(new Rect(99, 200, 199, 300));
+ assertTrue("Freeform should be overlapping with navigation bar (right)",
+ DisplayPolicy.isOverlappingWithNavBar(targetWin, navigationBar));
+
+ winFrame.mFrame.set(new Rect(199, 200, 299, 300));
+ assertTrue("Freeform should be overlapping with navigation bar (left)",
+ DisplayPolicy.isOverlappingWithNavBar(targetWin, navigationBar));
+ }
+
+ private WindowState createNavigationBarWindow() {
+ final WindowState win = createWindow(null, TYPE_NAVIGATION_BAR, "NavigationBar");
+ win.mHasSurface = true;
+ return win;
+ }
}
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 1b57c79..36698ea 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
@@ -302,43 +302,38 @@
@Test
public void testPrepareWindowToDisplayDuringRelayout() {
- testPrepareWindowToDisplayDuringRelayout(false /*wasVisible*/);
- testPrepareWindowToDisplayDuringRelayout(true /*wasVisible*/);
-
- // Call prepareWindowToDisplayDuringRelayout for a window without FLAG_TURN_SCREEN_ON
- // before calling prepareWindowToDisplayDuringRelayout for windows with flag in the same
- // appWindowToken.
+ // Call prepareWindowToDisplayDuringRelayout for a window without FLAG_TURN_SCREEN_ON before
+ // calling setCurrentLaunchCanTurnScreenOn for windows with flag in the same appWindowToken.
final AppWindowToken appWindowToken = createAppWindowToken(mDisplayContent,
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD);
final WindowState first = createWindow(null, TYPE_APPLICATION, appWindowToken, "first");
final WindowState second = createWindow(null, TYPE_APPLICATION, appWindowToken, "second");
second.mAttrs.flags |= WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
- reset(sPowerManagerWrapper);
- first.prepareWindowToDisplayDuringRelayout(false /*wasVisible*/);
- verify(sPowerManagerWrapper, never()).wakeUp(anyLong(), anyInt(), anyString());
- assertTrue(appWindowToken.canTurnScreenOn());
-
- reset(sPowerManagerWrapper);
- second.prepareWindowToDisplayDuringRelayout(false /*wasVisible*/);
- verify(sPowerManagerWrapper).wakeUp(anyLong(), anyInt(), anyString());
- assertFalse(appWindowToken.canTurnScreenOn());
+ testPrepareWindowToDisplayDuringRelayout(first, false /* expectedWakeupCalled */,
+ true /* expectedCurrentLaunchCanTurnScreenOn */);
+ testPrepareWindowToDisplayDuringRelayout(second, true /* expectedWakeupCalled */,
+ false /* expectedCurrentLaunchCanTurnScreenOn */);
// Call prepareWindowToDisplayDuringRelayout for two window that have FLAG_TURN_SCREEN_ON
// from the same appWindowToken. Only one should trigger the wakeup.
- appWindowToken.setCanTurnScreenOn(true);
+ appWindowToken.setCurrentLaunchCanTurnScreenOn(true);
first.mAttrs.flags |= WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
second.mAttrs.flags |= WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
- reset(sPowerManagerWrapper);
- first.prepareWindowToDisplayDuringRelayout(false /*wasVisible*/);
- verify(sPowerManagerWrapper).wakeUp(anyLong(), anyInt(), anyString());
- assertFalse(appWindowToken.canTurnScreenOn());
+ testPrepareWindowToDisplayDuringRelayout(first, true /* expectedWakeupCalled */,
+ false /* expectedCurrentLaunchCanTurnScreenOn */);
+ testPrepareWindowToDisplayDuringRelayout(second, false /* expectedWakeupCalled */,
+ false /* expectedCurrentLaunchCanTurnScreenOn */);
- reset(sPowerManagerWrapper);
- second.prepareWindowToDisplayDuringRelayout(false /*wasVisible*/);
- verify(sPowerManagerWrapper, never()).wakeUp(anyLong(), anyInt(), anyString());
- assertFalse(appWindowToken.canTurnScreenOn());
+ // Without window flags, the state of ActivityRecord.canTurnScreenOn should still be able to
+ // turn on the screen.
+ appWindowToken.setCurrentLaunchCanTurnScreenOn(true);
+ first.mAttrs.flags &= ~WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
+ doReturn(true).when(appWindowToken.mActivityRecord).canTurnScreenOn();
+
+ testPrepareWindowToDisplayDuringRelayout(first, true /* expectedWakeupCalled */,
+ false /* expectedCurrentLaunchCanTurnScreenOn */);
// Call prepareWindowToDisplayDuringRelayout for a windows that are not children of an
// appWindowToken. Both windows have the FLAG_TURNS_SCREEN_ON so both should call wakeup
@@ -360,6 +355,22 @@
verify(sPowerManagerWrapper).wakeUp(anyLong(), anyInt(), anyString());
}
+ private void testPrepareWindowToDisplayDuringRelayout(WindowState appWindow,
+ boolean expectedWakeupCalled, boolean expectedCurrentLaunchCanTurnScreenOn) {
+ reset(sPowerManagerWrapper);
+ appWindow.prepareWindowToDisplayDuringRelayout(false /* wasVisible */);
+
+ if (expectedWakeupCalled) {
+ verify(sPowerManagerWrapper).wakeUp(anyLong(), anyInt(), anyString());
+ } else {
+ verify(sPowerManagerWrapper, never()).wakeUp(anyLong(), anyInt(), anyString());
+ }
+ // If wakeup is expected to be called, the currentLaunchCanTurnScreenOn should be false
+ // because the state will be consumed.
+ assertThat(appWindow.mAppToken.currentLaunchCanTurnScreenOn(),
+ is(expectedCurrentLaunchCanTurnScreenOn));
+ }
+
@Test
public void testCanAffectSystemUiFlags() {
final WindowState app = createWindow(null, TYPE_APPLICATION, "app");
@@ -487,15 +498,6 @@
assertThat(app.getWmDisplayCutout().getDisplayCutout(), is(cutout.inset(7, 10, 5, 20)));
}
- private void testPrepareWindowToDisplayDuringRelayout(boolean wasVisible) {
- reset(sPowerManagerWrapper);
- final WindowState root = createWindow(null, TYPE_APPLICATION, "root");
- root.mAttrs.flags |= WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
-
- root.prepareWindowToDisplayDuringRelayout(wasVisible /*wasVisible*/);
- verify(sPowerManagerWrapper).wakeUp(anyLong(), anyInt(), anyString());
- }
-
@Test
public void testVisibilityChangeSwitchUser() {
final WindowState window = createWindow(null, TYPE_APPLICATION, "app");
diff --git a/test-mock/src/android/test/mock/MockContentProvider.java b/test-mock/src/android/test/mock/MockContentProvider.java
index e9a5ff7..4d8c7d9 100644
--- a/test-mock/src/android/test/mock/MockContentProvider.java
+++ b/test-mock/src/android/test/mock/MockContentProvider.java
@@ -16,6 +16,7 @@
package android.test.mock;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.ContentProvider;
import android.content.ContentProviderOperation;
@@ -23,6 +24,7 @@
import android.content.ContentValues;
import android.content.Context;
import android.content.IContentProvider;
+import android.content.Intent;
import android.content.OperationApplicationException;
import android.content.pm.PathPermission;
import android.content.pm.ProviderInfo;
@@ -154,6 +156,11 @@
ICancellationSignal cancellationSignal) throws RemoteException {
return MockContentProvider.this.refresh(url, args);
}
+
+ @Override
+ public int checkUriPermission(String callingPkg, Uri uri, int uid, int modeFlags) {
+ return MockContentProvider.this.checkUriPermission(uri, uid, modeFlags);
+ }
}
private final InversionIContentProvider mIContentProvider = new InversionIContentProvider();
@@ -266,6 +273,12 @@
throw new UnsupportedOperationException("unimplemented mock method call");
}
+ /** {@hide} */
+ @Override
+ public int checkUriPermission(@NonNull Uri uri, int uid, @Intent.AccessUriMode int modeFlags) {
+ throw new UnsupportedOperationException("unimplemented mock method call");
+ }
+
/**
* Returns IContentProvider which calls back same methods in this class.
* By overriding this class, we avoid the mechanism hidden behind ContentProvider
diff --git a/test-mock/src/android/test/mock/MockIContentProvider.java b/test-mock/src/android/test/mock/MockIContentProvider.java
index fc2a464..b072d74 100644
--- a/test-mock/src/android/test/mock/MockIContentProvider.java
+++ b/test-mock/src/android/test/mock/MockIContentProvider.java
@@ -16,12 +16,14 @@
package android.test.mock;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.ContentProviderOperation;
import android.content.ContentProviderResult;
import android.content.ContentValues;
import android.content.EntityIterator;
import android.content.IContentProvider;
+import android.content.Intent;
import android.content.res.AssetFileDescriptor;
import android.database.Cursor;
import android.net.Uri;
@@ -144,4 +146,10 @@
ICancellationSignal cancellationSignal) throws RemoteException {
throw new UnsupportedOperationException("unimplemented mock method");
}
+
+ /** {@hide} */
+ @Override
+ public int checkUriPermission(String callingPkg, Uri uri, int uid, int modeFlags) {
+ throw new UnsupportedOperationException("unimplemented mock method call");
+ }
}
diff --git a/tools/aapt2/cmd/Optimize.h b/tools/aapt2/cmd/Optimize.h
index 7f4a3ed..0be7dad 100644
--- a/tools/aapt2/cmd/Optimize.h
+++ b/tools/aapt2/cmd/Optimize.h
@@ -57,7 +57,7 @@
std::unordered_set<std::string> kept_artifacts;
// Whether or not to shorten resource paths in the APK.
- bool shorten_resource_paths;
+ bool shorten_resource_paths = false;
// Path to the output map of original resource paths to shortened paths.
Maybe<std::string> shortened_paths_map_path;
diff --git a/tools/lock_agent/Android.bp b/tools/lock_agent/Android.bp
index 408946b..79dce4a 100644
--- a/tools/lock_agent/Android.bp
+++ b/tools/lock_agent/Android.bp
@@ -12,13 +12,9 @@
],
sdk_version: "current",
stl: "c++_static",
- include_dirs: [
- // NDK headers aren't available in platform NDK builds.
- "libnativehelper/include_jni",
- // Use ScopedUtfChars.
- "libnativehelper/header_only_include",
- ],
header_libs: [
+ // Use ScopedUtfChars.
+ "libnativehelper_header_only",
"libopenjdkjvmti_headers",
],
compile_multilib: "both",
@@ -32,13 +28,9 @@
"libz",
"slicer",
],
- include_dirs: [
- // NDK headers aren't available in platform NDK builds.
- "libnativehelper/include_jni",
- // Use ScopedUtfChars.
- "libnativehelper/header_only_include",
- ],
header_libs: [
+ // Use ScopedUtfChars.
+ "libnativehelper_header_only",
"libopenjdkjvmti_headers",
],
}