Merge "Remove bubble options from notification_info xml"
diff --git a/Android.bp b/Android.bp
index b30bdaa..1865a3d 100644
--- a/Android.bp
+++ b/Android.bp
@@ -318,6 +318,7 @@
"rs/java",
"sax/java",
"telecomm/java",
+ "wifi/aidl-export",
],
},
diff --git a/apex/blobstore/framework/java/android/app/blob/BlobHandle.java b/apex/blobstore/framework/java/android/app/blob/BlobHandle.java
index 6aca4a1..60c3136 100644
--- a/apex/blobstore/framework/java/android/app/blob/BlobHandle.java
+++ b/apex/blobstore/framework/java/android/app/blob/BlobHandle.java
@@ -22,6 +22,9 @@
import com.android.internal.util.Preconditions;
+import java.util.Arrays;
+import java.util.Objects;
+
/**
* An identifier to represent a blob.
*/
@@ -173,6 +176,27 @@
dest.writeString(tag);
}
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null || !(obj instanceof BlobHandle)) {
+ return false;
+ }
+ final BlobHandle other = (BlobHandle) obj;
+ return this.algorithm.equals(other.algorithm)
+ && Arrays.equals(this.digest, other.digest)
+ && this.label.equals(other.label)
+ && this.expiryTimeMillis == other.expiryTimeMillis
+ && this.tag.equals(tag);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(algorithm, Arrays.hashCode(digest), label, expiryTimeMillis, tag);
+ }
+
public static final @NonNull Creator<BlobHandle> CREATOR = new Creator<BlobHandle>() {
@Override
public @NonNull BlobHandle createFromParcel(@NonNull Parcel source) {
diff --git a/apex/blobstore/framework/java/android/app/blob/BlobStoreManager.java b/apex/blobstore/framework/java/android/app/blob/BlobStoreManager.java
index 4395e5a..47af7c0 100644
--- a/apex/blobstore/framework/java/android/app/blob/BlobStoreManager.java
+++ b/apex/blobstore/framework/java/android/app/blob/BlobStoreManager.java
@@ -45,6 +45,11 @@
*/
@SystemService(Context.BLOB_STORE_SERVICE)
public class BlobStoreManager {
+ /** @hide */
+ public static final int COMMIT_RESULT_SUCCESS = 0;
+ /** @hide */
+ public static final int COMMIT_RESULT_ERROR = 1;
+
private final Context mContext;
private final IBlobStoreManager mService;
@@ -102,7 +107,28 @@
*/
public @NonNull Session openSession(@IntRange(from = 1) long sessionId) throws IOException {
try {
- return new Session(mService.openSession(sessionId));
+ return new Session(mService.openSession(sessionId, mContext.getOpPackageName()));
+ } catch (ParcelableException e) {
+ e.maybeRethrow(IOException.class);
+ throw new RuntimeException(e);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
+ * Delete an existing session and any data that was written to that session so far.
+ *
+ * @param sessionId a unique id obtained via {@link #createSession(BlobHandle)} that
+ * represents a particular session.
+ *
+ * @throws IOException when there is an I/O error while deleting the session.
+ * @throws SecurityException when the caller does not own the session, or
+ * the session does not exist or is invalid.
+ */
+ public void deleteSession(@IntRange(from = 1) long sessionId) throws IOException {
+ try {
+ mService.deleteSession(sessionId, mContext.getOpPackageName());
} catch (ParcelableException e) {
e.maybeRethrow(IOException.class);
throw new RuntimeException(e);
@@ -142,6 +168,9 @@
* <p> Any active leases will be automatically released when the blob's expiry time
* ({@link BlobHandle#getExpiryTimeMillis()}) is elapsed.
*
+ * <p> This lease information is persisted and calling this more than once will result in
+ * latest lease overriding any previous lease.
+ *
* @param blobHandle the {@link BlobHandle} representing the blob that the caller wants to
* acquire a lease for.
* @param descriptionResId the resource id for a short description string that can be surfaced
@@ -190,6 +219,9 @@
* <p> Any active leases will be automatically released when the blob's expiry time
* ({@link BlobHandle#getExpiryTimeMillis()}) is elapsed.
*
+ * <p> This lease information is persisted and calling this more than once will result in
+ * latest lease overriding any previous lease.
+ *
* @param blobHandle the {@link BlobHandle} representing the blob that the caller wants to
* acquire a lease for.
* @param descriptionResId the resource id for a short description string that can be surfaced
@@ -279,7 +311,9 @@
public @NonNull ParcelFileDescriptor openWrite(@BytesLong long offsetBytes,
@BytesLong long lengthBytes) throws IOException {
try {
- return mSession.openWrite(offsetBytes, lengthBytes);
+ final ParcelFileDescriptor pfd = mSession.openWrite(offsetBytes, lengthBytes);
+ pfd.seekTo(offsetBytes);
+ return pfd;
} catch (ParcelableException e) {
e.maybeRethrow(IOException.class);
throw new RuntimeException(e);
@@ -376,6 +410,31 @@
}
/**
+ * Returns {@code true} if access has been allowed for a {@code packageName} using either
+ * {@link #allowPackageAccess(String, byte[])}.
+ * Otherwise, {@code false}.
+ *
+ * @param packageName the name of the package to check the access for.
+ * @param certificate the input bytes representing a certificate of type
+ * {@link android.content.pm.PackageManager#CERT_INPUT_SHA256}.
+ *
+ * @throws IOException when there is an I/O error while getting the access type.
+ * @throws IllegalStateException when the caller tries to get access type from a session
+ * which is closed or abandoned.
+ */
+ public boolean isPackageAccessAllowed(@NonNull String packageName,
+ @NonNull byte[] certificate) throws IOException {
+ try {
+ return mSession.isPackageAccessAllowed(packageName, certificate);
+ } catch (ParcelableException e) {
+ e.maybeRethrow(IOException.class);
+ throw new RuntimeException(e);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
* Allow packages which are signed with the same certificate as the caller to access this
* blob data once it is committed using a {@link BlobHandle} representing the blob.
*
@@ -399,6 +458,26 @@
}
/**
+ * Returns {@code true} if access has been allowed for packages signed with the same
+ * certificate as the caller by using {@link #allowSameSignatureAccess()}.
+ * Otherwise, {@code false}.
+ *
+ * @throws IOException when there is an I/O error while getting the access type.
+ * @throws IllegalStateException when the caller tries to get access type from a session
+ * which is closed or abandoned.
+ */
+ public boolean isSameSignatureAccessAllowed() throws IOException {
+ try {
+ return mSession.isSameSignatureAccessAllowed();
+ } catch (ParcelableException e) {
+ e.maybeRethrow(IOException.class);
+ throw new RuntimeException(e);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
* Allow any app on the device to access this blob data once it is committed using
* a {@link BlobHandle} representing the blob.
*
@@ -427,6 +506,25 @@
}
/**
+ * Returns {@code true} if public access has been allowed by using
+ * {@link #allowPublicAccess()}. Otherwise, {@code false}.
+ *
+ * @throws IOException when there is an I/O error while getting the access type.
+ * @throws IllegalStateException when the caller tries to get access type from a session
+ * which is closed or abandoned.
+ */
+ public boolean isPublicAccessAllowed() throws IOException {
+ try {
+ return mSession.isPublicAccessAllowed();
+ } catch (ParcelableException e) {
+ e.maybeRethrow(IOException.class);
+ throw new RuntimeException(e);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
* Commit the file that was written so far to this session to the blob store maintained by
* the system.
*
@@ -439,6 +537,10 @@
* {@link BlobHandle#createWithSha256(byte[], CharSequence, long, String)} BlobHandle}
* associated with this session.
*
+ * <p> Committing the same data more than once will result in replacing the corresponding
+ * access mode (via calling one of {@link #allowPackageAccess(String, byte[])},
+ * {@link #allowSameSignatureAccess()}, etc) with the latest one.
+ *
* @param executor the executor on which result callback will be invoked.
* @param resultCallback a callback to receive the commit result. when the result is
* {@code 0}, it indicates success. Otherwise, failure.
diff --git a/apex/blobstore/framework/java/android/app/blob/IBlobStoreManager.aidl b/apex/blobstore/framework/java/android/app/blob/IBlobStoreManager.aidl
index b7a2f1a..dfbf78f 100644
--- a/apex/blobstore/framework/java/android/app/blob/IBlobStoreManager.aidl
+++ b/apex/blobstore/framework/java/android/app/blob/IBlobStoreManager.aidl
@@ -21,8 +21,9 @@
/** {@hide} */
interface IBlobStoreManager {
long createSession(in BlobHandle handle, in String packageName);
- IBlobStoreSession openSession(long sessionId);
+ IBlobStoreSession openSession(long sessionId, in String packageName);
ParcelFileDescriptor openBlob(in BlobHandle handle, in String packageName);
+ void deleteSession(long sessionId, in String packageName);
void acquireLease(in BlobHandle handle, int descriptionResId, long leaseTimeout,
in String packageName);
diff --git a/apex/blobstore/framework/java/android/app/blob/IBlobStoreSession.aidl b/apex/blobstore/framework/java/android/app/blob/IBlobStoreSession.aidl
index bb5ef3b..4ae919b 100644
--- a/apex/blobstore/framework/java/android/app/blob/IBlobStoreSession.aidl
+++ b/apex/blobstore/framework/java/android/app/blob/IBlobStoreSession.aidl
@@ -26,6 +26,10 @@
void allowSameSignatureAccess();
void allowPublicAccess();
+ boolean isPackageAccessAllowed(in String packageName, in byte[] certificate);
+ boolean isSameSignatureAccessAllowed();
+ boolean isPublicAccessAllowed();
+
long getSize();
void close();
void abandon();
diff --git a/apex/blobstore/service/java/com/android/server/blob/BlobAccessMode.java b/apex/blobstore/service/java/com/android/server/blob/BlobAccessMode.java
new file mode 100644
index 0000000..357250a
--- /dev/null
+++ b/apex/blobstore/service/java/com/android/server/blob/BlobAccessMode.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2020 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.server.blob;
+
+import android.annotation.IntDef;
+import android.annotation.NonNull;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.util.ArraySet;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * Class for representing how a blob can be shared.
+ *
+ * Note that this class is not thread-safe, callers need to take of synchronizing access.
+ */
+class BlobAccessMode {
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(flag = true, value = {
+ ACCESS_TYPE_PRIVATE,
+ ACCESS_TYPE_PUBLIC,
+ ACCESS_TYPE_SAME_SIGNATURE,
+ ACCESS_TYPE_WHITELIST,
+ })
+ @interface AccessType {}
+ static final int ACCESS_TYPE_PRIVATE = 1 << 0;
+ static final int ACCESS_TYPE_PUBLIC = 1 << 1;
+ static final int ACCESS_TYPE_SAME_SIGNATURE = 1 << 2;
+ static final int ACCESS_TYPE_WHITELIST = 1 << 3;
+
+ private int mAccessType = ACCESS_TYPE_PRIVATE;
+
+ private final ArraySet<PackageIdentifier> mWhitelistedPackages = new ArraySet<>();
+
+ void allow(BlobAccessMode other) {
+ if ((other.mAccessType & ACCESS_TYPE_WHITELIST) != 0) {
+ mWhitelistedPackages.addAll(other.mWhitelistedPackages);
+ }
+ mAccessType |= other.mAccessType;
+ }
+
+ void allowPublicAccess() {
+ mAccessType |= ACCESS_TYPE_PUBLIC;
+ }
+
+ void allowSameSignatureAccess() {
+ mAccessType |= ACCESS_TYPE_SAME_SIGNATURE;
+ }
+
+ void allowPackageAccess(@NonNull String packageName, @NonNull byte[] certificate) {
+ mAccessType |= ACCESS_TYPE_WHITELIST;
+ mWhitelistedPackages.add(PackageIdentifier.create(packageName, certificate));
+ }
+
+ boolean isPublicAccessAllowed() {
+ return (mAccessType & ACCESS_TYPE_PUBLIC) != 0;
+ }
+
+ boolean isSameSignatureAccessAllowed() {
+ return (mAccessType & ACCESS_TYPE_SAME_SIGNATURE) != 0;
+ }
+
+ boolean isPackageAccessAllowed(@NonNull String packageName, @NonNull byte[] certificate) {
+ if ((mAccessType & ACCESS_TYPE_WHITELIST) == 0) {
+ return false;
+ }
+ return mWhitelistedPackages.contains(PackageIdentifier.create(packageName, certificate));
+ }
+
+ boolean isAccessAllowedForCaller(Context context,
+ @NonNull String callingPackage, @NonNull String committerPackage) {
+ if ((mAccessType & ACCESS_TYPE_PUBLIC) != 0) {
+ return true;
+ }
+
+ final PackageManager pm = context.getPackageManager();
+ if ((mAccessType & ACCESS_TYPE_SAME_SIGNATURE) != 0) {
+ if (pm.checkSignatures(committerPackage, callingPackage)
+ == PackageManager.SIGNATURE_MATCH) {
+ return true;
+ }
+ }
+
+ if ((mAccessType & ACCESS_TYPE_WHITELIST) != 0) {
+ for (int i = 0; i < mWhitelistedPackages.size(); ++i) {
+ final PackageIdentifier packageIdentifier = mWhitelistedPackages.valueAt(i);
+ if (packageIdentifier.packageName.equals(callingPackage)
+ && pm.hasSigningCertificate(callingPackage, packageIdentifier.certificate,
+ PackageManager.CERT_INPUT_SHA256)) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ private static final class PackageIdentifier {
+ public final String packageName;
+ public final byte[] certificate;
+
+ private PackageIdentifier(@NonNull String packageName, @NonNull byte[] certificate) {
+ this.packageName = packageName;
+ this.certificate = certificate;
+ }
+
+ public static PackageIdentifier create(@NonNull String packageName,
+ @NonNull byte[] certificate) {
+ return new PackageIdentifier(packageName, certificate);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null || !(obj instanceof PackageIdentifier)) {
+ return false;
+ }
+ final PackageIdentifier other = (PackageIdentifier) obj;
+ return this.packageName.equals(other.packageName)
+ && Arrays.equals(this.certificate, other.certificate);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(packageName, Arrays.hashCode(certificate));
+ }
+ }
+}
diff --git a/apex/blobstore/service/java/com/android/server/blob/BlobMetadata.java b/apex/blobstore/service/java/com/android/server/blob/BlobMetadata.java
new file mode 100644
index 0000000..d3a2271
--- /dev/null
+++ b/apex/blobstore/service/java/com/android/server/blob/BlobMetadata.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2020 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.server.blob;
+
+import static android.system.OsConstants.O_RDONLY;
+
+import android.annotation.NonNull;
+import android.app.blob.BlobHandle;
+import android.content.Context;
+import android.os.ParcelFileDescriptor;
+import android.os.RevocableFileDescriptor;
+import android.system.ErrnoException;
+import android.system.Os;
+import android.util.ArrayMap;
+import android.util.ArraySet;
+
+import com.android.internal.annotations.GuardedBy;
+
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.util.Objects;
+
+class BlobMetadata {
+ private final Object mMetadataLock = new Object();
+
+ private final Context mContext;
+ private final long mBlobId;
+ private final BlobHandle mBlobHandle;
+
+ @GuardedBy("mMetadataLock")
+ private final ArraySet<Committer> mCommitters = new ArraySet<>();
+
+ @GuardedBy("mMetadataLock")
+ private final ArraySet<Leasee> mLeasees = new ArraySet<>();
+
+ /**
+ * Contains packageName -> {RevocableFileDescriptors}.
+ *
+ * Keep track of RevocableFileDescriptors given to clients which are not yet revoked/closed so
+ * that when clients access is revoked or the blob gets deleted, we can be sure that clients
+ * do not have any reference to the blob and the space occupied by the blob can be freed.
+ */
+ @GuardedBy("mRevocableFds")
+ private final ArrayMap<String, ArraySet<RevocableFileDescriptor>> mRevocableFds =
+ new ArrayMap<>();
+
+ BlobMetadata(Context context, long blobId, BlobHandle blobHandle) {
+ mContext = context;
+ mBlobId = blobId;
+ mBlobHandle = blobHandle;
+ }
+
+ void addCommitter(String packageName, int uid, BlobAccessMode blobAccessMode) {
+ synchronized (mMetadataLock) {
+ mCommitters.add(new Committer(packageName, uid, blobAccessMode));
+ }
+ }
+
+ void addLeasee(String callingPackage, int callingUid,
+ int descriptionResId, long leaseExpiryTimeMillis) {
+ synchronized (mMetadataLock) {
+ mLeasees.add(new Leasee(callingPackage, callingUid,
+ descriptionResId, leaseExpiryTimeMillis));
+ }
+ }
+
+ void removeLeasee(String packageName, int uid) {
+ synchronized (mMetadataLock) {
+ mLeasees.remove(new Accessor(packageName, uid));
+ }
+ }
+
+ boolean isAccessAllowedForCaller(String callingPackage, int callingUid) {
+ // TODO: verify blob is still valid (expiryTime is not elapsed)
+ synchronized (mMetadataLock) {
+ // Check if packageName already holds a lease on the blob.
+ for (int i = 0, size = mLeasees.size(); i < size; ++i) {
+ final Leasee leasee = mLeasees.valueAt(i);
+ if (leasee.equals(callingPackage, callingUid)
+ && leasee.isStillValid()) {
+ return true;
+ }
+ }
+
+ for (int i = 0, size = mCommitters.size(); i < size; ++i) {
+ final Committer committer = mCommitters.valueAt(i);
+
+ // Check if the caller is the same package that committed the blob.
+ if (committer.equals(callingPackage, callingUid)) {
+ return true;
+ }
+
+ // Check if the caller is allowed access as per the access mode specified
+ // by the committer.
+ if (committer.blobAccessMode.isAccessAllowedForCaller(mContext,
+ callingPackage, committer.packageName)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ ParcelFileDescriptor openForRead(String callingPackage) throws IOException {
+ // TODO: Add limit on opened fds
+ FileDescriptor fd;
+ try {
+ fd = Os.open(BlobStoreConfig.getBlobFile(mBlobId).getPath(), O_RDONLY, 0);
+ } catch (ErrnoException e) {
+ throw e.rethrowAsIOException();
+ }
+ synchronized (mMetadataLock) {
+ return createRevocableFdLocked(fd, callingPackage);
+ }
+ }
+
+ @GuardedBy("mMetadataLock")
+ @NonNull
+ private ParcelFileDescriptor createRevocableFdLocked(FileDescriptor fd,
+ String callingPackage) throws IOException {
+ final RevocableFileDescriptor revocableFd =
+ new RevocableFileDescriptor(mContext, fd);
+ synchronized (mRevocableFds) {
+ ArraySet<RevocableFileDescriptor> revocableFdsForPkg =
+ mRevocableFds.get(callingPackage);
+ if (revocableFdsForPkg == null) {
+ revocableFdsForPkg = new ArraySet<>();
+ mRevocableFds.put(callingPackage, revocableFdsForPkg);
+ }
+ revocableFdsForPkg.add(revocableFd);
+ }
+ revocableFd.addOnCloseListener((e) -> {
+ synchronized (mRevocableFds) {
+ final ArraySet<RevocableFileDescriptor> revocableFdsForPkg =
+ mRevocableFds.get(callingPackage);
+ if (revocableFdsForPkg != null) {
+ revocableFdsForPkg.remove(revocableFd);
+ }
+ }
+ });
+ return revocableFd.getRevocableFileDescriptor();
+ }
+
+ static final class Committer extends Accessor {
+ public final BlobAccessMode blobAccessMode;
+
+ Committer(String packageName, int uid, BlobAccessMode blobAccessMode) {
+ super(packageName, uid);
+ this.blobAccessMode = blobAccessMode;
+ }
+ }
+
+ static final class Leasee extends Accessor {
+ public final int descriptionResId;
+ public final long expiryTimeMillis;
+
+ Leasee(String packageName, int uid, int descriptionResId, long expiryTimeMillis) {
+ super(packageName, uid);
+ this.descriptionResId = descriptionResId;
+ this.expiryTimeMillis = expiryTimeMillis;
+ }
+
+ boolean isStillValid() {
+ return expiryTimeMillis == 0 || expiryTimeMillis <= System.currentTimeMillis();
+ }
+ }
+
+ static class Accessor {
+ public final String packageName;
+ public final int uid;
+
+ Accessor(String packageName, int uid) {
+ this.packageName = packageName;
+ this.uid = uid;
+ }
+
+ public boolean equals(String packageName, int uid) {
+ return this.uid == uid && this.packageName.equals(packageName);
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null || !(obj instanceof Accessor)) {
+ return false;
+ }
+ final Accessor other = (Accessor) obj;
+ return this.uid == other.uid && this.packageName.equals(other.packageName);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(packageName, uid);
+ }
+ }
+}
diff --git a/apex/blobstore/service/java/com/android/server/blob/BlobStoreConfig.java b/apex/blobstore/service/java/com/android/server/blob/BlobStoreConfig.java
new file mode 100644
index 0000000..b9a4b17
--- /dev/null
+++ b/apex/blobstore/service/java/com/android/server/blob/BlobStoreConfig.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2020 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.server.blob;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.os.Environment;
+import android.util.Slog;
+
+import java.io.File;
+
+class BlobStoreConfig {
+ public static final String TAG = "BlobStore";
+
+ @Nullable
+ public static File prepareBlobFile(long sessionId) {
+ final File blobsDir = prepareBlobsDir();
+ return blobsDir == null ? null : getBlobFile(blobsDir, sessionId);
+ }
+
+ @NonNull
+ public static File getBlobFile(long sessionId) {
+ return getBlobFile(getBlobsDir(), sessionId);
+ }
+
+ @NonNull
+ private static File getBlobFile(File blobsDir, long sessionId) {
+ return new File(blobsDir, String.valueOf(sessionId));
+ }
+
+ @Nullable
+ public static File prepareBlobsDir() {
+ final File blobsDir = getBlobsDir(prepareBlobStoreRootDir());
+ if (!blobsDir.exists() && !blobsDir.mkdir()) {
+ Slog.e(TAG, "Failed to mkdir(): " + blobsDir);
+ return null;
+ }
+ return blobsDir;
+ }
+
+ @NonNull
+ public static File getBlobsDir() {
+ return getBlobsDir(getBlobStoreRootDir());
+ }
+
+ @NonNull
+ private static File getBlobsDir(File blobsRootDir) {
+ return new File(blobsRootDir, "blobs");
+ }
+
+ @Nullable
+ public static File prepareBlobStoreRootDir() {
+ final File blobStoreRootDir = getBlobStoreRootDir();
+ if (!blobStoreRootDir.exists() && !blobStoreRootDir.mkdir()) {
+ Slog.e(TAG, "Failed to mkdir(): " + blobStoreRootDir);
+ return null;
+ }
+ return blobStoreRootDir;
+ }
+
+ @NonNull
+ public static File getBlobStoreRootDir() {
+ return new File(Environment.getDataSystemDirectory(), "blobstore");
+ }
+}
diff --git a/apex/blobstore/service/java/com/android/server/blob/BlobStoreManagerService.java b/apex/blobstore/service/java/com/android/server/blob/BlobStoreManagerService.java
index b204fee..9d60f86 100644
--- a/apex/blobstore/service/java/com/android/server/blob/BlobStoreManagerService.java
+++ b/apex/blobstore/service/java/com/android/server/blob/BlobStoreManagerService.java
@@ -15,58 +15,350 @@
*/
package com.android.server.blob;
+import static android.app.blob.BlobStoreManager.COMMIT_RESULT_SUCCESS;
+
+import static com.android.server.blob.BlobStoreConfig.TAG;
+import static com.android.server.blob.BlobStoreSession.STATE_ABANDONED;
+import static com.android.server.blob.BlobStoreSession.STATE_COMMITTED;
+import static com.android.server.blob.BlobStoreSession.STATE_VERIFIED_INVALID;
+import static com.android.server.blob.BlobStoreSession.STATE_VERIFIED_VALID;
+import static com.android.server.blob.BlobStoreSession.stateToString;
+
import android.annotation.CurrentTimeSecondsLong;
import android.annotation.IdRes;
+import android.annotation.IntRange;
import android.annotation.NonNull;
import android.app.blob.BlobHandle;
import android.app.blob.IBlobStoreManager;
import android.app.blob.IBlobStoreSession;
import android.content.Context;
+import android.content.pm.PackageManagerInternal;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.HandlerThread;
import android.os.ParcelFileDescriptor;
+import android.os.Process;
+import android.os.UserHandle;
+import android.util.ArrayMap;
+import android.util.ExceptionUtils;
+import android.util.LongSparseArray;
+import android.util.Slog;
+import android.util.SparseArray;
+import com.android.internal.annotations.GuardedBy;
+import com.android.internal.util.Preconditions;
+import com.android.internal.util.function.pooled.PooledLambda;
+import com.android.server.LocalServices;
+import com.android.server.ServiceThread;
import com.android.server.SystemService;
+import com.android.server.Watchdog;
+
+import java.io.IOException;
/**
* Service responsible for maintaining and facilitating access to data blobs published by apps.
*/
public class BlobStoreManagerService extends SystemService {
+ private final Object mBlobsLock = new Object();
+
+ // Contains data of userId -> {sessionId -> {BlobStoreSession}}.
+ @GuardedBy("mBlobsLock")
+ private final SparseArray<LongSparseArray<BlobStoreSession>> mSessions = new SparseArray<>();
+
+ @GuardedBy("mBlobsLock")
+ private long mCurrentMaxSessionId;
+
+ // Contains data of userId -> {BlobHandle -> {BlobMetadata}}
+ @GuardedBy("mBlobsLock")
+ private final SparseArray<ArrayMap<BlobHandle, BlobMetadata>> mBlobsMap = new SparseArray<>();
+
private final Context mContext;
+ private final Handler mHandler;
+ private final SessionStateChangeListener mSessionStateChangeListener =
+ new SessionStateChangeListener();
+
+ private PackageManagerInternal mPackageManagerInternal;
public BlobStoreManagerService(Context context) {
super(context);
mContext = context;
+
+ final HandlerThread handlerThread = new ServiceThread(TAG,
+ Process.THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
+ handlerThread.start();
+ mHandler = new Handler(handlerThread.getLooper());
+ Watchdog.getInstance().addThread(mHandler);
}
@Override
public void onStart() {
publishBinderService(Context.BLOB_STORE_SERVICE, new Stub());
+
+ mPackageManagerInternal = LocalServices.getService(PackageManagerInternal.class);
+ }
+
+
+ @GuardedBy("mBlobsLock")
+ private long generateNextSessionIdLocked() {
+ return ++mCurrentMaxSessionId;
+ }
+
+ @GuardedBy("mBlobsLock")
+ private LongSparseArray<BlobStoreSession> getUserSessionsLocked(int userId) {
+ LongSparseArray<BlobStoreSession> userSessions = mSessions.get(userId);
+ if (userSessions == null) {
+ userSessions = new LongSparseArray<>();
+ mSessions.put(userId, userSessions);
+ }
+ return userSessions;
+ }
+
+ @GuardedBy("mBlobsLock")
+ private ArrayMap<BlobHandle, BlobMetadata> getUserBlobsLocked(int userId) {
+ ArrayMap<BlobHandle, BlobMetadata> userBlobs = mBlobsMap.get(userId);
+ if (userBlobs == null) {
+ userBlobs = new ArrayMap<>();
+ mBlobsMap.put(userId, userBlobs);
+ }
+ return userBlobs;
+ }
+
+ private long createSessionInternal(BlobHandle blobHandle,
+ int callingUid, String callingPackage) {
+ synchronized (mBlobsLock) {
+ // TODO: throw if there is already an active session associated with blobHandle.
+ final long sessionId = generateNextSessionIdLocked();
+ final BlobStoreSession session = new BlobStoreSession(mContext,
+ sessionId, blobHandle, callingUid, callingPackage,
+ mSessionStateChangeListener);
+ getUserSessionsLocked(UserHandle.getUserId(callingUid)).put(sessionId, session);
+ // TODO: persist sessions data
+ return sessionId;
+ }
+ }
+
+ private BlobStoreSession openSessionInternal(long sessionId,
+ int callingUid, String callingPackage) {
+ final BlobStoreSession session;
+ synchronized (mBlobsLock) {
+ session = getUserSessionsLocked(
+ UserHandle.getUserId(callingUid)).get(sessionId);
+ if (session == null || !session.hasAccess(callingUid, callingPackage)
+ || session.isFinalized()) {
+ throw new SecurityException("Session not found: " + sessionId);
+ }
+ }
+ session.open();
+ return session;
+ }
+
+ private void deleteSessionInternal(long sessionId,
+ int callingUid, String callingPackage) {
+ synchronized (mBlobsLock) {
+ final BlobStoreSession session = openSessionInternal(sessionId,
+ callingUid, callingPackage);
+ session.open();
+ session.abandon();
+ // TODO: persist sessions data
+ }
+ }
+
+ private ParcelFileDescriptor openBlobInternal(BlobHandle blobHandle, int callingUid,
+ String callingPackage) throws IOException {
+ synchronized (mBlobsLock) {
+ final BlobMetadata blobMetadata = getUserBlobsLocked(UserHandle.getUserId(callingUid))
+ .get(blobHandle);
+ if (blobMetadata == null || !blobMetadata.isAccessAllowedForCaller(
+ callingPackage, callingUid)) {
+ throw new SecurityException("Caller not allowed to access " + blobHandle
+ + "; callingUid=" + callingUid + ", callingPackage=" + callingPackage);
+ }
+ return blobMetadata.openForRead(callingPackage);
+ }
+ }
+
+ private void acquireLeaseInternal(BlobHandle blobHandle, int descriptionResId,
+ long leaseExpiryTimeMillis, int callingUid, String callingPackage) {
+ synchronized (mBlobsLock) {
+ final BlobMetadata blobMetadata = getUserBlobsLocked(UserHandle.getUserId(callingUid))
+ .get(blobHandle);
+ if (blobMetadata == null || !blobMetadata.isAccessAllowedForCaller(
+ callingPackage, callingUid)) {
+ throw new SecurityException("Caller not allowed to access " + blobHandle
+ + "; callingUid=" + callingUid + ", callingPackage=" + callingPackage);
+ }
+ if (leaseExpiryTimeMillis != 0 && leaseExpiryTimeMillis > blobHandle.expiryTimeMillis) {
+ throw new IllegalArgumentException(
+ "Lease expiry cannot be later than blobs expiry time");
+ }
+ blobMetadata.addLeasee(callingPackage, callingUid,
+ descriptionResId, leaseExpiryTimeMillis);
+ // TODO: persist blobs data
+ }
+ }
+
+ private void releaseLeaseInternal(BlobHandle blobHandle, int callingUid,
+ String callingPackage) {
+ synchronized (mBlobsLock) {
+ final BlobMetadata blobMetadata = getUserBlobsLocked(UserHandle.getUserId(callingUid))
+ .get(blobHandle);
+ if (blobMetadata == null || !blobMetadata.isAccessAllowedForCaller(
+ callingPackage, callingUid)) {
+ throw new SecurityException("Caller not allowed to access " + blobHandle
+ + "; callingUid=" + callingUid + ", callingPackage=" + callingPackage);
+ }
+ blobMetadata.removeLeasee(callingPackage, callingUid);
+ }
+ }
+
+ private void verifyCallingPackage(int callingUid, String callingPackage) {
+ if (mPackageManagerInternal.getPackageUid(
+ callingPackage, 0, UserHandle.getUserId(callingUid)) != callingUid) {
+ throw new SecurityException("Specified calling package [" + callingPackage
+ + "] does not match the calling uid " + callingUid);
+ }
+ }
+
+ class SessionStateChangeListener {
+ public void onStateChanged(@NonNull BlobStoreSession session) {
+ mHandler.post(PooledLambda.obtainRunnable(
+ BlobStoreManagerService::onStateChangedInternal,
+ BlobStoreManagerService.this, session));
+ }
+ }
+
+ private void onStateChangedInternal(@NonNull BlobStoreSession session) {
+ synchronized (mBlobsLock) {
+ switch (session.getState()) {
+ case STATE_ABANDONED:
+ case STATE_VERIFIED_INVALID:
+ session.getSessionFile().delete();
+ getUserSessionsLocked(UserHandle.getUserId(session.ownerUid))
+ .remove(session.sessionId);
+ break;
+ case STATE_COMMITTED:
+ session.verifyBlobData();
+ break;
+ case STATE_VERIFIED_VALID:
+ final ArrayMap<BlobHandle, BlobMetadata> userBlobs =
+ getUserBlobsLocked(UserHandle.getUserId(session.ownerUid));
+ BlobMetadata blob = userBlobs.get(session.blobHandle);
+ if (blob == null) {
+ blob = new BlobMetadata(mContext,
+ session.sessionId, session.blobHandle);
+ userBlobs.put(session.blobHandle, blob);
+ }
+ blob.addCommitter(session.ownerPackageName, session.ownerUid,
+ session.getBlobAccessMode());
+ // TODO: Persist blobs data.
+ session.sendCommitCallbackResult(COMMIT_RESULT_SUCCESS);
+ getUserSessionsLocked(UserHandle.getUserId(session.ownerUid))
+ .remove(session.sessionId);
+ break;
+ default:
+ Slog.wtf(TAG, "Invalid session state: "
+ + stateToString(session.getState()));
+ }
+ // TODO: Persist sessions data.
+ }
}
private class Stub extends IBlobStoreManager.Stub {
@Override
- public long createSession(@NonNull BlobHandle blobHandle, @NonNull String packageName) {
- return 0;
+ @IntRange(from = 1)
+ public long createSession(@NonNull BlobHandle blobHandle,
+ @NonNull String packageName) {
+ Preconditions.checkNotNull(blobHandle, "blobHandle must not be null");
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+ // TODO: verify blobHandle.algorithm is sha-256
+ // TODO: assert blobHandle is valid.
+
+ final int callingUid = Binder.getCallingUid();
+ verifyCallingPackage(callingUid, packageName);
+
+ if (Process.isIsolated(callingUid) || mPackageManagerInternal.isInstantApp(
+ packageName, UserHandle.getUserId(callingUid))) {
+ throw new SecurityException("Caller not allowed to create session; "
+ + "callingUid=" + callingUid + ", callingPackage=" + packageName);
+ }
+
+ // TODO: Verify caller request is within limits (no. of calls/blob sessions/blobs)
+ return createSessionInternal(blobHandle, callingUid, packageName);
}
@Override
- public IBlobStoreSession openSession(long sessionId) {
- return null;
+ @NonNull
+ public IBlobStoreSession openSession(@IntRange(from = 1) long sessionId,
+ @NonNull String packageName) {
+ Preconditions.checkArgumentPositive(sessionId,
+ "sessionId must be positive: " + sessionId);
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+
+ final int callingUid = Binder.getCallingUid();
+ verifyCallingPackage(callingUid, packageName);
+
+ return openSessionInternal(sessionId, callingUid, packageName);
+ }
+
+ @Override
+ public void deleteSession(@IntRange(from = 1) long sessionId,
+ @NonNull String packageName) {
+ Preconditions.checkArgumentPositive(sessionId,
+ "sessionId must be positive: " + sessionId);
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+
+ final int callingUid = Binder.getCallingUid();
+ verifyCallingPackage(callingUid, packageName);
+
+ deleteSessionInternal(sessionId, callingUid, packageName);
}
@Override
public ParcelFileDescriptor openBlob(@NonNull BlobHandle blobHandle,
@NonNull String packageName) {
- return null;
+ Preconditions.checkNotNull(blobHandle, "blobHandle must not be null");
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+
+ final int callingUid = Binder.getCallingUid();
+ verifyCallingPackage(callingUid, packageName);
+
+ if (Process.isIsolated(callingUid) || mPackageManagerInternal.isInstantApp(
+ packageName, UserHandle.getUserId(callingUid))) {
+ throw new SecurityException("Caller not allowed to open blob; "
+ + "callingUid=" + callingUid + ", callingPackage=" + packageName);
+ }
+
+ try {
+ return openBlobInternal(blobHandle, callingUid, packageName);
+ } catch (IOException e) {
+ throw ExceptionUtils.wrap(e);
+ }
}
@Override
public void acquireLease(@NonNull BlobHandle blobHandle, @IdRes int descriptionResId,
- @CurrentTimeSecondsLong long leaseTimeout, @NonNull String packageName) {
+ @CurrentTimeSecondsLong long leaseTimeoutSecs, @NonNull String packageName) {
+ Preconditions.checkNotNull(blobHandle, "blobHandle must not be null");
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+
+ final int callingUid = Binder.getCallingUid();
+ verifyCallingPackage(callingUid, packageName);
+
+ acquireLeaseInternal(blobHandle, descriptionResId, leaseTimeoutSecs,
+ callingUid, packageName);
}
@Override
public void releaseLease(@NonNull BlobHandle blobHandle, @NonNull String packageName) {
+ Preconditions.checkNotNull(blobHandle, "blobHandle must not be null");
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+
+
+ final int callingUid = Binder.getCallingUid();
+ verifyCallingPackage(callingUid, packageName);
+
+ releaseLeaseInternal(blobHandle, callingUid, packageName);
}
}
}
diff --git a/apex/blobstore/service/java/com/android/server/blob/BlobStoreSession.java b/apex/blobstore/service/java/com/android/server/blob/BlobStoreSession.java
index 2c38e76..29092b3 100644
--- a/apex/blobstore/service/java/com/android/server/blob/BlobStoreSession.java
+++ b/apex/blobstore/service/java/com/android/server/blob/BlobStoreSession.java
@@ -15,20 +15,175 @@
*/
package com.android.server.blob;
+import static android.app.blob.BlobStoreManager.COMMIT_RESULT_ERROR;
+import static android.system.OsConstants.O_CREAT;
+import static android.system.OsConstants.O_RDWR;
+import static android.system.OsConstants.SEEK_SET;
+
+import static com.android.server.blob.BlobStoreConfig.TAG;
+
import android.annotation.BytesLong;
import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.app.blob.BlobHandle;
import android.app.blob.IBlobCommitCallback;
import android.app.blob.IBlobStoreSession;
+import android.content.Context;
+import android.os.Binder;
+import android.os.FileUtils;
import android.os.ParcelFileDescriptor;
+import android.os.RemoteException;
+import android.os.RevocableFileDescriptor;
+import android.os.storage.StorageManager;
+import android.system.ErrnoException;
+import android.system.Os;
+import android.util.ExceptionUtils;
+import android.util.Slog;
+
+import com.android.internal.annotations.GuardedBy;
+import com.android.internal.util.Preconditions;
+import com.android.server.blob.BlobStoreManagerService.SessionStateChangeListener;
+
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Arrays;
/** TODO: add doc */
public class BlobStoreSession extends IBlobStoreSession.Stub {
+ static final int STATE_OPENED = 1;
+ static final int STATE_CLOSED = 0;
+ static final int STATE_ABANDONED = 2;
+ static final int STATE_COMMITTED = 3;
+ static final int STATE_VERIFIED_VALID = 4;
+ static final int STATE_VERIFIED_INVALID = 5;
+
+ private final Object mSessionLock = new Object();
+
+ private final Context mContext;
+ private final SessionStateChangeListener mListener;
+
+ public final BlobHandle blobHandle;
+ public final long sessionId;
+ public final int ownerUid;
+ public final String ownerPackageName;
+
+ // Do not access this directly, instead use getSessionFile().
+ private File mSessionFile;
+
+ @GuardedBy("mRevocableFds")
+ private ArrayList<RevocableFileDescriptor> mRevocableFds = new ArrayList<>();
+
+ @GuardedBy("mSessionLock")
+ private int mState = STATE_CLOSED;
+
+ @GuardedBy("mSessionLock")
+ private final BlobAccessMode mBlobAccessMode = new BlobAccessMode();
+
+ @GuardedBy("mSessionLock")
+ private IBlobCommitCallback mBlobCommitCallback;
+
+ BlobStoreSession(Context context, long sessionId, BlobHandle blobHandle,
+ int ownerUid, String ownerPackageName, SessionStateChangeListener listener) {
+ this.mContext = context;
+ this.blobHandle = blobHandle;
+ this.sessionId = sessionId;
+ this.ownerUid = ownerUid;
+ this.ownerPackageName = ownerPackageName;
+ this.mListener = listener;
+ }
+
+ boolean hasAccess(int callingUid, String callingPackageName) {
+ return ownerUid == callingUid && ownerPackageName.equals(callingPackageName);
+ }
+
+ void open() {
+ synchronized (mSessionLock) {
+ if (isFinalized()) {
+ throw new IllegalStateException("Not allowed to open session with state: "
+ + stateToString(mState));
+ }
+ mState = STATE_OPENED;
+ }
+ }
+
+ int getState() {
+ synchronized (mSessionLock) {
+ return mState;
+ }
+ }
+
+ void sendCommitCallbackResult(int result) {
+ synchronized (mSessionLock) {
+ try {
+ mBlobCommitCallback.onResult(result);
+ } catch (RemoteException e) {
+ Slog.d(TAG, "Error sending the callback result", e);
+ }
+ mBlobCommitCallback = null;
+ }
+ }
+
+ BlobAccessMode getBlobAccessMode() {
+ synchronized (mSessionLock) {
+ return mBlobAccessMode;
+ }
+ }
+
+ boolean isFinalized() {
+ synchronized (mSessionLock) {
+ return mState == STATE_COMMITTED || mState == STATE_ABANDONED;
+ }
+ }
+
@Override
@NonNull
public ParcelFileDescriptor openWrite(@BytesLong long offsetBytes,
@BytesLong long lengthBytes) {
- return null;
+ assertCallerIsOwner();
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ throw new IllegalStateException("Not allowed to write in state: "
+ + stateToString(mState));
+ }
+
+ try {
+ return openWriteLocked(offsetBytes, lengthBytes);
+ } catch (IOException e) {
+ throw ExceptionUtils.wrap(e);
+ }
+ }
+ }
+
+ @GuardedBy("mSessionLock")
+ @NonNull
+ private ParcelFileDescriptor openWriteLocked(@BytesLong long offsetBytes,
+ @BytesLong long lengthBytes) throws IOException {
+ // TODO: Add limit on active open sessions/writes/reads
+ FileDescriptor fd = null;
+ try {
+ final File sessionFile = getSessionFile();
+ if (sessionFile == null) {
+ throw new IllegalStateException("Couldn't get the file for this session");
+ }
+ fd = Os.open(sessionFile.getPath(), O_CREAT | O_RDWR, 0600);
+ if (offsetBytes > 0) {
+ final long curOffset = Os.lseek(fd, offsetBytes, SEEK_SET);
+ if (curOffset != offsetBytes) {
+ throw new IllegalStateException("Failed to seek " + offsetBytes
+ + "; curOffset=" + offsetBytes);
+ }
+ }
+ if (lengthBytes > 0) {
+ mContext.getSystemService(StorageManager.class).allocateBytes(fd, lengthBytes);
+ }
+ } catch (ErrnoException e) {
+ e.rethrowAsIOException();
+ }
+ return createRevocableFdLocked(fd);
}
@Override
@@ -40,25 +195,192 @@
@Override
public void allowPackageAccess(@NonNull String packageName,
@NonNull byte[] certificate) {
+ assertCallerIsOwner();
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ throw new IllegalStateException("Not allowed to change access type in state: "
+ + stateToString(mState));
+ }
+ mBlobAccessMode.allowPackageAccess(packageName, certificate);
+ }
}
@Override
public void allowSameSignatureAccess() {
+ assertCallerIsOwner();
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ throw new IllegalStateException("Not allowed to change access type in state: "
+ + stateToString(mState));
+ }
+ mBlobAccessMode.allowSameSignatureAccess();
+ }
}
@Override
public void allowPublicAccess() {
+ assertCallerIsOwner();
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ throw new IllegalStateException("Not allowed to change access type in state: "
+ + stateToString(mState));
+ }
+ mBlobAccessMode.allowPublicAccess();
+ }
+ }
+
+ @Override
+ public boolean isPackageAccessAllowed(@NonNull String packageName,
+ @NonNull byte[] certificate) {
+ assertCallerIsOwner();
+ Preconditions.checkNotNull(packageName, "packageName must not be null");
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ throw new IllegalStateException("Not allowed to get access type in state: "
+ + stateToString(mState));
+ }
+ return mBlobAccessMode.isPackageAccessAllowed(packageName, certificate);
+ }
+ }
+
+ @Override
+ public boolean isSameSignatureAccessAllowed() {
+ assertCallerIsOwner();
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ throw new IllegalStateException("Not allowed to get access type in state: "
+ + stateToString(mState));
+ }
+ return mBlobAccessMode.isSameSignatureAccessAllowed();
+ }
+ }
+
+ @Override
+ public boolean isPublicAccessAllowed() {
+ assertCallerIsOwner();
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ throw new IllegalStateException("Not allowed to get access type in state: "
+ + stateToString(mState));
+ }
+ return mBlobAccessMode.isPublicAccessAllowed();
+ }
}
@Override
public void close() {
+ closeSession(STATE_CLOSED);
}
@Override
public void abandon() {
+ closeSession(STATE_ABANDONED);
}
@Override
public void commit(IBlobCommitCallback callback) {
+ synchronized (mSessionLock) {
+ mBlobCommitCallback = callback;
+
+ closeSession(STATE_COMMITTED);
+ }
+ }
+
+ private void closeSession(int state) {
+ assertCallerIsOwner();
+ synchronized (mSessionLock) {
+ if (mState != STATE_OPENED) {
+ if (state == STATE_CLOSED) {
+ // Just trying to close the session which is already deleted or abandoned,
+ // ignore.
+ return;
+ } else {
+ throw new IllegalStateException("Not allowed to delete or abandon a session"
+ + " with state: " + stateToString(mState));
+ }
+ }
+
+ mState = state;
+ revokeAllFdsLocked();
+
+ mListener.onStateChanged(this);
+ }
+ }
+
+ void verifyBlobData() {
+ byte[] actualDigest = null;
+ try {
+ actualDigest = FileUtils.digest(getSessionFile(), blobHandle.algorithm);
+ } catch (IOException | NoSuchAlgorithmException e) {
+ Slog.e(TAG, "Error computing the digest", e);
+ }
+ synchronized (mSessionLock) {
+ if (actualDigest != null && Arrays.equals(actualDigest, blobHandle.digest)) {
+ mState = STATE_VERIFIED_VALID;
+ // Commit callback will be sent once the data is persisted.
+ } else {
+ mState = STATE_VERIFIED_INVALID;
+ sendCommitCallbackResult(COMMIT_RESULT_ERROR);
+ }
+ mListener.onStateChanged(this);
+ }
+ }
+
+ @GuardedBy("mSessionLock")
+ private void revokeAllFdsLocked() {
+ for (int i = mRevocableFds.size() - 1; i >= 0; --i) {
+ mRevocableFds.get(i).revoke();
+ mRevocableFds.remove(i);
+ }
+ }
+
+ @GuardedBy("mSessionLock")
+ @NonNull
+ private ParcelFileDescriptor createRevocableFdLocked(FileDescriptor fd)
+ throws IOException {
+ final RevocableFileDescriptor revocableFd =
+ new RevocableFileDescriptor(mContext, fd);
+ synchronized (mRevocableFds) {
+ mRevocableFds.add(revocableFd);
+ }
+ revocableFd.addOnCloseListener((e) -> {
+ synchronized (mRevocableFds) {
+ mRevocableFds.remove(revocableFd);
+ }
+ });
+ return revocableFd.getRevocableFileDescriptor();
+ }
+
+ @Nullable
+ File getSessionFile() {
+ if (mSessionFile == null) {
+ mSessionFile = BlobStoreConfig.prepareBlobFile(sessionId);
+ }
+ return mSessionFile;
+ }
+
+ @NonNull
+ static String stateToString(int state) {
+ switch (state) {
+ case STATE_OPENED:
+ return "<opened>";
+ case STATE_CLOSED:
+ return "<closed>";
+ case STATE_ABANDONED:
+ return "<abandoned>";
+ case STATE_COMMITTED:
+ return "<committed>";
+ default:
+ Slog.wtf(TAG, "Unknown state: " + state);
+ return "<unknown>";
+ }
+ }
+
+ private void assertCallerIsOwner() {
+ final int callingUid = Binder.getCallingUid();
+ if (callingUid != ownerUid) {
+ throw new SecurityException(ownerUid + " is not the session owner");
+ }
}
}
diff --git a/apex/statsd/service/java/com/android/server/stats/StatsCompanionService.java b/apex/statsd/service/java/com/android/server/stats/StatsCompanionService.java
index e5d1182..018037c 100644
--- a/apex/statsd/service/java/com/android/server/stats/StatsCompanionService.java
+++ b/apex/statsd/service/java/com/android/server/stats/StatsCompanionService.java
@@ -714,98 +714,6 @@
}
}
- // read high watermark for section
- private long readProcStatsHighWaterMark(int section) {
- try {
- File[] files = mBaseDir.listFiles((d, name) -> {
- return name.toLowerCase().startsWith(String.valueOf(section) + '_');
- });
- if (files == null || files.length == 0) {
- return 0;
- }
- if (files.length > 1) {
- Log.e(TAG, "Only 1 file expected for high water mark. Found " + files.length);
- }
- return Long.valueOf(files[0].getName().split("_")[1]);
- } catch (SecurityException e) {
- Log.e(TAG, "Failed to get procstats high watermark file.", e);
- } catch (NumberFormatException e) {
- Log.e(TAG, "Failed to parse file name.", e);
- }
- return 0;
- }
-
- private IProcessStats mProcessStats =
- IProcessStats.Stub.asInterface(ServiceManager.getService(ProcessStats.SERVICE_NAME));
-
- private void pullProcessStats(int section, int tagId, long elapsedNanos, long wallClockNanos,
- List<StatsLogEventWrapper> pulledData) {
- synchronized (this) {
- try {
- long lastHighWaterMark = readProcStatsHighWaterMark(section);
- List<ParcelFileDescriptor> statsFiles = new ArrayList<>();
- long highWaterMark = mProcessStats.getCommittedStats(
- lastHighWaterMark, section, true, statsFiles);
- if (statsFiles.size() != 1) {
- return;
- }
- unpackStreamedData(tagId, elapsedNanos, wallClockNanos, pulledData, statsFiles);
- new File(mBaseDir.getAbsolutePath() + "/" + section + "_"
- + lastHighWaterMark).delete();
- new File(
- mBaseDir.getAbsolutePath() + "/" + section + "_"
- + highWaterMark).createNewFile();
- } catch (IOException e) {
- Log.e(TAG, "Getting procstats failed: ", e);
- } catch (RemoteException e) {
- Log.e(TAG, "Getting procstats failed: ", e);
- } catch (SecurityException e) {
- Log.e(TAG, "Getting procstats failed: ", e);
- }
- }
- }
-
- static void unpackStreamedData(int tagId, long elapsedNanos, long wallClockNanos,
- List<StatsLogEventWrapper> pulledData, List<ParcelFileDescriptor> statsFiles)
- throws IOException {
- InputStream stream = new ParcelFileDescriptor.AutoCloseInputStream(
- statsFiles.get(0));
- int[] len = new int[1];
- byte[] stats = readFully(stream, len);
- StatsLogEventWrapper e = new StatsLogEventWrapper(tagId, elapsedNanos,
- wallClockNanos);
- e.writeStorage(Arrays.copyOf(stats, len[0]));
- pulledData.add(e);
- }
-
- static byte[] readFully(InputStream stream, int[] outLen) throws IOException {
- int pos = 0;
- final int initialAvail = stream.available();
- byte[] data = new byte[initialAvail > 0 ? (initialAvail + 1) : 16384];
- while (true) {
- int amt = stream.read(data, pos, data.length - pos);
- if (DEBUG) {
- Slog.i(TAG, "Read " + amt + " bytes at " + pos + " of avail " + data.length);
- }
- if (amt < 0) {
- if (DEBUG) {
- Slog.i(TAG, "**** FINISHED READING: pos=" + pos + " len=" + data.length);
- }
- outLen[0] = pos;
- return data;
- }
- pos += amt;
- if (pos >= data.length) {
- byte[] newData = new byte[pos + 16384];
- if (DEBUG) {
- Slog.i(TAG, "Copying " + pos + " bytes to new array len " + newData.length);
- }
- System.arraycopy(data, 0, newData, 0, pos);
- data = newData;
- }
- }
- }
-
private void pullDebugElapsedClock(int tagId,
long elapsedNanos, final long wallClockNanos, List<StatsLogEventWrapper> pulledData) {
final long elapsedMillis = SystemClock.elapsedRealtime();
@@ -856,43 +764,6 @@
pulledData.add(e);
}
- private void pullFaceSettings(int tagId, long elapsedNanos, long wallClockNanos,
- List<StatsLogEventWrapper> pulledData) {
- long callingToken = Binder.clearCallingIdentity();
- try {
- List<UserInfo> users = mContext.getSystemService(UserManager.class).getUsers();
- int numUsers = users.size();
- for (int userNum = 0; userNum < numUsers; userNum++) {
- int userId = users.get(userNum).getUserHandle().getIdentifier();
-
- StatsLogEventWrapper e =
- new StatsLogEventWrapper(tagId, elapsedNanos, wallClockNanos);
- e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
- Settings.Secure.FACE_UNLOCK_KEYGUARD_ENABLED, 1,
- userId) != 0);
- e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
- Settings.Secure.FACE_UNLOCK_DISMISSES_KEYGUARD,
- 0, userId) != 0);
- e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
- Settings.Secure.FACE_UNLOCK_ATTENTION_REQUIRED, 1,
- userId) != 0);
- e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
- Settings.Secure.FACE_UNLOCK_APP_ENABLED, 1,
- userId) != 0);
- e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
- Settings.Secure.FACE_UNLOCK_ALWAYS_REQUIRE_CONFIRMATION, 0,
- userId) != 0);
- e.writeBoolean(Settings.Secure.getIntForUser(mContext.getContentResolver(),
- Settings.Secure.FACE_UNLOCK_DIVERSITY_REQUIRED, 1,
- userId) != 0);
-
- pulledData.add(e);
- }
- } finally {
- Binder.restoreCallingIdentity(callingToken);
- }
- }
-
/**
* Pulls various data.
*/
@@ -907,17 +778,6 @@
long wallClockNanos = SystemClock.currentTimeMicro() * 1000L;
switch (tagId) {
- case StatsLog.PROC_STATS: {
- pullProcessStats(ProcessStats.REPORT_ALL, tagId, elapsedNanos, wallClockNanos, ret);
- break;
- }
-
- case StatsLog.PROC_STATS_PKG_PROC: {
- pullProcessStats(ProcessStats.REPORT_PKG_PROC_STATS, tagId, elapsedNanos,
- wallClockNanos, ret);
- break;
- }
-
case StatsLog.DEBUG_ELAPSED_CLOCK: {
pullDebugElapsedClock(tagId, elapsedNanos, wallClockNanos, ret);
break;
@@ -928,11 +788,6 @@
break;
}
- case StatsLog.FACE_SETTINGS: {
- pullFaceSettings(tagId, elapsedNanos, wallClockNanos, ret);
- break;
- }
-
default:
Slog.w(TAG, "No such tagId data as " + tagId);
return null;
diff --git a/api/current.txt b/api/current.txt
index 1c03c23..e0183a0 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -5608,11 +5608,14 @@
public static final class Notification.BubbleMetadata implements android.os.Parcelable {
method public int describeContents();
method public boolean getAutoExpandBubble();
+ method @Nullable public android.graphics.drawable.Icon getBubbleIcon();
+ method @Nullable public android.app.PendingIntent getBubbleIntent();
method @Nullable public android.app.PendingIntent getDeleteIntent();
method @Dimension(unit=android.annotation.Dimension.DP) public int getDesiredHeight();
method @DimenRes public int getDesiredHeightResId();
- method @NonNull public android.graphics.drawable.Icon getIcon();
- method @NonNull public android.app.PendingIntent getIntent();
+ method @Deprecated @NonNull public android.graphics.drawable.Icon getIcon();
+ method @Deprecated @NonNull public android.app.PendingIntent getIntent();
+ method @Nullable public String getShortcutId();
method public boolean isNotificationSuppressed();
method public void writeToParcel(android.os.Parcel, int);
field @NonNull public static final android.os.Parcelable.Creator<android.app.Notification.BubbleMetadata> CREATOR;
@@ -5621,12 +5624,14 @@
public static final class Notification.BubbleMetadata.Builder {
ctor public Notification.BubbleMetadata.Builder();
method @NonNull public android.app.Notification.BubbleMetadata build();
+ method @NonNull public android.app.Notification.BubbleMetadata.Builder createIntentBubble(@NonNull android.app.PendingIntent, @NonNull android.graphics.drawable.Icon);
+ method @NonNull public android.app.Notification.BubbleMetadata.Builder createShortcutBubble(@NonNull String);
method @NonNull public android.app.Notification.BubbleMetadata.Builder setAutoExpandBubble(boolean);
method @NonNull public android.app.Notification.BubbleMetadata.Builder setDeleteIntent(@Nullable android.app.PendingIntent);
method @NonNull public android.app.Notification.BubbleMetadata.Builder setDesiredHeight(@Dimension(unit=android.annotation.Dimension.DP) int);
method @NonNull public android.app.Notification.BubbleMetadata.Builder setDesiredHeightResId(@DimenRes int);
- method @NonNull public android.app.Notification.BubbleMetadata.Builder setIcon(@NonNull android.graphics.drawable.Icon);
- method @NonNull public android.app.Notification.BubbleMetadata.Builder setIntent(@NonNull android.app.PendingIntent);
+ method @Deprecated @NonNull public android.app.Notification.BubbleMetadata.Builder setIcon(@NonNull android.graphics.drawable.Icon);
+ method @Deprecated @NonNull public android.app.Notification.BubbleMetadata.Builder setIntent(@NonNull android.app.PendingIntent);
method @NonNull public android.app.Notification.BubbleMetadata.Builder setSuppressNotification(boolean);
}
@@ -6470,7 +6475,11 @@
method public void disableCarMode(int);
method public void enableCarMode(int);
method public int getCurrentModeType();
+ method @NonNull public java.time.LocalTime getCustomNightModeEnd();
+ method @NonNull public java.time.LocalTime getCustomNightModeStart();
method public int getNightMode();
+ method public void setCustomNightModeEnd(@NonNull java.time.LocalTime);
+ method public void setCustomNightModeStart(@NonNull java.time.LocalTime);
method public void setNightMode(int);
field public static String ACTION_ENTER_CAR_MODE;
field public static String ACTION_ENTER_DESK_MODE;
@@ -6480,6 +6489,7 @@
field public static final int ENABLE_CAR_MODE_ALLOW_SLEEP = 2; // 0x2
field public static final int ENABLE_CAR_MODE_GO_CAR_HOME = 1; // 0x1
field public static final int MODE_NIGHT_AUTO = 0; // 0x0
+ field public static final int MODE_NIGHT_CUSTOM = 3; // 0x3
field public static final int MODE_NIGHT_NO = 1; // 0x1
field public static final int MODE_NIGHT_YES = 2; // 0x2
}
@@ -7501,6 +7511,7 @@
method public void acquireLease(@NonNull android.app.blob.BlobHandle, @IdRes int, long) throws java.io.IOException;
method public void acquireLease(@NonNull android.app.blob.BlobHandle, @IdRes int) throws java.io.IOException;
method @IntRange(from=1) public long createSession(@NonNull android.app.blob.BlobHandle) throws java.io.IOException;
+ method public void deleteSession(@IntRange(from=1) long) throws java.io.IOException;
method @NonNull public android.os.ParcelFileDescriptor openBlob(@NonNull android.app.blob.BlobHandle) throws java.io.IOException;
method @NonNull public android.app.blob.BlobStoreManager.Session openSession(@IntRange(from=1) long) throws java.io.IOException;
method public void releaseLease(@NonNull android.app.blob.BlobHandle) throws java.io.IOException;
@@ -7514,6 +7525,9 @@
method public void close() throws java.io.IOException;
method public void commit(@NonNull java.util.concurrent.Executor, @NonNull java.util.function.Consumer<java.lang.Integer>) throws java.io.IOException;
method public long getSize() throws java.io.IOException;
+ method public boolean isPackageAccessAllowed(@NonNull String, @NonNull byte[]) throws java.io.IOException;
+ method public boolean isPublicAccessAllowed() throws java.io.IOException;
+ method public boolean isSameSignatureAccessAllowed() throws java.io.IOException;
method @NonNull public android.os.ParcelFileDescriptor openWrite(long, long) throws java.io.IOException;
}
@@ -12034,7 +12048,6 @@
field public static final String FEATURE_STRONGBOX_KEYSTORE = "android.hardware.strongbox_keystore";
field public static final String FEATURE_TELEPHONY = "android.hardware.telephony";
field public static final String FEATURE_TELEPHONY_CDMA = "android.hardware.telephony.cdma";
- field public static final String FEATURE_TELEPHONY_DATA = "android.hardware.telephony.data";
field public static final String FEATURE_TELEPHONY_EUICC = "android.hardware.telephony.euicc";
field public static final String FEATURE_TELEPHONY_GSM = "android.hardware.telephony.gsm";
field public static final String FEATURE_TELEPHONY_IMS = "android.hardware.telephony.ims";
@@ -30730,9 +30743,19 @@
method @Deprecated @NonNull public android.net.MacAddress getRandomizedMacAddress();
method @Deprecated public boolean isPasspoint();
method @Deprecated public void setHttpProxy(android.net.ProxyInfo);
+ method @Deprecated public void setSecurityParams(int);
method public void writeToParcel(android.os.Parcel, int);
field @Deprecated public String BSSID;
field @Deprecated public String FQDN;
+ field @Deprecated public static final int SECURITY_TYPE_EAP = 3; // 0x3
+ field @Deprecated public static final int SECURITY_TYPE_EAP_SUITE_B = 5; // 0x5
+ field @Deprecated public static final int SECURITY_TYPE_OPEN = 0; // 0x0
+ field @Deprecated public static final int SECURITY_TYPE_OWE = 6; // 0x6
+ field @Deprecated public static final int SECURITY_TYPE_PSK = 2; // 0x2
+ field @Deprecated public static final int SECURITY_TYPE_SAE = 4; // 0x4
+ field @Deprecated public static final int SECURITY_TYPE_WAPI_CERT = 8; // 0x8
+ field @Deprecated public static final int SECURITY_TYPE_WAPI_PSK = 7; // 0x7
+ field @Deprecated public static final int SECURITY_TYPE_WEP = 1; // 0x1
field @Deprecated public String SSID;
field @Deprecated @NonNull public java.util.BitSet allowedAuthAlgorithms;
field @Deprecated @NonNull public java.util.BitSet allowedGroupCiphers;
@@ -30996,6 +31019,7 @@
field public static final String SCAN_RESULTS_AVAILABLE_ACTION = "android.net.wifi.SCAN_RESULTS";
field public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_DUPLICATE = 3; // 0x3
field public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_EXCEEDS_MAX_PER_APP = 4; // 0x4
+ field public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_INVALID = 7; // 0x7
field public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_NOT_ALLOWED = 6; // 0x6
field public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_APP_DISALLOWED = 2; // 0x2
field public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_INTERNAL = 1; // 0x1
@@ -50565,6 +50589,7 @@
method public static java.util.TimeZone getTimeZone(int, boolean, long, String);
method public static String getTimeZoneDatabaseVersion();
method @Nullable public static java.util.List<java.lang.String> getTimeZoneIdsForCountryCode(@NonNull String);
+ method public static boolean isTimeBetween(@NonNull java.time.LocalTime, @NonNull java.time.LocalTime, @NonNull java.time.LocalTime);
}
@Deprecated public class TimingLogger {
diff --git a/api/system-current.txt b/api/system-current.txt
index e5cc384..66b779d 100755
--- a/api/system-current.txt
+++ b/api/system-current.txt
@@ -96,6 +96,7 @@
field public static final String INTERNAL_SYSTEM_WINDOW = "android.permission.INTERNAL_SYSTEM_WINDOW";
field public static final String INVOKE_CARRIER_SETUP = "android.permission.INVOKE_CARRIER_SETUP";
field public static final String KILL_UID = "android.permission.KILL_UID";
+ field public static final String LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH = "android.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH";
field public static final String LOCAL_MAC_ADDRESS = "android.permission.LOCAL_MAC_ADDRESS";
field public static final String LOCK_DEVICE = "android.permission.LOCK_DEVICE";
field public static final String LOOP_RADIO = "android.permission.LOOP_RADIO";
@@ -331,10 +332,12 @@
method @RequiresPermission(anyOf={android.Manifest.permission.MANAGE_USERS, android.Manifest.permission.CREATE_USERS}) public boolean isProfileForeground(@NonNull android.os.UserHandle);
method @RequiresPermission(android.Manifest.permission.FORCE_STOP_PACKAGES) public void killProcessesWhenImperceptible(@NonNull int[], @NonNull String);
method @RequiresPermission(android.Manifest.permission.KILL_UID) public void killUid(int, String);
+ method public void registerHomeVisibilityObserver(@NonNull android.app.HomeVisibilityObserver);
method @RequiresPermission(android.Manifest.permission.PACKAGE_USAGE_STATS) public void removeOnUidImportanceListener(android.app.ActivityManager.OnUidImportanceListener);
method public void setDeviceLocales(@NonNull android.os.LocaleList);
method @RequiresPermission(android.Manifest.permission.RESTRICTED_VR_ACCESS) public static void setPersistentVrThread(int);
method @RequiresPermission(android.Manifest.permission.MANAGE_USERS) public boolean switchUser(@NonNull android.os.UserHandle);
+ method public void unregisterHomeVisibilityObserver(@NonNull android.app.HomeVisibilityObserver);
method @RequiresPermission(android.Manifest.permission.CHANGE_CONFIGURATION) public boolean updateMccMncConfiguration(@NonNull String, @NonNull String);
}
@@ -587,6 +590,11 @@
field public static final String ACTION_DOWNLOAD_COMPLETED = "android.intent.action.DOWNLOAD_COMPLETED";
}
+ public abstract class HomeVisibilityObserver {
+ ctor public HomeVisibilityObserver();
+ method public abstract void onHomeVisibilityChanged(boolean);
+ }
+
public abstract class InstantAppResolverService extends android.app.Service {
ctor public InstantAppResolverService();
method public final void attachBaseContext(android.content.Context);
@@ -8465,6 +8473,7 @@
field public static final String NAMESPACE_SYSTEMUI = "systemui";
field public static final String NAMESPACE_TELEPHONY = "telephony";
field public static final String NAMESPACE_TEXTCLASSIFIER = "textclassifier";
+ field public static final String NAMESPACE_WINDOW_MANAGER_NATIVE_BOOT = "window_manager_native_boot";
}
public static class DeviceConfig.BadConfigException extends java.lang.Exception {
@@ -9329,6 +9338,7 @@
public abstract class EuiccService extends android.app.Service {
ctor public EuiccService();
+ method public void dump(@NonNull java.io.PrintWriter);
method @CallSuper public android.os.IBinder onBind(android.content.Intent);
method public abstract int onDeleteSubscription(int, String);
method public android.service.euicc.DownloadSubscriptionResult onDownloadSubscription(int, @NonNull android.telephony.euicc.DownloadableSubscription, boolean, boolean, @Nullable android.os.Bundle);
@@ -10761,6 +10771,7 @@
method public void onRadioPowerStateChanged(int);
method public void onSrvccStateChanged(int);
method public void onVoiceActivationStateChanged(int);
+ field @RequiresPermission(android.Manifest.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH) public static final int LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH = 512; // 0x200
field public static final int LISTEN_CALL_ATTRIBUTES_CHANGED = 67108864; // 0x4000000
field @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int LISTEN_OUTGOING_EMERGENCY_CALL = 268435456; // 0x10000000
field @RequiresPermission(android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION) public static final int LISTEN_OUTGOING_EMERGENCY_SMS = 536870912; // 0x20000000
@@ -11249,6 +11260,7 @@
method @Deprecated @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public int setAllowedCarriers(int, java.util.List<android.service.carrier.CarrierIdentifier>);
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public boolean setAllowedNetworkTypes(long);
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public boolean setAlwaysAllowMmsData(boolean);
+ method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void setAlwaysReportSignalStrength(boolean);
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public void setCarrierDataEnabled(boolean);
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public int setCarrierRestrictionRules(@NonNull android.telephony.CarrierRestrictionRules);
method @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE) public boolean setCdmaRoamingMode(int);
@@ -11826,7 +11838,8 @@
field public static final String EXTRA_ADDITIONAL_CALL_INFO = "AdditionalCallInfo";
field public static final String EXTRA_ADDITIONAL_SIP_INVITE_FIELDS = "android.telephony.ims.extra.ADDITIONAL_SIP_INVITE_FIELDS";
field public static final String EXTRA_CALL_DISCONNECT_CAUSE = "android.telephony.ims.extra.CALL_DISCONNECT_CAUSE";
- field public static final String EXTRA_CALL_RAT_TYPE = "CallRadioTech";
+ field public static final String EXTRA_CALL_NETWORK_TYPE = "android.telephony.ims.extra.CALL_NETWORK_TYPE";
+ field @Deprecated public static final String EXTRA_CALL_RAT_TYPE = "CallRadioTech";
field public static final String EXTRA_CHILD_NUMBER = "ChildNum";
field public static final String EXTRA_CNA = "cna";
field public static final String EXTRA_CNAP = "cnap";
@@ -11858,8 +11871,8 @@
method public void callSessionConferenceExtendReceived(android.telephony.ims.stub.ImsCallSessionImplBase, android.telephony.ims.ImsCallProfile);
method public void callSessionConferenceExtended(android.telephony.ims.stub.ImsCallSessionImplBase, android.telephony.ims.ImsCallProfile);
method public void callSessionConferenceStateUpdated(android.telephony.ims.ImsConferenceState);
- method public void callSessionHandover(int, int, android.telephony.ims.ImsReasonInfo);
- method public void callSessionHandoverFailed(int, int, android.telephony.ims.ImsReasonInfo);
+ method @Deprecated public void callSessionHandover(int, int, android.telephony.ims.ImsReasonInfo);
+ method @Deprecated public void callSessionHandoverFailed(int, int, android.telephony.ims.ImsReasonInfo);
method public void callSessionHeld(android.telephony.ims.ImsCallProfile);
method public void callSessionHoldFailed(android.telephony.ims.ImsReasonInfo);
method public void callSessionHoldReceived(android.telephony.ims.ImsCallProfile);
@@ -11867,7 +11880,7 @@
method public void callSessionInitiatedFailed(android.telephony.ims.ImsReasonInfo);
method public void callSessionInviteParticipantsRequestDelivered();
method public void callSessionInviteParticipantsRequestFailed(android.telephony.ims.ImsReasonInfo);
- method public void callSessionMayHandover(int, int);
+ method @Deprecated public void callSessionMayHandover(int, int);
method public void callSessionMergeComplete(android.telephony.ims.stub.ImsCallSessionImplBase);
method public void callSessionMergeFailed(android.telephony.ims.ImsReasonInfo);
method public void callSessionMergeStarted(android.telephony.ims.stub.ImsCallSessionImplBase, android.telephony.ims.ImsCallProfile);
@@ -11889,6 +11902,9 @@
method public void callSessionUpdateReceived(android.telephony.ims.ImsCallProfile);
method public void callSessionUpdated(android.telephony.ims.ImsCallProfile);
method public void callSessionUssdMessageReceived(int, String);
+ method public void onHandover(int, int, @Nullable android.telephony.ims.ImsReasonInfo);
+ method public void onHandoverFailed(int, int, @NonNull android.telephony.ims.ImsReasonInfo);
+ method public void onMayHandover(int, int);
}
public final class ImsConferenceState implements android.os.Parcelable {
diff --git a/api/system-lint-baseline.txt b/api/system-lint-baseline.txt
index da0aae0..fde6bb3 100644
--- a/api/system-lint-baseline.txt
+++ b/api/system-lint-baseline.txt
@@ -1,33 +1,48 @@
// Baseline format: 1.0
+AcronymName: android.net.NetworkCapabilities#setSSID(String):
+ Acronyms should not be capitalized in method names: was `setSSID`, should this be `setSsid`?
+
+
ActionValue: android.location.Location#EXTRA_NO_GPS_LOCATION:
ActionValue: android.net.wifi.WifiManager#ACTION_LINK_CONFIGURATION_CHANGED:
- Inconsistent action value; expected `android.net.wifi.action.LINK_CONFIGURATION_CHANGED`, was `android.net.wifi.LINK_CONFIGURATION_CHANGED`
+
+ArrayReturn: android.bluetooth.BluetoothCodecStatus#BluetoothCodecStatus(android.bluetooth.BluetoothCodecConfig, android.bluetooth.BluetoothCodecConfig[], android.bluetooth.BluetoothCodecConfig[]) parameter #1:
+ Method parameter should be Collection<BluetoothCodecConfig> (or subclass) instead of raw array; was `android.bluetooth.BluetoothCodecConfig[]`
+ArrayReturn: android.bluetooth.BluetoothCodecStatus#BluetoothCodecStatus(android.bluetooth.BluetoothCodecConfig, android.bluetooth.BluetoothCodecConfig[], android.bluetooth.BluetoothCodecConfig[]) parameter #2:
+ Method parameter should be Collection<BluetoothCodecConfig> (or subclass) instead of raw array; was `android.bluetooth.BluetoothCodecConfig[]`
+ArrayReturn: android.bluetooth.BluetoothCodecStatus#getCodecsLocalCapabilities():
+ Method should return Collection<BluetoothCodecConfig> (or subclass) instead of raw array; was `android.bluetooth.BluetoothCodecConfig[]`
+ArrayReturn: android.bluetooth.BluetoothCodecStatus#getCodecsSelectableCapabilities():
+ Method should return Collection<BluetoothCodecConfig> (or subclass) instead of raw array; was `android.bluetooth.BluetoothCodecConfig[]`
+ArrayReturn: android.bluetooth.BluetoothUuid#containsAnyUuid(android.os.ParcelUuid[], android.os.ParcelUuid[]) parameter #0:
+ Method parameter should be Collection<ParcelUuid> (or subclass) instead of raw array; was `android.os.ParcelUuid[]`
+ArrayReturn: android.bluetooth.BluetoothUuid#containsAnyUuid(android.os.ParcelUuid[], android.os.ParcelUuid[]) parameter #1:
+ Method parameter should be Collection<ParcelUuid> (or subclass) instead of raw array; was `android.os.ParcelUuid[]`
+ArrayReturn: android.media.tv.tuner.Tuner.FilterCallback#onFilterEvent(android.media.tv.tuner.Tuner.Filter, android.media.tv.tuner.filter.FilterEvent[]) parameter #1:
+ Method parameter should be Collection<FilterEvent> (or subclass) instead of raw array; was `android.media.tv.tuner.filter.FilterEvent[]`
+ArrayReturn: android.net.NetworkScoreManager#requestScores(android.net.NetworkKey[]) parameter #0:
+ Method parameter should be Collection<NetworkKey> (or subclass) instead of raw array; was `android.net.NetworkKey[]`
ArrayReturn: android.view.contentcapture.ViewNode#getAutofillOptions():
ExecutorRegistration: android.net.wifi.p2p.WifiP2pManager#deletePersistentGroup(android.net.wifi.p2p.WifiP2pManager.Channel, int, android.net.wifi.p2p.WifiP2pManager.ActionListener):
- Registration methods should have overload that accepts delivery Executor: `deletePersistentGroup`
+
ExecutorRegistration: android.net.wifi.p2p.WifiP2pManager#factoryReset(android.net.wifi.p2p.WifiP2pManager.Channel, android.net.wifi.p2p.WifiP2pManager.ActionListener):
- Registration methods should have overload that accepts delivery Executor: `factoryReset`
+
ExecutorRegistration: android.net.wifi.p2p.WifiP2pManager#listen(android.net.wifi.p2p.WifiP2pManager.Channel, boolean, android.net.wifi.p2p.WifiP2pManager.ActionListener):
- Registration methods should have overload that accepts delivery Executor: `listen`
+
ExecutorRegistration: android.net.wifi.p2p.WifiP2pManager#requestPersistentGroupInfo(android.net.wifi.p2p.WifiP2pManager.Channel, android.net.wifi.p2p.WifiP2pManager.PersistentGroupInfoListener):
- Registration methods should have overload that accepts delivery Executor: `requestPersistentGroupInfo`
+
ExecutorRegistration: android.net.wifi.p2p.WifiP2pManager#setDeviceName(android.net.wifi.p2p.WifiP2pManager.Channel, String, android.net.wifi.p2p.WifiP2pManager.ActionListener):
- Registration methods should have overload that accepts delivery Executor: `setDeviceName`
+
ExecutorRegistration: android.net.wifi.p2p.WifiP2pManager#setWfdInfo(android.net.wifi.p2p.WifiP2pManager.Channel, android.net.wifi.p2p.WifiP2pWfdInfo, android.net.wifi.p2p.WifiP2pManager.ActionListener):
- Registration methods should have overload that accepts delivery Executor: `setWfdInfo`
+
ExecutorRegistration: android.net.wifi.p2p.WifiP2pManager#setWifiP2pChannels(android.net.wifi.p2p.WifiP2pManager.Channel, int, int, android.net.wifi.p2p.WifiP2pManager.ActionListener):
- Registration methods should have overload that accepts delivery Executor: `setWifiP2pChannels`
-
-HeavyBitSet: android.net.wifi.wificond.NativeScanResult#getCapabilities():
- Type must not be heavy BitSet (method android.net.wifi.wificond.NativeScanResult.getCapabilities())
-PairedRegistration: android.net.wifi.wificond.WifiCondManager#registerApCallback(String, java.util.concurrent.Executor, android.net.wifi.wificond.WifiCondManager.SoftApCallback):
- Found registerApCallback but not unregisterApCallback in android.net.wifi.wificond.WifiCondManager
+
GenericException: android.app.prediction.AppPredictor#finalize():
@@ -40,13 +55,22 @@
+HeavyBitSet: android.net.wifi.wificond.NativeScanResult#getCapabilities():
+
+IntentBuilderName: android.content.Context#registerReceiverForAllUsers(android.content.BroadcastReceiver, android.content.IntentFilter, String, android.os.Handler):
+ Methods creating an Intent should be named `create<Foo>Intent()`, was `registerReceiverForAllUsers`
+
KotlinKeyword: android.app.Notification#when:
+KotlinOperator: android.telephony.CbGeoUtils.Geometry#contains(android.telephony.CbGeoUtils.LatLng):
+ Method can be invoked as a "in" operator from Kotlin: `contains` (this is usually desirable; just make sure it makes sense for this type of object)
+
+
MissingNullability: android.hardware.soundtrigger.SoundTrigger.ModuleProperties#toString():
MissingNullability: android.hardware.soundtrigger.SoundTrigger.ModuleProperties#writeToParcel(android.os.Parcel, int) parameter #0:
@@ -70,7 +94,7 @@
MissingNullability: android.media.tv.TvRecordingClient.RecordingCallback#onEvent(String, String, android.os.Bundle) parameter #1:
MissingNullability: android.media.tv.TvRecordingClient.RecordingCallback#onEvent(String, String, android.os.Bundle) parameter #2:
-
+
MissingNullability: android.net.wifi.rtt.RangingRequest.Builder#addResponder(android.net.wifi.rtt.ResponderConfig):
MissingNullability: android.printservice.recommendation.RecommendationService#attachBaseContext(android.content.Context) parameter #0:
@@ -157,43 +181,60 @@
-
MutableBareField: android.net.IpConfiguration#httpProxy:
- Bare field httpProxy must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.IpConfiguration#ipAssignment:
- Bare field ipAssignment must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.IpConfiguration#proxySettings:
- Bare field proxySettings must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.IpConfiguration#staticIpConfiguration:
- Bare field staticIpConfiguration must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#allowAutojoin:
MutableBareField: android.net.wifi.WifiConfiguration#apBand:
- Bare field apBand must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#carrierId:
MutableBareField: android.net.wifi.WifiConfiguration#fromWifiNetworkSpecifier:
- Bare field fromWifiNetworkSpecifier must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#fromWifiNetworkSuggestion:
- Bare field fromWifiNetworkSuggestion must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#macRandomizationSetting:
- Bare field macRandomizationSetting must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#meteredOverride:
- Bare field meteredOverride must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#requirePMF:
- Bare field requirePMF must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#saePasswordId:
- Bare field saePasswordId must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiConfiguration#shared:
- Bare field shared must be marked final, or moved behind accessors if mutable
+
MutableBareField: android.net.wifi.WifiScanner.ScanSettings#type:
- Bare field type must be marked final, or moved behind accessors if mutable
+
NoClone: android.service.contentcapture.ContentCaptureService#dump(java.io.FileDescriptor, java.io.PrintWriter, String[]) parameter #0:
+NotCloseable: android.bluetooth.BluetoothA2dpSink:
+ Classes that release resources (finalize()) should implement AutoClosable and CloseGuard: class android.bluetooth.BluetoothA2dpSink
+NotCloseable: android.bluetooth.BluetoothMap:
+ Classes that release resources (finalize()) should implement AutoClosable and CloseGuard: class android.bluetooth.BluetoothMap
+NotCloseable: android.bluetooth.BluetoothPan:
+ Classes that release resources (finalize()) should implement AutoClosable and CloseGuard: class android.bluetooth.BluetoothPan
+NotCloseable: android.bluetooth.BluetoothPbap:
+ Classes that release resources (finalize()) should implement AutoClosable and CloseGuard: class android.bluetooth.BluetoothPbap
+
+
+OnNameExpected: android.content.ContentProvider#checkUriPermission(android.net.Uri, int, int):
+ If implemented by developer, should follow the on<Something> style; otherwise consider marking final
+
+
+PairedRegistration: android.net.wifi.wificond.WifiCondManager#registerApCallback(String, java.util.concurrent.Executor, android.net.wifi.wificond.WifiCondManager.SoftApCallback):
+
+
+
ProtectedMember: android.printservice.recommendation.RecommendationService#attachBaseContext(android.content.Context):
ProtectedMember: android.service.contentcapture.ContentCaptureService#dump(java.io.FileDescriptor, java.io.PrintWriter, String[]):
@@ -201,6 +242,7 @@
ProtectedMember: android.service.notification.NotificationAssistantService#attachBaseContext(android.content.Context):
+
SamShouldBeLast: android.accounts.AccountManager#addAccount(String, String, String[], android.os.Bundle, android.app.Activity, android.accounts.AccountManagerCallback<android.os.Bundle>, android.os.Handler):
SamShouldBeLast: android.accounts.AccountManager#addOnAccountsUpdatedListener(android.accounts.OnAccountsUpdateListener, android.os.Handler, boolean):
@@ -246,9 +288,11 @@
SamShouldBeLast: android.app.AlarmManager#setWindow(int, long, long, String, android.app.AlarmManager.OnAlarmListener, android.os.Handler):
SamShouldBeLast: android.app.WallpaperInfo#dump(android.util.Printer, String):
-
+
+SamShouldBeLast: android.app.WallpaperManager#addOnColorsChangedListener(android.app.WallpaperManager.OnColorsChangedListener, android.os.Handler):
+ SAM-compatible parameters (such as parameter 1, "listener", in android.app.WallpaperManager.addOnColorsChangedListener) should be last to improve Kotlin interoperability; see https://kotlinlang.org/docs/reference/java-interop.html#sam-conversions
SamShouldBeLast: android.app.admin.DevicePolicyManager#installSystemUpdate(android.content.ComponentName, android.net.Uri, java.util.concurrent.Executor, android.app.admin.DevicePolicyManager.InstallSystemUpdateCallback):
-
+
SamShouldBeLast: android.content.Context#bindIsolatedService(android.content.Intent, int, String, java.util.concurrent.Executor, android.content.ServiceConnection):
SamShouldBeLast: android.content.Context#bindService(android.content.Intent, int, java.util.concurrent.Executor, android.content.ServiceConnection):
@@ -279,12 +323,20 @@
SamShouldBeLast: android.location.LocationManager#registerGnssStatusCallback(java.util.concurrent.Executor, android.location.GnssStatus.Callback):
+SamShouldBeLast: android.location.LocationManager#requestLocationUpdates(String, long, float, android.location.LocationListener, android.os.Looper):
+ SAM-compatible parameters (such as parameter 4, "listener", in android.location.LocationManager.requestLocationUpdates) should be last to improve Kotlin interoperability; see https://kotlinlang.org/docs/reference/java-interop.html#sam-conversions
SamShouldBeLast: android.location.LocationManager#requestLocationUpdates(String, long, float, java.util.concurrent.Executor, android.location.LocationListener):
SamShouldBeLast: android.location.LocationManager#requestLocationUpdates(android.location.LocationRequest, java.util.concurrent.Executor, android.location.LocationListener):
+SamShouldBeLast: android.location.LocationManager#requestLocationUpdates(long, float, android.location.Criteria, android.location.LocationListener, android.os.Looper):
+ SAM-compatible parameters (such as parameter 4, "listener", in android.location.LocationManager.requestLocationUpdates) should be last to improve Kotlin interoperability; see https://kotlinlang.org/docs/reference/java-interop.html#sam-conversions
SamShouldBeLast: android.location.LocationManager#requestLocationUpdates(long, float, android.location.Criteria, java.util.concurrent.Executor, android.location.LocationListener):
+SamShouldBeLast: android.location.LocationManager#requestSingleUpdate(String, android.location.LocationListener, android.os.Looper):
+ SAM-compatible parameters (such as parameter 2, "listener", in android.location.LocationManager.requestSingleUpdate) should be last to improve Kotlin interoperability; see https://kotlinlang.org/docs/reference/java-interop.html#sam-conversions
+SamShouldBeLast: android.location.LocationManager#requestSingleUpdate(android.location.Criteria, android.location.LocationListener, android.os.Looper):
+ SAM-compatible parameters (such as parameter 2, "listener", in android.location.LocationManager.requestSingleUpdate) should be last to improve Kotlin interoperability; see https://kotlinlang.org/docs/reference/java-interop.html#sam-conversions
SamShouldBeLast: android.media.AudioFocusRequest.Builder#setOnAudioFocusChangeListener(android.media.AudioManager.OnAudioFocusChangeListener, android.os.Handler):
SamShouldBeLast: android.media.AudioManager#requestAudioFocus(android.media.AudioManager.OnAudioFocusChangeListener, int, int):
@@ -380,7 +432,7 @@
SamShouldBeLast: android.telephony.TelephonyManager#setPreferredOpportunisticDataSubscription(int, boolean, java.util.concurrent.Executor, java.util.function.Consumer<java.lang.Integer>):
SamShouldBeLast: android.telephony.TelephonyManager#updateAvailableNetworks(java.util.List<android.telephony.AvailableNetworkInfo>, java.util.concurrent.Executor, java.util.function.Consumer<java.lang.Integer>):
-
+
SamShouldBeLast: android.view.View#postDelayed(Runnable, long):
SamShouldBeLast: android.view.View#postOnAnimationDelayed(Runnable, long):
@@ -445,3 +497,11 @@
ServiceName: android.provider.DeviceConfig#NAMESPACE_PACKAGE_MANAGER_SERVICE:
+
+
+UserHandle: android.companion.CompanionDeviceManager#isDeviceAssociated(String, android.net.MacAddress, android.os.UserHandle):
+ When a method overload is needed to target a specific UserHandle, callers should be directed to use Context.createPackageContextAsUser() and re-obtain the relevant Manager, and no new API should be added
+
+
+UserHandleName: android.telephony.CellBroadcastIntents#sendOrderedBroadcastForBackgroundReceivers(android.content.Context, android.os.UserHandle, android.content.Intent, String, String, android.content.BroadcastReceiver, android.os.Handler, int, String, android.os.Bundle):
+ Method taking UserHandle should be named `doFooAsUser` or `queryFooForUser`, was `sendOrderedBroadcastForBackgroundReceivers`
diff --git a/api/test-current.txt b/api/test-current.txt
index d4b799d..c110ebe 100644
--- a/api/test-current.txt
+++ b/api/test-current.txt
@@ -3427,7 +3427,8 @@
field public static final String EXTRA_ADDITIONAL_CALL_INFO = "AdditionalCallInfo";
field public static final String EXTRA_ADDITIONAL_SIP_INVITE_FIELDS = "android.telephony.ims.extra.ADDITIONAL_SIP_INVITE_FIELDS";
field public static final String EXTRA_CALL_DISCONNECT_CAUSE = "android.telephony.ims.extra.CALL_DISCONNECT_CAUSE";
- field public static final String EXTRA_CALL_RAT_TYPE = "CallRadioTech";
+ field public static final String EXTRA_CALL_NETWORK_TYPE = "android.telephony.ims.extra.CALL_NETWORK_TYPE";
+ field @Deprecated public static final String EXTRA_CALL_RAT_TYPE = "CallRadioTech";
field public static final String EXTRA_CHILD_NUMBER = "ChildNum";
field public static final String EXTRA_CNA = "cna";
field public static final String EXTRA_CNAP = "cnap";
@@ -3460,8 +3461,8 @@
method public void callSessionConferenceExtendReceived(android.telephony.ims.stub.ImsCallSessionImplBase, android.telephony.ims.ImsCallProfile);
method public void callSessionConferenceExtended(android.telephony.ims.stub.ImsCallSessionImplBase, android.telephony.ims.ImsCallProfile);
method public void callSessionConferenceStateUpdated(android.telephony.ims.ImsConferenceState);
- method public void callSessionHandover(int, int, android.telephony.ims.ImsReasonInfo);
- method public void callSessionHandoverFailed(int, int, android.telephony.ims.ImsReasonInfo);
+ method @Deprecated public void callSessionHandover(int, int, android.telephony.ims.ImsReasonInfo);
+ method @Deprecated public void callSessionHandoverFailed(int, int, android.telephony.ims.ImsReasonInfo);
method public void callSessionHeld(android.telephony.ims.ImsCallProfile);
method public void callSessionHoldFailed(android.telephony.ims.ImsReasonInfo);
method public void callSessionHoldReceived(android.telephony.ims.ImsCallProfile);
@@ -3469,7 +3470,7 @@
method public void callSessionInitiatedFailed(android.telephony.ims.ImsReasonInfo);
method public void callSessionInviteParticipantsRequestDelivered();
method public void callSessionInviteParticipantsRequestFailed(android.telephony.ims.ImsReasonInfo);
- method public void callSessionMayHandover(int, int);
+ method @Deprecated public void callSessionMayHandover(int, int);
method public void callSessionMergeComplete(android.telephony.ims.stub.ImsCallSessionImplBase);
method public void callSessionMergeFailed(android.telephony.ims.ImsReasonInfo);
method public void callSessionMergeStarted(android.telephony.ims.stub.ImsCallSessionImplBase, android.telephony.ims.ImsCallProfile);
@@ -3491,6 +3492,9 @@
method public void callSessionUpdateReceived(android.telephony.ims.ImsCallProfile);
method public void callSessionUpdated(android.telephony.ims.ImsCallProfile);
method public void callSessionUssdMessageReceived(int, String);
+ method public void onHandover(int, int, @Nullable android.telephony.ims.ImsReasonInfo);
+ method public void onHandoverFailed(int, int, @NonNull android.telephony.ims.ImsReasonInfo);
+ method public void onMayHandover(int, int);
}
public final class ImsConferenceState implements android.os.Parcelable {
diff --git a/cmds/statsd/src/atoms.proto b/cmds/statsd/src/atoms.proto
index 4372e22..468a43f 100644
--- a/cmds/statsd/src/atoms.proto
+++ b/cmds/statsd/src/atoms.proto
@@ -95,7 +95,7 @@
ExcessiveCpuUsageReported excessive_cpu_usage_reported = 16;
CachedKillReported cached_kill_reported = 17;
ProcessMemoryStatReported process_memory_stat_reported = 18;
- LauncherUIChanged launcher_event = 19;
+ LauncherUIChanged launcher_event = 19 [(module) = "sysui"];
BatterySaverModeStateChanged battery_saver_mode_state_changed = 20;
DeviceIdleModeStateChanged device_idle_mode_state_changed = 21;
DeviceIdlingModeStateChanged device_idling_mode_state_changed = 22;
@@ -138,9 +138,9 @@
OverlayStateChanged overlay_state_changed = 59;
ForegroundServiceStateChanged foreground_service_state_changed = 60;
CallStateChanged call_state_changed = 61;
- KeyguardStateChanged keyguard_state_changed = 62;
- KeyguardBouncerStateChanged keyguard_bouncer_state_changed = 63;
- KeyguardBouncerPasswordEntered keyguard_bouncer_password_entered = 64;
+ KeyguardStateChanged keyguard_state_changed = 62 [(module) = "sysui"];
+ KeyguardBouncerStateChanged keyguard_bouncer_state_changed = 63 [(module) = "sysui"];
+ KeyguardBouncerPasswordEntered keyguard_bouncer_password_entered = 64 [(module) = "sysui"];
AppDied app_died = 65;
ResourceConfigurationChanged resource_configuration_changed = 66;
BluetoothEnabledStateChanged bluetooth_enabled_state_changed = 67;
@@ -231,7 +231,7 @@
UsbContaminantReported usb_contaminant_reported = 146;
WatchdogRollbackOccurred watchdog_rollback_occurred = 147;
BiometricSystemHealthIssueDetected biometric_system_health_issue_detected = 148;
- BubbleUIChanged bubble_ui_changed = 149;
+ BubbleUIChanged bubble_ui_changed = 149 [(module) = "sysui"];
ScheduledJobConstraintChanged scheduled_job_constraint_changed = 150;
BluetoothActiveDeviceChanged bluetooth_active_device_changed = 151;
BluetoothA2dpPlaybackStateChanged bluetooth_a2dp_playback_state_changed = 152;
@@ -262,7 +262,7 @@
AssistGestureProgressReported assist_gesture_progress_reported = 176;
TouchGestureClassified touch_gesture_classified = 177;
HiddenApiUsed hidden_api_used = 178 [(allow_from_any_uid) = true];
- StyleUIChanged style_ui_changed = 179 [(module) = "style"];
+ StyleUIChanged style_ui_changed = 179 [(module) = "sysui"];
PrivacyIndicatorsInteracted privacy_indicators_interacted =
180 [(module) = "permissioncontroller"];
AppInstallOnExternalStorageReported app_install_on_external_storage_reported = 181;
@@ -317,7 +317,7 @@
ConversationActionsEvent conversation_actions_event = 221 [(module) = "textclassifier"];
LanguageDetectionEvent language_detection_event = 222 [(module) = "textclassifier"];
ExclusionRectStateChanged exclusion_rect_state_changed = 223;
- BackGesture back_gesture_reported_reported = 224;
+ BackGesture back_gesture_reported_reported = 224 [(module) = "sysui"];
UpdateEngineUpdateAttemptReported update_engine_update_attempt_reported = 225;
UpdateEngineSuccessfulUpdateReported update_engine_successful_update_reported = 226;
CameraActionEvent camera_action_event = 227;
diff --git a/cmds/statsd/src/external/StatsPullerManager.cpp b/cmds/statsd/src/external/StatsPullerManager.cpp
index b4fde16..16a65e2 100644
--- a/cmds/statsd/src/external/StatsPullerManager.cpp
+++ b/cmds/statsd/src/external/StatsPullerManager.cpp
@@ -86,14 +86,6 @@
{{.atomTag = android::util::BATTERY_CYCLE_COUNT},
{.puller = new ResourceHealthManagerPuller(android::util::BATTERY_CYCLE_COUNT)}},
- // ProcStats.
- {{.atomTag = android::util::PROC_STATS},
- {.puller = new StatsCompanionServicePuller(android::util::PROC_STATS)}},
-
- // ProcStatsPkgProc.
- {{.atomTag = android::util::PROC_STATS_PKG_PROC},
- {.puller = new StatsCompanionServicePuller(android::util::PROC_STATS_PKG_PROC)}},
-
// DebugElapsedClock.
{{.atomTag = android::util::DEBUG_ELAPSED_CLOCK},
{.additiveFields = {1, 2, 3, 4},
@@ -115,10 +107,6 @@
{{.atomTag = android::util::GPU_STATS_APP_INFO},
{.puller = new GpuStatsPuller(android::util::GPU_STATS_APP_INFO)}},
- // Face Settings
- {{.atomTag = android::util::FACE_SETTINGS},
- {.puller = new StatsCompanionServicePuller(android::util::FACE_SETTINGS)}},
-
// VmsClientStats
{{.atomTag = android::util::VMS_CLIENT_STATS},
{.additiveFields = {5, 6, 7, 8, 9, 10},
diff --git a/core/java/android/app/ActivityManager.java b/core/java/android/app/ActivityManager.java
index 96029c9..f7c4d96 100644
--- a/core/java/android/app/ActivityManager.java
+++ b/core/java/android/app/ActivityManager.java
@@ -80,6 +80,7 @@
import com.android.internal.os.TransferPipe;
import com.android.internal.util.FastPrintWriter;
import com.android.internal.util.MemInfoReader;
+import com.android.internal.util.Preconditions;
import com.android.server.LocalServices;
import org.xmlpull.v1.XmlSerializer;
@@ -4689,4 +4690,35 @@
throw e.rethrowFromSystemServer();
}
}
+
+ /**
+ * Register with {@link HomeVisibilityObserver} with ActivityManager.
+ * @hide
+ */
+ @SystemApi
+ public void registerHomeVisibilityObserver(@NonNull HomeVisibilityObserver observer) {
+ Preconditions.checkNotNull(observer);
+ try {
+ observer.init(mContext, this);
+ getService().registerProcessObserver(observer.mObserver);
+ // Notify upon first registration.
+ observer.onHomeVisibilityChanged(observer.mIsHomeActivityVisible);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
+ * Unregister with {@link HomeVisibilityObserver} with ActivityManager.
+ * @hide
+ */
+ @SystemApi
+ public void unregisterHomeVisibilityObserver(@NonNull HomeVisibilityObserver observer) {
+ Preconditions.checkNotNull(observer);
+ try {
+ getService().unregisterProcessObserver(observer.mObserver);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
}
diff --git a/core/java/android/app/ApplicationPackageManager.java b/core/java/android/app/ApplicationPackageManager.java
index 326a076..fd56834 100644
--- a/core/java/android/app/ApplicationPackageManager.java
+++ b/core/java/android/app/ApplicationPackageManager.java
@@ -618,8 +618,7 @@
return hasSystemFeature(name, 0);
}
- @Override
- public boolean hasSystemFeature(String name, int version) {
+ private boolean hasSystemFeatureUncached(String name, int version) {
try {
return mPM.hasSystemFeature(name, version);
} catch (RemoteException e) {
@@ -627,6 +626,64 @@
}
}
+ // Make this cache relatively large. There are many system features and
+ // none are ever invalidated. MPTS tests suggests that the cache should
+ // hold at least 150 entries.
+ private static final int SYS_FEATURE_CACHE_SIZE = 256;
+ private static final String CACHE_KEY_SYS_FEATURE_PROPERTY = "cache_key.has_system_feature";
+
+ private class SystemFeatureQuery {
+ public final String name;
+ public final int version;
+ public SystemFeatureQuery(String n, int v) {
+ name = n;
+ version = v;
+ }
+ @Override
+ public String toString() {
+ return String.format("SystemFeatureQuery(name=\"%s\", version=%d)",
+ name, version);
+ }
+ @Override
+ public boolean equals(Object o) {
+ if (o instanceof SystemFeatureQuery) {
+ SystemFeatureQuery r = (SystemFeatureQuery) o;
+ return Objects.equals(name, r.name) && version == r.version;
+ } else {
+ return false;
+ }
+ }
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(name) + version;
+ }
+ }
+
+ private final PropertyInvalidatedCache<SystemFeatureQuery, Boolean> mSysFeatureCache =
+ new PropertyInvalidatedCache<SystemFeatureQuery, Boolean>(
+ SYS_FEATURE_CACHE_SIZE,
+ CACHE_KEY_SYS_FEATURE_PROPERTY) {
+ @Override
+ protected Boolean recompute(SystemFeatureQuery query) {
+ return hasSystemFeatureUncached(query.name, query.version);
+ }
+ };
+
+ @Override
+ public boolean hasSystemFeature(String name, int version) {
+ return mSysFeatureCache.query(new SystemFeatureQuery(name, version)).booleanValue();
+ }
+
+ /** @hide */
+ public void disableSysFeatureCache() {
+ mSysFeatureCache.disableLocal();
+ }
+
+ /** @hide */
+ public static void invalidateSysFeatureCache() {
+ PropertyInvalidatedCache.invalidateCache(CACHE_KEY_SYS_FEATURE_PROPERTY);
+ }
+
@Override
public int checkPermission(String permName, String pkgName) {
try {
diff --git a/core/java/android/app/HomeVisibilityObserver.java b/core/java/android/app/HomeVisibilityObserver.java
new file mode 100644
index 0000000..f3465f8
--- /dev/null
+++ b/core/java/android/app/HomeVisibilityObserver.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2020 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 android.app;
+
+import android.annotation.SystemApi;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+
+import java.util.List;
+
+/**
+ * An observer / callback to create and register by
+ * {@link ActivityManager#registerHomeVisibilityObserver} so that it's triggered when
+ * visibility of home page changes.
+ * @hide
+ */
+@SystemApi
+public abstract class HomeVisibilityObserver {
+ private Context mContext;
+ private ActivityManager mActivityManager;
+ /** @hide */
+ IProcessObserver.Stub mObserver;
+ /** @hide */
+ boolean mIsHomeActivityVisible;
+
+ /** @hide */
+ void init(Context context, ActivityManager activityManager) {
+ mContext = context;
+ mActivityManager = activityManager;
+ mIsHomeActivityVisible = isHomeActivityVisible();
+ }
+
+ /**
+ * The API that needs implemented and will be triggered when activity on home page changes.
+ */
+ public abstract void onHomeVisibilityChanged(boolean isHomeActivityVisible);
+
+ public HomeVisibilityObserver() {
+ mObserver = new IProcessObserver.Stub() {
+ @Override
+ public void onForegroundActivitiesChanged(int pid, int uid, boolean fg) {
+ boolean isHomeActivityVisible = isHomeActivityVisible();
+ if (mIsHomeActivityVisible != isHomeActivityVisible) {
+ mIsHomeActivityVisible = isHomeActivityVisible;
+ onHomeVisibilityChanged(mIsHomeActivityVisible);
+ }
+ }
+
+ @Override
+ public void onForegroundServicesChanged(int pid, int uid, int fgServiceTypes) {
+ }
+
+ @Override
+ public void onProcessDied(int pid, int uid) {
+ }
+ };
+ }
+
+ private boolean isHomeActivityVisible() {
+ List<ActivityManager.RunningTaskInfo> tasks = mActivityManager.getRunningTasks(1);
+ if (tasks == null || tasks.isEmpty()) {
+ return false;
+ }
+
+ String top = tasks.get(0).topActivity.getPackageName();
+ if (top == null) {
+ return false;
+ }
+
+ // We can assume that the screen is idle if the home application is in the foreground.
+ final Intent intent = new Intent(Intent.ACTION_MAIN, null);
+ intent.addCategory(Intent.CATEGORY_HOME);
+
+ ResolveInfo info = mContext.getPackageManager().resolveActivity(intent,
+ PackageManager.MATCH_DEFAULT_ONLY);
+ if (info != null && top.equals(info.activityInfo.packageName)) {
+ return true;
+ }
+
+ return false;
+ }
+}
diff --git a/core/java/android/app/INotificationManager.aidl b/core/java/android/app/INotificationManager.aidl
index f6014e5..d665f33 100644
--- a/core/java/android/app/INotificationManager.aidl
+++ b/core/java/android/app/INotificationManager.aidl
@@ -46,12 +46,10 @@
void clearData(String pkg, int uid, boolean fromApp);
// TODO: Replace parameter (ITransientNotification callback) with (CharSequence text)
- void enqueueTextToast(String pkg, ITransientNotification callback, int duration, int displayId);
- @UnsupportedAppUsage
- void enqueueToast(String pkg, ITransientNotification callback, int duration, int displayId);
- @UnsupportedAppUsage
- void cancelToast(String pkg, ITransientNotification callback);
- void finishToken(String pkg, ITransientNotification callback);
+ void enqueueTextToast(String pkg, IBinder token, ITransientNotification callback, int duration, int displayId);
+ void enqueueToast(String pkg, IBinder token, ITransientNotification callback, int duration, int displayId);
+ void cancelToast(String pkg, IBinder token);
+ void finishToken(String pkg, IBinder token);
void enqueueNotificationWithTag(String pkg, String opPkg, String tag, int id,
in Notification notification, int userId);
diff --git a/core/java/android/app/IUiModeManager.aidl b/core/java/android/app/IUiModeManager.aidl
index f5809ba..41e2ec9 100644
--- a/core/java/android/app/IUiModeManager.aidl
+++ b/core/java/android/app/IUiModeManager.aidl
@@ -70,7 +70,27 @@
boolean isNightModeLocked();
/**
- * @hide
+ * [De]Activates night mode
*/
boolean setNightModeActivated(boolean active);
+
+ /**
+ * Returns custom start clock time
+ */
+ long getCustomNightModeStart();
+
+ /**
+ * Sets custom start clock time
+ */
+ void setCustomNightModeStart(long time);
+
+ /**
+ * Returns custom end clock time
+ */
+ long getCustomNightModeEnd();
+
+ /**
+ * Sets custom end clock time
+ */
+ void setCustomNightModeEnd(long time);
}
diff --git a/core/java/android/app/Notification.java b/core/java/android/app/Notification.java
index 6f63eea..3c4e861 100644
--- a/core/java/android/app/Notification.java
+++ b/core/java/android/app/Notification.java
@@ -8542,13 +8542,16 @@
* Encapsulates the information needed to display a notification as a bubble.
*
* <p>A bubble is used to display app content in a floating window over the existing
- * foreground activity. A bubble has a collapsed state represented by an icon,
- * {@link BubbleMetadata.Builder#setIcon(Icon)} and an expanded state which is populated
- * via {@link BubbleMetadata.Builder#setIntent(PendingIntent)}.</p>
+ * foreground activity. A bubble has a collapsed state represented by an icon and an
+ * expanded state that displays an activity. These may be defined via
+ * {@link BubbleMetadata.Builder#createIntentBubble(PendingIntent, Icon)} or they may
+ * be definied via an existing shortcut using
+ * {@link BubbleMetadata.Builder#createShortcutBubble(String)}.
+ * </p>
*
* <b>Notifications with a valid and allowed bubble will display in collapsed state
* outside of the notification shade on unlocked devices. When a user interacts with the
- * collapsed bubble, the bubble intent will be invoked and displayed.</b>
+ * collapsed bubble, the bubble activity will be invoked and displayed.</b>
*
* @see Notification.Builder#setBubbleMetadata(BubbleMetadata)
*/
@@ -8560,10 +8563,12 @@
private int mDesiredHeight;
@DimenRes private int mDesiredHeightResId;
private int mFlags;
+ private String mShortcutId;
/**
* If set and the app creating the bubble is in the foreground, the bubble will be posted
- * in its expanded state, with the contents of {@link #getIntent()} in a floating window.
+ * in its expanded state, with the contents of {@link #getBubbleIntent()} in a floating
+ * window.
*
* <p>This flag has no effect if the app posting the bubble is not in the foreground.
* The app is considered foreground if it is visible and on the screen, note that
@@ -8595,34 +8600,61 @@
public static final int FLAG_SUPPRESS_NOTIFICATION = 0x00000002;
private BubbleMetadata(PendingIntent expandIntent, PendingIntent deleteIntent,
- Icon icon, int height, @DimenRes int heightResId) {
+ Icon icon, int height, @DimenRes int heightResId, String shortcutId) {
mPendingIntent = expandIntent;
mIcon = icon;
mDesiredHeight = height;
mDesiredHeightResId = heightResId;
mDeleteIntent = deleteIntent;
+ mShortcutId = shortcutId;
}
private BubbleMetadata(Parcel in) {
- mPendingIntent = PendingIntent.CREATOR.createFromParcel(in);
- mIcon = Icon.CREATOR.createFromParcel(in);
+ if (in.readInt() != 0) {
+ mPendingIntent = PendingIntent.CREATOR.createFromParcel(in);
+ }
+ if (in.readInt() != 0) {
+ mIcon = Icon.CREATOR.createFromParcel(in);
+ }
mDesiredHeight = in.readInt();
mFlags = in.readInt();
if (in.readInt() != 0) {
mDeleteIntent = PendingIntent.CREATOR.createFromParcel(in);
}
mDesiredHeightResId = in.readInt();
+ if (in.readInt() != 0) {
+ mShortcutId = in.readString();
+ }
}
/**
- * @return the pending intent used to populate the floating window for this bubble.
+ * @return the shortcut id used to populate the bubble, if it exists.
*/
+ @Nullable
+ public String getShortcutId() {
+ return mShortcutId;
+ }
+
+ /**
+ * @deprecated use {@link #getBubbleIntent()} or use {@link #getShortcutId()} if created
+ * with a valid shortcut instead.
+ */
+ @Deprecated
@NonNull
public PendingIntent getIntent() {
return mPendingIntent;
}
/**
+ * @return the pending intent used to populate the floating window for this bubble, or
+ * null if this bubble is shortcut based.
+ */
+ @Nullable
+ public PendingIntent getBubbleIntent() {
+ return mPendingIntent;
+ }
+
+ /**
* @return the pending intent to send when the bubble is dismissed by a user, if one exists.
*/
@Nullable
@@ -8631,17 +8663,28 @@
}
/**
- * @return the icon that will be displayed for this bubble when it is collapsed.
+ * @deprecated use {@link #getBubbleIcon()} or use {@link #getShortcutId()} if created
+ * with a valid shortcut instead.
*/
+ @Deprecated
@NonNull
public Icon getIcon() {
return mIcon;
}
/**
+ * @return the icon that will be displayed for this bubble when it is collapsed, or null
+ * if the bubble is shortcut based.
+ */
+ @Nullable
+ public Icon getBubbleIcon() {
+ return mIcon;
+ }
+
+ /**
* @return the ideal height, in DPs, for the floating window that app content defined by
- * {@link #getIntent()} for this bubble. A value of 0 indicates a desired height has not
- * been set.
+ * {@link #getBubbleIntent()} for this bubble. A value of 0 indicates a desired height has
+ * not been set.
*/
@Dimension(unit = DP)
public int getDesiredHeight() {
@@ -8650,7 +8693,7 @@
/**
* @return the resId of ideal height for the floating window that app content defined by
- * {@link #getIntent()} for this bubble. A value of 0 indicates a res value has not
+ * {@link #getBubbleIntent()} for this bubble. A value of 0 indicates a res value has not
* been provided for the desired height.
*/
@DimenRes
@@ -8697,8 +8740,14 @@
@Override
public void writeToParcel(Parcel out, int flags) {
- mPendingIntent.writeToParcel(out, 0);
- mIcon.writeToParcel(out, 0);
+ out.writeInt(mPendingIntent != null ? 1 : 0);
+ if (mPendingIntent != null) {
+ mPendingIntent.writeToParcel(out, 0);
+ }
+ out.writeInt(mIcon != null ? 1 : 0);
+ if (mIcon != null) {
+ mIcon.writeToParcel(out, 0);
+ }
out.writeInt(mDesiredHeight);
out.writeInt(mFlags);
out.writeInt(mDeleteIntent != null ? 1 : 0);
@@ -8706,6 +8755,10 @@
mDeleteIntent.writeToParcel(out, 0);
}
out.writeInt(mDesiredHeightResId);
+ out.writeInt(TextUtils.isEmpty(mShortcutId) ? 0 : 1);
+ if (!TextUtils.isEmpty(mShortcutId)) {
+ out.writeString(mShortcutId);
+ }
}
/**
@@ -8733,6 +8786,7 @@
@DimenRes private int mDesiredHeightResId;
private int mFlags;
private PendingIntent mDeleteIntent;
+ private String mShortcutId;
/**
* Constructs a new builder object.
@@ -8741,50 +8795,98 @@
}
/**
- * Sets the intent that will be used when the bubble is expanded. This will display the
- * app content in a floating window over the existing foreground activity.
+ * Creates a {@link BubbleMetadata.Builder} based on a shortcut. Only
+ * {@link android.content.pm.ShortcutManager#addDynamicShortcuts(List)} shortcuts are
+ * supported.
*
- * <p>An intent is required.</p>
+ * <p>The shortcut icon will be used to represent the bubble when it is collapsed.</p>
*
- * @throws IllegalArgumentException if intent is null
+ * <p>The shortcut activity will be used when the bubble is expanded. This will display
+ * the shortcut activity in a floating window over the existing foreground activity.</p>
+ *
+ * <p>If the shortcut has not been published when the bubble notification is sent,
+ * no bubble will be produced. If the shortcut is deleted while the bubble is active,
+ * the bubble will be removed.</p>
+ *
+ * <p>Calling this method will clear the contents of
+ * {@link #createIntentBubble(PendingIntent, Icon)} if it was previously called on
+ * this builder.</p>
*/
@NonNull
- public BubbleMetadata.Builder setIntent(@NonNull PendingIntent intent) {
- if (intent == null) {
- throw new IllegalArgumentException("Bubble requires non-null pending intent");
+ public BubbleMetadata.Builder createShortcutBubble(@NonNull String shortcutId) {
+ if (!TextUtils.isEmpty(shortcutId)) {
+ // If shortcut id is set, we don't use these if they were previously set.
+ mPendingIntent = null;
+ mIcon = null;
}
- mPendingIntent = intent;
+ mShortcutId = shortcutId;
return this;
}
/**
- * Sets the icon that will represent the bubble when it is collapsed.
+ * Creates a {@link BubbleMetadata.Builder} based on the provided intent and icon.
*
- * <p>An icon is required and should be representative of the content within the bubble.
- * If your app produces multiple bubbles, the image should be unique for each of them.
+ * <p>The icon will be used to represent the bubble when it is collapsed. An icon
+ * should be representative of the content within the bubble. If your app produces
+ * multiple bubbles, the icon should be unique for each of them.</p>
+ *
+ * <p>The intent that will be used when the bubble is expanded. This will display the
+ * app content in a floating window over the existing foreground activity.</p>
+ *
+ * <p>Calling this method will clear the contents of
+ * {@link #createShortcutBubble(String)} if it was previously called on this builder.
* </p>
*
- * <p>The shape of a bubble icon is adaptive and will match the device theme.
- *
- * Ideally your icon should be constructed via
- * {@link Icon#createWithAdaptiveBitmap(Bitmap)}, otherwise, the icon will be shrunk
- * and placed on an adaptive shape.
- * </p>
- *
+ * @throws IllegalArgumentException if intent is null.
* @throws IllegalArgumentException if icon is null.
*/
@NonNull
- public BubbleMetadata.Builder setIcon(@NonNull Icon icon) {
+ public BubbleMetadata.Builder createIntentBubble(@NonNull PendingIntent intent,
+ @NonNull Icon icon) {
+ if (intent == null) {
+ throw new IllegalArgumentException("Bubble requires non-null pending intent");
+ }
if (icon == null) {
throw new IllegalArgumentException("Bubbles require non-null icon");
}
+ mShortcutId = null;
+ mPendingIntent = intent;
mIcon = icon;
return this;
}
/**
- * Sets the desired height in DPs for the app content defined by
- * {@link #setIntent(PendingIntent)}.
+ * @deprecated use {@link #createIntentBubble(PendingIntent, Icon)}
+ * or {@link #createShortcutBubble(String)} instead.
+ */
+ @Deprecated
+ @NonNull
+ public BubbleMetadata.Builder setIntent(@NonNull PendingIntent intent) {
+ if (intent == null) {
+ throw new IllegalArgumentException("Bubble requires non-null pending intent");
+ }
+ mShortcutId = null;
+ mPendingIntent = intent;
+ return this;
+ }
+
+ /**
+ * @deprecated use {@link #createIntentBubble(PendingIntent, Icon)}
+ * or {@link #createShortcutBubble(String)} instead.
+ */
+ @Deprecated
+ @NonNull
+ public BubbleMetadata.Builder setIcon(@NonNull Icon icon) {
+ if (icon == null) {
+ throw new IllegalArgumentException("Bubbles require non-null icon");
+ }
+ mShortcutId = null;
+ mIcon = icon;
+ return this;
+ }
+
+ /**
+ * Sets the desired height in DPs for the expanded content of the bubble.
*
* <p>This height may not be respected if there is not enough space on the screen or if
* the provided height is too small to be useful.</p>
@@ -8806,8 +8908,7 @@
/**
- * Sets the desired height via resId for the app content defined by
- * {@link #setIntent(PendingIntent)}.
+ * Sets the desired height via resId for the expanded content of the bubble.
*
* <p>This height may not be respected if there is not enough space on the screen or if
* the provided height is too small to be useful.</p>
@@ -8829,7 +8930,7 @@
/**
* Sets whether the bubble will be posted in its expanded state (with the contents of
- * {@link #getIntent()} in a floating window).
+ * {@link #getBubbleIntent()} in a floating window).
*
* <p>This flag has no effect if the app posting the bubble is not in the foreground.
* The app is considered foreground if it is visible and on the screen, note that
@@ -8882,20 +8983,21 @@
/**
* Creates the {@link BubbleMetadata} defined by this builder.
*
- * @throws IllegalStateException if {@link #setIntent(PendingIntent)} and/or
- * {@link #setIcon(Icon)} have not been called on this
- * builder.
+ * @throws IllegalStateException if neither {@link #createShortcutBubble(String)} or
+ * {@link #createIntentBubble(PendingIntent, Icon)} have been called on this builder.
*/
@NonNull
public BubbleMetadata build() {
- if (mPendingIntent == null) {
- throw new IllegalStateException("Must supply pending intent to bubble");
+ if (mShortcutId == null && mPendingIntent == null) {
+ throw new IllegalStateException(
+ "Must supply pending intent or shortcut to bubble");
}
- if (mIcon == null) {
- throw new IllegalStateException("Must supply an icon for the bubble");
+ if (mShortcutId == null && mIcon == null) {
+ throw new IllegalStateException(
+ "Must supply an icon or shortcut for the bubble");
}
BubbleMetadata data = new BubbleMetadata(mPendingIntent, mDeleteIntent,
- mIcon, mDesiredHeight, mDesiredHeightResId);
+ mIcon, mDesiredHeight, mDesiredHeightResId, mShortcutId);
data.setFlags(mFlags);
return data;
}
diff --git a/core/java/android/app/NotificationHistory.java b/core/java/android/app/NotificationHistory.java
index 8ba39a8..909a476 100644
--- a/core/java/android/app/NotificationHistory.java
+++ b/core/java/android/app/NotificationHistory.java
@@ -24,6 +24,8 @@
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
@@ -311,11 +313,23 @@
mHistoryCount++;
}
+ /**
+ * Used when populating a history from disk; adds an historical notification.
+ */
+ public void addNewNotificationToWrite(@NonNull HistoricalNotification notification) {
+ if (notification == null) {
+ return;
+ }
+ mNotificationsToWrite.add(0, notification);
+ mHistoryCount++;
+ }
+
public void addNotificationsToWrite(@NonNull NotificationHistory notificationHistory) {
for (HistoricalNotification hn : notificationHistory.getNotificationsToWrite()) {
- // TODO: consider merging by date
addNotificationToWrite(hn);
}
+ Collections.sort(mNotificationsToWrite,
+ (o1, o2) -> -1 * Long.compare(o1.getPostedTimeMs(), o2.getPostedTimeMs()));
poolStringsFromNotifications();
}
diff --git a/core/java/android/app/UiModeManager.java b/core/java/android/app/UiModeManager.java
index 3633064..24873b8 100644
--- a/core/java/android/app/UiModeManager.java
+++ b/core/java/android/app/UiModeManager.java
@@ -18,6 +18,7 @@
import android.annotation.IntDef;
import android.annotation.IntRange;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.RequiresPermission;
import android.annotation.SystemApi;
@@ -32,6 +33,7 @@
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
+import java.time.LocalTime;
/**
* This class provides access to the system uimode services. These services
@@ -163,6 +165,7 @@
/** @hide */
@IntDef(prefix = { "MODE_" }, value = {
MODE_NIGHT_AUTO,
+ MODE_NIGHT_CUSTOM,
MODE_NIGHT_NO,
MODE_NIGHT_YES
})
@@ -173,19 +176,25 @@
* Constant for {@link #setNightMode(int)} and {@link #getNightMode()}:
* automatically switch night mode on and off based on the time.
*/
- public static final int MODE_NIGHT_AUTO = Configuration.UI_MODE_NIGHT_UNDEFINED >> 4;
+ public static final int MODE_NIGHT_AUTO = 0;
+
+ /**
+ * Constant for {@link #setNightMode(int)} and {@link #getNightMode()}:
+ * automatically switch night mode on and off based on the time.
+ */
+ public static final int MODE_NIGHT_CUSTOM = 3;
/**
* Constant for {@link #setNightMode(int)} and {@link #getNightMode()}:
* never run in night mode.
*/
- public static final int MODE_NIGHT_NO = Configuration.UI_MODE_NIGHT_NO >> 4;
+ public static final int MODE_NIGHT_NO = 1;
/**
* Constant for {@link #setNightMode(int)} and {@link #getNightMode()}:
* always run in night mode.
*/
- public static final int MODE_NIGHT_YES = Configuration.UI_MODE_NIGHT_YES >> 4;
+ public static final int MODE_NIGHT_YES = 2;
private IUiModeManager mService;
@@ -377,6 +386,8 @@
* {@code notnight} mode</li>
* <li><em>{@link #MODE_NIGHT_YES}</em> sets the device into
* {@code night} mode</li>
+ * <li><em>{@link #MODE_NIGHT_CUSTOM}</em> automatically switches between
+ * {@code night} and {@code notnight} based on the custom time set (or default)</li>
* <li><em>{@link #MODE_NIGHT_AUTO}</em> automatically switches between
* {@code night} and {@code notnight} based on the device's current
* location and certain other sensors</li>
@@ -418,6 +429,7 @@
* <li>{@link #MODE_NIGHT_NO}</li>
* <li>{@link #MODE_NIGHT_YES}</li>
* <li>{@link #MODE_NIGHT_AUTO}</li>
+ * <li>{@link #MODE_NIGHT_CUSTOM}</li>
* <li>{@code -1} on error</li>
* </ul>
*
@@ -475,7 +487,7 @@
}
/**
- * @hide*
+ * @hide
*/
public boolean setNightModeActivated(boolean active) {
if (mService != null) {
@@ -487,4 +499,75 @@
}
return false;
}
+
+ /**
+ * Returns the time of the day Dark theme activates
+ * <p>
+ * When night mode is {@link #MODE_NIGHT_CUSTOM}, the system uses
+ * this time set to activate it automatically.
+ */
+ @NonNull
+ public LocalTime getCustomNightModeStart() {
+ if (mService != null) {
+ try {
+ return LocalTime.ofNanoOfDay(mService.getCustomNightModeStart() * 1000);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+ return LocalTime.MIDNIGHT;
+ }
+
+ /**
+ * Sets the time of the day Dark theme activates
+ * <p>
+ * When night mode is {@link #MODE_NIGHT_CUSTOM}, the system uses
+ * this time set to activate it automatically
+ * @param time The time of the day Dark theme should activate
+ */
+ public void setCustomNightModeStart(@NonNull LocalTime time) {
+ if (mService != null) {
+ try {
+ mService.setCustomNightModeStart(time.toNanoOfDay() / 1000);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+ }
+
+ /**
+ * Returns the time of the day Dark theme deactivates
+ * <p>
+ * When night mode is {@link #MODE_NIGHT_CUSTOM}, the system uses
+ * this time set to deactivate it automatically.
+ */
+ @NonNull
+ public LocalTime getCustomNightModeEnd() {
+ if (mService != null) {
+ try {
+ return LocalTime.ofNanoOfDay(mService.getCustomNightModeEnd() * 1000);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+ return LocalTime.MIDNIGHT;
+ }
+
+ /**
+ * Sets the time of the day Dark theme deactivates
+ * <p>
+ * When night mode is {@link #MODE_NIGHT_CUSTOM}, the system uses
+ * this time set to deactivate it automatically.
+ * @param time The time of the day Dark theme should deactivate
+ */
+ public void setCustomNightModeEnd(@NonNull LocalTime time) {
+ if (mService != null) {
+ try {
+ mService.setCustomNightModeEnd(time.toNanoOfDay() / 1000);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+ }
+
}
diff --git a/core/java/android/content/pm/PackageManager.java b/core/java/android/content/pm/PackageManager.java
index 1f502a1..925d70c 100644
--- a/core/java/android/content/pm/PackageManager.java
+++ b/core/java/android/content/pm/PackageManager.java
@@ -2323,13 +2323,6 @@
public static final String FEATURE_TELEPHONY_GSM = "android.hardware.telephony.gsm";
/**
- * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: The device
- * has a telephony radio that support data.
- */
- @SdkConstant(SdkConstantType.FEATURE)
- public static final String FEATURE_TELEPHONY_DATA = "android.hardware.telephony.data";
-
- /**
* Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}:
* The device supports telephony carrier restriction mechanism.
*
diff --git a/core/java/android/hardware/camera2/CameraMetadata.java b/core/java/android/hardware/camera2/CameraMetadata.java
index 2377ccd..89dac2a 100644
--- a/core/java/android/hardware/camera2/CameraMetadata.java
+++ b/core/java/android/hardware/camera2/CameraMetadata.java
@@ -87,17 +87,31 @@
*/
protected abstract <T> T getProtected(TKey key);
- /**
- * @hide
- */
- protected void setNativeInstance(CameraMetadataNative nativeInstance) {
+ /**
+ * @hide
+ */
+ protected void setNativeInstance(CameraMetadataNative nativeInstance) {
mNativeInstance = nativeInstance;
- }
+ }
- /**
- * @hide
- */
- protected abstract Class<TKey> getKeyClass();
+ /**
+ * Retrieves the native CameraMetadata* as a Java long.
+ * Returns 0 if mNativeInstance is null.
+ *
+ * @hide
+ */
+ public long getNativeMetadataPtr() {
+ if (mNativeInstance == null) {
+ return 0;
+ } else {
+ return mNativeInstance.getMetadataPtr();
+ }
+ }
+
+ /**
+ * @hide
+ */
+ protected abstract Class<TKey> getKeyClass();
/**
* Returns a list of the keys contained in this map.
diff --git a/core/java/android/hardware/camera2/impl/CameraMetadataNative.java b/core/java/android/hardware/camera2/impl/CameraMetadataNative.java
index 1fab666..3ae3d78 100644
--- a/core/java/android/hardware/camera2/impl/CameraMetadataNative.java
+++ b/core/java/android/hardware/camera2/impl/CameraMetadataNative.java
@@ -1703,6 +1703,15 @@
/**
+ * Retrieves the pointer to the native CameraMetadata as a Java long.
+ *
+ * @hide
+ */
+ public long getMetadataPtr() {
+ return mMetadataPtr;
+ }
+
+ /**
* Return a list containing keys of the given key class for all defined vendor tags.
*
* @hide
diff --git a/core/java/android/os/AppZygote.java b/core/java/android/os/AppZygote.java
index 6daa5b4..9257496 100644
--- a/core/java/android/os/AppZygote.java
+++ b/core/java/android/os/AppZygote.java
@@ -21,6 +21,8 @@
import com.android.internal.annotations.GuardedBy;
+import dalvik.system.VMRuntime;
+
/**
* AppZygote is responsible for interfacing with an application-specific zygote.
*
@@ -113,7 +115,7 @@
"app_zygote", // seInfo
abi, // abi
abi, // acceptedAbiList
- null, // instructionSet
+ VMRuntime.getInstructionSet(abi), // instructionSet
mZygoteUidGidMin,
mZygoteUidGidMax);
diff --git a/core/java/android/os/RevocableFileDescriptor.java b/core/java/android/os/RevocableFileDescriptor.java
index a750ce6..ac2cd60 100644
--- a/core/java/android/os/RevocableFileDescriptor.java
+++ b/core/java/android/os/RevocableFileDescriptor.java
@@ -48,6 +48,8 @@
private volatile boolean mRevoked;
+ private ParcelFileDescriptor.OnCloseListener mOnCloseListener;
+
/** {@hide} */
public RevocableFileDescriptor() {
}
@@ -97,6 +99,14 @@
IoUtils.closeQuietly(mInner);
}
+ /**
+ * Callback for indicating that {@link ParcelFileDescriptor} passed to the client
+ * process ({@link #getRevocableFileDescriptor()}) has been closed.
+ */
+ public void addOnCloseListener(ParcelFileDescriptor.OnCloseListener onCloseListener) {
+ mOnCloseListener = onCloseListener;
+ }
+
public boolean isRevoked() {
return mRevoked;
}
@@ -156,6 +166,9 @@
if (DEBUG) Slog.v(TAG, "onRelease()");
mRevoked = true;
IoUtils.closeQuietly(mInner);
+ if (mOnCloseListener != null) {
+ mOnCloseListener.onClose(null);
+ }
}
};
}
diff --git a/core/java/android/provider/DeviceConfig.java b/core/java/android/provider/DeviceConfig.java
index 53f4615..84ceca0 100644
--- a/core/java/android/provider/DeviceConfig.java
+++ b/core/java/android/provider/DeviceConfig.java
@@ -333,6 +333,15 @@
public static final String NAMESPACE_WINDOW_MANAGER = "window_manager";
/**
+ * Namespace for window manager features accessible by native code and
+ * loaded once per boot.
+ *
+ * @hide
+ */
+ @SystemApi
+ public static final String NAMESPACE_WINDOW_MANAGER_NATIVE_BOOT = "window_manager_native_boot";
+
+ /**
* List of namespaces which can be read without READ_DEVICE_CONFIG permission
*
* @hide
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index eee8fb1..0742a20 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -5883,6 +5883,22 @@
"dark_mode_dialog_seen";
/**
+ * Custom time when Dark theme is scheduled to activate.
+ * Represented as milliseconds from midnight (e.g. 79200000 == 10pm).
+ * @hide
+ */
+ public static final String DARK_THEME_CUSTOM_START_TIME =
+ "dark_theme_custom_start_time";
+
+ /**
+ * Custom time when Dark theme is scheduled to deactivate.
+ * Represented as milliseconds from midnight (e.g. 79200000 == 10pm).
+ * @hide
+ */
+ public static final String DARK_THEME_CUSTOM_END_TIME =
+ "dark_theme_custom_end_time";
+
+ /**
* Defines value returned by {@link android.service.autofill.UserData#getMaxUserDataSize()}.
*
* @hide
@@ -7706,6 +7722,14 @@
public static final String UI_NIGHT_MODE = "ui_night_mode";
/**
+ * The current night mode that has been overrided by the system. Owned
+ * and controlled by UiModeManagerService. Constants are as per
+ * UiModeManager.
+ * @hide
+ */
+ public static final String UI_NIGHT_MODE_OVERRIDE = "ui_night_mode_override";
+
+ /**
* Whether screensavers are enabled.
* @hide
*/
diff --git a/core/java/android/service/euicc/IEuiccServiceDumpResultCallback.aidl b/core/java/android/service/euicc/IEuiccServiceDumpResultCallback.aidl
new file mode 100644
index 0000000..ea55ebb
--- /dev/null
+++ b/core/java/android/service/euicc/IEuiccServiceDumpResultCallback.aidl
@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2017 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 android.service.euicc;
+
+/** @hide */
+oneway interface IEuiccServiceDumpResultCallback {
+ void onComplete(in String logs);
+}
\ No newline at end of file
diff --git a/core/java/android/telephony/PhoneStateListener.java b/core/java/android/telephony/PhoneStateListener.java
index a4fe6aa..4def80e 100644
--- a/core/java/android/telephony/PhoneStateListener.java
+++ b/core/java/android/telephony/PhoneStateListener.java
@@ -168,6 +168,16 @@
public static final int LISTEN_SIGNAL_STRENGTHS = 0x00000100;
/**
+ * Listen for always reported changes of the network signal strengths (cellular),
+ * even in some situations such as the screen of the device is off.
+ *
+ * @hide
+ */
+ @RequiresPermission(android.Manifest.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH)
+ @SystemApi
+ public static final int LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH = 0x00000200;
+
+ /**
* Listen for changes to observed cell info.
*
* @see #onCellInfoChanged
diff --git a/core/java/android/util/TimeUtils.java b/core/java/android/util/TimeUtils.java
index 8439f5a..0558204 100644
--- a/core/java/android/util/TimeUtils.java
+++ b/core/java/android/util/TimeUtils.java
@@ -30,6 +30,7 @@
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
+import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
@@ -382,6 +383,28 @@
}
/**
+ * This method is used to find if a clock time is inclusively between two other clock times
+ * @param reference The time of the day we want check if it is between start and end
+ * @param start The start time reference
+ * @param end The end time
+ * @return true if the reference time is between the two clock times, and false otherwise.
+ */
+ public static boolean isTimeBetween(@NonNull LocalTime reference,
+ @NonNull LocalTime start,
+ @NonNull LocalTime end) {
+ // ////////E----+-----S////////
+ if ((reference.isBefore(start) && reference.isAfter(end)
+ // -----+----S//////////E------
+ || (reference.isBefore(end) && reference.isBefore(start) && start.isBefore(end))
+ // ---------S//////////E---+---
+ || (reference.isAfter(end) && reference.isAfter(start)) && start.isBefore(end))) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ /**
* Dump a currentTimeMillis style timestamp for dumpsys, with the delta time from now.
*
* @hide
diff --git a/core/java/android/view/SurfaceControl.java b/core/java/android/view/SurfaceControl.java
index 38416ee..bcc9e41 100644
--- a/core/java/android/view/SurfaceControl.java
+++ b/core/java/android/view/SurfaceControl.java
@@ -128,6 +128,8 @@
int l, int t, int r, int b);
private static native void nativeSetCornerRadius(long transactionObj, long nativeObject,
float cornerRadius);
+ private static native void nativeSetBackgroundBlurRadius(long transactionObj, long nativeObject,
+ int blurRadius);
private static native void nativeSetLayerStack(long transactionObj, long nativeObject,
int layerStack);
@@ -2505,6 +2507,20 @@
}
/**
+ * Sets the background blur radius of the {@link SurfaceControl}.
+ *
+ * @param sc SurfaceControl.
+ * @param radius Blur radius in pixels.
+ * @return itself.
+ * @hide
+ */
+ public Transaction setBackgroundBlurRadius(SurfaceControl sc, int radius) {
+ checkPreconditions(sc);
+ nativeSetBackgroundBlurRadius(mNativeObject, sc.mNativeObject, radius);
+ return this;
+ }
+
+ /**
* @hide
*/
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.O)
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 5356334..377a764 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -4778,7 +4778,7 @@
private CheckForTap mPendingCheckForTap = null;
private PerformClick mPerformClick;
private SendViewScrolledAccessibilityEvent mSendViewScrolledAccessibilityEvent;
-
+ private SendAccessibilityEventThrottle mSendStateChangedAccessibilityEvent;
private UnsetPressedState mUnsetPressedState;
/**
@@ -8148,13 +8148,46 @@
if ((event.getEventType() & POPULATING_ACCESSIBILITY_EVENT_TYPES) != 0) {
dispatchPopulateAccessibilityEvent(event);
}
- // In the beginning we called #isShown(), so we know that getParent() is not null.
+ SendAccessibilityEventThrottle throttle = getThrottleForAccessibilityEvent(event);
+ if (throttle != null) {
+ throttle.post(event);
+ } else {
+ requestParentSendAccessibilityEvent(event);
+ }
+ }
+
+ private void requestParentSendAccessibilityEvent(AccessibilityEvent event) {
ViewParent parent = getParent();
if (parent != null) {
getParent().requestSendAccessibilityEvent(this, event);
}
}
+ private SendAccessibilityEventThrottle getThrottleForAccessibilityEvent(
+ AccessibilityEvent event) {
+ if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_SCROLLED) {
+ if (mSendViewScrolledAccessibilityEvent == null) {
+ mSendViewScrolledAccessibilityEvent = new SendViewScrolledAccessibilityEvent();
+ }
+ return mSendViewScrolledAccessibilityEvent;
+ }
+ boolean isStateContentChanged = (event.getContentChangeTypes()
+ & AccessibilityEvent.CONTENT_CHANGE_TYPE_STATE_DESCRIPTION) != 0;
+ if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED
+ && isStateContentChanged) {
+ if (mSendStateChangedAccessibilityEvent == null) {
+ mSendStateChangedAccessibilityEvent = new SendAccessibilityEventThrottle();
+ }
+ return mSendStateChangedAccessibilityEvent;
+ }
+ return null;
+ }
+
+ private void clearAccessibilityThrottles() {
+ cancel(mSendViewScrolledAccessibilityEvent);
+ cancel(mSendStateChangedAccessibilityEvent);
+ }
+
/**
* Dispatches an {@link AccessibilityEvent} to the {@link View} first and then
* to its children for adding their text content to the event. Note that the
@@ -10375,8 +10408,12 @@
&& getImportantForAccessibility() == IMPORTANT_FOR_ACCESSIBILITY_AUTO) {
setImportantForAccessibility(IMPORTANT_FOR_ACCESSIBILITY_YES);
}
- notifyViewAccessibilityStateChangedIfNeeded(
- AccessibilityEvent.CONTENT_CHANGE_TYPE_STATE_DESCRIPTION);
+ if (AccessibilityManager.getInstance(mContext).isEnabled()) {
+ AccessibilityEvent event = AccessibilityEvent.obtain();
+ event.setEventType(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
+ event.setContentChangeTypes(AccessibilityEvent.CONTENT_CHANGE_TYPE_STATE_DESCRIPTION);
+ sendAccessibilityEventUnchecked(event);
+ }
}
/**
@@ -15983,10 +16020,7 @@
*/
protected void onScrollChanged(int l, int t, int oldl, int oldt) {
notifySubtreeAccessibilityStateChangedIfNeeded();
-
- if (AccessibilityManager.getInstance(mContext).isEnabled()) {
- postSendViewScrolledAccessibilityEventCallback(l - oldl, t - oldt);
- }
+ postSendViewScrolledAccessibilityEventCallback(l - oldl, t - oldt);
mBackgroundSizeChanged = true;
mDefaultFocusHighlightSizeChanged = true;
@@ -18709,10 +18743,13 @@
* {@link ViewConfiguration#getSendRecurringAccessibilityEventsInterval()}.
*/
private void postSendViewScrolledAccessibilityEventCallback(int dx, int dy) {
- if (mSendViewScrolledAccessibilityEvent == null) {
- mSendViewScrolledAccessibilityEvent = new SendViewScrolledAccessibilityEvent();
+ if (AccessibilityManager.getInstance(mContext).isEnabled()) {
+ AccessibilityEvent event =
+ AccessibilityEvent.obtain(AccessibilityEvent.TYPE_VIEW_SCROLLED);
+ event.setScrollDeltaX(dx);
+ event.setScrollDeltaY(dy);
+ sendAccessibilityEventUnchecked(event);
}
- mSendViewScrolledAccessibilityEvent.post(dx, dy);
}
/**
@@ -20010,7 +20047,7 @@
removeUnsetPressCallback();
removeLongPressCallback();
removePerformClickCallback();
- cancel(mSendViewScrolledAccessibilityEvent);
+ clearAccessibilityThrottles();
stopNestedScroll();
// Anything that started animating right before detach should already
@@ -28994,49 +29031,67 @@
}
}
- /**
- * Resuable callback for sending
- * {@link AccessibilityEvent#TYPE_VIEW_SCROLLED} accessibility event.
- */
- private class SendViewScrolledAccessibilityEvent implements Runnable {
+ private class SendAccessibilityEventThrottle implements Runnable {
public volatile boolean mIsPending;
- public int mDeltaX;
- public int mDeltaY;
+ private AccessibilityEvent mAccessibilityEvent;
- public void post(int dx, int dy) {
- mDeltaX += dx;
- mDeltaY += dy;
+ public void post(AccessibilityEvent accessibilityEvent) {
+ updateWithAccessibilityEvent(accessibilityEvent);
if (!mIsPending) {
mIsPending = true;
- postDelayed(this, ViewConfiguration.getSendRecurringAccessibilityEventsInterval());
+ postDelayed(this,
+ ViewConfiguration.getSendRecurringAccessibilityEventsInterval());
}
}
@Override
public void run() {
if (AccessibilityManager.getInstance(mContext).isEnabled()) {
- AccessibilityEvent event = AccessibilityEvent.obtain(
- AccessibilityEvent.TYPE_VIEW_SCROLLED);
- event.setScrollDeltaX(mDeltaX);
- event.setScrollDeltaY(mDeltaY);
- sendAccessibilityEventUnchecked(event);
+ requestParentSendAccessibilityEvent(mAccessibilityEvent);
}
reset();
}
- private void reset() {
+ public void updateWithAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
+ mAccessibilityEvent = accessibilityEvent;
+ }
+
+ public void reset() {
mIsPending = false;
+ mAccessibilityEvent = null;
+ }
+
+ }
+
+ /**
+ * Resuable callback for sending
+ * {@link AccessibilityEvent#TYPE_VIEW_SCROLLED} accessibility event.
+ */
+ private class SendViewScrolledAccessibilityEvent extends SendAccessibilityEventThrottle {
+ public int mDeltaX;
+ public int mDeltaY;
+
+ @Override
+ public void updateWithAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
+ super.updateWithAccessibilityEvent(accessibilityEvent);
+ mDeltaX += accessibilityEvent.getScrollDeltaX();
+ mDeltaY += accessibilityEvent.getScrollDeltaY();
+ accessibilityEvent.setScrollDeltaX(mDeltaX);
+ accessibilityEvent.setScrollDeltaY(mDeltaY);
+ }
+
+ @Override
+ public void reset() {
+ super.reset();
mDeltaX = 0;
mDeltaY = 0;
}
}
-
/**
- * Remove the pending callback for sending a
- * {@link AccessibilityEvent#TYPE_VIEW_SCROLLED} accessibility event.
+ * Remove the pending callback for sending a throttled accessibility event.
*/
@UnsupportedAppUsage
- private void cancel(@Nullable SendViewScrolledAccessibilityEvent callback) {
+ private void cancel(@Nullable SendAccessibilityEventThrottle callback) {
if (callback == null || !callback.mIsPending) return;
removeCallbacks(callback);
callback.reset();
diff --git a/core/java/android/view/WindowManagerGlobal.java b/core/java/android/view/WindowManagerGlobal.java
index ccfbd7e..d39c3c0 100644
--- a/core/java/android/view/WindowManagerGlobal.java
+++ b/core/java/android/view/WindowManagerGlobal.java
@@ -29,6 +29,7 @@
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemProperties;
+import android.provider.DeviceConfig;
import android.util.AndroidRuntimeException;
import android.util.ArraySet;
import android.util.Log;
@@ -56,11 +57,16 @@
public final class WindowManagerGlobal {
private static final String TAG = "WindowManager";
+ private static final String WM_USE_BLAST_ADAPTER_FLAG = "wm_use_blast_adapter";
+
/**
* This flag controls whether ViewRootImpl will utilize the Blast Adapter
* to send buffer updates to SurfaceFlinger
*/
- public static final boolean USE_BLAST_ADAPTER = false;
+ public static final boolean USE_BLAST_ADAPTER =
+ SystemProperties.getBoolean(String.join(".", "persist.device_config",
+ DeviceConfig.NAMESPACE_WINDOW_MANAGER_NATIVE_BOOT,
+ WM_USE_BLAST_ADAPTER_FLAG), false);
/**
* The user is navigating with keys (not the touch screen), so
diff --git a/core/java/android/widget/Toast.java b/core/java/android/widget/Toast.java
index 4e705db..969bda9 100644
--- a/core/java/android/widget/Toast.java
+++ b/core/java/android/widget/Toast.java
@@ -29,6 +29,7 @@
import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.PixelFormat;
+import android.os.Binder;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
@@ -104,7 +105,8 @@
*/
public static final int LENGTH_LONG = 1;
- final Context mContext;
+ private final Binder mToken;
+ private final Context mContext;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
final TN mTN;
@UnsupportedAppUsage
@@ -130,7 +132,8 @@
*/
public Toast(@NonNull Context context, @Nullable Looper looper) {
mContext = context;
- mTN = new TN(context.getPackageName(), looper);
+ mToken = new Binder();
+ mTN = new TN(context.getPackageName(), mToken, looper);
mTN.mY = context.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.toast_y_offset);
mTN.mGravity = context.getResources().getInteger(
@@ -153,9 +156,9 @@
try {
if (mIsCustomToast) {
- service.enqueueToast(pkg, tn, mDuration, displayId);
+ service.enqueueToast(pkg, mToken, tn, mDuration, displayId);
} else {
- service.enqueueTextToast(pkg, tn, mDuration, displayId);
+ service.enqueueTextToast(pkg, mToken, tn, mDuration, displayId);
}
} catch (RemoteException e) {
// Empty
@@ -435,7 +438,8 @@
WindowManager mWM;
- String mPackageName;
+ final String mPackageName;
+ final Binder mToken;
@GuardedBy("mCallbacks")
private final List<Callback> mCallbacks = new ArrayList<>();
@@ -443,7 +447,7 @@
static final long SHORT_DURATION_TIMEOUT = 4000;
static final long LONG_DURATION_TIMEOUT = 7000;
- TN(String packageName, @Nullable Looper looper) {
+ TN(String packageName, Binder token, @Nullable Looper looper) {
// XXX This should be changed to use a Dialog, with a Theme.Toast
// defined that sets up the layout params appropriately.
final WindowManager.LayoutParams params = mParams;
@@ -459,6 +463,7 @@
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
mPackageName = packageName;
+ mToken = token;
if (looper == null) {
// Use Looper.myLooper() if looper is not specified.
@@ -490,7 +495,7 @@
// handleShow()
mNextView = null;
try {
- getService().cancelToast(mPackageName, TN.this);
+ getService().cancelToast(mPackageName, mToken);
} catch (RemoteException e) {
}
break;
@@ -620,7 +625,7 @@
// Now that we've removed the view it's safe for the server to release
// the resources.
try {
- getService().finishToken(mPackageName, this);
+ getService().finishToken(mPackageName, mToken);
} catch (RemoteException e) {
}
diff --git a/core/jni/android_view_SurfaceControl.cpp b/core/jni/android_view_SurfaceControl.cpp
index 50a60a9..e0f9571 100644
--- a/core/jni/android_view_SurfaceControl.cpp
+++ b/core/jni/android_view_SurfaceControl.cpp
@@ -560,6 +560,14 @@
transaction->setCornerRadius(ctrl, cornerRadius);
}
+static void nativeSetBackgroundBlurRadius(JNIEnv* env, jclass clazz, jlong transactionObj,
+ jlong nativeObject, jint blurRadius) {
+ auto transaction = reinterpret_cast<SurfaceComposerClient::Transaction*>(transactionObj);
+
+ SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject);
+ transaction->setBackgroundBlurRadius(ctrl, blurRadius);
+}
+
static void nativeSetLayerStack(JNIEnv* env, jclass clazz, jlong transactionObj,
jlong nativeObject, jint layerStack) {
auto transaction = reinterpret_cast<SurfaceComposerClient::Transaction*>(transactionObj);
@@ -1369,6 +1377,8 @@
(void*)nativeSetWindowCrop },
{"nativeSetCornerRadius", "(JJF)V",
(void*)nativeSetCornerRadius },
+ {"nativeSetBackgroundBlurRadius", "(JJI)V",
+ (void*)nativeSetBackgroundBlurRadius },
{"nativeSetLayerStack", "(JJI)V",
(void*)nativeSetLayerStack },
{"nativeSetShadowRadius", "(JJF)V",
diff --git a/core/jni/com_android_internal_os_Zygote.cpp b/core/jni/com_android_internal_os_Zygote.cpp
index 2535fcf..4b969ec 100644
--- a/core/jni/com_android_internal_os_Zygote.cpp
+++ b/core/jni/com_android_internal_os_Zygote.cpp
@@ -1514,22 +1514,16 @@
DropCapabilitiesBoundingSet(fail_fn);
- bool use_native_bridge = !is_system_server &&
- instruction_set.has_value() &&
- android::NativeBridgeAvailable() &&
- android::NeedsNativeBridge(instruction_set.value().c_str());
+ bool need_pre_initialize_native_bridge =
+ !is_system_server &&
+ instruction_set.has_value() &&
+ android::NativeBridgeAvailable() &&
+ // Native bridge may be already initialized if this
+ // is an app forked from app-zygote.
+ !android::NativeBridgeInitialized() &&
+ android::NeedsNativeBridge(instruction_set.value().c_str());
- if (use_native_bridge && !app_data_dir.has_value()) {
- // The app_data_dir variable should never be empty if we need to use a
- // native bridge. In general, app_data_dir will never be empty for normal
- // applications. It can only happen in special cases (for isolated
- // processes which are not associated with any app). These are launched by
- // the framework and should not be emulated anyway.
- use_native_bridge = false;
- ALOGW("Native bridge will not be used because managed_app_data_dir == nullptr.");
- }
-
- MountEmulatedStorage(uid, mount_external, use_native_bridge, fail_fn);
+ MountEmulatedStorage(uid, mount_external, need_pre_initialize_native_bridge, fail_fn);
// System services, isolated process, webview/app zygote, old target sdk app, should
// give a null in same_uid_pkgs and private_volumes so they don't need app data isolation.
@@ -1555,11 +1549,12 @@
SetGids(env, gids, fail_fn);
SetRLimits(env, rlimits, fail_fn);
- if (use_native_bridge) {
- // Due to the logic behind use_native_bridge we know that both app_data_dir
- // and instruction_set contain values.
- android::PreInitializeNativeBridge(app_data_dir.value().c_str(),
- instruction_set.value().c_str());
+ if (need_pre_initialize_native_bridge) {
+ // Due to the logic behind need_pre_initialize_native_bridge we know that
+ // instruction_set contains a value.
+ android::PreInitializeNativeBridge(
+ app_data_dir.has_value() ? app_data_dir.value().c_str() : nullptr,
+ instruction_set.value().c_str());
}
if (setresgid(gid, gid, gid) == -1) {
diff --git a/core/proto/android/app/settings_enums.proto b/core/proto/android/app/settings_enums.proto
index a85c8f4..ce03727 100644
--- a/core/proto/android/app/settings_enums.proto
+++ b/core/proto/android/app/settings_enums.proto
@@ -2562,4 +2562,10 @@
// CATEGORY: SETTINGS
// OS: R
OPEN_SUPPORTED_LINKS = 1824;
+
+ // OPEN: Settings > Display > Dark theme > Set start time dialog
+ DIALOG_DARK_THEME_SET_START_TIME = 1825;
+
+ // OPEN: Settings > Display > Dark theme > Set end time dialog
+ DIALOG_DARK_THEME_SET_END_TIME = 1826;
}
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index 11f9909..da2e078 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -2091,6 +2091,11 @@
<permission android:name="android.permission.READ_ACTIVE_EMERGENCY_SESSION"
android:protectionLevel="signature" />
+ <!-- @SystemApi Allows listen permission to always reported signal strength.
+ @hide Used internally. -->
+ <permission android:name="android.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH"
+ android:protectionLevel="signature|telephony" />
+
<!-- @SystemApi Protects the ability to register any PhoneAccount with
PhoneAccount#CAPABILITY_SIM_SUBSCRIPTION. This capability indicates that the PhoneAccount
corresponds to a device SIM.
@@ -2211,12 +2216,12 @@
<!-- Must be required by a NetworkService to ensure that only the
system can bind to it.
- <p>Protection level: signature
+ <p>Protection level: signature|telephony
@SystemApi
@hide
-->
<permission android:name="android.permission.BIND_TELEPHONY_NETWORK_SERVICE"
- android:protectionLevel="signature" />
+ android:protectionLevel="signature|telephony" />
<!-- @SystemApi Allows an application to manage embedded subscriptions (those on a eUICC)
through EuiccManager APIs.
diff --git a/core/res/res/drawable-nodpi/platlogo.xml b/core/res/res/drawable-nodpi/platlogo.xml
index 19a296a..46e8f64 100644
--- a/core/res/res/drawable-nodpi/platlogo.xml
+++ b/core/res/res/drawable-nodpi/platlogo.xml
@@ -1,5 +1,5 @@
<!--
-Copyright (C) 2015 The Android Open Source Project
+Copyright (C) 2020 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.
@@ -14,14 +14,18 @@
limitations under the License.
-->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
- android:width="24dp"
- android:height="24dp"
- android:viewportWidth="24.0"
- android:viewportHeight="24.0">
+ android:width="240dp"
+ android:height="240dp"
+ android:viewportWidth="24"
+ android:viewportHeight="24">
<path
- android:fillColor="#FF000000"
- android:pathData="M19.45,22.89l-10.250001,-10.249999l-2.6599998,2.6599998l-1.77,-1.7600002l4.43,-4.4300003l12.0199995,12.0199995l-1.7699986,1.7600002z"/>
+ android:fillColor="#000"
+ android:pathData="M16 4c-2.2 0-4 1.8-4 4v4H4V8c0-2.2 1.8-4 4-4h8z"/>
<path
- android:fillColor="#FF000000"
- android:pathData="M12,6a6,6 0,1 1,-6 6,6 6,0 0,1 6,-6m0,-2.5A8.5,8.5 0,1 0,20.5 12,8.51 8.51,0 0,0 12,3.5Z"/>
+ android:fillColor="#000"
+ android:pathData="M8 20c2.2 0 4-1.8 4-4v-4H4v8h4z"/>
+ <path
+ android:fillColor="#80000000"
+ android:pathData="M16 12c2.2 0 4-1.8 4-4V4h-8v8h4z"/>
</vector>
+
diff --git a/core/res/res/drawable-nodpi/stat_sys_adb.xml b/core/res/res/drawable-nodpi/stat_sys_adb.xml
index 08e9fad..0e9aab2 100644
--- a/core/res/res/drawable-nodpi/stat_sys_adb.xml
+++ b/core/res/res/drawable-nodpi/stat_sys_adb.xml
@@ -1,5 +1,5 @@
<!--
-Copyright (C) 2019 The Android Open Source Project
+Copyright (C) 2020 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.
@@ -14,17 +14,17 @@
limitations under the License.
-->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
- android:width="24dp"
- android:height="24dp"
- android:viewportWidth="24.0"
- android:viewportHeight="24.0">
+ android:width="24dp"
+ android:height="24dp"
+ android:viewportWidth="24"
+ android:viewportHeight="24">
<path
- android:fillColor="#FF000000"
- android:pathData="M16.28,16.19A6,6 0,1 0,6 12c0,0.1 0,0.19 0,0.29L9.2,9.11Z"/>
+ android:fillColor="#000"
+ android:pathData="M16 4c-2.2 0-4 1.8-4 4v4H4V8c0-2.2 1.8-4 4-4h8z"/>
<path
- android:fillColor="#FF000000"
- android:pathData="M16,19.48a8.57,8.57 0,1 1,2 -1.52l1.77,1.77a11.07,11.07 0,1 0,-2 1.57Z"/>
+ android:fillColor="#000"
+ android:pathData="M8 20c2.2 0 4-1.8 4-4v-4H4v8h4z"/>
<path
- android:fillColor="#FF000000"
- android:pathData="M12,18a5.77,5.77 0,0 0,2 -0.34l0.19,-0.07 -0.87,-0.87L9.2,12.64 6.82,15A6,6 0,0 0,12 18Z"/>
+ android:fillColor="#80000000"
+ android:pathData="M16 12c2.2 0 4-1.8 4-4V4h-8v8h4z"/>
</vector>
diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml
index 0c01e87..7fd444a 100644
--- a/core/res/res/values/config.xml
+++ b/core/res/res/values/config.xml
@@ -281,6 +281,10 @@
before automatically restore the default connection. Set -1 if the connection
does not require auto-restore. -->
<!-- the 6th element indicates boot-time dependency-met value. -->
+ <!-- NOTE: The telephony module is no longer reading the configuration below for available
+ APN types. The set of APN types and relevant settings are specified within the telephony
+ module and are non-configurable. Whether or not data connectivity over a cellular network
+ is available at all is controlled by the flag: config_moble_data_capable. -->
<string-array translatable="false" name="networkAttributes">
<item>"wifi,1,1,1,-1,true"</item>
<item>"mobile,0,0,0,-1,true"</item>
@@ -1867,6 +1871,12 @@
Note: This config is deprecated, please use config_defaultSms instead. -->
<string name="default_sms_application" translatable="false">com.android.messaging</string>
+ <!-- Flag indicating whether the current device allows data.
+ If true, this means that the device supports data connectivity through
+ the telephony network.
+ This can be overridden to false for devices that support voice and/or sms . -->
+ <bool name="config_mobile_data_capable">true</bool>
+
<!-- Default web browser. This is the package name of the application that will
be the default browser when the device first boots. Afterwards the user
can select whatever browser app they wish to use as the default.
diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml
index 28b0feac..527798d 100644
--- a/core/res/res/values/symbols.xml
+++ b/core/res/res/values/symbols.xml
@@ -310,6 +310,7 @@
<java-symbol type="bool" name="config_sip_wifi_only" />
<java-symbol type="bool" name="config_sms_capable" />
<java-symbol type="bool" name="config_sms_utf8_support" />
+ <java-symbol type="bool" name="config_mobile_data_capable" />
<java-symbol type="bool" name="config_suspendWhenScreenOffDueToProximity" />
<java-symbol type="bool" name="config_swipeDisambiguation" />
<java-symbol type="bool" name="config_syncstorageengine_masterSyncAutomatically" />
diff --git a/core/tests/coretests/src/android/app/NotificationHistoryTest.java b/core/tests/coretests/src/android/app/NotificationHistoryTest.java
index f9a6a5c..0a21875 100644
--- a/core/tests/coretests/src/android/app/NotificationHistoryTest.java
+++ b/core/tests/coretests/src/android/app/NotificationHistoryTest.java
@@ -116,25 +116,28 @@
@Test
public void testAddNotificationsToWrite() {
NotificationHistory history = new NotificationHistory();
- HistoricalNotification n = getHistoricalNotification(0);
+ HistoricalNotification n = getHistoricalNotification(3);
HistoricalNotification n2 = getHistoricalNotification(1);
+ HistoricalNotification n5 = getHistoricalNotification(0);
history.addNotificationToWrite(n2);
history.addNotificationToWrite(n);
+ history.addNotificationToWrite(n5);
NotificationHistory secondHistory = new NotificationHistory();
- HistoricalNotification n3 = getHistoricalNotification(2);
- HistoricalNotification n4 = getHistoricalNotification(3);
+ HistoricalNotification n3 = getHistoricalNotification(4);
+ HistoricalNotification n4 = getHistoricalNotification(2);
secondHistory.addNotificationToWrite(n4);
secondHistory.addNotificationToWrite(n3);
history.addNotificationsToWrite(secondHistory);
- assertThat(history.getNotificationsToWrite().size()).isEqualTo(4);
- assertThat(history.getNotificationsToWrite().get(0)).isSameAs(n2);
+ assertThat(history.getNotificationsToWrite().size()).isEqualTo(5);
+ assertThat(history.getNotificationsToWrite().get(0)).isSameAs(n3);
assertThat(history.getNotificationsToWrite().get(1)).isSameAs(n);
assertThat(history.getNotificationsToWrite().get(2)).isSameAs(n4);
- assertThat(history.getNotificationsToWrite().get(3)).isSameAs(n3);
- assertThat(history.getHistoryCount()).isEqualTo(4);
+ assertThat(history.getNotificationsToWrite().get(3)).isSameAs(n2);
+ assertThat(history.getNotificationsToWrite().get(4)).isSameAs(n5);
+ assertThat(history.getHistoryCount()).isEqualTo(5);
assertThat(history.getPooledStringsToWrite()).asList().contains(n2.getChannelName());
assertThat(history.getPooledStringsToWrite()).asList().contains(n4.getPackage());
diff --git a/core/tests/overlaytests/host/Android.bp b/core/tests/overlaytests/host/Android.bp
new file mode 100644
index 0000000..a2fcef5
--- /dev/null
+++ b/core/tests/overlaytests/host/Android.bp
@@ -0,0 +1,30 @@
+// 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.
+
+java_test_host {
+ name: "OverlayHostTests",
+ srcs: ["src/**/*.java"],
+ libs: ["tradefed"],
+ test_suites: ["general-tests"],
+ target_required: [
+ "OverlayHostTests_NonPlatformSignatureOverlay",
+ "OverlayHostTests_PlatformSignatureStaticOverlay",
+ "OverlayHostTests_PlatformSignatureOverlay",
+ "OverlayHostTests_UpdateOverlay",
+ "OverlayHostTests_FrameworkOverlayV1",
+ "OverlayHostTests_FrameworkOverlayV2",
+ "OverlayHostTests_AppOverlayV1",
+ "OverlayHostTests_AppOverlayV2",
+ ],
+}
diff --git a/core/tests/overlaytests/host/Android.mk b/core/tests/overlaytests/host/Android.mk
index e7348d5..d58d939 100644
--- a/core/tests/overlaytests/host/Android.mk
+++ b/core/tests/overlaytests/host/Android.mk
@@ -14,23 +14,6 @@
LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := $(call all-java-files-under,src)
-LOCAL_MODULE_TAGS := tests
-LOCAL_MODULE := OverlayHostTests
-LOCAL_JAVA_LIBRARIES := tradefed
-LOCAL_COMPATIBILITY_SUITE := general-tests
-LOCAL_TARGET_REQUIRED_MODULES := \
- OverlayHostTests_NonPlatformSignatureOverlay \
- OverlayHostTests_PlatformSignatureStaticOverlay \
- OverlayHostTests_PlatformSignatureOverlay \
- OverlayHostTests_UpdateOverlay \
- OverlayHostTests_FrameworkOverlayV1 \
- OverlayHostTests_FrameworkOverlayV2 \
- OverlayHostTests_AppOverlayV1 \
- OverlayHostTests_AppOverlayV2
-include $(BUILD_HOST_JAVA_LIBRARY)
-
# Include to build test-apps.
include $(call all-makefiles-under,$(LOCAL_PATH))
diff --git a/packages/SystemUI/res/drawable/action_chip_background.xml b/packages/SystemUI/res/drawable/action_chip_background.xml
index fc3dfeb..ac227a6 100644
--- a/packages/SystemUI/res/drawable/action_chip_background.xml
+++ b/packages/SystemUI/res/drawable/action_chip_background.xml
@@ -19,7 +19,7 @@
android:color="@color/global_screenshot_button_ripple">
<item android:id="@android:id/background">
<shape android:shape="rectangle">
- <stroke android:width="1dp" android:color="@color/global_screenshot_button_text"/>
+ <stroke android:width="1dp" android:color="@color/global_screenshot_button_border"/>
<solid android:color="@color/global_screenshot_button_background"/>
<corners android:radius="@dimen/screenshot_button_corner_radius"/>
</shape>
diff --git a/packages/SystemUI/res/drawable/ic_arrow_downward.xml b/packages/SystemUI/res/drawable/ic_arrow_downward.xml
new file mode 100644
index 0000000..ddd075d
--- /dev/null
+++ b/packages/SystemUI/res/drawable/ic_arrow_downward.xml
@@ -0,0 +1,25 @@
+<!--
+ ~ Copyright (C) 2020 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.
+ -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+ android:width="24dp"
+ android:height="24dp"
+ android:viewportWidth="24.0"
+ android:viewportHeight="24.0"
+ android:tint="?attr/colorControlNormal">
+ <path
+ android:pathData="M20,12l-1.41,-1.41L13,16.17V4h-2v12.17l-5.58,-5.59L4,12l8,8 8,-8z"
+ android:fillColor="@android:color/white"/>
+</vector>
diff --git a/packages/SystemUI/res/drawable/screenshot_actions_background_protection.xml b/packages/SystemUI/res/drawable/screenshot_actions_background_protection.xml
new file mode 100644
index 0000000..163015b7
--- /dev/null
+++ b/packages/SystemUI/res/drawable/screenshot_actions_background_protection.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 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.
+ -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+ <gradient
+ android:angle="90"
+ android:startColor="#1f000000"
+ android:endColor="#00000000"/>
+</shape>
\ No newline at end of file
diff --git a/packages/SystemUI/res/drawable/screenshot_rounded_corners.xml b/packages/SystemUI/res/drawable/screenshot_rounded_corners.xml
new file mode 100644
index 0000000..fb8e9b7
--- /dev/null
+++ b/packages/SystemUI/res/drawable/screenshot_rounded_corners.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ ~ Copyright (C) 2020 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.
+ -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+ android:shape="rectangle">
+ <corners android:radius="@dimen/screenshot_button_corner_radius"/>
+</shape>
diff --git a/packages/SystemUI/res/layout/bubble_flyout.xml b/packages/SystemUI/res/layout/bubble_flyout.xml
index 5f773f4..7ab0a0c 100644
--- a/packages/SystemUI/res/layout/bubble_flyout.xml
+++ b/packages/SystemUI/res/layout/bubble_flyout.xml
@@ -15,25 +15,50 @@
-->
<merge xmlns:android="http://schemas.android.com/apk/res/android">
- <FrameLayout
+ <LinearLayout
android:id="@+id/bubble_flyout_text_container"
android:layout_height="wrap_content"
android:layout_width="wrap_content"
+ android:orientation="horizontal"
android:clipToPadding="false"
- android:paddingLeft="@dimen/bubble_flyout_padding_x"
- android:paddingRight="@dimen/bubble_flyout_padding_x"
+ android:clipChildren="false"
+ android:paddingStart="@dimen/bubble_flyout_padding_x"
+ android:paddingEnd="@dimen/bubble_flyout_padding_x"
android:paddingTop="@dimen/bubble_flyout_padding_y"
android:paddingBottom="@dimen/bubble_flyout_padding_y"
android:translationZ="@dimen/bubble_flyout_elevation">
- <TextView
- android:id="@+id/bubble_flyout_text"
+ <ImageView
+ android:id="@+id/bubble_flyout_avatar"
+ android:layout_width="30dp"
+ android:layout_height="30dp"
+ android:layout_marginEnd="@dimen/bubble_flyout_avatar_message_space"
+ android:scaleType="centerInside"
+ android:src="@drawable/ic_create_bubble"/>
+
+ <LinearLayout
android:layout_width="wrap_content"
android:layout_height="wrap_content"
- android:fontFamily="@*android:string/config_bodyFontFamily"
- android:maxLines="2"
- android:textAppearance="@*android:style/TextAppearance.DeviceDefault.Body2"/>
+ android:orientation="vertical">
- </FrameLayout>
+ <TextView
+ android:id="@+id/bubble_flyout_name"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:fontFamily="@*android:string/config_bodyFontFamilyMedium"
+ android:maxLines="1"
+ android:textAppearance="@*android:style/TextAppearance.DeviceDefault.Body2"/>
+
+ <TextView
+ android:id="@+id/bubble_flyout_text"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:fontFamily="@*android:string/config_bodyFontFamily"
+ android:maxLines="2"
+ android:textAppearance="@*android:style/TextAppearance.DeviceDefault.Body2"/>
+
+ </LinearLayout>
+
+ </LinearLayout>
</merge>
\ No newline at end of file
diff --git a/packages/SystemUI/res/layout/global_screenshot.xml b/packages/SystemUI/res/layout/global_screenshot.xml
index 995cb7d..1f7def2 100644
--- a/packages/SystemUI/res/layout/global_screenshot.xml
+++ b/packages/SystemUI/res/layout/global_screenshot.xml
@@ -1,51 +1,75 @@
<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2020 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.
--->
+<!--
+ ~ Copyright (C) 2011 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.
+ -->
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
- android:layout_width="match_parent"
- android:layout_height="match_parent">
- <ImageView android:id="@+id/global_screenshot_background"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+ <ImageView
+ android:id="@+id/global_screenshot_background"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:src="@android:color/black"
- android:visibility="gone" />
- <ImageView android:id="@+id/global_screenshot"
+ android:visibility="gone"/>
+ <ImageView
+ android:id="@+id/global_screenshot_actions_background"
+ android:layout_height="400dp"
+ android:layout_width="match_parent"
+ android:layout_gravity="bottom|center"
+ android:src="@drawable/screenshot_actions_background_protection"
+ android:alpha="0"/>
+ <HorizontalScrollView
+ android:id="@+id/global_screenshot_actions_container"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:layout_gravity="bottom|center"
+ android:elevation="3dp"
+ android:fillViewport="true"
+ android:layout_marginHorizontal="@dimen/screenshot_action_container_margin_horizontal"
+ android:gravity="center"
+ android:paddingLeft="@dimen/screenshot_action_container_padding_left"
+ android:paddingRight="@dimen/screenshot_action_container_padding_right"
+ android:paddingVertical="@dimen/screenshot_action_container_padding_vertical"
+ android:visibility="gone"
+ android:scrollbars="none"
+ android:background="@drawable/action_chip_container_background">
+ <LinearLayout
+ android:id="@+id/global_screenshot_actions"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"/>
+ </HorizontalScrollView>
+ <ImageView
+ android:id="@+id/global_screenshot"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center"
- android:background="@drawable/screenshot_panel"
+ android:elevation="8dp"
android:visibility="gone"
- android:adjustViewBounds="true" />
- <ImageView android:id="@+id/global_screenshot_flash"
+ android:background="@drawable/screenshot_rounded_corners"
+ android:adjustViewBounds="true"/>
+ <ImageView
+ android:id="@+id/global_screenshot_flash"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:src="@android:color/white"
- android:visibility="gone" />
+ android:visibility="gone"/>
<com.android.systemui.screenshot.ScreenshotSelectorView
android:id="@+id/global_screenshot_selector"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:visibility="gone"
android:pointerIcon="crosshair"/>
- <LinearLayout
- android:id="@+id/global_screenshot_actions"
- android:layout_width="match_parent"
- android:layout_height="wrap_content"
- android:layout_gravity="bottom|center"
- android:gravity="center"
- android:paddingVertical="@dimen/screenshot_action_container_padding"
- android:visibility="gone"
- android:background="@drawable/action_chip_container_background"/>
+
</FrameLayout>
diff --git a/packages/SystemUI/res/layout/global_screenshot_action_chip.xml b/packages/SystemUI/res/layout/global_screenshot_action_chip.xml
index 366abaa..79867a16b 100644
--- a/packages/SystemUI/res/layout/global_screenshot_action_chip.xml
+++ b/packages/SystemUI/res/layout/global_screenshot_action_chip.xml
@@ -36,5 +36,6 @@
android:layout_height="wrap_content"
android:layout_marginEnd="@dimen/screenshot_action_chip_padding_end"
android:textSize="@dimen/screenshot_action_chip_text_size"
+ android:textStyle="bold"
android:textColor="@color/global_screenshot_button_text"/>
</com.android.systemui.screenshot.ScreenshotActionChip>
diff --git a/packages/SystemUI/res/layout/notification_conversation_info.xml b/packages/SystemUI/res/layout/notification_conversation_info.xml
index 8749b1a..a9d6e35 100644
--- a/packages/SystemUI/res/layout/notification_conversation_info.xml
+++ b/packages/SystemUI/res/layout/notification_conversation_info.xml
@@ -67,11 +67,13 @@
android:layout_height="wrap_content"
android:layout_centerVertical="true"
style="@style/TextAppearance.NotificationImportanceHeader"
+ android:visibility="gone"
android:layout_marginStart="2dp"
android:layout_marginEnd="2dp"
android:text="@*android:string/notification_header_divider_symbol" />
<TextView
android:id="@+id/name"
+ android:visibility="gone"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="1"
diff --git a/packages/SystemUI/res/values/colors.xml b/packages/SystemUI/res/values/colors.xml
index c142465..8dd2a8b 100644
--- a/packages/SystemUI/res/values/colors.xml
+++ b/packages/SystemUI/res/values/colors.xml
@@ -182,8 +182,10 @@
<!-- Global screenshot actions -->
<color name="global_screenshot_button_background">#F5F5F5</color>
+ <color name="global_screenshot_button_text">#000000</color>
+ <color name="global_screenshot_button_border">@color/GM2_grey_300</color>
<color name="global_screenshot_button_ripple">#1f000000</color>
- <color name="global_screenshot_button_text">@color/GM2_blue_500</color>
+ <color name="global_screenshot_button_icon">@color/GM2_blue_500</color>
<!-- GM2 colors -->
<color name="GM2_grey_50">#F8F9FA</color>
diff --git a/packages/SystemUI/res/values/dimens.xml b/packages/SystemUI/res/values/dimens.xml
index 53df025..65ca9f2 100644
--- a/packages/SystemUI/res/values/dimens.xml
+++ b/packages/SystemUI/res/values/dimens.xml
@@ -295,17 +295,24 @@
<!-- The padding on the global screenshot background image -->
<dimen name="global_screenshot_legacy_bg_padding">20dp</dimen>
<dimen name="global_screenshot_bg_padding">20dp</dimen>
+ <dimen name="global_screenshot_x_scale">80dp</dimen>
+ <dimen name="screenshot_offset_y">48dp</dimen>
+ <dimen name="screenshot_offset_x">16dp</dimen>
+ <dimen name="screenshot_action_container_offset_y">32dp</dimen>
<dimen name="screenshot_action_container_corner_radius">10dp</dimen>
- <dimen name="screenshot_action_container_padding">10dp</dimen>
+ <dimen name="screenshot_action_container_padding_vertical">10dp</dimen>
+ <dimen name="screenshot_action_container_margin_horizontal">8dp</dimen>
+ <dimen name="screenshot_action_container_padding_left">100dp</dimen>
+ <dimen name="screenshot_action_container_padding_right">8dp</dimen>
<!-- Radius of the chip background on global screenshot actions -->
<dimen name="screenshot_button_corner_radius">20dp</dimen>
<dimen name="screenshot_action_chip_margin_horizontal">4dp</dimen>
<dimen name="screenshot_action_chip_padding_vertical">10dp</dimen>
<dimen name="screenshot_action_chip_icon_size">20dp</dimen>
- <dimen name="screenshot_action_chip_padding_start">4dp</dimen>
+ <dimen name="screenshot_action_chip_padding_start">8dp</dimen>
<!-- Padding between icon and text -->
<dimen name="screenshot_action_chip_padding_middle">8dp</dimen>
- <dimen name="screenshot_action_chip_padding_end">12dp</dimen>
+ <dimen name="screenshot_action_chip_padding_end">16dp</dimen>
<dimen name="screenshot_action_chip_text_size">14sp</dimen>
@@ -1079,6 +1086,10 @@
<dimen name="logout_button_margin_bottom">12dp</dimen>
<dimen name="logout_button_corner_radius">2dp</dimen>
+ <!-- Blur radius on status bar window and power menu -->
+ <dimen name="min_window_blur_radius">1px</dimen>
+ <dimen name="max_window_blur_radius">100px</dimen>
+
<!-- How much into a DisplayCutout's bounds we can go, on each side -->
<dimen name="display_cutout_margin_consumption">0px</dimen>
<!-- How much each bubble is elevated. -->
@@ -1086,13 +1097,15 @@
<!-- How much the bubble flyout text container is elevated. -->
<dimen name="bubble_flyout_elevation">4dp</dimen>
<!-- How much padding is around the left and right sides of the flyout text. -->
- <dimen name="bubble_flyout_padding_x">16dp</dimen>
+ <dimen name="bubble_flyout_padding_x">12dp</dimen>
<!-- How much padding is around the top and bottom of the flyout text. -->
- <dimen name="bubble_flyout_padding_y">8dp</dimen>
+ <dimen name="bubble_flyout_padding_y">10dp</dimen>
<!-- Size of the triangle that points from the flyout to the bubble stack. -->
<dimen name="bubble_flyout_pointer_size">6dp</dimen>
<!-- How much space to leave between the flyout (tip of the arrow) and the bubble stack. -->
<dimen name="bubble_flyout_space_from_bubble">8dp</dimen>
+ <!-- How much space to leave between the flyout text and the avatar displayed in the flyout. -->
+ <dimen name="bubble_flyout_avatar_message_space">6dp</dimen>
<!-- Padding between status bar and bubbles when displayed in expanded state -->
<dimen name="bubble_padding_top">16dp</dimen>
<!-- Size of individual bubbles. -->
diff --git a/packages/SystemUI/res/values/strings.xml b/packages/SystemUI/res/values/strings.xml
index 9129938..639005b 100644
--- a/packages/SystemUI/res/values/strings.xml
+++ b/packages/SystemUI/res/values/strings.xml
@@ -920,6 +920,10 @@
<string name="quick_settings_dark_mode_secondary_label_on_at_sunset">On at sunset</string>
<!-- QuickSettings: Secondary text for when the Dark Mode will be on until sunrise. [CHAR LIMIT=20] -->
<string name="quick_settings_dark_mode_secondary_label_until_sunrise">Until sunrise</string>
+ <!-- QuickSettings: Secondary text for when the Dark theme will be enabled at some user-selected time. [CHAR LIMIT=20] -->
+ <string name="quick_settings_dark_mode_secondary_label_on_at">On at <xliff:g id="time" example="10 pm">%s</xliff:g></string>
+ <!-- QuickSettings: Secondary text for when the Dark theme or some other tile will be on until some user-selected time. [CHAR LIMIT=20] -->
+ <string name="quick_settings_dark_mode_secondary_label_until">Until <xliff:g id="time" example="7 am">%s</xliff:g></string>
<!-- QuickSettings: NFC tile [CHAR LIMIT=NONE] -->
<string name="quick_settings_nfc_label">NFC</string>
diff --git a/packages/SystemUI/scripts/update_shared_lib.sh b/packages/SystemUI/scripts/update_shared_lib.sh
index 0537493..25f723f 100755
--- a/packages/SystemUI/scripts/update_shared_lib.sh
+++ b/packages/SystemUI/scripts/update_shared_lib.sh
@@ -1,6 +1,7 @@
#!/bin/sh
NUM_ARGS=$#
+JAR_DESTINATION="$1/prebuilts/framework_intermediates/quickstep/libs/sysui_shared.jar"
has_croot() {
declare -F croot > /dev/null
@@ -25,7 +26,6 @@
pushd .
croot
mma -j16 SystemUISharedLib
- JAR_DESTINATION="$1/prebuilts/framework_intermediates/quickstep/libs/sysui_shared.jar"
cp out/target/product/$TARGET_PRODUCT/obj/JAVA_LIBRARIES/SystemUISharedLib_intermediates/javalib.jar $JAR_DESTINATION
popd
fi
diff --git a/packages/SystemUI/shared/Android.bp b/packages/SystemUI/shared/Android.bp
index 4471818..fe6e44b 100644
--- a/packages/SystemUI/shared/Android.bp
+++ b/packages/SystemUI/shared/Android.bp
@@ -12,8 +12,22 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-android_library {
+genrule {
+ name: "statslog-SystemUI-java-gen",
+ tools: ["stats-log-api-gen"],
+ cmd: "$(location stats-log-api-gen) --java $(out) --module sysui --javaPackage com.android.systemui.shared.system --javaClass SysUiStatsLog",
+ out: ["com/android/systemui/shared/system/SysUiStatsLog.java"],
+}
+java_library {
+ name: "SystemUI-statsd",
+
+ srcs: [
+ ":statslog-SystemUI-java-gen",
+ ],
+}
+
+android_library {
name: "SystemUISharedLib",
srcs: [
"src/**/*.java",
@@ -21,7 +35,8 @@
],
static_libs: [
- "PluginCoreLib"
+ "PluginCoreLib",
+ "SystemUI-statsd",
],
// Enforce that the library is built against java 7 so that there are
diff --git a/packages/SystemUI/shared/src/com/android/systemui/shared/system/StatsLogCompat.java b/packages/SystemUI/shared/src/com/android/systemui/shared/system/StatsLogCompat.java
deleted file mode 100644
index 59ed111..0000000
--- a/packages/SystemUI/shared/src/com/android/systemui/shared/system/StatsLogCompat.java
+++ /dev/null
@@ -1,51 +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.
- */
-
-package com.android.systemui.shared.system;
-
-import android.util.StatsLog;
-
-/**
- * Wrapper class to make StatsLog hidden API accessible.
- */
-public class StatsLogCompat {
-
- /**
- * StatsLog.write(StatsLog.LAUNCHER_EVENT, int action, int src_state, int dst_state,
- * byte[] extension, boolean is_swipe_up_enabled);
- */
- public static void write(int action, int srcState, int dstState, byte [] extension,
- boolean swipeUpEnabled) {
- StatsLog.write(19, action, srcState, dstState, extension,
- swipeUpEnabled);
- }
-
- /**
- * StatsLog.write(StatsLog.STYLE_EVENT, action, colorPackageHash,
- * fontPackageHash, shapePackageHash, clockPackageHash,
- * launcherGrid, wallpaperCategoryHash, wallpaperIdHash,
- * colorPreference, locationPreference);
- */
- public static void write(int action, int colorPackageHash,
- int fontPackageHash, int shapePackageHash, int clockPackageHash,
- int launcherGrid, int wallpaperCategoryHash, int wallpaperIdHash,
- int colorPreference, int locationPreference) {
- StatsLog.write(179, action, colorPackageHash,
- fontPackageHash, shapePackageHash, clockPackageHash,
- launcherGrid, wallpaperCategoryHash, wallpaperIdHash,
- colorPreference, locationPreference);
- }
-}
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
index 91b22d1..9ae446e 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardSecurityContainer.java
@@ -28,7 +28,6 @@
import android.util.AttributeSet;
import android.util.Log;
import android.util.Slog;
-import android.util.StatsLog;
import android.util.TypedValue;
import android.view.LayoutInflater;
import android.view.MotionEvent;
@@ -50,6 +49,7 @@
import com.android.systemui.Dependency;
import com.android.systemui.R;
import com.android.systemui.SystemUIFactory;
+import com.android.systemui.shared.system.SysUiStatsLog;
import com.android.systemui.statusbar.policy.KeyguardStateController;
import com.android.systemui.util.InjectionInflationController;
@@ -615,8 +615,8 @@
public void reportUnlockAttempt(int userId, boolean success, int timeoutMs) {
if (success) {
- StatsLog.write(StatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED,
- StatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED__RESULT__SUCCESS);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED,
+ SysUiStatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED__RESULT__SUCCESS);
mLockPatternUtils.reportSuccessfulPasswordAttempt(userId);
// Force a garbage collection in an attempt to erase any lockscreen password left in
// memory. Do it asynchronously with a 5-sec delay to avoid making the keyguard
@@ -628,8 +628,8 @@
Runtime.getRuntime().gc();
});
} else {
- StatsLog.write(StatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED,
- StatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED__RESULT__FAILURE);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED,
+ SysUiStatsLog.KEYGUARD_BOUNCER_PASSWORD_ENTERED__RESULT__FAILURE);
KeyguardSecurityContainer.this.reportFailedUnlockAttempt(userId, timeoutMs);
}
mMetricsLogger.write(new LogMaker(MetricsEvent.BOUNCER)
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardSimPinView.java b/packages/SystemUI/src/com/android/keyguard/KeyguardSimPinView.java
index 35a65aa..76adf04 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardSimPinView.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardSimPinView.java
@@ -16,6 +16,7 @@
package com.android.keyguard;
+import android.annotation.NonNull;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
@@ -26,6 +27,7 @@
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Color;
+import android.telephony.PinResult;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
@@ -35,7 +37,6 @@
import android.view.WindowManager;
import android.widget.ImageView;
-import com.android.internal.telephony.PhoneConstants;
import com.android.systemui.Dependency;
import com.android.systemui.R;
@@ -139,11 +140,11 @@
// Sending empty PIN here to query the number of remaining PIN attempts
new CheckSimPin("", mSubId) {
- void onSimCheckResponse(final int result, final int attemptsRemaining) {
- Log.d(LOG_TAG, "onSimCheckResponse " + " dummy One result" + result +
- " attemptsRemaining=" + attemptsRemaining);
- if (attemptsRemaining >= 0) {
- mRemainingAttempts = attemptsRemaining;
+ void onSimCheckResponse(final PinResult result) {
+ Log.d(LOG_TAG, "onSimCheckResponse " + " dummy One result "
+ + result.toString());
+ if (result.getAttemptsRemaining() >= 0) {
+ mRemainingAttempts = result.getAttemptsRemaining();
setLockedSimMessage();
}
}
@@ -251,7 +252,7 @@
mSubId = subId;
}
- abstract void onSimCheckResponse(final int result, final int attemptsRemaining);
+ abstract void onSimCheckResponse(@NonNull PinResult result);
@Override
public void run() {
@@ -261,23 +262,23 @@
TelephonyManager telephonyManager =
((TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE))
.createForSubscriptionId(mSubId);
- final int[] result = telephonyManager.supplyPinReportResult(mPin);
- if (result == null || result.length == 0) {
+ final PinResult result = telephonyManager.supplyPinReportPinResult(mPin);
+ if (result == null) {
Log.e(TAG, "Error result for supplyPinReportResult.");
post(new Runnable() {
@Override
public void run() {
- onSimCheckResponse(PhoneConstants.PIN_GENERAL_FAILURE, -1);
+ onSimCheckResponse(PinResult.getDefaultFailedResult());
}
});
} else {
if (DEBUG) {
- Log.v(TAG, "supplyPinReportResult returned: " + result[0] + " " + result[1]);
+ Log.v(TAG, "supplyPinReportResult returned: " + result.toString());
}
post(new Runnable() {
@Override
public void run() {
- onSimCheckResponse(result[0], result[1]);
+ onSimCheckResponse(result);
}
});
}
@@ -330,17 +331,18 @@
if (mCheckSimPinThread == null) {
mCheckSimPinThread = new CheckSimPin(mPasswordEntry.getText(), mSubId) {
@Override
- void onSimCheckResponse(final int result, final int attemptsRemaining) {
+ void onSimCheckResponse(final PinResult result) {
post(new Runnable() {
@Override
public void run() {
- mRemainingAttempts = attemptsRemaining;
+ mRemainingAttempts = result.getAttemptsRemaining();
if (mSimUnlockProgressDialog != null) {
mSimUnlockProgressDialog.hide();
}
resetPasswordText(true /* animate */,
- result != PhoneConstants.PIN_RESULT_SUCCESS /* announce */);
- if (result == PhoneConstants.PIN_RESULT_SUCCESS) {
+ /* announce */
+ result.getType() != PinResult.PIN_RESULT_TYPE_SUCCESS);
+ if (result.getType() == PinResult.PIN_RESULT_TYPE_SUCCESS) {
Dependency.get(KeyguardUpdateMonitor.class)
.reportSimUnlocked(mSubId);
mRemainingAttempts = -1;
@@ -350,14 +352,16 @@
}
} else {
mShowDefaultMessage = false;
- if (result == PhoneConstants.PIN_PASSWORD_INCORRECT) {
- if (attemptsRemaining <= 2) {
+ if (result.getType() == PinResult.PIN_RESULT_TYPE_INCORRECT) {
+ if (result.getAttemptsRemaining() <= 2) {
// this is getting critical - show dialog
- getSimRemainingAttemptsDialog(attemptsRemaining).show();
+ getSimRemainingAttemptsDialog(
+ result.getAttemptsRemaining()).show();
} else {
// show message
mSecurityMessageDisplay.setMessage(
- getPinPasswordErrorMessage(attemptsRemaining, false));
+ getPinPasswordErrorMessage(
+ result.getAttemptsRemaining(), false));
}
} else {
// "PIN operation failed!" - no idea what this was and no way to
@@ -367,7 +371,7 @@
}
if (DEBUG) Log.d(LOG_TAG, "verifyPasswordAndUnlock "
+ " CheckSimPin.onSimCheckResponse: " + result
- + " attemptsRemaining=" + attemptsRemaining);
+ + " attemptsRemaining=" + result.getAttemptsRemaining());
}
mCallback.userActivity();
mCheckSimPinThread = null;
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardSimPukView.java b/packages/SystemUI/src/com/android/keyguard/KeyguardSimPukView.java
index dc68115..10dcbd6 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardSimPukView.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardSimPukView.java
@@ -16,6 +16,7 @@
package com.android.keyguard;
+import android.annotation.NonNull;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
@@ -25,6 +26,7 @@
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Color;
+import android.telephony.PinResult;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
@@ -34,7 +36,6 @@
import android.view.WindowManager;
import android.widget.ImageView;
-import com.android.internal.telephony.PhoneConstants;
import com.android.systemui.Dependency;
import com.android.systemui.R;
@@ -191,13 +192,16 @@
// Sending empty PUK here to query the number of remaining PIN attempts
new CheckSimPuk("", "", mSubId) {
- void onSimLockChangedResponse(final int result, final int attemptsRemaining) {
- Log.d(LOG_TAG, "onSimCheckResponse " + " dummy One result" + result +
- " attemptsRemaining=" + attemptsRemaining);
- if (attemptsRemaining >= 0) {
- mRemainingAttempts = attemptsRemaining;
- mSecurityMessageDisplay.setMessage(
- getPukPasswordErrorMessage(attemptsRemaining, true));
+ void onSimLockChangedResponse(final PinResult result) {
+ if (result == null) Log.e(LOG_TAG, "onSimCheckResponse, pin result is NULL");
+ else {
+ Log.d(LOG_TAG, "onSimCheckResponse " + " dummy One result "
+ + result.toString());
+ if (result.getAttemptsRemaining() >= 0) {
+ mRemainingAttempts = result.getAttemptsRemaining();
+ mSecurityMessageDisplay.setMessage(
+ getPukPasswordErrorMessage(result.getAttemptsRemaining(), true));
+ }
}
}
}.start();
@@ -311,7 +315,7 @@
mSubId = subId;
}
- abstract void onSimLockChangedResponse(final int result, final int attemptsRemaining);
+ abstract void onSimLockChangedResponse(@NonNull PinResult result);
@Override
public void run() {
@@ -319,23 +323,23 @@
TelephonyManager telephonyManager =
((TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE))
.createForSubscriptionId(mSubId);
- final int[] result = telephonyManager.supplyPukReportResult(mPuk, mPin);
- if (result == null || result.length == 0) {
+ final PinResult result = telephonyManager.supplyPukReportPinResult(mPuk, mPin);
+ if (result == null) {
Log.e(TAG, "Error result for supplyPukReportResult.");
post(new Runnable() {
@Override
public void run() {
- onSimLockChangedResponse(PhoneConstants.PIN_GENERAL_FAILURE, -1);
+ onSimLockChangedResponse(PinResult.getDefaultFailedResult());
}
});
} else {
if (DEBUG) {
- Log.v(TAG, "supplyPukReportResult returned: " + result[0] + " " + result[1]);
+ Log.v(TAG, "supplyPukReportResult returned: " + result.toString());
}
post(new Runnable() {
@Override
public void run() {
- onSimLockChangedResponse(result[0], result[1]);
+ onSimLockChangedResponse(result);
}
});
}
@@ -402,7 +406,7 @@
if (mCheckSimPukThread == null) {
mCheckSimPukThread = new CheckSimPuk(mPukText, mPinText, mSubId) {
@Override
- void onSimLockChangedResponse(final int result, final int attemptsRemaining) {
+ void onSimLockChangedResponse(final PinResult result) {
post(new Runnable() {
@Override
public void run() {
@@ -410,29 +414,32 @@
mSimUnlockProgressDialog.hide();
}
resetPasswordText(true /* animate */,
- result != PhoneConstants.PIN_RESULT_SUCCESS /* announce */);
- if (result == PhoneConstants.PIN_RESULT_SUCCESS) {
+ /* announce */
+ result.getType() != PinResult.PIN_RESULT_TYPE_SUCCESS);
+ if (result.getType() == PinResult.PIN_RESULT_TYPE_SUCCESS) {
Dependency.get(KeyguardUpdateMonitor.class)
.reportSimUnlocked(mSubId);
mRemainingAttempts = -1;
mShowDefaultMessage = true;
if (mCallback != null) {
- mCallback.dismiss(true, KeyguardUpdateMonitor.getCurrentUser());
+ mCallback.dismiss(true,
+ KeyguardUpdateMonitor.getCurrentUser());
}
} else {
mShowDefaultMessage = false;
- if (result == PhoneConstants.PIN_PASSWORD_INCORRECT) {
+ if (result.getType() == PinResult.PIN_RESULT_TYPE_INCORRECT) {
// show message
mSecurityMessageDisplay.setMessage(getPukPasswordErrorMessage(
- attemptsRemaining, false));
- if (attemptsRemaining <= 2) {
+ result.getAttemptsRemaining(), false));
+ if (result.getAttemptsRemaining() <= 2) {
// this is getting critical - show dialog
- getPukRemainingAttemptsDialog(attemptsRemaining).show();
+ getPukRemainingAttemptsDialog(
+ result.getAttemptsRemaining()).show();
} else {
// show message
mSecurityMessageDisplay.setMessage(
getPukPasswordErrorMessage(
- attemptsRemaining, false));
+ result.getAttemptsRemaining(), false));
}
} else {
mSecurityMessageDisplay.setMessage(getContext().getString(
@@ -440,7 +447,7 @@
}
if (DEBUG) Log.d(LOG_TAG, "verifyPasswordAndUnlock "
+ " UpdateSim.onSimCheckResponse: "
- + " attemptsRemaining=" + attemptsRemaining);
+ + " attemptsRemaining=" + result.getAttemptsRemaining());
mStateMachine.reset();
}
mCheckSimPukThread = null;
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/Bubble.java b/packages/SystemUI/src/com/android/systemui/bubbles/Bubble.java
index 77c8e0b..2d9775d 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/Bubble.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/Bubble.java
@@ -32,20 +32,17 @@
import android.content.pm.ShortcutInfo;
import android.content.res.Resources;
import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
import android.os.Bundle;
-import android.os.Parcelable;
import android.os.UserHandle;
import android.provider.Settings;
-import android.text.TextUtils;
import android.util.Log;
import com.android.internal.annotations.VisibleForTesting;
-import com.android.systemui.R;
import com.android.systemui.statusbar.notification.collection.NotificationEntry;
import java.io.FileDescriptor;
import java.io.PrintWriter;
-import java.util.List;
import java.util.Objects;
/**
@@ -85,6 +82,18 @@
/** Whether flyout text should be suppressed, regardless of any other flags or state. */
private boolean mSuppressFlyout;
+ /**
+ * Presentational info about the flyout.
+ */
+ public static class FlyoutMessage {
+ @Nullable public Drawable senderAvatar;
+ @Nullable public CharSequence senderName;
+ @Nullable public CharSequence message;
+ @Nullable public boolean isGroupChat;
+ }
+
+ private FlyoutMessage mFlyoutMessage;
+
public static String groupId(NotificationEntry entry) {
UserHandle user = entry.getSbn().getUser();
return user.getIdentifier() + "|" + entry.getSbn().getPackageName();
@@ -194,6 +203,7 @@
mShortcutInfo = info.shortcutInfo;
mAppName = info.appName;
+ mFlyoutMessage = info.flyoutMessage;
mExpandedView.update(this);
mIconView.update(this, info.badgedBubbleImage, info.dotColor, info.dotPath);
@@ -307,6 +317,10 @@
mSuppressFlyout = suppressFlyout;
}
+ FlyoutMessage getFlyoutMessage() {
+ return mFlyoutMessage;
+ }
+
/**
* Returns whether the notification for this bubble is a foreground service. It shows that this
* is an ongoing bubble.
@@ -346,14 +360,14 @@
* To populate the icon use {@link LauncherApps#getShortcutIconDrawable(ShortcutInfo, int)}.
*/
boolean usingShortcutInfo() {
- return BubbleExperimentConfig.isShortcutIntent(getBubbleIntent());
+ return mEntry.getBubbleMetadata().getShortcutId() != null;
}
@Nullable
PendingIntent getBubbleIntent() {
Notification.BubbleMetadata data = mEntry.getBubbleMetadata();
if (data != null) {
- return data.getIntent();
+ return data.getBubbleIntent();
}
return null;
}
@@ -368,72 +382,6 @@
return intent;
}
- /**
- * Returns our best guess for the most relevant text summary of the latest update to this
- * notification, based on its type. Returns null if there should not be an update message.
- */
- CharSequence getUpdateMessage(Context context) {
- final Notification underlyingNotif = mEntry.getSbn().getNotification();
- final Class<? extends Notification.Style> style = underlyingNotif.getNotificationStyle();
-
- try {
- if (Notification.BigTextStyle.class.equals(style)) {
- // Return the big text, it is big so probably important. If it's not there use the
- // normal text.
- CharSequence bigText =
- underlyingNotif.extras.getCharSequence(Notification.EXTRA_BIG_TEXT);
- return !TextUtils.isEmpty(bigText)
- ? bigText
- : underlyingNotif.extras.getCharSequence(Notification.EXTRA_TEXT);
- } else if (Notification.MessagingStyle.class.equals(style)) {
- final List<Notification.MessagingStyle.Message> messages =
- Notification.MessagingStyle.Message.getMessagesFromBundleArray(
- (Parcelable[]) underlyingNotif.extras.get(
- Notification.EXTRA_MESSAGES));
-
- final Notification.MessagingStyle.Message latestMessage =
- Notification.MessagingStyle.findLatestIncomingMessage(messages);
-
- if (latestMessage != null) {
- final CharSequence personName = latestMessage.getSenderPerson() != null
- ? latestMessage.getSenderPerson().getName()
- : null;
-
- // Prepend the sender name if available since group chats also use messaging
- // style.
- if (!TextUtils.isEmpty(personName)) {
- return context.getResources().getString(
- R.string.notification_summary_message_format,
- personName,
- latestMessage.getText());
- } else {
- return latestMessage.getText();
- }
- }
- } else if (Notification.InboxStyle.class.equals(style)) {
- CharSequence[] lines =
- underlyingNotif.extras.getCharSequenceArray(Notification.EXTRA_TEXT_LINES);
-
- // Return the last line since it should be the most recent.
- if (lines != null && lines.length > 0) {
- return lines[lines.length - 1];
- }
- } else if (Notification.MediaStyle.class.equals(style)) {
- // Return nothing, media updates aren't typically useful as a text update.
- return null;
- } else {
- // Default to text extra.
- return underlyingNotif.extras.getCharSequence(Notification.EXTRA_TEXT);
- }
- } catch (ClassCastException | NullPointerException | ArrayIndexOutOfBoundsException e) {
- // No use crashing, we'll just return null and the caller will assume there's no update
- // message.
- e.printStackTrace();
- }
-
- return null;
- }
-
private int getDimenForPackageUser(Context context, int resId, String pkg, int userId) {
PackageManager pm = context.getPackageManager();
Resources r;
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleController.java b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleController.java
index 644d8c4..e642d4e 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleController.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleController.java
@@ -1075,8 +1075,12 @@
*/
static boolean canLaunchInActivityView(Context context, NotificationEntry entry) {
PendingIntent intent = entry.getBubbleMetadata() != null
- ? entry.getBubbleMetadata().getIntent()
+ ? entry.getBubbleMetadata().getBubbleIntent()
: null;
+ if (entry.getBubbleMetadata() != null
+ && entry.getBubbleMetadata().getShortcutId() != null) {
+ return true;
+ }
if (intent == null) {
Log.w(TAG, "Unable to create bubble -- no intent: " + entry.getKey());
return false;
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExpandedView.java b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExpandedView.java
index c1705db..48ce4e9 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExpandedView.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExpandedView.java
@@ -42,7 +42,6 @@
import android.service.notification.StatusBarNotification;
import android.util.AttributeSet;
import android.util.Log;
-import android.util.StatsLog;
import android.view.View;
import android.view.WindowInsets;
import android.view.WindowManager;
@@ -52,6 +51,7 @@
import com.android.systemui.Dependency;
import com.android.systemui.R;
import com.android.systemui.recents.TriangleShape;
+import com.android.systemui.shared.system.SysUiStatsLog;
import com.android.systemui.statusbar.AlphaOptimizedButton;
/**
@@ -357,7 +357,7 @@
if (isNew) {
mBubbleIntent = mBubble.getBubbleIntent();
- if (mBubbleIntent != null) {
+ if (mBubbleIntent != null || mBubble.getShortcutInfo() != null) {
setContentVisibility(false);
mActivityView.setVisibility(VISIBLE);
}
@@ -467,7 +467,7 @@
mStackView.collapseStack(() -> {
mContext.startActivityAsUser(intent, mBubble.getEntry().getSbn().getUser());
logBubbleClickEvent(mBubble,
- StatsLog.BUBBLE_UICHANGED__ACTION__HEADER_GO_TO_SETTINGS);
+ SysUiStatsLog.BUBBLE_UICHANGED__ACTION__HEADER_GO_TO_SETTINGS);
});
}
}
@@ -543,7 +543,8 @@
}
private boolean usingActivityView() {
- return mBubbleIntent != null && mActivityView != null;
+ return (mBubbleIntent != null || mBubble.getShortcutInfo() != null)
+ && mActivityView != null;
}
/**
@@ -564,7 +565,7 @@
*/
private void logBubbleClickEvent(Bubble bubble, int action) {
StatusBarNotification notification = bubble.getEntry().getSbn();
- StatsLog.write(StatsLog.BUBBLE_UI_CHANGED,
+ SysUiStatsLog.write(SysUiStatsLog.BUBBLE_UI_CHANGED,
notification.getPackageName(),
notification.getNotification().getChannelId(),
notification.getId(),
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExperimentConfig.java b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExperimentConfig.java
index 4c1cf49..4252f72 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExperimentConfig.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleExperimentConfig.java
@@ -29,7 +29,6 @@
import android.app.PendingIntent;
import android.app.Person;
import android.content.Context;
-import android.content.Intent;
import android.content.pm.LauncherApps;
import android.content.pm.ShortcutInfo;
import android.graphics.Color;
@@ -182,7 +181,7 @@
ShortcutInfo info = getShortcutInfo(context, entry.getSbn().getPackageName(),
entry.getSbn().getUser(), shortcutId);
if (info != null) {
- metadata = createForShortcut(context, entry);
+ metadata = createForShortcut(shortcutId);
}
// Replace existing metadata with shortcut, or we're bubbling for experiment
@@ -259,30 +258,17 @@
}
if (intent != null) {
return new Notification.BubbleMetadata.Builder()
+ .createIntentBubble(intent, icon)
.setDesiredHeight(BUBBLE_HEIGHT)
- .setIcon(icon)
- .setIntent(intent)
.build();
}
return null;
}
- static Notification.BubbleMetadata createForShortcut(Context context, NotificationEntry entry) {
- // ShortcutInfo does not return an icon, instead a Drawable, lets just use
- // notification icon for BubbleMetadata.
- Icon icon = entry.getSbn().getNotification().getSmallIcon();
-
- // ShortcutInfo does not return the intent, lets make a fake but identifiable
- // intent so we can still add bubbleMetadata
- if (sDummyShortcutIntent == null) {
- Intent i = new Intent(SHORTCUT_DUMMY_INTENT);
- sDummyShortcutIntent = PendingIntent.getActivity(context, 0, i,
- PendingIntent.FLAG_UPDATE_CURRENT);
- }
+ static Notification.BubbleMetadata createForShortcut(String shortcutId) {
return new Notification.BubbleMetadata.Builder()
.setDesiredHeight(BUBBLE_HEIGHT)
- .setIcon(icon)
- .setIntent(sDummyShortcutIntent)
+ .createShortcutBubble(shortcutId)
.build();
}
@@ -304,10 +290,6 @@
: null;
}
- static boolean isShortcutIntent(PendingIntent intent) {
- return intent != null && intent.equals(sDummyShortcutIntent);
- }
-
static List<Person> getPeopleFromNotification(NotificationEntry entry) {
Bundle extras = entry.getSbn().getNotification().extras;
ArrayList<Person> personList = new ArrayList<>();
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleFlyoutView.java b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleFlyoutView.java
index 78e98eb..4194352 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleFlyoutView.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleFlyoutView.java
@@ -32,11 +32,13 @@
import android.graphics.PointF;
import android.graphics.RectF;
import android.graphics.drawable.ShapeDrawable;
+import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewOutlineProvider;
import android.widget.FrameLayout;
+import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.Nullable;
@@ -65,7 +67,9 @@
private final float mCornerRadius;
private final ViewGroup mFlyoutTextContainer;
- private final TextView mFlyoutText;
+ private final ImageView mSenderAvatar;
+ private final TextView mSenderText;
+ private final TextView mMessageText;
/** Values related to the 'new' dot which we use to figure out where to collapse the flyout. */
private final float mNewDotRadius;
@@ -142,7 +146,9 @@
LayoutInflater.from(context).inflate(R.layout.bubble_flyout, this, true);
mFlyoutTextContainer = findViewById(R.id.bubble_flyout_text_container);
- mFlyoutText = mFlyoutTextContainer.findViewById(R.id.bubble_flyout_text);
+ mSenderText = findViewById(R.id.bubble_flyout_name);
+ mSenderAvatar = findViewById(R.id.bubble_flyout_avatar);
+ mMessageText = mFlyoutTextContainer.findViewById(R.id.bubble_flyout_text);
final Resources res = getResources();
mFlyoutPadding = res.getDimensionPixelSize(R.dimen.bubble_flyout_padding_x);
@@ -204,9 +210,34 @@
/** Configures the flyout, collapsed into to dot form. */
void setupFlyoutStartingAsDot(
- CharSequence updateMessage, PointF stackPos, float parentWidth,
- boolean arrowPointingLeft, int dotColor, @Nullable Runnable onLayoutComplete,
- @Nullable Runnable onHide, float[] dotCenter, boolean hideDot) {
+ Bubble.FlyoutMessage flyoutMessage,
+ PointF stackPos,
+ float parentWidth,
+ boolean arrowPointingLeft,
+ int dotColor,
+ @Nullable Runnable onLayoutComplete,
+ @Nullable Runnable onHide,
+ float[] dotCenter,
+ boolean hideDot) {
+
+ if (flyoutMessage.senderAvatar != null && flyoutMessage.isGroupChat) {
+ mSenderAvatar.setVisibility(VISIBLE);
+ mSenderAvatar.setImageDrawable(flyoutMessage.senderAvatar);
+ } else {
+ mSenderAvatar.setVisibility(GONE);
+ mSenderAvatar.setTranslationX(0);
+ mMessageText.setTranslationX(0);
+ mSenderText.setTranslationX(0);
+ }
+
+ // Name visibility
+ if (!TextUtils.isEmpty(flyoutMessage.senderName)) {
+ mSenderText.setText(flyoutMessage.senderName);
+ mSenderText.setVisibility(VISIBLE);
+ } else {
+ mSenderText.setVisibility(GONE);
+ }
+
mArrowPointingLeft = arrowPointingLeft;
mDotColor = dotColor;
mOnHide = onHide;
@@ -217,15 +248,15 @@
// Set the flyout TextView's max width in terms of percent, and then subtract out the
// padding so that the entire flyout view will be the desired width (rather than the
// TextView being the desired width + extra padding).
- mFlyoutText.setMaxWidth(
+ mMessageText.setMaxWidth(
(int) (parentWidth * FLYOUT_MAX_WIDTH_PERCENT) - mFlyoutPadding * 2);
- mFlyoutText.setText(updateMessage);
+ mMessageText.setText(flyoutMessage.message);
// Wait for the TextView to lay out so we know its line count.
post(() -> {
float restingTranslationY;
// Multi line flyouts get top-aligned to the bubble.
- if (mFlyoutText.getLineCount() > 1) {
+ if (mMessageText.getLineCount() > 1) {
restingTranslationY = stackPos.y + mBubbleIconTopPadding;
} else {
// Single line flyouts are vertically centered with respect to the bubble.
@@ -289,11 +320,20 @@
mPercentStillFlyout = (1f - mPercentTransitionedToDot);
// Move and fade out the text.
- mFlyoutText.setTranslationX(
- (mArrowPointingLeft ? -getWidth() : getWidth()) * mPercentTransitionedToDot);
- mFlyoutText.setAlpha(clampPercentage(
+ final float translationX = mPercentTransitionedToDot
+ * (mArrowPointingLeft ? -getWidth() : getWidth());
+ final float alpha = clampPercentage(
(mPercentStillFlyout - (1f - BubbleStackView.FLYOUT_DRAG_PERCENT_DISMISS))
- / BubbleStackView.FLYOUT_DRAG_PERCENT_DISMISS));
+ / BubbleStackView.FLYOUT_DRAG_PERCENT_DISMISS);
+
+ mMessageText.setTranslationX(translationX);
+ mMessageText.setAlpha(alpha);
+
+ mSenderText.setTranslationX(translationX);
+ mSenderText.setAlpha(alpha);
+
+ mSenderAvatar.setTranslationX(translationX);
+ mSenderAvatar.setAlpha(alpha);
// Reduce the elevation towards that of the topmost bubble.
setTranslationZ(
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleIconFactory.java b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleIconFactory.java
index b32dbb7..3b818db 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleIconFactory.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleIconFactory.java
@@ -18,6 +18,7 @@
import android.app.Notification;
import android.content.Context;
import android.content.pm.LauncherApps;
+import android.content.pm.ShortcutInfo;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.drawable.BitmapDrawable;
@@ -48,16 +49,19 @@
/**
* Returns the drawable that the developer has provided to display in the bubble.
*/
- Drawable getBubbleDrawable(Bubble b, Context context) {
- if (b.getShortcutInfo() != null && b.usingShortcutInfo()) {
+ Drawable getBubbleDrawable(Context context, ShortcutInfo shortcutInfo,
+ Notification.BubbleMetadata metadata) {
+ if (shortcutInfo != null) {
LauncherApps launcherApps =
(LauncherApps) context.getSystemService(Context.LAUNCHER_APPS_SERVICE);
int density = context.getResources().getConfiguration().densityDpi;
- return launcherApps.getShortcutIconDrawable(b.getShortcutInfo(), density);
+ return launcherApps.getShortcutIconDrawable(shortcutInfo, density);
} else {
- Notification.BubbleMetadata metadata = b.getEntry().getBubbleMetadata();
- Icon ic = metadata.getIcon();
- return ic.loadDrawable(context);
+ Icon ic = metadata.getBubbleIcon();
+ if (ic != null) {
+ return ic.loadDrawable(context);
+ }
+ return null;
}
}
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleStackView.java b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleStackView.java
index 15c1c55..54a42a6 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleStackView.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleStackView.java
@@ -45,7 +45,6 @@
import android.os.Vibrator;
import android.service.notification.StatusBarNotification;
import android.util.Log;
-import android.util.StatsLog;
import android.view.Choreographer;
import android.view.DisplayCutout;
import android.view.Gravity;
@@ -73,6 +72,7 @@
import com.android.systemui.bubbles.animation.ExpandedAnimationController;
import com.android.systemui.bubbles.animation.PhysicsAnimationLayout;
import com.android.systemui.bubbles.animation.StackAnimationController;
+import com.android.systemui.shared.system.SysUiStatsLog;
import java.io.FileDescriptor;
import java.io.PrintWriter;
@@ -735,7 +735,7 @@
ViewClippingUtil.setClippingDeactivated(bubble.getIconView(), true, mClippingParameters);
animateInFlyoutForBubble(bubble);
requestUpdate();
- logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__POSTED);
+ logBubbleEvent(bubble, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__POSTED);
updatePointerPosition();
}
@@ -749,7 +749,7 @@
if (removedIndex >= 0) {
mBubbleContainer.removeViewAt(removedIndex);
bubble.cleanupExpandedState();
- logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__DISMISSED);
+ logBubbleEvent(bubble, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__DISMISSED);
} else {
Log.d(TAG, "was asked to remove Bubble, but didn't find the view! " + bubble);
}
@@ -760,7 +760,7 @@
void updateBubble(Bubble bubble) {
animateInFlyoutForBubble(bubble);
requestUpdate();
- logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__UPDATED);
+ logBubbleEvent(bubble, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__UPDATED);
}
public void updateBubbleOrder(List<Bubble> bubbles) {
@@ -800,8 +800,9 @@
updateExpandedBubble();
updatePointerPosition();
requestUpdate();
- logBubbleEvent(previouslySelected, StatsLog.BUBBLE_UICHANGED__ACTION__COLLAPSED);
- logBubbleEvent(bubbleToSelect, StatsLog.BUBBLE_UICHANGED__ACTION__EXPANDED);
+ logBubbleEvent(previouslySelected,
+ SysUiStatsLog.BUBBLE_UICHANGED__ACTION__COLLAPSED);
+ logBubbleEvent(bubbleToSelect, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__EXPANDED);
notifyExpansionChanged(previouslySelected, false /* expanded */);
notifyExpansionChanged(bubbleToSelect, true /* expanded */);
});
@@ -823,12 +824,12 @@
}
if (mIsExpanded) {
animateCollapse();
- logBubbleEvent(mExpandedBubble, StatsLog.BUBBLE_UICHANGED__ACTION__COLLAPSED);
+ logBubbleEvent(mExpandedBubble, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__COLLAPSED);
} else {
animateExpansion();
// TODO: move next line to BubbleData
- logBubbleEvent(mExpandedBubble, StatsLog.BUBBLE_UICHANGED__ACTION__EXPANDED);
- logBubbleEvent(mExpandedBubble, StatsLog.BUBBLE_UICHANGED__ACTION__STACK_EXPANDED);
+ logBubbleEvent(mExpandedBubble, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__EXPANDED);
+ logBubbleEvent(mExpandedBubble, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__STACK_EXPANDED);
}
notifyExpansionChanged(mExpandedBubble, mIsExpanded);
}
@@ -845,7 +846,7 @@
}
mBubbleData.dismissAll(reason);
logBubbleEvent(null /* no bubble associated with bubble stack dismiss */,
- StatsLog.BUBBLE_UICHANGED__ACTION__STACK_DISMISSED);
+ SysUiStatsLog.BUBBLE_UICHANGED__ACTION__STACK_DISMISSED);
}
/**
@@ -1093,7 +1094,7 @@
final float newStackX = mStackAnimationController.flingStackThenSpringToEdge(x, velX, velY);
logBubbleEvent(null /* no bubble associated with bubble stack move */,
- StatsLog.BUBBLE_UICHANGED__ACTION__STACK_MOVED);
+ SysUiStatsLog.BUBBLE_UICHANGED__ACTION__STACK_MOVED);
mStackOnLeftOrWillBe = newStackX <= 0;
updateBubbleZOrdersAndDotPosition(true /* animate */);
@@ -1376,9 +1377,10 @@
*/
@VisibleForTesting
void animateInFlyoutForBubble(Bubble bubble) {
- final CharSequence updateMessage = bubble.getUpdateMessage(getContext());
+ Bubble.FlyoutMessage flyoutMessage = bubble.getFlyoutMessage();
final BadgedImageView bubbleView = bubble.getIconView();
- if (updateMessage == null
+ if (flyoutMessage == null
+ || flyoutMessage.message == null
|| !bubble.showFlyout()
|| isExpanded()
|| mIsExpansionAnimating
@@ -1431,8 +1433,8 @@
};
mFlyout.postDelayed(mAnimateInFlyout, 200);
};
- mFlyout.setupFlyoutStartingAsDot(
- updateMessage, mStackAnimationController.getStackPosition(), getWidth(),
+ mFlyout.setupFlyoutStartingAsDot(flyoutMessage,
+ mStackAnimationController.getStackPosition(), getWidth(),
mStackAnimationController.isStackOnLeftSide(),
bubble.getIconView().getDotColor() /* dotColor */,
expandFlyoutAfterDelay /* onLayoutComplete */,
@@ -1443,7 +1445,7 @@
});
mFlyout.removeCallbacks(mHideFlyout);
mFlyout.postDelayed(mHideFlyout, FLYOUT_HIDE_AFTER);
- logBubbleEvent(bubble, StatsLog.BUBBLE_UICHANGED__ACTION__FLYOUT);
+ logBubbleEvent(bubble, SysUiStatsLog.BUBBLE_UICHANGED__ACTION__FLYOUT);
}
/** Hide the flyout immediately and cancel any pending hide runnables. */
@@ -1641,7 +1643,7 @@
private void logBubbleEvent(@Nullable Bubble bubble, int action) {
if (bubble == null || bubble.getEntry() == null
|| bubble.getEntry().getSbn() == null) {
- StatsLog.write(StatsLog.BUBBLE_UI_CHANGED,
+ SysUiStatsLog.write(SysUiStatsLog.BUBBLE_UI_CHANGED,
null /* package name */,
null /* notification channel */,
0 /* notification ID */,
@@ -1655,7 +1657,7 @@
false /* isAppForeground (unused) */);
} else {
StatusBarNotification notification = bubble.getEntry().getSbn();
- StatsLog.write(StatsLog.BUBBLE_UI_CHANGED,
+ SysUiStatsLog.write(SysUiStatsLog.BUBBLE_UI_CHANGED,
notification.getPackageName(),
notification.getNotification().getChannelId(),
notification.getId(),
diff --git a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleViewInfoTask.java b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleViewInfoTask.java
index 41f5028..e705584 100644
--- a/packages/SystemUI/src/com/android/systemui/bubbles/BubbleViewInfoTask.java
+++ b/packages/SystemUI/src/com/android/systemui/bubbles/BubbleViewInfoTask.java
@@ -21,6 +21,9 @@
import static com.android.systemui.bubbles.BubbleDebugConfig.TAG_BUBBLES;
import static com.android.systemui.bubbles.BubbleDebugConfig.TAG_WITH_CLASS_NAME;
+import android.annotation.NonNull;
+import android.app.Notification;
+import android.app.Person;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
@@ -31,7 +34,9 @@
import android.graphics.Path;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
+import android.os.Parcelable;
import android.service.notification.StatusBarNotification;
+import android.text.TextUtils;
import android.util.Log;
import android.util.PathParser;
import android.view.LayoutInflater;
@@ -41,8 +46,10 @@
import com.android.internal.graphics.ColorUtils;
import com.android.launcher3.icons.BitmapInfo;
import com.android.systemui.R;
+import com.android.systemui.statusbar.notification.collection.NotificationEntry;
import java.lang.ref.WeakReference;
+import java.util.List;
/**
* Simple task to inflate views & load necessary info to display a bubble.
@@ -98,6 +105,9 @@
}
}
+ /**
+ * Info necessary to render a bubble.
+ */
static class BubbleViewInfo {
BadgedImageView imageView;
BubbleExpandedView expandedView;
@@ -106,6 +116,7 @@
Bitmap badgedBubbleImage;
int dotColor;
Path dotPath;
+ Bubble.FlyoutMessage flyoutMessage;
@Nullable
static BubbleViewInfo populate(Context c, BubbleStackView stackView,
@@ -126,15 +137,22 @@
StatusBarNotification sbn = b.getEntry().getSbn();
String packageName = sbn.getPackageName();
- // Shortcut info for this bubble
- String shortcutId = sbn.getNotification().getShortcutId();
- if (BubbleExperimentConfig.useShortcutInfoToBubble(c)
- && shortcutId != null) {
- info.shortcutInfo = BubbleExperimentConfig.getShortcutInfo(c,
- packageName,
- sbn.getUser(), shortcutId);
+ // Real shortcut info for this bubble
+ String bubbleShortcutId = b.getEntry().getBubbleMetadata().getShortcutId();
+ if (bubbleShortcutId != null) {
+ info.shortcutInfo = BubbleExperimentConfig.getShortcutInfo(c, packageName,
+ sbn.getUser(), bubbleShortcutId);
+ } else {
+ // Check for experimental shortcut
+ String shortcutId = sbn.getNotification().getShortcutId();
+ if (BubbleExperimentConfig.useShortcutInfoToBubble(c) && shortcutId != null) {
+ info.shortcutInfo = BubbleExperimentConfig.getShortcutInfo(c,
+ packageName,
+ sbn.getUser(), shortcutId);
+ }
}
+
// App name & app icon
PackageManager pm = c.getPackageManager();
ApplicationInfo appInfo;
@@ -158,7 +176,8 @@
}
// Badged bubble image
- Drawable bubbleDrawable = iconFactory.getBubbleDrawable(b, c);
+ Drawable bubbleDrawable = iconFactory.getBubbleDrawable(c, info.shortcutInfo,
+ b.getEntry().getBubbleMetadata());
BitmapInfo badgeBitmapInfo = iconFactory.getBadgeBitmap(badgedIcon);
info.badgedBubbleImage = iconFactory.getBubbleBitmap(bubbleDrawable,
badgeBitmapInfo).icon;
@@ -176,7 +195,80 @@
info.dotPath = iconPath;
info.dotColor = ColorUtils.blendARGB(badgeBitmapInfo.color,
Color.WHITE, WHITE_SCRIM_ALPHA);
+
+ // Flyout
+ info.flyoutMessage = extractFlyoutMessage(c, b.getEntry());
return info;
}
}
+
+
+ /**
+ * Returns our best guess for the most relevant text summary of the latest update to this
+ * notification, based on its type. Returns null if there should not be an update message.
+ */
+ @NonNull
+ static Bubble.FlyoutMessage extractFlyoutMessage(Context context,
+ NotificationEntry entry) {
+ final Notification underlyingNotif = entry.getSbn().getNotification();
+ final Class<? extends Notification.Style> style = underlyingNotif.getNotificationStyle();
+
+ Bubble.FlyoutMessage bubbleMessage = new Bubble.FlyoutMessage();
+ bubbleMessage.isGroupChat = underlyingNotif.extras.getBoolean(
+ Notification.EXTRA_IS_GROUP_CONVERSATION);
+ try {
+ if (Notification.BigTextStyle.class.equals(style)) {
+ // Return the big text, it is big so probably important. If it's not there use the
+ // normal text.
+ CharSequence bigText =
+ underlyingNotif.extras.getCharSequence(Notification.EXTRA_BIG_TEXT);
+ bubbleMessage.message = !TextUtils.isEmpty(bigText)
+ ? bigText
+ : underlyingNotif.extras.getCharSequence(Notification.EXTRA_TEXT);
+ return bubbleMessage;
+ } else if (Notification.MessagingStyle.class.equals(style)) {
+ final List<Notification.MessagingStyle.Message> messages =
+ Notification.MessagingStyle.Message.getMessagesFromBundleArray(
+ (Parcelable[]) underlyingNotif.extras.get(
+ Notification.EXTRA_MESSAGES));
+
+ final Notification.MessagingStyle.Message latestMessage =
+ Notification.MessagingStyle.findLatestIncomingMessage(messages);
+ if (latestMessage != null) {
+ bubbleMessage.message = latestMessage.getText();
+ Person sender = latestMessage.getSenderPerson();
+ bubbleMessage.senderName = sender != null
+ ? sender.getName()
+ : null;
+ bubbleMessage.senderAvatar = sender != null
+ ? sender.getIcon().loadDrawable(context)
+ : null;
+ return bubbleMessage;
+ }
+ } else if (Notification.InboxStyle.class.equals(style)) {
+ CharSequence[] lines =
+ underlyingNotif.extras.getCharSequenceArray(Notification.EXTRA_TEXT_LINES);
+
+ // Return the last line since it should be the most recent.
+ if (lines != null && lines.length > 0) {
+ bubbleMessage.message = lines[lines.length - 1];
+ return bubbleMessage;
+ }
+ } else if (Notification.MediaStyle.class.equals(style)) {
+ // Return nothing, media updates aren't typically useful as a text update.
+ return bubbleMessage;
+ } else {
+ // Default to text extra.
+ bubbleMessage.message =
+ underlyingNotif.extras.getCharSequence(Notification.EXTRA_TEXT);
+ return bubbleMessage;
+ }
+ } catch (ClassCastException | NullPointerException | ArrayIndexOutOfBoundsException e) {
+ // No use crashing, we'll just return null and the caller will assume there's no update
+ // message.
+ e.printStackTrace();
+ }
+
+ return bubbleMessage;
+ }
}
diff --git a/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java b/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java
index a6fa414..36a8450 100644
--- a/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java
+++ b/packages/SystemUI/src/com/android/systemui/dagger/SystemUIModule.java
@@ -19,20 +19,26 @@
import android.annotation.Nullable;
import android.content.Context;
import android.content.pm.PackageManager;
+import android.content.res.Resources;
import com.android.keyguard.KeyguardUpdateMonitor;
import com.android.systemui.BootCompleteCache;
import com.android.systemui.BootCompleteCacheImpl;
import com.android.systemui.DumpController;
import com.android.systemui.assist.AssistModule;
+import com.android.systemui.dagger.qualifiers.Main;
import com.android.systemui.model.SysUiState;
import com.android.systemui.plugins.statusbar.StatusBarStateController;
import com.android.systemui.recents.Recents;
import com.android.systemui.stackdivider.Divider;
+import com.android.systemui.statusbar.BlurUtils;
import com.android.systemui.statusbar.CommandQueue;
+import com.android.systemui.statusbar.StatusBarWindowBlurController;
+import com.android.systemui.statusbar.SysuiStatusBarStateController;
import com.android.systemui.statusbar.notification.collection.inflation.NotificationRowBinder;
import com.android.systemui.statusbar.notification.collection.inflation.NotificationRowBinderImpl;
import com.android.systemui.statusbar.notification.people.PeopleHubModule;
+import com.android.systemui.statusbar.notification.row.dagger.NotificationRowComponent;
import com.android.systemui.statusbar.phone.KeyguardLiftController;
import com.android.systemui.statusbar.phone.StatusBar;
import com.android.systemui.statusbar.phone.dagger.StatusBarComponent;
@@ -56,7 +62,7 @@
@Module(includes = {AssistModule.class,
ConcurrencyModule.class,
PeopleHubModule.class},
- subcomponents = {StatusBarComponent.class})
+ subcomponents = {StatusBarComponent.class, NotificationRowComponent.class})
public abstract class SystemUIModule {
@Binds
@@ -82,6 +88,16 @@
keyguardUpdateMonitor, dumpController);
}
+ @Singleton
+ @Provides
+ @Nullable
+ static StatusBarWindowBlurController providesBlurController(BlurUtils blurUtils,
+ @Main Resources resources, SysuiStatusBarStateController statusBarStateController,
+ DumpController dumpController) {
+ return blurUtils.supportsBlursOnWindows() ? new StatusBarWindowBlurController(resources,
+ statusBarStateController, blurUtils, dumpController) : null;
+ }
+
/** */
@Binds
public abstract NotificationRowBinder bindNotificationRowBinder(
diff --git a/packages/SystemUI/src/com/android/systemui/globalactions/GlobalActionsDialog.java b/packages/SystemUI/src/com/android/systemui/globalactions/GlobalActionsDialog.java
index 36a4a10..3735198 100644
--- a/packages/SystemUI/src/com/android/systemui/globalactions/GlobalActionsDialog.java
+++ b/packages/SystemUI/src/com/android/systemui/globalactions/GlobalActionsDialog.java
@@ -98,6 +98,7 @@
import com.android.systemui.plugins.GlobalActions.GlobalActionsManager;
import com.android.systemui.plugins.GlobalActionsPanelPlugin;
import com.android.systemui.statusbar.phone.NotificationShadeWindowController;
+import com.android.systemui.statusbar.BlurUtils;
import com.android.systemui.statusbar.phone.ScrimController;
import com.android.systemui.statusbar.policy.ConfigurationController;
import com.android.systemui.statusbar.policy.KeyguardStateController;
@@ -157,6 +158,7 @@
private final IActivityManager mIActivityManager;
private final TelecomManager mTelecomManager;
private final MetricsLogger mMetricsLogger;
+ private final BlurUtils mBlurUtils;
private ArrayList<Action> mItems;
private ActionsDialog mDialog;
@@ -177,6 +179,9 @@
private final ScreenshotHelper mScreenshotHelper;
private final ScreenRecordHelper mScreenRecordHelper;
private final ActivityStarter mActivityStarter;
+ private final SysuiColorExtractor mSysuiColorExtractor;
+ private final IStatusBarService mStatusBarService;
+ private final NotificationShadeWindowController mNotificationShadeWindowController;
private GlobalActionsPanelPlugin mPanelPlugin;
/**
@@ -192,7 +197,10 @@
ConfigurationController configurationController, ActivityStarter activityStarter,
KeyguardStateController keyguardStateController, UserManager userManager,
TrustManager trustManager, IActivityManager iActivityManager,
- TelecomManager telecomManager, MetricsLogger metricsLogger) {
+ TelecomManager telecomManager, MetricsLogger metricsLogger,
+ BlurUtils blurUtils, SysuiColorExtractor colorExtractor,
+ IStatusBarService statusBarService,
+ NotificationShadeWindowController notificationShadeWindowController) {
mContext = new ContextThemeWrapper(context, com.android.systemui.R.style.qs_theme);
mWindowManagerFuncs = windowManagerFuncs;
mAudioManager = audioManager;
@@ -208,6 +216,10 @@
mIActivityManager = iActivityManager;
mTelecomManager = telecomManager;
mMetricsLogger = metricsLogger;
+ mBlurUtils = blurUtils;
+ mSysuiColorExtractor = colorExtractor;
+ mStatusBarService = statusBarService;
+ mNotificationShadeWindowController = notificationShadeWindowController;
// receive broadcasts
IntentFilter filter = new IntentFilter();
@@ -443,8 +455,9 @@
mKeyguardManager.isDeviceLocked())
: null;
- ActionsDialog dialog = new ActionsDialog(
- mContext, mAdapter, panelViewController, isControlsEnabled(mContext));
+ ActionsDialog dialog = new ActionsDialog(mContext, mAdapter, panelViewController,
+ mBlurUtils, mSysuiColorExtractor, mStatusBarService,
+ mNotificationShadeWindowController, isControlsEnabled(mContext));
dialog.setCanceledOnTouchOutside(false); // Handled by the custom class.
dialog.setKeyguardShowing(mKeyguardShowing);
@@ -1529,18 +1542,21 @@
private ResetOrientationData mResetOrientationData;
private boolean mHadTopUi;
private final NotificationShadeWindowController mNotificationShadeWindowController;
- private boolean mControlsEnabled;
+ private final BlurUtils mBlurUtils;
+ private final boolean mControlsEnabled;
ActionsDialog(Context context, MyAdapter adapter,
- GlobalActionsPanelPlugin.PanelViewController plugin,
+ GlobalActionsPanelPlugin.PanelViewController plugin, BlurUtils blurUtils,
+ SysuiColorExtractor sysuiColorExtractor, IStatusBarService statusBarService,
+ NotificationShadeWindowController notificationShadeWindowController,
boolean controlsEnabled) {
super(context, com.android.systemui.R.style.Theme_SystemUI_Dialog_GlobalActions);
mContext = context;
mAdapter = adapter;
- mColorExtractor = Dependency.get(SysuiColorExtractor.class);
- mStatusBarService = Dependency.get(IStatusBarService.class);
- mNotificationShadeWindowController =
- Dependency.get(NotificationShadeWindowController.class);
+ mBlurUtils = blurUtils;
+ mColorExtractor = sysuiColorExtractor;
+ mStatusBarService = statusBarService;
+ mNotificationShadeWindowController = notificationShadeWindowController;
mControlsEnabled = controlsEnabled;
// Window initialization
@@ -1735,9 +1751,11 @@
.setDuration(300)
.setInterpolator(Interpolators.FAST_OUT_SLOW_IN)
.setUpdateListener(animation -> {
- int alpha = (int) ((Float) animation.getAnimatedValue()
- * mScrimAlpha * 255);
+ float animatedValue = animation.getAnimatedFraction();
+ int alpha = (int) (animatedValue * mScrimAlpha * 255);
mBackgroundDrawable.setAlpha(alpha);
+ mBlurUtils.applyBlur(mGlobalActionsLayout.getViewRootImpl(),
+ mBlurUtils.radiusForRatio(animatedValue));
})
.start();
}
@@ -1759,9 +1777,11 @@
.withEndAction(this::completeDismiss)
.setInterpolator(new LogAccelerateInterpolator())
.setUpdateListener(animation -> {
- int alpha = (int) ((1f - (Float) animation.getAnimatedValue())
- * mScrimAlpha * 255);
+ float animatedValue = 1f - animation.getAnimatedFraction();
+ int alpha = (int) (animatedValue * mScrimAlpha * 255);
mBackgroundDrawable.setAlpha(alpha);
+ mBlurUtils.applyBlur(mGlobalActionsLayout.getViewRootImpl(),
+ mBlurUtils.radiusForRatio(animatedValue));
})
.start();
dismissPanel();
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipMotionHelper.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipMotionHelper.java
index 6afa0bf..eba2e78 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/phone/PipMotionHelper.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipMotionHelper.java
@@ -19,17 +19,11 @@
import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
-import static com.android.systemui.Interpolators.FAST_OUT_LINEAR_IN;
-import static com.android.systemui.Interpolators.FAST_OUT_SLOW_IN;
-import static com.android.systemui.Interpolators.LINEAR_OUT_SLOW_IN;
-
import android.animation.AnimationHandler;
import android.animation.Animator;
-import android.animation.Animator.AnimatorListener;
import android.animation.AnimatorListenerAdapter;
-import android.animation.RectEvaluator;
-import android.animation.ValueAnimator;
-import android.animation.ValueAnimator.AnimatorUpdateListener;
+import android.animation.TimeAnimator;
+import android.annotation.Nullable;
import android.app.ActivityManager.StackInfo;
import android.app.IActivityManager;
import android.app.IActivityTaskManager;
@@ -42,13 +36,16 @@
import android.os.Message;
import android.os.RemoteException;
import android.util.Log;
-import android.view.animation.Interpolator;
+
+import androidx.dynamicanimation.animation.SpringForce;
import com.android.internal.graphics.SfVsyncFrameCallbackProvider;
import com.android.internal.os.SomeArgs;
import com.android.systemui.pip.PipSnapAlgorithm;
import com.android.systemui.shared.system.WindowManagerWrapper;
import com.android.systemui.statusbar.FlingAnimationUtils;
+import com.android.systemui.util.animation.FloatProperties;
+import com.android.systemui.util.animation.PhysicsAnimator;
import java.io.PrintWriter;
@@ -60,18 +57,14 @@
private static final String TAG = "PipMotionHelper";
private static final boolean DEBUG = false;
- private static final RectEvaluator RECT_EVALUATOR = new RectEvaluator(new Rect());
-
- private static final int DEFAULT_MOVE_STACK_DURATION = 225;
- private static final int SNAP_STACK_DURATION = 225;
- private static final int DRAG_TO_TARGET_DISMISS_STACK_DURATION = 375;
- private static final int DRAG_TO_DISMISS_STACK_DURATION = 175;
private static final int SHRINK_STACK_FROM_MENU_DURATION = 250;
private static final int EXPAND_STACK_TO_MENU_DURATION = 250;
private static final int EXPAND_STACK_TO_FULLSCREEN_DURATION = 300;
- private static final int MINIMIZE_STACK_MAX_DURATION = 200;
private static final int SHIFT_DURATION = 300;
+ /** Friction to use for PIP when it moves via physics fling animations. */
+ private static final float DEFAULT_FRICTION = 2f;
+
// The fraction of the stack width that the user has to drag offscreen to minimize the PiP
private static final float MINIMIZE_OFFSCREEN_FRACTION = 0.3f;
// The fraction of the stack height that the user has to drag offscreen to dismiss the PiP
@@ -89,12 +82,39 @@
private PipMenuActivityController mMenuController;
private PipSnapAlgorithm mSnapAlgorithm;
private FlingAnimationUtils mFlingAnimationUtils;
- private AnimationHandler mAnimationHandler;
- private final Rect mBounds = new Rect();
private final Rect mStableInsets = new Rect();
- private ValueAnimator mBoundsAnimator = null;
+ /** PIP's current bounds on the screen. */
+ private final Rect mBounds = new Rect();
+
+ /**
+ * Bounds that are animated using the physics animator. PIP is moved to these bounds whenever
+ * the {@link #mVsyncTimeAnimator} ticks.
+ */
+ private final Rect mAnimatedBounds = new Rect();
+
+ /**
+ * PhysicsAnimator instance for animating {@link #mAnimatedBounds} using physics animations.
+ */
+ private PhysicsAnimator<Rect> mAnimatedBoundsPhysicsAnimator = PhysicsAnimator.getInstance(
+ mAnimatedBounds);
+
+ /**
+ * Time animator whose frame timing comes from the SurfaceFlinger vsync frame provider. At each
+ * frame, PIP is moved to {@link #mAnimatedBounds}, which are animated asynchronously using
+ * physics animations.
+ */
+ private TimeAnimator mVsyncTimeAnimator;
+
+ /** FlingConfig instances provided to PhysicsAnimator for fling gestures. */
+ private PhysicsAnimator.FlingConfig mFlingConfigX;
+ private PhysicsAnimator.FlingConfig mFlingConfigY;
+
+ /** SpringConfig to use for fling-then-spring animations. */
+ private final PhysicsAnimator.SpringConfig mSpringConfig =
+ new PhysicsAnimator.SpringConfig(
+ SpringForce.STIFFNESS_MEDIUM, SpringForce.DAMPING_RATIO_LOW_BOUNCY);
public PipMotionHelper(Context context, IActivityManager activityManager,
IActivityTaskManager activityTaskManager, PipMenuActivityController menuController,
@@ -106,9 +126,39 @@
mMenuController = menuController;
mSnapAlgorithm = snapAlgorithm;
mFlingAnimationUtils = flingAnimationUtils;
- mAnimationHandler = new AnimationHandler();
- mAnimationHandler.setProvider(new SfVsyncFrameCallbackProvider());
+ final AnimationHandler vsyncFrameCallbackProvider = new AnimationHandler();
+ vsyncFrameCallbackProvider.setProvider(new SfVsyncFrameCallbackProvider());
+
onConfigurationChanged();
+
+ // Construct a time animator that uses the vsync frame provider. Physics animations can't
+ // use custom frame providers, since they rely on constant time between frames to run the
+ // physics simulations. To work around this, we physically-animate a second set of bounds,
+ // and apply those animating bounds to the PIP in-sync via this TimeAnimator.
+ mVsyncTimeAnimator = new TimeAnimator() {
+ @Override
+ public AnimationHandler getAnimationHandler() {
+ return vsyncFrameCallbackProvider;
+ }
+ };
+
+ // When the time animator ticks, move PIP to the animated bounds.
+ mVsyncTimeAnimator.setTimeListener(
+ (animation, totalTime, deltaTime) ->
+ resizePipUnchecked(mAnimatedBounds));
+
+ // Add a listener for cancel/end events that moves PIP to the final animated bounds.
+ mVsyncTimeAnimator.addListener(new AnimatorListenerAdapter() {
+ @Override
+ public void onAnimationCancel(Animator animation) {
+ resizePipUnchecked(mAnimatedBounds);
+ }
+
+ @Override
+ public void onAnimationEnd(Animator animation) {
+ resizePipUnchecked(mAnimatedBounds);
+ }
+ });
}
/**
@@ -241,88 +291,85 @@
}
/**
- * Flings the minimized PiP to the closest minimized snap target.
- */
- Rect flingToMinimizedState(float velocityY, Rect movementBounds, Point dragStartPosition) {
- cancelAnimations();
- // We currently only allow flinging the minimized stack up and down, so just lock the
- // movement bounds to the current stack bounds horizontally
- movementBounds = new Rect(mBounds.left, movementBounds.top, mBounds.left,
- movementBounds.bottom);
- Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mBounds,
- 0 /* velocityX */, velocityY, dragStartPosition);
- if (!mBounds.equals(toBounds)) {
- mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, 0, FAST_OUT_SLOW_IN);
- mFlingAnimationUtils.apply(mBoundsAnimator, 0,
- distanceBetweenRectOffsets(mBounds, toBounds),
- velocityY);
- mBoundsAnimator.start();
- }
- return toBounds;
- }
-
- /**
* Animates the PiP to the minimized state, slightly offscreen.
*/
- Rect animateToClosestMinimizedState(Rect movementBounds,
- AnimatorUpdateListener updateListener) {
- cancelAnimations();
- Rect toBounds = getClosestMinimizedBounds(mBounds, movementBounds);
- if (!mBounds.equals(toBounds)) {
- mBoundsAnimator = createAnimationToBounds(mBounds, toBounds,
- MINIMIZE_STACK_MAX_DURATION, LINEAR_OUT_SLOW_IN);
- if (updateListener != null) {
- mBoundsAnimator.addUpdateListener(updateListener);
- }
- mBoundsAnimator.start();
+ void animateToClosestMinimizedState(Rect movementBounds, @Nullable Runnable updateAction) {
+ final Rect toBounds = getClosestMinimizedBounds(mBounds, movementBounds);
+
+ prepareForBoundsAnimation(movementBounds);
+
+ mAnimatedBoundsPhysicsAnimator
+ .spring(FloatProperties.RECT_X, toBounds.left, mSpringConfig)
+ .spring(FloatProperties.RECT_Y, toBounds.top, mSpringConfig);
+
+ if (updateAction != null) {
+ mAnimatedBoundsPhysicsAnimator.addUpdateListener(
+ (target, values) -> updateAction.run());
}
- return toBounds;
+
+ startBoundsAnimation();
}
/**
* Flings the PiP to the closest snap target.
*/
- Rect flingToSnapTarget(float velocity, float velocityX, float velocityY, Rect movementBounds,
- AnimatorUpdateListener updateListener, AnimatorListener listener,
- Point startPosition) {
- cancelAnimations();
- Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mBounds,
- velocityX, velocityY, startPosition);
- if (!mBounds.equals(toBounds)) {
- mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, 0, FAST_OUT_SLOW_IN);
- mFlingAnimationUtils.apply(mBoundsAnimator, 0,
- distanceBetweenRectOffsets(mBounds, toBounds),
- velocity);
- if (updateListener != null) {
- mBoundsAnimator.addUpdateListener(updateListener);
- }
- if (listener != null){
- mBoundsAnimator.addListener(listener);
- }
- mBoundsAnimator.start();
- }
- return toBounds;
+ void flingToSnapTarget(
+ float velocityX, float velocityY, Rect movementBounds, Runnable updateAction,
+ @Nullable Runnable endAction) {
+ prepareForBoundsAnimation(movementBounds);
+
+ mAnimatedBoundsPhysicsAnimator
+ .flingThenSpring(
+ FloatProperties.RECT_X, velocityX, mFlingConfigX, mSpringConfig,
+ true /* flingMustReachMinOrMax */)
+ .flingThenSpring(
+ FloatProperties.RECT_Y, velocityY, mFlingConfigY, mSpringConfig)
+ .addUpdateListener((target, values) -> updateAction.run())
+ .withEndActions(endAction);
+
+ startBoundsAnimation();
}
/**
* Animates the PiP to the closest snap target.
*/
- Rect animateToClosestSnapTarget(Rect movementBounds, AnimatorUpdateListener updateListener,
- AnimatorListener listener) {
- cancelAnimations();
- Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mBounds);
- if (!mBounds.equals(toBounds)) {
- mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, SNAP_STACK_DURATION,
- FAST_OUT_SLOW_IN);
- if (updateListener != null) {
- mBoundsAnimator.addUpdateListener(updateListener);
- }
- if (listener != null){
- mBoundsAnimator.addListener(listener);
- }
- mBoundsAnimator.start();
+ void animateToClosestSnapTarget(Rect movementBounds) {
+ prepareForBoundsAnimation(movementBounds);
+
+ final Rect toBounds = mSnapAlgorithm.findClosestSnapBounds(movementBounds, mBounds);
+ mAnimatedBoundsPhysicsAnimator
+ .spring(FloatProperties.RECT_X, toBounds.left, mSpringConfig)
+ .spring(FloatProperties.RECT_Y, toBounds.top, mSpringConfig);
+
+ startBoundsAnimation();
+ }
+
+ /**
+ * Animates the dismissal of the PiP off the edge of the screen.
+ */
+ void animateDismiss(float velocityX, float velocityY, @Nullable Runnable updateAction) {
+ final float velocity = PointF.length(velocityX, velocityY);
+ final boolean isFling = velocity > mFlingAnimationUtils.getMinVelocityPxPerSecond();
+ final Point dismissEndPoint = getDismissEndPoint(mBounds, velocityX, velocityY, isFling);
+
+ // Set the animated bounds to start at the current bounds. We don't need to rebuild the
+ // fling configs here via prepareForBoundsAnimation, since animateDismiss isn't provided
+ // with new movement bounds.
+ mAnimatedBounds.set(mBounds);
+
+ // Animate to the dismiss end point, and then dismiss PIP.
+ mAnimatedBoundsPhysicsAnimator
+ .spring(FloatProperties.RECT_X, dismissEndPoint.x, velocityX, mSpringConfig)
+ .spring(FloatProperties.RECT_Y, dismissEndPoint.y, velocityY, mSpringConfig)
+ .withEndActions(this::dismissPip);
+
+ // If we were provided with an update action, run it whenever there's an update.
+ if (updateAction != null) {
+ mAnimatedBoundsPhysicsAnimator.addUpdateListener(
+ (target, values) -> updateAction.run());
}
- return toBounds;
+
+ startBoundsAnimation();
}
/**
@@ -378,64 +425,42 @@
}
/**
- * Animates the dismissal of the PiP off the edge of the screen.
- */
- Rect animateDismiss(Rect pipBounds, float velocityX, float velocityY,
- AnimatorUpdateListener listener) {
- cancelAnimations();
- final float velocity = PointF.length(velocityX, velocityY);
- final boolean isFling = velocity > mFlingAnimationUtils.getMinVelocityPxPerSecond();
- Point p = getDismissEndPoint(pipBounds, velocityX, velocityY, isFling);
- Rect toBounds = new Rect(pipBounds);
- toBounds.offsetTo(p.x, p.y);
- mBoundsAnimator = createAnimationToBounds(mBounds, toBounds, DRAG_TO_DISMISS_STACK_DURATION,
- FAST_OUT_LINEAR_IN);
- mBoundsAnimator.addListener(new AnimatorListenerAdapter() {
- @Override
- public void onAnimationEnd(Animator animation) {
- dismissPip();
- }
- });
- if (isFling) {
- mFlingAnimationUtils.apply(mBoundsAnimator, 0,
- distanceBetweenRectOffsets(mBounds, toBounds), velocity);
- }
- if (listener != null) {
- mBoundsAnimator.addUpdateListener(listener);
- }
- mBoundsAnimator.start();
- return toBounds;
- }
-
- /**
* Cancels all existing animations.
*/
- void cancelAnimations() {
- if (mBoundsAnimator != null) {
- mBoundsAnimator.cancel();
- mBoundsAnimator = null;
- }
+ private void cancelAnimations() {
+ mAnimatedBoundsPhysicsAnimator.cancel();
+ mVsyncTimeAnimator.cancel();
}
/**
- * Creates an animation to move the PiP to give given {@param toBounds}.
+ * Set new fling configs whose min/max values respect the given movement bounds, and set the
+ * animated bounds to PIP's current 'real' bounds.
*/
- private ValueAnimator createAnimationToBounds(Rect fromBounds, Rect toBounds, int duration,
- Interpolator interpolator) {
- ValueAnimator anim = new ValueAnimator() {
- @Override
- public AnimationHandler getAnimationHandler() {
- return mAnimationHandler;
- }
- };
- anim.setObjectValues(fromBounds, toBounds);
- anim.setEvaluator(RECT_EVALUATOR);
- anim.setDuration(duration);
- anim.setInterpolator(interpolator);
- anim.addUpdateListener((ValueAnimator animation) -> {
- resizePipUnchecked((Rect) animation.getAnimatedValue());
- });
- return anim;
+ private void prepareForBoundsAnimation(Rect movementBounds) {
+ mFlingConfigX = new PhysicsAnimator.FlingConfig(
+ DEFAULT_FRICTION, movementBounds.left, movementBounds.right);
+ mFlingConfigY = new PhysicsAnimator.FlingConfig(
+ DEFAULT_FRICTION, movementBounds.top, movementBounds.bottom);
+
+ mAnimatedBounds.set(mBounds);
+ }
+
+ /**
+ * Starts the physics animator which will update the animated PIP bounds using physics
+ * animations, as well as the TimeAnimator which will apply those bounds to PIP at intervals
+ * synchronized with the SurfaceFlinger vsync frame provider.
+ *
+ * This will also add end actions to the bounds animator that cancel the TimeAnimator and update
+ * the 'real' bounds to equal the final animated bounds.
+ */
+ private void startBoundsAnimation() {
+ cancelAnimations();
+
+ mAnimatedBoundsPhysicsAnimator
+ .withEndActions(
+ mVsyncTimeAnimator::cancel)
+ .start();
+ mVsyncTimeAnimator.start();
}
/**
diff --git a/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java b/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java
index 95e3444..09f1638 100644
--- a/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java
+++ b/packages/SystemUI/src/com/android/systemui/pip/phone/PipTouchHandler.java
@@ -20,10 +20,6 @@
import static com.android.systemui.pip.phone.PipMenuActivityController.MENU_STATE_FULL;
import static com.android.systemui.pip.phone.PipMenuActivityController.MENU_STATE_NONE;
-import android.animation.Animator;
-import android.animation.AnimatorListenerAdapter;
-import android.animation.ValueAnimator;
-import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.app.IActivityManager;
import android.app.IActivityTaskManager;
import android.content.ComponentName;
@@ -111,13 +107,6 @@
}
}
};
- private ValueAnimator.AnimatorUpdateListener mUpdateScrimListener =
- new AnimatorUpdateListener() {
- @Override
- public void onAnimationUpdate(ValueAnimator animation) {
- updateDismissFraction();
- }
- };
// Behaviour states
private int mMenuState = MENU_STATE_NONE;
@@ -162,7 +151,7 @@
@Override
public void onPipMinimize() {
setMinimizedStateInternal(true);
- mMotionHelper.animateToClosestMinimizedState(mMovementBounds, null /* updateListener */);
+ mMotionHelper.animateToClosestMinimizedState(mMovementBounds, null /* updateAction */);
}
@Override
@@ -655,15 +644,6 @@
float lastY = mStartPosition.y + mDelta.y;
float left = lastX + lastDelta.x;
float top = lastY + lastDelta.y;
- if (!touchState.allowDraggingOffscreen() || !ENABLE_MINIMIZE) {
- left = Math.max(mMovementBounds.left, Math.min(mMovementBounds.right, left));
- }
- if (mEnableDimissDragToEdge) {
- // Allow pip to move past bottom bounds
- top = Math.max(mMovementBounds.top, top);
- } else {
- top = Math.max(mMovementBounds.top, Math.min(mMovementBounds.bottom, top));
- }
// Add to the cumulative delta after bounding the position
mDelta.x += left - lastX;
@@ -720,8 +700,9 @@
if (mMotionHelper.shouldDismissPip() || isFlingToBot) {
MetricsLoggerWrapper.logPictureInPictureDismissByDrag(mContext,
PipUtils.getTopPinnedActivity(mContext, mActivityManager));
- mMotionHelper.animateDismiss(mMotionHelper.getBounds(), vel.x,
- vel.y, mUpdateScrimListener);
+ mMotionHelper.animateDismiss(
+ vel.x, vel.y,
+ PipTouchHandler.this::updateDismissFraction /* updateAction */);
return true;
}
}
@@ -739,8 +720,9 @@
// minimize offset adjusted
mMenuController.hideMenu();
} else {
- mMotionHelper.animateToClosestMinimizedState(mMovementBounds,
- mUpdateScrimListener);
+ mMotionHelper.animateToClosestMinimizedState(
+ mMovementBounds,
+ PipTouchHandler.this::updateDismissFraction /* updateAction */);
}
return true;
}
@@ -750,7 +732,7 @@
setMinimizedStateInternal(false);
}
- AnimatorListenerAdapter postAnimationCallback = null;
+ Runnable endAction = null;
if (mMenuState != MENU_STATE_NONE) {
// If the menu is still visible, and we aren't minimized, then just poke the
// menu so that it will timeout after the user stops touching it
@@ -759,26 +741,20 @@
} else {
// If the menu is not visible, then we can still be showing the activity for the
// dismiss overlay, so just finish it after the animation completes
- postAnimationCallback = new AnimatorListenerAdapter() {
- @Override
- public void onAnimationEnd(Animator animation) {
- mMenuController.hideMenu();
- }
- };
+ endAction = mMenuController::hideMenu;
}
if (isFling) {
- mMotionHelper.flingToSnapTarget(velocity, vel.x, vel.y, mMovementBounds,
- mUpdateScrimListener, postAnimationCallback,
- mStartPosition);
+ mMotionHelper.flingToSnapTarget(
+ vel.x, vel.y, mMovementBounds,
+ PipTouchHandler.this::updateDismissFraction /* updateAction */,
+ endAction /* endAction */);
} else {
- mMotionHelper.animateToClosestSnapTarget(mMovementBounds, mUpdateScrimListener,
- postAnimationCallback);
+ mMotionHelper.animateToClosestSnapTarget(mMovementBounds);
}
} else if (mIsMinimized) {
// This was a tap, so no longer minimized
- mMotionHelper.animateToClosestSnapTarget(mMovementBounds, null /* updateListener */,
- null /* animatorListener */);
+ mMotionHelper.animateToClosestSnapTarget(mMovementBounds);
setMinimizedStateInternal(false);
} else if (mTouchState.isDoubleTap()) {
// Expand to fullscreen if this is a double tap
diff --git a/packages/SystemUI/src/com/android/systemui/qs/tiles/UiModeNightTile.java b/packages/SystemUI/src/com/android/systemui/qs/tiles/UiModeNightTile.java
index 7bc2a0d..8f1769b 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/tiles/UiModeNightTile.java
+++ b/packages/SystemUI/src/com/android/systemui/qs/tiles/UiModeNightTile.java
@@ -33,6 +33,8 @@
import com.android.systemui.statusbar.policy.ConfigurationController;
import javax.inject.Inject;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
/**
* Quick Settings tile for: Night Mode / Dark Theme / Dark Mode.
@@ -43,7 +45,7 @@
public class UiModeNightTile extends QSTileImpl<QSTile.BooleanState> implements
ConfigurationController.ConfigurationListener,
BatteryController.BatteryStateChangeCallback {
-
+ public static DateTimeFormatter formatter = DateTimeFormatter.ofPattern("hh:mm a");
private final Icon mIcon = ResourceIcon.get(
com.android.internal.R.drawable.ic_qs_ui_mode_night);
private final UiModeManager mUiModeManager;
@@ -88,17 +90,28 @@
protected void handleUpdateState(BooleanState state, Object arg) {
int uiMode = mUiModeManager.getNightMode();
boolean powerSave = mBatteryController.isPowerSave();
- boolean isAuto = uiMode == UiModeManager.MODE_NIGHT_AUTO;
boolean nightMode = (mContext.getResources().getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES;
if (powerSave) {
state.secondaryLabel = mContext.getResources().getString(
R.string.quick_settings_dark_mode_secondary_label_battery_saver);
- } else if (isAuto) {
+ } else if (uiMode == UiModeManager.MODE_NIGHT_AUTO) {
state.secondaryLabel = mContext.getResources().getString(nightMode
? R.string.quick_settings_dark_mode_secondary_label_until_sunrise
: R.string.quick_settings_dark_mode_secondary_label_on_at_sunset);
+ } else if (uiMode == UiModeManager.MODE_NIGHT_CUSTOM) {
+ final boolean use24HourFormat = android.text.format.DateFormat.is24HourFormat(mContext);
+ final LocalTime time;
+ if (nightMode) {
+ time = mUiModeManager.getCustomNightModeEnd();
+ } else {
+ time = mUiModeManager.getCustomNightModeStart();
+ }
+ state.secondaryLabel = mContext.getResources().getString(nightMode
+ ? R.string.quick_settings_dark_mode_secondary_label_until
+ : R.string.quick_settings_dark_mode_secondary_label_on_at,
+ use24HourFormat ? time.toString() : formatter.format(time));
} else {
state.secondaryLabel = null;
}
diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java
index 27c9555..50e9a51 100644
--- a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java
+++ b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2011 The Android Open Source Project
+ * Copyright (C) 2020 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.
@@ -29,19 +29,21 @@
import android.animation.ValueAnimator;
import android.animation.ValueAnimator.AnimatorUpdateListener;
import android.annotation.Nullable;
+import android.app.ActivityManager;
import android.app.ActivityOptions;
import android.app.Notification;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
-import android.content.res.Configuration;
import android.content.res.Resources;
import android.graphics.Bitmap;
-import android.graphics.Color;
+import android.graphics.Outline;
import android.graphics.PixelFormat;
import android.graphics.PointF;
import android.graphics.Rect;
+import android.graphics.Region;
+import android.graphics.drawable.Icon;
import android.media.MediaActionSound;
import android.net.Uri;
import android.os.AsyncTask;
@@ -49,6 +51,7 @@
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
+import android.os.RemoteException;
import android.os.UserHandle;
import android.provider.DeviceConfig;
import android.util.DisplayMetrics;
@@ -60,8 +63,11 @@
import android.view.SurfaceControl;
import android.view.View;
import android.view.ViewGroup;
+import android.view.ViewOutlineProvider;
+import android.view.ViewTreeObserver;
import android.view.WindowManager;
import android.view.animation.Interpolator;
+import android.widget.HorizontalScrollView;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.Toast;
@@ -87,7 +93,7 @@
* Class for handling device screen shots
*/
@Singleton
-public class GlobalScreenshot {
+public class GlobalScreenshot implements ViewTreeObserver.OnComputeInternalInsetsListener {
/**
* POD used in the AsyncTask which saves an image in the background.
@@ -98,6 +104,7 @@
public Consumer<Uri> finisher;
public GlobalScreenshot.ActionsReadyListener mActionsReadyListener;
public int errorMsgResId;
+ public boolean createDeleteAction;
void clearImage() {
image = null;
@@ -106,7 +113,8 @@
}
abstract static class ActionsReadyListener {
- abstract void onActionsReady(Uri imageUri, List<Notification.Action> actions);
+ abstract void onActionsReady(Uri imageUri, List<Notification.Action> smartActions,
+ List<Notification.Action> actions);
}
// These strings are used for communicating the action invoked to
@@ -130,38 +138,36 @@
private static final int SCREENSHOT_DROP_OUT_DELAY = 500;
private static final int SCREENSHOT_DROP_OUT_DURATION = 430;
private static final int SCREENSHOT_DROP_OUT_SCALE_DURATION = 370;
- private static final int SCREENSHOT_FAST_DROP_OUT_DURATION = 320;
private static final float BACKGROUND_ALPHA = 0.5f;
- private static final float SCREENSHOT_SCALE = 1f;
- private static final float SCREENSHOT_DROP_IN_MIN_SCALE = SCREENSHOT_SCALE * 0.725f;
- private static final float SCREENSHOT_DROP_OUT_MIN_SCALE = SCREENSHOT_SCALE * 0.45f;
- private static final float SCREENSHOT_CORNER_MIN_SCALE = SCREENSHOT_SCALE * 0.2f;
- private static final float SCREENSHOT_FAST_DROP_OUT_MIN_SCALE = SCREENSHOT_SCALE * 0.6f;
- private static final float SCREENSHOT_DROP_OUT_MIN_SCALE_OFFSET = 0f;
- private static final float SCREENSHOT_CORNER_MIN_SCALE_OFFSET = .1f;
+ private static final float SCREENSHOT_DROP_IN_MIN_SCALE = 0.725f;
+ private static final float ROUNDED_CORNER_RADIUS = .05f;
private static final long SCREENSHOT_CORNER_TIMEOUT_MILLIS = 8000;
private static final int MESSAGE_CORNER_TIMEOUT = 2;
private final ScreenshotNotificationsController mNotificationsController;
- private Context mContext;
- private WindowManager mWindowManager;
- private WindowManager.LayoutParams mWindowLayoutParams;
- private Display mDisplay;
- private DisplayMetrics mDisplayMetrics;
+ private final Context mContext;
+ private final WindowManager mWindowManager;
+ private final WindowManager.LayoutParams mWindowLayoutParams;
+ private final Display mDisplay;
+ private final DisplayMetrics mDisplayMetrics;
+
+ private final View mScreenshotLayout;
+ private final ScreenshotSelectorView mScreenshotSelectorView;
+ private final ImageView mBackgroundView;
+ private final ImageView mScreenshotView;
+ private final ImageView mScreenshotFlash;
+ private final HorizontalScrollView mActionsContainer;
+ private final LinearLayout mActionsView;
+ private final ImageView mBackgroundProtection;
private Bitmap mScreenBitmap;
- private View mScreenshotLayout;
- private ScreenshotSelectorView mScreenshotSelectorView;
- private ImageView mBackgroundView;
- private ImageView mScreenshotView;
- private ImageView mScreenshotFlash;
- private LinearLayout mActionsView;
-
private AnimatorSet mScreenshotAnimation;
- private float mBgPadding;
- private float mBgPaddingScale;
+ private float mScreenshotOffsetXPx;
+ private float mScreenshotOffsetYPx;
+ private float mScreenshotHeightPx;
+ private float mCornerScale;
private AsyncTask<Void, Void, Void> mSaveInBgTask;
@@ -172,7 +178,7 @@
public void handleMessage(Message msg) {
switch (msg.what) {
case MESSAGE_CORNER_TIMEOUT:
- GlobalScreenshot.this.clearScreenshot();
+ GlobalScreenshot.this.clearScreenshot("timeout");
break;
default:
break;
@@ -194,7 +200,20 @@
mScreenshotLayout = layoutInflater.inflate(R.layout.global_screenshot, null);
mBackgroundView = mScreenshotLayout.findViewById(R.id.global_screenshot_background);
mScreenshotView = mScreenshotLayout.findViewById(R.id.global_screenshot);
+ mScreenshotView.setClipToOutline(true);
+ mScreenshotView.setOutlineProvider(new ViewOutlineProvider() {
+ @Override
+ public void getOutline(View view, Outline outline) {
+ outline.setRoundRect(new Rect(0, 0, view.getWidth(), view.getHeight()),
+ ROUNDED_CORNER_RADIUS * view.getWidth());
+ }
+ });
+
+ mActionsContainer = mScreenshotLayout.findViewById(
+ R.id.global_screenshot_actions_container);
mActionsView = mScreenshotLayout.findViewById(R.id.global_screenshot_actions);
+ mBackgroundProtection = mScreenshotLayout.findViewById(
+ R.id.global_screenshot_actions_background);
mScreenshotFlash = mScreenshotLayout.findViewById(R.id.global_screenshot_flash);
mScreenshotSelectorView = mScreenshotLayout.findViewById(R.id.global_screenshot_selector);
@@ -202,6 +221,9 @@
mScreenshotSelectorView.setFocusable(true);
mScreenshotSelectorView.setFocusableInTouchMode(true);
mScreenshotLayout.setOnTouchListener((v, event) -> {
+ if (event.getAction() == MotionEvent.ACTION_OUTSIDE) {
+ clearScreenshot("tap_outside");
+ }
// Intercept and ignore all touch events
return true;
});
@@ -212,6 +234,8 @@
WindowManager.LayoutParams.TYPE_SCREENSHOT,
WindowManager.LayoutParams.FLAG_FULLSCREEN
| WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
+ | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
+ | WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH
| WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED,
PixelFormat.TRANSLUCENT);
mWindowLayoutParams.setTitle("ScreenshotAnimation");
@@ -222,16 +246,33 @@
mDisplayMetrics = new DisplayMetrics();
mDisplay.getRealMetrics(mDisplayMetrics);
- // Scale has to account for both sides of the bg
- mBgPadding = (float) resources.getDimensionPixelSize(R.dimen.global_screenshot_bg_padding);
- mBgPaddingScale = mBgPadding / mDisplayMetrics.widthPixels;
-
+ mScreenshotOffsetXPx = resources.getDimensionPixelSize(R.dimen.screenshot_offset_x);
+ mScreenshotOffsetYPx = resources.getDimensionPixelSize(R.dimen.screenshot_offset_y);
+ mScreenshotHeightPx =
+ resources.getDimensionPixelSize(R.dimen.screenshot_action_container_offset_y);
+ mCornerScale = resources.getDimensionPixelSize(R.dimen.global_screenshot_x_scale)
+ / (float) mDisplayMetrics.widthPixels;
// Setup the Camera shutter sound
mCameraSound = new MediaActionSound();
mCameraSound.load(MediaActionSound.SHUTTER_CLICK);
}
+ @Override // ViewTreeObserver.OnComputeInternalInsetsListener
+ public void onComputeInternalInsets(ViewTreeObserver.InternalInsetsInfo inoutInfo) {
+ inoutInfo.setTouchableInsets(ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_REGION);
+ Region touchRegion = new Region();
+
+ Rect screenshotRect = new Rect();
+ mScreenshotView.getBoundsOnScreen(screenshotRect);
+ touchRegion.op(screenshotRect, Region.Op.UNION);
+ Rect actionsRect = new Rect();
+ mActionsContainer.getBoundsOnScreen(actionsRect);
+ touchRegion.op(actionsRect, Region.Op.UNION);
+
+ inoutInfo.touchableRegion.set(touchRegion);
+ }
+
/**
* Creates a new worker thread and saves the screenshot to the media store.
*/
@@ -241,6 +282,7 @@
data.image = mScreenBitmap;
data.finisher = finisher;
data.mActionsReadyListener = actionsReadyListener;
+ data.createDeleteAction = false;
if (mSaveInBgTask != null) {
mSaveInBgTask.cancel(false);
}
@@ -252,6 +294,8 @@
* Takes a screenshot of the current display and shows an animation.
*/
private void takeScreenshot(Consumer<Uri> finisher, Rect crop) {
+ clearScreenshot("new screenshot requested");
+
int rot = mDisplay.getRotation();
int width = crop.width();
int height = crop.height();
@@ -269,6 +313,9 @@
mScreenBitmap.setHasAlpha(false);
mScreenBitmap.prepareToDraw();
+ mWindowManager.addView(mScreenshotLayout, mWindowLayoutParams);
+ mScreenshotLayout.getViewTreeObserver().addOnComputeInternalInsetsListener(this);
+
// Start the post-screenshot animation
startAnimation(finisher, mDisplayMetrics.widthPixels, mDisplayMetrics.heightPixels);
}
@@ -314,12 +361,9 @@
return false;
}
});
- mScreenshotLayout.post(new Runnable() {
- @Override
- public void run() {
- mScreenshotSelectorView.setVisibility(View.VISIBLE);
- mScreenshotSelectorView.requestFocus();
- }
+ mScreenshotLayout.post(() -> {
+ mScreenshotSelectorView.setVisibility(View.VISIBLE);
+ mScreenshotSelectorView.requestFocus();
});
}
@@ -337,16 +381,20 @@
/**
* Clears current screenshot
*/
- private void clearScreenshot() {
+ private void clearScreenshot(String reason) {
+ Log.e(TAG, "clearing screenshot: " + reason);
if (mScreenshotLayout.isAttachedToWindow()) {
mWindowManager.removeView(mScreenshotLayout);
}
+ mScreenshotHandler.removeMessages(MESSAGE_CORNER_TIMEOUT);
+ mScreenshotLayout.getViewTreeObserver().removeOnComputeInternalInsetsListener(this);
// Clear any references to the bitmap
mScreenBitmap = null;
mScreenshotView.setImageBitmap(null);
- mActionsView.setVisibility(View.GONE);
+ mActionsContainer.setVisibility(View.GONE);
mBackgroundView.setVisibility(View.GONE);
+ mBackgroundProtection.setAlpha(0f);
mScreenshotView.setVisibility(View.GONE);
mScreenshotView.setLayerType(View.LAYER_TYPE_NONE, null);
}
@@ -374,7 +422,6 @@
mScreenshotAnimation.removeAllListeners();
}
- mWindowManager.addView(mScreenshotLayout, mWindowLayoutParams);
ValueAnimator screenshotDropInAnim = createScreenshotDropInAnimation();
ValueAnimator screenshotFadeOutAnim = createScreenshotToCornerAnimation(w, h);
mScreenshotAnimation = new AnimatorSet();
@@ -385,16 +432,19 @@
// Save the screenshot once we have a bit of time now
saveScreenshotInWorkerThread(finisher, new ActionsReadyListener() {
@Override
- void onActionsReady(Uri uri, List<Notification.Action> actions) {
+ void onActionsReady(Uri uri, List<Notification.Action> smartActions,
+ List<Notification.Action> actions) {
if (uri == null) {
mNotificationsController.notifyScreenshotError(
R.string.screenshot_failed_to_capture_text);
} else {
mScreenshotHandler.post(() ->
- createScreenshotActionsShadeAnimation(actions).start());
+ createScreenshotActionsShadeAnimation(smartActions,
+ actions).start());
}
}
});
+ mScreenshotHandler.removeMessages(MESSAGE_CORNER_TIMEOUT);
mScreenshotHandler.sendMessageDelayed(
mScreenshotHandler.obtainMessage(MESSAGE_CORNER_TIMEOUT),
SCREENSHOT_CORNER_TIMEOUT_MILLIS);
@@ -435,14 +485,6 @@
}
};
- Resources r = mContext.getResources();
- if ((r.getConfiguration().uiMode & Configuration.UI_MODE_NIGHT_MASK)
- == Configuration.UI_MODE_NIGHT_YES) {
- mScreenshotView.getBackground().setTint(Color.BLACK);
- } else {
- mScreenshotView.getBackground().setTintList(null);
- }
-
ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
anim.setDuration(SCREENSHOT_DROP_IN_DURATION);
anim.addListener(new AnimatorListenerAdapter() {
@@ -453,8 +495,8 @@
mScreenshotView.setAlpha(0f);
mScreenshotView.setTranslationX(0f);
mScreenshotView.setTranslationY(0f);
- mScreenshotView.setScaleX(SCREENSHOT_SCALE + mBgPaddingScale);
- mScreenshotView.setScaleY(SCREENSHOT_SCALE + mBgPaddingScale);
+ mScreenshotView.setScaleX(1);
+ mScreenshotView.setScaleY(1);
mScreenshotView.setVisibility(View.VISIBLE);
mScreenshotFlash.setAlpha(0f);
mScreenshotFlash.setVisibility(View.VISIBLE);
@@ -469,9 +511,8 @@
@Override
public void onAnimationUpdate(ValueAnimator animation) {
float t = (Float) animation.getAnimatedValue();
- float scaleT = (SCREENSHOT_SCALE + mBgPaddingScale)
- - scaleInterpolator.getInterpolation(t)
- * (SCREENSHOT_SCALE - SCREENSHOT_DROP_IN_MIN_SCALE);
+ float scaleT = 1 - (scaleInterpolator.getInterpolation(t)
+ * (1 - SCREENSHOT_DROP_IN_MIN_SCALE));
mBackgroundView.setAlpha(scaleInterpolator.getInterpolation(t) * BACKGROUND_ALPHA);
mScreenshotView.setAlpha(t);
mScreenshotView.setScaleX(scaleT);
@@ -500,20 +541,19 @@
};
// Determine the bounds of how to scale
- float halfScreenWidth = (w - 2f * mBgPadding) / 2f;
- float halfScreenHeight = (h - 2f * mBgPadding) / 2f;
- final float offsetPct = SCREENSHOT_CORNER_MIN_SCALE_OFFSET;
+ float halfScreenWidth = w / 2f;
+ float halfScreenHeight = h / 2f;
final PointF finalPos = new PointF(
- -halfScreenWidth + (SCREENSHOT_CORNER_MIN_SCALE + offsetPct) * halfScreenWidth,
- halfScreenHeight - (SCREENSHOT_CORNER_MIN_SCALE + offsetPct) * halfScreenHeight);
+ -halfScreenWidth + mCornerScale * halfScreenWidth + mScreenshotOffsetXPx,
+ halfScreenHeight - mCornerScale * halfScreenHeight - mScreenshotOffsetYPx);
// Animate the screenshot to the bottom left corner
anim.setDuration(SCREENSHOT_DROP_OUT_DURATION);
anim.addUpdateListener(animation -> {
float t = (Float) animation.getAnimatedValue();
- float scaleT = (SCREENSHOT_DROP_IN_MIN_SCALE + mBgPaddingScale)
+ float scaleT = (SCREENSHOT_DROP_IN_MIN_SCALE)
- scaleInterpolator.getInterpolation(t)
- * (SCREENSHOT_DROP_IN_MIN_SCALE - SCREENSHOT_CORNER_MIN_SCALE);
+ * (SCREENSHOT_DROP_IN_MIN_SCALE - mCornerScale);
mBackgroundView.setAlpha((1f - t) * BACKGROUND_ALPHA);
mScreenshotView.setScaleX(scaleT);
mScreenshotView.setScaleY(scaleT);
@@ -523,24 +563,48 @@
return anim;
}
- private ValueAnimator createScreenshotActionsShadeAnimation(List<Notification.Action> actions) {
+ private ValueAnimator createScreenshotActionsShadeAnimation(
+ List<Notification.Action> smartActions, List<Notification.Action> actions) {
LayoutInflater inflater = LayoutInflater.from(mContext);
mActionsView.removeAllViews();
+ mActionsContainer.setScrollX(0);
+ mScreenshotLayout.invalidate();
+ mScreenshotLayout.requestLayout();
+ mScreenshotLayout.getViewTreeObserver().dispatchOnGlobalLayout();
+
+ // By default the activities won't be able to start immediately; override this to keep
+ // the same behavior as if started from a notification
+ try {
+ ActivityManager.getService().resumeAppSwitches();
+ } catch (RemoteException e) {
+ }
+
+ for (Notification.Action smartAction : smartActions) {
+ ScreenshotActionChip actionChip = (ScreenshotActionChip) inflater.inflate(
+ R.layout.global_screenshot_action_chip, mActionsView, false);
+ actionChip.setText(smartAction.title);
+ actionChip.setIcon(smartAction.getIcon(), false);
+ actionChip.setPendingIntent(smartAction.actionIntent,
+ () -> clearScreenshot("chip tapped"));
+ mActionsView.addView(actionChip);
+ }
for (Notification.Action action : actions) {
ScreenshotActionChip actionChip = (ScreenshotActionChip) inflater.inflate(
R.layout.global_screenshot_action_chip, mActionsView, false);
actionChip.setText(action.title);
actionChip.setIcon(action.getIcon(), true);
- actionChip.setOnClickListener(v -> {
- try {
- action.actionIntent.send();
- clearScreenshot();
- } catch (PendingIntent.CanceledException e) {
- Log.e(TAG,
- String.format("Intent cancelled (title: %s)", action.title), e);
- }
- });
+ actionChip.setPendingIntent(action.actionIntent, () -> clearScreenshot("chip tapped"));
+ if (action.actionIntent.getIntent().getAction().equals(Intent.ACTION_EDIT)) {
+ mScreenshotView.setOnClickListener(v -> {
+ try {
+ action.actionIntent.send();
+ clearScreenshot("screenshot preview tapped");
+ } catch (PendingIntent.CanceledException e) {
+ Log.e(TAG, "Intent cancelled", e);
+ }
+ });
+ }
mActionsView.addView(actionChip);
}
@@ -550,27 +614,29 @@
Toast scrollNotImplemented = Toast.makeText(
mContext, "Not implemented", Toast.LENGTH_SHORT);
scrollChip.setText("Extend"); // TODO (mkephart): add resource and translate
+ scrollChip.setIcon(
+ Icon.createWithResource(mContext, R.drawable.ic_arrow_downward), true);
scrollChip.setOnClickListener(v -> scrollNotImplemented.show());
mActionsView.addView(scrollChip);
}
ValueAnimator animator = ValueAnimator.ofFloat(0, 1);
- mActionsView.setY(mDisplayMetrics.heightPixels);
- mActionsView.setVisibility(VISIBLE);
- mActionsView.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
- float actionsViewHeight = mActionsView.getMeasuredHeight();
- float screenshotStartHeight = mScreenshotView.getTranslationY();
+ mActionsContainer.setY(mDisplayMetrics.heightPixels);
+ mActionsContainer.setVisibility(VISIBLE);
+ mActionsContainer.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
+ float actionsViewHeight = mActionsContainer.getMeasuredHeight() + mScreenshotHeightPx;
animator.addUpdateListener(animation -> {
float t = animation.getAnimatedFraction();
- mScreenshotView.setTranslationY(screenshotStartHeight - actionsViewHeight * t);
- mActionsView.setY(mDisplayMetrics.heightPixels - actionsViewHeight * t);
+ mBackgroundProtection.setAlpha(t);
+ mActionsContainer.setY(mDisplayMetrics.heightPixels - actionsViewHeight * t);
});
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
mScreenshotView.requestFocus();
+ mScreenshotView.setElevation(50);
}
});
return animator;
diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshotLegacy.java b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshotLegacy.java
index 11aa80b..16447fb 100644
--- a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshotLegacy.java
+++ b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshotLegacy.java
@@ -184,6 +184,7 @@
data.image = mScreenBitmap;
data.finisher = finisher;
data.mActionsReadyListener = actionsReadyListener;
+ data.createDeleteAction = true;
if (mSaveInBgTask != null) {
mSaveInBgTask.cancel(false);
}
@@ -264,12 +265,9 @@
return false;
}
});
- mScreenshotLayout.post(new Runnable() {
- @Override
- public void run() {
- mScreenshotSelectorView.setVisibility(View.VISIBLE);
- mScreenshotSelectorView.requestFocus();
- }
+ mScreenshotLayout.post(() -> {
+ mScreenshotSelectorView.setVisibility(View.VISIBLE);
+ mScreenshotSelectorView.requestFocus();
});
}
@@ -326,8 +324,8 @@
mWindowManager.addView(mScreenshotLayout, mWindowLayoutParams);
ValueAnimator screenshotDropInAnim = createScreenshotDropInAnimation();
- ValueAnimator screenshotFadeOutAnim = createScreenshotDropOutAnimation(w, h,
- statusBarVisible, navBarVisible);
+ ValueAnimator screenshotFadeOutAnim =
+ createScreenshotDropOutAnimation(w, h, statusBarVisible, navBarVisible);
mScreenshotAnimation = new AnimatorSet();
mScreenshotAnimation.playSequentially(screenshotDropInAnim, screenshotFadeOutAnim);
mScreenshotAnimation.addListener(new AnimatorListenerAdapter() {
@@ -336,13 +334,14 @@
// Save the screenshot once we have a bit of time now
saveScreenshotInWorkerThread(finisher, new GlobalScreenshot.ActionsReadyListener() {
@Override
- void onActionsReady(Uri uri, List<Notification.Action> actions) {
+ void onActionsReady(Uri uri, List<Notification.Action> smartActions,
+ List<Notification.Action> actions) {
if (uri == null) {
mNotificationsController.notifyScreenshotError(
R.string.screenshot_failed_to_capture_text);
} else {
- mNotificationsController.showScreenshotActionsNotification(
- uri, actions);
+ mNotificationsController
+ .showScreenshotActionsNotification(uri, smartActions, actions);
}
}
});
diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/SaveImageInBackgroundTask.java b/packages/SystemUI/src/com/android/systemui/screenshot/SaveImageInBackgroundTask.java
index 6bad15c..e6082dd 100644
--- a/packages/SystemUI/src/com/android/systemui/screenshot/SaveImageInBackgroundTask.java
+++ b/packages/SystemUI/src/com/android/systemui/screenshot/SaveImageInBackgroundTask.java
@@ -65,7 +65,6 @@
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
-import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Objects;
@@ -90,6 +89,7 @@
private final ScreenshotNotificationSmartActionsProvider mSmartActionsProvider;
private final String mScreenshotId;
private final boolean mSmartActionsEnabled;
+ private final boolean mCreateDeleteAction;
private final Random mRandom = new Random();
SaveImageInBackgroundTask(Context context, GlobalScreenshot.SaveImageInBackgroundData data) {
@@ -102,6 +102,8 @@
mImageFileName = String.format(SCREENSHOT_FILE_NAME_TEMPLATE, imageDate);
mScreenshotId = String.format(SCREENSHOT_ID_TEMPLATE, UUID.randomUUID());
+ mCreateDeleteAction = data.createDeleteAction;
+
// Initialize screenshot notification smart actions provider.
mSmartActionsEnabled = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI,
SystemUiDeviceConfigFlags.ENABLE_SCREENSHOT_NOTIFICATION_SMART_ACTIONS, false);
@@ -196,8 +198,20 @@
}
List<Notification.Action> actions =
- populateNotificationActions(mContext, r, uri, smartActionsFuture);
- mParams.mActionsReadyListener.onActionsReady(uri, actions);
+ populateNotificationActions(mContext, r, uri);
+ List<Notification.Action> smartActions = new ArrayList<>();
+ if (mSmartActionsEnabled) {
+ int timeoutMs = DeviceConfig.getInt(
+ DeviceConfig.NAMESPACE_SYSTEMUI,
+ SystemUiDeviceConfigFlags.SCREENSHOT_NOTIFICATION_SMART_ACTIONS_TIMEOUT_MS,
+ 1000);
+ smartActions.addAll(buildSmartActions(
+ ScreenshotSmartActions.getSmartActions(
+ mScreenshotId, smartActionsFuture, timeoutMs,
+ mSmartActionsProvider),
+ mContext));
+ }
+ mParams.mActionsReadyListener.onActionsReady(uri, smartActions, actions);
mParams.imageUri = uri;
mParams.image = null;
mParams.errorMsgResId = 0;
@@ -207,7 +221,7 @@
Slog.e(TAG, "unable to save screenshot", e);
mParams.clearImage();
mParams.errorMsgResId = R.string.screenshot_failed_to_save_text;
- mParams.mActionsReadyListener.onActionsReady(null, null);
+ mParams.mActionsReadyListener.onActionsReady(null, null, null);
}
// Recycle the bitmap data
@@ -228,14 +242,13 @@
// If we are cancelled while the task is running in the background, we may get null
// params. The finisher is expected to always be called back, so just use the baked-in
// params from the ctor in any case.
- mParams.mActionsReadyListener.onActionsReady(null, null);
+ mParams.mActionsReadyListener.onActionsReady(null, null, null);
mParams.finisher.accept(null);
mParams.clearImage();
}
@VisibleForTesting
- List<Notification.Action> populateNotificationActions(Context context, Resources r, Uri uri,
- CompletableFuture<List<Notification.Action>> smartActionsFuture) {
+ List<Notification.Action> populateNotificationActions(Context context, Resources r, Uri uri) {
// Note: Both the share and edit actions are proxied through ActionProxyReceiver in
// order to do some common work like dismissing the keyguard and sending
// closeSystemWindows
@@ -260,6 +273,8 @@
// by setting the (otherwise unused) request code to the current user id.
int requestCode = context.getUserId();
+ ArrayList<Notification.Action> actions = new ArrayList<>();
+
PendingIntent chooserAction = PendingIntent.getBroadcast(context, requestCode,
new Intent(context, GlobalScreenshot.TargetChosenReceiver.class),
PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT);
@@ -282,6 +297,7 @@
Notification.Action.Builder shareActionBuilder = new Notification.Action.Builder(
Icon.createWithResource(r, R.drawable.ic_screenshot_share),
r.getString(com.android.internal.R.string.share), shareAction);
+ actions.add(shareActionBuilder.build());
// Create an edit intent, if a specific package is provided as the editor, then
// launch that directly
@@ -309,31 +325,21 @@
Notification.Action.Builder editActionBuilder = new Notification.Action.Builder(
Icon.createWithResource(r, R.drawable.ic_screenshot_edit),
r.getString(com.android.internal.R.string.screenshot_edit), editAction);
+ actions.add(editActionBuilder.build());
- // Create a delete action for the notification
- PendingIntent deleteAction = PendingIntent.getBroadcast(context, requestCode,
- new Intent(context, GlobalScreenshot.DeleteScreenshotReceiver.class)
- .putExtra(GlobalScreenshot.SCREENSHOT_URI_ID, uri.toString())
- .putExtra(GlobalScreenshot.EXTRA_ID, mScreenshotId)
- .putExtra(GlobalScreenshot.EXTRA_SMART_ACTIONS_ENABLED,
- mSmartActionsEnabled),
- PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT);
- Notification.Action.Builder deleteActionBuilder = new Notification.Action.Builder(
- Icon.createWithResource(r, R.drawable.ic_screenshot_delete),
- r.getString(com.android.internal.R.string.delete), deleteAction);
-
- ArrayList<Notification.Action> actions = new ArrayList<>(
- Arrays.asList(shareActionBuilder.build(), editActionBuilder.build(),
- deleteActionBuilder.build()));
- if (mSmartActionsEnabled) {
- int timeoutMs = DeviceConfig.getInt(
- DeviceConfig.NAMESPACE_SYSTEMUI,
- SystemUiDeviceConfigFlags.SCREENSHOT_NOTIFICATION_SMART_ACTIONS_TIMEOUT_MS,
- 1000);
- actions.addAll(buildSmartActions(
- ScreenshotSmartActions.getSmartActions(
- mScreenshotId, smartActionsFuture, timeoutMs, mSmartActionsProvider),
- context));
+ if (mCreateDeleteAction) {
+ // Create a delete action for the notification
+ PendingIntent deleteAction = PendingIntent.getBroadcast(context, requestCode,
+ new Intent(context, GlobalScreenshot.DeleteScreenshotReceiver.class)
+ .putExtra(GlobalScreenshot.SCREENSHOT_URI_ID, uri.toString())
+ .putExtra(GlobalScreenshot.EXTRA_ID, mScreenshotId)
+ .putExtra(GlobalScreenshot.EXTRA_SMART_ACTIONS_ENABLED,
+ mSmartActionsEnabled),
+ PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT);
+ Notification.Action.Builder deleteActionBuilder = new Notification.Action.Builder(
+ Icon.createWithResource(r, R.drawable.ic_screenshot_delete),
+ r.getString(com.android.internal.R.string.delete), deleteAction);
+ actions.add(deleteActionBuilder.build());
}
return actions;
}
diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotActionChip.java b/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotActionChip.java
index 6edacd1..44b20e5 100644
--- a/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotActionChip.java
+++ b/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotActionChip.java
@@ -17,9 +17,11 @@
package com.android.systemui.screenshot;
import android.annotation.ColorInt;
+import android.app.PendingIntent;
import android.content.Context;
import android.graphics.drawable.Icon;
import android.util.AttributeSet;
+import android.util.Log;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
@@ -31,6 +33,8 @@
*/
public class ScreenshotActionChip extends LinearLayout {
+ private static final String TAG = "ScreenshotActionChip";
+
private ImageView mIcon;
private TextView mText;
private @ColorInt int mIconColor;
@@ -47,11 +51,11 @@
this(context, attrs, defStyleAttr, 0);
}
- public ScreenshotActionChip(Context context, AttributeSet attrs, int defStyleAttr,
- int defStyleRes) {
+ public ScreenshotActionChip(
+ Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
- mIconColor = context.getColor(R.color.global_screenshot_button_text);
+ mIconColor = context.getColor(R.color.global_screenshot_button_icon);
}
@Override
@@ -70,4 +74,15 @@
void setText(CharSequence text) {
mText.setText(text);
}
+
+ void setPendingIntent(PendingIntent intent, Runnable finisher) {
+ setOnClickListener(v -> {
+ try {
+ intent.send();
+ finisher.run();
+ } catch (PendingIntent.CanceledException e) {
+ Log.e(TAG, "Intent cancelled", e);
+ }
+ });
+ }
}
diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotNotificationsController.java b/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotNotificationsController.java
index 42fca94..811a8d9 100644
--- a/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotNotificationsController.java
+++ b/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotNotificationsController.java
@@ -190,10 +190,14 @@
*/
public void showScreenshotActionsNotification(
Uri imageUri,
+ List<Notification.Action> smartActions,
List<Notification.Action> actions) {
for (Notification.Action action : actions) {
mNotificationBuilder.addAction(action);
}
+ for (Notification.Action smartAction : smartActions) {
+ mNotificationBuilder.addAction(smartAction);
+ }
// Create the intent to show the screenshot in gallery
Intent launchIntent = new Intent(Intent.ACTION_VIEW);
diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/TakeScreenshotService.java b/packages/SystemUI/src/com/android/systemui/screenshot/TakeScreenshotService.java
index 4f045d5..9570b5a 100644
--- a/packages/SystemUI/src/com/android/systemui/screenshot/TakeScreenshotService.java
+++ b/packages/SystemUI/src/com/android/systemui/screenshot/TakeScreenshotService.java
@@ -107,6 +107,7 @@
@Override
public boolean onUnbind(Intent intent) {
if (mScreenshot != null) mScreenshot.stopScreenshot();
+ // TODO (mkephart) remove once notifications flow is fully deprecated
if (mScreenshotLegacy != null) mScreenshotLegacy.stopScreenshot();
return true;
}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/BlurUtils.kt b/packages/SystemUI/src/com/android/systemui/statusbar/BlurUtils.kt
new file mode 100644
index 0000000..083fbc9
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/BlurUtils.kt
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2020 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.systemui.statusbar
+
+import android.app.ActivityManager
+import android.content.res.Resources
+import android.os.SystemProperties
+import android.util.MathUtils
+import android.view.SurfaceControl
+import android.view.ViewRootImpl
+import com.android.internal.util.IndentingPrintWriter
+import com.android.systemui.DumpController
+import com.android.systemui.Dumpable
+import com.android.systemui.R
+import com.android.systemui.dagger.qualifiers.Main
+import java.io.FileDescriptor
+import java.io.PrintWriter
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class BlurUtils @Inject constructor(
+ @Main private val resources: Resources,
+ val dumpController: DumpController
+) : Dumpable {
+ private val minBlurRadius = resources.getDimensionPixelSize(R.dimen.min_window_blur_radius)
+ private val maxBlurRadius = resources.getDimensionPixelSize(R.dimen.max_window_blur_radius)
+ private val blurSysProp = SystemProperties
+ .getBoolean("ro.surface_flinger.supports_background_blur", false)
+
+ init {
+ dumpController.registerDumpable(this)
+ }
+
+ /**
+ * Translates a ratio from 0 to 1 to a blur radius in pixels.
+ */
+ fun radiusForRatio(ratio: Float): Int {
+ if (ratio == 0f) {
+ return 0
+ }
+ return MathUtils.lerp(minBlurRadius.toFloat(), maxBlurRadius.toFloat(), ratio).toInt()
+ }
+
+ /**
+ * Applies background blurs to a {@link ViewRootImpl}.
+ *
+ * @param viewRootImpl The window root.
+ * @param radius blur radius in pixels.
+ */
+ fun applyBlur(viewRootImpl: ViewRootImpl?, radius: Int) {
+ if (viewRootImpl == null || !supportsBlursOnWindows()) {
+ return
+ }
+ SurfaceControl.Transaction().use {
+ it.setBackgroundBlurRadius(viewRootImpl.surfaceControl, radius)
+ it.apply()
+ }
+ }
+
+ /**
+ * If this device can render blurs.
+ *
+ * @see android.view.SurfaceControl.Transaction#setBackgroundBlurRadius(SurfaceControl, int)
+ * @return {@code true} when supported.
+ */
+ fun supportsBlursOnWindows(): Boolean {
+ return blurSysProp && ActivityManager.isHighEndGfx()
+ }
+
+ override fun dump(fd: FileDescriptor, pw: PrintWriter, args: Array<out String>) {
+ IndentingPrintWriter(pw, " ").use {
+ it.println("BlurUtils:")
+ it.increaseIndent()
+ it.println("minBlurRadius: $minBlurRadius")
+ it.println("maxBlurRadius: $maxBlurRadius")
+ it.println("blurSysProp: $blurSysProp")
+ it.println("supportsBlursOnWindows: ${supportsBlursOnWindows()}")
+ }
+ }
+}
\ No newline at end of file
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/StatusBarWindowBlurController.kt b/packages/SystemUI/src/com/android/systemui/statusbar/StatusBarWindowBlurController.kt
new file mode 100644
index 0000000..2e72163
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/StatusBarWindowBlurController.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2020 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.systemui.statusbar
+
+import android.content.res.Resources
+import android.view.View
+import com.android.internal.util.IndentingPrintWriter
+import com.android.systemui.DumpController
+import com.android.systemui.Dumpable
+import com.android.systemui.dagger.qualifiers.Main
+import com.android.systemui.statusbar.phone.PanelExpansionListener
+import java.io.FileDescriptor
+import java.io.PrintWriter
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Controller responsible for statusbar window blur.
+ */
+@Singleton
+class StatusBarWindowBlurController @Inject constructor(
+ @Main private val resources: Resources,
+ private val statusBarStateController: SysuiStatusBarStateController,
+ private val blurUtils: BlurUtils,
+ dumpController: DumpController
+) : PanelExpansionListener, Dumpable {
+
+ lateinit var root: View
+ private var blurRadius = 0
+
+ init {
+ dumpController.registerDumpable(this)
+ }
+
+ override fun onPanelExpansionChanged(expansion: Float, tracking: Boolean) {
+ val newBlur = if (statusBarStateController.state == StatusBarState.SHADE)
+ blurUtils.radiusForRatio(expansion)
+ else
+ 0
+
+ if (blurRadius == newBlur) {
+ return
+ }
+ blurRadius = newBlur
+ blurUtils.applyBlur(root.viewRootImpl, blurRadius)
+ }
+
+ override fun dump(fd: FileDescriptor, pw: PrintWriter, args: Array<out String>) {
+ IndentingPrintWriter(pw, " ").use {
+ it.println("StatusBarWindowBlurController:")
+ it.increaseIndent()
+ it.println("blurRadius: $blurRadius")
+ }
+ }
+}
\ No newline at end of file
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/SuperStatusBarViewFactory.java b/packages/SystemUI/src/com/android/systemui/statusbar/SuperStatusBarViewFactory.java
index 0ab5afa..405f32a 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/SuperStatusBarViewFactory.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/SuperStatusBarViewFactory.java
@@ -21,6 +21,7 @@
import android.view.ViewGroup;
import com.android.systemui.R;
+import com.android.systemui.statusbar.notification.row.dagger.NotificationRowComponent;
import com.android.systemui.statusbar.phone.LockIcon;
import com.android.systemui.statusbar.phone.NotificationPanelView;
import com.android.systemui.statusbar.phone.NotificationShadeWindowView;
@@ -39,6 +40,7 @@
private final Context mContext;
private final InjectionInflationController mInjectionInflationController;
+ private final NotificationRowComponent.Builder mNotificationRowComponentBuilder;
private NotificationShadeWindowView mNotificationShadeWindowView;
private StatusBarWindowView mStatusBarWindowView;
@@ -46,9 +48,11 @@
@Inject
public SuperStatusBarViewFactory(Context context,
- InjectionInflationController injectionInflationController) {
+ InjectionInflationController injectionInflationController,
+ NotificationRowComponent.Builder notificationRowComponentBuilder) {
mContext = context;
mInjectionInflationController = injectionInflationController;
+ mNotificationRowComponentBuilder = notificationRowComponentBuilder;
}
/**
@@ -114,6 +118,12 @@
mNotificationShelf = (NotificationShelf) mInjectionInflationController.injectable(
LayoutInflater.from(mContext)).inflate(R.layout.status_bar_notification_shelf,
container, /* attachToRoot= */ false);
+
+ NotificationRowComponent component = mNotificationRowComponentBuilder
+ .activatableNotificationView(mNotificationShelf)
+ .build();
+ component.getActivatableNotificationViewController().init();
+
if (mNotificationShelf == null) {
throw new IllegalStateException(
"R.layout.status_bar_notification_shelf could not be properly inflated");
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationInterruptionStateProvider.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationInterruptionStateProvider.java
index 66ed864..bbf2dde 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationInterruptionStateProvider.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationInterruptionStateProvider.java
@@ -188,7 +188,9 @@
return false;
}
- if (entry.getBubbleMetadata() == null || entry.getBubbleMetadata().getIntent() == null) {
+ if (entry.getBubbleMetadata() == null
+ || (entry.getBubbleMetadata().getShortcutId() == null
+ && entry.getBubbleMetadata().getBubbleIntent() == null)) {
if (DEBUG) {
Log.d(TAG, "No bubble up: notification: " + sbn.getKey()
+ " doesn't have valid metadata");
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/inflation/NotificationRowBinderImpl.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/inflation/NotificationRowBinderImpl.java
index 5cd3e94..2a7683a 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/inflation/NotificationRowBinderImpl.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/inflation/NotificationRowBinderImpl.java
@@ -41,9 +41,6 @@
import com.android.systemui.statusbar.notification.NotificationInterruptionStateProvider;
import com.android.systemui.statusbar.notification.collection.NotificationEntry;
import com.android.systemui.statusbar.notification.logging.NotificationLogger;
-import com.android.systemui.statusbar.notification.people.NotificationPersonExtractorPluginBoundary;
-import com.android.systemui.statusbar.notification.people.PeopleNotificationIdentifier;
-import com.android.systemui.statusbar.notification.people.PeopleNotificationIdentifierImpl;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
import com.android.systemui.statusbar.notification.row.NotificationGutsManager;
import com.android.systemui.statusbar.notification.row.NotificationRowContentBinder;
@@ -52,13 +49,13 @@
import com.android.systemui.statusbar.phone.KeyguardBypassController;
import com.android.systemui.statusbar.phone.NotificationGroupManager;
import com.android.systemui.statusbar.phone.StatusBar;
-import com.android.systemui.statusbar.policy.ExtensionControllerImpl;
import com.android.systemui.statusbar.policy.HeadsUpManager;
import java.util.Objects;
import javax.inject.Inject;
import javax.inject.Named;
+import javax.inject.Provider;
import javax.inject.Singleton;
/** Handles inflating and updating views for notifications. */
@@ -88,6 +85,7 @@
private ExpandableNotificationRow.OnAppOpsClickListener mOnAppOpsClickListener;
private BindRowCallback mBindRowCallback;
private NotificationClicker mNotificationClicker;
+ private final Provider<RowInflaterTask> mRowInflaterTaskProvider;
private final NotificationLogger mNotificationLogger;
@Inject
@@ -102,6 +100,7 @@
NotificationGroupManager notificationGroupManager,
NotificationGutsManager notificationGutsManager,
NotificationInterruptionStateProvider notificationInterruptionStateProvider,
+ Provider<RowInflaterTask> rowInflaterTaskProvider,
NotificationLogger logger) {
mContext = context;
mRowContentBinder = rowContentBinder;
@@ -114,6 +113,7 @@
mGroupManager = notificationGroupManager;
mGutsManager = notificationGutsManager;
mNotificationInterruptionStateProvider = notificationInterruptionStateProvider;
+ mRowInflaterTaskProvider = rowInflaterTaskProvider;
mNotificationLogger = logger;
}
@@ -159,7 +159,7 @@
entry.getRow().setOnDismissRunnable(onDismissRunnable);
} else {
entry.createIcons(mContext, sbn);
- new RowInflaterTask().inflate(mContext, parent, entry,
+ mRowInflaterTaskProvider.get().inflate(mContext, parent, entry,
row -> {
bindRow(entry, pmUser, sbn, row, onDismissRunnable);
updateNotification(entry, pmUser, sbn, row);
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/ActivatableNotificationViewController.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/ActivatableNotificationViewController.java
new file mode 100644
index 0000000..18993ff
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/ActivatableNotificationViewController.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2020 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.systemui.statusbar.notification.row;
+
+import android.view.accessibility.AccessibilityManager;
+
+import com.android.systemui.plugins.FalsingManager;
+
+import javax.inject.Inject;
+
+/**
+ * Controller for {@link ActivatableNotificationView}
+ */
+public class ActivatableNotificationViewController {
+ private final ActivatableNotificationView mView;
+ private final AccessibilityManager mAccessibilityManager;
+ private final FalsingManager mFalsingManager;
+
+ @Inject
+ public ActivatableNotificationViewController(ActivatableNotificationView view,
+ AccessibilityManager accessibilityManager, FalsingManager falsingManager) {
+ mView = view;
+ mAccessibilityManager = accessibilityManager;
+ mFalsingManager = falsingManager;
+ }
+
+ /**
+ * Initialize the controller, setting up handlers and other behavior.
+ */
+ public void init() {
+
+ }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfo.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfo.java
index 64bdd97..18c755d 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfo.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfo.java
@@ -240,6 +240,10 @@
// a custom channel
if (TextUtils.isEmpty(mNotificationChannel.getConversationId())) {
try {
+ // TODO: remove
+ mNotificationChannel.setName(mContext.getString(
+ R.string.notification_summary_message_format,
+ getName(), mNotificationChannel.getName()));
mINotificationManager.createConversationNotificationChannelForPackage(
mPackageName, mAppUid, mSbn.getKey(), mNotificationChannel,
mConversationId);
@@ -347,7 +351,8 @@
channelName.setText(mNotificationChannel.getName());
bindGroup();
- bindName();
+ // TODO: bring back when channel name does not include name
+ // bindName();
bindPackage();
bindIcon();
@@ -383,15 +388,19 @@
private void bindName() {
TextView name = findViewById(R.id.name);
+ name.setText(getName());
+ }
+
+ private String getName() {
if (mShortcutInfo != null) {
- name.setText(mShortcutInfo.getShortLabel());
+ return mShortcutInfo.getShortLabel().toString();
} else {
Bundle extras = mSbn.getNotification().extras;
String nameString = extras.getString(Notification.EXTRA_CONVERSATION_TITLE);
if (TextUtils.isEmpty(nameString)) {
nameString = extras.getString(Notification.EXTRA_TITLE);
}
- name.setText(nameString);
+ return nameString;
}
}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/RowInflaterTask.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/RowInflaterTask.java
index 0160c547..c173b4d 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/RowInflaterTask.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/RowInflaterTask.java
@@ -26,6 +26,9 @@
import com.android.systemui.R;
import com.android.systemui.statusbar.InflationTask;
import com.android.systemui.statusbar.notification.collection.NotificationEntry;
+import com.android.systemui.statusbar.notification.row.dagger.NotificationRowComponent;
+
+import javax.inject.Inject;
/**
* An inflater task that asynchronously inflates a ExpandableNotificationRow
@@ -34,12 +37,20 @@
private static final String TAG = "RowInflaterTask";
private static final boolean TRACE_ORIGIN = true;
+ private final NotificationRowComponent.Builder mNotificationRowComponentBuilder;
private RowInflationFinishedListener mListener;
private NotificationEntry mEntry;
private boolean mCancelled;
private Throwable mInflateOrigin;
+ @Inject
+ public RowInflaterTask(
+ NotificationRowComponent.Builder notificationRowComponentBuilder) {
+ super();
+ mNotificationRowComponentBuilder = notificationRowComponentBuilder;
+ }
+
/**
* Inflates a new notificationView. This should not be called twice on this object
*/
@@ -64,6 +75,12 @@
public void onInflateFinished(View view, int resid, ViewGroup parent) {
if (!mCancelled) {
try {
+ // Setup the controller for the view.
+ NotificationRowComponent component = mNotificationRowComponentBuilder
+ .activatableNotificationView((ActivatableNotificationView) view)
+ .build();
+ component.getActivatableNotificationViewController().init();
+
mEntry.onInflationTaskFinished();
mListener.onInflationFinished((ExpandableNotificationRow) view);
} catch (Throwable t) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/dagger/NotificationRowComponent.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/dagger/NotificationRowComponent.java
new file mode 100644
index 0000000..f16ea7a
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/dagger/NotificationRowComponent.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2020 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.systemui.statusbar.notification.row.dagger;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.android.systemui.statusbar.notification.row.ActivatableNotificationView;
+import com.android.systemui.statusbar.notification.row.ActivatableNotificationViewController;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+
+import javax.inject.Scope;
+
+import dagger.BindsInstance;
+import dagger.Subcomponent;
+
+/**
+ * Dagger subcomponent for Notification related views.
+ */
+@Subcomponent(modules = {})
+@NotificationRowComponent.NotificationRowScope
+public interface NotificationRowComponent {
+ /**
+ * Builder for {@link NotificationRowComponent}.
+ */
+ @Subcomponent.Builder
+ interface Builder {
+ @BindsInstance
+ Builder activatableNotificationView(ActivatableNotificationView view);
+ NotificationRowComponent build();
+ }
+
+ /**
+ * Scope annotation for singleton items within the StatusBarComponent.
+ */
+ @Documented
+ @Retention(RUNTIME)
+ @Scope
+ @interface NotificationRowScope {}
+
+ /**
+ * Creates a ActivatableNotificationViewController.
+ */
+ @NotificationRowScope
+ ActivatableNotificationViewController getActivatableNotificationViewController();
+}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManager.java
index 09c1fad..23433cb 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManager.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManager.java
@@ -33,12 +33,14 @@
import com.android.systemui.plugins.ActivityStarter;
import com.android.systemui.plugins.statusbar.StatusBarStateController;
import com.android.systemui.statusbar.StatusBarState;
+import com.android.systemui.statusbar.notification.NotificationSectionsFeatureManager;
import com.android.systemui.statusbar.notification.people.DataListener;
import com.android.systemui.statusbar.notification.people.PeopleHubSectionFooterViewAdapter;
import com.android.systemui.statusbar.notification.people.PeopleHubSectionFooterViewBoundary;
import com.android.systemui.statusbar.notification.people.PersonViewModel;
import com.android.systemui.statusbar.notification.row.ActivatableNotificationView;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
+import com.android.systemui.statusbar.notification.row.dagger.NotificationRowComponent;
import com.android.systemui.statusbar.policy.ConfigurationController;
import com.android.systemui.statusbar.policy.ConfigurationController.ConfigurationListener;
@@ -46,6 +48,8 @@
import java.util.ArrayList;
import java.util.List;
+import javax.inject.Inject;
+
import kotlin.sequences.Sequence;
/**
@@ -59,11 +63,13 @@
private static final String TAG = "NotifSectionsManager";
private static final boolean DEBUG = false;
- private final NotificationStackScrollLayout mParent;
+ private NotificationStackScrollLayout mParent;
private final ActivityStarter mActivityStarter;
private final StatusBarStateController mStatusBarStateController;
private final ConfigurationController mConfigurationController;
private final int mNumberOfSections;
+ private final NotificationSectionsFeatureManager mSectionsFeatureManager;
+ private final NotificationRowComponent.Builder mNotificationRowComponentBuilder;
private boolean mInitialized = false;
private SectionHeaderView mGentleHeader;
@@ -99,22 +105,25 @@
@Nullable private View.OnClickListener mOnClearGentleNotifsClickListener;
+ @Inject
NotificationSectionsManager(
- NotificationStackScrollLayout parent,
ActivityStarter activityStarter,
StatusBarStateController statusBarStateController,
ConfigurationController configurationController,
PeopleHubSectionFooterViewAdapter peopleHubViewAdapter,
- int numberOfSections) {
- mParent = parent;
+ NotificationSectionsFeatureManager sectionsFeatureManager,
+ NotificationRowComponent.Builder notificationRowComponentBuilder) {
mActivityStarter = activityStarter;
mStatusBarStateController = statusBarStateController;
mConfigurationController = configurationController;
mPeopleHubViewAdapter = peopleHubViewAdapter;
- mNumberOfSections = numberOfSections;
+ mSectionsFeatureManager = sectionsFeatureManager;
+ mNumberOfSections = mSectionsFeatureManager.getNumberOfBuckets();
+ mNotificationRowComponentBuilder = notificationRowComponentBuilder;
}
- NotificationSection[] createSectionsForBuckets(int[] buckets) {
+ NotificationSection[] createSectionsForBuckets() {
+ int[] buckets = mSectionsFeatureManager.getNotificationBuckets();
NotificationSection[] sections = new NotificationSection[buckets.length];
for (int i = 0; i < buckets.length; i++) {
sections[i] = new NotificationSection(mParent, buckets[i] /* bucket */);
@@ -124,11 +133,13 @@
}
/** Must be called before use. */
- void initialize(LayoutInflater layoutInflater) {
+ void initialize(
+ NotificationStackScrollLayout parent, LayoutInflater layoutInflater) {
if (mInitialized) {
throw new IllegalStateException("NotificationSectionsManager already initialized");
}
mInitialized = true;
+ mParent = parent;
reinflateViews(layoutInflater);
mPeopleHubViewAdapter.bindView(mPeopleHubViewBoundary);
mConfigurationController.addCallback(mConfigurationListener);
@@ -159,6 +170,11 @@
mGentleHeader = (SectionHeaderView) layoutInflater.inflate(
R.layout.status_bar_notification_section_header, mParent, false);
+ NotificationRowComponent sectionHeaderComponent = mNotificationRowComponentBuilder
+ .activatableNotificationView(mGentleHeader)
+ .build();
+ sectionHeaderComponent.getActivatableNotificationViewController().init();
+
mGentleHeader.setOnHeaderClickListener(this::onGentleHeaderClick);
mGentleHeader.setOnClearAllClickListener(this::onClearGentleNotifsClick);
@@ -169,6 +185,11 @@
mPeopleHubView = (PeopleHubView) layoutInflater.inflate(
R.layout.people_strip, mParent, false);
+ NotificationRowComponent notificationRowComponent = mNotificationRowComponentBuilder
+ .activatableNotificationView(mPeopleHubView)
+ .build();
+ notificationRowComponent.getActivatableNotificationViewController().init();
+
if (oldPeopleHubPos != -1) {
mParent.addView(mPeopleHubView, oldPeopleHubPos);
}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayout.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayout.java
index dc2d99c..11ead8b 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayout.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayout.java
@@ -88,7 +88,6 @@
import com.android.systemui.R;
import com.android.systemui.SwipeHelper;
import com.android.systemui.colorextraction.SysuiColorExtractor;
-import com.android.systemui.plugins.ActivityStarter;
import com.android.systemui.plugins.FalsingManager;
import com.android.systemui.plugins.statusbar.NotificationMenuRowPlugin;
import com.android.systemui.plugins.statusbar.NotificationMenuRowPlugin.MenuItem;
@@ -109,14 +108,12 @@
import com.android.systemui.statusbar.notification.FakeShadowView;
import com.android.systemui.statusbar.notification.NotificationEntryListener;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
-import com.android.systemui.statusbar.notification.NotificationSectionsFeatureManager;
import com.android.systemui.statusbar.notification.NotificationUtils;
import com.android.systemui.statusbar.notification.ShadeViewRefactor;
import com.android.systemui.statusbar.notification.ShadeViewRefactor.RefactorComponent;
import com.android.systemui.statusbar.notification.VisualStabilityManager;
import com.android.systemui.statusbar.notification.collection.NotificationEntry;
import com.android.systemui.statusbar.notification.logging.NotificationLogger;
-import com.android.systemui.statusbar.notification.people.PeopleHubSectionFooterViewAdapter;
import com.android.systemui.statusbar.notification.row.ActivatableNotificationView;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
import com.android.systemui.statusbar.notification.row.ExpandableView;
@@ -512,17 +509,14 @@
@Named(ALLOW_NOTIFICATION_LONG_PRESS_NAME) boolean allowLongPress,
NotificationRoundnessManager notificationRoundnessManager,
DynamicPrivacyController dynamicPrivacyController,
- ConfigurationController configurationController,
- ActivityStarter activityStarter,
- StatusBarStateController statusBarStateController,
+ SysuiStatusBarStateController statusBarStateController,
HeadsUpManagerPhone headsUpManager,
KeyguardBypassController keyguardBypassController,
FalsingManager falsingManager,
NotificationLockscreenUserManager notificationLockscreenUserManager,
NotificationGutsManager notificationGutsManager,
- NotificationSectionsFeatureManager sectionsFeatureManager,
- PeopleHubSectionFooterViewAdapter peopleHubViewAdapter,
- ZenModeController zenController) {
+ ZenModeController zenController,
+ NotificationSectionsManager notificationSectionsManager) {
super(context, attrs, 0, 0);
Resources res = getResources();
@@ -539,22 +533,14 @@
mFalsingManager = falsingManager;
mZenController = zenController;
- int[] buckets = sectionsFeatureManager.getNotificationBuckets();
- mSectionsManager =
- new NotificationSectionsManager(
- this,
- activityStarter,
- statusBarStateController,
- configurationController,
- peopleHubViewAdapter,
- buckets.length);
- mSectionsManager.initialize(LayoutInflater.from(context));
+ mSectionsManager = notificationSectionsManager;
+ mSectionsManager.initialize(this, LayoutInflater.from(context));
mSectionsManager.setOnClearGentleNotifsClickListener(v -> {
// Leave the shade open if there will be other notifs left over to clear
final boolean closeShade = !hasActiveClearableNotifications(ROWS_HIGH_PRIORITY);
clearNotifications(ROWS_GENTLE, closeShade);
});
- mSections = mSectionsManager.createSectionsForBuckets(buckets);
+ mSections = mSectionsManager.createSectionsForBuckets();
mAmbientState = new AmbientState(context, mSectionsManager, mHeadsUpManager);
mBgColor = context.getColor(R.color.notification_shade_background_color);
@@ -617,7 +603,7 @@
});
dynamicPrivacyController.addListener(this);
mDynamicPrivacyController = dynamicPrivacyController;
- mStatusbarStateController = (SysuiStatusBarStateController) statusBarStateController;
+ mStatusbarStateController = statusBarStateController;
}
private void updateDismissRtlSetting(boolean dismissRtl) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/EdgeBackGestureHandler.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/EdgeBackGestureHandler.java
index 9840a7b..ef581db 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/EdgeBackGestureHandler.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/EdgeBackGestureHandler.java
@@ -31,7 +31,6 @@
import android.os.SystemClock;
import android.os.SystemProperties;
import android.util.Log;
-import android.util.StatsLog;
import android.view.ISystemGestureExclusionListener;
import android.view.InputChannel;
import android.view.InputDevice;
@@ -54,6 +53,7 @@
import com.android.systemui.recents.OverviewProxyService;
import com.android.systemui.shared.plugins.PluginManager;
import com.android.systemui.shared.system.QuickStepContract;
+import com.android.systemui.shared.system.SysUiStatsLog;
import java.io.PrintWriter;
import java.util.concurrent.Executor;
@@ -133,23 +133,23 @@
mOverviewProxyService.notifyBackAction(true, (int) mDownPoint.x,
(int) mDownPoint.y, false /* isButton */, !mIsOnLeftEdge);
int backtype = (mInRejectedExclusion
- ? StatsLog.BACK_GESTURE__TYPE__COMPLETED_REJECTED :
- StatsLog.BACK_GESTURE__TYPE__COMPLETED);
- StatsLog.write(StatsLog.BACK_GESTURE_REPORTED_REPORTED, backtype,
+ ? SysUiStatsLog.BACK_GESTURE__TYPE__COMPLETED_REJECTED :
+ SysUiStatsLog.BACK_GESTURE__TYPE__COMPLETED);
+ SysUiStatsLog.write(SysUiStatsLog.BACK_GESTURE_REPORTED_REPORTED, backtype,
(int) mDownPoint.y, mIsOnLeftEdge
- ? StatsLog.BACK_GESTURE__X_LOCATION__LEFT :
- StatsLog.BACK_GESTURE__X_LOCATION__RIGHT);
+ ? SysUiStatsLog.BACK_GESTURE__X_LOCATION__LEFT :
+ SysUiStatsLog.BACK_GESTURE__X_LOCATION__RIGHT);
}
@Override
public void cancelBack() {
mOverviewProxyService.notifyBackAction(false, (int) mDownPoint.x,
(int) mDownPoint.y, false /* isButton */, !mIsOnLeftEdge);
- int backtype = StatsLog.BACK_GESTURE__TYPE__INCOMPLETE;
- StatsLog.write(StatsLog.BACK_GESTURE_REPORTED_REPORTED, backtype,
+ int backtype = SysUiStatsLog.BACK_GESTURE__TYPE__INCOMPLETE;
+ SysUiStatsLog.write(SysUiStatsLog.BACK_GESTURE_REPORTED_REPORTED, backtype,
(int) mDownPoint.y, mIsOnLeftEdge
- ? StatsLog.BACK_GESTURE__X_LOCATION__LEFT :
- StatsLog.BACK_GESTURE__X_LOCATION__RIGHT);
+ ? SysUiStatsLog.BACK_GESTURE__X_LOCATION__LEFT :
+ SysUiStatsLog.BACK_GESTURE__X_LOCATION__RIGHT);
}
};
@@ -334,10 +334,10 @@
if (isInExcludedRegion) {
mOverviewProxyService.notifyBackAction(false /* completed */, -1, -1,
false /* isButton */, !mIsOnLeftEdge);
- StatsLog.write(StatsLog.BACK_GESTURE_REPORTED_REPORTED,
- StatsLog.BACK_GESTURE__TYPE__INCOMPLETE_EXCLUDED, y,
- mIsOnLeftEdge ? StatsLog.BACK_GESTURE__X_LOCATION__LEFT :
- StatsLog.BACK_GESTURE__X_LOCATION__RIGHT);
+ SysUiStatsLog.write(SysUiStatsLog.BACK_GESTURE_REPORTED_REPORTED,
+ SysUiStatsLog.BACK_GESTURE__TYPE__INCOMPLETE_EXCLUDED, y,
+ mIsOnLeftEdge ? SysUiStatsLog.BACK_GESTURE__X_LOCATION__LEFT :
+ SysUiStatsLog.BACK_GESTURE__X_LOCATION__RIGHT);
} else {
mInRejectedExclusion = mUnrestrictedExcludeRegion.contains(x, y);
}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java
index f34c15c..3074e33 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java
@@ -27,7 +27,6 @@
import android.util.Log;
import android.util.MathUtils;
import android.util.Slog;
-import android.util.StatsLog;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
@@ -47,6 +46,7 @@
import com.android.systemui.R;
import com.android.systemui.keyguard.DismissCallbackRegistry;
import com.android.systemui.plugins.FalsingManager;
+import com.android.systemui.shared.system.SysUiStatsLog;
import com.android.systemui.statusbar.policy.KeyguardStateController;
import java.io.PrintWriter;
@@ -248,8 +248,8 @@
mKeyguardView.onResume();
mKeyguardView.resetSecurityContainer();
}
- StatsLog.write(StatsLog.KEYGUARD_BOUNCER_STATE_CHANGED,
- StatsLog.KEYGUARD_BOUNCER_STATE_CHANGED__STATE__SHOWN);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_BOUNCER_STATE_CHANGED,
+ SysUiStatsLog.KEYGUARD_BOUNCER_STATE_CHANGED__STATE__SHOWN);
}
};
@@ -290,8 +290,8 @@
public void hide(boolean destroyView) {
if (isShowing()) {
- StatsLog.write(StatsLog.KEYGUARD_BOUNCER_STATE_CHANGED,
- StatsLog.KEYGUARD_BOUNCER_STATE_CHANGED__STATE__HIDDEN);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_BOUNCER_STATE_CHANGED,
+ SysUiStatsLog.KEYGUARD_BOUNCER_STATE_CHANGED__STATE__HIDDEN);
mDismissCallbackRegistry.notifyDismissCancelled();
}
mIsScrimmed = false;
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewController.java
index c691a35..ab1c8ad 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewController.java
@@ -18,6 +18,7 @@
import static android.app.StatusBarManager.WINDOW_STATE_SHOWING;
+import android.annotation.Nullable;
import android.app.StatusBarManager;
import android.graphics.RectF;
import android.hardware.display.AmbientDisplayConfiguration;
@@ -44,6 +45,7 @@
import com.android.systemui.statusbar.DragDownHelper;
import com.android.systemui.statusbar.NotificationLockscreenUserManager;
import com.android.systemui.statusbar.PulseExpansionHandler;
+import com.android.systemui.statusbar.StatusBarWindowBlurController;
import com.android.systemui.statusbar.SysuiStatusBarStateController;
import com.android.systemui.statusbar.notification.DynamicPrivacyController;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
@@ -79,6 +81,7 @@
private final CommandQueue mCommandQueue;
private final NotificationShadeWindowView mView;
private final ShadeController mShadeController;
+ private final StatusBarWindowBlurController mBlurController;
private GestureDetector mGestureDetector;
private View mBrightnessMirror;
@@ -120,6 +123,7 @@
CommandQueue commandQueue,
ShadeController shadeController,
DockManager dockManager,
+ @Nullable StatusBarWindowBlurController blurController,
NotificationShadeWindowView statusBarWindowView,
NotificationPanelViewController notificationPanelViewController) {
mInjectionInflationController = injectionInflationController;
@@ -141,6 +145,7 @@
mShadeController = shadeController;
mDockManager = dockManager;
mNotificationPanelViewController = notificationPanelViewController;
+ mBlurController = blurController;
// This view is not part of the newly inflated expanded status bar.
mBrightnessMirror = mView.findViewById(R.id.brightness_mirror);
@@ -383,6 +388,11 @@
new DragDownHelper(
mView.getContext(), mView, expandHelperCallback,
dragDownCallback, mFalsingManager));
+
+ if (mBlurController != null) {
+ mBlurController.setRoot(mView);
+ mNotificationPanelViewController.addExpansionListener(mBlurController);
+ }
}
public NotificationShadeWindowView getView() {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java
index de37cd9..86a81ce 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java
@@ -26,7 +26,6 @@
import android.content.res.ColorStateList;
import android.os.Bundle;
import android.os.SystemClock;
-import android.util.StatsLog;
import android.view.KeyEvent;
import android.view.View;
import android.view.ViewGroup;
@@ -48,6 +47,7 @@
import com.android.systemui.plugins.FalsingManager;
import com.android.systemui.plugins.statusbar.StatusBarStateController;
import com.android.systemui.shared.system.QuickStepContract;
+import com.android.systemui.shared.system.SysUiStatsLog;
import com.android.systemui.statusbar.CrossFadeHelper;
import com.android.systemui.statusbar.NotificationMediaManager;
import com.android.systemui.statusbar.RemoteInputController;
@@ -319,8 +319,8 @@
mKeyguardStateController.notifyKeyguardState(mShowing,
mKeyguardStateController.isOccluded());
reset(true /* hideBouncerWhenShowing */);
- StatsLog.write(StatsLog.KEYGUARD_STATE_CHANGED,
- StatsLog.KEYGUARD_STATE_CHANGED__STATE__SHOWN);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_STATE_CHANGED,
+ SysUiStatsLog.KEYGUARD_STATE_CHANGED__STATE__SHOWN);
}
/**
@@ -501,8 +501,8 @@
public void setOccluded(boolean occluded, boolean animate) {
mStatusBar.setOccluded(occluded);
if (occluded && !mOccluded && mShowing) {
- StatsLog.write(StatsLog.KEYGUARD_STATE_CHANGED,
- StatsLog.KEYGUARD_STATE_CHANGED__STATE__OCCLUDED);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_STATE_CHANGED,
+ SysUiStatsLog.KEYGUARD_STATE_CHANGED__STATE__OCCLUDED);
if (mStatusBar.isInLaunchTransition()) {
mOccluded = true;
mStatusBar.fadeKeyguardAfterLaunchTransition(null /* beforeFading */,
@@ -516,8 +516,8 @@
return;
}
} else if (!occluded && mOccluded && mShowing) {
- StatsLog.write(StatsLog.KEYGUARD_STATE_CHANGED,
- StatsLog.KEYGUARD_STATE_CHANGED__STATE__SHOWN);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_STATE_CHANGED,
+ SysUiStatsLog.KEYGUARD_STATE_CHANGED__STATE__SHOWN);
}
boolean isOccluding = !mOccluded && occluded;
mOccluded = occluded;
@@ -653,8 +653,8 @@
mNotificationShadeWindowController.setKeyguardShowing(false);
mViewMediatorCallback.keyguardGone();
}
- StatsLog.write(StatsLog.KEYGUARD_STATE_CHANGED,
- StatsLog.KEYGUARD_STATE_CHANGED__STATE__HIDDEN);
+ SysUiStatsLog.write(SysUiStatsLog.KEYGUARD_STATE_CHANGED,
+ SysUiStatsLog.KEYGUARD_STATE_CHANGED__STATE__HIDDEN);
}
private boolean needsBypassFading() {
diff --git a/packages/SystemUI/src/com/android/systemui/util/animation/FloatProperties.kt b/packages/SystemUI/src/com/android/systemui/util/animation/FloatProperties.kt
new file mode 100644
index 0000000..ecd3afd
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/util/animation/FloatProperties.kt
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2020 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.systemui.util.animation
+
+import android.graphics.Rect
+import android.graphics.RectF
+import androidx.dynamicanimation.animation.FloatPropertyCompat
+
+/**
+ * Helpful extra properties to use with the [PhysicsAnimator]. These allow you to animate objects
+ * such as [Rect] and [RectF].
+ *
+ * There are additional, more basic properties available in [DynamicAnimation].
+ */
+class FloatProperties {
+ companion object {
+ /**
+ * Represents the x-coordinate of a [Rect]. Typically used to animate moving a Rect
+ * horizontally.
+ *
+ * This property's getter returns [Rect.left], and its setter uses [Rect.offsetTo], which
+ * sets [Rect.left] to the new value and offsets [Rect.right] so that the width of the Rect
+ * does not change.
+ */
+ @JvmField
+ val RECT_X = object : FloatPropertyCompat<Rect>("RectX") {
+ override fun setValue(rect: Rect?, value: Float) {
+ rect?.offsetTo(value.toInt(), rect.top)
+ }
+
+ override fun getValue(rect: Rect?): Float {
+ return rect?.left?.toFloat() ?: -Float.MAX_VALUE
+ }
+ }
+
+ /**
+ * Represents the y-coordinate of a [Rect]. Typically used to animate moving a Rect
+ * vertically.
+ *
+ * This property's getter returns [Rect.top], and its setter uses [Rect.offsetTo], which
+ * sets [Rect.top] to the new value and offsets [Rect.bottom] so that the height of the Rect
+ * does not change.
+ */
+ @JvmField
+ val RECT_Y = object : FloatPropertyCompat<Rect>("RectY") {
+ override fun setValue(rect: Rect?, value: Float) {
+ rect?.offsetTo(rect.left, value.toInt())
+ }
+
+ override fun getValue(rect: Rect?): Float {
+ return rect?.top?.toFloat() ?: -Float.MAX_VALUE
+ }
+ }
+
+ /**
+ * Represents the x-coordinate of a [RectF]. Typically used to animate moving a RectF
+ * horizontally.
+ *
+ * This property's getter returns [RectF.left], and its setter uses [RectF.offsetTo], which
+ * sets [RectF.left] to the new value and offsets [RectF.right] so that the width of the
+ * RectF does not change.
+ */
+ @JvmField
+ val RECTF_X = object : FloatPropertyCompat<RectF>("RectFX") {
+ override fun setValue(rect: RectF?, value: Float) {
+ rect?.offsetTo(value, rect.top)
+ }
+
+ override fun getValue(rect: RectF?): Float {
+ return rect?.left ?: -Float.MAX_VALUE
+ }
+ }
+
+ /**
+ * Represents the y-coordinate of a [RectF]. Typically used to animate moving a RectF
+ * vertically.
+ *
+ * This property's getter returns [RectF.top], and its setter uses [RectF.offsetTo], which
+ * sets [RectF.top] to the new value and offsets [RectF.bottom] so that the height of the
+ * RectF does not change.
+ */
+ @JvmField
+ val RECTF_Y = object : FloatPropertyCompat<RectF>("RectFY") {
+ override fun setValue(rect: RectF?, value: Float) {
+ rect?.offsetTo(rect.left, value)
+ }
+
+ override fun getValue(rect: RectF?): Float {
+ return rect?.top ?: -Float.MAX_VALUE
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/packages/SystemUI/src/com/android/systemui/util/animation/PhysicsAnimator.kt b/packages/SystemUI/src/com/android/systemui/util/animation/PhysicsAnimator.kt
index 8a1759d..cfd77be 100644
--- a/packages/SystemUI/src/com/android/systemui/util/animation/PhysicsAnimator.kt
+++ b/packages/SystemUI/src/com/android/systemui/util/animation/PhysicsAnimator.kt
@@ -293,15 +293,19 @@
val velocityToReachDestination = distanceToDestination *
(flingConfig.friction * FLING_FRICTION_SCALAR_MULTIPLIER)
- // Try to use the provided start velocity, but use the required velocity to reach the
- // destination if the provided velocity is insufficient.
- val sufficientVelocity =
- if (distanceToDestination < 0)
- min(velocityToReachDestination, startVelocity)
- else
- max(velocityToReachDestination, startVelocity)
+ // If there's distance to cover, and the provided velocity is moving in the correct
+ // direction, ensure that the velocity is high enough to reach the destination.
+ // Otherwise, just use startVelocity - this means that the fling is at or out of bounds.
+ // The fling will immediately end and a spring will bring the object back into bounds
+ // with this startVelocity.
+ flingConfigCopy.startVelocity = when {
+ distanceToDestination > 0f && startVelocity >= 0f ->
+ max(velocityToReachDestination, startVelocity)
+ distanceToDestination < 0f && startVelocity <= 0f ->
+ min(velocityToReachDestination, startVelocity)
+ else -> startVelocity
+ }
- flingConfigCopy.startVelocity = sufficientVelocity
springConfigCopy.finalPosition = toAtLeast
} else {
flingConfigCopy.startVelocity = startVelocity
@@ -367,8 +371,17 @@
* animation is explicitly canceled, use [addEndListener]. End listeners have an allEnded param,
* which indicates that all relevant animations have ended.
*/
- fun withEndActions(vararg endActions: EndAction): PhysicsAnimator<T> {
- this.endActions.addAll(endActions)
+ fun withEndActions(vararg endActions: EndAction?): PhysicsAnimator<T> {
+ this.endActions.addAll(endActions.filterNotNull())
+ return this
+ }
+
+ /**
+ * Helper overload so that callers from Java can use Runnables or method references as end
+ * actions without having to explicitly return Unit.
+ */
+ fun withEndActions(vararg endActions: Runnable?): PhysicsAnimator<T> {
+ this.endActions.addAll(endActions.filterNotNull().map { it::run })
return this
}
@@ -416,8 +429,10 @@
max = max(currentValue, this.max)
}
- // Apply the configuration and start the animation.
+ // Apply the configuration and start the animation. Since flings can't be
+ // redirected while in motion, cancel it first.
getFlingAnimation(animatedProperty)
+ .also { it.cancel() }
.also { flingConfig.applyToAnimation(it) }
.start()
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleControllerTest.java
index 04116ec..2c9058a 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleControllerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleControllerTest.java
@@ -70,7 +70,9 @@
import com.android.systemui.statusbar.notification.NotificationFilter;
import com.android.systemui.statusbar.notification.NotificationInterruptionStateProvider;
import com.android.systemui.statusbar.notification.collection.NotificationEntry;
+import com.android.systemui.statusbar.notification.row.ActivatableNotificationView;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
+import com.android.systemui.statusbar.notification.row.dagger.NotificationRowComponent;
import com.android.systemui.statusbar.phone.DozeParameters;
import com.android.systemui.statusbar.phone.KeyguardBypassController;
import com.android.systemui.statusbar.phone.NotificationGroupManager;
@@ -151,6 +153,8 @@
private ShadeController mShadeController;
@Mock
private RemoteInputUriController mRemoteInputUriController;
+ @Mock
+ private NotificationRowComponent mNotificationRowComponent;
private SuperStatusBarViewFactory mSuperStatusBarViewFactory;
private BubbleData mBubbleData;
@@ -167,7 +171,19 @@
when(mColorExtractor.getNeutralColors()).thenReturn(mGradientColors);
mSuperStatusBarViewFactory = new SuperStatusBarViewFactory(mContext,
- new InjectionInflationController(SystemUIFactory.getInstance().getRootComponent()));
+ new InjectionInflationController(SystemUIFactory.getInstance().getRootComponent()),
+ new NotificationRowComponent.Builder() {
+ @Override
+ public NotificationRowComponent.Builder activatableNotificationView(
+ ActivatableNotificationView view) {
+ return this;
+ }
+
+ @Override
+ public NotificationRowComponent build() {
+ return mNotificationRowComponent;
+ }
+ });
// Bubbles get added to status bar window view
mNotificationShadeWindowController = new NotificationShadeWindowController(mContext,
diff --git a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleDataTest.java b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleDataTest.java
index c4ae409..7daf922 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleDataTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleDataTest.java
@@ -952,9 +952,8 @@
long postTime) {
// BubbleMetadata
Notification.BubbleMetadata bubbleMetadata = new Notification.BubbleMetadata.Builder()
- .setIntent(mExpandIntent)
+ .createIntentBubble(mExpandIntent, Icon.createWithResource("", 0))
.setDeleteIntent(mDeleteIntent)
- .setIcon(Icon.createWithResource("", 0))
.build();
// Notification -> BubbleMetadata
Notification notification = mNotificationTestHelper.createNotification(false,
diff --git a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleFlyoutViewTest.java b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleFlyoutViewTest.java
index 376ecf7..fd6e2ee 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleFlyoutViewTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleFlyoutViewTest.java
@@ -45,14 +45,22 @@
public class BubbleFlyoutViewTest extends SysuiTestCase {
private BubbleFlyoutView mFlyout;
private TextView mFlyoutText;
+ private TextView mSenderName;
private float[] mDotCenter = new float[2];
+ private Bubble.FlyoutMessage mFlyoutMessage;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
+
+ mFlyoutMessage = new Bubble.FlyoutMessage();
+ mFlyoutMessage.senderName = "Josh";
+ mFlyoutMessage.message = "Hello";
+
mFlyout = new BubbleFlyoutView(getContext());
mFlyoutText = mFlyout.findViewById(R.id.bubble_flyout_text);
+ mSenderName = mFlyout.findViewById(R.id.bubble_flyout_name);
mDotCenter[0] = 30;
mDotCenter[1] = 30;
}
@@ -60,19 +68,21 @@
@Test
public void testShowFlyout_isVisible() {
mFlyout.setupFlyoutStartingAsDot(
- "Hello", new PointF(100, 100), 500, true, Color.WHITE, null, null, mDotCenter,
+ mFlyoutMessage,
+ new PointF(100, 100), 500, true, Color.WHITE, null, null, mDotCenter,
false);
mFlyout.setVisibility(View.VISIBLE);
assertEquals("Hello", mFlyoutText.getText());
+ assertEquals("Josh", mSenderName.getText());
assertEquals(View.VISIBLE, mFlyout.getVisibility());
}
@Test
public void testFlyoutHide_runsCallback() {
Runnable after = Mockito.mock(Runnable.class);
- mFlyout.setupFlyoutStartingAsDot(
- "Hello", new PointF(100, 100), 500, true, Color.WHITE, null, after, mDotCenter,
+ mFlyout.setupFlyoutStartingAsDot(mFlyoutMessage,
+ new PointF(100, 100), 500, true, Color.WHITE, null, after, mDotCenter,
false);
mFlyout.hideFlyout();
@@ -81,8 +91,8 @@
@Test
public void testSetCollapsePercent() {
- mFlyout.setupFlyoutStartingAsDot(
- "Hello", new PointF(100, 100), 500, true, Color.WHITE, null, null, mDotCenter,
+ mFlyout.setupFlyoutStartingAsDot(mFlyoutMessage,
+ new PointF(100, 100), 500, true, Color.WHITE, null, null, mDotCenter,
false);
mFlyout.setVisibility(View.VISIBLE);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleTest.java b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleTest.java
index 3c42fd1..02f721c 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/bubbles/BubbleTest.java
@@ -45,7 +45,6 @@
private Notification mNotif;
private NotificationEntry mEntry;
- private Bubble mBubble;
private Bundle mExtras;
@Before
@@ -58,7 +57,6 @@
mEntry = new NotificationEntryBuilder()
.setNotification(mNotif)
.build();
- mBubble = new Bubble(mEntry);
}
@Test
@@ -66,7 +64,8 @@
final String msg = "Hello there!";
doReturn(Notification.Style.class).when(mNotif).getNotificationStyle();
mExtras.putCharSequence(Notification.EXTRA_TEXT, msg);
- assertEquals(msg, mBubble.getUpdateMessage(mContext));
+ assertEquals(msg, BubbleViewInfoTask.extractFlyoutMessage(mContext,
+ mEntry).message);
}
@Test
@@ -77,7 +76,8 @@
mExtras.putCharSequence(Notification.EXTRA_BIG_TEXT, msg);
// Should be big text, not the small text.
- assertEquals(msg, mBubble.getUpdateMessage(mContext));
+ assertEquals(msg, BubbleViewInfoTask.extractFlyoutMessage(mContext,
+ mEntry).message);
}
@Test
@@ -85,7 +85,8 @@
doReturn(Notification.MediaStyle.class).when(mNotif).getNotificationStyle();
// Media notifs don't get update messages.
- assertNull(mBubble.getUpdateMessage(mContext));
+ assertNull(BubbleViewInfoTask.extractFlyoutMessage(mContext,
+ mEntry).message);
}
@Test
@@ -100,7 +101,8 @@
"Really? I prefer them that way."});
// Should be the last one only.
- assertEquals("Really? I prefer them that way.", mBubble.getUpdateMessage(mContext));
+ assertEquals("Really? I prefer them that way.",
+ BubbleViewInfoTask.extractFlyoutMessage(mContext, mEntry).message);
}
@Test
@@ -115,6 +117,10 @@
"Oh, hello!", 0, "Mady").toBundle()});
// Should be the last one only.
- assertEquals("Mady: Oh, hello!", mBubble.getUpdateMessage(mContext));
+ assertEquals("Oh, hello!",
+ BubbleViewInfoTask.extractFlyoutMessage(mContext, mEntry).message);
+ assertEquals("Mady",
+ BubbleViewInfoTask.extractFlyoutMessage(mContext,
+ mEntry).senderName);
}
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsTest.java b/packages/SystemUI/tests/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsTest.java
index 2c7cee3..aeb31e1 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsTest.java
@@ -169,11 +169,11 @@
data.image = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
data.finisher = null;
data.mActionsReadyListener = null;
+ data.createDeleteAction = true;
SaveImageInBackgroundTask task = new SaveImageInBackgroundTask(mContext, data);
List<Notification.Action> actions = task.populateNotificationActions(
mContext, mContext.getResources(),
- Uri.parse("Screenshot_123.png"),
- CompletableFuture.completedFuture(Collections.emptyList()));
+ Uri.parse("Screenshot_123.png"));
Assert.assertEquals(actions.size(), 3);
boolean isShareFound = false;
@@ -184,7 +184,8 @@
Assert.assertNotNull(intent);
Bundle bundle = intent.getExtras();
Assert.assertTrue(bundle.containsKey(GlobalScreenshot.EXTRA_ID));
- Assert.assertTrue(bundle.containsKey(GlobalScreenshot.EXTRA_SMART_ACTIONS_ENABLED));
+ Assert.assertTrue(
+ bundle.containsKey(GlobalScreenshot.EXTRA_SMART_ACTIONS_ENABLED));
if (action.title.equals(GlobalScreenshot.ACTION_TYPE_DELETE)) {
isDeleteFound = intent.getAction() == null;
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationInterruptionStateProviderTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationInterruptionStateProviderTest.java
index 677a6fc..1693e7f 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationInterruptionStateProviderTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationInterruptionStateProviderTest.java
@@ -557,8 +557,8 @@
private NotificationEntry createBubble() {
Notification.BubbleMetadata data = new Notification.BubbleMetadata.Builder()
- .setIntent(PendingIntent.getActivity(mContext, 0, new Intent(), 0))
- .setIcon(Icon.createWithResource(mContext.getResources(), R.drawable.android))
+ .createIntentBubble(PendingIntent.getActivity(mContext, 0, new Intent(), 0),
+ Icon.createWithResource(mContext.getResources(), R.drawable.android))
.build();
Notification n = new Notification.Builder(getContext(), "a")
.setContentTitle("title")
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationTestHelper.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationTestHelper.java
index 61e43b0..457bbe2 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationTestHelper.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationTestHelper.java
@@ -383,9 +383,9 @@
PendingIntent bubbleIntent = PendingIntent.getActivity(mContext, 0, target, 0);
return new BubbleMetadata.Builder()
- .setIntent(bubbleIntent)
+ .createIntentBubble(bubbleIntent,
+ Icon.createWithResource(mContext, R.drawable.android))
.setDeleteIntent(deleteIntent)
- .setIcon(Icon.createWithResource(mContext, R.drawable.android))
.setDesiredHeight(314)
.build();
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java
index d852fa1..4b2ce01 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java
@@ -83,12 +83,14 @@
import com.android.systemui.statusbar.notification.logging.NotifLog;
import com.android.systemui.statusbar.notification.logging.NotificationLogger;
import com.android.systemui.statusbar.notification.people.PeopleNotificationIdentifier;
+import com.android.systemui.statusbar.notification.row.ActivatableNotificationViewController;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
import com.android.systemui.statusbar.notification.row.NotifRemoteViewCache;
import com.android.systemui.statusbar.notification.row.NotificationContentInflater;
import com.android.systemui.statusbar.notification.row.NotificationGutsManager;
import com.android.systemui.statusbar.notification.row.NotificationRowContentBinder;
import com.android.systemui.statusbar.notification.row.RowInflaterTask;
+import com.android.systemui.statusbar.notification.row.dagger.NotificationRowComponent;
import com.android.systemui.statusbar.notification.stack.NotificationListContainer;
import com.android.systemui.statusbar.phone.KeyguardBypassController;
import com.android.systemui.statusbar.phone.NotificationGroupManager;
@@ -139,6 +141,8 @@
@Mock private NotifLog mNotifLog;
@Mock private FeatureFlags mFeatureFlags;
@Mock private LeakDetector mLeakDetector;
+ @Mock private ActivatableNotificationViewController mActivatableNotificationViewController;
+ @Mock private NotificationRowComponent.Builder mNotificationRowComponentBuilder;
private int mId;
private NotificationEntry mEntry;
@@ -207,6 +211,10 @@
mock(NotifRemoteViewCache.class),
mRemoteInputManager);
+ when(mNotificationRowComponentBuilder.activatableNotificationView(any()))
+ .thenReturn(mNotificationRowComponentBuilder);
+ when(mNotificationRowComponentBuilder.build()).thenReturn(
+ () -> mActivatableNotificationViewController);
NotificationRowBinderImpl notificationRowBinder =
new NotificationRowBinderImpl(mContext,
mRemoteInputManager,
@@ -218,6 +226,7 @@
mGroupManager,
mGutsManager,
mNotificationInterruptionStateProvider,
+ () -> new RowInflaterTask(mNotificationRowComponentBuilder),
mock(NotificationLogger.class));
when(mFeatureFlags.isNewNotifPipelineEnabled()).thenReturn(false);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfoTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfoTest.java
index 9ae477e..5fc40cc 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfoTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationConversationInfoTest.java
@@ -195,8 +195,8 @@
new Intent(mContext, BubblesTestActivity.class), 0);
mBubbleSbn = new SbnBuilder(mSbn).setBubbleMetadata(
new Notification.BubbleMetadata.Builder()
- .setIntent(bubbleIntent)
- .setIcon(Icon.createWithResource(mContext, R.drawable.android)).build())
+ .createIntentBubble(bubbleIntent,
+ Icon.createWithResource(mContext, R.drawable.android)).build())
.build();
mBubbleEntry = new NotificationEntryBuilder().setSbn(mBubbleSbn).build();
@@ -209,26 +209,6 @@
}
@Test
- public void testBindNotification_SetsTextShortcutName() {
- mNotificationInfo.bindNotification(
- mShortcutManager,
- mLauncherApps,
- mMockPackageManager,
- mMockINotificationManager,
- mVisualStabilityManager,
- TEST_PACKAGE_NAME,
- mNotificationChannel,
- mEntry,
- null,
- null,
- null,
- true);
- final TextView textView = mNotificationInfo.findViewById(R.id.name);
- assertEquals(mShortcutInfo.getShortLabel(), textView.getText().toString());
- assertEquals(VISIBLE, mNotificationInfo.findViewById(R.id.header).getVisibility());
- }
-
- @Test
public void testBindNotification_SetsShortcutIcon() {
mNotificationInfo.bindNotification(
mShortcutManager,
@@ -267,7 +247,7 @@
assertTrue(textView.getText().toString().contains("App Name"));
assertEquals(VISIBLE, mNotificationInfo.findViewById(R.id.header).getVisibility());
}
-
+/**
@Test
public void testBindNotification_SetsTextChannelName() {
mNotificationInfo.bindNotification(
@@ -287,7 +267,7 @@
assertTrue(textView.getText().toString().contains(mNotificationChannel.getName()));
assertEquals(VISIBLE, mNotificationInfo.findViewById(R.id.header).getVisibility());
}
-
+*/
@Test
public void testBindNotification_SetsTextGroupName() throws Exception {
NotificationChannelGroup group = new NotificationChannelGroup("id", "name");
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManagerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManagerTest.java
index 518b670..51f214d 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManagerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationSectionsManagerTest.java
@@ -44,8 +44,12 @@
import com.android.systemui.SysuiTestCase;
import com.android.systemui.plugins.statusbar.StatusBarStateController;
import com.android.systemui.statusbar.StatusBarState;
+import com.android.systemui.statusbar.notification.NotificationSectionsFeatureManager;
import com.android.systemui.statusbar.notification.people.PeopleHubSectionFooterViewAdapter;
+import com.android.systemui.statusbar.notification.row.ActivatableNotificationView;
+import com.android.systemui.statusbar.notification.row.ActivatableNotificationViewController;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
+import com.android.systemui.statusbar.notification.row.dagger.NotificationRowComponent;
import com.android.systemui.statusbar.policy.ConfigurationController;
import org.junit.Before;
@@ -58,7 +62,7 @@
@SmallTest
@RunWith(AndroidTestingRunner.class)
-@TestableLooper.RunWithLooper
+@TestableLooper.RunWithLooper(setAsMainLooper = true)
public class NotificationSectionsManagerTest extends SysuiTestCase {
@Rule public final MockitoRule mockitoRule = MockitoJUnit.rule();
@@ -68,30 +72,47 @@
@Mock private StatusBarStateController mStatusBarStateController;
@Mock private ConfigurationController mConfigurationController;
@Mock private PeopleHubSectionFooterViewAdapter mPeopleHubAdapter;
+ @Mock private NotificationSectionsFeatureManager mSectionsFeatureManager;
+ @Mock private NotificationRowComponent mNotificationRowComponent;
+ @Mock private ActivatableNotificationViewController mActivatableNotificationViewController;
private NotificationSectionsManager mSectionsManager;
@Before
public void setUp() {
+ when(mSectionsFeatureManager.getNumberOfBuckets()).thenReturn(2);
+ when(mNotificationRowComponent.getActivatableNotificationViewController()).thenReturn(
+ mActivatableNotificationViewController
+ );
mSectionsManager =
new NotificationSectionsManager(
- mNssl,
mActivityStarterDelegate,
mStatusBarStateController,
mConfigurationController,
mPeopleHubAdapter,
- 2);
+ mSectionsFeatureManager,
+ new NotificationRowComponent.Builder() {
+ @Override
+ public NotificationRowComponent.Builder activatableNotificationView(
+ ActivatableNotificationView view) {
+ return this;
+ }
+
+ @Override
+ public NotificationRowComponent build() {
+ return mNotificationRowComponent;
+ }});
// Required in order for the header inflation to work properly
when(mNssl.generateLayoutParams(any(AttributeSet.class)))
.thenReturn(new ViewGroup.LayoutParams(WRAP_CONTENT, WRAP_CONTENT));
- mSectionsManager.initialize(LayoutInflater.from(mContext));
+ mSectionsManager.initialize(mNssl, LayoutInflater.from(mContext));
when(mNssl.indexOfChild(any(View.class))).thenReturn(-1);
when(mStatusBarStateController.getState()).thenReturn(StatusBarState.SHADE);
}
@Test(expected = IllegalStateException.class)
public void testDuplicateInitializeThrows() {
- mSectionsManager.initialize(LayoutInflater.from(mContext));
+ mSectionsManager.initialize(mNssl, LayoutInflater.from(mContext));
}
@Test
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java
index d9939f4..7602e45 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java
@@ -46,7 +46,6 @@
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.nano.MetricsProto;
-import com.android.systemui.ActivityStarterDelegate;
import com.android.systemui.ExpandHelper;
import com.android.systemui.R;
import com.android.systemui.SysuiTestCase;
@@ -74,7 +73,6 @@
import com.android.systemui.statusbar.notification.collection.inflation.NotificationRowBinder;
import com.android.systemui.statusbar.notification.collection.provider.HighPriorityProvider;
import com.android.systemui.statusbar.notification.logging.NotifLog;
-import com.android.systemui.statusbar.notification.people.PeopleHubSectionFooterViewAdapter;
import com.android.systemui.statusbar.notification.people.PeopleNotificationIdentifier;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
import com.android.systemui.statusbar.notification.row.FooterView;
@@ -87,9 +85,7 @@
import com.android.systemui.statusbar.phone.ScrimController;
import com.android.systemui.statusbar.phone.ShadeController;
import com.android.systemui.statusbar.phone.StatusBar;
-import com.android.systemui.statusbar.policy.ConfigurationController;
import com.android.systemui.statusbar.policy.ZenModeController;
-import com.android.systemui.util.DeviceConfigProxyFake;
import com.android.systemui.util.leak.LeakDetector;
import org.junit.After;
@@ -132,6 +128,8 @@
@Mock private NotificationRoundnessManager mNotificationRoundnessManager;
@Mock private KeyguardBypassController mKeyguardBypassController;
@Mock private ZenModeController mZenModeController;
+ @Mock private NotificationSectionsManager mNotificationSectionsManager;
+ @Mock private NotificationSection mNotificationSection;
private TestableNotificationEntryManager mEntryManager;
private int mOriginalInterruptionModelSetting;
@@ -181,7 +179,10 @@
NotificationShelf notificationShelf = mock(NotificationShelf.class);
-
+ when(mNotificationSectionsManager.createSectionsForBuckets()).thenReturn(
+ new NotificationSection[]{
+ mNotificationSection
+ });
// The actual class under test. You may need to work with this class directly when
// testing anonymous class members of mStackScroller, like mMenuEventListener,
// which refer to members of NotificationStackScrollLayout. The spy
@@ -190,17 +191,14 @@
mStackScrollerInternal = new NotificationStackScrollLayout(getContext(), null,
true /* allowLongPress */, mNotificationRoundnessManager,
mock(DynamicPrivacyController.class),
- mock(ConfigurationController.class),
- mock(ActivityStarterDelegate.class),
mock(SysuiStatusBarStateController.class),
mHeadsUpManager,
mKeyguardBypassController,
new FalsingManagerFake(),
mock(NotificationLockscreenUserManager.class),
mock(NotificationGutsManager.class),
- new NotificationSectionsFeatureManager(new DeviceConfigProxyFake(), mContext),
- mock(PeopleHubSectionFooterViewAdapter.class),
- mZenModeController);
+ mZenModeController,
+ mNotificationSectionsManager);
mStackScroller = spy(mStackScrollerInternal);
mStackScroller.setShelf(notificationShelf);
mStackScroller.setStatusBar(mBar);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewTest.java
index 9853540..8936a2d 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationShadeWindowViewTest.java
@@ -38,6 +38,7 @@
import com.android.systemui.statusbar.DragDownHelper;
import com.android.systemui.statusbar.NotificationLockscreenUserManager;
import com.android.systemui.statusbar.PulseExpansionHandler;
+import com.android.systemui.statusbar.StatusBarWindowBlurController;
import com.android.systemui.statusbar.SysuiStatusBarStateController;
import com.android.systemui.statusbar.notification.DynamicPrivacyController;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
@@ -79,6 +80,7 @@
@Mock private DockManager mDockManager;
@Mock private NotificationPanelViewController mNotificationPanelViewController;
@Mock private NotificationStackScrollLayout mNotificationStackScrollLayout;
+ @Mock private StatusBarWindowBlurController mStatusBarWindowBlurController;
@Before
public void setUp() {
@@ -112,6 +114,7 @@
new CommandQueue(mContext),
mShadeController,
mDockManager,
+ mStatusBarWindowBlurController,
mView,
mNotificationPanelViewController);
mController.setupExpandedStatusBar();
diff --git a/services/core/java/com/android/server/NetworkTimeUpdateService.java b/services/core/java/com/android/server/NetworkTimeUpdateService.java
index 1ff455ea..c34dd98 100644
--- a/services/core/java/com/android/server/NetworkTimeUpdateService.java
+++ b/services/core/java/com/android/server/NetworkTimeUpdateService.java
@@ -16,15 +16,273 @@
package com.android.server;
-import android.os.IBinder;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.app.timedetector.NetworkTimeSuggestion;
+import android.app.timedetector.TimeDetector;
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.ContentObserver;
+import android.net.ConnectivityManager;
+import android.net.ConnectivityManager.NetworkCallback;
+import android.net.Network;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.os.PowerManager;
+import android.os.SystemClock;
+import android.os.TimestampedValue;
+import android.provider.Settings;
+import android.util.Log;
+import android.util.NtpTrustedTime;
+import android.util.TimeUtils;
+
+import com.android.internal.util.DumpUtils;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
/**
- * An interface for NetworkTimeUpdateService implementations. Eventually part or all of this service
- * will be subsumed into {@link com.android.server.timedetector.TimeDetectorService}. In the
- * meantime this interface allows Android to use either the old or new implementation.
+ * Monitors the network time. If looking up the network time fails for some reason, it tries a few
+ * times with a short interval and then resets to checking on longer intervals.
+ *
+ * <p>When available, the time is always suggested to the {@link
+ * com.android.server.timedetector.TimeDetectorService} where it may be used to set the device
+ * system clock, depending on user settings and what other signals are available.
*/
-public interface NetworkTimeUpdateService extends IBinder {
+public class NetworkTimeUpdateService extends Binder {
+
+ private static final String TAG = "NetworkTimeUpdateService";
+ private static final boolean DBG = false;
+
+ private static final int EVENT_AUTO_TIME_ENABLED = 1;
+ private static final int EVENT_POLL_NETWORK_TIME = 2;
+ private static final int EVENT_NETWORK_CHANGED = 3;
+
+ private static final String ACTION_POLL =
+ "com.android.server.NetworkTimeUpdateService.action.POLL";
+
+ private static final int POLL_REQUEST = 0;
+
+ private Network mDefaultNetwork = null;
+
+ private final Context mContext;
+ private final NtpTrustedTime mTime;
+ private final AlarmManager mAlarmManager;
+ private final TimeDetector mTimeDetector;
+ private final ConnectivityManager mCM;
+ private final PendingIntent mPendingPollIntent;
+ private final PowerManager.WakeLock mWakeLock;
+
+ // NTP lookup is done on this thread and handler
+ private Handler mHandler;
+ private AutoTimeSettingObserver mAutoTimeSettingObserver;
+ private NetworkTimeUpdateCallback mNetworkTimeUpdateCallback;
+
+ // Normal polling frequency
+ private final long mPollingIntervalMs;
+ // Try-again polling interval, in case the network request failed
+ private final long mPollingIntervalShorterMs;
+ // Number of times to try again
+ private final int mTryAgainTimesMax;
+ // Keeps track of how many quick attempts were made to fetch NTP time.
+ // During bootup, the network may not have been up yet, or it's taking time for the
+ // connection to happen.
+ private int mTryAgainCounter;
+
+ public NetworkTimeUpdateService(Context context) {
+ mContext = context;
+ mTime = NtpTrustedTime.getInstance(context);
+ mAlarmManager = mContext.getSystemService(AlarmManager.class);
+ mTimeDetector = mContext.getSystemService(TimeDetector.class);
+ mCM = mContext.getSystemService(ConnectivityManager.class);
+
+ Intent pollIntent = new Intent(ACTION_POLL, null);
+ mPendingPollIntent = PendingIntent.getBroadcast(mContext, POLL_REQUEST, pollIntent, 0);
+
+ mPollingIntervalMs = mContext.getResources().getInteger(
+ com.android.internal.R.integer.config_ntpPollingInterval);
+ mPollingIntervalShorterMs = mContext.getResources().getInteger(
+ com.android.internal.R.integer.config_ntpPollingIntervalShorter);
+ mTryAgainTimesMax = mContext.getResources().getInteger(
+ com.android.internal.R.integer.config_ntpRetry);
+
+ mWakeLock = context.getSystemService(PowerManager.class).newWakeLock(
+ PowerManager.PARTIAL_WAKE_LOCK, TAG);
+ }
/** Initialize the receivers and initiate the first NTP request */
- void systemRunning();
+ public void systemRunning() {
+ registerForAlarms();
+
+ HandlerThread thread = new HandlerThread(TAG);
+ thread.start();
+ mHandler = new MyHandler(thread.getLooper());
+ mNetworkTimeUpdateCallback = new NetworkTimeUpdateCallback();
+ mCM.registerDefaultNetworkCallback(mNetworkTimeUpdateCallback, mHandler);
+
+ mAutoTimeSettingObserver = new AutoTimeSettingObserver(mContext, mHandler,
+ EVENT_AUTO_TIME_ENABLED);
+ mAutoTimeSettingObserver.observe();
+ }
+
+ private void registerForAlarms() {
+ mContext.registerReceiver(
+ new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ mHandler.obtainMessage(EVENT_POLL_NETWORK_TIME).sendToTarget();
+ }
+ }, new IntentFilter(ACTION_POLL));
+ }
+
+ private void onPollNetworkTime(int event) {
+ // If we don't have any default network, don't bother.
+ if (mDefaultNetwork == null) return;
+ mWakeLock.acquire();
+ try {
+ onPollNetworkTimeUnderWakeLock(event);
+ } finally {
+ mWakeLock.release();
+ }
+ }
+
+ private void onPollNetworkTimeUnderWakeLock(int event) {
+ // Force an NTP fix when outdated
+ NtpTrustedTime.TimeResult cachedNtpResult = mTime.getCachedTimeResult();
+ if (cachedNtpResult == null || cachedNtpResult.getAgeMillis() >= mPollingIntervalMs) {
+ if (DBG) Log.d(TAG, "Stale NTP fix; forcing refresh");
+ mTime.forceRefresh();
+ cachedNtpResult = mTime.getCachedTimeResult();
+ }
+
+ if (cachedNtpResult != null && cachedNtpResult.getAgeMillis() < mPollingIntervalMs) {
+ // Obtained fresh fix; schedule next normal update
+ resetAlarm(mPollingIntervalMs);
+
+ // Suggest the time to the time detector. It may choose use it to set the system clock.
+ TimestampedValue<Long> timeSignal = new TimestampedValue<>(
+ cachedNtpResult.getElapsedRealtimeMillis(), cachedNtpResult.getTimeMillis());
+ NetworkTimeSuggestion timeSuggestion = new NetworkTimeSuggestion(timeSignal);
+ timeSuggestion.addDebugInfo("Origin: NetworkTimeUpdateService. event=" + event);
+ mTimeDetector.suggestNetworkTime(timeSuggestion);
+ } else {
+ // No fresh fix; schedule retry
+ mTryAgainCounter++;
+ if (mTryAgainTimesMax < 0 || mTryAgainCounter <= mTryAgainTimesMax) {
+ resetAlarm(mPollingIntervalShorterMs);
+ } else {
+ // Try much later
+ mTryAgainCounter = 0;
+ resetAlarm(mPollingIntervalMs);
+ }
+ }
+ }
+
+ /**
+ * Cancel old alarm and starts a new one for the specified interval.
+ *
+ * @param interval when to trigger the alarm, starting from now.
+ */
+ private void resetAlarm(long interval) {
+ mAlarmManager.cancel(mPendingPollIntent);
+ long now = SystemClock.elapsedRealtime();
+ long next = now + interval;
+ mAlarmManager.set(AlarmManager.ELAPSED_REALTIME, next, mPendingPollIntent);
+ }
+
+ /** Handler to do the network accesses on */
+ private class MyHandler extends Handler {
+
+ MyHandler(Looper l) {
+ super(l);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case EVENT_AUTO_TIME_ENABLED:
+ case EVENT_POLL_NETWORK_TIME:
+ case EVENT_NETWORK_CHANGED:
+ onPollNetworkTime(msg.what);
+ break;
+ }
+ }
+ }
+
+ private class NetworkTimeUpdateCallback extends NetworkCallback {
+ @Override
+ public void onAvailable(Network network) {
+ Log.d(TAG, String.format("New default network %s; checking time.", network));
+ mDefaultNetwork = network;
+ // Running on mHandler so invoke directly.
+ onPollNetworkTime(EVENT_NETWORK_CHANGED);
+ }
+
+ @Override
+ public void onLost(Network network) {
+ if (network.equals(mDefaultNetwork)) mDefaultNetwork = null;
+ }
+ }
+
+ /**
+ * Observer to watch for changes to the AUTO_TIME setting. It only triggers when the setting
+ * is enabled.
+ */
+ private static class AutoTimeSettingObserver extends ContentObserver {
+
+ private final Context mContext;
+ private final int mMsg;
+ private final Handler mHandler;
+
+ AutoTimeSettingObserver(Context context, Handler handler, int msg) {
+ super(handler);
+ mContext = context;
+ mHandler = handler;
+ mMsg = msg;
+ }
+
+ void observe() {
+ ContentResolver resolver = mContext.getContentResolver();
+ resolver.registerContentObserver(Settings.Global.getUriFor(Settings.Global.AUTO_TIME),
+ false, this);
+ }
+
+ @Override
+ public void onChange(boolean selfChange) {
+ if (isAutomaticTimeEnabled()) {
+ mHandler.obtainMessage(mMsg).sendToTarget();
+ }
+ }
+
+ /**
+ * Checks if the user prefers to automatically set the time.
+ */
+ private boolean isAutomaticTimeEnabled() {
+ ContentResolver resolver = mContext.getContentResolver();
+ return Settings.Global.getInt(resolver, Settings.Global.AUTO_TIME, 0) != 0;
+ }
+ }
+
+ @Override
+ protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+ if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return;
+ pw.print("PollingIntervalMs: ");
+ TimeUtils.formatDuration(mPollingIntervalMs, pw);
+ pw.print("\nPollingIntervalShorterMs: ");
+ TimeUtils.formatDuration(mPollingIntervalShorterMs, pw);
+ pw.println("\nTryAgainTimesMax: " + mTryAgainTimesMax);
+ pw.println("\nTryAgainCounter: " + mTryAgainCounter);
+ NtpTrustedTime.TimeResult ntpResult = mTime.getCachedTimeResult();
+ pw.println("NTP cache result: " + ntpResult);
+ if (ntpResult != null) {
+ pw.println("NTP result age: " + ntpResult.getAgeMillis());
+ }
+ pw.println();
+ }
}
diff --git a/services/core/java/com/android/server/NetworkTimeUpdateServiceImpl.java b/services/core/java/com/android/server/NetworkTimeUpdateServiceImpl.java
deleted file mode 100644
index 7894788..0000000
--- a/services/core/java/com/android/server/NetworkTimeUpdateServiceImpl.java
+++ /dev/null
@@ -1,288 +0,0 @@
-/*
- * Copyright (C) 2010 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.server;
-
-import android.app.AlarmManager;
-import android.app.PendingIntent;
-import android.app.timedetector.NetworkTimeSuggestion;
-import android.app.timedetector.TimeDetector;
-import android.content.BroadcastReceiver;
-import android.content.ContentResolver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.database.ContentObserver;
-import android.net.ConnectivityManager;
-import android.net.ConnectivityManager.NetworkCallback;
-import android.net.Network;
-import android.os.Binder;
-import android.os.Handler;
-import android.os.HandlerThread;
-import android.os.Looper;
-import android.os.Message;
-import android.os.PowerManager;
-import android.os.SystemClock;
-import android.os.TimestampedValue;
-import android.provider.Settings;
-import android.util.Log;
-import android.util.NtpTrustedTime;
-import android.util.TimeUtils;
-
-import com.android.internal.util.DumpUtils;
-
-import java.io.FileDescriptor;
-import java.io.PrintWriter;
-
-/**
- * Monitors the network time. If looking up the network time fails for some reason, it tries a few
- * times with a short interval and then resets to checking on longer intervals.
- *
- * <p>When available, the time is always suggested to the {@link
- * com.android.server.timedetector.TimeDetectorService} where it may be used to set the device
- * system clock, depending on user settings and what other signals are available.
- */
-public class NetworkTimeUpdateServiceImpl extends Binder implements NetworkTimeUpdateService {
-
- private static final String TAG = "NetworkTimeUpdateService";
- private static final boolean DBG = false;
-
- private static final int EVENT_AUTO_TIME_ENABLED = 1;
- private static final int EVENT_POLL_NETWORK_TIME = 2;
- private static final int EVENT_NETWORK_CHANGED = 3;
-
- private static final String ACTION_POLL =
- "com.android.server.NetworkTimeUpdateService.action.POLL";
-
- private static final int POLL_REQUEST = 0;
-
- private Network mDefaultNetwork = null;
-
- private final Context mContext;
- private final NtpTrustedTime mTime;
- private final AlarmManager mAlarmManager;
- private final TimeDetector mTimeDetector;
- private final ConnectivityManager mCM;
- private final PendingIntent mPendingPollIntent;
- private final PowerManager.WakeLock mWakeLock;
-
- // NTP lookup is done on this thread and handler
- private Handler mHandler;
- private AutoTimeSettingObserver mAutoTimeSettingObserver;
- private NetworkTimeUpdateCallback mNetworkTimeUpdateCallback;
-
- // Normal polling frequency
- private final long mPollingIntervalMs;
- // Try-again polling interval, in case the network request failed
- private final long mPollingIntervalShorterMs;
- // Number of times to try again
- private final int mTryAgainTimesMax;
- // Keeps track of how many quick attempts were made to fetch NTP time.
- // During bootup, the network may not have been up yet, or it's taking time for the
- // connection to happen.
- private int mTryAgainCounter;
-
- public NetworkTimeUpdateServiceImpl(Context context) {
- mContext = context;
- mTime = NtpTrustedTime.getInstance(context);
- mAlarmManager = mContext.getSystemService(AlarmManager.class);
- mTimeDetector = mContext.getSystemService(TimeDetector.class);
- mCM = mContext.getSystemService(ConnectivityManager.class);
-
- Intent pollIntent = new Intent(ACTION_POLL, null);
- mPendingPollIntent = PendingIntent.getBroadcast(mContext, POLL_REQUEST, pollIntent, 0);
-
- mPollingIntervalMs = mContext.getResources().getInteger(
- com.android.internal.R.integer.config_ntpPollingInterval);
- mPollingIntervalShorterMs = mContext.getResources().getInteger(
- com.android.internal.R.integer.config_ntpPollingIntervalShorter);
- mTryAgainTimesMax = mContext.getResources().getInteger(
- com.android.internal.R.integer.config_ntpRetry);
-
- mWakeLock = context.getSystemService(PowerManager.class).newWakeLock(
- PowerManager.PARTIAL_WAKE_LOCK, TAG);
- }
-
- @Override
- public void systemRunning() {
- registerForAlarms();
-
- HandlerThread thread = new HandlerThread(TAG);
- thread.start();
- mHandler = new MyHandler(thread.getLooper());
- mNetworkTimeUpdateCallback = new NetworkTimeUpdateCallback();
- mCM.registerDefaultNetworkCallback(mNetworkTimeUpdateCallback, mHandler);
-
- mAutoTimeSettingObserver = new AutoTimeSettingObserver(mContext, mHandler,
- EVENT_AUTO_TIME_ENABLED);
- mAutoTimeSettingObserver.observe();
- }
-
- private void registerForAlarms() {
- mContext.registerReceiver(
- new BroadcastReceiver() {
- @Override
- public void onReceive(Context context, Intent intent) {
- mHandler.obtainMessage(EVENT_POLL_NETWORK_TIME).sendToTarget();
- }
- }, new IntentFilter(ACTION_POLL));
- }
-
- private void onPollNetworkTime(int event) {
- // If we don't have any default network, don't bother.
- if (mDefaultNetwork == null) return;
- mWakeLock.acquire();
- try {
- onPollNetworkTimeUnderWakeLock(event);
- } finally {
- mWakeLock.release();
- }
- }
-
- private void onPollNetworkTimeUnderWakeLock(int event) {
- // Force an NTP fix when outdated
- NtpTrustedTime.TimeResult cachedNtpResult = mTime.getCachedTimeResult();
- if (cachedNtpResult == null || cachedNtpResult.getAgeMillis() >= mPollingIntervalMs) {
- if (DBG) Log.d(TAG, "Stale NTP fix; forcing refresh");
- mTime.forceRefresh();
- cachedNtpResult = mTime.getCachedTimeResult();
- }
-
- if (cachedNtpResult != null && cachedNtpResult.getAgeMillis() < mPollingIntervalMs) {
- // Obtained fresh fix; schedule next normal update
- resetAlarm(mPollingIntervalMs);
-
- // Suggest the time to the time detector. It may choose use it to set the system clock.
- TimestampedValue<Long> timeSignal = new TimestampedValue<>(
- cachedNtpResult.getElapsedRealtimeMillis(), cachedNtpResult.getTimeMillis());
- NetworkTimeSuggestion timeSuggestion = new NetworkTimeSuggestion(timeSignal);
- timeSuggestion.addDebugInfo("Origin: NetworkTimeUpdateServiceImpl. event=" + event);
- mTimeDetector.suggestNetworkTime(timeSuggestion);
- } else {
- // No fresh fix; schedule retry
- mTryAgainCounter++;
- if (mTryAgainTimesMax < 0 || mTryAgainCounter <= mTryAgainTimesMax) {
- resetAlarm(mPollingIntervalShorterMs);
- } else {
- // Try much later
- mTryAgainCounter = 0;
- resetAlarm(mPollingIntervalMs);
- }
- }
- }
-
- /**
- * Cancel old alarm and starts a new one for the specified interval.
- *
- * @param interval when to trigger the alarm, starting from now.
- */
- private void resetAlarm(long interval) {
- mAlarmManager.cancel(mPendingPollIntent);
- long now = SystemClock.elapsedRealtime();
- long next = now + interval;
- mAlarmManager.set(AlarmManager.ELAPSED_REALTIME, next, mPendingPollIntent);
- }
-
- /** Handler to do the network accesses on */
- private class MyHandler extends Handler {
-
- public MyHandler(Looper l) {
- super(l);
- }
-
- @Override
- public void handleMessage(Message msg) {
- switch (msg.what) {
- case EVENT_AUTO_TIME_ENABLED:
- case EVENT_POLL_NETWORK_TIME:
- case EVENT_NETWORK_CHANGED:
- onPollNetworkTime(msg.what);
- break;
- }
- }
- }
-
- private class NetworkTimeUpdateCallback extends NetworkCallback {
- @Override
- public void onAvailable(Network network) {
- Log.d(TAG, String.format("New default network %s; checking time.", network));
- mDefaultNetwork = network;
- // Running on mHandler so invoke directly.
- onPollNetworkTime(EVENT_NETWORK_CHANGED);
- }
-
- @Override
- public void onLost(Network network) {
- if (network.equals(mDefaultNetwork)) mDefaultNetwork = null;
- }
- }
-
- /**
- * Observer to watch for changes to the AUTO_TIME setting. It only triggers when the setting
- * is enabled.
- */
- private static class AutoTimeSettingObserver extends ContentObserver {
-
- private final Context mContext;
- private final int mMsg;
- private final Handler mHandler;
-
- AutoTimeSettingObserver(Context context, Handler handler, int msg) {
- super(handler);
- mContext = context;
- mHandler = handler;
- mMsg = msg;
- }
-
- void observe() {
- ContentResolver resolver = mContext.getContentResolver();
- resolver.registerContentObserver(Settings.Global.getUriFor(Settings.Global.AUTO_TIME),
- false, this);
- }
-
- @Override
- public void onChange(boolean selfChange) {
- if (isAutomaticTimeEnabled()) {
- mHandler.obtainMessage(mMsg).sendToTarget();
- }
- }
-
- /**
- * Checks if the user prefers to automatically set the time.
- */
- private boolean isAutomaticTimeEnabled() {
- ContentResolver resolver = mContext.getContentResolver();
- return Settings.Global.getInt(resolver, Settings.Global.AUTO_TIME, 0) != 0;
- }
- }
-
- @Override
- protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
- if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return;
- pw.print("PollingIntervalMs: ");
- TimeUtils.formatDuration(mPollingIntervalMs, pw);
- pw.print("\nPollingIntervalShorterMs: ");
- TimeUtils.formatDuration(mPollingIntervalShorterMs, pw);
- pw.println("\nTryAgainTimesMax: " + mTryAgainTimesMax);
- pw.println("\nTryAgainCounter: " + mTryAgainCounter);
- NtpTrustedTime.TimeResult ntpResult = mTime.getCachedTimeResult();
- pw.println("NTP cache result: " + ntpResult);
- if (ntpResult != null) {
- pw.println("NTP result age: " + ntpResult.getAgeMillis());
- }
- pw.println();
- }
-}
diff --git a/services/core/java/com/android/server/TelephonyRegistry.java b/services/core/java/com/android/server/TelephonyRegistry.java
index 7324d97..1cae5f2 100644
--- a/services/core/java/com/android/server/TelephonyRegistry.java
+++ b/services/core/java/com/android/server/TelephonyRegistry.java
@@ -885,6 +885,10 @@
remove(r.binder);
}
}
+ if ((events & PhoneStateListener.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH)
+ != 0) {
+ updateReportSignalStrengthDecision(r.subId);
+ }
if (validateEventsAndUserLocked(r, PhoneStateListener.LISTEN_CELL_INFO)) {
try {
if (DBG_LOC) log("listen: mCellInfo[" + phoneId + "] = "
@@ -1021,6 +1025,27 @@
}
}
+ private void updateReportSignalStrengthDecision(int subscriptionId) {
+ synchronized (mRecords) {
+ TelephonyManager telephonyManager = (TelephonyManager) mContext
+ .getSystemService(Context.TELEPHONY_SERVICE);
+ for (Record r : mRecords) {
+ // If any of the system clients wants to always listen to signal strength,
+ // we need to set it on.
+ if (r.matchPhoneStateListenerEvent(
+ PhoneStateListener.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH)) {
+ telephonyManager.createForSubscriptionId(subscriptionId)
+ .setAlwaysReportSignalStrength(true);
+ return;
+ }
+ }
+ // If none of the system clients wants to always listen to signal strength,
+ // we need to set it off.
+ telephonyManager.createForSubscriptionId(subscriptionId)
+ .setAlwaysReportSignalStrength(false);
+ }
+ }
+
private String getCallIncomingNumber(Record record, int phoneId) {
// Only reveal the incoming number if the record has read call log permission.
return record.canReadCallLog() ? mCallIncomingNumber[phoneId] : "";
@@ -1078,6 +1103,14 @@
}
mRecords.remove(i);
+
+ // Every time a client that is registrating to always receive the signal
+ // strength is removed from registry records, we need to check if
+ // the signal strength decision needs to update on its slot.
+ if (r.matchPhoneStateListenerEvent(
+ PhoneStateListener.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH)) {
+ updateReportSignalStrengthDecision(r.subId);
+ }
return;
}
}
@@ -2494,6 +2527,11 @@
android.Manifest.permission.READ_ACTIVE_EMERGENCY_SESSION, null);
}
+ if ((events & PhoneStateListener.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH) != 0) {
+ mContext.enforceCallingOrSelfPermission(
+ android.Manifest.permission.LISTEN_ALWAYS_REPORTED_SIGNAL_STRENGTH, null);
+ }
+
if ((events & PhoneStateListener.LISTEN_OEM_HOOK_RAW_EVENT) != 0) {
mContext.enforceCallingOrSelfPermission(
android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE, null);
diff --git a/services/core/java/com/android/server/UiModeManagerService.java b/services/core/java/com/android/server/UiModeManagerService.java
index 9ffe89c..b994e6c 100644
--- a/services/core/java/com/android/server/UiModeManagerService.java
+++ b/services/core/java/com/android/server/UiModeManagerService.java
@@ -21,6 +21,7 @@
import android.app.Activity;
import android.app.ActivityManager;
import android.app.ActivityTaskManager;
+import android.app.AlarmManager;
import android.app.IUiModeManager;
import android.app.Notification;
import android.app.NotificationManager;
@@ -70,10 +71,19 @@
import java.io.FileDescriptor;
import java.io.PrintWriter;
+import java.time.DateTimeException;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
+import static android.app.UiModeManager.MODE_NIGHT_AUTO;
+import static android.app.UiModeManager.MODE_NIGHT_CUSTOM;
+import static android.app.UiModeManager.MODE_NIGHT_YES;
+import static android.util.TimeUtils.isTimeBetween;
+
final class UiModeManagerService extends SystemService {
private static final String TAG = UiModeManager.class.getSimpleName();
private static final boolean LOG = false;
@@ -90,7 +100,12 @@
// we use the override auto mode
// for example: force night mode off in the night time while in auto mode
private int mNightModeOverride = mNightMode;
- protected static final String OVERRIDE_NIGHT_MODE = Secure.UI_NIGHT_MODE + "_override";
+ private final LocalTime DEFAULT_CUSTOM_NIGHT_START_TIME = LocalTime.of(22, 0);
+ private final LocalTime DEFAULT_CUSTOM_NIGHT_END_TIME = LocalTime.of(6, 0);
+ private LocalTime mCustomAutoNightModeStartMilliseconds = DEFAULT_CUSTOM_NIGHT_START_TIME;
+ private LocalTime mCustomAutoNightModeEndMilliseconds = DEFAULT_CUSTOM_NIGHT_END_TIME;
+
+ protected static final String OVERRIDE_NIGHT_MODE = Secure.UI_NIGHT_MODE_OVERRIDE;
private Map<Integer, String> mCarModePackagePriority = new HashMap<>();
private boolean mCarModeEnabled = false;
@@ -131,6 +146,8 @@
private NotificationManager mNotificationManager;
private StatusBarManager mStatusBarManager;
private WindowManagerInternal mWindowManager;
+ private AlarmManager mAlarmManager;
+ private PowerManager mPowerManager;
private PowerManager.WakeLock mWakeLock;
@@ -141,14 +158,16 @@
}
@VisibleForTesting
- protected UiModeManagerService(Context context, WindowManagerInternal wm,
- PowerManager.WakeLock wl, TwilightManager tm,
+ protected UiModeManagerService(Context context, WindowManagerInternal wm, AlarmManager am,
+ PowerManager pm, PowerManager.WakeLock wl, TwilightManager tm,
boolean setupWizardComplete) {
super(context);
mWindowManager = wm;
mWakeLock = wl;
mTwilightManager = tm;
mSetupWizardComplete = setupWizardComplete;
+ mAlarmManager = am;
+ mPowerManager = pm;
}
private static Intent buildHomeIntent(String category) {
@@ -237,6 +256,21 @@
}
};
+ private final BroadcastReceiver mOnTimeChangedHandler = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ synchronized (mLock) {
+ updateCustomTimeLocked();
+ }
+ }
+ };
+
+ private final AlarmManager.OnAlarmListener mCustomTimeListener = () -> {
+ synchronized (mLock) {
+ updateCustomTimeLocked();
+ }
+ };
+
private final IVrStateCallbacks mVrStateCallbacks = new IVrStateCallbacks.Stub() {
@Override
public void onVrStateChanged(boolean enabled) {
@@ -270,8 +304,9 @@
public void onChange(boolean selfChange, Uri uri) {
int mode = Secure.getIntForUser(getContext().getContentResolver(), Secure.UI_NIGHT_MODE,
mNightMode, 0);
- mode = mode == UiModeManager.MODE_NIGHT_AUTO
- ? UiModeManager.MODE_NIGHT_YES : UiModeManager.MODE_NIGHT_NO;
+ if (mode == MODE_NIGHT_AUTO || mode == MODE_NIGHT_CUSTOM) {
+ mode = MODE_NIGHT_YES;
+ }
SystemProperties.set(SYSTEM_PROPERTY_DEVICE_THEME, Integer.toString(mode));
}
};
@@ -287,10 +322,11 @@
public void onStart() {
final Context context = getContext();
- final PowerManager powerManager =
+ mPowerManager =
(PowerManager) context.getSystemService(Context.POWER_SERVICE);
- mWakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG);
+ mWakeLock = mPowerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG);
mWindowManager = LocalServices.getService(WindowManagerInternal.class);
+ mAlarmManager = (AlarmManager) getContext().getSystemService(Context.ALARM_SERVICE);
// If setup isn't complete for this user listen for completion so we can unblock
// being able to send a night mode configuration change event
@@ -387,6 +423,16 @@
Secure.USER_SETUP_COMPLETE, 0, UserHandle.getCallingUserId()) == 1;
}
+ private void updateCustomTimeLocked() {
+ if (mNightMode != MODE_NIGHT_CUSTOM) return;
+ if (shouldApplyAutomaticChangesImmediately()) {
+ updateLocked(0, 0);
+ } else {
+ registerScreenOffEvent();
+ }
+ scheduleNextCustomTimeListener();
+ }
+
/**
* Updates the night mode setting in Settings.Global and returns if the value was successfully
* changed.
@@ -404,9 +450,19 @@
Secure.UI_NIGHT_MODE, defaultNightMode, userId);
mNightModeOverride = Secure.getIntForUser(context.getContentResolver(),
OVERRIDE_NIGHT_MODE, defaultNightMode, userId);
+ mCustomAutoNightModeStartMilliseconds = LocalTime.ofNanoOfDay(
+ Secure.getLongForUser(context.getContentResolver(),
+ Secure.DARK_THEME_CUSTOM_START_TIME,
+ DEFAULT_CUSTOM_NIGHT_START_TIME.toNanoOfDay() / 1000L, userId) * 1000);
+ mCustomAutoNightModeEndMilliseconds = LocalTime.ofNanoOfDay(
+ Secure.getLongForUser(context.getContentResolver(),
+ Secure.DARK_THEME_CUSTOM_END_TIME,
+ DEFAULT_CUSTOM_NIGHT_END_TIME.toNanoOfDay() / 1000L, userId) * 1000);
} else {
mNightMode = defaultNightMode;
mNightModeOverride = defaultNightMode;
+ mCustomAutoNightModeEndMilliseconds = DEFAULT_CUSTOM_NIGHT_END_TIME;
+ mCustomAutoNightModeStartMilliseconds = DEFAULT_CUSTOM_NIGHT_START_TIME;
}
return oldNightMode != mNightMode;
@@ -419,6 +475,10 @@
getContext().registerReceiver(mOnScreenOffHandler, intentFilter);
}
+ private void cancelCustomAlarm() {
+ mAlarmManager.cancel(mCustomTimeListener);
+ }
+
private void unregisterScreenOffEvent() {
mWaitForScreenOff = false;
try {
@@ -428,6 +488,21 @@
}
}
+ private void registerTimeChangeEvent() {
+ final IntentFilter intentFilter =
+ new IntentFilter(Intent.ACTION_TIME_CHANGED);
+ intentFilter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
+ getContext().registerReceiver(mOnTimeChangedHandler, intentFilter);
+ }
+
+ private void unregisterTimeChangeEvent() {
+ try {
+ getContext().unregisterReceiver(mOnTimeChangedHandler);
+ } catch (IllegalArgumentException e) {
+ // we ignore this exception if the receiver is unregistered already.
+ }
+ }
+
private final IUiModeManager.Stub mService = new IUiModeManager.Stub() {
@Override
public void enableCarMode(@UiModeManager.EnableCarMode int flags,
@@ -537,7 +612,8 @@
switch (mode) {
case UiModeManager.MODE_NIGHT_NO:
case UiModeManager.MODE_NIGHT_YES:
- case UiModeManager.MODE_NIGHT_AUTO:
+ case MODE_NIGHT_AUTO:
+ case MODE_NIGHT_CUSTOM:
break;
default:
throw new IllegalArgumentException("Unknown mode: " + mode);
@@ -548,8 +624,9 @@
try {
synchronized (mLock) {
if (mNightMode != mode) {
- if (mNightMode == UiModeManager.MODE_NIGHT_AUTO) {
+ if (mNightMode == MODE_NIGHT_AUTO || mNightMode == MODE_NIGHT_CUSTOM) {
unregisterScreenOffEvent();
+ cancelCustomAlarm();
}
mNightMode = mode;
@@ -559,7 +636,9 @@
persistNightMode(user);
}
// on screen off will update configuration instead
- if (mNightMode != UiModeManager.MODE_NIGHT_AUTO || mCar) {
+ if ((mNightMode != MODE_NIGHT_AUTO && mNightMode != MODE_NIGHT_CUSTOM)
+ || shouldApplyAutomaticChangesImmediately()) {
+ unregisterScreenOffEvent();
updateLocked(0, 0);
} else {
registerScreenOffEvent();
@@ -610,7 +689,7 @@
final int user = UserHandle.getCallingUserId();
final long ident = Binder.clearCallingIdentity();
try {
- if (mNightMode == UiModeManager.MODE_NIGHT_AUTO) {
+ if (mNightMode == MODE_NIGHT_AUTO || mNightMode == MODE_NIGHT_CUSTOM) {
unregisterScreenOffEvent();
mNightModeOverride = active
? UiModeManager.MODE_NIGHT_YES : UiModeManager.MODE_NIGHT_NO;
@@ -630,8 +709,74 @@
}
}
}
+
+ @Override
+ public long getCustomNightModeStart() {
+ return mCustomAutoNightModeStartMilliseconds.toNanoOfDay() / 1000;
+ }
+
+ @Override
+ public void setCustomNightModeStart(long time) {
+ if (isNightModeLocked() && getContext().checkCallingOrSelfPermission(
+ android.Manifest.permission.MODIFY_DAY_NIGHT_MODE)
+ != PackageManager.PERMISSION_GRANTED) {
+ Slog.e(TAG, "Set custom time start, requires MODIFY_DAY_NIGHT_MODE permission");
+ return;
+ }
+ final int user = UserHandle.getCallingUserId();
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ LocalTime newTime = LocalTime.ofNanoOfDay(time * 1000);
+ if (newTime == null) return;
+ mCustomAutoNightModeStartMilliseconds = newTime;
+ persistNightMode(user);
+ onCustomTimeUpdated(user);
+ } catch (DateTimeException e) {
+ unregisterScreenOffEvent();
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
+
+ @Override
+ public long getCustomNightModeEnd() {
+ return mCustomAutoNightModeEndMilliseconds.toNanoOfDay() / 1000;
+ }
+
+ @Override
+ public void setCustomNightModeEnd(long time) {
+ if (isNightModeLocked() && getContext().checkCallingOrSelfPermission(
+ android.Manifest.permission.MODIFY_DAY_NIGHT_MODE)
+ != PackageManager.PERMISSION_GRANTED) {
+ Slog.e(TAG, "Set custom time end, requires MODIFY_DAY_NIGHT_MODE permission");
+ return;
+ }
+ final int user = UserHandle.getCallingUserId();
+ final long ident = Binder.clearCallingIdentity();
+ try {
+ LocalTime newTime = LocalTime.ofNanoOfDay(time * 1000);
+ if (newTime == null) return;
+ mCustomAutoNightModeEndMilliseconds = newTime;
+ onCustomTimeUpdated(user);
+ } catch (DateTimeException e) {
+ unregisterScreenOffEvent();
+ } finally {
+ Binder.restoreCallingIdentity(ident);
+ }
+ }
};
+ private void onCustomTimeUpdated(int user) {
+ persistNightMode(user);
+ if (mNightMode != MODE_NIGHT_CUSTOM) return;
+ if (shouldApplyAutomaticChangesImmediately()) {
+ unregisterScreenOffEvent();
+ updateLocked(0, 0);
+ } else {
+ registerScreenOffEvent();
+ }
+ }
+
void dumpImpl(PrintWriter pw) {
synchronized (mLock) {
pw.println("Current UI Mode Service state:");
@@ -677,7 +822,6 @@
mTwilightManager = getLocalService(TwilightManager.class);
mSystemReady = true;
mCarModeEnabled = mDockState == Intent.EXTRA_DOCK_STATE_CAR;
- updateComputedNightModeLocked();
registerVrStateListener();
updateLocked(0, 0);
}
@@ -838,6 +982,12 @@
Secure.UI_NIGHT_MODE, mNightMode, user);
Secure.putIntForUser(getContext().getContentResolver(),
OVERRIDE_NIGHT_MODE, mNightModeOverride, user);
+ Secure.putLongForUser(getContext().getContentResolver(),
+ Secure.DARK_THEME_CUSTOM_START_TIME,
+ mCustomAutoNightModeStartMilliseconds.toNanoOfDay() / 1000, user);
+ Secure.putLongForUser(getContext().getContentResolver(),
+ Secure.DARK_THEME_CUSTOM_END_TIME,
+ mCustomAutoNightModeEndMilliseconds.toNanoOfDay() / 1000, user);
}
private void updateConfigurationLocked() {
@@ -856,13 +1006,16 @@
uiMode = Configuration.UI_MODE_TYPE_VR_HEADSET;
}
- if (mNightMode == UiModeManager.MODE_NIGHT_AUTO) {
+ if (mNightMode == MODE_NIGHT_AUTO) {
+ boolean activateNightMode = mComputedNightMode;
if (mTwilightManager != null) {
mTwilightManager.registerListener(mTwilightListener, mHandler);
+ final TwilightState lastState = mTwilightManager.getLastTwilightState();
+ activateNightMode = lastState == null ? mComputedNightMode : lastState.isNight();
}
- updateComputedNightModeLocked();
- uiMode |= mComputedNightMode ? Configuration.UI_MODE_NIGHT_YES
- : Configuration.UI_MODE_NIGHT_NO;
+
+ updateComputedNightModeLocked(activateNightMode);
+ uiMode = getComputedUiModeConfiguration(uiMode);
} else {
if (mTwilightManager != null) {
mTwilightManager.unregisterListener(mTwilightListener);
@@ -870,6 +1023,16 @@
uiMode |= mNightMode << 4;
}
+ if (mNightMode == MODE_NIGHT_CUSTOM) {
+ registerTimeChangeEvent();
+ final boolean activate = computeCustomNightMode();
+ updateComputedNightModeLocked(activate);
+ scheduleNextCustomTimeListener();
+ uiMode = getComputedUiModeConfiguration(uiMode);
+ } else {
+ unregisterTimeChangeEvent();
+ }
+
// Override night mode in power save mode if not in car mode
if (mPowerSave && !mCarModeEnabled) {
uiMode &= ~Configuration.UI_MODE_NIGHT_NO;
@@ -885,11 +1048,26 @@
}
mCurUiMode = uiMode;
- if (!mHoldingConfiguration || !mWaitForScreenOff) {
+ if (!mHoldingConfiguration && !mWaitForScreenOff) {
mConfiguration.uiMode = uiMode;
}
}
+ @UiModeManager.NightMode
+ private int getComputedUiModeConfiguration(@UiModeManager.NightMode int uiMode) {
+ uiMode |= mComputedNightMode ? Configuration.UI_MODE_NIGHT_YES
+ : Configuration.UI_MODE_NIGHT_NO;
+ uiMode &= mComputedNightMode ? ~Configuration.UI_MODE_NIGHT_NO
+ : ~Configuration.UI_MODE_NIGHT_YES;
+ return uiMode;
+ }
+
+ private boolean computeCustomNightMode() {
+ return isTimeBetween(LocalTime.now(),
+ mCustomAutoNightModeStartMilliseconds,
+ mCustomAutoNightModeEndMilliseconds);
+ }
+
private void applyConfigurationExternallyLocked() {
if (mSetUiMode != mConfiguration.uiMode) {
mSetUiMode = mConfiguration.uiMode;
@@ -899,10 +1077,34 @@
ActivityTaskManager.getService().updateConfiguration(mConfiguration);
} catch (RemoteException e) {
Slog.w(TAG, "Failure communicating with activity manager", e);
+ } catch (SecurityException e) {
+ Slog.e(TAG, "Activity does not have the ", e);
}
}
}
+ private boolean shouldApplyAutomaticChangesImmediately() {
+ return mCar || !mPowerManager.isInteractive();
+ }
+
+ private void scheduleNextCustomTimeListener() {
+ cancelCustomAlarm();
+ LocalDateTime now = LocalDateTime.now();
+ final boolean active = computeCustomNightMode();
+ final LocalDateTime next = active
+ ? getDateTimeAfter(mCustomAutoNightModeEndMilliseconds, now)
+ : getDateTimeAfter(mCustomAutoNightModeStartMilliseconds, now);
+ final long millis = next.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
+ mAlarmManager.setExact(AlarmManager.RTC, millis, TAG, mCustomTimeListener, null);
+ }
+
+ private LocalDateTime getDateTimeAfter(LocalTime localTime, LocalDateTime compareTime) {
+ final LocalDateTime ldt = LocalDateTime.of(compareTime.toLocalDate(), localTime);
+
+ // Check if the local time has passed, if so return the same time tomorrow.
+ return ldt.isBefore(compareTime) ? ldt.plusDays(1) : ldt;
+ }
+
void updateLocked(int enableFlags, int disableFlags) {
String action = null;
String oldAction = null;
@@ -1133,26 +1335,21 @@
}
}
- private void updateComputedNightModeLocked() {
- if (mTwilightManager != null) {
- TwilightState state = mTwilightManager.getLastTwilightState();
- if (state != null) {
- mComputedNightMode = state.isNight();
- }
- if (mNightModeOverride == UiModeManager.MODE_NIGHT_YES && !mComputedNightMode) {
- mComputedNightMode = true;
- return;
- }
- if (mNightModeOverride == UiModeManager.MODE_NIGHT_NO && mComputedNightMode) {
- mComputedNightMode = false;
- return;
- }
-
- mNightModeOverride = mNightMode;
- final int user = UserHandle.getCallingUserId();
- Secure.putIntForUser(getContext().getContentResolver(),
- OVERRIDE_NIGHT_MODE, mNightModeOverride, user);
+ private void updateComputedNightModeLocked(boolean activate) {
+ mComputedNightMode = activate;
+ if (mNightModeOverride == UiModeManager.MODE_NIGHT_YES && !mComputedNightMode) {
+ mComputedNightMode = true;
+ return;
}
+ if (mNightModeOverride == UiModeManager.MODE_NIGHT_NO && mComputedNightMode) {
+ mComputedNightMode = false;
+ return;
+ }
+
+ mNightModeOverride = mNightMode;
+ final int user = UserHandle.getCallingUserId();
+ Secure.putIntForUser(getContext().getContentResolver(),
+ OVERRIDE_NIGHT_MODE, mNightModeOverride, user);
}
private void registerVrStateListener() {
@@ -1174,6 +1371,7 @@
public static final String NIGHT_MODE_STR_YES = "yes";
public static final String NIGHT_MODE_STR_NO = "no";
public static final String NIGHT_MODE_STR_AUTO = "auto";
+ public static final String NIGHT_MODE_STR_CUSTOM = "custom";
public static final String NIGHT_MODE_STR_UNKNOWN = "unknown";
private final IUiModeManager mInterface;
@@ -1246,6 +1444,8 @@
return NIGHT_MODE_STR_NO;
case UiModeManager.MODE_NIGHT_AUTO:
return NIGHT_MODE_STR_AUTO;
+ case MODE_NIGHT_CUSTOM:
+ return NIGHT_MODE_STR_CUSTOM;
default:
return NIGHT_MODE_STR_UNKNOWN;
}
@@ -1259,6 +1459,8 @@
return UiModeManager.MODE_NIGHT_NO;
case NIGHT_MODE_STR_AUTO:
return UiModeManager.MODE_NIGHT_AUTO;
+ case NIGHT_MODE_STR_CUSTOM:
+ return UiModeManager.MODE_NIGHT_CUSTOM;
default:
return -1;
}
diff --git a/services/core/java/com/android/server/accounts/AccountManagerServiceShellCommand.java b/services/core/java/com/android/server/accounts/AccountManagerServiceShellCommand.java
index 9bf0bd3..afb20ec 100644
--- a/services/core/java/com/android/server/accounts/AccountManagerServiceShellCommand.java
+++ b/services/core/java/com/android/server/accounts/AccountManagerServiceShellCommand.java
@@ -78,7 +78,18 @@
final String option = getNextOption();
if (option != null) {
if (option.equals("--user")) {
- return UserHandle.parseUserArg(getNextArgRequired());
+ int userId = UserHandle.parseUserArg(getNextArgRequired());
+ if (userId == UserHandle.USER_CURRENT) {
+ return ActivityManager.getCurrentUser();
+ } else if (userId == UserHandle.USER_ALL) {
+ getErrPrintWriter().println("USER_ALL not supported. Specify a user.");
+ return null;
+ } else if (userId < 0) {
+ getErrPrintWriter().println("Invalid user: " + userId);
+ return null;
+ } else {
+ return userId;
+ }
} else {
getErrPrintWriter().println("Unknown option: " + option);
return null;
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index d9fbc85..00c0b3e 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -4866,7 +4866,7 @@
updateProcessForegroundLocked(app, false, 0, false);
app.hasShownUi = false;
app.setDebugging(false);
- app.cached = false;
+ app.setCached(false);
app.killedByAm = false;
app.killed = false;
@@ -12154,7 +12154,7 @@
r.lastSwapPss*1024, new StringBuilder()));
proto.write(ProcessOomProto.Detail.LAST_CACHED_PSS, DebugUtils.sizeValueToString(
r.lastCachedPss*1024, new StringBuilder()));
- proto.write(ProcessOomProto.Detail.CACHED, r.cached);
+ proto.write(ProcessOomProto.Detail.CACHED, r.isCached());
proto.write(ProcessOomProto.Detail.EMPTY, r.empty);
proto.write(ProcessOomProto.Detail.HAS_ABOVE_CLIENT, r.hasAboveClient);
@@ -12281,7 +12281,7 @@
pw.println();
pw.print(prefix);
pw.print(" ");
- pw.print("cached="); pw.print(r.cached);
+ pw.print("cached="); pw.print(r.isCached());
pw.print(" empty="); pw.print(r.empty);
pw.print(" hasAboveClient="); pw.println(r.hasAboveClient);
diff --git a/services/core/java/com/android/server/am/ActivityManagerShellCommand.java b/services/core/java/com/android/server/am/ActivityManagerShellCommand.java
index e7d6eb7..3f0e2ce 100644
--- a/services/core/java/com/android/server/am/ActivityManagerShellCommand.java
+++ b/services/core/java/com/android/server/am/ActivityManagerShellCommand.java
@@ -1759,7 +1759,7 @@
return 0;
}
- private void switchUserAndWaitForComplete(int userId) throws RemoteException {
+ private boolean switchUserAndWaitForComplete(int userId) throws RemoteException {
// Register switch observer.
final CountDownLatch switchLatch = new CountDownLatch(1);
mInterface.registerUserSwitchObserver(
@@ -1773,7 +1773,7 @@
}, ActivityManagerShellCommand.class.getName());
// Switch.
- mInterface.switchUser(userId);
+ boolean switched = mInterface.switchUser(userId);
// Wait.
try {
@@ -1781,6 +1781,7 @@
} catch (InterruptedException e) {
getErrPrintWriter().println("Thread interrupted unexpectedly.");
}
+ return switched;
}
int runSwitchUser(PrintWriter pw) throws RemoteException {
@@ -1802,12 +1803,18 @@
}
int userId = Integer.parseInt(getNextArgRequired());
+ boolean switched;
if (wait) {
- switchUserAndWaitForComplete(userId);
+ switched = switchUserAndWaitForComplete(userId);
} else {
- mInterface.switchUser(userId);
+ switched = mInterface.switchUser(userId);
}
- return 0;
+ if (switched) {
+ return 0;
+ } else {
+ pw.printf("Failed to switch to user %d\n", userId);
+ return 1;
+ }
}
int runGetCurrentUser(PrintWriter pw) throws RemoteException {
diff --git a/services/core/java/com/android/server/am/OomAdjuster.java b/services/core/java/com/android/server/am/OomAdjuster.java
index be14b3b..63331fa 100644
--- a/services/core/java/com/android/server/am/OomAdjuster.java
+++ b/services/core/java/com/android/server/am/OomAdjuster.java
@@ -71,6 +71,9 @@
import android.app.ActivityManager;
import android.app.ApplicationExitInfo;
import android.app.usage.UsageEvents;
+import android.compat.Compatibility;
+import android.compat.annotation.ChangeId;
+import android.compat.annotation.EnabledAfter;
import android.content.Context;
import android.content.pm.ServiceInfo;
import android.os.Build;
@@ -106,7 +109,6 @@
*/
public final class OomAdjuster {
private static final String TAG = "OomAdjuster";
-
static final String OOM_ADJ_REASON_METHOD = "updateOomAdj";
static final String OOM_ADJ_REASON_NONE = OOM_ADJ_REASON_METHOD + "_meh";
static final String OOM_ADJ_REASON_ACTIVITY = OOM_ADJ_REASON_METHOD + "_activityChange";
@@ -123,6 +125,17 @@
static final String OOM_ADJ_REASON_PROCESS_END = OOM_ADJ_REASON_METHOD + "_processEnd";
/**
+ * Flag {@link Context#BIND_INCLUDE_CAPABILITIES} is used
+ * to pass while-in-use capabilities from client process to bound service. In targetSdkVersion
+ * R and above, if client is a TOP activity, when this flag is present, bound service gets all
+ * while-in-use capabilities; when this flag is not present, bound service gets no while-in-use
+ * capabilitiy from client.
+ */
+ @ChangeId
+ @EnabledAfter(targetSdkVersion=android.os.Build.VERSION_CODES.Q)
+ static final long PROCESS_CAPABILITY_CHANGE_ID = 136274596L;
+
+ /**
* For some direct access we need to power manager.
*/
PowerManagerInternal mLocalPowerManager;
@@ -248,7 +261,7 @@
return updateOomAdjLocked(app, oomAdjReason);
}
final ProcessRecord TOP_APP = mService.getTopAppLocked();
- final boolean wasCached = app.cached;
+ final boolean wasCached = app.isCached();
mAdjSeq++;
@@ -261,7 +274,7 @@
boolean success = updateOomAdjLocked(app, cachedAdj, TOP_APP, false,
SystemClock.uptimeMillis());
if (oomAdjAll
- && (wasCached != app.cached || app.getCurRawAdj() == ProcessList.UNKNOWN_ADJ)) {
+ && (wasCached != app.isCached() || app.getCurRawAdj() == ProcessList.UNKNOWN_ADJ)) {
// Changed to/from cached state, so apps after it in the LRU
// list may also be changed.
updateOomAdjLocked(oomAdjReason);
@@ -337,7 +350,7 @@
mAdjSeq++;
// Firstly, try to see if the importance of itself gets changed
- final boolean wasCached = app.cached;
+ final boolean wasCached = app.isCached();
final int oldAdj = app.getCurRawAdj();
final int cachedAdj = oldAdj >= ProcessList.CACHED_APP_MIN_ADJ
? oldAdj : ProcessList.UNKNOWN_ADJ;
@@ -347,7 +360,7 @@
app.resetCachedInfo();
boolean success = updateOomAdjLocked(app, cachedAdj, topApp, false,
SystemClock.uptimeMillis());
- if (!success || (wasCached == app.cached && oldAdj != ProcessList.INVALID_ADJ
+ if (!success || (wasCached == app.isCached() && oldAdj != ProcessList.INVALID_ADJ
&& wasBackground == ActivityManager.isProcStateBackground(app.setProcState))) {
// Okay, it's unchanged, it won't impact any service it binds to, we're done here.
if (DEBUG_OOM_ADJ) {
@@ -965,7 +978,7 @@
if (schedGroup < ProcessList.SCHED_GROUP_DEFAULT) {
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
- app.cached = false;
+ app.setCached(false);
app.empty = false;
foregroundActivities = true;
}
@@ -990,7 +1003,7 @@
if (schedGroup < ProcessList.SCHED_GROUP_DEFAULT) {
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
- app.cached = false;
+ app.setCached(false);
app.empty = false;
foregroundActivities = true;
}
@@ -1022,7 +1035,7 @@
}
}
}
- app.cached = false;
+ app.setCached(false);
app.empty = false;
foregroundActivities = true;
}
@@ -1071,7 +1084,7 @@
app.adjSource = null;
app.adjTarget = null;
app.empty = false;
- app.cached = false;
+ app.setCached(false);
final int appUid = app.info.uid;
final int logUid = mService.mCurOomAdjUid;
@@ -1207,7 +1220,7 @@
// value that the caller wants us to.
adj = cachedAdj;
procState = PROCESS_STATE_CACHED_EMPTY;
- app.cached = true;
+ app.setCached(true);
app.empty = true;
app.adjType = "cch-empty";
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
@@ -1242,7 +1255,7 @@
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
procState = PROCESS_STATE_FOREGROUND_SERVICE;
app.adjType = "fg-service";
- app.cached = false;
+ app.setCached(false);
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise to " + app.adjType + ": "
@@ -1252,7 +1265,7 @@
// The process is display an overlay UI.
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
procState = PROCESS_STATE_IMPORTANT_FOREGROUND;
- app.cached = false;
+ app.setCached(false);
app.adjType = "has-overlay-ui";
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
@@ -1282,7 +1295,7 @@
// thus out of background check), so we yes the best background level we can.
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
procState = PROCESS_STATE_TRANSIENT_BACKGROUND;
- app.cached = false;
+ app.setCached(false);
app.adjType = "force-imp";
app.adjSource = app.forcingToImportant;
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
@@ -1297,7 +1310,7 @@
// We don't want to kill the current heavy-weight process.
adj = ProcessList.HEAVY_WEIGHT_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
- app.cached = false;
+ app.setCached(false);
app.adjType = "heavy";
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to heavy: " + app);
@@ -1318,7 +1331,7 @@
// home app, so we don't want to let it go into the background.
adj = ProcessList.HOME_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
- app.cached = false;
+ app.setCached(false);
app.adjType = "home";
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to home: " + app);
@@ -1340,7 +1353,7 @@
// a good experience around switching between two apps.
adj = ProcessList.PREVIOUS_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
- app.cached = false;
+ app.setCached(false);
app.adjType = "previous";
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to prev: " + app);
@@ -1387,7 +1400,7 @@
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ, "Raise adj to backup: " + app);
}
- app.cached = false;
+ app.setCached(false);
}
if (procState > ActivityManager.PROCESS_STATE_BACKUP) {
procState = ActivityManager.PROCESS_STATE_BACKUP;
@@ -1435,7 +1448,7 @@
reportOomAdjMessageLocked(TAG_OOM_ADJ,
"Raise adj to started service: " + app);
}
- app.cached = false;
+ app.setCached(false);
}
}
// If we have let the service slide into the background
@@ -1525,7 +1538,7 @@
if (adj > clientAdj) {
adjType = "cch-bound-ui-services";
}
- app.cached = false;
+ app.setCached(false);
clientAdj = adj;
clientProcState = procState;
} else {
@@ -1588,8 +1601,8 @@
newAdj = adj;
}
}
- if (!client.cached) {
- app.cached = false;
+ if (!client.isCached()) {
+ app.setCached(false);
}
if (adj > newAdj) {
adj = newAdj;
@@ -1631,7 +1644,7 @@
// Go at most to BOUND_TOP, unless requested to elevate
// to client's state.
clientProcState = PROCESS_STATE_BOUND_TOP;
- if (client.info.targetSdkVersion >= Build.VERSION_CODES.R) {
+ if (Compatibility.isChangeEnabled(PROCESS_CAPABILITY_CHANGE_ID)) {
if (cr.hasFlag(Context.BIND_INCLUDE_CAPABILITIES)) {
// TOP process passes all capabilities to the service.
capability = PROCESS_CAPABILITY_ALL;
@@ -1713,7 +1726,7 @@
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
}
- app.cached = false;
+ app.setCached(false);
app.adjType = "service";
app.adjTypeCode = ActivityManager.RunningAppProcessInfo
.REASON_SERVICE_IN_USE;
@@ -1778,7 +1791,7 @@
app.setCurRawAdj(adj);
adjType = "provider";
}
- app.cached &= client.cached;
+ app.setCached(app.isCached() & client.isCached());
}
if (clientProcState <= PROCESS_STATE_FOREGROUND_SERVICE) {
@@ -1823,7 +1836,7 @@
adj = ProcessList.FOREGROUND_APP_ADJ;
app.setCurRawAdj(adj);
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
- app.cached = false;
+ app.setCached(false);
app.adjType = "ext-provider";
app.adjTarget = cpr.name;
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
@@ -1847,7 +1860,7 @@
if (adj > ProcessList.PREVIOUS_APP_ADJ) {
adj = ProcessList.PREVIOUS_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
- app.cached = false;
+ app.setCached(false);
app.adjType = "recent-provider";
if (DEBUG_OOM_ADJ_REASON || logUid == appUid) {
reportOomAdjMessageLocked(TAG_OOM_ADJ,
diff --git a/services/core/java/com/android/server/am/ProcessRecord.java b/services/core/java/com/android/server/am/ProcessRecord.java
index 0639db0..156466c 100644
--- a/services/core/java/com/android/server/am/ProcessRecord.java
+++ b/services/core/java/com/android/server/am/ProcessRecord.java
@@ -237,7 +237,7 @@
long lastTopTime; // The last time the process was in the TOP state or greater.
boolean reportLowMemory; // Set to true when waiting to report low mem
boolean empty; // Is this an empty background process?
- boolean cached; // Is this a cached process?
+ private volatile boolean mCached; // Is this a cached process?
String adjType; // Debugging: primary thing impacting oom_adj.
int adjTypeCode; // Debugging: adj code to report to app.
Object adjSource; // Debugging: option dependent object.
@@ -410,7 +410,7 @@
pw.println();
pw.print(prefix); pw.print("procStateMemTracker: ");
procStateMemTracker.dumpLine(pw);
- pw.print(prefix); pw.print("cached="); pw.print(cached);
+ pw.print(prefix); pw.print("cached="); pw.print(mCached);
pw.print(" empty="); pw.println(empty);
if (serviceb) {
pw.print(prefix); pw.print("serviceb="); pw.print(serviceb);
@@ -689,6 +689,18 @@
}
}
+ void setCached(boolean cached) {
+ if (mCached != cached) {
+ mCached = cached;
+ mWindowProcessController.onProcCachedStateChanged(cached);
+ }
+ }
+
+ @Override
+ public boolean isCached() {
+ return mCached;
+ }
+
boolean hasActivities() {
return mWindowProcessController.hasActivities();
}
diff --git a/services/core/java/com/android/server/am/SettingsToPropertiesMapper.java b/services/core/java/com/android/server/am/SettingsToPropertiesMapper.java
index 4a6e63f..0a8e70c 100644
--- a/services/core/java/com/android/server/am/SettingsToPropertiesMapper.java
+++ b/services/core/java/com/android/server/am/SettingsToPropertiesMapper.java
@@ -87,6 +87,7 @@
DeviceConfig.NAMESPACE_RUNTIME_NATIVE,
DeviceConfig.NAMESPACE_RUNTIME_NATIVE_BOOT,
DeviceConfig.NAMESPACE_STORAGE_NATIVE_BOOT,
+ DeviceConfig.NAMESPACE_WINDOW_MANAGER_NATIVE_BOOT,
};
private final String[] mGlobalSettings;
diff --git a/services/core/java/com/android/server/am/UserController.java b/services/core/java/com/android/server/am/UserController.java
index f3a2e70..afc3d91 100644
--- a/services/core/java/com/android/server/am/UserController.java
+++ b/services/core/java/com/android/server/am/UserController.java
@@ -54,6 +54,7 @@
import android.content.Context;
import android.content.IIntentReceiver;
import android.content.Intent;
+import android.content.PermissionChecker;
import android.content.pm.IPackageManager;
import android.content.pm.PackageManager;
import android.content.pm.UserInfo;
@@ -1756,7 +1757,7 @@
// We require full access, sucks to be you.
allow = false;
} else if (canInteractWithAcrossProfilesPermission(
- allowMode, isSameProfileGroup, callingPid, callingUid)) {
+ allowMode, isSameProfileGroup, callingPid, callingUid, callerPackage)) {
allow = true;
} else if (mInjector.checkComponentPermission(INTERACT_ACROSS_USERS, callingPid,
callingUid, -1, true) != PackageManager.PERMISSION_GRANTED) {
@@ -1821,16 +1822,21 @@
}
private boolean canInteractWithAcrossProfilesPermission(
- int allowMode, boolean isSameProfileGroup, int callingPid, int callingUid) {
+ int allowMode, boolean isSameProfileGroup, int callingPid, int callingUid,
+ String callingPackage) {
if (allowMode != ALLOW_ALL_PROFILE_PERMISSIONS_IN_PROFILE) {
return false;
}
if (!isSameProfileGroup) {
return false;
}
- return mInjector.checkComponentPermission(
- INTERACT_ACROSS_PROFILES, callingPid, callingUid, /*owningUid= */-1,
- /*exported= */true) == PackageManager.PERMISSION_GRANTED;
+ return PermissionChecker.PERMISSION_GRANTED
+ == PermissionChecker.checkPermissionForPreflight(
+ mInjector.getContext(),
+ INTERACT_ACROSS_PROFILES,
+ callingPid,
+ callingUid,
+ callingPackage);
}
int unsafeConvertIncomingUser(@UserIdInt int userId) {
diff --git a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
index c518614..bb954ab 100644
--- a/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
+++ b/services/core/java/com/android/server/net/NetworkPolicyManagerService.java
@@ -169,6 +169,7 @@
import android.os.Binder;
import android.os.Environment;
import android.os.Handler;
+import android.os.HandlerExecutor;
import android.os.HandlerThread;
import android.os.IDeviceIdleController;
import android.os.INetworkManagementService;
@@ -882,7 +883,8 @@
// Listen for subscriber changes
mContext.getSystemService(SubscriptionManager.class).addOnSubscriptionsChangedListener(
- new OnSubscriptionsChangedListener(mHandler.getLooper()) {
+ new HandlerExecutor(mHandler),
+ new OnSubscriptionsChangedListener() {
@Override
public void onSubscriptionsChanged() {
updateNetworksInternal();
diff --git a/services/core/java/com/android/server/notification/NotificationHistoryDatabase.java b/services/core/java/com/android/server/notification/NotificationHistoryDatabase.java
index e1ebdf1..e8cb163 100644
--- a/services/core/java/com/android/server/notification/NotificationHistoryDatabase.java
+++ b/services/core/java/com/android/server/notification/NotificationHistoryDatabase.java
@@ -172,7 +172,7 @@
public void addNotification(final HistoricalNotification notification) {
synchronized (mLock) {
- mBuffer.addNotificationToWrite(notification);
+ mBuffer.addNewNotificationToWrite(notification);
// Each time we have new history to write to disk, schedule a write in [interval] ms
if (mBuffer.getHistoryCount() == 1) {
mFileWriteHandler.postDelayed(mWriteBufferRunnable, WRITE_BUFFER_INTERVAL_MS);
diff --git a/services/core/java/com/android/server/notification/NotificationManagerService.java b/services/core/java/com/android/server/notification/NotificationManagerService.java
index 385d84a..d0e4fe6 100755
--- a/services/core/java/com/android/server/notification/NotificationManagerService.java
+++ b/services/core/java/com/android/server/notification/NotificationManagerService.java
@@ -51,6 +51,8 @@
import static android.content.Context.BIND_AUTO_CREATE;
import static android.content.Context.BIND_FOREGROUND_SERVICE;
import static android.content.Context.BIND_NOT_PERCEPTIBLE;
+import static android.content.pm.LauncherApps.ShortcutQuery.FLAG_MATCH_DYNAMIC;
+import static android.content.pm.LauncherApps.ShortcutQuery.FLAG_MATCH_PINNED;
import static android.content.pm.PackageManager.FEATURE_LEANBACK;
import static android.content.pm.PackageManager.FEATURE_TELEVISION;
import static android.content.pm.PackageManager.MATCH_ALL;
@@ -147,10 +149,12 @@
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageManager;
+import android.content.pm.LauncherApps;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.NameNotFoundException;
import android.content.pm.PackageManagerInternal;
import android.content.pm.ParceledListSlice;
+import android.content.pm.ShortcutInfo;
import android.content.pm.UserInfo;
import android.content.res.Resources;
import android.database.ContentObserver;
@@ -279,6 +283,7 @@
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
@@ -399,6 +404,7 @@
private RoleObserver mRoleObserver;
private UserManager mUm;
private IPlatformCompat mPlatformCompat;
+ private LauncherApps mLauncherAppsService;
final IBinder mForegroundToken = new Binder();
private WorkerHandler mHandler;
@@ -844,20 +850,22 @@
private static final class ToastRecord
{
- final int pid;
- final String pkg;
- final ITransientNotification callback;
- int duration;
- int displayId;
- Binder token;
+ public final int pid;
+ public final String pkg;
+ public final IBinder token;
+ public final ITransientNotification callback;
+ public int duration;
+ public int displayId;
+ public Binder windowToken;
- ToastRecord(int pid, String pkg, ITransientNotification callback, int duration,
- Binder token, int displayId) {
+ ToastRecord(int pid, String pkg, IBinder token, ITransientNotification callback,
+ int duration, Binder windowToken, int displayId) {
this.pid = pid;
this.pkg = pkg;
+ this.token = token;
this.callback = callback;
this.duration = duration;
- this.token = token;
+ this.windowToken = windowToken;
this.displayId = displayId;
}
@@ -876,8 +884,10 @@
return "ToastRecord{"
+ Integer.toHexString(System.identityHashCode(this))
+ " pkg=" + pkg
+ + " token=" + token
+ " callback=" + callback
- + " duration=" + duration;
+ + " duration=" + duration
+ + "}";
}
}
@@ -1195,12 +1205,7 @@
final StatusBarNotification n = r.sbn;
final int callingUid = n.getUid();
final String pkg = n.getPackageName();
- if (isBubble && isNotificationAppropriateToBubble(r, pkg, callingUid,
- null /* oldEntry */)) {
- r.getNotification().flags |= FLAG_BUBBLE;
- } else {
- r.getNotification().flags &= ~FLAG_BUBBLE;
- }
+ applyFlagBubble(r, pkg, callingUid, null /* oldEntry */, isBubble);
}
}
}
@@ -1575,6 +1580,80 @@
}
};
+ // Key: packageName Value: <shortcutId, notifId>
+ private HashMap<String, HashMap<String, String>> mActiveShortcutBubbles = new HashMap<>();
+
+ private boolean mLauncherAppsCallbackRegistered;
+
+ // Bubbles can be created based on a shortcut, we need to listen for changes to
+ // that shortcut so that we may update the bubble appropriately.
+ private final LauncherApps.Callback mLauncherAppsCallback = new LauncherApps.Callback() {
+ @Override
+ public void onPackageRemoved(String packageName, UserHandle user) {
+ }
+
+ @Override
+ public void onPackageAdded(String packageName, UserHandle user) {
+ }
+
+ @Override
+ public void onPackageChanged(String packageName, UserHandle user) {
+ }
+
+ @Override
+ public void onPackagesAvailable(String[] packageNames, UserHandle user,
+ boolean replacing) {
+ }
+
+ @Override
+ public void onPackagesUnavailable(String[] packageNames, UserHandle user,
+ boolean replacing) {
+ }
+
+ @Override
+ public void onShortcutsChanged(@NonNull String packageName,
+ @NonNull List<ShortcutInfo> shortcuts, @NonNull UserHandle user) {
+ HashMap<String, String> shortcutBubbles = mActiveShortcutBubbles.get(packageName);
+ boolean isAppForeground = packageName != null
+ && mActivityManager.getPackageImportance(packageName) == IMPORTANCE_FOREGROUND;
+ ArrayList<String> bubbleKeysToRemove = new ArrayList<>();
+ if (shortcutBubbles != null) {
+ // If we can't find one of our bubbles in the shortcut list, that bubble needs
+ // to be removed.
+ for (String shortcutId : shortcutBubbles.keySet()) {
+ boolean foundShortcut = false;
+ for (int i = 0; i < shortcuts.size(); i++) {
+ if (shortcuts.get(i).getId().equals(shortcutId)) {
+ foundShortcut = true;
+ break;
+ }
+ }
+ if (!foundShortcut) {
+ bubbleKeysToRemove.add(shortcutBubbles.get(shortcutId));
+ }
+ }
+ }
+
+ // Do the removals
+ for (int i = 0; i < bubbleKeysToRemove.size(); i++) {
+ // update flag bubble
+ String bubbleKey = bubbleKeysToRemove.get(i);
+ synchronized (mNotificationLock) {
+ NotificationRecord r = mNotificationsByKey.get(bubbleKey);
+ if (r != null) {
+ final StatusBarNotification n = r.sbn;
+ final int callingUid = n.getUid();
+ final String pkg = n.getPackageName();
+ applyFlagBubble(r, pkg, callingUid, null /* oldEntry */, isAppForeground);
+ mHandler.post(new EnqueueNotificationRunnable(user.getIdentifier(), r,
+ false /* isAppForeground */));
+ }
+ }
+ }
+ }
+ };
+
+
private final class SettingsObserver extends ContentObserver {
private final Uri NOTIFICATION_BADGING_URI
= Settings.Secure.getUriFor(Settings.Secure.NOTIFICATION_BADGING);
@@ -1658,6 +1737,11 @@
}
@VisibleForTesting
+ void setLauncherApps(LauncherApps launcherApps) {
+ mLauncherAppsService = launcherApps;
+ }
+
+ @VisibleForTesting
void setHints(int hints) {
mListenerHints = hints;
}
@@ -2151,6 +2235,8 @@
mRoleObserver = new RoleObserver(getContext().getSystemService(RoleManager.class),
mPackageManager, getContext().getMainExecutor());
mRoleObserver.init();
+ mLauncherAppsService =
+ (LauncherApps) getContext().getSystemService(Context.LAUNCHER_APPS_SERVICE);
} else if (phase == SystemService.PHASE_THIRD_PARTY_APPS_CAN_START) {
// This observer will force an update when observe is called, causing us to
// bind to listener services.
@@ -2559,26 +2645,27 @@
// ============================================================================
@Override
- public void enqueueTextToast(String pkg, ITransientNotification callback, int duration,
- int displayId) {
- enqueueToast(pkg, callback, duration, displayId, false);
+ public void enqueueTextToast(String pkg, IBinder token, ITransientNotification callback,
+ int duration, int displayId) {
+ enqueueToast(pkg, token, callback, duration, displayId, false);
}
@Override
- public void enqueueToast(String pkg, ITransientNotification callback, int duration,
- int displayId) {
- enqueueToast(pkg, callback, duration, displayId, true);
+ public void enqueueToast(String pkg, IBinder token, ITransientNotification callback,
+ int duration, int displayId) {
+ enqueueToast(pkg, token, callback, duration, displayId, true);
}
- private void enqueueToast(String pkg, ITransientNotification callback, int duration,
- int displayId, boolean isCustomToast) {
+ private void enqueueToast(String pkg, IBinder token, ITransientNotification callback,
+ int duration, int displayId, boolean isCustomToast) {
if (DBG) {
Slog.i(TAG, "enqueueToast pkg=" + pkg + " callback=" + callback
+ " duration=" + duration + " displayId=" + displayId);
}
- if (pkg == null || callback == null) {
- Slog.e(TAG, "Not enqueuing toast. pkg=" + pkg + " callback=" + callback);
+ if (pkg == null || callback == null || token == null) {
+ Slog.e(TAG, "Not enqueuing toast. pkg=" + pkg + " callback=" + callback + " token="
+ + token);
return ;
}
@@ -2636,7 +2723,7 @@
long callingId = Binder.clearCallingIdentity();
try {
ToastRecord record;
- int index = indexOfToastLocked(pkg, callback);
+ int index = indexOfToastLocked(pkg, token);
// If it's already in the queue, we update it in place, we don't
// move it to the end of the queue.
if (index >= 0) {
@@ -2661,10 +2748,10 @@
}
}
- Binder token = new Binder();
- mWindowManagerInternal.addWindowToken(token, TYPE_TOAST, displayId);
- record = new ToastRecord(callingPid, pkg, callback, duration, token,
- displayId);
+ Binder windowToken = new Binder();
+ mWindowManagerInternal.addWindowToken(windowToken, TYPE_TOAST, displayId);
+ record = new ToastRecord(callingPid, pkg, token, callback, duration,
+ windowToken, displayId);
mToastQueue.add(record);
index = mToastQueue.size() - 1;
keepProcessAliveIfNeededLocked(callingPid);
@@ -2683,23 +2770,23 @@
}
@Override
- public void cancelToast(String pkg, ITransientNotification callback) {
- Slog.i(TAG, "cancelToast pkg=" + pkg + " callback=" + callback);
+ public void cancelToast(String pkg, IBinder token) {
+ Slog.i(TAG, "cancelToast pkg=" + pkg + " token=" + token);
- if (pkg == null || callback == null) {
- Slog.e(TAG, "Not cancelling notification. pkg=" + pkg + " callback=" + callback);
+ if (pkg == null || token == null) {
+ Slog.e(TAG, "Not cancelling notification. pkg=" + pkg + " token=" + token);
return ;
}
synchronized (mToastQueue) {
long callingId = Binder.clearCallingIdentity();
try {
- int index = indexOfToastLocked(pkg, callback);
+ int index = indexOfToastLocked(pkg, token);
if (index >= 0) {
cancelToastLocked(index);
} else {
Slog.w(TAG, "Toast already cancelled. pkg=" + pkg
- + " callback=" + callback);
+ + " token=" + token);
}
} finally {
Binder.restoreCallingIdentity(callingId);
@@ -2708,17 +2795,17 @@
}
@Override
- public void finishToken(String pkg, ITransientNotification callback) {
+ public void finishToken(String pkg, IBinder token) {
synchronized (mToastQueue) {
long callingId = Binder.clearCallingIdentity();
try {
- int index = indexOfToastLocked(pkg, callback);
+ int index = indexOfToastLocked(pkg, token);
if (index >= 0) {
ToastRecord record = mToastQueue.get(index);
- finishTokenLocked(record.token, record.displayId);
+ finishWindowTokenLocked(record.windowToken, record.displayId);
} else {
Slog.w(TAG, "Toast already killed. pkg=" + pkg
- + " callback=" + callback);
+ + " token=" + token);
}
} finally {
Binder.restoreCallingIdentity(callingId);
@@ -5439,19 +5526,18 @@
}
/**
- * Updates the flags for this notification to reflect whether it is a bubble or not.
+ * Updates the flags for this notification to reflect whether it is a bubble or not. Some
+ * bubble specific flags only work if the app is foreground, this will strip those flags
+ * if the app wasn't foreground.
*/
- private void flagNotificationForBubbles(NotificationRecord r, String pkg, int userId,
+ private void updateNotificationBubbleFlags(NotificationRecord r, String pkg, int userId,
NotificationRecord oldRecord, boolean isAppForeground) {
Notification notification = r.getNotification();
- if (isNotificationAppropriateToBubble(r, pkg, userId, oldRecord)) {
- notification.flags |= FLAG_BUBBLE;
- } else {
- notification.flags &= ~FLAG_BUBBLE;
- }
+ applyFlagBubble(r, pkg, userId, oldRecord, true /* desiredFlag */);
+
+ // Remove any bubble specific flags that only work when foregrounded
Notification.BubbleMetadata metadata = notification.getBubbleMetadata();
if (!isAppForeground && metadata != null) {
- // Remove any flags that only work when foregrounded
int flags = metadata.getFlags();
flags &= ~Notification.BubbleMetadata.FLAG_AUTO_EXPAND_BUBBLE;
flags &= ~Notification.BubbleMetadata.FLAG_SUPPRESS_NOTIFICATION;
@@ -5460,6 +5546,54 @@
}
/**
+ * Handles actually applying or removing {@link Notification#FLAG_BUBBLE}. Performs necessary
+ * checks for the provided record to see if it can actually be a bubble.
+ * Tracks shortcut based bubbles so that we can find out if they've changed or been removed.
+ */
+ private void applyFlagBubble(NotificationRecord r, String pkg, int userId,
+ NotificationRecord oldRecord, boolean desiredFlag) {
+ boolean applyFlag = desiredFlag
+ && isNotificationAppropriateToBubble(r, pkg, userId, oldRecord);
+ final String shortcutId = r.getNotification().getBubbleMetadata() != null
+ ? r.getNotification().getBubbleMetadata().getShortcutId()
+ : null;
+ if (applyFlag) {
+ if (shortcutId != null) {
+ // Must track shortcut based bubbles in case the shortcut is removed
+ HashMap<String, String> packageBubbles = mActiveShortcutBubbles.get(
+ r.sbn.getPackageName());
+ if (packageBubbles == null) {
+ packageBubbles = new HashMap<>();
+ }
+ packageBubbles.put(shortcutId, r.getKey());
+ mActiveShortcutBubbles.put(r.sbn.getPackageName(), packageBubbles);
+ if (!mLauncherAppsCallbackRegistered) {
+ mLauncherAppsService.registerCallback(mLauncherAppsCallback, mHandler);
+ mLauncherAppsCallbackRegistered = true;
+ }
+ }
+ r.getNotification().flags |= FLAG_BUBBLE;
+ } else {
+ if (shortcutId != null) {
+ // No longer track shortcut
+ HashMap<String, String> packageBubbles = mActiveShortcutBubbles.get(
+ r.sbn.getPackageName());
+ if (packageBubbles != null) {
+ packageBubbles.remove(shortcutId);
+ }
+ if (packageBubbles != null && packageBubbles.isEmpty()) {
+ mActiveShortcutBubbles.remove(r.sbn.getPackageName());
+ }
+ if (mLauncherAppsCallbackRegistered && mActiveShortcutBubbles.isEmpty()) {
+ mLauncherAppsService.unregisterCallback(mLauncherAppsCallback);
+ mLauncherAppsCallbackRegistered = false;
+ }
+ }
+ r.getNotification().flags &= ~FLAG_BUBBLE;
+ }
+ }
+
+ /**
* @return whether the provided notification record is allowed to be represented as a bubble,
* accounting for user choice & policy.
*/
@@ -5533,10 +5667,6 @@
// no log: no need to inform dev if they didn't attach bubble metadata
return false;
}
- if (!canLaunchInActivityView(getContext(), metadata.getIntent(), pkg)) {
- // no log: method has the failure log
- return false;
- }
if (!mPreferencesHelper.bubblesEnabled()) {
logBubbleError(r.getKey(), "bubbles disabled for user: " + userId);
return false;
@@ -5551,7 +5681,20 @@
"bubbles for channel " + r.getChannel().getId() + " disabled");
return false;
}
- return true;
+
+ String shortcutId = metadata.getShortcutId();
+ boolean shortcutValid = shortcutId != null
+ && hasValidShortcutInfo(shortcutId, pkg, r.getUser());
+ if (metadata.getBubbleIntent() == null && !shortcutValid) {
+ // Should have a shortcut if intent is null
+ logBubbleError(r.getKey(), "couldn't find shortcutId for bubble: " + shortcutId);
+ return false;
+ }
+ if (shortcutValid) {
+ return true;
+ }
+ // no log: canLaunch method has the failure log
+ return canLaunchInActivityView(getContext(), metadata.getBubbleIntent(), pkg);
}
private boolean hasValidRemoteInput(Notification n) {
@@ -5570,6 +5713,22 @@
return false;
}
+ private boolean hasValidShortcutInfo(String shortcutId, String packageName, UserHandle user) {
+ LauncherApps.ShortcutQuery query = new LauncherApps.ShortcutQuery();
+ if (packageName != null) {
+ query.setPackage(packageName);
+ }
+ if (shortcutId != null) {
+ query.setShortcutIds(Arrays.asList(shortcutId));
+ }
+ query.setQueryFlags(FLAG_MATCH_DYNAMIC | FLAG_MATCH_PINNED);
+ List<ShortcutInfo> shortcuts = mLauncherAppsService.getShortcuts(query, user);
+ ShortcutInfo shortcutInfo = shortcuts != null && shortcuts.size() > 0
+ ? shortcuts.get(0)
+ : null;
+ return shortcutInfo != null;
+ }
+
private void logBubbleError(String key, String failureMessage) {
if (DBG) {
Log.w(TAG, "Bubble notification: " + key + " failed: " + failureMessage);
@@ -6025,7 +6184,7 @@
final String tag = n.getTag();
// We need to fix the notification up a little for bubbles
- flagNotificationForBubbles(r, pkg, callingUid, old, isAppForeground);
+ updateNotificationBubbleFlags(r, pkg, callingUid, old, isAppForeground);
// Handle grouped notifications and bail out early if we
// can to avoid extracting signals.
@@ -6757,7 +6916,7 @@
while (record != null) {
if (DBG) Slog.d(TAG, "Show pkg=" + record.pkg + " callback=" + record.callback);
try {
- record.callback.show(record.token);
+ record.callback.show(record.windowToken);
scheduleDurationReachedLocked(record);
return;
} catch (RemoteException e) {
@@ -6792,7 +6951,7 @@
ToastRecord lastToast = mToastQueue.remove(index);
- mWindowManagerInternal.removeWindowToken(lastToast.token, false /* removeWindows */,
+ mWindowManagerInternal.removeWindowToken(lastToast.windowToken, false /* removeWindows */,
lastToast.displayId);
// We passed 'false' for 'removeWindows' so that the client has time to stop
// rendering (as hide above is a one-way message), otherwise we could crash
@@ -6810,7 +6969,7 @@
}
}
- void finishTokenLocked(IBinder t, int displayId) {
+ void finishWindowTokenLocked(IBinder t, int displayId) {
mHandler.removeCallbacksAndMessages(t);
// We pass 'true' for 'removeWindows' to let the WindowManager destroy any
// remaining surfaces as either the client has called finishToken indicating
@@ -6835,9 +6994,9 @@
private void handleDurationReached(ToastRecord record)
{
- if (DBG) Slog.d(TAG, "Timeout pkg=" + record.pkg + " callback=" + record.callback);
+ if (DBG) Slog.d(TAG, "Timeout pkg=" + record.pkg + " token=" + record.token);
synchronized (mToastQueue) {
- int index = indexOfToastLocked(record.pkg, record.callback);
+ int index = indexOfToastLocked(record.pkg, record.token);
if (index >= 0) {
cancelToastLocked(index);
}
@@ -6854,21 +7013,19 @@
private void handleKillTokenTimeout(ToastRecord record)
{
- if (DBG) Slog.d(TAG, "Kill Token Timeout token=" + record.token);
+ if (DBG) Slog.d(TAG, "Kill Token Timeout token=" + record.windowToken);
synchronized (mToastQueue) {
- finishTokenLocked(record.token, record.displayId);
+ finishWindowTokenLocked(record.windowToken, record.displayId);
}
}
@GuardedBy("mToastQueue")
- int indexOfToastLocked(String pkg, ITransientNotification callback)
- {
- IBinder cbak = callback.asBinder();
+ int indexOfToastLocked(String pkg, IBinder token) {
ArrayList<ToastRecord> list = mToastQueue;
int len = list.size();
for (int i=0; i<len; i++) {
ToastRecord r = list.get(i);
- if (r.pkg.equals(pkg) && r.callback.asBinder() == cbak) {
+ if (r.pkg.equals(pkg) && r.token == token) {
return i;
}
}
diff --git a/services/core/java/com/android/server/notification/NotificationRecord.java b/services/core/java/com/android/server/notification/NotificationRecord.java
index c8afcc9..f344a84 100644
--- a/services/core/java/com/android/server/notification/NotificationRecord.java
+++ b/services/core/java/com/android/server/notification/NotificationRecord.java
@@ -466,6 +466,7 @@
pw.println(prefix + "deleteIntent=" + notification.deleteIntent);
pw.println(prefix + "number=" + notification.number);
pw.println(prefix + "groupAlertBehavior=" + notification.getGroupAlertBehavior());
+ pw.println(prefix + "when=" + notification.when);
pw.print(prefix + "tickerText=");
if (!TextUtils.isEmpty(notification.tickerText)) {
diff --git a/services/core/java/com/android/server/pm/CrossProfileAppsServiceImpl.java b/services/core/java/com/android/server/pm/CrossProfileAppsServiceImpl.java
index bdc1b07..3635004 100644
--- a/services/core/java/com/android/server/pm/CrossProfileAppsServiceImpl.java
+++ b/services/core/java/com/android/server/pm/CrossProfileAppsServiceImpl.java
@@ -35,6 +35,7 @@
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
+import android.content.PermissionChecker;
import android.content.pm.ActivityInfo;
import android.content.pm.ICrossProfileApps;
import android.content.pm.IPackageManager;
@@ -114,6 +115,7 @@
final int callerUserId = mInjector.getCallingUserId();
final int callingUid = mInjector.getCallingUid();
+ final int callingPid = mInjector.getCallingPid();
List<UserHandle> allowedTargetUsers = getTargetUserProfilesUnchecked(
callingPackage, callerUserId);
@@ -143,10 +145,13 @@
// must have the required permission and the users must be in the same profile group
// in order to launch any of its own activities.
if (callerUserId != userId) {
- final int permissionFlag = mInjector.checkComponentPermission(
- android.Manifest.permission.INTERACT_ACROSS_PROFILES, callingUid,
- -1, true);
- if (permissionFlag != PackageManager.PERMISSION_GRANTED
+ final int permissionFlag = PermissionChecker.checkPermissionForPreflight(
+ mContext,
+ android.Manifest.permission.INTERACT_ACROSS_PROFILES,
+ callingPid,
+ callingUid,
+ callingPackage);
+ if (permissionFlag != PermissionChecker.PERMISSION_GRANTED
|| !isSameProfileGroup(callerUserId, userId)) {
throw new SecurityException("Attempt to launch activity without required "
+ android.Manifest.permission.INTERACT_ACROSS_PROFILES + " permission"
@@ -210,12 +215,15 @@
return false;
}
final int callingUid = mInjector.getCallingUid();
+ final int callingPid = mInjector.getCallingPid();
return isPermissionGranted(Manifest.permission.INTERACT_ACROSS_USERS_FULL, callingUid)
|| isPermissionGranted(Manifest.permission.INTERACT_ACROSS_USERS, callingUid)
- || isPermissionGranted(Manifest.permission.INTERACT_ACROSS_PROFILES, callingUid)
- || AppOpsManager.MODE_ALLOWED == getAppOpsService().noteOperation(
- OP_INTERACT_ACROSS_PROFILES, callingUid, callingPackage, /* featureId= */ null,
- /*shouldCollectAsyncNotedOp= */false, /*message= */null);
+ || PermissionChecker.checkPermissionForPreflight(
+ mContext,
+ Manifest.permission.INTERACT_ACROSS_PROFILES,
+ callingPid,
+ callingUid,
+ callingPackage) == PermissionChecker.PERMISSION_GRANTED;
}
private boolean isCrossProfilePackageWhitelisted(String packageName) {
@@ -436,6 +444,10 @@
return Binder.getCallingUid();
}
+ public int getCallingPid() {
+ return Binder.getCallingPid();
+ }
+
public int getCallingUserId() {
return UserHandle.getCallingUserId();
}
@@ -504,6 +516,8 @@
public interface Injector {
int getCallingUid();
+ int getCallingPid();
+
int getCallingUserId();
UserHandle getCallingUserHandle();
diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java
index d0f91c2..07aec4a 100644
--- a/services/core/java/com/android/server/pm/PackageManagerService.java
+++ b/services/core/java/com/android/server/pm/PackageManagerService.java
@@ -124,6 +124,7 @@
import android.annotation.Nullable;
import android.annotation.UserIdInt;
import android.app.ActivityManager;
+import android.app.ApplicationPackageManager;
import android.app.AppOpsManager;
import android.app.BroadcastOptions;
import android.app.IActivityManager;
@@ -2721,6 +2722,7 @@
t.traceBegin("get system config");
SystemConfig systemConfig = SystemConfig.getInstance();
mAvailableFeatures = systemConfig.getAvailableFeatures();
+ ApplicationPackageManager.invalidateSysFeatureCache();
t.traceEnd();
mProtectedPackages = new ProtectedPackages(mContext);
diff --git a/services/core/java/com/android/server/pm/permission/PermissionManagerService.java b/services/core/java/com/android/server/pm/permission/PermissionManagerService.java
index 0411e29..6167a50 100644
--- a/services/core/java/com/android/server/pm/permission/PermissionManagerService.java
+++ b/services/core/java/com/android/server/pm/permission/PermissionManagerService.java
@@ -58,6 +58,7 @@
import android.compat.annotation.ChangeId;
import android.compat.annotation.EnabledAfter;
import android.content.Context;
+import android.content.PermissionChecker;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManager.PermissionGroupInfoFlags;
@@ -4070,8 +4071,13 @@
return;
}
final boolean isSameProfileGroup = isSameProfileGroup(callingUserId, userId);
- if (isSameProfileGroup
- && hasPermission(android.Manifest.permission.INTERACT_ACROSS_PROFILES)) {
+ if (isSameProfileGroup && PermissionChecker.checkPermissionForPreflight(
+ mContext,
+ android.Manifest.permission.INTERACT_ACROSS_PROFILES,
+ PermissionChecker.PID_UNKNOWN,
+ callingUid,
+ mPackageManagerInt.getPackage(callingUid).getPackageName())
+ == PermissionChecker.PERMISSION_GRANTED) {
return;
}
String errorMessage = buildInvalidCrossUserOrProfilePermissionMessage(
@@ -4349,7 +4355,8 @@
@Override
public void enforceCrossUserOrProfilePermission(int callingUid, int userId,
boolean requireFullPermission, boolean checkShell, String message) {
- PermissionManagerService.this.enforceCrossUserOrProfilePermission(callingUid,
+ PermissionManagerService.this.enforceCrossUserOrProfilePermission(
+ callingUid,
userId,
requireFullPermission,
checkShell,
diff --git a/services/core/java/com/android/server/recoverysystem/RecoverySystemService.java b/services/core/java/com/android/server/recoverysystem/RecoverySystemService.java
index c36d5ef..7164a30 100644
--- a/services/core/java/com/android/server/recoverysystem/RecoverySystemService.java
+++ b/services/core/java/com/android/server/recoverysystem/RecoverySystemService.java
@@ -24,8 +24,11 @@
import android.os.IRecoverySystem;
import android.os.IRecoverySystemProgressListener;
import android.os.PowerManager;
+import android.os.Process;
import android.os.RecoverySystem;
import android.os.RemoteException;
+import android.os.ResultReceiver;
+import android.os.ShellCallback;
import android.os.SystemProperties;
import android.util.Slog;
@@ -39,6 +42,7 @@
import java.io.DataInputStream;
import java.io.DataOutputStream;
+import java.io.FileDescriptor;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
@@ -550,4 +554,28 @@
IoUtils.closeQuietly(mLocalSocket);
}
}
+
+ private boolean isCallerShell() {
+ final int callingUid = Binder.getCallingUid();
+ return callingUid == Process.SHELL_UID || callingUid == Process.ROOT_UID;
+ }
+
+ private void enforceShell() {
+ if (!isCallerShell()) {
+ throw new SecurityException("Caller must be shell");
+ }
+ }
+
+ @Override
+ public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
+ String[] args, ShellCallback callback, ResultReceiver resultReceiver) {
+ enforceShell();
+ final long origId = Binder.clearCallingIdentity();
+ try {
+ new RecoverySystemShellCommand(this).exec(
+ this, in, out, err, args, callback, resultReceiver);
+ } finally {
+ Binder.restoreCallingIdentity(origId);
+ }
+ }
}
diff --git a/services/core/java/com/android/server/recoverysystem/RecoverySystemShellCommand.java b/services/core/java/com/android/server/recoverysystem/RecoverySystemShellCommand.java
new file mode 100644
index 0000000..c6905b5
--- /dev/null
+++ b/services/core/java/com/android/server/recoverysystem/RecoverySystemShellCommand.java
@@ -0,0 +1,90 @@
+/*
+ * 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.server.recoverysystem;
+
+import android.os.IRecoverySystem;
+import android.os.RemoteException;
+import android.os.ShellCommand;
+
+import java.io.PrintWriter;
+
+/**
+ * Shell commands to call to {@link RecoverySystemService} from ADB.
+ */
+public class RecoverySystemShellCommand extends ShellCommand {
+ private final IRecoverySystem mService;
+
+ public RecoverySystemShellCommand(RecoverySystemService service) {
+ mService = service;
+ }
+
+ @Override
+ public int onCommand(String cmd) {
+ if (cmd == null) {
+ return handleDefaultCommands(cmd);
+ }
+ try {
+ switch (cmd) {
+ case "request-lskf":
+ return requestLskf();
+ case "clear-lskf":
+ return clearLskf();
+ case "reboot-and-apply":
+ return rebootAndApply();
+ default:
+ return handleDefaultCommands(cmd);
+ }
+ } catch (Exception e) {
+ getErrPrintWriter().println("Error while executing command: " + cmd);
+ e.printStackTrace(getErrPrintWriter());
+ return -1;
+ }
+ }
+
+ private int requestLskf() throws RemoteException {
+ String updateToken = getNextArgRequired();
+ boolean success = mService.requestLskf(updateToken, null);
+ PrintWriter pw = getOutPrintWriter();
+ pw.println("Request LSKF status: " + (success ? "success" : "failure"));
+ return 0;
+ }
+
+ private int clearLskf() throws RemoteException {
+ boolean success = mService.clearLskf();
+ PrintWriter pw = getOutPrintWriter();
+ pw.println("Clear LSKF: " + (success ? "success" : "failure"));
+ return 0;
+ }
+
+ private int rebootAndApply() throws RemoteException {
+ String updateToken = getNextArgRequired();
+ String rebootReason = getNextArgRequired();
+ boolean success = mService.rebootWithLskf(updateToken, rebootReason);
+ PrintWriter pw = getOutPrintWriter();
+ pw.println("Reboot and apply status: " + (success ? "success" : "failure"));
+ return 0;
+ }
+
+ @Override
+ public void onHelp() {
+ PrintWriter pw = getOutPrintWriter();
+ pw.println("Recovery system commands:");
+ pw.println(" request-lskf <token>");
+ pw.println(" clear-lskf");
+ pw.println(" reboot-and-apply <token> <reason>");
+ }
+}
diff --git a/services/core/java/com/android/server/stats/pull/StatsPullAtomService.java b/services/core/java/com/android/server/stats/pull/StatsPullAtomService.java
index b11ec6f..3c41c10 100644
--- a/services/core/java/com/android/server/stats/pull/StatsPullAtomService.java
+++ b/services/core/java/com/android/server/stats/pull/StatsPullAtomService.java
@@ -196,16 +196,23 @@
private final Object mNetworkStatsLock = new Object();
@GuardedBy("mNetworkStatsLock")
private INetworkStatsService mNetworkStatsService;
+
private final Object mThermalLock = new Object();
@GuardedBy("mThermalLock")
private IThermalService mThermalService;
+
private final Object mStoragedLock = new Object();
@GuardedBy("mStoragedLock")
private IStoraged mStorageService;
+
private final Object mNotificationStatsLock = new Object();
@GuardedBy("mNotificationStatsLock")
private INotificationManager mNotificationManagerService;
+ private final Object mProcessStatsLock = new Object();
+ @GuardedBy("mProcessStatsLock")
+ private IProcessStats mProcessStatsService;
+
private final Context mContext;
private StatsManager mStatsManager;
private StorageManager mStorageManager;
@@ -222,7 +229,7 @@
mTelephony = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
mStorageManager = (StorageManager) mContext.getSystemService(StorageManager.class);
- // Used to initialize the CPU Frequency atom.
+ // Initialize state for CPU_TIME_PER_FREQ atom
PowerProfile powerProfile = new PowerProfile(mContext);
final int numClusters = powerProfile.getNumCpuClusters();
mKernelCpuSpeedReaders = new KernelCpuSpeedReader[numClusters];
@@ -237,6 +244,9 @@
// Used for CPU_TIME_PER_THREAD_FREQ
mKernelCpuThreadReader =
KernelCpuThreadReaderSettingsObserver.getSettingsModifiedReader(mContext);
+
+ // Used by PROC_STATS and PROC_STATS_PKG_PROC atoms
+ mBaseDir.mkdirs();
}
@Override
@@ -385,7 +395,7 @@
synchronized (mNotificationStatsLock) {
if (mNotificationManagerService == null) {
mNotificationManagerService = INotificationManager.Stub.asInterface(
- ServiceManager.getService(Context.NOTIFICATION_SERVICE));
+ ServiceManager.getService(Context.NOTIFICATION_SERVICE));
}
if (mNotificationManagerService != null) {
try {
@@ -403,6 +413,28 @@
return mNotificationManagerService;
}
+ private IProcessStats getIProcessStatsService() {
+ synchronized (mProcessStatsLock) {
+ if (mProcessStatsService == null) {
+ mProcessStatsService = IProcessStats.Stub.asInterface(
+ ServiceManager.getService(ProcessStats.SERVICE_NAME));
+ }
+ if (mProcessStatsService != null) {
+ try {
+ mProcessStatsService.asBinder().linkToDeath(() -> {
+ synchronized (mProcessStatsLock) {
+ mProcessStatsService = null;
+ }
+ }, /* flags */ 0);
+ } catch (RemoteException e) {
+ Slog.e(TAG, "linkToDeath with ProcessStats failed", e);
+ mProcessStatsService = null;
+ }
+ }
+ }
+ return mProcessStatsService;
+ }
+
private void registerWifiBytesTransfer() {
int tagId = StatsLog.WIFI_BYTES_TRANSFER;
PullAtomMetadata metadata = new PullAtomMetadata.Builder()
@@ -1868,22 +1900,88 @@
return StatsManager.PULL_SUCCESS;
}
- private void registerProcStats() {
- // No op.
- }
+ private File mBaseDir = new File(SystemServiceManager.ensureSystemDir(), "stats_companion");
- private void pullProcStats() {
- // No op.
+ private void registerProcStats() {
+ int tagId = StatsLog.PROC_STATS;
+ mStatsManager.registerPullAtomCallback(
+ tagId,
+ null, // use default PullAtomMetadata values
+ (atomTag, data) -> pullProcStats(ProcessStats.REPORT_ALL, atomTag, data),
+ BackgroundThread.getExecutor()
+ );
}
private void registerProcStatsPkgProc() {
- // No op.
+ int tagId = StatsLog.PROC_STATS_PKG_PROC;
+ mStatsManager.registerPullAtomCallback(
+ tagId,
+ null, // use default PullAtomMetadata values
+ (atomTag, data) -> pullProcStats(ProcessStats.REPORT_PKG_PROC_STATS, atomTag, data),
+ BackgroundThread.getExecutor()
+ );
}
- private void pullProcStatsPkgProc() {
- // No op.
+ private int pullProcStats(int section, int atomTag, List<StatsEvent> pulledData) {
+ IProcessStats processStatsService = getIProcessStatsService();
+ if (processStatsService == null) {
+ return StatsManager.PULL_SKIP;
+ }
+
+ synchronized (mProcessStatsLock) {
+ final long token = Binder.clearCallingIdentity();
+ try {
+ long lastHighWaterMark = readProcStatsHighWaterMark(section);
+ List<ParcelFileDescriptor> statsFiles = new ArrayList<>();
+ long highWaterMark = processStatsService.getCommittedStats(
+ lastHighWaterMark, section, true, statsFiles);
+ if (statsFiles.size() != 1) {
+ return StatsManager.PULL_SKIP;
+ }
+ unpackStreamedData(atomTag, pulledData, statsFiles);
+ new File(mBaseDir.getAbsolutePath() + "/" + section + "_" + lastHighWaterMark)
+ .delete();
+ new File(mBaseDir.getAbsolutePath() + "/" + section + "_" + highWaterMark)
+ .createNewFile();
+ } catch (IOException e) {
+ Slog.e(TAG, "Getting procstats failed: ", e);
+ return StatsManager.PULL_SKIP;
+ } catch (RemoteException e) {
+ Slog.e(TAG, "Getting procstats failed: ", e);
+ return StatsManager.PULL_SKIP;
+ } catch (SecurityException e) {
+ Slog.e(TAG, "Getting procstats failed: ", e);
+ return StatsManager.PULL_SKIP;
+ } finally {
+ Binder.restoreCallingIdentity(token);
+ }
+ }
+
+ return StatsManager.PULL_SUCCESS;
}
+ // read high watermark for section
+ private long readProcStatsHighWaterMark(int section) {
+ try {
+ File[] files = mBaseDir.listFiles((d, name) -> {
+ return name.toLowerCase().startsWith(String.valueOf(section) + '_');
+ });
+ if (files == null || files.length == 0) {
+ return 0;
+ }
+ if (files.length > 1) {
+ Slog.e(TAG, "Only 1 file expected for high water mark. Found " + files.length);
+ }
+ return Long.valueOf(files[0].getName().split("_")[1]);
+ } catch (SecurityException e) {
+ Slog.e(TAG, "Failed to get procstats high watermark file.", e);
+ } catch (NumberFormatException e) {
+ Slog.e(TAG, "Failed to parse file name.", e);
+ }
+ return 0;
+ }
+
+
private StoragedUidIoStatsReader mStoragedUidIoStatsReader =
new StoragedUidIoStatsReader();
@@ -1953,7 +2051,7 @@
private void registerProcessCpuTime() {
int tagId = StatsLog.PROCESS_CPU_TIME;
- // Min cool-down is 5 sec, inline with what ActivityManagerService uses.
+ // Min cool-down is 5 sec, in line with what ActivityManagerService uses.
PullAtomMetadata metadata = PullAtomMetadata.newBuilder()
.setCoolDownNs(5 * NS_PER_SEC)
.build();
@@ -2497,11 +2595,57 @@
}
private void registerFaceSettings() {
- // No op.
+ int tagId = StatsLog.FACE_SETTINGS;
+ mStatsManager.registerPullAtomCallback(
+ tagId,
+ null, // use default PullAtomMetadata values
+ (atomTag, data) -> pullFaceSettings(atomTag, data),
+ BackgroundThread.getExecutor()
+ );
}
- private void pullRegisterFaceSettings() {
- // No op.
+ private int pullFaceSettings(int atomTag, List<StatsEvent> pulledData) {
+ final long callingToken = Binder.clearCallingIdentity();
+ try {
+ List<UserInfo> users = mContext.getSystemService(UserManager.class).getUsers();
+ int numUsers = users.size();
+ for (int userNum = 0; userNum < numUsers; userNum++) {
+ int userId = users.get(userNum).getUserHandle().getIdentifier();
+
+ int unlockKeyguardEnabled = Settings.Secure.getIntForUser(
+ mContext.getContentResolver(),
+ Settings.Secure.FACE_UNLOCK_KEYGUARD_ENABLED, 1, userId);
+ int unlockDismissesKeyguard = Settings.Secure.getIntForUser(
+ mContext.getContentResolver(),
+ Settings.Secure.FACE_UNLOCK_DISMISSES_KEYGUARD, 0, userId);
+ int unlockAttentionRequired = Settings.Secure.getIntForUser(
+ mContext.getContentResolver(),
+ Settings.Secure.FACE_UNLOCK_ATTENTION_REQUIRED, 1, userId);
+ int unlockAppEnabled = Settings.Secure.getIntForUser(
+ mContext.getContentResolver(),
+ Settings.Secure.FACE_UNLOCK_APP_ENABLED, 1, userId);
+ int unlockAlwaysRequireConfirmation = Settings.Secure.getIntForUser(
+ mContext.getContentResolver(),
+ Settings.Secure.FACE_UNLOCK_ALWAYS_REQUIRE_CONFIRMATION, 0, userId);
+ int unlockDiversityRequired = Settings.Secure.getIntForUser(
+ mContext.getContentResolver(),
+ Settings.Secure.FACE_UNLOCK_DIVERSITY_REQUIRED, 1, userId);
+
+ StatsEvent e = StatsEvent.newBuilder()
+ .setAtomId(atomTag)
+ .writeBoolean(unlockKeyguardEnabled != 0)
+ .writeBoolean(unlockDismissesKeyguard != 0)
+ .writeBoolean(unlockAttentionRequired != 0)
+ .writeBoolean(unlockAppEnabled != 0)
+ .writeBoolean(unlockAlwaysRequireConfirmation != 0)
+ .writeBoolean(unlockDiversityRequired != 0)
+ .build();
+ pulledData.add(e);
+ }
+ } finally {
+ Binder.restoreCallingIdentity(callingToken);
+ }
+ return StatsManager.PULL_SUCCESS;
}
private void registerAppOps() {
@@ -2516,7 +2660,7 @@
}
private int pullAppOps(int atomTag, List<StatsEvent> pulledData) {
- long token = Binder.clearCallingIdentity();
+ final long token = Binder.clearCallingIdentity();
try {
AppOpsManager appOps = mContext.getSystemService(AppOpsManager.class);
@@ -2632,7 +2776,7 @@
}
final long callingToken = Binder.clearCallingIdentity();
try {
- // determine last pull tine. Copy file trick from pullProcessStats?
+ // determine last pull tine. Copy file trick from pullProcStats?
long wallClockNanos = SystemClock.currentTimeMicro() * 1000L;
long lastNotificationStatsNs = wallClockNanos -
TimeUnit.NANOSECONDS.convert(1, TimeUnit.DAYS);
diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java
index 0e13e6c..d1c8448 100644
--- a/services/core/java/com/android/server/wm/ActivityRecord.java
+++ b/services/core/java/com/android/server/wm/ActivityRecord.java
@@ -31,7 +31,6 @@
import static android.app.ActivityOptions.ANIM_THUMBNAIL_SCALE_DOWN;
import static android.app.ActivityOptions.ANIM_THUMBNAIL_SCALE_UP;
import static android.app.ActivityOptions.ANIM_UNDEFINED;
-import static android.app.ActivityTaskManager.INVALID_STACK_ID;
import static android.app.ActivityTaskManager.INVALID_TASK_ID;
import static android.app.AppOpsManager.MODE_ALLOWED;
import static android.app.AppOpsManager.OP_PICTURE_IN_PICTURE;
@@ -1426,7 +1425,7 @@
return null;
}
ActivityRecord r = token.weakActivity.get();
- if (r == null || r.getActivityStack() == null) {
+ if (r == null || r.getRootTask() == null) {
return null;
}
return r;
@@ -2055,19 +2054,17 @@
}
}
- /**
- * @return Stack value from current task, null if there is no task.
- */
- ActivityStack getActivityStack() {
- return task != null ? task.getStack() : null;
+ /** @return Root task of this activity, null if there is no task. */
+ ActivityStack getRootTask() {
+ return task != null ? (ActivityStack) task.getRootTask() : null;
}
- int getStackId() {
- return getActivityStack() != null ? getActivityStack().mStackId : INVALID_STACK_ID;
+ int getRootTaskId() {
+ return task != null ? task.getRootTaskId() : INVALID_TASK_ID;
}
DisplayContent getDisplay() {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
return stack != null ? stack.getDisplay() : null;
}
@@ -2088,7 +2085,7 @@
mWmService.mWindowPlacerLocked.requestTraversal();
if (changed && task != null && !occludesParent) {
- getActivityStack().convertActivityToTranslucent(this);
+ getRootTask().convertActivityToTranslucent(this);
}
// Always ensure visibility if this activity doesn't occlude parent, so the
// {@link #returningOptions} of the activity under this one can be applied in
@@ -2123,7 +2120,7 @@
}
boolean isInStackLocked() {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
return stack != null && stack.isInStackLocked(this) != null;
}
@@ -2226,7 +2223,7 @@
boolean isCurrentAppLocked =
mAtmService.getLockTaskModeState() != LOCK_TASK_MODE_NONE;
final DisplayContent display = getDisplay();
- boolean hasPinnedStack = display != null && display.hasPinnedStack();
+ boolean hasPinnedStack = display != null && display.hasPinnedTask();
// Don't return early if !isNotLocked, since we want to throw an exception if the activity
// is in an incorrect state
boolean isNotLockedOrOnKeyguard = !isKeyguardLocked && !isCurrentAppLocked;
@@ -2325,7 +2322,7 @@
return false;
}
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (stack == null) {
Slog.w(TAG, "moveActivityStackToFront: invalid task or stack: activity="
+ this + " task=" + task);
@@ -2456,7 +2453,7 @@
return FINISH_RESULT_CANCELLED;
}
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
final boolean mayAdjustTop = (isState(RESUMED) || stack.mResumedActivity == null)
&& stack.isFocusedStackOnDisplay();
final boolean shouldAdjustGlobalFocus = mayAdjustTop
@@ -2497,7 +2494,7 @@
final DisplayContent display = stack.getDisplay();
next = display.topRunningActivity();
if (next != null) {
- display.positionStackAtTop(next.getActivityStack(),
+ display.positionStackAtTop(next.getRootTask(),
false /* includingParents */, "finish-display-top");
}
}
@@ -2666,13 +2663,13 @@
mStackSupervisor.mStoppingActivities.remove(this);
mStackSupervisor.mGoingToSleepActivities.remove(this);
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
final DisplayContent display = getDisplay();
// TODO(b/137329632): Exclude current activity when looking for the next one with
// DisplayContent#topRunningActivity().
final ActivityRecord next = display.topRunningActivity();
final boolean isLastStackOverEmptyHome =
- next == null && stack.isFocusedStackOnDisplay() && display.getHomeStack() != null;
+ next == null && stack.isFocusedStackOnDisplay() && display.getRootHomeTask() != null;
if (isLastStackOverEmptyHome) {
// Don't destroy activity immediately if this is the last activity on the display and
// the display contains home stack. Although there is no next activity at the moment,
@@ -2824,7 +2821,7 @@
boolean safelyDestroy(String reason) {
if (isDestroyable()) {
if (DEBUG_SWITCH) {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
Slog.v(TAG_SWITCH, "Safely destroying " + this + " in state " + getState()
+ " resumed=" + stack.mResumedActivity
+ " pausing=" + stack.mPausingActivity
@@ -3612,7 +3609,7 @@
}
final boolean isSleeping() {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
return stack != null ? stack.shouldSleepActivities() : mAtmService.isSleepingLocked();
}
@@ -3827,7 +3824,7 @@
// Notify the pinned stack upon all windows drawn. If there was an animation in
// progress then this signal will resume that animation.
- final ActivityStack pinnedStack = mDisplayContent.getPinnedStack();
+ final ActivityStack pinnedStack = mDisplayContent.getRootPinnedTask();
if (pinnedStack != null) {
pinnedStack.onAllWindowsDrawn();
}
@@ -4449,7 +4446,7 @@
return visibleIgnoringKeyguard;
}
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (stack == null) {
return false;
}
@@ -4471,7 +4468,7 @@
}
boolean shouldBeVisible() {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (stack == null) {
return false;
}
@@ -4492,7 +4489,7 @@
// If this activity is paused, tell it to now show its window.
if (DEBUG_VISIBILITY) Slog.v(TAG_VISIBILITY,
"Making visible and scheduling visibility: " + this);
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
try {
if (stack.mTranslucentActivityWaiting != null) {
updateOptionsLocked(returningOptions);
@@ -4578,7 +4575,7 @@
if (DEBUG_VISIBILITY) {
Slog.v(TAG_VISIBILITY, "Resume visible activity, " + this);
}
- return getActivityStack().resumeTopActivityUncheckedLocked(activeActivity /* prev */,
+ return getRootTask().resumeTopActivityUncheckedLocked(activeActivity /* prev */,
null /* options */);
} else if (shouldPauseActivity(activeActivity)) {
if (DEBUG_VISIBILITY) {
@@ -4643,7 +4640,7 @@
*/
private boolean shouldBeResumed(ActivityRecord activeActivity) {
return shouldMakeActive(activeActivity) && isFocusable()
- && getActivityStack().getVisibility(activeActivity) == STACK_VISIBILITY_VISIBLE
+ && getRootTask().getVisibility(activeActivity) == STACK_VISIBILITY_VISIBLE
&& canResumeByCompat();
}
@@ -4672,7 +4669,7 @@
// ActivityStack#ensureActivitiesVisible will bring the activity to a proper
// active state.
if (!isState(STARTED, RESUMED, PAUSED, STOPPED, STOPPING)
- || getActivityStack().mTranslucentActivityWaiting != null) {
+ || getRootTask().mTranslucentActivityWaiting != null) {
return false;
}
@@ -4769,7 +4766,7 @@
mStackSupervisor.reportResumedActivityLocked(this);
resumeKeyDispatchingLocked();
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
mStackSupervisor.mNoAnimActivities.clear();
// Mark the point when the activity is resuming
@@ -4862,7 +4859,7 @@
void stopIfPossible() {
if (DEBUG_SWITCH) Slog.d(TAG_SWITCH, "Stopping: " + this);
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (isNoHistory()) {
if (!finishing) {
if (!stack.shouldSleepActivities()) {
@@ -4919,7 +4916,7 @@
void activityStopped(Bundle newIcicle, PersistableBundle newPersistentState,
CharSequence description) {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
final boolean isStopping = mState == STOPPING;
if (!isStopping && mState != RESTARTING_PROCESS) {
Slog.i(TAG, "Activity reported stop, but no longer stopping: " + this);
@@ -4969,7 +4966,7 @@
mStackSupervisor.mStoppingActivities.add(this);
}
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
// If we already have a few activities waiting to stop, then give up on things going idle
// and start clearing them out. Or if r is the last of activity of the last task the stack
// will be empty and must be cleared immediately.
@@ -5005,7 +5002,7 @@
return false;
}
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (stack == null) {
return false;
}
@@ -5021,7 +5018,7 @@
void finishLaunchTickingLocked() {
launchTickTime = 0;
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (stack == null) {
return;
}
@@ -5491,13 +5488,13 @@
static ActivityRecord isInStackLocked(IBinder token) {
final ActivityRecord r = ActivityRecord.forTokenLocked(token);
- return (r != null) ? r.getActivityStack().isInStackLocked(r) : null;
+ return (r != null) ? r.getRootTask().isInStackLocked(r) : null;
}
static ActivityStack getStackLocked(IBinder token) {
final ActivityRecord r = ActivityRecord.isInStackLocked(token);
if (r != null) {
- return r.getActivityStack();
+ return r.getRootTask();
}
return null;
}
@@ -5507,7 +5504,7 @@
* {@link android.view.Display#INVALID_DISPLAY} if not attached.
*/
int getDisplayId() {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (stack == null) {
return INVALID_DISPLAY;
}
@@ -5519,7 +5516,7 @@
// This would be redundant.
return false;
}
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (isState(RESUMED) || stack == null || this == stack.mPausingActivity || !mHaveState
|| !stopped) {
// We're not ready for this kind of thing.
@@ -6715,7 +6712,7 @@
void savePinnedStackBounds() {
// Leaving PiP to fullscreen, save the snap fraction based on the pre-animation bounds
// for the next re-entry into PiP (assuming the activity is not hidden or destroyed)
- final ActivityStack pinnedStack = mDisplayContent.getPinnedStack();
+ final ActivityStack pinnedStack = mDisplayContent.getRootPinnedTask();
if (pinnedStack == null) return;
final Rect stackBounds;
if (pinnedStack.lastAnimatingBoundsWasToFullscreen()) {
@@ -6755,7 +6752,7 @@
private void applyAspectRatio(Rect outBounds, Rect containingAppBounds,
Rect containingBounds) {
final float maxAspectRatio = info.maxAspectRatio;
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
final float minAspectRatio = info.minAspectRatio;
if (task == null || stack == null || (inMultiWindowMode() && !shouldUseSizeCompatMode())
@@ -6861,7 +6858,7 @@
*/
boolean ensureActivityConfiguration(int globalChanges, boolean preserveWindow,
boolean ignoreVisibility) {
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
if (stack.mConfigWillChange) {
if (DEBUG_SWITCH || DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION,
"Skipping config check (will change): " + this);
@@ -7406,7 +7403,7 @@
if (!getTurnScreenOnFlag()) {
return false;
}
- final ActivityStack stack = getActivityStack();
+ final ActivityStack stack = getRootTask();
return stack != null &&
stack.checkKeyguardVisibility(this, true /* shouldBeVisible */, true /* isTop */);
}
diff --git a/services/core/java/com/android/server/wm/ActivityStack.java b/services/core/java/com/android/server/wm/ActivityStack.java
index 60e0f51e..942be84 100644
--- a/services/core/java/com/android/server/wm/ActivityStack.java
+++ b/services/core/java/com/android/server/wm/ActivityStack.java
@@ -277,9 +277,6 @@
int mCurrentUser;
- /** Unique identifier */
- final int mStackId;
-
/** For comparison with DisplayContent bounds. */
private Rect mTmpRect = new Rect();
private Rect mTmpRect2 = new Rect();
@@ -633,7 +630,6 @@
_realActivitySuspended, userSetupComplete, minWidth, minHeight, info, _voiceSession,
_voiceInteractor, stack);
- mStackId = mTaskId;
mDockedStackMinimizeThickness = mWmService.mContext.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.docked_stack_minimize_thickness);
EventLogTags.writeWmStackCreated(id);
@@ -732,11 +728,11 @@
setBounds(newBounds);
newBounds.set(newBounds);
} else if (overrideWindowingMode == WINDOWING_MODE_SPLIT_SCREEN_SECONDARY) {
- Rect dockedBounds = display.getSplitScreenPrimaryStack().getBounds();
+ Rect dockedBounds = display.getRootSplitScreenPrimaryTask().getBounds();
final boolean isMinimizedDock =
display.mDisplayContent.getDockedDividerController().isMinimizedDock();
if (isMinimizedDock) {
- Task topTask = display.getSplitScreenPrimaryStack().getTopMostTask();
+ Task topTask = display.getRootSplitScreenPrimaryTask().getTopMostTask();
if (topTask != null) {
dockedBounds = topTask.getBounds();
}
@@ -830,7 +826,7 @@
final int currentOverrideMode = getRequestedOverrideWindowingMode();
final DisplayContent display = getDisplay();
final Task topTask = getTopMostTask();
- final ActivityStack splitScreenStack = display.getSplitScreenPrimaryStack();
+ final ActivityStack splitScreenStack = display.getRootSplitScreenPrimaryTask();
int windowingMode = preferredWindowingMode;
if (preferredWindowingMode == WINDOWING_MODE_UNDEFINED
&& isTransientWindowingMode(currentMode)) {
@@ -851,7 +847,7 @@
windowingMode = mRestoreOverrideWindowingMode;
}
- final boolean alreadyInSplitScreenMode = display.hasSplitScreenPrimaryStack();
+ final boolean alreadyInSplitScreenMode = display.hasSplitScreenPrimaryTask();
// Don't send non-resizeable notifications if the windowing mode changed was a side effect
// of us entering split-screen mode.
@@ -868,7 +864,7 @@
// warning toast about it.
mAtmService.getTaskChangeNotificationController()
.notifyActivityDismissingDockedStack();
- final ActivityStack primarySplitStack = display.getSplitScreenPrimaryStack();
+ final ActivityStack primarySplitStack = display.getRootSplitScreenPrimaryTask();
primarySplitStack.setWindowingModeInSurfaceTransaction(WINDOWING_MODE_UNDEFINED,
false /* animate */, false /* showRecents */,
false /* enteringSplitScreenMode */, true /* deferEnsuringVisibility */,
@@ -1118,7 +1114,7 @@
return null;
}
final Task task = r.getTask();
- final ActivityStack stack = r.getActivityStack();
+ final ActivityStack stack = r.getRootTask();
if (stack != null && task.mChildren.contains(r) && mChildren.contains(task)) {
if (stack != this) Slog.w(TAG,
"Illegal state! task does not point to stack it is in.");
@@ -1165,7 +1161,7 @@
final ActivityStack topFullScreenStack =
display.getTopStackInWindowingMode(WINDOWING_MODE_FULLSCREEN);
if (topFullScreenStack != null) {
- final ActivityStack primarySplitScreenStack = display.getSplitScreenPrimaryStack();
+ final ActivityStack primarySplitScreenStack = display.getRootSplitScreenPrimaryTask();
if (display.getIndexOf(topFullScreenStack)
> display.getIndexOf(primarySplitScreenStack)) {
primarySplitScreenStack.moveToFront(reason + " splitScreenToTop");
@@ -1347,7 +1343,7 @@
private boolean containsActivityFromStack(List<ActivityRecord> rs) {
for (ActivityRecord r : rs) {
- if (r.getActivityStack() == this) {
+ if (r.getRootTask() == this) {
return true;
}
}
@@ -1563,7 +1559,7 @@
// focus). Also if there is an active pinned stack - we always want to notify it about
// task stack changes, because its positioning may depend on it.
if (mStackSupervisor.mAppVisibilitiesChangedSinceLastPause
- || (getDisplay() != null && getDisplay().hasPinnedStack())) {
+ || (getDisplay() != null && getDisplay().hasPinnedTask())) {
mAtmService.getTaskChangeNotificationController().notifyTaskStackChanged();
mStackSupervisor.mAppVisibilitiesChangedSinceLastPause = false;
}
@@ -1873,7 +1869,7 @@
final DisplayContent displayContent = getDisplay();
if (displayContent == null) {
throw new IllegalStateException("Stack is not attached to any display, stackId="
- + mStackId);
+ + getRootTaskId());
}
final int flags = displayContent.mDisplay.getFlags();
@@ -2592,7 +2588,7 @@
return false;
}
final ActivityStack targetStack = toFrontTask != null
- ? toFrontTask.getStack() : toFrontActivity.getActivityStack();
+ ? toFrontTask.getStack() : toFrontActivity.getRootTask();
if (targetStack != null && targetStack.isActivityTypeAssistant()) {
// Ensure the task/activity being brought forward is not the assistant
return false;
@@ -3073,7 +3069,7 @@
}
ActivityRecord topActivity = getDisplay().topRunningActivity();
- ActivityStack topStack = topActivity.getActivityStack();
+ ActivityStack topStack = topActivity.getRootTask();
if (topStack != null && topStack != this && topActivity.isState(RESUMED)) {
// The new top activity is already resumed, so there's a good chance that nothing will
// get resumed below. So, update visibility now in case the transition is closed
@@ -3102,7 +3098,7 @@
return;
}
- Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "stack.resize_" + mStackId);
+ Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "stack.resize_" + getRootTaskId());
mAtmService.deferWindowLayout();
try {
// Update override configurations of all tasks in the stack.
@@ -3219,7 +3215,7 @@
boolean dump(FileDescriptor fd, PrintWriter pw, boolean dumpAll, boolean dumpClient,
String dumpPackage, boolean needSep) {
- pw.println(" Stack #" + mStackId
+ pw.println(" Stack #" + getRootTaskId()
+ ": type=" + activityTypeToString(getActivityType())
+ " mode=" + windowingModeToString(getWindowingMode()));
pw.println(" isSleeping=" + shouldSleepActivities());
@@ -4484,7 +4480,7 @@
@Override
void dump(PrintWriter pw, String prefix, boolean dumpAll) {
- pw.println(prefix + "mStackId=" + mStackId);
+ pw.println(prefix + "mStackId=" + getRootTaskId());
pw.println(prefix + "mDeferRemoval=" + mDeferRemoval);
pw.println(prefix + "mBounds=" + getRawBounds().toShortString());
if (mMinimizeAmount != 0f) {
@@ -4515,14 +4511,6 @@
mAnimatingActivityRegistry.dump(pw, "AnimatingApps:", prefix);
}
- String getName() {
- return toShortString();
- }
-
- public String toShortString() {
- return "Stack=" + mStackId;
- }
-
/**
* For docked workspace (or workspace that's side-by-side to the docked), provides
* information which side of the screen was the dock anchored.
@@ -4731,7 +4719,7 @@
// activity early for the recents animation prior to the PiP animation starting, there
// is no subsequent all-drawn signal. In this case, we can skip the pause when the home
// stack is already visible and drawn.
- final ActivityStack homeStack = mDisplayContent.getHomeStack();
+ final ActivityStack homeStack = mDisplayContent.getRootHomeTask();
if (homeStack == null) {
return true;
}
@@ -4863,7 +4851,7 @@
@WindowTraceLogLevel int logLevel) {
final long token = proto.start(fieldId);
dumpDebugInnerStackOnly(proto, STACK, logLevel);
- proto.write(com.android.server.am.ActivityStackProto.ID, mStackId);
+ proto.write(com.android.server.am.ActivityStackProto.ID, getRootTaskId());
forAllTasks((t) -> {
t.dumpDebugInner(proto, com.android.server.am.ActivityStackProto.TASKS, logLevel);
@@ -4891,7 +4879,7 @@
final long token = proto.start(fieldId);
super.dumpDebug(proto, WINDOW_CONTAINER, logLevel);
- proto.write(StackProto.ID, mStackId);
+ proto.write(StackProto.ID, getRootTaskId());
forAllTasks((t) -> {
t.dumpDebugInnerTaskOnly(proto, StackProto.TASKS, logLevel);
}, true /* traverseTopToBottom */, this);
diff --git a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
index f2ce7e8..2c0f3e6 100644
--- a/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
+++ b/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
@@ -824,7 +824,7 @@
false /* markFrozenIfConfigChanged */, true /* deferResume */);
}
- if (r.getActivityStack().checkKeyguardVisibility(r, true /* shouldBeVisible */,
+ if (r.getRootTask().checkKeyguardVisibility(r, true /* shouldBeVisible */,
true /* isTop */) && r.allowMoveToFront()) {
// We only set the visibility to true if the activity is not being launched in
// background, and is allowed to be visible based on keyguard state. This avoids
@@ -1582,7 +1582,7 @@
}
final ActivityStack stack =
- mRootWindowContainer.getDefaultDisplay().getSplitScreenPrimaryStack();
+ mRootWindowContainer.getDefaultDisplay().getRootSplitScreenPrimaryTask();
if (stack == null) {
Slog.w(TAG, "resizeDockedStackLocked: docked stack not found");
return;
@@ -1670,7 +1670,7 @@
void resizePinnedStackLocked(Rect pinnedBounds, Rect tempPinnedTaskBounds) {
// TODO(multi-display): The display containing the stack should be passed in.
final ActivityStack stack =
- mRootWindowContainer.getDefaultDisplay().getPinnedStack();
+ mRootWindowContainer.getDefaultDisplay().getRootPinnedTask();
if (stack == null) {
Slog.w(TAG, "resizePinnedStackLocked: pinned stack not found");
return;
@@ -1891,13 +1891,13 @@
// TODO: Look into changing users to this method to DisplayContent.resolveWindowingMode()
ActivityStack getReparentTargetStack(Task task, ActivityStack stack, boolean toTop) {
final ActivityStack prevStack = task.getStack();
- final int stackId = stack.mStackId;
+ final int rootTaskId = stack.mTaskId;
final boolean inMultiWindowMode = stack.inMultiWindowMode();
// Check that we aren't reparenting to the same stack that the task is already in
- if (prevStack != null && prevStack.mStackId == stackId) {
+ if (prevStack != null && prevStack.mTaskId == rootTaskId) {
Slog.w(TAG, "Can not reparent to same stack, task=" + task
- + " already in stackId=" + stackId);
+ + " already in stackId=" + rootTaskId);
return prevStack;
}
@@ -1912,7 +1912,7 @@
// multi-display.
if (stack.getDisplayId() != DEFAULT_DISPLAY && !mService.mSupportsMultiDisplay) {
throw new IllegalArgumentException("Device doesn't support multi-display, can not"
- + " reparent task=" + task + " to stackId=" + stackId);
+ + " reparent task=" + task + " to stackId=" + rootTaskId);
}
// Ensure that we aren't trying to move into a freeform stack without freeform support
@@ -1993,7 +1993,7 @@
void activitySleptLocked(ActivityRecord r) {
mGoingToSleepActivities.remove(r);
- final ActivityStack s = r.getActivityStack();
+ final ActivityStack s = r.getRootTask();
if (s != null) {
s.checkReadyForSleep();
} else {
@@ -2029,7 +2029,7 @@
// A resumed activity cannot be stopping. remove from list
mStoppingActivities.remove(r);
- final ActivityStack stack = r.getActivityStack();
+ final ActivityStack stack = r.getRootTask();
if (stack.getDisplay().allResumedActivitiesComplete()) {
mRootWindowContainer.ensureActivitiesVisible(null, 0, !PRESERVE_WINDOWS);
// Make sure activity & window visibility should be identical
@@ -2082,7 +2082,7 @@
if (DEBUG_STATES) Slog.v(TAG, "Stopping " + s + ": nowVisible=" + s.nowVisible
+ " animating=" + animating + " finishing=" + s.finishing);
- final ActivityStack stack = s.getActivityStack();
+ final ActivityStack stack = s.getRootTask();
final boolean shouldSleepOrShutDown = stack != null
? stack.shouldSleepOrShutDownActivities()
: mService.isSleepingOrShuttingDownLocked();
@@ -2395,7 +2395,7 @@
final boolean isSecondaryDisplayPreferred =
(preferredDisplayId != DEFAULT_DISPLAY && preferredDisplayId != INVALID_DISPLAY);
final boolean inSplitScreenMode = actualStack != null
- && actualStack.getDisplay().hasSplitScreenPrimaryStack();
+ && actualStack.getDisplay().hasSplitScreenPrimaryTask();
if (((!inSplitScreenMode && preferredWindowingMode != WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)
&& !isSecondaryDisplayPreferred) || !task.isActivityTypeStandardOrUndefined()) {
return;
@@ -2444,7 +2444,7 @@
// we need to move it to top of fullscreen stack, otherwise it will be covered.
final ActivityStack dockedStack =
- task.getStack().getDisplay().getSplitScreenPrimaryStack();
+ task.getStack().getDisplay().getRootSplitScreenPrimaryTask();
if (dockedStack != null) {
// Display a warning toast that we tried to put an app that doesn't support
// split-screen in split-screen.
@@ -2473,7 +2473,7 @@
final ActivityRecord r = ActivityRecord.isInStackLocked(token);
if (r != null) {
r.finishRelaunching();
- if (r.getActivityStack().shouldSleepOrShutDownActivities()) {
+ if (r.getRootTask().shouldSleepOrShutDownActivities()) {
r.setSleeping(true, true);
}
}
diff --git a/services/core/java/com/android/server/wm/ActivityStarter.java b/services/core/java/com/android/server/wm/ActivityStarter.java
index 6587226..26812f4 100644
--- a/services/core/java/com/android/server/wm/ActivityStarter.java
+++ b/services/core/java/com/android/server/wm/ActivityStarter.java
@@ -937,7 +937,7 @@
}
final ActivityStack resultStack = resultRecord == null
- ? null : resultRecord.getActivityStack();
+ ? null : resultRecord.getRootTask();
if (err != START_SUCCESS) {
if (resultRecord != null) {
@@ -1365,7 +1365,7 @@
break;
case WINDOWING_MODE_SPLIT_SCREEN_PRIMARY:
final ActivityStack homeStack =
- startedActivityStack.getDisplay().getHomeStack();
+ startedActivityStack.getDisplay().getRootHomeTask();
if (homeStack != null && homeStack.shouldBeVisible(null /* starting */)) {
mService.mWindowManager.showRecentApps();
}
@@ -1425,7 +1425,7 @@
* @return the stack where the successful started activity resides.
*/
private @Nullable ActivityStack handleStartResult(@NonNull ActivityRecord started, int result) {
- final ActivityStack currentStack = started.getActivityStack();
+ final ActivityStack currentStack = started.getRootTask();
ActivityStack startedActivityStack = currentStack != null ? currentStack : mTargetStack;
if (ActivityManager.isStartResultSuccessful(result)) {
@@ -1446,7 +1446,7 @@
// If we are not able to proceed, disassociate the activity from the task. Leaving an
// activity in an incomplete state can lead to issues, such as performing operations
// without a window container.
- final ActivityStack stack = mStartActivity.getActivityStack();
+ final ActivityStack stack = mStartActivity.getRootTask();
if (stack != null) {
mStartActivity.finishIfPossible("startActivity", true /* oomAdj */);
}
@@ -2231,7 +2231,7 @@
return;
}
if (!mSourceRecord.finishing) {
- mSourceStack = mSourceRecord.getActivityStack();
+ mSourceStack = mSourceRecord.getRootTask();
return;
}
@@ -2314,7 +2314,7 @@
* @return {@link ActivityRecord} brought to front.
*/
private void setTargetStackIfNeeded(ActivityRecord intentActivity) {
- mTargetStack = intentActivity.getActivityStack();
+ mTargetStack = intentActivity.getRootTask();
mTargetStack.mLastPausedActivity = null;
// If the target task is not in the front, then we need to bring it to the front...
// except... well, with SINGLE_TASK_LAUNCH it's not entirely clear. We'd like to have
@@ -2371,7 +2371,7 @@
}
// Need to update mTargetStack because if task was moved out of it, the original stack may
// be destroyed.
- mTargetStack = intentActivity.getActivityStack();
+ mTargetStack = intentActivity.getRootTask();
mSupervisor.handleNonResizableTaskIfNeeded(intentActivity.getTask(),
WINDOWING_MODE_UNDEFINED, DEFAULT_DISPLAY, mTargetStack);
}
@@ -2422,10 +2422,11 @@
return;
}
- final ActivityStack stack = task.getStack();
- if (stack != null && stack.inPinnedWindowingMode()) {
- mService.animateResizePinnedStack(stack.mStackId, bounds, -1);
+ final Task rootTask = task.getRootTask();
+ if (rootTask != null && rootTask.inPinnedWindowingMode()) {
+ mService.animateResizePinnedStack(rootTask.mTaskId, bounds, -1);
} else {
+ // TODO: I don't believe it is possible to reach this else condition anymore...
task.setBounds(bounds);
}
}
diff --git a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
index 8491bc2..31b7c68 100644
--- a/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
+++ b/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
@@ -1612,7 +1612,7 @@
if (mController != null) {
// Find the first activity that is not finishing.
final ActivityRecord next =
- r.getActivityStack().topRunningActivity(token, INVALID_TASK_ID);
+ r.getRootTask().topRunningActivity(token, INVALID_TASK_ID);
if (next != null) {
// ask watcher if this is allowed
boolean resumeOK = true;
@@ -2037,7 +2037,7 @@
synchronized (mGlobalLock) {
ActivityRecord r = mRootWindowContainer.isInAnyStack(token);
if (r != null) {
- r.getActivityStack().notifyActivityDrawnLocked(r);
+ r.getRootTask().notifyActivityDrawnLocked(r);
}
}
}
@@ -2073,7 +2073,7 @@
synchronized (mGlobalLock) {
ActivityStack focusedStack = getTopDisplayFocusedStack();
if (focusedStack != null) {
- return mRootWindowContainer.getStackInfo(focusedStack.mStackId);
+ return mRootWindowContainer.getStackInfo(focusedStack.mTaskId);
}
return null;
}
@@ -2175,7 +2175,7 @@
synchronized (mGlobalLock) {
final ActivityRecord srec = ActivityRecord.forTokenLocked(token);
if (srec != null) {
- return srec.getActivityStack().shouldUpRecreateTaskLocked(srec, destAffinity);
+ return srec.getRootTask().shouldUpRecreateTaskLocked(srec, destAffinity);
}
}
return false;
@@ -2188,7 +2188,7 @@
synchronized (mGlobalLock) {
final ActivityRecord r = ActivityRecord.forTokenLocked(token);
if (r != null) {
- return r.getActivityStack().navigateUpTo(
+ return r.getRootTask().navigateUpTo(
r, destIntent, resultCode, resultData);
}
return false;
@@ -2354,7 +2354,7 @@
if (r == null) {
return;
}
- ActivityStack stack = r.getActivityStack();
+ ActivityStack stack = r.getRootTask();
if (stack != null && stack.isSingleTaskInstance()) {
// Single-task stacks are used for activities which are presented in floating
// windows above full screen activities. Instead of directly finishing the
@@ -2582,7 +2582,7 @@
r, resultWho, requestCode);
// TODO: This should probably only loop over the task since you need to be in the
// same task to return results.
- r.getActivityStack().forAllActivities(c);
+ r.getRootTask().forAllActivities(c);
c.recycle();
updateOomAdj();
@@ -3215,7 +3215,7 @@
+ ainfo.applicationInfo.uid + ", calling uid=" + callingUid);
}
- final ActivityStack stack = r.getActivityStack();
+ final ActivityStack stack = r.getRootTask();
final Task task = stack.createTask(
mStackSupervisor.getNextTaskIdForUser(r.mUserId), ainfo, intent, !ON_TOP);
if (!mRecentTasks.addToBottom(task)) {
@@ -3551,7 +3551,7 @@
+ token);
}
- final ActivityStack stack = r.getActivityStack();
+ final ActivityStack stack = r.getRootTask();
if (stack == null) {
throw new IllegalStateException("toggleFreeformWindowingMode: the activity "
+ "doesn't have a stack");
@@ -4080,7 +4080,7 @@
try {
synchronized (mGlobalLock) {
final ActivityStack stack =
- mRootWindowContainer.getDefaultDisplay().getSplitScreenPrimaryStack();
+ mRootWindowContainer.getDefaultDisplay().getRootSplitScreenPrimaryTask();
if (stack == null) {
Slog.w(TAG, "dismissSplitScreenMode: primary split-screen stack not found.");
return;
@@ -4121,7 +4121,7 @@
try {
synchronized (mGlobalLock) {
final ActivityStack stack =
- mRootWindowContainer.getDefaultDisplay().getPinnedStack();
+ mRootWindowContainer.getDefaultDisplay().getRootPinnedTask();
if (stack == null) {
Slog.w(TAG, "dismissPip: pinned stack not found.");
return;
@@ -4235,14 +4235,14 @@
}
private boolean isInPictureInPictureMode(ActivityRecord r) {
- if (r == null || r.getActivityStack() == null || !r.inPinnedWindowingMode()
- || r.getActivityStack().isInStackLocked(r) == null) {
+ if (r == null || r.getRootTask() == null || !r.inPinnedWindowingMode()
+ || r.getRootTask().isInStackLocked(r) == null) {
return false;
}
// If we are animating to fullscreen then we have already dispatched the PIP mode
// changed, so we should reflect that check here as well.
- final ActivityStack taskStack = r.getActivityStack();
+ final ActivityStack taskStack = r.getRootTask();
return !taskStack.isAnimatingBoundsToFullscreen();
}
@@ -4281,7 +4281,7 @@
r.pictureInPictureArgs.getSourceRectHint());
mRootWindowContainer.moveActivityToPinnedStack(
r, sourceBounds, aspectRatio, "enterPictureInPictureMode");
- final ActivityStack stack = r.getActivityStack();
+ final ActivityStack stack = r.getRootTask();
stack.setPictureInPictureAspectRatio(aspectRatio);
stack.setPictureInPictureActions(actions);
MetricsLoggerWrapper.logPictureInPictureEnter(mContext,
@@ -4326,7 +4326,7 @@
// If the activity is already in picture-in-picture, update the pinned stack now
// if it is not already expanding to fullscreen. Otherwise, the arguments will
// be used the next time the activity enters PiP
- final ActivityStack stack = r.getActivityStack();
+ final ActivityStack stack = r.getRootTask();
if (!stack.isAnimatingBoundsToFullscreen()) {
stack.setPictureInPictureAspectRatio(
r.pictureInPictureArgs.getAspectRatio());
@@ -4923,7 +4923,7 @@
Slog.i(TAG, "Moving " + r.shortComponentName + " from display " + r.getDisplayId()
+ " to main display for VR");
mRootWindowContainer.moveStackToDisplay(
- r.getStackId(), DEFAULT_DISPLAY, true /* toTop */);
+ r.getRootTaskId(), DEFAULT_DISPLAY, true /* toTop */);
}
mH.post(() -> {
if (!mVrController.onVrModeChanged(r)) {
@@ -6752,7 +6752,7 @@
int requestCode, int resultCode, Intent data) {
synchronized (mGlobalLock) {
final ActivityRecord r = ActivityRecord.isInStackLocked(activityToken);
- if (r != null && r.getActivityStack() != null) {
+ if (r != null && r.getRootTask() != null) {
r.sendResult(callingUid, resultWho, requestCode, resultCode, data);
}
}
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 0d19ef7..825f93c 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -19,6 +19,7 @@
import static android.app.ActivityTaskManager.INVALID_STACK_ID;
import static android.app.ActivityTaskManager.SPLIT_SCREEN_CREATE_MODE_TOP_OR_LEFT;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_HOME;
+import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_UNDEFINED;
import static android.app.WindowConfiguration.ROTATION_UNDEFINED;
@@ -294,7 +295,7 @@
/** The containers below are the only child containers {@link #mWindowContainers} can have. */
// Contains all window containers that are related to apps (Activities)
- private final TaskStackContainers mTaskStackContainers = new TaskStackContainers(mWmService);
+ private final TaskContainers mTaskContainers = new TaskContainers(mWmService);
// Contains all non-app window containers that should be displayed above the app containers
// (e.g. Status bar)
private final AboveAppWindowContainers mAboveAppWindowsContainers =
@@ -401,14 +402,6 @@
private int mCurrentOverrideConfigurationChanges;
/**
- * Orientation forced by some window. If there is no visible window that specifies orientation
- * it is set to {@link android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED}.
- *
- * @see NonAppWindowContainers#getOrientation()
- */
- private int mLastWindowForcedOrientation = SCREEN_ORIENTATION_UNSPECIFIED;
-
- /**
* Last orientation forced by the keyguard. It is applied when keyguard is shown and is not
* occluded.
*
@@ -1283,11 +1276,6 @@
return mDisplayRotation.getLastOrientation();
}
- @ScreenOrientation
- int getLastWindowForcedOrientation() {
- return mLastWindowForcedOrientation;
- }
-
void registerRemoteAnimations(RemoteAnimationDefinition definition) {
mAppTransitionController.registerRemoteAnimations(definition);
}
@@ -1946,39 +1934,25 @@
return (mDisplay.getFlags() & FLAG_PRIVATE) != 0;
}
- ActivityStack getHomeStack() {
- return mTaskStackContainers.getHomeStack();
+ ActivityStack getRootHomeTask() {
+ return mTaskContainers.getRootHomeTask();
}
- ActivityStack getRecentsStack() {
- return mTaskStackContainers.getRecentsStack();
+ /** @return The primary split-screen task, and {@code null} otherwise. */
+ ActivityStack getRootSplitScreenPrimaryTask() {
+ return mTaskContainers.getRootSplitScreenPrimaryTask();
}
- /**
- * @return The primary split-screen stack, and {@code null} otherwise.
- */
- ActivityStack getSplitScreenPrimaryStack() {
- return mTaskStackContainers.getSplitScreenPrimaryStack();
+ boolean hasSplitScreenPrimaryTask() {
+ return getRootSplitScreenPrimaryTask() != null;
}
- boolean hasSplitScreenPrimaryStack() {
- return getSplitScreenPrimaryStack() != null;
+ ActivityStack getRootPinnedTask() {
+ return mTaskContainers.getRootPinnedTask();
}
- /**
- * Like {@link #getSplitScreenPrimaryStack}, but also returns the stack if it's currently
- * not visible.
- */
- ActivityStack getSplitScreenPrimaryStackIgnoringVisibility() {
- return mTaskStackContainers.getSplitScreenPrimaryStack();
- }
-
- ActivityStack getPinnedStack() {
- return mTaskStackContainers.getPinnedStack();
- }
-
- boolean hasPinnedStack() {
- return mTaskStackContainers.getPinnedStack() != null;
+ boolean hasPinnedTask() {
+ return mTaskContainers.getRootPinnedTask() != null;
}
/**
@@ -1994,45 +1968,45 @@
* activity type. Null is no compatible stack on the display.
*/
ActivityStack getStack(int windowingMode, int activityType) {
- return mTaskStackContainers.getStack(windowingMode, activityType);
+ return mTaskContainers.getStack(windowingMode, activityType);
}
protected int getStackCount() {
- return mTaskStackContainers.mChildren.size();
+ return mTaskContainers.mChildren.size();
}
protected ActivityStack getStackAt(int index) {
- return mTaskStackContainers.mChildren.get(index);
+ return mTaskContainers.mChildren.get(index);
}
int getIndexOf(ActivityStack stack) {
- return mTaskStackContainers.getIndexOf(stack);
+ return mTaskContainers.getIndexOf(stack);
}
void removeStack(ActivityStack stack) {
- mTaskStackContainers.removeChild(stack);
+ mTaskContainers.removeChild(stack);
}
@VisibleForTesting
WindowList<ActivityStack> getStacks() {
- return mTaskStackContainers.mChildren;
+ return mTaskContainers.mChildren;
}
@VisibleForTesting
ActivityStack getTopStack() {
- return mTaskStackContainers.getTopStack();
+ return mTaskContainers.getTopStack();
}
ArrayList<Task> getVisibleTasks() {
- return mTaskStackContainers.getVisibleTasks();
+ return mTaskContainers.getVisibleTasks();
}
SurfaceControl getSplitScreenDividerAnchor() {
- return mTaskStackContainers.getSplitScreenDividerAnchor();
+ return mTaskContainers.getSplitScreenDividerAnchor();
}
void onStackWindowingModeChanged(ActivityStack stack) {
- mTaskStackContainers.onStackWindowingModeChanged(stack);
+ mTaskContainers.onStackWindowingModeChanged(stack);
}
/**
@@ -2065,7 +2039,7 @@
// If there was no pinned stack, we still need to notify the controller of the display info
// update as a result of the config change.
- if (mPinnedStackControllerLocked != null && !hasPinnedStack()) {
+ if (mPinnedStackControllerLocked != null && !hasPinnedTask()) {
mPinnedStackControllerLocked.onDisplayInfoChanged(getDisplayInfo());
}
}
@@ -2134,16 +2108,7 @@
}
if (mWmService.mDisplayFrozen) {
- if (mLastWindowForcedOrientation != SCREEN_ORIENTATION_UNSPECIFIED) {
- ProtoLog.v(WM_DEBUG_ORIENTATION,
- "Display id=%d is frozen, return %d", mDisplayId,
- mLastWindowForcedOrientation);
- // If the display is frozen, some activities may be in the middle of restarting, and
- // thus have removed their old window. If the window has the flag to hide the lock
- // screen, then the lock screen can re-appear and inflict its own orientation on us.
- // Keep the orientation stable until this all settles down.
- return mLastWindowForcedOrientation;
- } else if (policy.isKeyguardLocked()) {
+ if (policy.isKeyguardLocked()) {
// Use the last orientation the while the display is frozen with the keyguard
// locked. This could be the keyguard forced orientation or from a SHOW_WHEN_LOCKED
// window. We don't want to check the show when locked window directly though as
@@ -2154,15 +2119,14 @@
mDisplayId, getLastOrientation());
return getLastOrientation();
}
- } else {
- final int orientation = mAboveAppWindowsContainers.getOrientation();
- if (orientation != SCREEN_ORIENTATION_UNSET) {
- return orientation;
- }
+ }
+ final int orientation = mAboveAppWindowsContainers.getOrientation();
+ if (orientation != SCREEN_ORIENTATION_UNSET) {
+ return orientation;
}
// Top system windows are not requesting an orientation. Start searching from apps.
- return mTaskStackContainers.getOrientation();
+ return mTaskContainers.getOrientation();
}
void updateDisplayInfo() {
@@ -2346,11 +2310,11 @@
void setStackOnDisplay(ActivityStack stack, int position) {
if (DEBUG_STACK) Slog.d(TAG_WM, "Set stack=" + stack + " on displayId=" + mDisplayId);
- mTaskStackContainers.addChild(stack, position);
+ mTaskContainers.addChild(stack, position);
}
void moveStackToDisplay(ActivityStack stack, boolean onTop) {
- stack.reparent(mTaskStackContainers, onTop ? POSITION_TOP: POSITION_BOTTOM);
+ stack.reparent(mTaskContainers, onTop ? POSITION_TOP: POSITION_BOTTOM);
}
@Override
@@ -2387,7 +2351,7 @@
}
void positionStackAt(int position, ActivityStack child, boolean includingParents) {
- mTaskStackContainers.positionChildAt(position, child, includingParents);
+ mTaskContainers.positionChildAt(position, child, includingParents);
layoutAndAssignWindowLayersIfNeeded();
}
@@ -2418,7 +2382,7 @@
*/
Task findTaskForResizePoint(int x, int y) {
final int delta = dipToPixel(RESIZE_HANDLE_WIDTH_IN_DP, mDisplayMetrics);
- return mTmpTaskForResizePointSearchResult.process(mTaskStackContainers, x, y, delta);
+ return mTmpTaskForResizePointSearchResult.process(mTaskContainers, x, y, delta);
}
void updateTouchExcludeRegion() {
@@ -2434,7 +2398,7 @@
final PooledConsumer c = PooledLambda.obtainConsumer(
DisplayContent::processTaskForTouchExcludeRegion, this,
PooledLambda.__(Task.class), focusedTask, delta);
- mTaskStackContainers.forAllTasks(c);
+ mTaskContainers.forAllTasks(c);
c.recycle();
// If we removed the focused task above, add it back and only leave its
@@ -2458,7 +2422,7 @@
}
amendWindowTapExcludeRegion(mTouchExcludeRegion);
// TODO(multi-display): Support docked stacks on secondary displays.
- if (mDisplayId == DEFAULT_DISPLAY && getSplitScreenPrimaryStack() != null) {
+ if (mDisplayId == DEFAULT_DISPLAY && getRootSplitScreenPrimaryTask() != null) {
mDividerControllerLocked.getTouchRegion(mTmpRect);
mTmpRegion.set(mTmpRect);
mTouchExcludeRegion.op(mTmpRegion, Op.UNION);
@@ -2604,8 +2568,8 @@
float dividerAnimationTarget) {
boolean updated = false;
- for (int i = mTaskStackContainers.getChildCount() - 1; i >= 0; --i) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(i);
+ for (int i = mTaskContainers.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack stack = mTaskContainers.getChildAt(i);
if (stack == null || !stack.isAdjustedForIme()) {
continue;
}
@@ -2633,8 +2597,8 @@
boolean clearImeAdjustAnimation() {
boolean changed = false;
- for (int i = mTaskStackContainers.getChildCount() - 1; i >= 0; --i) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(i);
+ for (int i = mTaskContainers.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack stack = mTaskContainers.getChildAt(i);
if (stack != null && stack.isAdjustedForIme()) {
stack.resetAdjustedForIme(true /* adjustBoundsNow */);
changed = true;
@@ -2644,8 +2608,8 @@
}
void beginImeAdjustAnimation() {
- for (int i = mTaskStackContainers.getChildCount() - 1; i >= 0; --i) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(i);
+ for (int i = mTaskContainers.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack stack = mTaskContainers.getChildAt(i);
if (stack.isVisible() && stack.isAdjustedForIme()) {
stack.beginImeAdjustAnimation();
}
@@ -2656,7 +2620,7 @@
final WindowState imeWin = mInputMethodWindow;
final boolean imeVisible = imeWin != null && imeWin.isVisibleLw() && imeWin.isDisplayedLw()
&& !mDividerControllerLocked.isImeHideRequested();
- final ActivityStack dockedStack = getSplitScreenPrimaryStack();
+ final ActivityStack dockedStack = getRootSplitScreenPrimaryTask();
final boolean dockVisible = dockedStack != null;
final Task topDockedTask = dockVisible ? dockedStack.getTask((t) -> true): null;
final ActivityStack imeTargetStack = mWmService.getImeFocusStackLocked();
@@ -2682,8 +2646,8 @@
// - If IME is not visible, divider is not moved and is normal width.
if (imeVisible && dockVisible && (imeOnTop || imeOnBottom) && !dockMinimized) {
- for (int i = mTaskStackContainers.getChildCount() - 1; i >= 0; --i) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(i);
+ for (int i = mTaskContainers.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack stack = mTaskContainers.getChildAt(i);
final boolean isDockedOnBottom = stack.getDockSide() == DOCKED_BOTTOM;
if (stack.isVisible() && (imeOnBottom || isDockedOnBottom)
&& stack.inSplitScreenWindowingMode()) {
@@ -2695,8 +2659,8 @@
mDividerControllerLocked.setAdjustedForIme(
imeOnBottom /*ime*/, true /*divider*/, true /*animate*/, imeWin, imeHeight);
} else {
- for (int i = mTaskStackContainers.getChildCount() - 1; i >= 0; --i) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(i);
+ for (int i = mTaskContainers.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack stack = mTaskContainers.getChildAt(i);
stack.resetAdjustedForIme(!dockVisible);
}
mDividerControllerLocked.setAdjustedForIme(
@@ -2706,8 +2670,8 @@
}
void prepareFreezingTaskBounds() {
- for (int stackNdx = mTaskStackContainers.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(stackNdx);
+ for (int stackNdx = mTaskContainers.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = mTaskContainers.getChildAt(stackNdx);
stack.prepareFreezingTaskBounds();
}
}
@@ -2783,7 +2747,7 @@
proto.write(SINGLE_TASK_INSTANCE, mSingleTaskInstance);
final ActivityStack focusedStack = getFocusedStack();
if (focusedStack != null) {
- proto.write(FOCUSED_STACK_ID, focusedStack.mStackId);
+ proto.write(FOCUSED_STACK_ID, focusedStack.getRootTaskId());
final ActivityRecord focusedActivity = focusedStack.getDisplay().getResumedActivity();
if (focusedActivity != null) {
focusedActivity.writeIdentifierToProto(proto, RESUMED_ACTIVITY);
@@ -2809,8 +2773,8 @@
final long token = proto.start(fieldId);
super.dumpDebug(proto, WINDOW_CONTAINER, logLevel);
proto.write(ID, mDisplayId);
- for (int stackNdx = mTaskStackContainers.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(stackNdx);
+ for (int stackNdx = mTaskContainers.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = mTaskContainers.getChildAt(stackNdx);
stack.dumpDebugInnerStackOnly(proto, STACKS, logLevel);
}
mDividerControllerLocked.dumpDebug(proto, DOCKED_STACK_DIVIDER_CONTROLLER);
@@ -2936,8 +2900,8 @@
pw.println();
pw.println(prefix + "Application tokens in top down Z order:");
- for (int stackNdx = mTaskStackContainers.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(stackNdx);
+ for (int stackNdx = mTaskContainers.getChildCount() - 1; stackNdx >= 0; --stackNdx) {
+ final ActivityStack stack = mTaskContainers.getChildAt(stackNdx);
stack.dump(pw, prefix + " ", dumpAll);
}
@@ -2967,19 +2931,20 @@
pw.println();
// Dump stack references
- final ActivityStack homeStack = getHomeStack();
+ final ActivityStack homeStack = getRootHomeTask();
if (homeStack != null) {
pw.println(prefix + "homeStack=" + homeStack.getName());
}
- final ActivityStack pinnedStack = getPinnedStack();
+ final ActivityStack pinnedStack = getRootPinnedTask();
if (pinnedStack != null) {
pw.println(prefix + "pinnedStack=" + pinnedStack.getName());
}
- final ActivityStack splitScreenPrimaryStack = getSplitScreenPrimaryStack();
+ final ActivityStack splitScreenPrimaryStack = getRootSplitScreenPrimaryTask();
if (splitScreenPrimaryStack != null) {
pw.println(prefix + "splitScreenPrimaryStack=" + splitScreenPrimaryStack.getName());
}
- final ActivityStack recentsStack = getRecentsStack();
+ final ActivityStack recentsStack =
+ getStack(WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_RECENTS);
if (recentsStack != null) {
pw.println(prefix + "recentsStack=" + recentsStack.getName());
}
@@ -4017,7 +3982,7 @@
}
// Initialize state of exiting applications.
- mTaskStackContainers.setExitingTokensHasVisible(hasVisible);
+ mTaskContainers.setExitingTokensHasVisible(hasVisible);
}
void removeExistingTokensIfPossible() {
@@ -4029,7 +3994,7 @@
}
// Time to remove any exiting applications?
- mTaskStackContainers.removeExistingAppTokensIfPossible();
+ mTaskContainers.removeExistingAppTokensIfPossible();
}
@Override
@@ -4141,6 +4106,8 @@
DisplayChildWindowContainer(WindowManagerService service) {
super(service);
+ // TODO(display-area): move to ConfigurationContainer?
+ mOrientation = SCREEN_ORIENTATION_UNSET;
}
@Override
@@ -4158,7 +4125,7 @@
* Window container class that contains all containers on this display relating to Apps.
* I.e Activities.
*/
- private final class TaskStackContainers extends DisplayChildWindowContainer<ActivityStack> {
+ private final class TaskContainers extends DisplayChildWindowContainer<ActivityStack> {
/**
* A control placed at the appropriate level for transitions to occur.
*/
@@ -4181,14 +4148,13 @@
*/
SurfaceControl mSplitScreenDividerAnchor = null;
- // Cached reference to some special stacks we tend to get a lot so we don't need to loop
+ // Cached reference to some special tasks we tend to get a lot so we don't need to loop
// through the list to find them.
- private ActivityStack mHomeStack = null;
- private ActivityStack mRecentsStack = null;
- private ActivityStack mPinnedStack = null;
- private ActivityStack mSplitScreenPrimaryStack = null;
+ private ActivityStack mRootHomeTask = null;
+ private ActivityStack mRootPinnedTask = null;
+ private ActivityStack mRootSplitScreenPrimaryTask = null;
- TaskStackContainers(WindowManagerService service) {
+ TaskContainers(WindowManagerService service) {
super(service);
}
@@ -4198,15 +4164,15 @@
*/
ActivityStack getStack(int windowingMode, int activityType) {
if (activityType == ACTIVITY_TYPE_HOME) {
- return mHomeStack;
+ return mRootHomeTask;
}
if (windowingMode == WINDOWING_MODE_PINNED) {
- return mPinnedStack;
+ return mRootPinnedTask;
} else if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
- return mSplitScreenPrimaryStack;
+ return mRootSplitScreenPrimaryTask;
}
- for (int i = mTaskStackContainers.getChildCount() - 1; i >= 0; --i) {
- final ActivityStack stack = mTaskStackContainers.getChildAt(i);
+ for (int i = mTaskContainers.getChildCount() - 1; i >= 0; --i) {
+ final ActivityStack stack = mTaskContainers.getChildAt(i);
if (activityType == ACTIVITY_TYPE_UNDEFINED
&& windowingMode == stack.getWindowingMode()) {
// Passing in undefined type means we want to match the topmost stack with the
@@ -4222,31 +4188,27 @@
@VisibleForTesting
ActivityStack getTopStack() {
- return mTaskStackContainers.getChildCount() > 0
- ? mTaskStackContainers.getChildAt(mTaskStackContainers.getChildCount() - 1) : null;
+ return mTaskContainers.getChildCount() > 0
+ ? mTaskContainers.getChildAt(mTaskContainers.getChildCount() - 1) : null;
}
int getIndexOf(ActivityStack stack) {
- return mTaskStackContainers.mChildren.indexOf(stack);
+ return mTaskContainers.mChildren.indexOf(stack);
}
- ActivityStack getHomeStack() {
- if (mHomeStack == null && mDisplayId == DEFAULT_DISPLAY) {
+ ActivityStack getRootHomeTask() {
+ if (mRootHomeTask == null && mDisplayId == DEFAULT_DISPLAY) {
Slog.e(TAG_WM, "getHomeStack: Returning null from this=" + this);
}
- return mHomeStack;
+ return mRootHomeTask;
}
- ActivityStack getRecentsStack() {
- return mRecentsStack;
+ ActivityStack getRootPinnedTask() {
+ return mRootPinnedTask;
}
- ActivityStack getPinnedStack() {
- return mPinnedStack;
- }
-
- ActivityStack getSplitScreenPrimaryStack() {
- return mSplitScreenPrimaryStack;
+ ActivityStack getRootSplitScreenPrimaryTask() {
+ return mRootSplitScreenPrimaryTask;
}
ArrayList<Task> getVisibleTasks() {
@@ -4262,7 +4224,7 @@
void onStackWindowingModeChanged(ActivityStack stack) {
removeStackReferenceIfNeeded(stack);
addStackReferenceIfNeeded(stack);
- if (stack == mPinnedStack && getTopStack() != stack) {
+ if (stack == mRootPinnedTask && getTopStack() != stack) {
// Looks like this stack changed windowing mode to pinned. Move it to the top.
positionChildAt(POSITION_TOP, stack, false /* includingParents */);
}
@@ -4270,46 +4232,36 @@
private void addStackReferenceIfNeeded(ActivityStack stack) {
if (stack.isActivityTypeHome()) {
- if (mHomeStack != null) {
- if (!stack.isDescendantOf(mHomeStack)) {
+ if (mRootHomeTask != null) {
+ if (!stack.isDescendantOf(mRootHomeTask)) {
throw new IllegalArgumentException("addStackReferenceIfNeeded: home stack="
- + mHomeStack + " already exist on display=" + this
+ + mRootHomeTask + " already exist on display=" + this
+ " stack=" + stack);
}
} else {
- mHomeStack = stack;
- }
- } else if (stack.isActivityTypeRecents()) {
- if (mRecentsStack != null && mRecentsStack != stack) {
- if (!stack.isDescendantOf(mRecentsStack)) {
- throw new IllegalArgumentException(
- "addStackReferenceIfNeeded: recents stack=" + mRecentsStack
- + " already exist on display=" + this + " stack=" + stack);
- }
- } else {
- mRecentsStack = stack;
+ mRootHomeTask = stack;
}
}
final int windowingMode = stack.getWindowingMode();
if (windowingMode == WINDOWING_MODE_PINNED) {
- if (mPinnedStack != null) {
- if (!stack.isDescendantOf(mPinnedStack)) {
+ if (mRootPinnedTask != null) {
+ if (!stack.isDescendantOf(mRootPinnedTask)) {
throw new IllegalArgumentException(
- "addStackReferenceIfNeeded: pinned stack=" + mPinnedStack
+ "addStackReferenceIfNeeded: pinned stack=" + mRootPinnedTask
+ " already exist on display=" + this + " stack=" + stack);
}
} else {
- mPinnedStack = stack;
+ mRootPinnedTask = stack;
}
} else if (windowingMode == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
- if (mSplitScreenPrimaryStack != null) {
- if (!stack.isDescendantOf(mSplitScreenPrimaryStack)) {
+ if (mRootSplitScreenPrimaryTask != null) {
+ if (!stack.isDescendantOf(mRootSplitScreenPrimaryTask)) {
throw new IllegalArgumentException("addStackReferenceIfNeeded:"
- + " split-screen-primary" + " stack=" + mSplitScreenPrimaryStack
+ + " split-screen-primary" + " stack=" + mRootSplitScreenPrimaryTask
+ " already exist on display=" + this + " stack=" + stack);
}
} else {
- mSplitScreenPrimaryStack = stack;
+ mRootSplitScreenPrimaryTask = stack;
mDisplayContent.onSplitScreenModeActivated();
mDividerControllerLocked.notifyDockedStackExistsChanged(true);
}
@@ -4317,14 +4269,12 @@
}
void removeStackReferenceIfNeeded(ActivityStack stack) {
- if (stack == mHomeStack) {
- mHomeStack = null;
- } else if (stack == mRecentsStack) {
- mRecentsStack = null;
- } else if (stack == mPinnedStack) {
- mPinnedStack = null;
- } else if (stack == mSplitScreenPrimaryStack) {
- mSplitScreenPrimaryStack = null;
+ if (stack == mRootHomeTask) {
+ mRootHomeTask = null;
+ } else if (stack == mRootPinnedTask) {
+ mRootPinnedTask = null;
+ } else if (stack == mRootSplitScreenPrimaryTask) {
+ mRootSplitScreenPrimaryTask = null;
mDisplayContent.onSplitScreenModeDismissed();
// Re-set the split-screen create mode whenever the split-screen stack is removed.
mWmService.setDockedStackCreateStateLocked(
@@ -4426,9 +4376,9 @@
int minPosition = POSITION_BOTTOM;
if (stack.isAlwaysOnTop()) {
- if (hasPinnedStack()) {
+ if (hasPinnedTask()) {
// Always-on-top stacks go below the pinned stack.
- maxPosition = getStacks().indexOf(mPinnedStack) - 1;
+ maxPosition = getStacks().indexOf(mRootPinnedTask) - 1;
}
// Always-on-top stacks need to be above all other stacks.
minPosition = belowAlwaysOnTopPosition !=
@@ -4547,17 +4497,17 @@
}
@Override
- int getOrientation() {
+ int getOrientation(int candidate) {
if (isStackVisible(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY)) {
// Apps and their containers are not allowed to specify an orientation while the
// docked stack is visible...except for the home stack if the docked stack is
// minimized and it actually set something and the bounds is different from the
// display.
- if (mHomeStack != null && mHomeStack.isVisible()
+ if (mRootHomeTask != null && mRootHomeTask.isVisible()
&& mDividerControllerLocked.isMinimizedDock()
&& !(mDividerControllerLocked.isHomeStackResizable()
- && mHomeStack.matchParentBounds())) {
- final int orientation = mHomeStack.getOrientation();
+ && mRootHomeTask.matchParentBounds())) {
+ final int orientation = mRootHomeTask.getOrientation();
if (orientation != SCREEN_ORIENTATION_UNSET) {
return orientation;
}
@@ -4565,7 +4515,7 @@
return SCREEN_ORIENTATION_UNSPECIFIED;
}
- final int orientation = super.getOrientation();
+ final int orientation = super.getOrientation(candidate);
if (orientation != SCREEN_ORIENTATION_UNSET
&& orientation != SCREEN_ORIENTATION_BEHIND) {
ProtoLog.v(WM_DEBUG_ORIENTATION,
@@ -4738,7 +4688,7 @@
void assignChildLayers(SurfaceControl.Transaction t) {
mImeWindowsContainers.setNeedsLayer();
mBelowAppWindowsContainers.assignLayer(t, 0);
- mTaskStackContainers.assignLayer(t, 1);
+ mTaskContainers.assignLayer(t, 1);
mAboveAppWindowsContainers.assignLayer(t, 2);
final WindowState imeTarget = mInputMethodTarget;
@@ -4777,7 +4727,7 @@
// Above we have assigned layers to our children, now we ask them to assign
// layers to their children.
mBelowAppWindowsContainers.assignChildLayers(t);
- mTaskStackContainers.assignChildLayers(t);
+ mTaskContainers.assignChildLayers(t);
mAboveAppWindowsContainers.assignChildLayers(t);
mImeWindowsContainers.assignRelativeLayer(t, getSurfaceControl(), Integer.MAX_VALUE);
mImeWindowsContainers.assignChildLayers(t);
@@ -4790,7 +4740,7 @@
void addChildren() {
addChild(mBelowAppWindowsContainers, null);
- addChild(mTaskStackContainers, null);
+ addChild(mTaskContainers, null);
addChild(mAboveAppWindowsContainers, null);
addChild(mImeWindowsContainers, null);
}
@@ -4820,11 +4770,25 @@
token2.mOwnerCanManageAppTokens) ? -1 : 1;
private final Predicate<WindowState> mGetOrientingWindow = w -> {
- if (!w.isVisibleLw() || !w.mLegacyPolicyVisibilityAfterAnim) {
- return false;
+ final WindowManagerPolicy policy = mWmService.mPolicy;
+ if (policy.isKeyguardHostWindow(w.mAttrs)) {
+ if (mWmService.mKeyguardGoingAway) {
+ return false;
+ }
+ // Consider unoccluding only when all unknown visibilities have been
+ // resolved, as otherwise we just may be starting another occluding activity.
+ final boolean isUnoccluding =
+ mDisplayContent.mAppTransition.getAppTransition()
+ == TRANSIT_KEYGUARD_UNOCCLUDE
+ && mDisplayContent.mUnknownAppVisibilityController.allResolved();
+ // If keyguard is showing, or we're unoccluding, force the keyguard's orientation,
+ // even if SystemUI hasn't updated the attrs yet.
+ if (policy.isKeyguardShowingAndNotOccluded() || isUnoccluding) {
+ return true;
+ }
}
final int req = w.mAttrs.screenOrientation;
- if(req == SCREEN_ORIENTATION_UNSPECIFIED || req == SCREEN_ORIENTATION_BEHIND
+ if (req == SCREEN_ORIENTATION_UNSPECIFIED || req == SCREEN_ORIENTATION_BEHIND
|| req == SCREEN_ORIENTATION_UNSET) {
return false;
}
@@ -4851,39 +4815,27 @@
}
@Override
- int getOrientation() {
- final WindowManagerPolicy policy = mWmService.mPolicy;
+ int getOrientation(int candidate) {
// Find a window requesting orientation.
final WindowState win = getWindow(mGetOrientingWindow);
if (win != null) {
- final int req = win.mAttrs.screenOrientation;
- if (policy.isKeyguardHostWindow(win.mAttrs)) {
- mLastKeyguardForcedOrientation = req;
- if (mWmService.mKeyguardGoingAway) {
- // Keyguard can't affect the orientation if it is going away...
- mLastWindowForcedOrientation = SCREEN_ORIENTATION_UNSPECIFIED;
- return SCREEN_ORIENTATION_UNSET;
- }
- }
+ int req = win.mAttrs.screenOrientation;
ProtoLog.v(WM_DEBUG_ORIENTATION,
"%s forcing orientation to %d for display id=%d", win, req,
mDisplayId);
- return (mLastWindowForcedOrientation = req);
+ if (mWmService.mPolicy.isKeyguardHostWindow(win.mAttrs)) {
+ // SystemUI controls the Keyguard orientation asynchronously, and mAttrs may be
+ // stale. We record / use the last known override.
+ if (req != SCREEN_ORIENTATION_UNSET && req != SCREEN_ORIENTATION_UNSPECIFIED) {
+ mDisplayContent.mLastKeyguardForcedOrientation = req;
+ } else {
+ req = mDisplayContent.mLastKeyguardForcedOrientation;
+ }
+ }
+ return req;
}
-
- mLastWindowForcedOrientation = SCREEN_ORIENTATION_UNSPECIFIED;
-
- // Only allow force setting the orientation when all unknown visibilities have been
- // resolved, as otherwise we just may be starting another occluding activity.
- final boolean isUnoccluding =
- mAppTransition.getAppTransition() == TRANSIT_KEYGUARD_UNOCCLUDE
- && mUnknownAppVisibilityController.allResolved();
- if (policy.isKeyguardShowingAndNotOccluded() || isUnoccluding) {
- return mLastKeyguardForcedOrientation;
- }
-
- return SCREEN_ORIENTATION_UNSET;
+ return candidate;
}
@Override
@@ -4930,6 +4882,12 @@
}
@Override
+ int getOrientation(int candidate) {
+ // IME does not participate in orientation.
+ return candidate;
+ }
+
+ @Override
boolean forAllWindows(ToBooleanFunction<WindowState> callback,
boolean traverseTopToBottom) {
final DisplayContent dc = mDisplayContent;
@@ -4942,7 +4900,7 @@
private boolean skipImeWindowsDuringTraversal(DisplayContent dc) {
// We skip IME windows so they're processed just above their target, except
// in split-screen mode where we process the IME containers above the docked divider.
- return dc.mInputMethodTarget != null && !dc.hasSplitScreenPrimaryStack();
+ return dc.mInputMethodTarget != null && !dc.hasSplitScreenPrimaryTask();
}
/** Like {@link #forAllWindows}, but ignores {@link #skipImeWindowsDuringTraversal} */
@@ -5093,7 +5051,7 @@
}
void assignStackOrdering() {
- mTaskStackContainers.assignStackOrdering(getPendingTransaction());
+ mTaskContainers.assignStackOrdering(getPendingTransaction());
}
/**
@@ -5682,8 +5640,8 @@
if (currentFocusedStack != prevFocusedStack) {
mLastFocusedStack = prevFocusedStack;
EventLogTags.writeWmFocusedStack(mRootWindowContainer.mCurrentUser, mDisplayId,
- currentFocusedStack == null ? -1 : currentFocusedStack.getStackId(),
- mLastFocusedStack == null ? -1 : mLastFocusedStack.getStackId(),
+ currentFocusedStack == null ? -1 : currentFocusedStack.getRootTaskId(),
+ mLastFocusedStack == null ? -1 : mLastFocusedStack.getRootTaskId(),
updateLastFocusedStackReason);
}
}
@@ -5691,10 +5649,10 @@
onStackOrderChanged(stack);
}
- ActivityStack getStack(int stackId) {
+ ActivityStack getStack(int rootTaskId) {
for (int i = getStackCount() - 1; i >= 0; --i) {
final ActivityStack stack = getStackAt(i);
- if (stack.mStackId == stackId) {
+ if (stack.getRootTaskId() == rootTaskId) {
return stack;
}
}
@@ -6054,7 +6012,7 @@
} finally {
final ActivityStack topFullscreenStack =
getTopStackInWindowingMode(WINDOWING_MODE_FULLSCREEN);
- final ActivityStack homeStack = getHomeStack();
+ final ActivityStack homeStack = getRootHomeTask();
if (topFullscreenStack != null && homeStack != null && !isTopStack(homeStack)) {
// Whenever split-screen is dismissed we want the home stack directly behind the
// current top fullscreen stack so it shows up when the top stack is finished.
@@ -6072,7 +6030,7 @@
mAtmService.deferWindowLayout();
try {
// Adjust the windowing mode of any affected by split-screen to split-screen secondary.
- final ActivityStack splitScreenPrimaryStack = getSplitScreenPrimaryStack();
+ final ActivityStack splitScreenPrimaryStack = getRootSplitScreenPrimaryTask();
for (int i = getStackCount() - 1; i >= 0; --i) {
final ActivityStack otherStack = getStackAt(i);
if (otherStack == splitScreenPrimaryStack
@@ -6201,7 +6159,7 @@
}
}
- final boolean inSplitScreenMode = hasSplitScreenPrimaryStack();
+ final boolean inSplitScreenMode = hasSplitScreenPrimaryTask();
if (!inSplitScreenMode
&& windowingMode == WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY) {
// Switch to the display's windowing mode if we are not in split-screen mode and we are
@@ -6447,7 +6405,7 @@
// If default display is in split-window mode, set windowing mode of the stack
// to split-screen secondary. Otherwise, set the windowing mode to undefined by
// default to let stack inherited the windowing mode from the new display.
- final int windowingMode = toDisplay.hasSplitScreenPrimaryStack()
+ final int windowingMode = toDisplay.hasSplitScreenPrimaryTask()
? WINDOWING_MODE_SPLIT_SCREEN_SECONDARY
: WINDOWING_MODE_UNDEFINED;
stack.reparent(toDisplay, true /* onTop */);
@@ -6616,7 +6574,7 @@
}
void moveHomeStackToFront(String reason) {
- final ActivityStack homeStack = getHomeStack();
+ final ActivityStack homeStack = getRootHomeTask();
if (homeStack != null) {
homeStack.moveToFront(reason);
}
@@ -6642,7 +6600,7 @@
@Nullable
ActivityRecord getHomeActivityForUser(int userId) {
- final ActivityStack homeStack = getHomeStack();
+ final ActivityStack homeStack = getRootHomeTask();
if (homeStack == null) {
return null;
}
@@ -6731,7 +6689,7 @@
public void dumpStacks(PrintWriter pw) {
for (int i = getStackCount() - 1; i >= 0; --i) {
- pw.print(getStackAt(i).mStackId);
+ pw.print(getStackAt(i).getRootTaskId());
if (i > 0) {
pw.print(",");
}
diff --git a/services/core/java/com/android/server/wm/DisplayRotation.java b/services/core/java/com/android/server/wm/DisplayRotation.java
index b59c4e3..f90f224 100644
--- a/services/core/java/com/android/server/wm/DisplayRotation.java
+++ b/services/core/java/com/android/server/wm/DisplayRotation.java
@@ -582,7 +582,7 @@
// In the presence of the PINNED stack or System Alert windows we unfortunately can not
// seamlessly rotate.
- if (mDisplayContent.hasPinnedStack() || mDisplayContent.hasAlertWindowSurfaces()) {
+ if (mDisplayContent.hasPinnedTask() || mDisplayContent.hasAlertWindowSurfaces()) {
return false;
}
diff --git a/services/core/java/com/android/server/wm/DockedStackDividerController.java b/services/core/java/com/android/server/wm/DockedStackDividerController.java
index 6b5859d..872379e 100644
--- a/services/core/java/com/android/server/wm/DockedStackDividerController.java
+++ b/services/core/java/com/android/server/wm/DockedStackDividerController.java
@@ -255,7 +255,7 @@
}
boolean isHomeStackResizable() {
- final ActivityStack homeStack = mDisplayContent.getHomeStack();
+ final ActivityStack homeStack = mDisplayContent.getRootHomeTask();
if (homeStack == null) {
return false;
}
@@ -371,7 +371,7 @@
if (mWindow == null) {
return;
}
- ActivityStack stack = mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ ActivityStack stack = mDisplayContent.getRootSplitScreenPrimaryTask();
// If the stack is invisible, we policy force hide it in WindowAnimator.shouldForceHide
final boolean visible = stack != null;
@@ -415,7 +415,7 @@
}
void positionDockedStackedDivider(Rect frame) {
- ActivityStack stack = mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ ActivityStack stack = mDisplayContent.getRootSplitScreenPrimaryTask();
if (stack == null) {
// Unfortunately we might end up with still having a divider, even though the underlying
// stack was already removed. This is because we are on AM thread and the removal of the
@@ -524,7 +524,7 @@
// If a primary stack was just created, it will not have access to display content at
// this point so pass it from here to get a valid dock side.
final ActivityStack stack =
- mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ mDisplayContent.getRootSplitScreenPrimaryTask();
mOriginalDockedSide = stack.getDockSideForDisplay(mDisplayContent);
return;
}
@@ -560,7 +560,7 @@
long animDuration = 0;
if (animate) {
final ActivityStack stack =
- mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ mDisplayContent.getRootSplitScreenPrimaryTask();
final long transitionDuration = isAnimationMaximizing()
? mDisplayContent.mAppTransition.getLastClipRevealTransitionDuration()
: DEFAULT_APP_TRANSITION_DURATION;
@@ -615,7 +615,7 @@
mDockedStackListeners.register(listener);
notifyDockedDividerVisibilityChanged(wasVisible());
notifyDockedStackExistsChanged(
- mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility() != null);
+ mDisplayContent.getRootSplitScreenPrimaryTask() != null);
notifyDockedStackMinimizedChanged(mMinimizedDock, false /* animate */,
isHomeStackResizable());
notifyAdjustedForImeChanged(mAdjustedForIme, 0 /* animDuration */);
@@ -633,7 +633,7 @@
final ActivityStack stack = targetWindowingMode != WINDOWING_MODE_UNDEFINED
? mDisplayContent.getTopStackInWindowingMode(targetWindowingMode)
: null;
- final ActivityStack dockedStack = mDisplayContent.getSplitScreenPrimaryStack();
+ final ActivityStack dockedStack = mDisplayContent.getRootSplitScreenPrimaryTask();
boolean visibleAndValid = visible && stack != null && dockedStack != null;
// Ensure an old dim that was shown for the docked stack divider is removed so we don't end
@@ -701,10 +701,10 @@
}
void checkMinimizeChanged(boolean animate) {
- if (mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility() == null) {
+ if (mDisplayContent.getRootSplitScreenPrimaryTask() == null) {
return;
}
- final ActivityStack homeStack = mDisplayContent.getHomeStack();
+ final ActivityStack homeStack = mDisplayContent.getRootHomeTask();
if (homeStack == null) {
return;
}
@@ -873,7 +873,7 @@
}
private boolean setMinimizedDockedStack(boolean minimized) {
- final ActivityStack stack = mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ final ActivityStack stack = mDisplayContent.getRootSplitScreenPrimaryTask();
notifyDockedStackMinimizedChanged(minimized, false /* animate */, isHomeStackResizable());
return stack != null && stack.setAdjustedForMinimizedDock(minimized ? 1f : 0f);
}
@@ -923,7 +923,7 @@
}
private boolean animateForMinimizedDockedStack(long now) {
- final ActivityStack stack = mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ final ActivityStack stack = mDisplayContent.getRootSplitScreenPrimaryTask();
if (!mAnimationStarted) {
mAnimationStarted = true;
mAnimationStartTime = now;
diff --git a/services/core/java/com/android/server/wm/KeyguardController.java b/services/core/java/com/android/server/wm/KeyguardController.java
index 7db30f6..ad65e10 100644
--- a/services/core/java/com/android/server/wm/KeyguardController.java
+++ b/services/core/java/com/android/server/wm/KeyguardController.java
@@ -407,7 +407,7 @@
// stack since it will be complicated/risky to try to put the activity on top
// of the lock screen in the right fullscreen configuration.
final ActivityStack stack =
- mRootWindowContainer.getDefaultDisplay().getSplitScreenPrimaryStack();
+ mRootWindowContainer.getDefaultDisplay().getRootSplitScreenPrimaryTask();
if (stack == null) {
return;
}
diff --git a/services/core/java/com/android/server/wm/LaunchParamsController.java b/services/core/java/com/android/server/wm/LaunchParamsController.java
index 03e1322..a9820ef 100644
--- a/services/core/java/com/android/server/wm/LaunchParamsController.java
+++ b/services/core/java/com/android/server/wm/LaunchParamsController.java
@@ -138,7 +138,7 @@
try {
if (mTmpParams.hasPreferredDisplay()
&& mTmpParams.mPreferredDisplayId != task.getStack().getDisplay().mDisplayId) {
- mService.moveStackToDisplay(task.getStackId(), mTmpParams.mPreferredDisplayId);
+ mService.moveStackToDisplay(task.getRootTaskId(), mTmpParams.mPreferredDisplayId);
}
if (mTmpParams.hasWindowingMode()
diff --git a/services/core/java/com/android/server/wm/LaunchParamsPersister.java b/services/core/java/com/android/server/wm/LaunchParamsPersister.java
index f4e608e..660706e 100644
--- a/services/core/java/com/android/server/wm/LaunchParamsPersister.java
+++ b/services/core/java/com/android/server/wm/LaunchParamsPersister.java
@@ -197,6 +197,10 @@
}
void saveTask(Task task) {
+ saveTask(task, task.getDisplayContent());
+ }
+
+ void saveTask(Task task, DisplayContent display) {
final ComponentName name = task.realActivity;
final int userId = task.mUserId;
PersistableLaunchParams params;
@@ -211,7 +215,7 @@
params = new PersistableLaunchParams();
map.put(name, params);
}
- final boolean changed = saveTaskToLaunchParam(task, params);
+ final boolean changed = saveTaskToLaunchParam(task, display, params);
if (changed) {
mPersisterQueue.updateLastOrAddItem(
@@ -220,17 +224,16 @@
}
}
- private boolean saveTaskToLaunchParam(Task task, PersistableLaunchParams params) {
- final ActivityStack stack = task.getStack();
- final DisplayContent display = stack.getDisplayContent();
+ private boolean saveTaskToLaunchParam(
+ Task task, DisplayContent display, PersistableLaunchParams params) {
final DisplayInfo info = new DisplayInfo();
display.mDisplay.getDisplayInfo(info);
boolean changed = !Objects.equals(params.mDisplayUniqueId, info.uniqueId);
params.mDisplayUniqueId = info.uniqueId;
- changed |= params.mWindowingMode != stack.getWindowingMode();
- params.mWindowingMode = stack.getWindowingMode();
+ changed |= params.mWindowingMode != task.getWindowingMode();
+ params.mWindowingMode = task.getWindowingMode();
if (task.mLastNonFullscreenBounds != null) {
changed |= !Objects.equals(params.mBounds, task.mLastNonFullscreenBounds);
diff --git a/services/core/java/com/android/server/wm/PinnedStackController.java b/services/core/java/com/android/server/wm/PinnedStackController.java
index b4f75e5..1d5b5d1 100644
--- a/services/core/java/com/android/server/wm/PinnedStackController.java
+++ b/services/core/java/com/android/server/wm/PinnedStackController.java
@@ -125,7 +125,7 @@
public void startAnimation(Rect destinationBounds, Rect sourceRectHint,
int animationDuration) {
synchronized (mService.mGlobalLock) {
- final ActivityStack pinnedStack = mDisplayContent.getPinnedStack();
+ final ActivityStack pinnedStack = mDisplayContent.getRootPinnedTask();
pinnedStack.animateResizePinnedStack(destinationBounds,
sourceRectHint, animationDuration, true /* fromFullscreen */);
}
@@ -134,7 +134,7 @@
@Override
public void resetBoundsAnimation(Rect bounds) {
synchronized (mService.mGlobalLock) {
- if (mDisplayContent.hasPinnedStack()) {
+ if (mDisplayContent.hasPinnedTask()) {
final ActivityStack pinnedStack = mDisplayContent.getTopStackInWindowingMode(
WINDOWING_MODE_PINNED);
if (pinnedStack != null) {
@@ -383,7 +383,7 @@
}
try {
final Rect animatingBounds = new Rect();
- final ActivityStack pinnedStack = mDisplayContent.getPinnedStack();
+ final ActivityStack pinnedStack = mDisplayContent.getRootPinnedTask();
if (pinnedStack != null) {
pinnedStack.getAnimationOrCurrentBounds(animatingBounds);
}
diff --git a/services/core/java/com/android/server/wm/RecentTasks.java b/services/core/java/com/android/server/wm/RecentTasks.java
index e1dfc17..292e8aa 100644
--- a/services/core/java/com/android/server/wm/RecentTasks.java
+++ b/services/core/java/com/android/server/wm/RecentTasks.java
@@ -1387,7 +1387,7 @@
// Trim tasks that are in stacks that are behind the home stack
final DisplayContent display = stack.getDisplay();
- return display.getIndexOf(stack) < display.getIndexOf(display.getHomeStack());
+ return display.getIndexOf(stack) < display.getIndexOf(display.getRootHomeTask());
}
/**
diff --git a/services/core/java/com/android/server/wm/RecentsAnimationController.java b/services/core/java/com/android/server/wm/RecentsAnimationController.java
index 6148095..da9d074 100644
--- a/services/core/java/com/android/server/wm/RecentsAnimationController.java
+++ b/services/core/java/com/android/server/wm/RecentsAnimationController.java
@@ -413,7 +413,7 @@
// Save the minimized home height
final ActivityStack dockedStack =
- mDisplayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ mDisplayContent.getRootSplitScreenPrimaryTask();
mDisplayContent.getDockedDividerController().getHomeStackBoundsInDockedMode(
mDisplayContent.getConfiguration(),
dockedStack == null ? DOCKED_INVALID : dockedStack.getDockSide(),
diff --git a/services/core/java/com/android/server/wm/RootWindowContainer.java b/services/core/java/com/android/server/wm/RootWindowContainer.java
index 8202833..d3da500 100644
--- a/services/core/java/com/android/server/wm/RootWindowContainer.java
+++ b/services/core/java/com/android/server/wm/RootWindowContainer.java
@@ -1656,7 +1656,7 @@
// Only resume home activity if isn't finishing.
if (r != null && !r.finishing) {
r.moveFocusableActivityToTop(myReason);
- return resumeFocusedStacksTopActivities(r.getActivityStack(), prev, null);
+ return resumeFocusedStacksTopActivities(r.getRootTask(), prev, null);
}
return startHomeOnDisplay(mCurrentUser, myReason, displayId);
}
@@ -1980,9 +1980,9 @@
}
boolean switchUser(int userId, UserState uss) {
- final int focusStackId = getTopDisplayFocusedStack().getStackId();
+ final int focusStackId = getTopDisplayFocusedStack().getRootTaskId();
// We dismiss the docked stack whenever we switch users.
- final ActivityStack dockedStack = getDefaultDisplay().getSplitScreenPrimaryStack();
+ final ActivityStack dockedStack = getDefaultDisplay().getRootSplitScreenPrimaryTask();
if (dockedStack != null) {
mStackSupervisor.moveTasksToFullscreenStackLocked(
dockedStack, dockedStack.isFocusedStackOnDisplay());
@@ -1994,7 +1994,7 @@
mUserStackInFront.put(mCurrentUser, focusStackId);
final int restoreStackId =
- mUserStackInFront.get(userId, getDefaultDisplay().getHomeStack().mStackId);
+ mUserStackInFront.get(userId, getDefaultDisplay().getRootHomeTask().getRootTaskId());
mCurrentUser = userId;
mStackSupervisor.mStartingUsers.add(uss);
@@ -2012,7 +2012,7 @@
ActivityStack stack = getStack(restoreStackId);
if (stack == null) {
- stack = getDefaultDisplay().getHomeStack();
+ stack = getDefaultDisplay().getRootHomeTask();
}
final boolean homeInFront = stack.isActivityTypeHome();
if (stack.isOnHomeDisplay()) {
@@ -2034,8 +2034,8 @@
*/
void updateUserStack(int userId, ActivityStack stack) {
if (userId != mCurrentUser) {
- mUserStackInFront.put(userId, stack != null ? stack.getStackId()
- : getDefaultDisplay().getHomeStack().mStackId);
+ mUserStackInFront.put(userId, stack != null ? stack.getRootTaskId()
+ : getDefaultDisplay().getRootHomeTask().getRootTaskId());
}
}
@@ -2108,12 +2108,12 @@
String reason) {
mService.deferWindowLayout();
- final DisplayContent display = r.getActivityStack().getDisplay();
+ final DisplayContent display = r.getRootTask().getDisplay();
try {
final Task task = r.getTask();
- final ActivityStack pinnedStack = display.getPinnedStack();
+ final ActivityStack pinnedStack = display.getRootPinnedTask();
// This will change the pinned stack's windowing mode to its original mode, ensuring
// we only have one stack that is in pinned mode.
if (pinnedStack != null) {
@@ -2124,13 +2124,13 @@
final ActivityStack stack;
if (singleActivity) {
- stack = r.getActivityStack();
+ stack = r.getRootTask();
} else {
// In the case of multiple activities, we will create a new stack for it and then
// move the PIP activity into the stack.
// We will then perform a windowing mode change for both scenarios.
stack = display.createStack(
- r.getActivityStack().getRequestedOverrideWindowingMode(),
+ r.getRootTask().getRequestedOverrideWindowingMode(),
r.getActivityType(), ON_TOP, r.info, r.intent);
// There are multiple activities in the task and moving the top activity should
// reveal/leave the other activities in their original task.
@@ -2398,7 +2398,7 @@
ActivityManager.StackInfo info = new ActivityManager.StackInfo();
stack.getBounds(info.bounds);
info.displayId = display.mDisplayId;
- info.stackId = stack.mStackId;
+ info.stackId = stack.mTaskId;
info.stackToken = stack.mRemoteToken;
info.userId = stack.mCurrentUser;
info.visible = stack.shouldBeVisible(null);
@@ -2853,7 +2853,7 @@
stack = candidateTask.getStack();
}
if (stack == null && r != null) {
- stack = r.getActivityStack();
+ stack = r.getRootTask();
}
if (stack != null) {
display = stack.getDisplay();
@@ -2868,7 +2868,7 @@
return stack;
}
if (windowingMode == WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY
- && display.getSplitScreenPrimaryStack() == stack
+ && display.getRootSplitScreenPrimaryTask() == stack
&& candidateTask == stack.getTopMostTask()) {
// This is a special case when we try to launch an activity that is currently on
// top of split-screen primary stack, but is targeting split-screen secondary.
@@ -3244,7 +3244,7 @@
if (resumedActivity == null || !resumedActivity.idle) {
if (DEBUG_STATES) {
Slog.d(TAG_STATES, "allResumedActivitiesIdle: stack="
- + stack.mStackId + " " + resumedActivity + " not idle");
+ + stack.getRootTaskId() + " " + resumedActivity + " not idle");
}
return false;
}
@@ -3599,7 +3599,7 @@
// TODO(b/111541062): Update tests to look for resumed activities on all displays
final ActivityStack focusedStack = getTopDisplayFocusedStack();
if (focusedStack != null) {
- proto.write(FOCUSED_STACK_ID, focusedStack.mStackId);
+ proto.write(FOCUSED_STACK_ID, focusedStack.getRootTaskId());
final ActivityRecord focusedActivity = focusedStack.getDisplay().getResumedActivity();
if (focusedActivity != null) {
focusedActivity.writeIdentifierToProto(proto, RESUMED_ACTIVITY);
diff --git a/services/core/java/com/android/server/wm/Task.java b/services/core/java/com/android/server/wm/Task.java
index 9e6cb68..917b437 100644
--- a/services/core/java/com/android/server/wm/Task.java
+++ b/services/core/java/com/android/server/wm/Task.java
@@ -526,7 +526,7 @@
ActivityStack stack) {
super(atmService.mWindowManager);
- EventLogTags.writeWmTaskCreated(_taskId, stack != null ? stack.mStackId : INVALID_STACK_ID);
+ EventLogTags.writeWmTaskCreated(_taskId, stack != null ? getRootTaskId() : INVALID_TASK_ID);
mAtmService = atmService;
mStackSupervisor = atmService.mStackSupervisor;
mRootWindowContainer = mAtmService.mRootWindowContainer;
@@ -574,13 +574,19 @@
mAtmService.getTaskChangeNotificationController().notifyTaskCreated(_taskId, realActivity);
}
- private void cleanUpResourcesForDestroy() {
+ private void cleanUpResourcesForDestroy(ConfigurationContainer oldParent) {
if (hasChild()) {
return;
}
- // This task is going away, so save the last state if necessary.
- saveLaunchingStateIfNeeded();
+ // TODO(xutan): Removed type check after stack and task is merged.
+ // Before the real merge of stack and task, we need to avoid saving state of stacks. Once
+ // the merge is finished we can just pass DisplayContent because both windowing mode and
+ // bounds are set in the merged task.
+ if (oldParent instanceof ActivityStack) {
+ // This task is going away, so save the last state if necessary.
+ saveLaunchingStateIfNeeded(((WindowContainer) oldParent).getDisplayContent());
+ }
// TODO: VI what about activity?
final boolean isVoiceSession = voiceSession != null;
@@ -1053,9 +1059,8 @@
mPrevDisplayId = (oldDisplay != null) ? oldDisplay.mDisplayId : INVALID_DISPLAY;
- // Task is going to be removed, clean it up before detaching from hierarchy.
if (oldParent != null && newParent == null) {
- cleanUpResourcesForDestroy();
+ cleanUpResourcesForDestroy(oldParent);
}
if (display != null) {
@@ -1080,7 +1085,7 @@
// the display, so we should probably consolidate it there instead.
if (getParent() == null && mDisplayContent != null) {
- EventLogTags.writeWmStackRemoved(getStackId());
+ EventLogTags.writeWmStackRemoved(getRootTaskId());
mDisplayContent = null;
mWmService.mWindowPlacerLocked.requestTraversal();
}
@@ -1884,7 +1889,11 @@
* It only saves state if this task has been shown to user and it's in fullscreen or freeform
* mode on freeform displays.
*/
- void saveLaunchingStateIfNeeded() {
+ private void saveLaunchingStateIfNeeded() {
+ saveLaunchingStateIfNeeded(getDisplayContent());
+ }
+
+ private void saveLaunchingStateIfNeeded(DisplayContent display) {
if (!hasBeenVisible) {
// Not ever visible to user.
return;
@@ -1904,7 +1913,7 @@
}
// Saves the new state so that we can launch the activity at the same location.
- mStackSupervisor.mLaunchParamsPersister.saveTask(this);
+ mStackSupervisor.mLaunchParamsPersister.saveTask(this, display);
}
/**
@@ -2344,17 +2353,27 @@
return dc != null ? dc.mDisplayId : INVALID_DISPLAY;
}
+ // TODO: Migrate callers to getRootTask()
ActivityStack getStack() {
- final WindowContainer parent = getParent();
- return (ActivityStack) (parent instanceof ActivityStack ? parent : this);
+ return (ActivityStack) getRootTask();
}
- /**
- * @return Id of current stack, {@link ActivityTaskManager#INVALID_STACK_ID} if no stack is set.
- */
- int getStackId() {
- final ActivityStack stack = getStack();
- return stack != null ? stack.mStackId : INVALID_STACK_ID;
+ /** @return Id of root task. */
+ int getRootTaskId() {
+ return getRootTask().mTaskId;
+ }
+
+ Task getRootTask() {
+ final WindowContainer parent = getParent();
+ if (parent == null) return this;
+
+ final Task parentTask = parent.asTask();
+ return parentTask == null ? this : parentTask.getRootTask();
+ }
+
+ // TODO(task-merge): Figure out what's the right thing to do for places that used it.
+ boolean isRootTask() {
+ return getRootTask() == this;
}
int getDescendantTaskCount() {
@@ -2736,7 +2755,7 @@
// No need to check if the mode is allowed if it's leaving dragResize
if (dragResizing && !DragResizeMode.isModeAllowedForStack(getStack(), dragResizeMode)) {
throw new IllegalArgumentException("Drag resize mode not allow for stack stackId="
- + getStack().mStackId + " dragResizeMode=" + dragResizeMode);
+ + getRootTaskId() + " dragResizeMode=" + dragResizeMode);
}
mDragResizing = dragResizing;
mDragResizeMode = dragResizeMode;
@@ -3010,11 +3029,6 @@
return mTaskDescription;
}
- // TODO(task-merge): Figure out what's the right thing to do for places that used it.
- boolean isRootTask() {
- return getParent() == null || getParent().asTask() == null;
- }
-
@Override
boolean fillsParent() {
return matchParentBounds();
@@ -3167,7 +3181,7 @@
void fillTaskInfo(TaskInfo info) {
getNumRunningActivities(mReuseActivitiesReport);
info.userId = mUserId;
- info.stackId = getStackId();
+ info.stackId = getRootTaskId();
info.taskId = mTaskId;
info.displayId = getDisplayId();
info.isRunning = getTopNonFinishingActivity() != null;
@@ -3298,7 +3312,7 @@
if (mRootProcess != null) {
pw.print(prefix); pw.print("mRootProcess="); pw.println(mRootProcess);
}
- pw.print(prefix); pw.print("taskId=" + mTaskId); pw.println(" stackId=" + getStackId());
+ pw.print(prefix); pw.print("taskId=" + mTaskId); pw.println(" stackId=" + getRootTaskId());
pw.print(prefix + "hasBeenVisible=" + hasBeenVisible);
pw.print(" mResizeMode=" + ActivityInfo.resizeModeToString(mResizeMode));
pw.print(" mSupportsPictureInPicture=" + mSupportsPictureInPicture);
@@ -3315,7 +3329,7 @@
sb.append(" U=");
sb.append(mUserId);
sb.append(" StackId=");
- sb.append(getStackId());
+ sb.append(getRootTaskId());
sb.append(" sz=");
sb.append(getChildCount());
sb.append('}');
@@ -3358,7 +3372,7 @@
forAllActivities((r) -> {
r.dumpDebug(proto, ACTIVITIES);
});
- proto.write(STACK_ID, getStackId());
+ proto.write(STACK_ID, getRootTaskId());
if (mLastNonFullscreenBounds != null) {
mLastNonFullscreenBounds.dumpDebug(proto, LAST_NON_FULLSCREEN_BOUNDS);
}
diff --git a/services/core/java/com/android/server/wm/TaskChangeNotificationController.java b/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
index 688fe12..2dde0ba 100644
--- a/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
+++ b/services/core/java/com/android/server/wm/TaskChangeNotificationController.java
@@ -350,7 +350,7 @@
void notifyActivityPinned(ActivityRecord r) {
mHandler.removeMessages(NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG);
final Message msg = mHandler.obtainMessage(NOTIFY_ACTIVITY_PINNED_LISTENERS_MSG,
- r.getTask().mTaskId, r.getStackId(), r.packageName);
+ r.getTask().mTaskId, r.getRootTaskId(), r.packageName);
msg.sendingUid = r.mUserId;
forAllLocalListeners(mNotifyActivityPinned, msg);
msg.sendToTarget();
diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java
index 92cb948..81a4c68 100644
--- a/services/core/java/com/android/server/wm/WindowManagerService.java
+++ b/services/core/java/com/android/server/wm/WindowManagerService.java
@@ -3163,7 +3163,7 @@
// Notify whether the docked stack exists for the current user
final DisplayContent displayContent = getDefaultDisplayContentLocked();
final ActivityStack stack =
- displayContent.getSplitScreenPrimaryStackIgnoringVisibility();
+ displayContent.getRootSplitScreenPrimaryTask();
displayContent.mDividerControllerLocked.notifyDockedStackExistsChanged(
stack != null && stack.hasTaskForUser(newUserId));
@@ -5998,12 +5998,10 @@
pw.print(" apps="); pw.print(mAppsFreezingScreen);
final DisplayContent defaultDisplayContent = getDefaultDisplayContentLocked();
pw.print(" mRotation="); pw.print(defaultDisplayContent.getRotation());
- pw.print(" mLastWindowForcedOrientation=");
- pw.print(defaultDisplayContent.getLastWindowForcedOrientation());
- pw.print(" mLastOrientation=");
- pw.println(defaultDisplayContent.getLastOrientation());
- pw.print(" waitingForConfig=");
- pw.println(defaultDisplayContent.mWaitingForConfig);
+ pw.print(" mLastOrientation=");
+ pw.println(defaultDisplayContent.getLastOrientation());
+ pw.print(" waitingForConfig=");
+ pw.println(defaultDisplayContent.mWaitingForConfig);
pw.print(" Animation settings: disabled="); pw.print(mAnimationsDisabled);
pw.print(" window="); pw.print(mWindowAnimationScaleSetting);
@@ -6416,7 +6414,7 @@
public int getDockedStackSide() {
synchronized (mGlobalLock) {
final ActivityStack dockedStack = getDefaultDisplayContentLocked()
- .getSplitScreenPrimaryStackIgnoringVisibility();
+ .getRootSplitScreenPrimaryTask();
return dockedStack == null ? DOCKED_INVALID : dockedStack.getDockSide();
}
}
diff --git a/services/core/java/com/android/server/wm/WindowProcessController.java b/services/core/java/com/android/server/wm/WindowProcessController.java
index c755e60..87b04b2 100644
--- a/services/core/java/com/android/server/wm/WindowProcessController.java
+++ b/services/core/java/com/android/server/wm/WindowProcessController.java
@@ -179,6 +179,8 @@
// Last configuration that was reported to the process.
private final Configuration mLastReportedConfiguration;
+ // Configuration that is waiting to be dispatched to the process.
+ private Configuration mPendingConfiguration;
private final Configuration mNewOverrideConfig = new Configuration();
// Registered display id as a listener to override config change
private int mDisplayId;
@@ -618,15 +620,15 @@
// Compare the z-order of ActivityStacks if both activities landed on same display.
if (display == topDisplay
- && mPreQTopResumedActivity.getActivityStack().compareTo(
- activity.getActivityStack()) <= 0) {
+ && mPreQTopResumedActivity.getRootTask().compareTo(
+ activity.getRootTask()) <= 0) {
canUpdate = true;
}
if (canUpdate) {
// Make sure the previous top activity in the process no longer be resumed.
if (mPreQTopResumedActivity != null && mPreQTopResumedActivity.isState(RESUMED)) {
- final ActivityStack stack = mPreQTopResumedActivity.getActivityStack();
+ final ActivityStack stack = mPreQTopResumedActivity.getRootTask();
if (stack != null) {
stack.startPausingLocked(false /* userLeaving */, false /* uiSleeping */,
activity);
@@ -1073,24 +1075,38 @@
return;
}
- try {
- if (mThread == null) {
- if (Build.IS_DEBUGGABLE && mIsImeProcess) {
- // TODO (b/135719017): Temporary log for debugging IME service.
- Slog.w(TAG_CONFIGURATION, "Unable to send config for IME proc " + mName
- + ": no app thread");
- }
- return;
+ if (mListener.isCached()) {
+ // This process is in a cached state. We will delay delivering the config change to the
+ // process until the process is no longer cached.
+ if (mPendingConfiguration == null) {
+ mPendingConfiguration = new Configuration(config);
+ } else {
+ mPendingConfiguration.setTo(config);
}
- if (DEBUG_CONFIGURATION) {
- Slog.v(TAG_CONFIGURATION, "Sending to proc " + mName
- + " new config " + config);
- }
+ return;
+ }
+
+ dispatchConfigurationChange(config);
+ }
+
+ private void dispatchConfigurationChange(Configuration config) {
+ if (mThread == null) {
if (Build.IS_DEBUGGABLE && mIsImeProcess) {
// TODO (b/135719017): Temporary log for debugging IME service.
- Slog.v(TAG_CONFIGURATION, "Sending to IME proc " + mName
- + " new config " + config);
+ Slog.w(TAG_CONFIGURATION, "Unable to send config for IME proc " + mName
+ + ": no app thread");
}
+ return;
+ }
+ if (DEBUG_CONFIGURATION) {
+ Slog.v(TAG_CONFIGURATION, "Sending to proc " + mName + " new config " + config);
+ }
+ if (Build.IS_DEBUGGABLE && mIsImeProcess) {
+ // TODO (b/135719017): Temporary log for debugging IME service.
+ Slog.v(TAG_CONFIGURATION, "Sending to IME proc " + mName + " new config " + config);
+ }
+
+ try {
config.seq = mAtm.increaseConfigurationSeqLocked();
mAtm.getLifecycleManager().scheduleTransaction(mThread,
ConfigurationChangeItem.obtain(config));
@@ -1190,6 +1206,21 @@
return false;
}
+ /**
+ * Called to notify WindowProcessController of a change in the process's cached state.
+ *
+ * @param isCached whether or not the process is cached.
+ */
+ public void onProcCachedStateChanged(boolean isCached) {
+ synchronized (mAtm.mGlobalLock) {
+ if (!isCached && mPendingConfiguration != null) {
+ final Configuration config = mPendingConfiguration;
+ mPendingConfiguration = null;
+ dispatchConfigurationChange(config);
+ }
+ }
+ }
+
@HotPath(caller = HotPath.OOM_ADJUSTMENT)
public void onTopProcChanged() {
synchronized (mAtm.mGlobalLockWithoutBoost) {
diff --git a/services/core/java/com/android/server/wm/WindowProcessListener.java b/services/core/java/com/android/server/wm/WindowProcessListener.java
index 9505191..88c215b 100644
--- a/services/core/java/com/android/server/wm/WindowProcessListener.java
+++ b/services/core/java/com/android/server/wm/WindowProcessListener.java
@@ -51,6 +51,11 @@
*/
boolean isRemoved();
+ /**
+ * Returns true if the process is in a cached state.
+ */
+ boolean isCached();
+
/** Returns the total time (in milliseconds) spent executing in both user and system code. */
long getCpuTime();
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index 2965764..73984fd 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -16,7 +16,7 @@
package com.android.server.wm;
-import static android.app.ActivityTaskManager.INVALID_STACK_ID;
+import static android.app.ActivityTaskManager.INVALID_TASK_ID;
import static android.app.AppOpsManager.MODE_ALLOWED;
import static android.app.AppOpsManager.MODE_DEFAULT;
import static android.app.AppOpsManager.OP_NONE;
@@ -1055,7 +1055,7 @@
}
}
- final ActivityStack stack = getStack();
+ final ActivityStack stack = getRootTask();
if (inPinnedWindowingMode() && stack != null
&& stack.lastAnimatingBoundsWasToFullscreen()) {
// PIP edge case: When going from pinned to fullscreen, we apply a
@@ -1469,17 +1469,15 @@
return mActivityRecord != null ? mActivityRecord.getTask() : null;
}
- ActivityStack getStack() {
- Task task = getTask();
+ ActivityStack getRootTask() {
+ final Task task = getTask();
if (task != null) {
- if (task.getStack() != null) {
- return task.getStack();
- }
+ return (ActivityStack) task.getRootTask();
}
// Some system windows (e.g. "Power off" dialog) don't have a task, but we would still
// associate them with some stack to enable dimming.
final DisplayContent dc = getDisplayContent();
- return mAttrs.type >= FIRST_SYSTEM_WINDOW && dc != null ? dc.getHomeStack() : null;
+ return mAttrs.type >= FIRST_SYSTEM_WINDOW && dc != null ? dc.getRootHomeTask() : null;
}
/**
@@ -2229,7 +2227,7 @@
return false;
}
- final ActivityStack stack = getStack();
+ final ActivityStack stack = getRootTask();
if (stack != null && stack.shouldIgnoreInput()) {
// Ignore when the stack shouldn't receive input event.
// (i.e. the minimized stack in split screen mode.)
@@ -2472,7 +2470,7 @@
if (task != null) {
task.getDimBounds(mTmpRect);
} else {
- getStack().getDimBounds(mTmpRect);
+ getRootTask().getDimBounds(mTmpRect);
}
}
if (inFreeformWindowingMode()) {
@@ -2653,7 +2651,7 @@
// also reset drag resizing state, because the owner can't do it
// anymore.
final ActivityStack stack =
- dc.getSplitScreenPrimaryStackIgnoringVisibility();
+ dc.getRootSplitScreenPrimaryTask();
if (stack != null) {
stack.resetDockedStackToMiddle();
}
@@ -3563,12 +3561,12 @@
return mTmpRect;
}
- private int getStackId() {
- final ActivityStack stack = getStack();
+ private int getRootTaskId() {
+ final ActivityStack stack = getRootTask();
if (stack == null) {
- return INVALID_STACK_ID;
+ return INVALID_TASK_ID;
}
- return stack.mStackId;
+ return stack.mTaskId;
}
private void dispatchResized(Rect frame, Rect contentInsets,
@@ -3753,7 +3751,7 @@
super.dumpDebug(proto, WINDOW_CONTAINER, logLevel);
writeIdentifierToProto(proto, IDENTIFIER);
proto.write(DISPLAY_ID, getDisplayId());
- proto.write(STACK_ID, getStackId());
+ proto.write(STACK_ID, getRootTaskId());
mAttrs.dumpDebug(proto, ATTRIBUTES);
mGivenContentInsets.dumpDebug(proto, GIVEN_CONTENT_INSETS);
mWindowFrames.dumpDebug(proto, WINDOW_FRAMES);
@@ -3795,10 +3793,9 @@
@Override
void dump(PrintWriter pw, String prefix, boolean dumpAll) {
- final ActivityStack stack = getStack();
pw.print(prefix + "mDisplayId=" + getDisplayId());
- if (stack != null) {
- pw.print(" stackId=" + stack.mStackId);
+ if (getRootTask() != null) {
+ pw.print(" rootTaskId=" + getRootTaskId());
}
pw.println(" mSession=" + mSession
+ " mClient=" + mClient.asBinder());
@@ -5271,7 +5268,7 @@
outPoint.offset(-parentBounds.left, -parentBounds.top);
}
- ActivityStack stack = getStack();
+ ActivityStack stack = getRootTask();
// If we have stack outsets, that means the top-left
// will be outset, and we need to inset ourselves
diff --git a/services/core/java/com/android/server/wm/WindowStateAnimator.java b/services/core/java/com/android/server/wm/WindowStateAnimator.java
index 6189fbd..069ee4f 100644
--- a/services/core/java/com/android/server/wm/WindowStateAnimator.java
+++ b/services/core/java/com/android/server/wm/WindowStateAnimator.java
@@ -1013,7 +1013,7 @@
mSurfaceController.deferTransactionUntil(mSurfaceController.mSurfaceControl,
mWin.getFrameNumber());
} else {
- final ActivityStack stack = mWin.getStack();
+ final ActivityStack stack = mWin.getRootTask();
mTmpPos.x = 0;
mTmpPos.y = 0;
if (stack != null) {
diff --git a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
index 4b90027..e939d84 100644
--- a/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
+++ b/services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java
@@ -9102,11 +9102,16 @@
}
private void enforceAcrossUsersPermissions() {
- if (isCallerWithSystemUid() || mInjector.binderGetCallingUid() == Process.ROOT_UID) {
+ final int callingUid = mInjector.binderGetCallingUid();
+ final int callingPid = mInjector.binderGetCallingPid();
+ final String packageName = mContext.getPackageName();
+
+ if (isCallerWithSystemUid() || callingUid == Process.ROOT_UID) {
return;
}
- if (mContext.checkCallingPermission(permission.INTERACT_ACROSS_PROFILES)
- == PackageManager.PERMISSION_GRANTED) {
+ if (PermissionChecker.checkPermissionForPreflight(
+ mContext, permission.INTERACT_ACROSS_PROFILES, callingPid, callingUid,
+ packageName) == PermissionChecker.PERMISSION_GRANTED) {
return;
}
if (mContext.checkCallingPermission(permission.INTERACT_ACROSS_USERS)
diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java
index 66d1407..0b7c359 100644
--- a/services/java/com/android/server/SystemServer.java
+++ b/services/java/com/android/server/SystemServer.java
@@ -1769,7 +1769,7 @@
if (!isWatch && !disableNetworkTime) {
t.traceBegin("StartNetworkTimeUpdateService");
try {
- networkTimeUpdater = new NetworkTimeUpdateServiceImpl(context);
+ networkTimeUpdater = new NetworkTimeUpdateService(context);
ServiceManager.addService("network_time_update_service", networkTimeUpdater);
} catch (Throwable e) {
reportWtf("starting NetworkTimeUpdate service", e);
diff --git a/services/robotests/src/com/android/server/pm/CrossProfileAppsServiceImplRoboTest.java b/services/robotests/src/com/android/server/pm/CrossProfileAppsServiceImplRoboTest.java
index ce088643..96ff9c1 100644
--- a/services/robotests/src/com/android/server/pm/CrossProfileAppsServiceImplRoboTest.java
+++ b/services/robotests/src/com/android/server/pm/CrossProfileAppsServiceImplRoboTest.java
@@ -79,6 +79,7 @@
@Config(shadows = {ShadowUserManager.class, ShadowApplicationPackageManager.class})
public class CrossProfileAppsServiceImplRoboTest {
private static final int CALLING_UID = 1111;
+ private static final int CALLING_PID = 1000;
private static final String CROSS_PROFILE_APP_PACKAGE_NAME =
"com.android.server.pm.crossprofileappsserviceimplrobotest.crossprofileapp";
private static final int PERSONAL_PROFILE_USER_ID = 0;
@@ -383,6 +384,11 @@
}
@Override
+ public int getCallingPid() {
+ return CALLING_PID;
+ }
+
+ @Override
public @UserIdInt int getCallingUserId() {
return PERSONAL_PROFILE_USER_ID;
}
diff --git a/services/tests/mockingservicestests/src/com/android/server/am/MockingOomAdjusterTests.java b/services/tests/mockingservicestests/src/com/android/server/am/MockingOomAdjusterTests.java
index 4635c08..fc2ae40 100644
--- a/services/tests/mockingservicestests/src/com/android/server/am/MockingOomAdjusterTests.java
+++ b/services/tests/mockingservicestests/src/com/android/server/am/MockingOomAdjusterTests.java
@@ -546,7 +546,7 @@
public void testUpdateOomAdj_DoOne_NonCachedToCached() {
ProcessRecord app = spy(makeDefaultProcessRecord(MOCKAPP_PID, MOCKAPP_UID,
MOCKAPP_PROCESSNAME, MOCKAPP_PACKAGENAME, false));
- app.cached = false;
+ app.setCached(false);
app.setCurRawAdj(SERVICE_ADJ);
doReturn(null).when(sService).getTopAppLocked();
sService.mWakefulness = PowerManagerInternal.WAKEFULNESS_AWAKE;
@@ -1662,7 +1662,7 @@
}
app.lastProviderTime = lastProviderTime;
app.lastTopTime = lastTopTime;
- app.cached = cached;
+ app.setCached(cached);
for (int i = 0; i < numOfExecutingServices; i++) {
app.executingServices.add(mock(ServiceRecord.class));
}
diff --git a/services/tests/servicestests/src/com/android/server/devicepolicy/DevicePolicyManagerTest.java b/services/tests/servicestests/src/com/android/server/devicepolicy/DevicePolicyManagerTest.java
index 43e9570..aeba488 100644
--- a/services/tests/servicestests/src/com/android/server/devicepolicy/DevicePolicyManagerTest.java
+++ b/services/tests/servicestests/src/com/android/server/devicepolicy/DevicePolicyManagerTest.java
@@ -5711,6 +5711,7 @@
public void testGetAllCrossProfilePackages_notSet_returnsEmpty() throws Exception {
addManagedProfile(admin1, mServiceContext.binder.callingUid, admin1);
+ mContext.packageName = admin1.getPackageName();
setCrossProfileAppsList();
@@ -5720,6 +5721,7 @@
public void testGetAllCrossProfilePackages_notSet_dpmsReinitialized_returnsEmpty()
throws Exception {
addManagedProfile(admin1, mServiceContext.binder.callingUid, admin1);
+ mContext.packageName = admin1.getPackageName();
setCrossProfileAppsList();
initializeDpms();
@@ -5730,6 +5732,7 @@
public void testGetAllCrossProfilePackages_whenSet_returnsCombinedSet() throws Exception {
addManagedProfile(admin1, mServiceContext.binder.callingUid, admin1);
final Set<String> packages = Sets.newSet("TEST_PACKAGE", "TEST_COMMON_PACKAGE");
+ mContext.packageName = admin1.getPackageName();
dpm.setCrossProfilePackages(admin1, packages);
setCrossProfileAppsList("TEST_DEFAULT_PACKAGE", "TEST_COMMON_PACKAGE");
@@ -5744,6 +5747,7 @@
throws Exception {
addManagedProfile(admin1, mServiceContext.binder.callingUid, admin1);
final Set<String> packages = Sets.newSet("TEST_PACKAGE", "TEST_COMMON_PACKAGE");
+ mContext.packageName = admin1.getPackageName();
dpm.setCrossProfilePackages(admin1, packages);
setCrossProfileAppsList("TEST_DEFAULT_PACKAGE", "TEST_COMMON_PACKAGE");
diff --git a/services/tests/servicestests/src/com/android/server/devicepolicy/DpmMockContext.java b/services/tests/servicestests/src/com/android/server/devicepolicy/DpmMockContext.java
index 960f670..6cf6b67 100644
--- a/services/tests/servicestests/src/com/android/server/devicepolicy/DpmMockContext.java
+++ b/services/tests/servicestests/src/com/android/server/devicepolicy/DpmMockContext.java
@@ -219,6 +219,8 @@
return mMockSystemServices.accountManager;
case Context.TELEPHONY_SERVICE:
return mMockSystemServices.telephonyManager;
+ case Context.APP_OPS_SERVICE:
+ return mMockSystemServices.appOpsManager;
}
throw new UnsupportedOperationException();
}
@@ -256,6 +258,22 @@
}
@Override
+ public int checkPermission(String permission, int pid, int uid) {
+ if (UserHandle.isSameApp(binder.getCallingUid(), SYSTEM_UID)) {
+ return PackageManager.PERMISSION_GRANTED; // Assume system has all permissions.
+ }
+ List<String> permissions = binder.callingPermissions.get(binder.getCallingUid());
+ if (permissions == null) {
+ permissions = callerPermissions;
+ }
+ if (permissions.contains(permission)) {
+ return PackageManager.PERMISSION_GRANTED;
+ } else {
+ return PackageManager.PERMISSION_DENIED;
+ }
+ }
+
+ @Override
public void sendBroadcast(Intent intent) {
spiedContext.sendBroadcast(intent);
}
diff --git a/services/tests/servicestests/src/com/android/server/devicepolicy/MockSystemServices.java b/services/tests/servicestests/src/com/android/server/devicepolicy/MockSystemServices.java
index 068daf5..b9fb1aa 100644
--- a/services/tests/servicestests/src/com/android/server/devicepolicy/MockSystemServices.java
+++ b/services/tests/servicestests/src/com/android/server/devicepolicy/MockSystemServices.java
@@ -28,6 +28,7 @@
import android.accounts.AccountManager;
import android.app.ActivityManagerInternal;
import android.app.AlarmManager;
+import android.app.AppOpsManager;
import android.app.IActivityManager;
import android.app.IActivityTaskManager;
import android.app.NotificationManager;
@@ -120,6 +121,7 @@
public final TimeZoneDetector timeZoneDetector;
public final KeyChain.KeyChainConnection keyChainConnection;
public final PersistentDataBlockManagerInternal persistentDataBlockManagerInternal;
+ public final AppOpsManager appOpsManager;
/** Note this is a partial mock, not a real mock. */
public final PackageManager packageManager;
public final BuildMock buildMock = new BuildMock();
@@ -164,6 +166,7 @@
timeZoneDetector = mock(TimeZoneDetector.class);
keyChainConnection = mock(KeyChain.KeyChainConnection.class, RETURNS_DEEP_STUBS);
persistentDataBlockManagerInternal = mock(PersistentDataBlockManagerInternal.class);
+ appOpsManager = mock(AppOpsManager.class);
// Package manager is huge, so we use a partial mock instead.
packageManager = spy(realContext.getPackageManager());
diff --git a/services/tests/servicestests/src/com/android/server/pm/CrossProfileAppsServiceImplTest.java b/services/tests/servicestests/src/com/android/server/pm/CrossProfileAppsServiceImplTest.java
index 68f60b4..91cc9f3 100644
--- a/services/tests/servicestests/src/com/android/server/pm/CrossProfileAppsServiceImplTest.java
+++ b/services/tests/servicestests/src/com/android/server/pm/CrossProfileAppsServiceImplTest.java
@@ -27,6 +27,7 @@
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageManagerInternal;
+import android.content.pm.PermissionInfo;
import android.content.pm.ResolveInfo;
import android.os.Bundle;
import android.os.UserHandle;
@@ -95,6 +96,7 @@
public void initCrossProfileAppsServiceImpl() {
mTestInjector = new TestInjector();
mCrossProfileAppsServiceImpl = new CrossProfileAppsServiceImpl(mContext, mTestInjector);
+ when(mContext.getPackageManager()).thenReturn(mPackageManager);
}
@Before
@@ -365,6 +367,11 @@
@Test
public void startAnyActivityAsUser_profile_notExported() {
+ try {
+ when(mPackageManager.getPermissionInfo(anyString(), anyInt()))
+ .thenReturn(new PermissionInfo());
+ } catch (PackageManager.NameNotFoundException ignored) {
+ }
mActivityInfo.exported = false;
assertThrows(
@@ -523,11 +530,16 @@
private class TestInjector implements CrossProfileAppsServiceImpl.Injector {
private int mCallingUid;
private int mCallingUserId;
+ private int mCallingPid;
public void setCallingUid(int uid) {
mCallingUid = uid;
}
+ public void setCallingPid(int pid) {
+ mCallingPid = pid;
+ }
+
public void setCallingUserId(int userId) {
mCallingUserId = userId;
}
@@ -538,6 +550,11 @@
}
@Override
+ public int getCallingPid() {
+ return mCallingPid;
+ }
+
+ @Override
public int getCallingUserId() {
return mCallingUserId;
}
diff --git a/services/tests/uiservicestests/src/com/android/server/UiModeManagerServiceTest.java b/services/tests/uiservicestests/src/com/android/server/UiModeManagerServiceTest.java
index 03c10f3..22046a5 100644
--- a/services/tests/uiservicestests/src/com/android/server/UiModeManagerServiceTest.java
+++ b/services/tests/uiservicestests/src/com/android/server/UiModeManagerServiceTest.java
@@ -16,38 +16,54 @@
package com.android.server;
+import android.app.AlarmManager;
import android.app.IUiModeManager;
import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.content.res.Configuration;
import android.content.res.Resources;
+import android.os.Handler;
import android.os.PowerManager;
import android.os.RemoteException;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import com.android.server.twilight.TwilightManager;
+import com.android.server.twilight.TwilightState;
import com.android.server.wm.WindowManagerInternal;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
-import java.util.HashSet;
-import java.util.Set;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
import static android.app.UiModeManager.MODE_NIGHT_AUTO;
+import static android.app.UiModeManager.MODE_NIGHT_CUSTOM;
import static android.app.UiModeManager.MODE_NIGHT_NO;
import static android.app.UiModeManager.MODE_NIGHT_YES;
import static junit.framework.TestCase.assertFalse;
import static junit.framework.TestCase.assertTrue;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.notNull;
import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
@RunWith(AndroidTestingRunner.class)
@TestableLooper.RunWithLooper
@@ -66,22 +82,51 @@
TwilightManager mTwilightManager;
@Mock
PowerManager.WakeLock mWakeLock;
- private Set<BroadcastReceiver> mScreenOffRecievers;
+ @Mock
+ AlarmManager mAlarmManager;
+ @Mock
+ PowerManager mPowerManager;
+ @Mock
+ TwilightState mTwilightState;
+
+ private BroadcastReceiver mScreenOffCallback;
+ private BroadcastReceiver mTimeChangedCallback;
+ private AlarmManager.OnAlarmListener mCustomListener;
@Before
public void setUp() {
- mUiManagerService = new UiModeManagerService(mContext, mWindowManager, mWakeLock,
- mTwilightManager, true);
- mScreenOffRecievers = new HashSet<>();
+ initMocks(this);
+ mUiManagerService = new UiModeManagerService(mContext,
+ mWindowManager, mAlarmManager, mPowerManager,
+ mWakeLock, mTwilightManager, true);
mService = mUiManagerService.getService();
when(mContext.checkCallingOrSelfPermission(anyString()))
.thenReturn(PackageManager.PERMISSION_GRANTED);
when(mContext.getResources()).thenReturn(mResources);
when(mContext.getContentResolver()).thenReturn(mContentResolver);
- when(mContext.registerReceiver(any(), any())).then(inv -> {
- mScreenOffRecievers.add(inv.getArgument(0));
+ when(mPowerManager.isInteractive()).thenReturn(true);
+ when(mTwilightManager.getLastTwilightState()).thenReturn(mTwilightState);
+ when(mTwilightState.isNight()).thenReturn(true);
+ when(mContext.registerReceiver(notNull(), notNull())).then(inv -> {
+ IntentFilter filter = inv.getArgument(1);
+ if (filter.hasAction(Intent.ACTION_TIMEZONE_CHANGED)) {
+ mTimeChangedCallback = inv.getArgument(0);
+ }
+ if (filter.hasAction(Intent.ACTION_SCREEN_OFF)) {
+ mScreenOffCallback = inv.getArgument(0);
+ }
return null;
});
+ doAnswer(inv -> {
+ mCustomListener = inv.getArgument(3);
+ return null;
+ }).when(mAlarmManager).setExact(anyInt(), anyLong(), anyString(),
+ any(AlarmManager.OnAlarmListener.class), any(Handler.class));
+
+ doAnswer(inv -> {
+ mCustomListener = () -> {};
+ return null;
+ }).when(mAlarmManager).cancel(eq(mCustomListener));
}
@Test
@@ -102,7 +147,7 @@
mService.setNightMode(MODE_NIGHT_NO);
} catch (SecurityException e) { /*we should ignore this update config exception*/ }
given(mContext.registerReceiver(any(), any())).willThrow(SecurityException.class);
- verify(mContext).unregisterReceiver(any(BroadcastReceiver.class));
+ verify(mContext, atLeastOnce()).unregisterReceiver(any(BroadcastReceiver.class));
}
@Test
@@ -165,6 +210,132 @@
assertFalse(isNightModeActivated());
}
+ @Test
+ public void customTime_darkThemeOn() throws RemoteException {
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_NO);
+ mService.setCustomNightModeStart(now.minusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.plusHours(1L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertTrue(isNightModeActivated());
+ }
+
+ @Test
+ public void customTime_darkThemeOff() throws RemoteException {
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_YES);
+ mService.setCustomNightModeStart(now.plusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.minusHours(1L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertFalse(isNightModeActivated());
+ }
+
+ @Test
+ public void customTime_darkThemeOff_afterStartEnd() throws RemoteException {
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_YES);
+ mService.setCustomNightModeStart(now.plusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.plusHours(2L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertFalse(isNightModeActivated());
+ }
+
+ @Test
+ public void customTime_darkThemeOn_afterStartEnd() throws RemoteException {
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_YES);
+ mService.setCustomNightModeStart(now.plusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.plusHours(2L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertFalse(isNightModeActivated());
+ }
+
+
+
+ @Test
+ public void customTime_darkThemeOn_beforeStartEnd() throws RemoteException {
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_YES);
+ mService.setCustomNightModeStart(now.minusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.minusHours(2L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertTrue(isNightModeActivated());
+ }
+
+ @Test
+ public void customTime_darkThemeOff_beforeStartEnd() throws RemoteException {
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_YES);
+ mService.setCustomNightModeStart(now.minusHours(2L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.minusHours(1L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertFalse(isNightModeActivated());
+ }
+
+ @Test
+ public void customTIme_customAlarmSetWhenScreenTimeChanges() throws RemoteException {
+ when(mPowerManager.isInteractive()).thenReturn(false);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ verify(mAlarmManager, times(1))
+ .setExact(anyInt(), anyLong(), anyString(), any(), any());
+ mTimeChangedCallback.onReceive(mContext, new Intent(Intent.ACTION_TIME_CHANGED));
+ verify(mAlarmManager, atLeast(2))
+ .setExact(anyInt(), anyLong(), anyString(), any(), any());
+ }
+
+ @Test
+ public void customTime_alarmSetInTheFutureWhenOn() throws RemoteException {
+ LocalDateTime now = LocalDateTime.now();
+ when(mPowerManager.isInteractive()).thenReturn(false);
+ mService.setNightMode(MODE_NIGHT_YES);
+ mService.setCustomNightModeStart(now.toLocalTime().minusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.toLocalTime().plusHours(1L).toNanoOfDay() / 1000);
+ LocalDateTime next = now.plusHours(1L);
+ final long millis = next.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ verify(mAlarmManager)
+ .setExact(anyInt(), eq(millis), anyString(), any(), any());
+ }
+
+ @Test
+ public void customTime_appliesImmediatelyWhenScreenOff() throws RemoteException {
+ when(mPowerManager.isInteractive()).thenReturn(false);
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_NO);
+ mService.setCustomNightModeStart(now.minusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.plusHours(1L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ assertTrue(isNightModeActivated());
+ }
+
+ @Test
+ public void customTime_appliesOnlyWhenScreenOff() throws RemoteException {
+ LocalTime now = LocalTime.now();
+ mService.setNightMode(MODE_NIGHT_NO);
+ mService.setCustomNightModeStart(now.minusHours(1L).toNanoOfDay() / 1000);
+ mService.setCustomNightModeEnd(now.plusHours(1L).toNanoOfDay() / 1000);
+ mService.setNightMode(MODE_NIGHT_CUSTOM);
+ assertFalse(isNightModeActivated());
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertTrue(isNightModeActivated());
+ }
+
+ @Test
+ public void nightAuto_appliesOnlyWhenScreenOff() throws RemoteException {
+ when(mTwilightState.isNight()).thenReturn(true);
+ mService.setNightMode(MODE_NIGHT_NO);
+ mService.setNightMode(MODE_NIGHT_AUTO);
+ assertFalse(isNightModeActivated());
+ mScreenOffCallback.onReceive(mContext, new Intent(Intent.ACTION_SCREEN_OFF));
+ assertTrue(isNightModeActivated());
+ }
+
private boolean isNightModeActivated() {
return (mUiManagerService.getConfiguration().uiMode
& Configuration.UI_MODE_NIGHT_YES) != 0;
diff --git a/services/tests/uiservicestests/src/com/android/server/notification/NotificationHistoryDatabaseTest.java b/services/tests/uiservicestests/src/com/android/server/notification/NotificationHistoryDatabaseTest.java
index 9ad6986..5b5ad87 100644
--- a/services/tests/uiservicestests/src/com/android/server/notification/NotificationHistoryDatabaseTest.java
+++ b/services/tests/uiservicestests/src/com/android/server/notification/NotificationHistoryDatabaseTest.java
@@ -186,6 +186,20 @@
}
@Test
+ public void testAddNotification_newestFirst() {
+ HistoricalNotification n = getHistoricalNotification(1);
+ HistoricalNotification n2 = getHistoricalNotification(2);
+
+ mDataBase.addNotification(n);
+
+ // second add should not trigger another write
+ mDataBase.addNotification(n2);
+
+ assertThat(mDataBase.mBuffer.getNotificationsToWrite().get(0)).isEqualTo(n2);
+ assertThat(mDataBase.mBuffer.getNotificationsToWrite().get(1)).isEqualTo(n);
+ }
+
+ @Test
public void testReadNotificationHistory_readsAllFiles() throws Exception {
for (long i = 10; i >= 5; i--) {
AtomicFile af = mock(AtomicFile.class);
diff --git a/services/tests/uiservicestests/src/com/android/server/notification/NotificationManagerServiceTest.java b/services/tests/uiservicestests/src/com/android/server/notification/NotificationManagerServiceTest.java
index c6c64c9..9260fbf 100755
--- a/services/tests/uiservicestests/src/com/android/server/notification/NotificationManagerServiceTest.java
+++ b/services/tests/uiservicestests/src/com/android/server/notification/NotificationManagerServiceTest.java
@@ -100,8 +100,10 @@
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageManager;
+import android.content.pm.LauncherApps;
import android.content.pm.PackageManager;
import android.content.pm.ParceledListSlice;
+import android.content.pm.ShortcutInfo;
import android.content.pm.UserInfo;
import android.content.res.Resources;
import android.graphics.Color;
@@ -214,6 +216,8 @@
@Mock
private AudioManager mAudioManager;
@Mock
+ private LauncherApps mLauncherApps;
+ @Mock
ActivityManager mActivityManager;
@Mock
Resources mResources;
@@ -420,6 +424,7 @@
mService.onBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
mService.setAudioManager(mAudioManager);
+ mService.setLauncherApps(mLauncherApps);
// Tests call directly into the Binder.
mBinderService = mService.getBinderService();
@@ -618,8 +623,8 @@
private Notification.BubbleMetadata.Builder getBubbleMetadataBuilder() {
PendingIntent pi = PendingIntent.getActivity(mContext, 0, new Intent(), 0);
return new Notification.BubbleMetadata.Builder()
- .setIntent(pi)
- .setIcon(Icon.createWithResource(mContext, android.R.drawable.sym_def_app_icon));
+ .createIntentBubble(pi,
+ Icon.createWithResource(mContext, android.R.drawable.sym_def_app_icon));
}
private Notification.Builder getMessageStyleNotifBuilder(boolean addBubbleMetadata,
@@ -4397,7 +4402,7 @@
when(mActivityManager.getUidImportance(mUid)).thenReturn(IMPORTANCE_FOREGROUND);
// enqueue toast -> toast should still enqueue
- ((INotificationManager)mService.mService).enqueueToast(testPackage,
+ ((INotificationManager) mService.mService).enqueueToast(testPackage, new Binder(),
new TestableToastCallback(), 2000, 0);
assertEquals(1, mService.mToastQueue.size());
}
@@ -4417,7 +4422,7 @@
when(mPreferencesHelper.getImportance(testPackage, mUid)).thenReturn(IMPORTANCE_LOW);
// enqueue toast -> no toasts enqueued
- ((INotificationManager)mService.mService).enqueueToast(testPackage,
+ ((INotificationManager) mService.mService).enqueueToast(testPackage, new Binder(),
new TestableToastCallback(), 2000, 0);
assertEquals(0, mService.mToastQueue.size());
}
@@ -4440,7 +4445,7 @@
when(mActivityManager.getUidImportance(mUid)).thenReturn(IMPORTANCE_GONE);
// enqueue toast -> no toasts enqueued
- ((INotificationManager)mService.mService).enqueueToast(testPackage,
+ ((INotificationManager) mService.mService).enqueueToast(testPackage, new Binder(),
new TestableToastCallback(), 2000, 0);
assertEquals(0, mService.mToastQueue.size());
}
@@ -4463,7 +4468,7 @@
when(mActivityManager.getUidImportance(mUid)).thenReturn(IMPORTANCE_GONE);
// enqueue toast -> system toast can still be enqueued
- ((INotificationManager)mService.mService).enqueueToast(testPackage,
+ ((INotificationManager) mService.mService).enqueueToast(testPackage, new Binder(),
new TestableToastCallback(), 2000, 0);
assertEquals(1, mService.mToastQueue.size());
}
@@ -5689,6 +5694,58 @@
}
@Test
+ public void testNotificationBubbles_flagRemoved_whenShortcutRemoved()
+ throws RemoteException {
+ // Bubbles are allowed!
+ setUpPrefsForBubbles(PKG, mUid, true /* global */, true /* app */, true /* channel */);
+
+ ArgumentCaptor<LauncherApps.Callback> launcherAppsCallback =
+ ArgumentCaptor.forClass(LauncherApps.Callback.class);
+
+ // Messaging notification with shortcut info
+ Notification.BubbleMetadata metadata =
+ getBubbleMetadataBuilder().createShortcutBubble("someshortcutId").build();
+ Notification.Builder nb = getMessageStyleNotifBuilder(false /* addDefaultMetadata */,
+ null /* groupKey */, false /* isSummary */);
+ nb.setBubbleMetadata(metadata);
+ StatusBarNotification sbn = new StatusBarNotification(PKG, PKG, 1,
+ "tag", mUid, 0, nb.build(), new UserHandle(mUid), null, 0);
+ NotificationRecord nr = new NotificationRecord(mContext, sbn, mTestNotificationChannel);
+
+ // Pretend the shortcut exists
+ List<ShortcutInfo> shortcutInfos = new ArrayList<>();
+ shortcutInfos.add(mock(ShortcutInfo.class));
+ when(mLauncherApps.getShortcuts(any(), any())).thenReturn(shortcutInfos);
+
+ // Test: Send the bubble notification
+ mBinderService.enqueueNotificationWithTag(PKG, PKG, nr.sbn.getTag(),
+ nr.sbn.getId(), nr.sbn.getNotification(), nr.sbn.getUserId());
+ waitForIdle();
+
+ // Verify:
+
+ // Make sure we register the callback for shortcut changes
+ verify(mLauncherApps, times(1)).registerCallback(launcherAppsCallback.capture(), any());
+
+ // yes allowed, yes messaging w/shortcut, yes bubble
+ Notification notif = mService.getNotificationRecord(nr.sbn.getKey()).getNotification();
+ assertTrue(notif.isBubbleNotification());
+
+ // Test: Remove the shortcut
+ launcherAppsCallback.getValue().onShortcutsChanged(PKG, Collections.emptyList(),
+ new UserHandle(mUid));
+
+ // Verify:
+
+ // Make sure callback is unregistered
+ verify(mLauncherApps, times(1)).unregisterCallback(launcherAppsCallback.getValue());
+
+ // We're no longer a bubble
+ Notification notif2 = mService.getNotificationRecord(nr.sbn.getKey()).getNotification();
+ assertFalse(notif2.isBubbleNotification());
+ }
+
+ @Test
public void testNotificationBubbles_bubbleChildrenStay_whenGroupSummaryDismissed()
throws Exception {
// Bubbles are allowed!
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java
index ed9cdf4..4f84ee1 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityDisplayTests.java
@@ -233,7 +233,7 @@
final ActivityStack pinnedStack = display.createStack(
WINDOWING_MODE_PINNED, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- assertEquals(pinnedStack, display.getPinnedStack());
+ assertEquals(pinnedStack, display.getRootPinnedTask());
assertEquals(pinnedStack, display.getTopStack());
final ActivityStack anotherAlwaysOnTopStack = display.createStack(
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
index c60ca48..ebe4ab9 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityRecordTests.java
@@ -136,7 +136,7 @@
public void testStackCleanupOnTaskRemoval() {
mStack.removeChild(mTask, null /*reason*/);
// Stack should be gone on task removal.
- assertNull(mService.mRootWindowContainer.getStack(mStack.mStackId));
+ assertNull(mService.mRootWindowContainer.getStack(mStack.mTaskId));
}
@Test
@@ -1010,7 +1010,7 @@
@Test
public void testDestroyIfPossible_lastActivityAboveEmptyHomeStack() {
// Empty the home stack.
- final ActivityStack homeStack = mActivity.getDisplay().getHomeStack();
+ final ActivityStack homeStack = mActivity.getDisplay().getRootHomeTask();
homeStack.forAllTasks((t) -> {
homeStack.removeChild(t, "test");
}, true /* traverseTopToBottom */, homeStack);
@@ -1036,7 +1036,7 @@
@Test
public void testCompleteFinishing_lastActivityAboveEmptyHomeStack() {
// Empty the home stack.
- final ActivityStack homeStack = mActivity.getDisplay().getHomeStack();
+ final ActivityStack homeStack = mActivity.getDisplay().getRootHomeTask();
homeStack.forAllTasks((t) -> {
homeStack.removeChild(t, "test");
}, true /* traverseTopToBottom */, homeStack);
@@ -1136,7 +1136,7 @@
@Test
public void testRemoveFromHistory() {
- final ActivityStack stack = mActivity.getActivityStack();
+ final ActivityStack stack = mActivity.getRootTask();
final Task task = mActivity.getTask();
mActivity.removeFromHistory("test");
diff --git a/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java b/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java
index 9e54f40..0fc2bc5 100644
--- a/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java
@@ -153,7 +153,7 @@
assertThat((Object) task2.getStack()).isInstanceOf(ActivityStack.class);
mStarter.updateBounds(task2, bounds);
- verify(mService, times(1)).animateResizePinnedStack(eq(task2.getStack().mStackId),
+ verify(mService, times(1)).animateResizePinnedStack(eq(task2.getRootTaskId()),
eq(bounds), anyInt());
// In the case of no animation, the stack and task bounds should be set immediately.
@@ -229,11 +229,12 @@
service.mStackSupervisor, mock(ActivityStartInterceptor.class));
prepareStarter(launchFlags);
final IApplicationThread caller = mock(IApplicationThread.class);
+ final WindowProcessListener listener = mock(WindowProcessListener.class);
final WindowProcessController wpc =
containsConditions(preconditions, PRECONDITION_NO_CALLER_APP)
? null : new WindowProcessController(
- service, mock(ApplicationInfo.class), null, 0, -1, null, null);
+ service, mock(ApplicationInfo.class), null, 0, -1, null, listener);
doReturn(wpc).when(service).getProcessController(anyObject());
final Intent intent = new Intent();
@@ -446,13 +447,13 @@
new ActivityBuilder(mService).setCreateTask(true).build();
final ActivityRecord splitSecondReusableActivity =
new ActivityBuilder(mService).setCreateTask(true).build();
- splitPrimaryFocusActivity.getActivityStack()
+ splitPrimaryFocusActivity.getRootTask()
.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
- splitSecondReusableActivity.getActivityStack()
+ splitSecondReusableActivity.getRootTask()
.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
// Set focus back to primary.
- splitPrimaryFocusActivity.getActivityStack().moveToFront("testSplitScreenDeliverToTop");
+ splitPrimaryFocusActivity.getRootTask().moveToFront("testSplitScreenDeliverToTop");
// Start activity and delivered new intent.
starter.getIntent().setComponent(splitSecondReusableActivity.mActivityComponent);
@@ -477,18 +478,18 @@
new ActivityBuilder(mService).setCreateTask(true).build();
final ActivityRecord splitPrimaryFocusActivity =
new ActivityBuilder(mService).setCreateTask(true).build();
- splitPrimaryFocusActivity.getActivityStack()
+ splitPrimaryFocusActivity.getRootTask()
.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
- splitSecondReusableActivity.getActivityStack()
+ splitSecondReusableActivity.getRootTask()
.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
- splitSecondTopActivity.getActivityStack()
+ splitSecondTopActivity.getRootTask()
.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY);
// Make it on top of split-screen-secondary.
- splitSecondTopActivity.getActivityStack().moveToFront("testSplitScreenTaskToFront");
+ splitSecondTopActivity.getRootTask().moveToFront("testSplitScreenTaskToFront");
// Let primary stack has focus.
- splitPrimaryFocusActivity.getActivityStack().moveToFront("testSplitScreenTaskToFront");
+ splitPrimaryFocusActivity.getRootTask().moveToFront("testSplitScreenTaskToFront");
// Start activity and delivered new intent.
starter.getIntent().setComponent(splitSecondReusableActivity.mActivityComponent);
@@ -680,10 +681,11 @@
doReturn(realCallingUidProcState).when(mService).getUidState(realCallingUid);
// foreground activities
final IApplicationThread caller = mock(IApplicationThread.class);
+ final WindowProcessListener listener = mock(WindowProcessListener.class);
final ApplicationInfo ai = new ApplicationInfo();
ai.uid = callingUid;
final WindowProcessController callerApp =
- new WindowProcessController(mService, ai, null, callingUid, -1, null, null);
+ new WindowProcessController(mService, ai, null, callingUid, -1, null, listener);
callerApp.setHasForegroundActivities(hasForegroundActivities);
doReturn(callerApp).when(mService).getProcessController(caller);
// caller is recents
@@ -732,13 +734,13 @@
final ActivityRecord activity = new ActivityBuilder(mService)
.setCreateTask(true).build();
new ActivityBuilder(mService)
- .setStack(activity.getActivityStack())
+ .setStack(activity.getRootTask())
.setCreateTask(true).build();
// Create a top finishing activity.
final ActivityRecord finishingTopActivity = new ActivityBuilder(mService)
.setCreateTask(true).build();
- finishingTopActivity.getActivityStack().moveToFront("finishingTopActivity");
+ finishingTopActivity.getRootTask().moveToFront("finishingTopActivity");
assertEquals(finishingTopActivity, mRootWindowContainer.topRunningActivity());
finishingTopActivity.finishing = true;
@@ -997,8 +999,8 @@
assertThat(outActivity[0].inSplitScreenWindowingMode()).isFalse();
// Move activity to split-screen-primary stack and make sure it has the focus.
- top.getActivityStack().setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
- top.getActivityStack().moveToFront("testWindowingModeOptionsLaunchAdjacent");
+ top.getRootTask().setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
+ top.getRootTask().moveToFront("testWindowingModeOptionsLaunchAdjacent");
// Activity must landed on split-screen-secondary when launch adjacent.
starter.setActivityOptions(options.toBundle())
diff --git a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java
index cf1f0a8..1144272 100644
--- a/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/LaunchParamsControllerTests.java
@@ -284,7 +284,7 @@
doNothing().when(mService).moveStackToDisplay(anyInt(), anyInt());
mController.layoutTask(task, null /* windowLayout */);
- verify(mService, times(1)).moveStackToDisplay(eq(task.getStackId()),
+ verify(mService, times(1)).moveStackToDisplay(eq(task.getRootTaskId()),
eq(params.mPreferredDisplayId));
}
@@ -421,7 +421,7 @@
}
@Override
- void saveTask(Task task) {
+ void saveTask(Task task, DisplayContent display) {
final int userId = task.mUserId;
final ComponentName realActivity = task.realActivity;
mTmpParams.mPreferredDisplayId = task.getDisplayId();
diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
index 79f808e..b5e7dd5 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RecentTasksTest.java
@@ -303,7 +303,7 @@
// other task
Task task1 = createTaskBuilder(".Task1")
.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_MULTIPLE_TASK)
- .setStack(mDisplay.getHomeStack()).build();
+ .setStack(mDisplay.getRootHomeTask()).build();
Task task2 = createTaskBuilder(".Task1")
.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_MULTIPLE_TASK)
.setStack(mStack).build();
@@ -792,7 +792,7 @@
public void testBackStackTasks_expectNoTrim() {
mRecentTasks.setParameters(-1 /* min */, 1 /* max */, -1 /* ms */);
- final ActivityStack homeStack = mDisplay.getHomeStack();
+ final ActivityStack homeStack = mDisplay.getRootHomeTask();
final ActivityStack aboveHomeStack = mDisplay.createStack(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
@@ -812,7 +812,7 @@
final ActivityStack behindHomeStack = mDisplay.createStack(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
- final ActivityStack homeStack = mDisplay.getHomeStack();
+ final ActivityStack homeStack = mDisplay.getRootHomeTask();
final ActivityStack aboveHomeStack = mDisplay.createStack(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
@@ -832,7 +832,7 @@
public void testOtherDisplayTasks_expectNoTrim() {
mRecentTasks.setParameters(-1 /* min */, 1 /* max */, -1 /* ms */);
- final ActivityStack homeStack = mDisplay.getHomeStack();
+ final ActivityStack homeStack = mDisplay.getRootHomeTask();
final DisplayContent otherDisplay = addNewDisplayContentAt(DisplayContent.POSITION_TOP);
final ActivityStack otherDisplayStack = otherDisplay.createStack(
WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */);
diff --git a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java
index 7e42c62..b78107e 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RecentsAnimationTest.java
@@ -97,7 +97,7 @@
.setStack(recentsStack)
.build();
ActivityRecord topActivity = new ActivityBuilder(mService).setCreateTask(true).build();
- topActivity.getActivityStack().moveToFront("testRecentsActivityVisiblility");
+ topActivity.getRootTask().moveToFront("testRecentsActivityVisiblility");
doCallRealMethod().when(mRootWindowContainer).ensureActivitiesVisible(
any() /* starting */, anyInt() /* configChanges */,
@@ -187,7 +187,7 @@
recentActivity.app = null;
// Start an activity on top.
- new ActivityBuilder(mService).setCreateTask(true).build().getActivityStack().moveToFront(
+ new ActivityBuilder(mService).setCreateTask(true).build().getRootTask().moveToFront(
"testRestartRecentsActivity");
doCallRealMethod().when(mRootWindowContainer).ensureActivitiesVisible(
@@ -209,7 +209,7 @@
public void testSetLaunchTaskBehindOfTargetActivity() {
DisplayContent display = mRootWindowContainer.getDefaultDisplay();
display.mDisplayContent.mBoundsAnimationController = mock(BoundsAnimationController.class);
- ActivityStack homeStack = display.getHomeStack();
+ ActivityStack homeStack = display.getRootHomeTask();
// Assume the home activity support recents.
ActivityRecord targetActivity = homeStack.getTopNonFinishingActivity();
if (targetActivity == null) {
@@ -229,7 +229,7 @@
new ActivityBuilder(mService)
.setCreateTask(true)
.build()
- .getActivityStack()
+ .getRootTask()
.moveToFront("Activity start");
// Start the recents animation.
diff --git a/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java b/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java
index ea8d082..79db927 100644
--- a/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/RootActivityContainerTests.java
@@ -131,7 +131,7 @@
0f /*aspectRatio*/, "initialMove");
final DisplayContent display = mFullscreenStack.getDisplay();
- ActivityStack pinnedStack = display.getPinnedStack();
+ ActivityStack pinnedStack = display.getRootPinnedTask();
// Ensure a task has moved over.
ensureStackPlacement(pinnedStack, firstActivity);
ensureStackPlacement(mFullscreenStack, secondActivity);
@@ -141,7 +141,7 @@
0f /*aspectRatio*/, "secondMove");
// Need to get stacks again as a new instance might have been created.
- pinnedStack = display.getPinnedStack();
+ pinnedStack = display.getRootPinnedTask();
mFullscreenStack = display.getStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD);
// Ensure stacks have swapped tasks.
ensureStackPlacement(pinnedStack, secondActivity);
@@ -417,7 +417,7 @@
@Test
public void testResumeFocusedStacksStartsHomeActivity_NoActivities() {
mFullscreenStack.removeIfPossible();
- mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY).getHomeStack()
+ mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY).getRootHomeTask()
.removeIfPossible();
mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY)
.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP);
@@ -440,7 +440,7 @@
@Test
public void testResumeFocusedStacksStartsHomeActivity_ActivityOnSecondaryScreen() {
mFullscreenStack.removeIfPossible();
- mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY).getHomeStack()
+ mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY).getRootHomeTask()
.removeIfPossible();
mService.mRootWindowContainer.getDisplayContent(DEFAULT_DISPLAY)
.createStack(WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_HOME, ON_TOP);
@@ -638,7 +638,7 @@
final ActivityRecord resolverActivity = mRootWindowContainer.topRunningActivity();
assertEquals(info, resolverActivity.info);
- assertEquals(ACTIVITY_TYPE_STANDARD, resolverActivity.getActivityStack().getActivityType());
+ assertEquals(ACTIVITY_TYPE_STANDARD, resolverActivity.getRootTask().getActivityType());
}
/**
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskStackContainersTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskContainersTests.java
similarity index 98%
rename from services/tests/wmtests/src/com/android/server/wm/TaskStackContainersTests.java
rename to services/tests/wmtests/src/com/android/server/wm/TaskContainersTests.java
index 6ad9f74..f228397 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskStackContainersTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskContainersTests.java
@@ -46,7 +46,7 @@
@SmallTest
@Presubmit
@RunWith(WindowTestRunner.class)
-public class TaskStackContainersTests extends WindowTestsBase {
+public class TaskContainersTests extends WindowTestsBase {
private ActivityStack mPinnedStack;
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java
index 8970571..7aaf3fb 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java
@@ -85,7 +85,7 @@
mPositioner.register(mDisplayContent, win);
- win.getStack().setWindowingMode(WINDOWING_MODE_FREEFORM);
+ win.getRootTask().setWindowingMode(WINDOWING_MODE_FREEFORM);
}
@After
diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java
index fa0485c..ebf14d2 100644
--- a/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/TaskRecordTests.java
@@ -20,6 +20,8 @@
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM;
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
+import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
+import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED;
import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
import static android.content.Intent.FLAG_ACTIVITY_TASK_ON_HOME;
import static android.content.pm.ActivityInfo.FLAG_RELINQUISH_TASK_IDENTITY;
@@ -34,6 +36,7 @@
import static com.android.dx.mockito.inline.extended.ExtendedMockito.doAnswer;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.eq;
+import static com.android.dx.mockito.inline.extended.ExtendedMockito.never;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify;
import static com.android.server.policy.WindowManagerPolicy.USER_ROTATION_FREE;
@@ -51,10 +54,13 @@
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.same;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
import android.app.ActivityManager;
import android.app.TaskInfo;
+import android.app.WindowConfiguration;
import android.content.ComponentName;
import android.content.Intent;
import android.content.pm.ActivityInfo;
@@ -859,6 +865,78 @@
verify(task).setIntent(eq(activity0));
}
+ @Test
+ public void testSaveLaunchingStateWhenConfigurationChanged() {
+ LaunchParamsPersister persister = mService.mStackSupervisor.mLaunchParamsPersister;
+ spyOn(persister);
+
+ final Task task = getTestTask();
+ task.hasBeenVisible = false;
+ task.getDisplayContent().setDisplayWindowingMode(WINDOWING_MODE_FREEFORM);
+ task.getStack().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
+
+ task.hasBeenVisible = true;
+ task.onConfigurationChanged(task.getParent().getConfiguration());
+
+ verify(persister).saveTask(task, task.getDisplayContent());
+ }
+
+ @Test
+ public void testSaveLaunchingStateWhenClearingParent() {
+ LaunchParamsPersister persister = mService.mStackSupervisor.mLaunchParamsPersister;
+ spyOn(persister);
+
+ final Task task = getTestTask();
+ task.hasBeenVisible = false;
+ task.getDisplayContent().setWindowingMode(WindowConfiguration.WINDOWING_MODE_FREEFORM);
+ task.getStack().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ final DisplayContent oldDisplay = task.getDisplayContent();
+
+ LaunchParamsController.LaunchParams params = new LaunchParamsController.LaunchParams();
+ params.mWindowingMode = WINDOWING_MODE_UNDEFINED;
+ persister.getLaunchParams(task, null, params);
+ assertEquals(WINDOWING_MODE_UNDEFINED, params.mWindowingMode);
+
+ task.hasBeenVisible = true;
+ task.removeImmediately();
+
+ verify(persister).saveTask(task, oldDisplay);
+
+ persister.getLaunchParams(task, null, params);
+ assertEquals(WINDOWING_MODE_FULLSCREEN, params.mWindowingMode);
+ }
+
+ @Test
+ public void testNotSaveLaunchingStateNonFreeformDisplay() {
+ LaunchParamsPersister persister = mService.mStackSupervisor.mLaunchParamsPersister;
+ spyOn(persister);
+
+ final Task task = getTestTask();
+ task.hasBeenVisible = false;
+ task.getStack().setWindowingMode(WINDOWING_MODE_FULLSCREEN);
+
+ task.hasBeenVisible = true;
+ task.onConfigurationChanged(task.getParent().getConfiguration());
+
+ verify(persister, never()).saveTask(same(task), any());
+ }
+
+ @Test
+ public void testNotSaveLaunchingStateWhenNotFullscreenOrFreeformWindow() {
+ LaunchParamsPersister persister = mService.mStackSupervisor.mLaunchParamsPersister;
+ spyOn(persister);
+
+ final Task task = getTestTask();
+ task.hasBeenVisible = false;
+ task.getDisplayContent().setDisplayWindowingMode(WINDOWING_MODE_FREEFORM);
+ task.getStack().setWindowingMode(WINDOWING_MODE_PINNED);
+
+ task.hasBeenVisible = true;
+ task.onConfigurationChanged(task.getParent().getConfiguration());
+
+ verify(persister, never()).saveTask(same(task), any());
+ }
+
private Task getTestTask() {
final ActivityStack stack = new StackBuilder(mRootWindowContainer).build();
return stack.getBottomMostTask();
diff --git a/services/tests/wmtests/src/com/android/server/wm/WindowProcessControllerTests.java b/services/tests/wmtests/src/com/android/server/wm/WindowProcessControllerTests.java
index db4fdc77..34e487b 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowProcessControllerTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowProcessControllerTests.java
@@ -16,6 +16,8 @@
package com.android.server.wm;
+import static android.content.res.Configuration.ORIENTATION_LANDSCAPE;
+import static android.content.res.Configuration.ORIENTATION_PORTRAIT;
import static android.view.Display.INVALID_DISPLAY;
import static org.junit.Assert.assertEquals;
@@ -24,7 +26,9 @@
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.when;
+import android.app.IApplicationThread;
import android.content.pm.ApplicationInfo;
import android.content.res.Configuration;
import android.platform.test.annotations.Presubmit;
@@ -53,6 +57,7 @@
mMockListener = mock(WindowProcessListener.class);
mWpc = new WindowProcessController(
mService, mock(ApplicationInfo.class), null, 0, -1, null, mMockListener);
+ mWpc.setThread(mock(IApplicationThread.class));
}
@Test
@@ -132,23 +137,51 @@
@Test
public void testConfigurationForSecondaryScreen() {
- final WindowProcessController wpc = new WindowProcessController(
- mService, mock(ApplicationInfo.class), null, 0, -1, null, null);
// By default, the process should not listen to any display.
- assertEquals(INVALID_DISPLAY, wpc.getDisplayId());
+ assertEquals(INVALID_DISPLAY, mWpc.getDisplayId());
// Register to a new display as a listener.
final DisplayContent display = new TestDisplayContent.Builder(mService, 2000, 1000)
.setDensityDpi(300).setPosition(DisplayContent.POSITION_TOP).build();
- wpc.registerDisplayConfigurationListener(display);
+ mWpc.registerDisplayConfigurationListener(display);
- assertEquals(display.mDisplayId, wpc.getDisplayId());
+ assertEquals(display.mDisplayId, mWpc.getDisplayId());
final Configuration expectedConfig = mService.mRootWindowContainer.getConfiguration();
expectedConfig.updateFrom(display.getConfiguration());
- assertEquals(expectedConfig, wpc.getConfiguration());
+ assertEquals(expectedConfig, mWpc.getConfiguration());
+ }
+
+ @Test
+ public void testDelayingConfigurationChange() {
+ when(mMockListener.isCached()).thenReturn(false);
+
+ Configuration tmpConfig = new Configuration(mWpc.getConfiguration());
+ invertOrientation(tmpConfig);
+ mWpc.onConfigurationChanged(tmpConfig);
+
+ // The last reported config should be the current config as the process is not cached.
+ Configuration originalConfig = new Configuration(mWpc.getConfiguration());
+ assertEquals(mWpc.getLastReportedConfiguration(), originalConfig);
+
+ when(mMockListener.isCached()).thenReturn(true);
+ invertOrientation(tmpConfig);
+ mWpc.onConfigurationChanged(tmpConfig);
+
+ Configuration newConfig = new Configuration(mWpc.getConfiguration());
+
+ // Last reported config hasn't changed because the process is in a cached state.
+ assertEquals(mWpc.getLastReportedConfiguration(), originalConfig);
+
+ mWpc.onProcCachedStateChanged(false);
+ assertEquals(mWpc.getLastReportedConfiguration(), newConfig);
}
private TestDisplayContent createTestDisplayContentInContainer() {
return new TestDisplayContent.Builder(mService, 1000, 1500).build();
}
+
+ private static void invertOrientation(Configuration config) {
+ config.orientation = config.orientation == ORIENTATION_PORTRAIT
+ ? ORIENTATION_LANDSCAPE : ORIENTATION_PORTRAIT;
+ }
}
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 6d0b54f..5cf9c44 100644
--- a/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
+++ b/services/tests/wmtests/src/com/android/server/wm/WindowStateTests.java
@@ -278,7 +278,7 @@
spyOn(stack);
doReturn(true).when(controller).isMinimizedDock();
doReturn(true).when(controller).isHomeStackResizable();
- doReturn(stack).when(appWindow).getStack();
+ doReturn(stack).when(appWindow).getRootTask();
// Make sure canBeImeTarget is false due to shouldIgnoreInput is true;
assertFalse(appWindow.canBeImeTarget());
diff --git a/services/usb/java/com/android/server/usb/UsbService.java b/services/usb/java/com/android/server/usb/UsbService.java
index 27531949..b1bd04e 100644
--- a/services/usb/java/com/android/server/usb/UsbService.java
+++ b/services/usb/java/com/android/server/usb/UsbService.java
@@ -56,6 +56,8 @@
import com.android.internal.util.IndentingPrintWriter;
import com.android.internal.util.Preconditions;
import com.android.internal.util.dump.DualDumpOutputStream;
+import com.android.server.FgThread;
+import com.android.server.SystemServerInitThreadPool;
import com.android.server.SystemService;
import java.io.File;
@@ -64,6 +66,7 @@
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.concurrent.CompletableFuture;
/**
* UsbService manages all USB related state, including both host and device support.
@@ -74,6 +77,9 @@
public static class Lifecycle extends SystemService {
private UsbService mUsbService;
+ private final CompletableFuture<Void> mOnStartFinished = new CompletableFuture<>();
+ private final CompletableFuture<Void> mOnActivityManagerPhaseFinished =
+ new CompletableFuture<>();
public Lifecycle(Context context) {
super(context);
@@ -81,32 +87,41 @@
@Override
public void onStart() {
- mUsbService = new UsbService(getContext());
- publishBinderService(Context.USB_SERVICE, mUsbService);
+ SystemServerInitThreadPool.submit(() -> {
+ mUsbService = new UsbService(getContext());
+ publishBinderService(Context.USB_SERVICE, mUsbService);
+ mOnStartFinished.complete(null);
+ }, "UsbService$Lifecycle#onStart");
}
@Override
public void onBootPhase(int phase) {
if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) {
- mUsbService.systemReady();
+ SystemServerInitThreadPool.submit(() -> {
+ mOnStartFinished.join();
+ mUsbService.systemReady();
+ mOnActivityManagerPhaseFinished.complete(null);
+ }, "UsbService$Lifecycle#onBootPhase");
} else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
+ mOnActivityManagerPhaseFinished.join();
mUsbService.bootCompleted();
}
}
@Override
- public void onSwitchUser(int newUserId) {
- mUsbService.onSwitchUser(newUserId);
+ public void onSwitchUser(TargetUser from, TargetUser to) {
+ FgThread.getHandler()
+ .postAtFrontOfQueue(() -> mUsbService.onSwitchUser(to.getUserIdentifier()));
}
@Override
- public void onStopUser(int userHandle) {
- mUsbService.onStopUser(UserHandle.of(userHandle));
+ public void onStopUser(TargetUser userInfo) {
+ mUsbService.onStopUser(userInfo.getUserHandle());
}
@Override
- public void onUnlockUser(int userHandle) {
- mUsbService.onUnlockUser(userHandle);
+ public void onUnlockUser(TargetUser userInfo) {
+ mUsbService.onUnlockUser(userInfo.getUserIdentifier());
}
}
diff --git a/telephony/java/android/service/euicc/EuiccService.java b/telephony/java/android/service/euicc/EuiccService.java
index bc6a9e8..ef11f46 100644
--- a/telephony/java/android/service/euicc/EuiccService.java
+++ b/telephony/java/android/service/euicc/EuiccService.java
@@ -34,6 +34,8 @@
import android.telephony.euicc.EuiccManager.OtaStatus;
import android.util.Log;
+import java.io.PrintWriter;
+import java.io.StringWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.concurrent.LinkedBlockingQueue;
@@ -583,6 +585,13 @@
public abstract int onRetainSubscriptionsForFactoryReset(int slotId);
/**
+ * Dump to a provided printWriter.
+ */
+ public void dump(@NonNull PrintWriter printWriter) {
+ printWriter.println("The connected LPA does not implement EuiccService#dump()");
+ }
+
+ /**
* Wrapper around IEuiccService that forwards calls to implementations of {@link EuiccService}.
*/
private class IEuiccServiceWrapper extends IEuiccService.Stub {
@@ -834,5 +843,22 @@
}
});
}
+
+ @Override
+ public void dump(IEuiccServiceDumpResultCallback callback) throws RemoteException {
+ mExecutor.execute(new Runnable() {
+ @Override
+ public void run() {
+ try {
+ final StringWriter sw = new StringWriter();
+ final PrintWriter pw = new PrintWriter(sw);
+ EuiccService.this.dump(pw);
+ callback.onComplete(sw.toString());
+ } catch (RemoteException e) {
+ // Can't communicate with the phone process; ignore.
+ }
+ }
+ });
+ }
}
}
diff --git a/telephony/java/android/service/euicc/IEuiccService.aidl b/telephony/java/android/service/euicc/IEuiccService.aidl
index 2acc47a..bb7b569 100644
--- a/telephony/java/android/service/euicc/IEuiccService.aidl
+++ b/telephony/java/android/service/euicc/IEuiccService.aidl
@@ -29,6 +29,7 @@
import android.service.euicc.IRetainSubscriptionsForFactoryResetCallback;
import android.service.euicc.ISwitchToSubscriptionCallback;
import android.service.euicc.IUpdateSubscriptionNicknameCallback;
+import android.service.euicc.IEuiccServiceDumpResultCallback;
import android.telephony.euicc.DownloadableSubscription;
import android.os.Bundle;
@@ -56,4 +57,5 @@
int slotIndex, int options, in IEraseSubscriptionsCallback callback);
void retainSubscriptionsForFactoryReset(
int slotId, in IRetainSubscriptionsForFactoryResetCallback callback);
+ void dump(in IEuiccServiceDumpResultCallback callback);
}
\ No newline at end of file
diff --git a/telephony/java/android/telephony/TelephonyManager.java b/telephony/java/android/telephony/TelephonyManager.java
index c9d5006..92fafdc 100644
--- a/telephony/java/android/telephony/TelephonyManager.java
+++ b/telephony/java/android/telephony/TelephonyManager.java
@@ -45,7 +45,6 @@
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
-import android.content.pm.PackageManager;
import android.database.Cursor;
import android.net.ConnectivityManager;
import android.net.NetworkStats;
@@ -11042,6 +11041,27 @@
}
/**
+ * Enable or disable signal strength changes from radio will always be reported in any
+ * condition (e.g. screen is off). This is only allowed for System caller.
+ *
+ * @param isEnabled {@code true} for enabling; {@code false} for disabling.
+ * @hide
+ */
+ @SystemApi
+ @RequiresPermission(android.Manifest.permission.MODIFY_PHONE_STATE)
+ public void setAlwaysReportSignalStrength(boolean isEnabled) {
+ try {
+ ITelephony telephony = getITelephony();
+ if (telephony != null) {
+ telephony.setAlwaysReportSignalStrength(getSubId(), isEnabled);
+ }
+ } catch (RemoteException ex) {
+ Log.e(TAG, "setAlwaysReportSignalStrength RemoteException", ex);
+ ex.rethrowAsRuntimeException();
+ }
+ }
+
+ /**
* Get the most recently available signal strength information.
*
* Get the most recent SignalStrength information reported by the modem. Due
@@ -11103,8 +11123,8 @@
*/
public boolean isDataCapable() {
if (mContext == null) return true;
- return mContext.getPackageManager().hasSystemFeature(
- PackageManager.FEATURE_TELEPHONY_DATA);
+ return mContext.getResources().getBoolean(
+ com.android.internal.R.bool.config_mobile_data_capable);
}
/**
diff --git a/telephony/java/android/telephony/data/ApnSetting.java b/telephony/java/android/telephony/data/ApnSetting.java
index 6e630e3..7896320 100644
--- a/telephony/java/android/telephony/data/ApnSetting.java
+++ b/telephony/java/android/telephony/data/ApnSetting.java
@@ -305,42 +305,44 @@
private static final Map<Integer, String> MVNO_TYPE_INT_MAP;
static {
- APN_TYPE_STRING_MAP = new ArrayMap<String, Integer>();
- APN_TYPE_STRING_MAP.put("*", TYPE_ALL);
- APN_TYPE_STRING_MAP.put("default", TYPE_DEFAULT);
- APN_TYPE_STRING_MAP.put("mms", TYPE_MMS);
- APN_TYPE_STRING_MAP.put("supl", TYPE_SUPL);
- APN_TYPE_STRING_MAP.put("dun", TYPE_DUN);
- APN_TYPE_STRING_MAP.put("hipri", TYPE_HIPRI);
- APN_TYPE_STRING_MAP.put("fota", TYPE_FOTA);
- APN_TYPE_STRING_MAP.put("ims", TYPE_IMS);
- APN_TYPE_STRING_MAP.put("cbs", TYPE_CBS);
- APN_TYPE_STRING_MAP.put("ia", TYPE_IA);
- APN_TYPE_STRING_MAP.put("emergency", TYPE_EMERGENCY);
- APN_TYPE_STRING_MAP.put("mcx", TYPE_MCX);
- APN_TYPE_STRING_MAP.put("xcap", TYPE_XCAP);
- APN_TYPE_INT_MAP = new ArrayMap<Integer, String>();
- APN_TYPE_INT_MAP.put(TYPE_DEFAULT, "default");
- APN_TYPE_INT_MAP.put(TYPE_MMS, "mms");
- APN_TYPE_INT_MAP.put(TYPE_SUPL, "supl");
- APN_TYPE_INT_MAP.put(TYPE_DUN, "dun");
- APN_TYPE_INT_MAP.put(TYPE_HIPRI, "hipri");
- APN_TYPE_INT_MAP.put(TYPE_FOTA, "fota");
- APN_TYPE_INT_MAP.put(TYPE_IMS, "ims");
- APN_TYPE_INT_MAP.put(TYPE_CBS, "cbs");
- APN_TYPE_INT_MAP.put(TYPE_IA, "ia");
- APN_TYPE_INT_MAP.put(TYPE_EMERGENCY, "emergency");
- APN_TYPE_INT_MAP.put(TYPE_MCX, "mcx");
- APN_TYPE_INT_MAP.put(TYPE_XCAP, "xcap");
+ APN_TYPE_STRING_MAP = new ArrayMap<>();
+ APN_TYPE_STRING_MAP.put(TYPE_ALL_STRING, TYPE_ALL);
+ APN_TYPE_STRING_MAP.put(TYPE_DEFAULT_STRING, TYPE_DEFAULT);
+ APN_TYPE_STRING_MAP.put(TYPE_MMS_STRING, TYPE_MMS);
+ APN_TYPE_STRING_MAP.put(TYPE_SUPL_STRING, TYPE_SUPL);
+ APN_TYPE_STRING_MAP.put(TYPE_DUN_STRING, TYPE_DUN);
+ APN_TYPE_STRING_MAP.put(TYPE_HIPRI_STRING, TYPE_HIPRI);
+ APN_TYPE_STRING_MAP.put(TYPE_FOTA_STRING, TYPE_FOTA);
+ APN_TYPE_STRING_MAP.put(TYPE_IMS_STRING, TYPE_IMS);
+ APN_TYPE_STRING_MAP.put(TYPE_CBS_STRING, TYPE_CBS);
+ APN_TYPE_STRING_MAP.put(TYPE_IA_STRING, TYPE_IA);
+ APN_TYPE_STRING_MAP.put(TYPE_EMERGENCY_STRING, TYPE_EMERGENCY);
+ APN_TYPE_STRING_MAP.put(TYPE_MCX_STRING, TYPE_MCX);
+ APN_TYPE_STRING_MAP.put(TYPE_XCAP_STRING, TYPE_XCAP);
- PROTOCOL_STRING_MAP = new ArrayMap<String, Integer>();
+ APN_TYPE_INT_MAP = new ArrayMap<>();
+ APN_TYPE_INT_MAP.put(TYPE_DEFAULT, TYPE_DEFAULT_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_MMS, TYPE_MMS_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_SUPL, TYPE_SUPL_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_DUN, TYPE_DUN_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_HIPRI, TYPE_HIPRI_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_FOTA, TYPE_FOTA_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_IMS, TYPE_IMS_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_CBS, TYPE_CBS_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_IA, TYPE_IA_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_EMERGENCY, TYPE_EMERGENCY_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_MCX, TYPE_MCX_STRING);
+ APN_TYPE_INT_MAP.put(TYPE_XCAP, TYPE_XCAP_STRING);
+
+ PROTOCOL_STRING_MAP = new ArrayMap<>();
PROTOCOL_STRING_MAP.put("IP", PROTOCOL_IP);
PROTOCOL_STRING_MAP.put("IPV6", PROTOCOL_IPV6);
PROTOCOL_STRING_MAP.put("IPV4V6", PROTOCOL_IPV4V6);
PROTOCOL_STRING_MAP.put("PPP", PROTOCOL_PPP);
PROTOCOL_STRING_MAP.put("NON-IP", PROTOCOL_NON_IP);
PROTOCOL_STRING_MAP.put("UNSTRUCTURED", PROTOCOL_UNSTRUCTURED);
- PROTOCOL_INT_MAP = new ArrayMap<Integer, String>();
+
+ PROTOCOL_INT_MAP = new ArrayMap<>();
PROTOCOL_INT_MAP.put(PROTOCOL_IP, "IP");
PROTOCOL_INT_MAP.put(PROTOCOL_IPV6, "IPV6");
PROTOCOL_INT_MAP.put(PROTOCOL_IPV4V6, "IPV4V6");
@@ -348,12 +350,13 @@
PROTOCOL_INT_MAP.put(PROTOCOL_NON_IP, "NON-IP");
PROTOCOL_INT_MAP.put(PROTOCOL_UNSTRUCTURED, "UNSTRUCTURED");
- MVNO_TYPE_STRING_MAP = new ArrayMap<String, Integer>();
+ MVNO_TYPE_STRING_MAP = new ArrayMap<>();
MVNO_TYPE_STRING_MAP.put("spn", MVNO_TYPE_SPN);
MVNO_TYPE_STRING_MAP.put("imsi", MVNO_TYPE_IMSI);
MVNO_TYPE_STRING_MAP.put("gid", MVNO_TYPE_GID);
MVNO_TYPE_STRING_MAP.put("iccid", MVNO_TYPE_ICCID);
- MVNO_TYPE_INT_MAP = new ArrayMap<Integer, String>();
+
+ MVNO_TYPE_INT_MAP = new ArrayMap<>();
MVNO_TYPE_INT_MAP.put(MVNO_TYPE_SPN, "spn");
MVNO_TYPE_INT_MAP.put(MVNO_TYPE_IMSI, "imsi");
MVNO_TYPE_INT_MAP.put(MVNO_TYPE_GID, "gid");
diff --git a/telephony/java/android/telephony/ims/ImsCallProfile.java b/telephony/java/android/telephony/ims/ImsCallProfile.java
index 3f260eb..8c9765b 100644
--- a/telephony/java/android/telephony/ims/ImsCallProfile.java
+++ b/telephony/java/android/telephony/ims/ImsCallProfile.java
@@ -302,15 +302,30 @@
* updateImsCallRatFromExtras(Bundle)} to determine whether to set the
* {@link android.telecom.TelecomManager#EXTRA_CALL_NETWORK_TYPE} extra value and
* {@link android.telecom.Connection#PROPERTY_WIFI} property on a connection.
+ * @deprecated the constants associated with this extra are hidden, instead use
+ * {@link #EXTRA_CALL_NETWORK_TYPE}.
*/
+ @Deprecated
public static final String EXTRA_CALL_RAT_TYPE = "CallRadioTech";
/**
+ * Extra key with an {@code int} value which can be set in {@link #setCallExtraInt(String, int)}
+ * to indicate the network type used for a call.
+ * <p>
+ * Valid values are defined by {@code TelephonyManager.NETWORK_TYPE_*} constants. An example may
+ * be {@link android.telephony.TelephonyManager#NETWORK_TYPE_LTE}.
+ */
+ public static final String EXTRA_CALL_NETWORK_TYPE =
+ "android.telephony.ims.extra.CALL_NETWORK_TYPE";
+
+ /**
* Similar to {@link #EXTRA_CALL_RAT_TYPE}, except with a lowercase 'c'. Used to ensure
* compatibility with modems that are non-compliant with the {@link #EXTRA_CALL_RAT_TYPE}
* extra key. Should be removed when the non-compliant modems are fixed.
* @hide
+ * @deprecated Use {@link #EXTRA_CALL_NETWORK_TYPE} instead.
*/
+ @Deprecated
public static final String EXTRA_CALL_RAT_TYPE_ALT = "callRadioTech";
/** @hide */
diff --git a/telephony/java/android/telephony/ims/ImsCallSession.java b/telephony/java/android/telephony/ims/ImsCallSession.java
index 5adc99e..1b583fd 100644
--- a/telephony/java/android/telephony/ims/ImsCallSession.java
+++ b/telephony/java/android/telephony/ims/ImsCallSession.java
@@ -25,8 +25,6 @@
import com.android.ims.internal.IImsCallSession;
import com.android.ims.internal.IImsVideoCallProvider;
-import java.util.Objects;
-
/**
* Provides the call initiation/termination, and media exchange between two IMS endpoints.
* It directly communicates with IMS service which implements the IMS protocol behavior.
@@ -346,7 +344,7 @@
}
/**
- * Called when an {@link ImsCallSession} may handover from one radio technology to another.
+ * Called when an {@link ImsCallSession} may handover from one network type to another.
* For example, the session may handover from WIFI to LTE if conditions are right.
* <p>
* If handover is attempted,
@@ -355,24 +353,24 @@
* called to indicate the success or failure of the handover.
*
* @param session IMS session object
- * @param srcAccessTech original access technology
- * @param targetAccessTech new access technology
+ * @param srcNetworkType original network type
+ * @param targetNetworkType new network type
*/
- public void callSessionMayHandover(ImsCallSession session, int srcAccessTech,
- int targetAccessTech) {
+ public void callSessionMayHandover(ImsCallSession session, int srcNetworkType,
+ int targetNetworkType) {
// no-op
}
/**
- * Called when session access technology changes
+ * Called when session network type changes
*
* @param session IMS session object
- * @param srcAccessTech original access technology
- * @param targetAccessTech new access technology
+ * @param srcNetworkType original network type
+ * @param targetNetworkType new network type
* @param reasonInfo
*/
public void callSessionHandover(ImsCallSession session,
- int srcAccessTech, int targetAccessTech,
+ int srcNetworkType, int targetNetworkType,
ImsReasonInfo reasonInfo) {
// no-op
}
@@ -381,12 +379,12 @@
* Called when session access technology change fails
*
* @param session IMS session object
- * @param srcAccessTech original access technology
- * @param targetAccessTech new access technology
+ * @param srcNetworkType original access technology
+ * @param targetNetworkType new access technology
* @param reasonInfo handover failure reason
*/
public void callSessionHandoverFailed(ImsCallSession session,
- int srcAccessTech, int targetAccessTech,
+ int srcNetworkType, int targetNetworkType,
ImsReasonInfo reasonInfo) {
// no-op
}
@@ -1303,20 +1301,19 @@
/**
* Notifies of a case where a {@link ImsCallSession} may
* potentially handover from one radio technology to another.
- * @param srcAccessTech The source radio access technology; one of the access technology
- * constants defined in {@link android.telephony.ServiceState}. For
- * example
- * {@link android.telephony.ServiceState#RIL_RADIO_TECHNOLOGY_LTE}.
- * @param targetAccessTech The target radio access technology; one of the access technology
- * constants defined in {@link android.telephony.ServiceState}. For
- * example
- * {@link android.telephony.ServiceState#RIL_RADIO_TECHNOLOGY_LTE}.
+ * @param srcNetworkType The source network type; one of the network type constants defined
+ * in {@link android.telephony.TelephonyManager}. For example
+ * {@link android.telephony.TelephonyManager#NETWORK_TYPE_LTE}.
+ * @param targetNetworkType The target radio access technology; one of the network type
+ * constants defined in {@link android.telephony.TelephonyManager}.
+ * For example
+ * {@link android.telephony.TelephonyManager#NETWORK_TYPE_LTE}.
*/
@Override
- public void callSessionMayHandover(int srcAccessTech, int targetAccessTech) {
+ public void callSessionMayHandover(int srcNetworkType, int targetNetworkType) {
if (mListener != null) {
- mListener.callSessionMayHandover(ImsCallSession.this, srcAccessTech,
- targetAccessTech);
+ mListener.callSessionMayHandover(ImsCallSession.this, srcNetworkType,
+ targetNetworkType);
}
}
@@ -1324,11 +1321,11 @@
* Notifies of handover information for this call
*/
@Override
- public void callSessionHandover(int srcAccessTech, int targetAccessTech,
+ public void callSessionHandover(int srcNetworkType, int targetNetworkType,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
- mListener.callSessionHandover(ImsCallSession.this, srcAccessTech,
- targetAccessTech, reasonInfo);
+ mListener.callSessionHandover(ImsCallSession.this, srcNetworkType,
+ targetNetworkType, reasonInfo);
}
}
@@ -1336,11 +1333,11 @@
* Notifies of handover failure info for this call
*/
@Override
- public void callSessionHandoverFailed(int srcAccessTech, int targetAccessTech,
+ public void callSessionHandoverFailed(int srcNetworkType, int targetNetworkType,
ImsReasonInfo reasonInfo) {
if (mListener != null) {
- mListener.callSessionHandoverFailed(ImsCallSession.this, srcAccessTech,
- targetAccessTech, reasonInfo);
+ mListener.callSessionHandoverFailed(ImsCallSession.this, srcNetworkType,
+ targetNetworkType, reasonInfo);
}
}
diff --git a/telephony/java/android/telephony/ims/ImsCallSessionListener.java b/telephony/java/android/telephony/ims/ImsCallSessionListener.java
index e11886f..025721c 100644
--- a/telephony/java/android/telephony/ims/ImsCallSessionListener.java
+++ b/telephony/java/android/telephony/ims/ImsCallSessionListener.java
@@ -17,10 +17,13 @@
package android.telephony.ims;
import android.annotation.NonNull;
+import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.annotation.TestApi;
import android.os.RemoteException;
+import android.telephony.Annotation;
import android.telephony.CallQuality;
+import android.telephony.ServiceState;
import android.telephony.ims.aidl.IImsCallSessionListener;
import android.telephony.ims.stub.ImsCallSessionImplBase;
@@ -476,11 +479,27 @@
* @param targetAccessTech The target radio access technology; one of the access technology
* constants defined in {@link android.telephony.ServiceState}. For example
* {@link android.telephony.ServiceState#RIL_RADIO_TECHNOLOGY_LTE}.
+ * @deprecated Uses hidden constants for radio access technology, use
+ * {@link #onMayHandover(int, int)} instead.
*/
- public void callSessionMayHandover(int srcAccessTech, int targetAccessTech)
- {
+ @Deprecated
+ public void callSessionMayHandover(int srcAccessTech, int targetAccessTech) {
+ // Use new API internally.
+ onMayHandover(ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
+ ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech));
+ }
+
+ /**
+ * Notify the framework that the associated {@link ImsCallSession} may handover from one network
+ * type to another.
+ *
+ * @param srcNetworkType The source network type.
+ * @param targetNetworkType The target network type.
+ */
+ public void onMayHandover(@Annotation.NetworkType int srcNetworkType,
+ @Annotation.NetworkType int targetNetworkType) {
try {
- mListener.callSessionMayHandover(srcAccessTech, targetAccessTech);
+ mListener.callSessionMayHandover(srcNetworkType, targetNetworkType);
} catch (RemoteException e) {
throw new RuntimeException(e);
}
@@ -494,11 +513,29 @@
* @param targetAccessTech new access technology, defined in
* {@link android.telephony.ServiceState}.
* @param reasonInfo The {@link ImsReasonInfo} associated with this handover.
+ * @deprecated Uses hidden radio access technology constants, use
+ * {@link #onHandover(int, int, ImsReasonInfo)} instead.
*/
+ @Deprecated
public void callSessionHandover(int srcAccessTech, int targetAccessTech,
ImsReasonInfo reasonInfo) {
+ // Use new API internally.
+ onHandover(ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
+ ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech), reasonInfo);
+ }
+
+ /**
+ * Notify the framework that the associated {@link ImsCallSession} has handed over from one
+ * network type to another.
+ *
+ * @param srcNetworkType original network type.
+ * @param targetNetworkType target network type after handover..
+ * @param reasonInfo An optional {@link ImsReasonInfo} associated with this handover.
+ */
+ public void onHandover(@Annotation.NetworkType int srcNetworkType,
+ @Annotation.NetworkType int targetNetworkType, @Nullable ImsReasonInfo reasonInfo) {
try {
- mListener.callSessionHandover(srcAccessTech, targetAccessTech, reasonInfo);
+ mListener.callSessionHandover(srcNetworkType, targetNetworkType, reasonInfo);
} catch (RemoteException e) {
throw new RuntimeException(e);
}
@@ -510,11 +547,28 @@
* @param srcAccessTech original access technology
* @param targetAccessTech new access technology
* @param reasonInfo An {@link ImsReasonInfo} detailing the reason for the failure.
+ * @deprecated Uses hidden radio access technology constants, use
+ * {@link #onHandoverFailed(int, int, ImsReasonInfo)} instead
*/
+ @Deprecated
public void callSessionHandoverFailed(int srcAccessTech, int targetAccessTech,
ImsReasonInfo reasonInfo) {
+ // Use new API internally.
+ onHandoverFailed(ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
+ ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech), reasonInfo);
+ }
+
+ /**
+ * The IMS call session's access technology change has failed..
+ *
+ * @param srcNetworkType original network type.
+ * @param targetNetworkType target network type that the handover failed for.
+ * @param reasonInfo An {@link ImsReasonInfo} detailing the reason for the failure.
+ */
+ public void onHandoverFailed(@Annotation.NetworkType int srcNetworkType,
+ @Annotation.NetworkType int targetNetworkType, @NonNull ImsReasonInfo reasonInfo) {
try {
- mListener.callSessionHandoverFailed(srcAccessTech, targetAccessTech, reasonInfo);
+ mListener.callSessionHandoverFailed(srcNetworkType, targetNetworkType, reasonInfo);
} catch (RemoteException e) {
throw new RuntimeException(e);
}
diff --git a/telephony/java/android/telephony/ims/aidl/IImsCallSessionListener.aidl b/telephony/java/android/telephony/ims/aidl/IImsCallSessionListener.aidl
index d64e67a..cc2ebb9 100644
--- a/telephony/java/android/telephony/ims/aidl/IImsCallSessionListener.aidl
+++ b/telephony/java/android/telephony/ims/aidl/IImsCallSessionListener.aidl
@@ -92,11 +92,11 @@
/**
* Notifies of handover information for this call
*/
- void callSessionHandover(int srcAccessTech, int targetAccessTech,
+ void callSessionHandover(int srcNetworkType, int targetNetworkType,
in ImsReasonInfo reasonInfo);
- void callSessionHandoverFailed(int srcAccessTech, int targetAccessTech,
+ void callSessionHandoverFailed(int srcNetworkType, int targetNetworkType,
in ImsReasonInfo reasonInfo);
- void callSessionMayHandover(int srcAccessTech, int targetAccessTech);
+ void callSessionMayHandover(int srcNetworkType, int targetNetworkType);
/**
* Notifies the TTY mode change by remote party.
diff --git a/telephony/java/android/telephony/ims/compat/stub/ImsCallSessionImplBase.java b/telephony/java/android/telephony/ims/compat/stub/ImsCallSessionImplBase.java
index acab738..75bd6a7 100644
--- a/telephony/java/android/telephony/ims/compat/stub/ImsCallSessionImplBase.java
+++ b/telephony/java/android/telephony/ims/compat/stub/ImsCallSessionImplBase.java
@@ -20,6 +20,7 @@
import android.os.Message;
import android.os.RemoteException;
import android.telephony.CallQuality;
+import android.telephony.ServiceState;
import android.telephony.ims.ImsCallProfile;
import android.telephony.ims.ImsCallSession;
import android.telephony.ims.ImsConferenceState;
@@ -547,19 +548,25 @@
@Override
public void callSessionHandover(IImsCallSession i, int srcAccessTech, int targetAccessTech,
ImsReasonInfo reasonInfo) throws RemoteException {
- mNewListener.callSessionHandover(srcAccessTech, targetAccessTech, reasonInfo);
+ mNewListener.callSessionHandover(
+ ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
+ ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech), reasonInfo);
}
@Override
public void callSessionHandoverFailed(IImsCallSession i, int srcAccessTech,
int targetAccessTech, ImsReasonInfo reasonInfo) throws RemoteException {
- mNewListener.callSessionHandoverFailed(srcAccessTech, targetAccessTech, reasonInfo);
+ mNewListener.callSessionHandoverFailed(
+ ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
+ ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech), reasonInfo);
}
@Override
public void callSessionMayHandover(IImsCallSession i, int srcAccessTech, int targetAccessTech)
throws RemoteException {
- mNewListener.callSessionMayHandover(srcAccessTech, targetAccessTech);
+ mNewListener.callSessionMayHandover(
+ ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
+ ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech));
}
@Override
diff --git a/telephony/java/com/android/internal/telephony/ITelephony.aidl b/telephony/java/com/android/internal/telephony/ITelephony.aidl
index 7add741..e88c773 100644
--- a/telephony/java/com/android/internal/telephony/ITelephony.aidl
+++ b/telephony/java/com/android/internal/telephony/ITelephony.aidl
@@ -990,6 +990,11 @@
boolean isManualNetworkSelectionAllowed(int subId);
/**
+ * Enable or disable always reporting signal strength changes from radio.
+ */
+ void setAlwaysReportSignalStrength(int subId, boolean isEnable);
+
+ /**
* Get P-CSCF address from PCO after data connection is established or modified.
* @param apnType the apnType, "ims" for IMS APN, "emergency" for EMERGENCY APN
* @param callingPackage The package making the call.
diff --git a/wifi/Android.bp b/wifi/Android.bp
index 099cbff..8fc8af9 100644
--- a/wifi/Android.bp
+++ b/wifi/Android.bp
@@ -12,9 +12,15 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+filegroup {
+ name: "framework-wifi-updatable-exported-aidl-sources",
+ srcs: ["aidl-export/**/*.aidl"],
+ path: "aidl-export",
+ visibility: ["//visibility:private"],
+}
filegroup {
- name: "framework-wifi-updatable-sources",
+ name: "framework-wifi-updatable-java-sources",
srcs: [
"java/**/*.java",
"java/**/*.aidl",
@@ -23,6 +29,15 @@
":framework-wifi-non-updatable-sources"
],
path: "java",
+ visibility: ["//visibility:private"],
+}
+
+filegroup {
+ name: "framework-wifi-updatable-sources",
+ srcs: [
+ ":framework-wifi-updatable-java-sources",
+ ":framework-wifi-updatable-exported-aidl-sources",
+ ],
}
filegroup {
diff --git a/wifi/java/android/net/wifi/ScanResult.aidl b/wifi/aidl-export/android/net/wifi/ScanResult.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/ScanResult.aidl
rename to wifi/aidl-export/android/net/wifi/ScanResult.aidl
diff --git a/wifi/java/android/net/wifi/SoftApCapability.aidl b/wifi/aidl-export/android/net/wifi/SoftApCapability.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/SoftApCapability.aidl
rename to wifi/aidl-export/android/net/wifi/SoftApCapability.aidl
diff --git a/wifi/java/android/net/wifi/SoftApConfiguration.aidl b/wifi/aidl-export/android/net/wifi/SoftApConfiguration.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/SoftApConfiguration.aidl
rename to wifi/aidl-export/android/net/wifi/SoftApConfiguration.aidl
diff --git a/wifi/java/android/net/wifi/SoftApInfo.aidl b/wifi/aidl-export/android/net/wifi/SoftApInfo.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/SoftApInfo.aidl
rename to wifi/aidl-export/android/net/wifi/SoftApInfo.aidl
diff --git a/wifi/java/android/net/wifi/WifiClient.aidl b/wifi/aidl-export/android/net/wifi/WifiClient.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WifiClient.aidl
rename to wifi/aidl-export/android/net/wifi/WifiClient.aidl
diff --git a/wifi/java/android/net/wifi/WifiConfiguration.aidl b/wifi/aidl-export/android/net/wifi/WifiConfiguration.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WifiConfiguration.aidl
rename to wifi/aidl-export/android/net/wifi/WifiConfiguration.aidl
diff --git a/wifi/java/android/net/wifi/WifiEnterpriseConfig.aidl b/wifi/aidl-export/android/net/wifi/WifiEnterpriseConfig.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WifiEnterpriseConfig.aidl
rename to wifi/aidl-export/android/net/wifi/WifiEnterpriseConfig.aidl
diff --git a/wifi/java/android/net/wifi/WifiInfo.aidl b/wifi/aidl-export/android/net/wifi/WifiInfo.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WifiInfo.aidl
rename to wifi/aidl-export/android/net/wifi/WifiInfo.aidl
diff --git a/wifi/java/android/net/wifi/WifiNetworkConnectionStatistics.aidl b/wifi/aidl-export/android/net/wifi/WifiNetworkConnectionStatistics.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WifiNetworkConnectionStatistics.aidl
rename to wifi/aidl-export/android/net/wifi/WifiNetworkConnectionStatistics.aidl
diff --git a/wifi/java/android/net/wifi/WifiNetworkSuggestion.aidl b/wifi/aidl-export/android/net/wifi/WifiNetworkSuggestion.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WifiNetworkSuggestion.aidl
rename to wifi/aidl-export/android/net/wifi/WifiNetworkSuggestion.aidl
diff --git a/wifi/java/android/net/wifi/WifiUsabilityStatsEntry.aidl b/wifi/aidl-export/android/net/wifi/WifiUsabilityStatsEntry.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WifiUsabilityStatsEntry.aidl
rename to wifi/aidl-export/android/net/wifi/WifiUsabilityStatsEntry.aidl
diff --git a/wifi/java/android/net/wifi/WpsInfo.aidl b/wifi/aidl-export/android/net/wifi/WpsInfo.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/WpsInfo.aidl
rename to wifi/aidl-export/android/net/wifi/WpsInfo.aidl
diff --git a/wifi/java/android/net/wifi/aware/Characteristics.aidl b/wifi/aidl-export/android/net/wifi/aware/Characteristics.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/aware/Characteristics.aidl
rename to wifi/aidl-export/android/net/wifi/aware/Characteristics.aidl
diff --git a/wifi/java/android/net/wifi/aware/PublishConfig.aidl b/wifi/aidl-export/android/net/wifi/aware/PublishConfig.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/aware/PublishConfig.aidl
rename to wifi/aidl-export/android/net/wifi/aware/PublishConfig.aidl
diff --git a/wifi/java/android/net/wifi/aware/SubscribeConfig.aidl b/wifi/aidl-export/android/net/wifi/aware/SubscribeConfig.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/aware/SubscribeConfig.aidl
rename to wifi/aidl-export/android/net/wifi/aware/SubscribeConfig.aidl
diff --git a/wifi/java/android/net/wifi/hotspot2/OsuProvider.aidl b/wifi/aidl-export/android/net/wifi/hotspot2/OsuProvider.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/hotspot2/OsuProvider.aidl
rename to wifi/aidl-export/android/net/wifi/hotspot2/OsuProvider.aidl
diff --git a/wifi/java/android/net/wifi/hotspot2/PasspointConfiguration.aidl b/wifi/aidl-export/android/net/wifi/hotspot2/PasspointConfiguration.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/hotspot2/PasspointConfiguration.aidl
rename to wifi/aidl-export/android/net/wifi/hotspot2/PasspointConfiguration.aidl
diff --git a/wifi/java/android/net/wifi/hotspot2/pps/Credential.aidl b/wifi/aidl-export/android/net/wifi/hotspot2/pps/Credential.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/hotspot2/pps/Credential.aidl
rename to wifi/aidl-export/android/net/wifi/hotspot2/pps/Credential.aidl
diff --git a/wifi/java/android/net/wifi/hotspot2/pps/HomeSp.aidl b/wifi/aidl-export/android/net/wifi/hotspot2/pps/HomeSp.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/hotspot2/pps/HomeSp.aidl
rename to wifi/aidl-export/android/net/wifi/hotspot2/pps/HomeSp.aidl
diff --git a/wifi/java/android/net/wifi/p2p/WifiP2pConfig.aidl b/wifi/aidl-export/android/net/wifi/p2p/WifiP2pConfig.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/p2p/WifiP2pConfig.aidl
rename to wifi/aidl-export/android/net/wifi/p2p/WifiP2pConfig.aidl
diff --git a/wifi/java/android/net/wifi/p2p/WifiP2pDevice.aidl b/wifi/aidl-export/android/net/wifi/p2p/WifiP2pDevice.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/p2p/WifiP2pDevice.aidl
rename to wifi/aidl-export/android/net/wifi/p2p/WifiP2pDevice.aidl
diff --git a/wifi/java/android/net/wifi/p2p/WifiP2pDeviceList.aidl b/wifi/aidl-export/android/net/wifi/p2p/WifiP2pDeviceList.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/p2p/WifiP2pDeviceList.aidl
rename to wifi/aidl-export/android/net/wifi/p2p/WifiP2pDeviceList.aidl
diff --git a/wifi/java/android/net/wifi/p2p/WifiP2pGroup.aidl b/wifi/aidl-export/android/net/wifi/p2p/WifiP2pGroup.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/p2p/WifiP2pGroup.aidl
rename to wifi/aidl-export/android/net/wifi/p2p/WifiP2pGroup.aidl
diff --git a/wifi/java/android/net/wifi/p2p/WifiP2pInfo.aidl b/wifi/aidl-export/android/net/wifi/p2p/WifiP2pInfo.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/p2p/WifiP2pInfo.aidl
rename to wifi/aidl-export/android/net/wifi/p2p/WifiP2pInfo.aidl
diff --git a/wifi/java/android/net/wifi/p2p/nsd/WifiP2pServiceInfo.aidl b/wifi/aidl-export/android/net/wifi/p2p/nsd/WifiP2pServiceInfo.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/p2p/nsd/WifiP2pServiceInfo.aidl
rename to wifi/aidl-export/android/net/wifi/p2p/nsd/WifiP2pServiceInfo.aidl
diff --git a/wifi/java/android/net/wifi/p2p/nsd/WifiP2pServiceRequest.aidl b/wifi/aidl-export/android/net/wifi/p2p/nsd/WifiP2pServiceRequest.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/p2p/nsd/WifiP2pServiceRequest.aidl
rename to wifi/aidl-export/android/net/wifi/p2p/nsd/WifiP2pServiceRequest.aidl
diff --git a/wifi/java/android/net/wifi/rtt/RangingRequest.aidl b/wifi/aidl-export/android/net/wifi/rtt/RangingRequest.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/rtt/RangingRequest.aidl
rename to wifi/aidl-export/android/net/wifi/rtt/RangingRequest.aidl
diff --git a/wifi/java/android/net/wifi/rtt/RangingResult.aidl b/wifi/aidl-export/android/net/wifi/rtt/RangingResult.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/rtt/RangingResult.aidl
rename to wifi/aidl-export/android/net/wifi/rtt/RangingResult.aidl
diff --git a/wifi/java/android/net/wifi/rtt/ResponderConfig.aidl b/wifi/aidl-export/android/net/wifi/rtt/ResponderConfig.aidl
similarity index 100%
rename from wifi/java/android/net/wifi/rtt/ResponderConfig.aidl
rename to wifi/aidl-export/android/net/wifi/rtt/ResponderConfig.aidl
diff --git a/wifi/java/android/net/wifi/SoftApConfiguration.java b/wifi/java/android/net/wifi/SoftApConfiguration.java
index c02f8c3..c8fd243 100644
--- a/wifi/java/android/net/wifi/SoftApConfiguration.java
+++ b/wifi/java/android/net/wifi/SoftApConfiguration.java
@@ -212,7 +212,6 @@
*/
public static final int SECURITY_TYPE_OPEN = 0;
-
/**
* The definition of security type WPA2-PSK.
*/
@@ -408,7 +407,11 @@
/**
* Get security type params which depends on which security passphrase to set.
*
- * @return One of the security types from {@link SecurityType}.
+ * @return One of:
+ * {@link #SECURITY_TYPE_OPEN},
+ * {@link #SECURITY_TYPE_WPA2_PSK},
+ * {@link #SECURITY_TYPE_WPA3_SAE_TRANSITION},
+ * {@link #SECURITY_TYPE_WPA3_SAE}
*/
public @SecurityType int getSecurityType() {
return mSecurityType;
diff --git a/wifi/java/android/net/wifi/WifiConfiguration.java b/wifi/java/android/net/wifi/WifiConfiguration.java
index e84369f..e2befeb 100644
--- a/wifi/java/android/net/wifi/WifiConfiguration.java
+++ b/wifi/java/android/net/wifi/WifiConfiguration.java
@@ -402,29 +402,29 @@
public static final String[] strings = { "current", "disabled", "enabled" };
}
- /**
- * Security types we support.
- */
- /** @hide */
+ /** Security type for an open network. */
public static final int SECURITY_TYPE_OPEN = 0;
- /** @hide */
+ /** Security type for a WEP network. */
public static final int SECURITY_TYPE_WEP = 1;
- /** @hide */
+ /** Security type for a PSK network. */
public static final int SECURITY_TYPE_PSK = 2;
- /** @hide */
+ /** Security type for an EAP network. */
public static final int SECURITY_TYPE_EAP = 3;
- /** @hide */
+ /** Security type for an SAE network. */
public static final int SECURITY_TYPE_SAE = 4;
- /** @hide */
+ /** Security type for an EAP Suite B network. */
public static final int SECURITY_TYPE_EAP_SUITE_B = 5;
- /** @hide */
+ /** Security type for an OWE network. */
public static final int SECURITY_TYPE_OWE = 6;
- /** @hide */
+ /** Security type for a WAPI PSK network. */
public static final int SECURITY_TYPE_WAPI_PSK = 7;
- /** @hide */
+ /** Security type for a WAPI Certificate network. */
public static final int SECURITY_TYPE_WAPI_CERT = 8;
- /** @hide */
+ /**
+ * Security types we support.
+ * @hide
+ */
@Retention(RetentionPolicy.SOURCE)
@IntDef(prefix = { "SECURITY_TYPE_" }, value = {
SECURITY_TYPE_OPEN,
@@ -440,10 +440,19 @@
public @interface SecurityType {}
/**
- * @hide
- * Set security params (sets the various bitsets exposed in WifiConfiguration).
+ * Set the various security params to correspond to the provided security type.
+ * This is accomplished by setting the various BitSets exposed in WifiConfiguration.
*
- * @param securityType One of the security types from {@link SecurityType}.
+ * @param securityType One of the following security types:
+ * {@link #SECURITY_TYPE_OPEN},
+ * {@link #SECURITY_TYPE_WEP},
+ * {@link #SECURITY_TYPE_PSK},
+ * {@link #SECURITY_TYPE_EAP},
+ * {@link #SECURITY_TYPE_SAE},
+ * {@link #SECURITY_TYPE_EAP_SUITE_B},
+ * {@link #SECURITY_TYPE_OWE},
+ * {@link #SECURITY_TYPE_WAPI_PSK}, or
+ * {@link #SECURITY_TYPE_WAPI_CERT}
*/
public void setSecurityParams(@SecurityType int securityType) {
// Clear all the bitsets.
diff --git a/wifi/java/android/net/wifi/WifiManager.java b/wifi/java/android/net/wifi/WifiManager.java
index c35303d..208ce9c 100644
--- a/wifi/java/android/net/wifi/WifiManager.java
+++ b/wifi/java/android/net/wifi/WifiManager.java
@@ -201,6 +201,13 @@
*/
public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_NOT_ALLOWED = 6;
+ /**
+ * Reason code if one or more of the network suggestions added is invalid.
+ *
+ * Please user {@link WifiNetworkSuggestion.Builder} to create network suggestions.
+ */
+ public static final int STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_INVALID = 7;
+
/** @hide */
@IntDef(prefix = { "STATUS_NETWORK_SUGGESTIONS_" }, value = {
STATUS_NETWORK_SUGGESTIONS_SUCCESS,
@@ -210,6 +217,7 @@
STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_EXCEEDS_MAX_PER_APP,
STATUS_NETWORK_SUGGESTIONS_ERROR_REMOVE_INVALID,
STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_NOT_ALLOWED,
+ STATUS_NETWORK_SUGGESTIONS_ERROR_ADD_INVALID,
})
@Retention(RetentionPolicy.SOURCE)
public @interface NetworkSuggestionsStatusCode {}