Merge "Limit broadcast rate for low priority DropBox entries"
diff --git a/api/current.txt b/api/current.txt
index 7491023..1e6bf2c 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -23044,6 +23044,9 @@
method public int getUsage();
method public int getVolumeControlStream();
method public void writeToParcel(android.os.Parcel, int);
+ field public static final int ALLOW_CAPTURE_BY_ALL = 1; // 0x1
+ field public static final int ALLOW_CAPTURE_BY_NONE = 3; // 0x3
+ field public static final int ALLOW_CAPTURE_BY_SYSTEM = 2; // 0x2
field public static final int CONTENT_TYPE_MOVIE = 3; // 0x3
field public static final int CONTENT_TYPE_MUSIC = 2; // 0x2
field public static final int CONTENT_TYPE_SONIFICATION = 4; // 0x4
@@ -23075,7 +23078,7 @@
ctor public AudioAttributes.Builder();
ctor public AudioAttributes.Builder(android.media.AudioAttributes);
method public android.media.AudioAttributes build();
- method @NonNull public android.media.AudioAttributes.Builder setAllowCapture(boolean);
+ method @NonNull public android.media.AudioAttributes.Builder setAllowedCapturePolicy(int);
method public android.media.AudioAttributes.Builder setContentType(int);
method public android.media.AudioAttributes.Builder setFlags(int);
method public android.media.AudioAttributes.Builder setLegacyStreamType(int);
@@ -25072,7 +25075,7 @@
field public static final String KEY_LANGUAGE = "language";
field public static final String KEY_LATENCY = "latency";
field public static final String KEY_LEVEL = "level";
- field public static final String KEY_MAX_BFRAMES = "max-bframes";
+ field public static final String KEY_MAX_B_FRAMES = "max-bframes";
field public static final String KEY_MAX_FPS_TO_ENCODER = "max-fps-to-encoder";
field public static final String KEY_MAX_HEIGHT = "max-height";
field public static final String KEY_MAX_INPUT_SIZE = "max-input-size";
@@ -38854,6 +38857,7 @@
field public static final String ACTION_APPLICATION_DETAILS_SETTINGS = "android.settings.APPLICATION_DETAILS_SETTINGS";
field public static final String ACTION_APPLICATION_DEVELOPMENT_SETTINGS = "android.settings.APPLICATION_DEVELOPMENT_SETTINGS";
field public static final String ACTION_APPLICATION_SETTINGS = "android.settings.APPLICATION_SETTINGS";
+ field public static final String ACTION_APP_NOTIFICATION_BUBBLE_SETTINGS = "android.settings.APP_NOTIFICATION_BUBBLE_SETTINGS";
field public static final String ACTION_APP_NOTIFICATION_SETTINGS = "android.settings.APP_NOTIFICATION_SETTINGS";
field public static final String ACTION_APP_SEARCH_SETTINGS = "android.settings.APP_SEARCH_SETTINGS";
field public static final String ACTION_APP_USAGE_SETTINGS = "android.settings.action.APP_USAGE_SETTINGS";
diff --git a/api/system-current.txt b/api/system-current.txt
index d2c5844..48b1385 100644
--- a/api/system-current.txt
+++ b/api/system-current.txt
@@ -49,6 +49,7 @@
field @Deprecated public static final String BROADCAST_NETWORK_PRIVILEGED = "android.permission.BROADCAST_NETWORK_PRIVILEGED";
field public static final String CAMERA_DISABLE_TRANSMIT_LED = "android.permission.CAMERA_DISABLE_TRANSMIT_LED";
field public static final String CAPTURE_AUDIO_HOTWORD = "android.permission.CAPTURE_AUDIO_HOTWORD";
+ field public static final String CAPTURE_MEDIA_OUTPUT = "android.permission.CAPTURE_MEDIA_OUTPUT";
field public static final String CAPTURE_TV_INPUT = "android.permission.CAPTURE_TV_INPUT";
field public static final String CHANGE_APP_IDLE_STATE = "android.permission.CHANGE_APP_IDLE_STATE";
field public static final String CHANGE_DEVICE_IDLE_TEMP_WHITELIST = "android.permission.CHANGE_DEVICE_IDLE_TEMP_WHITELIST";
@@ -564,7 +565,7 @@
method @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) public byte[] getStatsMetadata() throws android.app.StatsManager.StatsUnavailableException;
method @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) public void removeConfig(long) throws android.app.StatsManager.StatsUnavailableException;
method @Deprecated @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) public boolean removeConfiguration(long);
- method @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) public long[] setActiveConfigsChangedOperation(@Nullable android.app.PendingIntent) throws android.app.StatsManager.StatsUnavailableException;
+ method @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) @NonNull public long[] setActiveConfigsChangedOperation(@Nullable android.app.PendingIntent) throws android.app.StatsManager.StatsUnavailableException;
method @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) public void setBroadcastSubscriber(android.app.PendingIntent, long, long) throws android.app.StatsManager.StatsUnavailableException;
method @Deprecated @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) public boolean setBroadcastSubscriber(long, long, android.app.PendingIntent);
method @Deprecated @RequiresPermission(allOf={android.Manifest.permission.DUMP, android.Manifest.permission.PACKAGE_USAGE_STATS}) public boolean setDataFetchOperation(long, android.app.PendingIntent);
@@ -3377,19 +3378,19 @@
public class LocationManager {
method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public void flushGnssBatch();
+ method @Nullable public String getExtraLocationControllerPackage();
method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public int getGnssBatchSize();
method @Nullable public android.location.GnssCapabilities getGnssCapabilities();
- method @Nullable public String getLocationControllerExtraPackage();
method @RequiresPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) public void injectGnssMeasurementCorrections(@NonNull android.location.GnssMeasurementCorrections);
- method public boolean isLocationControllerExtraPackageEnabled();
+ method public boolean isExtraLocationControllerPackageEnabled();
method public boolean isLocationEnabledForUser(@NonNull android.os.UserHandle);
method public boolean isProviderEnabledForUser(@NonNull String, @NonNull android.os.UserHandle);
method public boolean isProviderPackage(@NonNull String);
method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public boolean registerGnssBatchedLocationCallback(long, boolean, @NonNull android.location.BatchedLocationCallback, @Nullable android.os.Handler);
method @RequiresPermission(anyOf={android.Manifest.permission.ACCESS_COARSE_LOCATION, android.Manifest.permission.ACCESS_FINE_LOCATION}) public void requestLocationUpdates(@NonNull android.location.LocationRequest, @NonNull android.location.LocationListener, @Nullable android.os.Looper);
method @RequiresPermission(anyOf={android.Manifest.permission.ACCESS_COARSE_LOCATION, android.Manifest.permission.ACCESS_FINE_LOCATION}) public void requestLocationUpdates(@NonNull android.location.LocationRequest, @NonNull android.app.PendingIntent);
- method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public void setLocationControllerExtraPackage(@NonNull String);
- method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public void setLocationControllerExtraPackageEnabled(boolean);
+ method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public void setExtraLocationControllerPackage(@Nullable String);
+ method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public void setExtraLocationControllerPackageEnabled(boolean);
method @RequiresPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS) public void setLocationEnabledForUser(boolean, @NonNull android.os.UserHandle);
method @Deprecated @RequiresPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS) public boolean setProviderEnabledForUser(@NonNull String, boolean, @NonNull android.os.UserHandle);
method @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public boolean unregisterGnssBatchedLocationCallback(@NonNull android.location.BatchedLocationCallback);
@@ -3602,6 +3603,7 @@
ctor public AudioMixingRule.Builder();
method public android.media.audiopolicy.AudioMixingRule.Builder addMixRule(int, Object) throws java.lang.IllegalArgumentException;
method public android.media.audiopolicy.AudioMixingRule.Builder addRule(android.media.AudioAttributes, int) throws java.lang.IllegalArgumentException;
+ method @NonNull public android.media.audiopolicy.AudioMixingRule.Builder allowPrivilegedPlaybackCapture(boolean);
method public android.media.audiopolicy.AudioMixingRule build();
method public android.media.audiopolicy.AudioMixingRule.Builder excludeMixRule(int, Object) throws java.lang.IllegalArgumentException;
method public android.media.audiopolicy.AudioMixingRule.Builder excludeRule(android.media.AudioAttributes, int) throws java.lang.IllegalArgumentException;
diff --git a/api/system-removed.txt b/api/system-removed.txt
index 9780d43..162f212 100644
--- a/api/system-removed.txt
+++ b/api/system-removed.txt
@@ -67,6 +67,8 @@
method @Deprecated public boolean addGpsNavigationMessageListener(android.location.GpsNavigationMessageEvent.Listener);
method @Deprecated public void removeGpsMeasurementListener(android.location.GpsMeasurementsEvent.Listener);
method @Deprecated public void removeGpsNavigationMessageListener(android.location.GpsNavigationMessageEvent.Listener);
+ method @Deprecated @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public void setLocationControllerExtraPackage(String);
+ method @Deprecated @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public void setLocationControllerExtraPackageEnabled(boolean);
}
}
diff --git a/core/java/android/app/ApplicationLoaders.java b/core/java/android/app/ApplicationLoaders.java
index 9ef24c6..faa30f3 100644
--- a/core/java/android/app/ApplicationLoaders.java
+++ b/core/java/android/app/ApplicationLoaders.java
@@ -17,20 +17,27 @@
package android.app;
import android.annotation.UnsupportedAppUsage;
+import android.content.pm.SharedLibraryInfo;
import android.os.Build;
import android.os.GraphicsEnvironment;
import android.os.Trace;
import android.util.ArrayMap;
+import android.util.Log;
import com.android.internal.os.ClassLoaderFactory;
import dalvik.system.PathClassLoader;
+import java.util.ArrayList;
import java.util.Collection;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
/** @hide */
public class ApplicationLoaders {
+ private static final String TAG = "ApplicationLoaders";
+
@UnsupportedAppUsage
public static ApplicationLoaders getDefault() {
return gApplicationLoaders;
@@ -54,6 +61,26 @@
libraryPermittedPath, parent, zip, classLoaderName, sharedLibraries);
}
+ /**
+ * Gets a class loader for a shared library. Additional dependent shared libraries are allowed
+ * to be specified (sharedLibraries).
+ *
+ * Additionally, as an optimization, this will return a pre-created ClassLoader if one has
+ * been cached by createAndCacheNonBootclasspathSystemClassLoaders.
+ */
+ ClassLoader getSharedLibraryClassLoaderWithSharedLibraries(String zip, int targetSdkVersion,
+ boolean isBundled, String librarySearchPath, String libraryPermittedPath,
+ ClassLoader parent, String classLoaderName, List<ClassLoader> sharedLibraries) {
+ ClassLoader loader = getCachedNonBootclasspathSystemLib(zip, parent, classLoaderName,
+ sharedLibraries);
+ if (loader != null) {
+ return loader;
+ }
+
+ return getClassLoaderWithSharedLibraries(zip, targetSdkVersion, isBundled,
+ librarySearchPath, libraryPermittedPath, parent, classLoaderName, sharedLibraries);
+ }
+
private ClassLoader getClassLoader(String zip, int targetSdkVersion, boolean isBundled,
String librarySearchPath, String libraryPermittedPath,
ClassLoader parent, String cacheKey,
@@ -95,7 +122,9 @@
classloader, librarySearchPath, libraryPermittedPath);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
- mLoaders.put(cacheKey, classloader);
+ if (cacheKey != null) {
+ mLoaders.put(cacheKey, classloader);
+ }
return classloader;
}
@@ -108,6 +137,112 @@
}
/**
+ * Caches system library class loaders which are not on the bootclasspath but are still used
+ * by many system apps.
+ *
+ * All libraries in the closure of libraries to be loaded must be in libs. A library can
+ * only depend on libraries that come before it in the list.
+ */
+ public void createAndCacheNonBootclasspathSystemClassLoaders(SharedLibraryInfo[] libs) {
+ if (mSystemLibsCacheMap != null) {
+ Log.wtf(TAG, "Already cached.");
+ return;
+ }
+
+ mSystemLibsCacheMap = new HashMap<String, CachedClassLoader>();
+
+ for (SharedLibraryInfo lib : libs) {
+ createAndCacheNonBootclasspathSystemClassLoader(lib);
+ }
+ }
+
+ /**
+ * Caches a single non-bootclasspath class loader.
+ *
+ * All of this library's dependencies must have previously been cached.
+ */
+ private void createAndCacheNonBootclasspathSystemClassLoader(SharedLibraryInfo lib) {
+ String path = lib.getPath();
+ List<SharedLibraryInfo> dependencies = lib.getDependencies();
+
+ // get cached classloaders for dependencies
+ ArrayList<ClassLoader> sharedLibraries = null;
+ if (dependencies != null) {
+ sharedLibraries = new ArrayList<ClassLoader>(dependencies.size());
+ for (SharedLibraryInfo dependency : dependencies) {
+ String dependencyPath = dependency.getPath();
+ CachedClassLoader cached = mSystemLibsCacheMap.get(dependencyPath);
+
+ if (cached == null) {
+ Log.e(TAG, "Failed to find dependency " + dependencyPath
+ + " of cached library " + path);
+ return;
+ }
+
+ sharedLibraries.add(cached.loader);
+ }
+ }
+
+ // assume cached libraries work with current sdk since they are built-in
+ ClassLoader classLoader = getClassLoader(path, Build.VERSION.SDK_INT, true /*isBundled*/,
+ null /*librarySearchPath*/, null /*libraryPermittedPath*/, null /*parent*/,
+ null /*cacheKey*/, null /*classLoaderName*/, sharedLibraries /*sharedLibraries*/);
+
+ if (classLoader == null) {
+ Log.e(TAG, "Failed to cache " + path);
+ return;
+ }
+
+ CachedClassLoader cached = new CachedClassLoader();
+ cached.loader = classLoader;
+ cached.sharedLibraries = sharedLibraries;
+
+ Log.d(TAG, "Created zygote-cached class loader: " + path);
+ mSystemLibsCacheMap.put(path, cached);
+ }
+
+ private static boolean sharedLibrariesEquals(List<ClassLoader> lhs, List<ClassLoader> rhs) {
+ if (lhs == null) {
+ return rhs == null;
+ }
+
+ return lhs.equals(rhs);
+ }
+
+ /**
+ * Returns lib cached with createAndCacheNonBootclasspathSystemClassLoader. This is called by
+ * the zygote during caching.
+ *
+ * If there is an error or the cache is not available, this returns null.
+ */
+ private ClassLoader getCachedNonBootclasspathSystemLib(String zip, ClassLoader parent,
+ String classLoaderName, List<ClassLoader> sharedLibraries) {
+ if (mSystemLibsCacheMap == null) {
+ return null;
+ }
+
+ // we only cache top-level libs with the default class loader
+ if (parent != null || classLoaderName != null) {
+ return null;
+ }
+
+ CachedClassLoader cached = mSystemLibsCacheMap.get(zip);
+ if (cached == null) {
+ return null;
+ }
+
+ // cached must be built and loaded in the same environment
+ if (!sharedLibrariesEquals(sharedLibraries, cached.sharedLibraries)) {
+ Log.w(TAG, "Unexpected environment for cached library: (" + sharedLibraries + "|"
+ + cached.sharedLibraries + ")");
+ return null;
+ }
+
+ Log.d(TAG, "Returning zygote-cached class loader: " + zip);
+ return cached.loader;
+ }
+
+ /**
* Creates a classloader for the WebView APK and places it in the cache of loaders maintained
* by this class. This is used in the WebView zygote, where its presence in the cache speeds up
* startup and enables memory sharing.
@@ -151,4 +286,18 @@
private final ArrayMap<String, ClassLoader> mLoaders = new ArrayMap<>();
private static final ApplicationLoaders gApplicationLoaders = new ApplicationLoaders();
+
+ private static class CachedClassLoader {
+ ClassLoader loader;
+
+ /**
+ * The shared libraries used when constructing loader for verification.
+ */
+ List<ClassLoader> sharedLibraries;
+ }
+
+ /**
+ * This is a map of zip to associated class loader.
+ */
+ private Map<String, CachedClassLoader> mSystemLibsCacheMap = null;
}
diff --git a/core/java/android/app/LoadedApk.java b/core/java/android/app/LoadedApk.java
index 41a9921..25e3573 100644
--- a/core/java/android/app/LoadedApk.java
+++ b/core/java/android/app/LoadedApk.java
@@ -676,7 +676,7 @@
// Shared libraries get a null parent: this has the side effect of having canonicalized
// shared libraries using ApplicationLoaders cache, which is the behavior we want.
- return ApplicationLoaders.getDefault().getClassLoaderWithSharedLibraries(jars,
+ return ApplicationLoaders.getDefault().getSharedLibraryClassLoaderWithSharedLibraries(jars,
mApplicationInfo.targetSdkVersion, isBundledApp, librarySearchPath,
libraryPermittedPath, /* parent */ null,
/* classLoaderName */ null, sharedLibraries);
diff --git a/core/java/android/app/StatsManager.java b/core/java/android/app/StatsManager.java
index 7746148..7aca2f2 100644
--- a/core/java/android/app/StatsManager.java
+++ b/core/java/android/app/StatsManager.java
@@ -18,6 +18,7 @@
import static android.Manifest.permission.DUMP;
import static android.Manifest.permission.PACKAGE_USAGE_STATS;
+import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.RequiresPermission;
import android.annotation.SystemApi;
@@ -295,7 +296,7 @@
* @throws StatsUnavailableException if unsuccessful due to failing to connect to stats service
*/
@RequiresPermission(allOf = { DUMP, PACKAGE_USAGE_STATS })
- public long[] setActiveConfigsChangedOperation(@Nullable PendingIntent pendingIntent)
+ public @NonNull long[] setActiveConfigsChangedOperation(@Nullable PendingIntent pendingIntent)
throws StatsUnavailableException {
synchronized (this) {
try {
diff --git a/core/java/android/app/usage/EventList.java b/core/java/android/app/usage/EventList.java
index aaae57e5..8c03405 100644
--- a/core/java/android/app/usage/EventList.java
+++ b/core/java/android/app/usage/EventList.java
@@ -103,4 +103,18 @@
}
return result;
}
+
+ /**
+ * Merge the {@link UsageEvents.Event events} in the given {@link EventList list} into this
+ * list while keeping the list sorted based on the event {@link
+ * UsageEvents.Event#mTimeStamp timestamps}.
+ *
+ * @param events The event list to merge
+ */
+ public void merge(EventList events) {
+ final int size = events.size();
+ for (int i = 0; i < size; i++) {
+ insert(events.get(i));
+ }
+ }
}
diff --git a/core/java/android/net/ConnectivityManager.java b/core/java/android/net/ConnectivityManager.java
index ae93cf0..4a64128 100644
--- a/core/java/android/net/ConnectivityManager.java
+++ b/core/java/android/net/ConnectivityManager.java
@@ -1934,6 +1934,8 @@
@NonNull Callback callback) {
ParcelFileDescriptor dup;
try {
+ // Dup is needed here as the pfd inside the socket is owned by the IpSecService,
+ // which cannot be obtained by the app process.
dup = ParcelFileDescriptor.dup(socket.getFileDescriptor());
} catch (IOException ignored) {
// Construct an invalid fd, so that if the user later calls start(), it will fail with
@@ -1975,6 +1977,7 @@
@NonNull Callback callback) {
ParcelFileDescriptor dup;
try {
+ // TODO: Consider remove unnecessary dup.
dup = pfd.dup();
} catch (IOException ignored) {
// Construct an invalid fd, so that if the user later calls start(), it will fail with
diff --git a/core/java/android/os/storage/StorageManager.java b/core/java/android/os/storage/StorageManager.java
index f6fcdb0..56c2f4c 100644
--- a/core/java/android/os/storage/StorageManager.java
+++ b/core/java/android/os/storage/StorageManager.java
@@ -135,6 +135,7 @@
@SystemService(Context.STORAGE_SERVICE)
public class StorageManager {
private static final String TAG = "StorageManager";
+ private static final boolean LOCAL_LOGV = Log.isLoggable(TAG, Log.VERBOSE);
/** {@hide} */
public static final String PROP_PRIMARY_PHYSICAL = "ro.vold.primary_physical";
@@ -1652,13 +1653,11 @@
/**
* Check that given app holds both permission and appop.
- *
- * @return {@code null} if the permission and appop are held, otherwise
- * returns a string indicating why access was denied.
+ * @hide
*/
- private boolean checkPermissionAndAppOp(boolean enforce, int pid, int uid, String packageName,
- String permission, int op) {
- if (mContext.checkPermission(permission, pid, uid) != PERMISSION_GRANTED) {
+ public static boolean checkPermissionAndAppOp(Context context, boolean enforce,
+ int pid, int uid, String packageName, String permission, int op) {
+ if (context.checkPermission(permission, pid, uid) != PERMISSION_GRANTED) {
if (enforce) {
throw new SecurityException(
"Permission " + permission + " denied for package " + packageName);
@@ -1667,7 +1666,7 @@
}
}
- final AppOpsManager appOps = mContext.getSystemService(AppOpsManager.class);
+ final AppOpsManager appOps = context.getSystemService(AppOpsManager.class);
final int mode = appOps.noteOpNoThrow(op, uid, packageName);
switch (mode) {
case AppOpsManager.MODE_ALLOWED:
@@ -1688,6 +1687,11 @@
}
}
+ private boolean checkPermissionAndAppOp(boolean enforce,
+ int pid, int uid, String packageName, String permission, int op) {
+ return checkPermissionAndAppOp(mContext, enforce, pid, uid, packageName, permission, op);
+ }
+
// Callers must hold both the old and new permissions, so that we can
// handle obscure cases like when an app targets Q but was installed on
// a device that was originally running on P before being upgraded to Q.
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index e754ab23..1cab250 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -1542,6 +1542,18 @@
= "android.settings.CHANNEL_NOTIFICATION_SETTINGS";
/**
+ * Activity Action: Show notification bubble settings for a single app.
+ * See {@link NotificationManager#areBubblesAllowed()}.
+ * <p>
+ * Input: {@link #EXTRA_APP_PACKAGE}, the package to display.
+ * <p>
+ * Output: Nothing.
+ */
+ @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
+ public static final String ACTION_APP_NOTIFICATION_BUBBLE_SETTINGS
+ = "android.settings.APP_NOTIFICATION_BUBBLE_SETTINGS";
+
+ /**
* Activity Extra: The package owner of the notification channel settings to display.
* <p>
* This must be passed as an extra field to the {@link #ACTION_CHANNEL_NOTIFICATION_SETTINGS}.
diff --git a/core/java/android/service/quicksettings/TileService.java b/core/java/android/service/quicksettings/TileService.java
index c35423f..d32bdad 100644
--- a/core/java/android/service/quicksettings/TileService.java
+++ b/core/java/android/service/quicksettings/TileService.java
@@ -87,6 +87,10 @@
* This intent may also define a {@link Intent#EXTRA_COMPONENT_NAME} value
* to indicate the {@link ComponentName} that caused the preferences to be
* opened.
+ * <p>
+ * To ensure that the activity can only be launched through quick settings
+ * UI provided by this service, apps can protect it with the
+ * BIND_QUICK_SETTINGS_TILE permission.
*/
@SdkConstant(SdkConstantType.INTENT_CATEGORY)
public static final String ACTION_QS_TILE_PREFERENCES
diff --git a/core/java/android/service/wallpaper/IWallpaperService.aidl b/core/java/android/service/wallpaper/IWallpaperService.aidl
index 99a81f5..56e2486 100644
--- a/core/java/android/service/wallpaper/IWallpaperService.aidl
+++ b/core/java/android/service/wallpaper/IWallpaperService.aidl
@@ -26,4 +26,5 @@
void attach(IWallpaperConnection connection,
IBinder windowToken, int windowType, boolean isPreview,
int reqWidth, int reqHeight, in Rect padding, int displayId);
+ void detach();
}
diff --git a/core/java/android/service/wallpaper/WallpaperService.java b/core/java/android/service/wallpaper/WallpaperService.java
index e1762df..d645e3f 100644
--- a/core/java/android/service/wallpaper/WallpaperService.java
+++ b/core/java/android/service/wallpaper/WallpaperService.java
@@ -72,6 +72,7 @@
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Supplier;
/**
@@ -1309,6 +1310,7 @@
final int mDisplayId;
final DisplayManager mDisplayManager;
final Display mDisplay;
+ private final AtomicBoolean mDetached = new AtomicBoolean();
Engine mEngine;
@@ -1399,8 +1401,23 @@
mCaller.sendMessage(msg);
}
+ public void detach() {
+ mDetached.set(true);
+ }
+
+ private void doDetachEngine() {
+ mActiveEngines.remove(mEngine);
+ mEngine.detach();
+ }
+
@Override
public void executeMessage(Message message) {
+ if (mDetached.get()) {
+ if (mActiveEngines.contains(mEngine)) {
+ doDetachEngine();
+ }
+ return;
+ }
switch (message.what) {
case DO_ATTACH: {
try {
@@ -1416,8 +1433,7 @@
return;
}
case DO_DETACH: {
- mActiveEngines.remove(mEngine);
- mEngine.detach();
+ doDetachEngine();
return;
}
case DO_SET_DESIRED_SIZE: {
@@ -1497,6 +1513,7 @@
*/
class IWallpaperServiceWrapper extends IWallpaperService.Stub {
private final WallpaperService mTarget;
+ private IWallpaperEngineWrapper mEngineWrapper;
public IWallpaperServiceWrapper(WallpaperService context) {
mTarget = context;
@@ -1506,9 +1523,14 @@
public void attach(IWallpaperConnection conn, IBinder windowToken,
int windowType, boolean isPreview, int reqWidth, int reqHeight, Rect padding,
int displayId) {
- new IWallpaperEngineWrapper(mTarget, conn, windowToken,
+ mEngineWrapper = new IWallpaperEngineWrapper(mTarget, conn, windowToken,
windowType, isPreview, reqWidth, reqHeight, padding, displayId);
}
+
+ @Override
+ public void detach() {
+ mEngineWrapper.detach();
+ }
}
@Override
diff --git a/core/java/com/android/internal/os/ZygoteInit.java b/core/java/com/android/internal/os/ZygoteInit.java
index dd18060..7cca7b7 100644
--- a/core/java/com/android/internal/os/ZygoteInit.java
+++ b/core/java/com/android/internal/os/ZygoteInit.java
@@ -22,6 +22,8 @@
import android.annotation.UnsupportedAppUsage;
import android.content.res.Resources;
import android.content.res.TypedArray;
+import android.app.ApplicationLoaders;
+import android.content.pm.SharedLibraryInfo;
import android.os.Build;
import android.os.Environment;
import android.os.IInstalld;
@@ -138,6 +140,9 @@
bootTimingsTraceLog.traceBegin("PreloadClasses");
preloadClasses();
bootTimingsTraceLog.traceEnd(); // PreloadClasses
+ bootTimingsTraceLog.traceBegin("CacheNonBootClasspathClassLoaders");
+ cacheNonBootClasspathClassLoaders();
+ bootTimingsTraceLog.traceEnd(); // CacheNonBootClasspathClassLoaders
bootTimingsTraceLog.traceBegin("PreloadResources");
preloadResources();
bootTimingsTraceLog.traceEnd(); // PreloadResources
@@ -344,6 +349,32 @@
}
/**
+ * Load in things which are used by many apps but which cannot be put in the boot
+ * classpath.
+ */
+ private static void cacheNonBootClasspathClassLoaders() {
+ // These libraries used to be part of the bootclasspath, but had to be removed.
+ // Old system applications still get them for backwards compatibility reasons,
+ // so they are cached here in order to preserve performance characteristics.
+ SharedLibraryInfo hidlBase = new SharedLibraryInfo(
+ "/system/framework/android.hidl.base-V1.0-java.jar", null /*packageName*/,
+ null /*codePaths*/, null /*name*/, 0 /*version*/, SharedLibraryInfo.TYPE_BUILTIN,
+ null /*declaringPackage*/, null /*dependentPackages*/, null /*dependencies*/);
+ SharedLibraryInfo hidlManager = new SharedLibraryInfo(
+ "/system/framework/android.hidl.manager-V1.0-java.jar", null /*packageName*/,
+ null /*codePaths*/, null /*name*/, 0 /*version*/, SharedLibraryInfo.TYPE_BUILTIN,
+ null /*declaringPackage*/, null /*dependentPackages*/, null /*dependencies*/);
+ hidlManager.addDependency(hidlBase);
+
+ ApplicationLoaders.getDefault().createAndCacheNonBootclasspathSystemClassLoaders(
+ new SharedLibraryInfo[]{
+ // ordered dependencies first
+ hidlBase,
+ hidlManager,
+ });
+ }
+
+ /**
* Load in commonly used resources, so they can be shared across processes.
*
* These tend to be a few Kbytes, but are frequently in the 20-40K range, and occasionally even
diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp
index e0b7629..a4e3709 100755
--- a/core/jni/android/graphics/Bitmap.cpp
+++ b/core/jni/android/graphics/Bitmap.cpp
@@ -39,7 +39,6 @@
static jfieldID gBitmap_nativePtr;
static jmethodID gBitmap_constructorMethodID;
static jmethodID gBitmap_reinitMethodID;
-static jmethodID gBitmap_getAllocationByteCountMethodID;
namespace android {
@@ -193,11 +192,6 @@
info.width(), info.height(), isPremultiplied);
}
-int getBitmapAllocationByteCount(JNIEnv* env, jobject javaBitmap)
-{
- return env->CallIntMethod(javaBitmap, gBitmap_getAllocationByteCountMethodID);
-}
-
jobject createBitmap(JNIEnv* env, Bitmap* bitmap,
int bitmapCreateFlags, jbyteArray ninePatchChunk, jobject ninePatchInsets,
int density) {
@@ -236,8 +230,7 @@
return localBitmap->bitmap();
}
-Bitmap& toBitmap(JNIEnv* env, jlong bitmapHandle) {
- SkASSERT(env);
+Bitmap& toBitmap(jlong bitmapHandle) {
LocalScopedBitmap localBitmap(bitmapHandle);
return localBitmap->bitmap();
}
@@ -1227,7 +1220,6 @@
gBitmap_nativePtr = GetFieldIDOrDie(env, gBitmap_class, "mNativePtr", "J");
gBitmap_constructorMethodID = GetMethodIDOrDie(env, gBitmap_class, "<init>", "(JIIIZ[BLandroid/graphics/NinePatch$InsetStruct;Z)V");
gBitmap_reinitMethodID = GetMethodIDOrDie(env, gBitmap_class, "reinit", "(IIZ)V");
- gBitmap_getAllocationByteCountMethodID = GetMethodIDOrDie(env, gBitmap_class, "getAllocationByteCount", "()I");
return android::RegisterMethodsOrDie(env, "android/graphics/Bitmap", gBitmapMethods,
NELEM(gBitmapMethods));
}
diff --git a/core/jni/android/graphics/Bitmap.h b/core/jni/android/graphics/Bitmap.h
index 06877915..6934d26 100644
--- a/core/jni/android/graphics/Bitmap.h
+++ b/core/jni/android/graphics/Bitmap.h
@@ -41,7 +41,7 @@
void toSkBitmap(jlong bitmapHandle, SkBitmap* outBitmap);
Bitmap& toBitmap(JNIEnv* env, jobject bitmap);
-Bitmap& toBitmap(JNIEnv* env, jlong bitmapHandle);
+Bitmap& toBitmap(jlong bitmapHandle);
// NDK access
void imageInfo(JNIEnv* env, jobject bitmap, AndroidBitmapInfo* info);
@@ -56,8 +56,6 @@
void reinitBitmap(JNIEnv* env, jobject javaBitmap, const SkImageInfo& info,
bool isPremultiplied);
-int getBitmapAllocationByteCount(JNIEnv* env, jobject javaBitmap);
-
} // namespace bitmap
} // namespace android
diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp
index 47b1548..3f05c3b 100644
--- a/core/jni/android/graphics/BitmapFactory.cpp
+++ b/core/jni/android/graphics/BitmapFactory.cpp
@@ -180,7 +180,8 @@
}
static jobject doDecode(JNIEnv* env, std::unique_ptr<SkStreamRewindable> stream,
- jobject padding, jobject options, jlong colorSpaceHandle) {
+ jobject padding, jobject options, jlong inBitmapHandle,
+ jlong colorSpaceHandle) {
// Set default values for the options parameters.
int sampleSize = 1;
bool onlyDecodeSize = false;
@@ -323,14 +324,14 @@
android::Bitmap* reuseBitmap = nullptr;
unsigned int existingBufferSize = 0;
- if (javaBitmap != NULL) {
- reuseBitmap = &bitmap::toBitmap(env, javaBitmap);
+ if (javaBitmap != nullptr) {
+ reuseBitmap = &bitmap::toBitmap(inBitmapHandle);
if (reuseBitmap->isImmutable()) {
ALOGW("Unable to reuse an immutable bitmap as an image decoder target.");
- javaBitmap = NULL;
+ javaBitmap = nullptr;
reuseBitmap = nullptr;
} else {
- existingBufferSize = bitmap::getBitmapAllocationByteCount(env, javaBitmap);
+ existingBufferSize = reuseBitmap->getAllocationByteCount();
}
}
@@ -513,7 +514,7 @@
}
static jobject nativeDecodeStream(JNIEnv* env, jobject clazz, jobject is, jbyteArray storage,
- jobject padding, jobject options, jlong colorSpaceHandle) {
+ jobject padding, jobject options, jlong inBitmapHandle, jlong colorSpaceHandle) {
jobject bitmap = NULL;
std::unique_ptr<SkStream> stream(CreateJavaInputStreamAdaptor(env, is, storage));
@@ -522,13 +523,14 @@
std::unique_ptr<SkStreamRewindable> bufferedStream(
SkFrontBufferedStream::Make(std::move(stream), SkCodec::MinBufferedBytesNeeded()));
SkASSERT(bufferedStream.get() != NULL);
- bitmap = doDecode(env, std::move(bufferedStream), padding, options, colorSpaceHandle);
+ bitmap = doDecode(env, std::move(bufferedStream), padding, options, inBitmapHandle,
+ colorSpaceHandle);
}
return bitmap;
}
static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz, jobject fileDescriptor,
- jobject padding, jobject bitmapFactoryOptions, jlong colorSpaceHandle) {
+ jobject padding, jobject bitmapFactoryOptions, jlong inBitmapHandle, jlong colorSpaceHandle) {
NPE_CHECK_RETURN_ZERO(env, fileDescriptor);
@@ -565,7 +567,7 @@
if (::lseek(descriptor, 0, SEEK_CUR) == 0) {
assert(isSeekable(dupDescriptor));
return doDecode(env, std::move(fileStream), padding, bitmapFactoryOptions,
- colorSpaceHandle);
+ inBitmapHandle, colorSpaceHandle);
}
// Use a buffered stream. Although an SkFILEStream can be rewound, this
@@ -574,25 +576,26 @@
std::unique_ptr<SkStreamRewindable> stream(SkFrontBufferedStream::Make(std::move(fileStream),
SkCodec::MinBufferedBytesNeeded()));
- return doDecode(env, std::move(stream), padding, bitmapFactoryOptions, colorSpaceHandle);
+ return doDecode(env, std::move(stream), padding, bitmapFactoryOptions, inBitmapHandle,
+ colorSpaceHandle);
}
static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jlong native_asset,
- jobject padding, jobject options, jlong colorSpaceHandle) {
+ jobject padding, jobject options, jlong inBitmapHandle, jlong colorSpaceHandle) {
Asset* asset = reinterpret_cast<Asset*>(native_asset);
// since we know we'll be done with the asset when we return, we can
// just use a simple wrapper
return doDecode(env, skstd::make_unique<AssetStreamAdaptor>(asset), padding, options,
- colorSpaceHandle);
+ inBitmapHandle, colorSpaceHandle);
}
static jobject nativeDecodeByteArray(JNIEnv* env, jobject, jbyteArray byteArray,
- jint offset, jint length, jobject options, jlong colorSpaceHandle) {
+ jint offset, jint length, jobject options, jlong inBitmapHandle, jlong colorSpaceHandle) {
AutoJavaByteArray ar(env, byteArray);
return doDecode(env, skstd::make_unique<SkMemoryStream>(ar.ptr() + offset, length, false),
- nullptr, options, colorSpaceHandle);
+ nullptr, options, inBitmapHandle, colorSpaceHandle);
}
static jboolean nativeIsSeekable(JNIEnv* env, jobject, jobject fileDescriptor) {
@@ -604,22 +607,22 @@
static const JNINativeMethod gMethods[] = {
{ "nativeDecodeStream",
- "(Ljava/io/InputStream;[BLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;",
+ "(Ljava/io/InputStream;[BLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;",
(void*)nativeDecodeStream
},
{ "nativeDecodeFileDescriptor",
- "(Ljava/io/FileDescriptor;Landroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;",
+ "(Ljava/io/FileDescriptor;Landroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;",
(void*)nativeDecodeFileDescriptor
},
{ "nativeDecodeAsset",
- "(JLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;",
+ "(JLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;",
(void*)nativeDecodeAsset
},
{ "nativeDecodeByteArray",
- "([BIILandroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;",
+ "([BIILandroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;",
(void*)nativeDecodeByteArray
},
diff --git a/core/jni/android/graphics/BitmapRegionDecoder.cpp b/core/jni/android/graphics/BitmapRegionDecoder.cpp
index 9c07e2d..6ffa72a 100644
--- a/core/jni/android/graphics/BitmapRegionDecoder.cpp
+++ b/core/jni/android/graphics/BitmapRegionDecoder.cpp
@@ -125,13 +125,14 @@
* reportSizeToVM not supported
*/
static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint inputX,
- jint inputY, jint inputWidth, jint inputHeight, jobject options, jlong colorSpaceHandle) {
+ jint inputY, jint inputWidth, jint inputHeight, jobject options, jlong inBitmapHandle,
+ jlong colorSpaceHandle) {
// Set default options.
int sampleSize = 1;
SkColorType colorType = kN32_SkColorType;
bool requireUnpremul = false;
- jobject javaBitmap = NULL;
+ jobject javaBitmap = nullptr;
bool isHardware = false;
sk_sp<SkColorSpace> colorSpace = GraphicsJNI::getNativeColorSpace(colorSpaceHandle);
// Update the default options with any options supplied by the client.
@@ -158,11 +159,11 @@
android::Bitmap* recycledBitmap = nullptr;
size_t recycledBytes = 0;
if (javaBitmap) {
- recycledBitmap = &bitmap::toBitmap(env, javaBitmap);
+ recycledBitmap = &bitmap::toBitmap(inBitmapHandle);
if (recycledBitmap->isImmutable()) {
ALOGW("Warning: Reusing an immutable bitmap as an image decoder target.");
}
- recycledBytes = bitmap::getBitmapAllocationByteCount(env, javaBitmap);
+ recycledBytes = recycledBitmap->getAllocationByteCount();
}
SkBitmapRegionDecoder* brd = reinterpret_cast<SkBitmapRegionDecoder*>(brdHandle);
@@ -258,7 +259,7 @@
static const JNINativeMethod gBitmapRegionDecoderMethods[] = {
{ "nativeDecodeRegion",
- "(JIIIILandroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;",
+ "(JIIIILandroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;",
(void*)nativeDecodeRegion},
{ "nativeGetHeight", "(J)I", (void*)nativeGetHeight},
diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp
index bb291e7..15f9516 100644
--- a/core/jni/android/graphics/NinePatch.cpp
+++ b/core/jni/android/graphics/NinePatch.cpp
@@ -84,13 +84,13 @@
delete[] patch;
}
- static jlong getTransparentRegion(JNIEnv* env, jobject, jobject jbitmap,
+ static jlong getTransparentRegion(JNIEnv* env, jobject, jlong bitmapPtr,
jlong chunkHandle, jobject dstRect) {
Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
SkASSERT(chunk);
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
SkRect dst;
GraphicsJNI::jrect_to_rect(env, dstRect, &dst);
@@ -156,7 +156,7 @@
{ "validateNinePatchChunk", "([B)J",
(void*) SkNinePatchGlue::validateNinePatchChunk },
{ "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize },
- { "nativeGetTransparentRegion", "(Landroid/graphics/Bitmap;JLandroid/graphics/Rect;)J",
+ { "nativeGetTransparentRegion", "(JJLandroid/graphics/Rect;)J",
(void*) SkNinePatchGlue::getTransparentRegion }
};
diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp
index 298f7f8..44d2cac 100644
--- a/core/jni/android/graphics/Shader.cpp
+++ b/core/jni/android/graphics/Shader.cpp
@@ -62,14 +62,14 @@
///////////////////////////////////////////////////////////////////////////////////////////////
-static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jobject jbitmap,
+static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jlong bitmapHandle,
jint tileModeX, jint tileModeY) {
const SkMatrix* matrix = reinterpret_cast<const SkMatrix*>(matrixPtr);
sk_sp<SkImage> image;
- if (jbitmap) {
+ if (bitmapHandle) {
// Only pass a valid SkBitmap object to the constructor if the Bitmap exists. Otherwise,
// we'll pass an empty SkBitmap to avoid crashing/excepting for compatibility.
- image = android::bitmap::toBitmap(env, jbitmap).makeImage();
+ image = android::bitmap::toBitmap(bitmapHandle).makeImage();
}
if (!image.get()) {
@@ -222,7 +222,7 @@
};
static const JNINativeMethod gBitmapShaderMethods[] = {
- { "nativeCreate", "(JLandroid/graphics/Bitmap;II)J", (void*)BitmapShader_constructor },
+ { "nativeCreate", "(JJII)J", (void*)BitmapShader_constructor },
};
static const JNINativeMethod gLinearGradientMethods[] = {
diff --git a/core/jni/android/graphics/pdf/PdfRenderer.cpp b/core/jni/android/graphics/pdf/PdfRenderer.cpp
index 32ac30f..761830b 100644
--- a/core/jni/android/graphics/pdf/PdfRenderer.cpp
+++ b/core/jni/android/graphics/pdf/PdfRenderer.cpp
@@ -73,12 +73,12 @@
}
static void nativeRenderPage(JNIEnv* env, jclass thiz, jlong documentPtr, jlong pagePtr,
- jobject jbitmap, jint clipLeft, jint clipTop, jint clipRight, jint clipBottom,
+ jlong bitmapPtr, jint clipLeft, jint clipTop, jint clipRight, jint clipBottom,
jlong transformPtr, jint renderMode) {
FPDF_PAGE page = reinterpret_cast<FPDF_PAGE>(pagePtr);
SkBitmap skBitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &skBitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&skBitmap);
const int stride = skBitmap.width() * 4;
@@ -117,7 +117,7 @@
{"nativeClose", "(J)V", (void*) nativeClose},
{"nativeGetPageCount", "(J)I", (void*) nativeGetPageCount},
{"nativeScaleForPrinting", "(J)Z", (void*) nativeScaleForPrinting},
- {"nativeRenderPage", "(JJLandroid/graphics/Bitmap;IIIIJI)V", (void*) nativeRenderPage},
+ {"nativeRenderPage", "(JJJIIIIJI)V", (void*) nativeRenderPage},
{"nativeOpenPageAndGetSize", "(JILandroid/graphics/Point;)J", (void*) nativeOpenPageAndGetSize},
{"nativeClosePage", "(J)V", (void*) nativeClosePage}
};
diff --git a/core/jni/android/opengl/util.cpp b/core/jni/android/opengl/util.cpp
index d50e60c..09f0e8e 100644
--- a/core/jni/android/opengl/util.cpp
+++ b/core/jni/android/opengl/util.cpp
@@ -703,27 +703,27 @@
}
static jint util_getInternalFormat(JNIEnv *env, jclass clazz,
- jobject jbitmap)
+ jlong bitmapPtr)
{
SkBitmap nativeBitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &nativeBitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&nativeBitmap);
return getInternalFormat(nativeBitmap.colorType());
}
static jint util_getType(JNIEnv *env, jclass clazz,
- jobject jbitmap)
+ jlong bitmapPtr)
{
SkBitmap nativeBitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &nativeBitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&nativeBitmap);
return getType(nativeBitmap.colorType());
}
static jint util_texImage2D(JNIEnv *env, jclass clazz,
jint target, jint level, jint internalformat,
- jobject jbitmap, jint type, jint border)
+ jlong bitmapPtr, jint type, jint border)
{
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
SkColorType colorType = bitmap.colorType();
if (internalformat < 0) {
internalformat = getInternalFormat(colorType);
@@ -748,10 +748,10 @@
static jint util_texSubImage2D(JNIEnv *env, jclass clazz,
jint target, jint level, jint xoffset, jint yoffset,
- jobject jbitmap, jint format, jint type)
+ jlong bitmapPtr, jint format, jint type)
{
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
SkColorType colorType = bitmap.colorType();
int internalFormat = getInternalFormat(colorType);
if (format < 0) {
@@ -1068,10 +1068,10 @@
};
static const JNINativeMethod gUtilsMethods[] = {
- { "native_getInternalFormat", "(Landroid/graphics/Bitmap;)I", (void*) util_getInternalFormat },
- { "native_getType", "(Landroid/graphics/Bitmap;)I", (void*) util_getType },
- { "native_texImage2D", "(IIILandroid/graphics/Bitmap;II)I", (void*)util_texImage2D },
- { "native_texSubImage2D", "(IIIILandroid/graphics/Bitmap;II)I", (void*)util_texSubImage2D },
+ { "native_getInternalFormat", "(J)I", (void*) util_getInternalFormat },
+ { "native_getType", "(J)I", (void*) util_getType },
+ { "native_texImage2D", "(IIIJII)I", (void*)util_texImage2D },
+ { "native_texSubImage2D", "(IIIIJII)I", (void*)util_texSubImage2D },
};
static const JNINativeMethod gEtc1Methods[] = {
diff --git a/core/jni/android_graphics_Canvas.cpp b/core/jni/android_graphics_Canvas.cpp
index 9c48c33..7a8c5c8 100644
--- a/core/jni/android_graphics_Canvas.cpp
+++ b/core/jni/android_graphics_Canvas.cpp
@@ -54,20 +54,20 @@
}
// Native wrapper constructor used by Canvas(Bitmap)
-static jlong initRaster(JNIEnv* env, jobject, jobject jbitmap) {
+static jlong initRaster(JNIEnv* env, jobject, jlong bitmapHandle) {
SkBitmap bitmap;
- if (jbitmap != NULL) {
- GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
+ if (bitmapHandle != 0) {
+ bitmap::toBitmap(bitmapHandle).getSkBitmap(&bitmap);
}
return reinterpret_cast<jlong>(Canvas::create_canvas(bitmap));
}
// Set the given bitmap as the new draw target (wrapped in a new SkCanvas),
// optionally copying canvas matrix & clip state.
-static void setBitmap(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap) {
+static void setBitmap(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle) {
SkBitmap bitmap;
- if (jbitmap != NULL) {
- GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
+ if (bitmapHandle != 0) {
+ bitmap::toBitmap(bitmapHandle).getSkBitmap(&bitmap);
}
get_canvas(canvasHandle)->setBitmap(bitmap);
}
@@ -397,7 +397,7 @@
jlong paintHandle, jint dstDensity, jint srcDensity) {
Canvas* canvas = get_canvas(canvasHandle);
- Bitmap& bitmap = android::bitmap::toBitmap(env, bitmapHandle);
+ Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle);
const android::Res_png_9patch* chunk = reinterpret_cast<android::Res_png_9patch*>(chunkHandle);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
@@ -423,11 +423,11 @@
}
}
-static void drawBitmap(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
+static void drawBitmap(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,
jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,
jint screenDensity, jint bitmapDensity) {
Canvas* canvas = get_canvas(canvasHandle);
- Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap);
+ Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
@@ -458,22 +458,22 @@
}
}
-static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
+static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,
jlong matrixHandle, jlong paintHandle) {
const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
- Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap);
+ Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle);
get_canvas(canvasHandle)->drawBitmap(bitmap, *matrix, paint);
}
-static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
+static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,
float srcLeft, float srcTop, float srcRight, float srcBottom,
float dstLeft, float dstTop, float dstRight, float dstBottom,
jlong paintHandle, jint screenDensity, jint bitmapDensity) {
Canvas* canvas = get_canvas(canvasHandle);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
- Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap);
+ Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle);
if (screenDensity != 0 && screenDensity != bitmapDensity) {
Paint filteredPaint;
if (paint) {
@@ -512,7 +512,7 @@
get_canvas(canvasHandle)->drawBitmap(*androidBitmap, x, y, paint);
}
-static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
+static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,
jint meshWidth, jint meshHeight, jfloatArray jverts,
jint vertIndex, jintArray jcolors, jint colorIndex, jlong paintHandle) {
if (Canvas::GetApiLevel() < __ANDROID_API_P__) {
@@ -527,7 +527,7 @@
AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount);
const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
- Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap);
+ Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle);
get_canvas(canvasHandle)->drawBitmapMesh(bitmap, meshWidth, meshHeight,
vertA.ptr() + vertIndex*2,
colorA.ptr() + colorIndex, paint);
@@ -651,13 +651,13 @@
static const JNINativeMethod gMethods[] = {
{"nGetNativeFinalizer", "()J", (void*) CanvasJNI::getNativeFinalizer},
- {"nInitRaster", "(Landroid/graphics/Bitmap;)J", (void*) CanvasJNI::initRaster},
{"nFreeCaches", "()V", (void*) CanvasJNI::freeCaches},
{"nFreeTextLayoutCaches", "()V", (void*) CanvasJNI::freeTextLayoutCaches},
{"nSetCompatibilityVersion", "(I)V", (void*) CanvasJNI::setCompatibilityVersion},
// ------------ @FastNative ----------------
- {"nSetBitmap", "(JLandroid/graphics/Bitmap;)V", (void*) CanvasJNI::setBitmap},
+ {"nInitRaster", "(J)J", (void*) CanvasJNI::initRaster},
+ {"nSetBitmap", "(JJ)V", (void*) CanvasJNI::setBitmap},
{"nGetClipBounds","(JLandroid/graphics/Rect;)Z", (void*) CanvasJNI::getClipBounds},
// ------------ @CriticalNative ----------------
@@ -706,10 +706,10 @@
{"nDrawPath","(JJJ)V", (void*) CanvasJNI::drawPath},
{"nDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices},
{"nDrawNinePatch", "(JJJFFFFJII)V", (void*)CanvasJNI::drawNinePatch},
- {"nDrawBitmapMatrix", "(JLandroid/graphics/Bitmap;JJ)V", (void*)CanvasJNI::drawBitmapMatrix},
- {"nDrawBitmapMesh", "(JLandroid/graphics/Bitmap;II[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh},
- {"nDrawBitmap","(JLandroid/graphics/Bitmap;FFJIII)V", (void*) CanvasJNI::drawBitmap},
- {"nDrawBitmap","(JLandroid/graphics/Bitmap;FFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect},
+ {"nDrawBitmapMatrix", "(JJJJ)V", (void*)CanvasJNI::drawBitmapMatrix},
+ {"nDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh},
+ {"nDrawBitmap","(JJFFJIII)V", (void*) CanvasJNI::drawBitmap},
+ {"nDrawBitmap","(JJFFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect},
{"nDrawBitmap", "(J[IIIFFIIZJ)V", (void*)CanvasJNI::drawBitmapArray},
{"nDrawText","(J[CIIFFIJ)V", (void*) CanvasJNI::drawTextChars},
{"nDrawText","(JLjava/lang/String;IIFFIJ)V", (void*) CanvasJNI::drawTextString},
diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp
index c8f81e2..88713d1 100644
--- a/core/jni/android_media_AudioSystem.cpp
+++ b/core/jni/android_media_AudioSystem.cpp
@@ -144,6 +144,7 @@
static jclass gAudioMixingRuleClass;
static struct {
jfieldID mCriteria;
+ jfieldID mAllowPrivilegedPlaybackCapture;
// other fields unused by JNI
} gAudioMixingRuleFields;
@@ -1868,6 +1869,8 @@
jobject jRule = env->GetObjectField(jAudioMix, gAudioMixFields.mRule);
jobject jRuleCriteria = env->GetObjectField(jRule, gAudioMixingRuleFields.mCriteria);
+ nAudioMix->mAllowPrivilegedPlaybackCapture =
+ env->GetBooleanField(jRule, gAudioMixingRuleFields.mAllowPrivilegedPlaybackCapture);
env->DeleteLocalRef(jRule);
jobjectArray jCriteria = (jobjectArray)env->CallObjectMethod(jRuleCriteria,
gArrayListMethods.toArray);
@@ -2456,6 +2459,8 @@
gAudioMixingRuleClass = MakeGlobalRefOrDie(env, audioMixingRuleClass);
gAudioMixingRuleFields.mCriteria = GetFieldIDOrDie(env, audioMixingRuleClass, "mCriteria",
"Ljava/util/ArrayList;");
+ gAudioMixingRuleFields.mAllowPrivilegedPlaybackCapture =
+ GetFieldIDOrDie(env, audioMixingRuleClass, "mAllowPrivilegedPlaybackCapture", "Z");
jclass audioMixMatchCriterionClass =
FindClassOrDie(env, "android/media/audiopolicy/AudioMixingRule$AudioMixMatchCriterion");
diff --git a/core/jni/android_view_ThreadedRenderer.cpp b/core/jni/android_view_ThreadedRenderer.cpp
index ecc2dd0..e7cbf93 100644
--- a/core/jni/android_view_ThreadedRenderer.cpp
+++ b/core/jni/android_view_ThreadedRenderer.cpp
@@ -736,11 +736,11 @@
}
static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
- jlong proxyPtr, jlong layerPtr, jobject jbitmap) {
+ jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
return proxy->copyLayerInto(layer, bitmap);
}
@@ -911,9 +911,9 @@
static jint android_view_ThreadedRenderer_copySurfaceInto(JNIEnv* env,
jobject clazz, jobject jsurface, jint left, jint top,
- jint right, jint bottom, jobject jbitmap) {
+ jint right, jint bottom, jlong bitmapPtr) {
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
sp<Surface> surface = android_view_Surface_getSurface(env, jsurface);
return RenderProxy::copySurfaceInto(surface, left, top, right, bottom, &bitmap);
}
@@ -1106,7 +1106,7 @@
{ "nInvokeFunctor", "(JZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
{ "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
{ "nBuildLayer", "(JJ)V", (void*) android_view_ThreadedRenderer_buildLayer },
- { "nCopyLayerInto", "(JJLandroid/graphics/Bitmap;)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
+ { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
{ "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate },
{ "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate },
{ "nDetachSurfaceTexture", "(JJ)V", (void*) android_view_ThreadedRenderer_detachSurfaceTexture },
@@ -1135,7 +1135,7 @@
{ "nRemoveFrameMetricsObserver",
"(JJ)V",
(void*)android_view_ThreadedRenderer_removeFrameMetricsObserver },
- { "nCopySurfaceInto", "(Landroid/view/Surface;IIIILandroid/graphics/Bitmap;)I",
+ { "nCopySurfaceInto", "(Landroid/view/Surface;IIIIJ)I",
(void*)android_view_ThreadedRenderer_copySurfaceInto },
{ "nCreateHardwareBitmap", "(JII)Landroid/graphics/Bitmap;",
(void*)android_view_ThreadedRenderer_createHardwareBitmapFromRenderNode },
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index 2d7cfa4..cffa46c 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -3562,10 +3562,30 @@
android:protectionLevel="signature" />
<!-- Allows an application to capture audio output.
+ Use the {@code CAPTURE_MEDIA_OUTPUT} permission if only the {@code USAGE_UNKNOWN}),
+ {@code USAGE_MEDIA}) or {@code USAGE_GAME}) usages are intended to be captured.
<p>Not for use by third-party applications.</p> -->
<permission android:name="android.permission.CAPTURE_AUDIO_OUTPUT"
android:protectionLevel="signature|privileged" />
+ <!-- @SystemApi Allows an application to capture the audio played by other apps
+ that have set an allow capture policy of
+ {@link android.media.AudioAttributes#ALLOW_CAPTURE_BY_SYSTEM}.
+
+ Without this permission, only audio with an allow capture policy of
+ {@link android.media.AudioAttributes#ALLOW_CAPTURE_BY_ALL} can be used.
+
+ There are strong restriction listed at
+ {@link android.media.AudioAttributes#ALLOW_CAPTURE_BY_SYSTEM}
+ on what an app can do with the captured audio.
+
+ See {@code CAPTURE_AUDIO_OUTPUT} for capturing audio use cases other than media playback.
+
+ <p>Not for use by third-party applications.</p>
+ @hide -->
+ <permission android:name="android.permission.CAPTURE_MEDIA_OUTPUT"
+ android:protectionLevel="signature|privileged" />
+
<!-- @SystemApi Allows an application to capture audio for hotword detection.
<p>Not for use by third-party applications.</p>
@hide -->
diff --git a/core/res/res/values/attrs_manifest.xml b/core/res/res/values/attrs_manifest.xml
index fe2c665..362d01c 100644
--- a/core/res/res/values/attrs_manifest.xml
+++ b/core/res/res/values/attrs_manifest.xml
@@ -1673,8 +1673,19 @@
This flag is turned on by default. <em>This attribute is usable only by system apps.
</em> -->
<attr name="allowClearUserDataOnFailedRestore"/>
- <!-- If {@code true} the app's non sensitive audio can be capture by other apps.
- The default value is true. -->
+ <!-- If {@code true} the app's non sensitive audio can be capture by other apps with
+ {@code AudioPlaybackCaptureConfiguration} and a {@code MediaProjection}.
+
+ <p>
+ Non sensitive audio is defined as audio whose {@code AttributeUsage} is
+ {@code USAGE_UNKNOWN}), {@code USAGE_MEDIA}) or {@code USAGE_GAME}).
+ All other usages (eg. {@code USAGE_VOICE_COMMUNICATION}) will not be captured.
+
+ <p>
+ The default value is:
+ - {@code true} for apps with targetSdkVersion >= 29 (Q).
+ - {@code false} for apps with targetSdkVersion < 29.
+ -->
<attr name="allowAudioPlaybackCapture" format="boolean" />
</declare-styleable>
<!-- The <code>permission</code> tag declares a security permission that can be
diff --git a/graphics/java/android/graphics/BaseCanvas.java b/graphics/java/android/graphics/BaseCanvas.java
index 3190678..c9431e3 100644
--- a/graphics/java/android/graphics/BaseCanvas.java
+++ b/graphics/java/android/graphics/BaseCanvas.java
@@ -112,14 +112,14 @@
public void drawBitmap(@NonNull Bitmap bitmap, float left, float top, @Nullable Paint paint) {
throwIfCannotDraw(bitmap);
throwIfHasHwBitmapInSwMode(paint);
- nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top,
+ nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top,
paint != null ? paint.getNativeInstance() : 0, mDensity, mScreenDensity,
bitmap.mDensity);
}
public void drawBitmap(@NonNull Bitmap bitmap, @NonNull Matrix matrix, @Nullable Paint paint) {
throwIfHasHwBitmapInSwMode(paint);
- nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap, matrix.ni(),
+ nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap.getNativeInstance(), matrix.ni(),
paint != null ? paint.getNativeInstance() : 0);
}
@@ -144,7 +144,7 @@
bottom = src.bottom;
}
- nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom,
+ nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom,
dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity,
bitmap.mDensity);
}
@@ -170,7 +170,7 @@
bottom = src.bottom;
}
- nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom,
+ nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom,
dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity,
bitmap.mDensity);
}
@@ -229,7 +229,7 @@
// no mul by 2, since we need only 1 color per vertex
checkRange(colors.length, colorOffset, count);
}
- nDrawBitmapMesh(mNativeCanvasWrapper, bitmap, meshWidth, meshHeight,
+ nDrawBitmapMesh(mNativeCanvasWrapper, bitmap.getNativeInstance(), meshWidth, meshHeight,
verts, vertOffset, colors, colorOffset,
paint != null ? paint.getNativeInstance() : 0);
}
@@ -664,10 +664,11 @@
}
}
- private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap, float left, float top,
- long nativePaintOrZero, int canvasDensity, int screenDensity, int bitmapDensity);
+ private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle, float left,
+ float top, long nativePaintOrZero, int canvasDensity, int screenDensity,
+ int bitmapDensity);
- private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap, float srcLeft,
+ private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle, float srcLeft,
float srcTop,
float srcRight, float srcBottom, float dstLeft, float dstTop, float dstRight,
float dstBottom, long nativePaintOrZero, int screenDensity, int bitmapDensity);
@@ -726,10 +727,10 @@
float dstLeft, float dstTop, float dstRight, float dstBottom, long nativePaintOrZero,
int screenDensity, int bitmapDensity);
- private static native void nDrawBitmapMatrix(long nativeCanvas, Bitmap bitmap,
+ private static native void nDrawBitmapMatrix(long nativeCanvas, long bitmapHandle,
long nativeMatrix, long nativePaint);
- private static native void nDrawBitmapMesh(long nativeCanvas, Bitmap bitmap, int meshWidth,
+ private static native void nDrawBitmapMesh(long nativeCanvas, long bitmapHandle, int meshWidth,
int meshHeight, float[] verts, int vertOffset, int[] colors, int colorOffset,
long nativePaint);
diff --git a/graphics/java/android/graphics/BaseRecordingCanvas.java b/graphics/java/android/graphics/BaseRecordingCanvas.java
index 2afc3d2..028b784 100644
--- a/graphics/java/android/graphics/BaseRecordingCanvas.java
+++ b/graphics/java/android/graphics/BaseRecordingCanvas.java
@@ -67,7 +67,7 @@
public final void drawBitmap(@NonNull Bitmap bitmap, float left, float top,
@Nullable Paint paint) {
throwIfCannotDraw(bitmap);
- nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top,
+ nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top,
paint != null ? paint.getNativeInstance() : 0, mDensity, mScreenDensity,
bitmap.mDensity);
}
@@ -75,7 +75,7 @@
@Override
public final void drawBitmap(@NonNull Bitmap bitmap, @NonNull Matrix matrix,
@Nullable Paint paint) {
- nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap, matrix.ni(),
+ nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap.getNativeInstance(), matrix.ni(),
paint != null ? paint.getNativeInstance() : 0);
}
@@ -100,7 +100,7 @@
bottom = src.bottom;
}
- nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom,
+ nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom,
dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity,
bitmap.mDensity);
}
@@ -126,7 +126,7 @@
bottom = src.bottom;
}
- nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom,
+ nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom,
dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity,
bitmap.mDensity);
}
@@ -188,7 +188,7 @@
// no mul by 2, since we need only 1 color per vertex
checkRange(colors.length, colorOffset, count);
}
- nDrawBitmapMesh(mNativeCanvasWrapper, bitmap, meshWidth, meshHeight,
+ nDrawBitmapMesh(mNativeCanvasWrapper, bitmap.getNativeInstance(), meshWidth, meshHeight,
verts, vertOffset, colors, colorOffset,
paint != null ? paint.getNativeInstance() : 0);
}
@@ -581,11 +581,12 @@
}
@FastNative
- private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap, float left, float top,
- long nativePaintOrZero, int canvasDensity, int screenDensity, int bitmapDensity);
+ private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle, float left,
+ float top, long nativePaintOrZero, int canvasDensity, int screenDensity,
+ int bitmapDensity);
@FastNative
- private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap,
+ private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle,
float srcLeft, float srcTop, float srcRight, float srcBottom,
float dstLeft, float dstTop, float dstRight, float dstBottom,
long nativePaintOrZero, int screenDensity, int bitmapDensity);
@@ -663,11 +664,11 @@
int screenDensity, int bitmapDensity);
@FastNative
- private static native void nDrawBitmapMatrix(long nativeCanvas, Bitmap bitmap,
+ private static native void nDrawBitmapMatrix(long nativeCanvas, long bitmapHandle,
long nativeMatrix, long nativePaint);
@FastNative
- private static native void nDrawBitmapMesh(long nativeCanvas, Bitmap bitmap, int meshWidth,
+ private static native void nDrawBitmapMesh(long nativeCanvas, long bitmapHandle, int meshWidth,
int meshHeight, float[] verts, int vertOffset, int[] colors, int colorOffset,
long nativePaint);
diff --git a/graphics/java/android/graphics/BitmapFactory.java b/graphics/java/android/graphics/BitmapFactory.java
index 49c3a3b..5623a8a 100644
--- a/graphics/java/android/graphics/BitmapFactory.java
+++ b/graphics/java/android/graphics/BitmapFactory.java
@@ -436,9 +436,15 @@
static void validate(Options opts) {
if (opts == null) return;
- if (opts.inBitmap != null && opts.inBitmap.getConfig() == Bitmap.Config.HARDWARE) {
- throw new IllegalArgumentException(
- "Bitmaps with Config.HARDWARE are always immutable");
+ if (opts.inBitmap != null) {
+ if (opts.inBitmap.getConfig() == Bitmap.Config.HARDWARE) {
+ throw new IllegalArgumentException(
+ "Bitmaps with Config.HARDWARE are always immutable");
+ }
+ if (opts.inBitmap.isRecycled()) {
+ throw new IllegalArgumentException(
+ "Cannot reuse a recycled Bitmap");
+ }
}
if (opts.inMutable && opts.inPreferredConfig == Bitmap.Config.HARDWARE) {
@@ -459,6 +465,17 @@
}
/**
+ * Helper for passing inBitmap's native pointer to native.
+ */
+ static long nativeInBitmap(Options opts) {
+ if (opts == null || opts.inBitmap == null) {
+ return 0;
+ }
+
+ return opts.inBitmap.getNativeInstance();
+ }
+
+ /**
* Helper for passing SkColorSpace pointer to native.
*
* @throws IllegalArgumentException if the ColorSpace is not Rgb or does
@@ -646,6 +663,7 @@
Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "decodeBitmap");
try {
bm = nativeDecodeByteArray(data, offset, length, opts,
+ Options.nativeInBitmap(opts),
Options.nativeColorSpace(opts));
if (bm == null && opts != null && opts.inBitmap != null) {
@@ -741,7 +759,8 @@
try {
if (is instanceof AssetManager.AssetInputStream) {
final long asset = ((AssetManager.AssetInputStream) is).getNativeAsset();
- bm = nativeDecodeAsset(asset, outPadding, opts, Options.nativeColorSpace(opts));
+ bm = nativeDecodeAsset(asset, outPadding, opts, Options.nativeInBitmap(opts),
+ Options.nativeColorSpace(opts));
} else {
bm = decodeStreamInternal(is, outPadding, opts);
}
@@ -769,6 +788,7 @@
if (opts != null) tempStorage = opts.inTempStorage;
if (tempStorage == null) tempStorage = new byte[DECODE_BUFFER_SIZE];
return nativeDecodeStream(is, tempStorage, outPadding, opts,
+ Options.nativeInBitmap(opts),
Options.nativeColorSpace(opts));
}
@@ -813,6 +833,7 @@
try {
if (nativeIsSeekable(fd)) {
bm = nativeDecodeFileDescriptor(fd, outPadding, opts,
+ Options.nativeInBitmap(opts),
Options.nativeColorSpace(opts));
} else {
FileInputStream fis = new FileInputStream(fd);
@@ -850,15 +871,15 @@
@UnsupportedAppUsage
private static native Bitmap nativeDecodeStream(InputStream is, byte[] storage,
- Rect padding, Options opts, long colorSpaceHandle);
+ Rect padding, Options opts, long inBitmapHandle, long colorSpaceHandle);
@UnsupportedAppUsage
private static native Bitmap nativeDecodeFileDescriptor(FileDescriptor fd,
- Rect padding, Options opts, long colorSpaceHandle);
+ Rect padding, Options opts, long inBitmapHandle, long colorSpaceHandle);
@UnsupportedAppUsage
private static native Bitmap nativeDecodeAsset(long nativeAsset, Rect padding, Options opts,
- long colorSpaceHandle);
+ long inBitmapHandle, long colorSpaceHandle);
@UnsupportedAppUsage
private static native Bitmap nativeDecodeByteArray(byte[] data, int offset,
- int length, Options opts, long colorSpaceHandle);
+ int length, Options opts, long inBitmapHandle, long colorSpaceHandle);
private static native boolean nativeIsSeekable(FileDescriptor fd);
}
diff --git a/graphics/java/android/graphics/BitmapRegionDecoder.java b/graphics/java/android/graphics/BitmapRegionDecoder.java
index 1410423..629d8c1 100644
--- a/graphics/java/android/graphics/BitmapRegionDecoder.java
+++ b/graphics/java/android/graphics/BitmapRegionDecoder.java
@@ -196,6 +196,7 @@
throw new IllegalArgumentException("rectangle is outside the image");
return nativeDecodeRegion(mNativeBitmapRegionDecoder, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top, options,
+ BitmapFactory.Options.nativeInBitmap(options),
BitmapFactory.Options.nativeColorSpace(options));
}
}
@@ -266,7 +267,8 @@
private static native Bitmap nativeDecodeRegion(long lbm,
int start_x, int start_y, int width, int height,
- BitmapFactory.Options options, long colorSpaceHandle);
+ BitmapFactory.Options options, long inBitmapHandle,
+ long colorSpaceHandle);
private static native int nativeGetWidth(long lbm);
private static native int nativeGetHeight(long lbm);
private static native void nativeClean(long lbm);
diff --git a/graphics/java/android/graphics/BitmapShader.java b/graphics/java/android/graphics/BitmapShader.java
index eb0f2e1..198d1e7 100644
--- a/graphics/java/android/graphics/BitmapShader.java
+++ b/graphics/java/android/graphics/BitmapShader.java
@@ -62,9 +62,9 @@
@Override
long createNativeInstance(long nativeMatrix) {
- return nativeCreate(nativeMatrix, mBitmap, mTileX, mTileY);
+ return nativeCreate(nativeMatrix, mBitmap.getNativeInstance(), mTileX, mTileY);
}
- private static native long nativeCreate(long nativeMatrix, Bitmap bitmap,
+ private static native long nativeCreate(long nativeMatrix, long bitmapHandle,
int shaderTileModeX, int shaderTileModeY);
}
diff --git a/graphics/java/android/graphics/Canvas.java b/graphics/java/android/graphics/Canvas.java
index df64204..6f00fc90 100644
--- a/graphics/java/android/graphics/Canvas.java
+++ b/graphics/java/android/graphics/Canvas.java
@@ -95,7 +95,7 @@
public Canvas() {
if (!isHardwareAccelerated()) {
// 0 means no native bitmap
- mNativeCanvasWrapper = nInitRaster(null);
+ mNativeCanvasWrapper = nInitRaster(0);
mFinalizer = NoImagePreloadHolder.sRegistry.registerNativeAllocation(
this, mNativeCanvasWrapper);
} else {
@@ -117,7 +117,7 @@
throw new IllegalStateException("Immutable bitmap passed to Canvas constructor");
}
throwIfCannotDraw(bitmap);
- mNativeCanvasWrapper = nInitRaster(bitmap);
+ mNativeCanvasWrapper = nInitRaster(bitmap.getNativeInstance());
mFinalizer = NoImagePreloadHolder.sRegistry.registerNativeAllocation(
this, mNativeCanvasWrapper);
mBitmap = bitmap;
@@ -185,7 +185,7 @@
}
if (bitmap == null) {
- nSetBitmap(mNativeCanvasWrapper, null);
+ nSetBitmap(mNativeCanvasWrapper, 0);
mDensity = Bitmap.DENSITY_NONE;
} else {
if (!bitmap.isMutable()) {
@@ -193,7 +193,7 @@
}
throwIfCannotDraw(bitmap);
- nSetBitmap(mNativeCanvasWrapper, bitmap);
+ nSetBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance());
mDensity = bitmap.mDensity;
}
@@ -1364,14 +1364,16 @@
private static native void nFreeCaches();
private static native void nFreeTextLayoutCaches();
- private static native long nInitRaster(Bitmap bitmap);
private static native long nGetNativeFinalizer();
private static native void nSetCompatibilityVersion(int apiLevel);
// ---------------- @FastNative -------------------
@FastNative
- private static native void nSetBitmap(long canvasHandle, Bitmap bitmap);
+ private static native long nInitRaster(long bitmapHandle);
+
+ @FastNative
+ private static native void nSetBitmap(long canvasHandle, long bitmapHandle);
@FastNative
private static native boolean nGetClipBounds(long nativeCanvas, Rect bounds);
diff --git a/graphics/java/android/graphics/HardwareRenderer.java b/graphics/java/android/graphics/HardwareRenderer.java
index bc744cc..b6b2d4e 100644
--- a/graphics/java/android/graphics/HardwareRenderer.java
+++ b/graphics/java/android/graphics/HardwareRenderer.java
@@ -682,8 +682,8 @@
/** @hide */
public boolean copyLayerInto(final TextureLayer layer, final Bitmap bitmap) {
- return nCopyLayerInto(mNativeProxy,
- layer.getDeferredLayerUpdater(), bitmap);
+ return nCopyLayerInto(mNativeProxy, layer.getDeferredLayerUpdater(),
+ bitmap.getNativeInstance());
}
/**
@@ -910,10 +910,10 @@
public static int copySurfaceInto(Surface surface, Rect srcRect, Bitmap bitmap) {
if (srcRect == null) {
// Empty rect means entire surface
- return nCopySurfaceInto(surface, 0, 0, 0, 0, bitmap);
+ return nCopySurfaceInto(surface, 0, 0, 0, 0, bitmap.getNativeInstance());
} else {
return nCopySurfaceInto(surface, srcRect.left, srcRect.top,
- srcRect.right, srcRect.bottom, bitmap);
+ srcRect.right, srcRect.bottom, bitmap.getNativeInstance());
}
}
@@ -1115,7 +1115,7 @@
private static native void nBuildLayer(long nativeProxy, long node);
- private static native boolean nCopyLayerInto(long nativeProxy, long layer, Bitmap bitmap);
+ private static native boolean nCopyLayerInto(long nativeProxy, long layer, long bitmapHandle);
private static native void nPushLayerUpdate(long nativeProxy, long layer);
@@ -1162,7 +1162,7 @@
private static native void nRemoveFrameMetricsObserver(long nativeProxy, long nativeObserver);
private static native int nCopySurfaceInto(Surface surface,
- int srcLeft, int srcTop, int srcRight, int srcBottom, Bitmap bitmap);
+ int srcLeft, int srcTop, int srcRight, int srcBottom, long bitmapHandle);
private static native Bitmap nCreateHardwareBitmap(long renderNode, int width, int height);
diff --git a/graphics/java/android/graphics/NinePatch.java b/graphics/java/android/graphics/NinePatch.java
index 800247a..c4c1eac 100644
--- a/graphics/java/android/graphics/NinePatch.java
+++ b/graphics/java/android/graphics/NinePatch.java
@@ -261,7 +261,8 @@
* that are transparent.
*/
public final Region getTransparentRegion(Rect bounds) {
- long r = nativeGetTransparentRegion(mBitmap, mNativeChunk, bounds);
+ long r = nativeGetTransparentRegion(mBitmap.getNativeInstance(),
+ mNativeChunk, bounds);
return r != 0 ? new Region(r) : null;
}
@@ -282,5 +283,6 @@
*/
private static native long validateNinePatchChunk(byte[] chunk);
private static native void nativeFinalize(long chunk);
- private static native long nativeGetTransparentRegion(Bitmap bitmap, long chunk, Rect location);
+ private static native long nativeGetTransparentRegion(long bitmapHandle, long chunk,
+ Rect location);
}
diff --git a/graphics/java/android/graphics/Xfermode.java b/graphics/java/android/graphics/Xfermode.java
index 41cf79a..6f4adfd 100644
--- a/graphics/java/android/graphics/Xfermode.java
+++ b/graphics/java/android/graphics/Xfermode.java
@@ -31,7 +31,7 @@
* objects drawn with that paint have the xfermode applied.
*/
public class Xfermode {
- static final int DEFAULT = BlendMode.SRC_OVER.getXfermode().porterDuffMode;
+ static final int DEFAULT = PorterDuff.Mode.SRC_OVER.nativeInt;
@UnsupportedAppUsage
int porterDuffMode = DEFAULT;
}
diff --git a/graphics/java/android/graphics/pdf/PdfRenderer.java b/graphics/java/android/graphics/pdf/PdfRenderer.java
index 1836f00..bd1a492 100644
--- a/graphics/java/android/graphics/pdf/PdfRenderer.java
+++ b/graphics/java/android/graphics/pdf/PdfRenderer.java
@@ -435,8 +435,9 @@
final long transformPtr = transform.native_instance;
synchronized (sPdfiumLock) {
- nativeRenderPage(mNativeDocument, mNativePage, destination, contentLeft,
- contentTop, contentRight, contentBottom, transformPtr, renderMode);
+ nativeRenderPage(mNativeDocument, mNativePage, destination.getNativeInstance(),
+ contentLeft, contentTop, contentRight, contentBottom, transformPtr,
+ renderMode);
}
}
@@ -487,7 +488,7 @@
private static native void nativeClose(long documentPtr);
private static native int nativeGetPageCount(long documentPtr);
private static native boolean nativeScaleForPrinting(long documentPtr);
- private static native void nativeRenderPage(long documentPtr, long pagePtr, Bitmap dest,
+ private static native void nativeRenderPage(long documentPtr, long pagePtr, long bitmapHandle,
int clipLeft, int clipTop, int clipRight, int clipBottom, long transformPtr,
int renderMode);
private static native long nativeOpenPageAndGetSize(long documentPtr, int pageIndex,
diff --git a/libs/hwui/HardwareBitmapUploader.cpp b/libs/hwui/HardwareBitmapUploader.cpp
index 8f7e814..9bb6031 100644
--- a/libs/hwui/HardwareBitmapUploader.cpp
+++ b/libs/hwui/HardwareBitmapUploader.cpp
@@ -349,8 +349,7 @@
} else {
SkBitmap bitmap;
const SkImageInfo& info = source.info();
- bitmap.allocPixels(
- SkImageInfo::MakeN32(info.width(), info.height(), info.alphaType(), nullptr));
+ bitmap.allocPixels(info.makeColorType(kN32_SkColorType));
SkCanvas canvas(bitmap);
canvas.drawColor(0);
@@ -416,7 +415,9 @@
}
void HardwareBitmapUploader::terminate() {
- sUploader->destroy();
+ if (sUploader) {
+ sUploader->destroy();
+ }
}
} // namespace android::uirenderer
diff --git a/location/java/android/location/ILocationManager.aidl b/location/java/android/location/ILocationManager.aidl
index 93dc6fa..97bc404 100644
--- a/location/java/android/location/ILocationManager.aidl
+++ b/location/java/android/location/ILocationManager.aidl
@@ -93,10 +93,10 @@
ProviderProperties getProviderProperties(String provider);
boolean isProviderPackage(String packageName);
- void setLocationControllerExtraPackage(String packageName);
- String getLocationControllerExtraPackage();
- void setLocationControllerExtraPackageEnabled(boolean enabled);
- boolean isLocationControllerExtraPackageEnabled();
+ void setExtraLocationControllerPackage(String packageName);
+ String getExtraLocationControllerPackage();
+ void setExtraLocationControllerPackageEnabled(boolean enabled);
+ boolean isExtraLocationControllerPackageEnabled();
boolean isProviderEnabledForUser(String provider, int userId);
boolean isLocationEnabledForUser(int userId);
diff --git a/location/java/android/location/LocationManager.java b/location/java/android/location/LocationManager.java
index edf304c..af60e3c 100644
--- a/location/java/android/location/LocationManager.java
+++ b/location/java/android/location/LocationManager.java
@@ -2328,9 +2328,27 @@
*/
@SystemApi
@RequiresPermission(Manifest.permission.LOCATION_HARDWARE)
- public void setLocationControllerExtraPackage(@NonNull String packageName) {
+ public void setExtraLocationControllerPackage(@Nullable String packageName) {
try {
- mService.setLocationControllerExtraPackage(packageName);
+ mService.setExtraLocationControllerPackage(packageName);
+ } catch (RemoteException e) {
+ e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
+ * Set the extra location controller package for location services on the device.
+ *
+ * @removed
+ * @deprecated Use {@link #setExtraLocationControllerPackage} instead.
+ * @hide
+ */
+ @Deprecated
+ @SystemApi
+ @RequiresPermission(Manifest.permission.LOCATION_HARDWARE)
+ public void setLocationControllerExtraPackage(String packageName) {
+ try {
+ mService.setExtraLocationControllerPackage(packageName);
} catch (RemoteException e) {
e.rethrowFromSystemServer();
}
@@ -2342,9 +2360,9 @@
* @hide
*/
@SystemApi
- public @Nullable String getLocationControllerExtraPackage() {
+ public @Nullable String getExtraLocationControllerPackage() {
try {
- return mService.getLocationControllerExtraPackage();
+ return mService.getExtraLocationControllerPackage();
} catch (RemoteException e) {
e.rethrowFromSystemServer();
return null;
@@ -2354,13 +2372,31 @@
/**
* Set whether the extra location controller package is currently enabled on the device.
*
+ * @removed
+ * @deprecated Use {@link #setExtraLocationControllerPackageEnabled} instead.
+ * @hide
+ */
+ @SystemApi
+ @Deprecated
+ @RequiresPermission(Manifest.permission.LOCATION_HARDWARE)
+ public void setLocationControllerExtraPackageEnabled(boolean enabled) {
+ try {
+ mService.setExtraLocationControllerPackageEnabled(enabled);
+ } catch (RemoteException e) {
+ e.rethrowFromSystemServer();
+ }
+ }
+
+ /**
+ * Set whether the extra location controller package is currently enabled on the device.
+ *
* @hide
*/
@SystemApi
@RequiresPermission(Manifest.permission.LOCATION_HARDWARE)
- public void setLocationControllerExtraPackageEnabled(boolean enabled) {
+ public void setExtraLocationControllerPackageEnabled(boolean enabled) {
try {
- mService.setLocationControllerExtraPackageEnabled(enabled);
+ mService.setExtraLocationControllerPackageEnabled(enabled);
} catch (RemoteException e) {
e.rethrowFromSystemServer();
}
@@ -2372,9 +2408,9 @@
* @hide
*/
@SystemApi
- public boolean isLocationControllerExtraPackageEnabled() {
+ public boolean isExtraLocationControllerPackageEnabled() {
try {
- return mService.isLocationControllerExtraPackageEnabled();
+ return mService.isExtraLocationControllerPackageEnabled();
} catch (RemoteException e) {
e.rethrowFromSystemServer();
return false;
diff --git a/media/java/android/media/AudioAttributes.java b/media/java/android/media/AudioAttributes.java
index c2f29bc..efb7f46 100644
--- a/media/java/android/media/AudioAttributes.java
+++ b/media/java/android/media/AudioAttributes.java
@@ -370,9 +370,10 @@
/**
* @hide
- * Flag specifying that the audio shall not be captured by other apps.
+ * Flag specifying that the audio shall not be captured by third-party apps
+ * with a MediaProjection.
*/
- public static final int FLAG_NO_CAPTURE = 0x1 << 10;
+ public static final int FLAG_NO_MEDIA_PROJECTION = 0x1 << 10;
/**
* @hide
@@ -380,12 +381,63 @@
*/
public static final int FLAG_MUTE_HAPTIC = 0x1 << 11;
+ /**
+ * @hide
+ * Flag specifying that the audio shall not be captured by any apps, not even system apps.
+ */
+ public static final int FLAG_NO_SYSTEM_CAPTURE = 0x1 << 12;
+
private final static int FLAG_ALL = FLAG_AUDIBILITY_ENFORCED | FLAG_SECURE | FLAG_SCO |
FLAG_BEACON | FLAG_HW_AV_SYNC | FLAG_HW_HOTWORD | FLAG_BYPASS_INTERRUPTION_POLICY |
FLAG_BYPASS_MUTE | FLAG_LOW_LATENCY | FLAG_DEEP_BUFFER | FLAG_MUTE_HAPTIC;
private final static int FLAG_ALL_PUBLIC = FLAG_AUDIBILITY_ENFORCED |
FLAG_HW_AV_SYNC | FLAG_LOW_LATENCY;
+ /**
+ * Indicates that the audio may be captured by any app.
+ *
+ * For privacy, the following usages can not be recorded: VOICE_COMMUNICATION*,
+ * USAGE_NOTIFICATION*, USAGE_ASSISTANCE* and USAGE_ASSISTANT.
+ *
+ * On {@link android.os.Build.VERSION_CODES#Q}, this means only {@link #USAGE_UNKNOWN},
+ * {@link #USAGE_MEDIA} and {@link #USAGE_GAME} may be captured.
+ *
+ * See {@link android.media.projection.MediaProjection} and
+ * {@link Builder#setAllowedCapturePolicy}.
+ */
+ public static final int ALLOW_CAPTURE_BY_ALL = 1;
+ /**
+ * Indicates that the audio may only be captured by system apps.
+ *
+ * System apps can capture for many purposes like accessibility, user guidance...
+ * but abide to the following restrictions:
+ * - the audio can not leave the device
+ * - the audio can not be passed to a third party app
+ * - the audio can not be recorded at a higher quality then 16kHz 16bit mono
+ *
+ * See {@link Builder#setAllowedCapturePolicy}.
+ */
+ public static final int ALLOW_CAPTURE_BY_SYSTEM = 2;
+ /**
+ * Indicates that the audio is not to be recorded by any app, even if it is a system app.
+ *
+ * It is encouraged to use {@link #ALLOW_CAPTURE_BY_SYSTEM} instead of this value as system apps
+ * provide significant and useful features for the user (such as live captioning
+ * and accessibility).
+ *
+ * See {@link Builder#setAllowedCapturePolicy}.
+ */
+ public static final int ALLOW_CAPTURE_BY_NONE = 3;
+
+ /** @hide */
+ @IntDef({
+ ALLOW_CAPTURE_BY_ALL,
+ ALLOW_CAPTURE_BY_SYSTEM,
+ ALLOW_CAPTURE_BY_NONE,
+ })
+ @Retention(RetentionPolicy.SOURCE)
+ public @interface CapturePolicy {}
+
@UnsupportedAppUsage
private int mUsage = USAGE_UNKNOWN;
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
@@ -593,10 +645,10 @@
case USAGE_GAME:
case USAGE_VIRTUAL_SOURCE:
case USAGE_ASSISTANT:
- mUsage = usage;
- break;
+ mUsage = usage;
+ break;
default:
- mUsage = USAGE_UNKNOWN;
+ mUsage = USAGE_UNKNOWN;
}
return this;
}
@@ -642,17 +694,34 @@
}
/**
- * Specifying if audio shall or shall not be captured by other apps.
- * By default, capture is allowed.
- * @param allowCapture false to forbid capture of the audio by any apps,
- * true to allow apps to capture the audio
+ * Specifying if audio may or may not be captured by other apps or the system.
+ *
+ * The default is {@link AudioAttributes#ALLOW_CAPTURE_BY_ALL}.
+ *
+ * Note that an application can also set its global policy, in which case the most
+ * restrictive policy is always applied.
+ *
+ * @param capturePolicy one of
+ * {@link #ALLOW_CAPTURE_BY_ALL},
+ * {@link #ALLOW_CAPTURE_BY_SYSTEM},
+ * {@link #ALLOW_CAPTURE_BY_NONE}.
* @return the same Builder instance
+ * @throws IllegalArgumentException if the argument is not a valid value.
*/
- public @NonNull Builder setAllowCapture(boolean allowCapture) {
- if (allowCapture) {
- mFlags &= ~FLAG_NO_CAPTURE;
- } else {
- mFlags |= FLAG_NO_CAPTURE;
+ public @NonNull Builder setAllowedCapturePolicy(@CapturePolicy int capturePolicy) {
+ switch (capturePolicy) {
+ case ALLOW_CAPTURE_BY_NONE:
+ mFlags |= FLAG_NO_MEDIA_PROJECTION | FLAG_NO_SYSTEM_CAPTURE;
+ break;
+ case ALLOW_CAPTURE_BY_SYSTEM:
+ mFlags |= FLAG_NO_MEDIA_PROJECTION;
+ mFlags &= ~FLAG_NO_SYSTEM_CAPTURE;
+ break;
+ case ALLOW_CAPTURE_BY_ALL:
+ mFlags &= ~FLAG_NO_SYSTEM_CAPTURE & ~FLAG_NO_MEDIA_PROJECTION;
+ break;
+ default:
+ throw new IllegalArgumentException("Unknown allow playback capture policy");
}
return this;
}
diff --git a/media/java/android/media/AudioPlaybackCaptureConfiguration.java b/media/java/android/media/AudioPlaybackCaptureConfiguration.java
index 4aa0b90..9ee6f87 100644
--- a/media/java/android/media/AudioPlaybackCaptureConfiguration.java
+++ b/media/java/android/media/AudioPlaybackCaptureConfiguration.java
@@ -28,7 +28,7 @@
/**
* Configuration for capturing audio played by other apps.
*
- * For privacy and copyright reason, only the following audio can be captured:
+ * Only the following audio can be captured:
* - usage MUST be UNKNOWN or GAME or MEDIA. All other usages CAN NOT be capturable.
* - audio attributes MUST NOT have the FLAG_NO_CAPTURE
* - played by apps that MUST be in the same user profile as the capturing app
diff --git a/media/java/android/media/MediaFormat.java b/media/java/android/media/MediaFormat.java
index a22c8d0..4d63cc8 100644
--- a/media/java/android/media/MediaFormat.java
+++ b/media/java/android/media/MediaFormat.java
@@ -1060,7 +1060,7 @@
* that no B frames are allowed. Note that non-zero value does not guarantee
* B frames; it's up to the encoder to decide.
*/
- public static final String KEY_MAX_BFRAMES = "max-bframes";
+ public static final String KEY_MAX_B_FRAMES = "max-bframes";
/* package private */ MediaFormat(@NonNull Map<String, Object> map) {
mMap = map;
diff --git a/media/java/android/media/audiopolicy/AudioMix.java b/media/java/android/media/audiopolicy/AudioMix.java
index 6fd6298..09f17c0 100644
--- a/media/java/android/media/audiopolicy/AudioMix.java
+++ b/media/java/android/media/audiopolicy/AudioMix.java
@@ -142,7 +142,8 @@
return mFormat;
}
- AudioMixingRule getRule() {
+ /** @hide */
+ public AudioMixingRule getRule() {
return mRule;
}
diff --git a/media/java/android/media/audiopolicy/AudioMixingRule.java b/media/java/android/media/audiopolicy/AudioMixingRule.java
index d41f416..947b06c 100644
--- a/media/java/android/media/audiopolicy/AudioMixingRule.java
+++ b/media/java/android/media/audiopolicy/AudioMixingRule.java
@@ -16,6 +16,7 @@
package android.media.audiopolicy;
+import android.annotation.NonNull;
import android.annotation.SystemApi;
import android.annotation.UnsupportedAppUsage;
import android.media.AudioAttributes;
@@ -43,9 +44,11 @@
@SystemApi
public class AudioMixingRule {
- private AudioMixingRule(int mixType, ArrayList<AudioMixMatchCriterion> criteria) {
+ private AudioMixingRule(int mixType, ArrayList<AudioMixMatchCriterion> criteria,
+ boolean allowPrivilegedPlaybackCapture) {
mCriteria = criteria;
mTargetMixType = mixType;
+ mAllowPrivilegedPlaybackCapture = allowPrivilegedPlaybackCapture;
}
/**
@@ -161,6 +164,13 @@
@UnsupportedAppUsage
private final ArrayList<AudioMixMatchCriterion> mCriteria;
ArrayList<AudioMixMatchCriterion> getCriteria() { return mCriteria; }
+ @UnsupportedAppUsage
+ private boolean mAllowPrivilegedPlaybackCapture = false;
+
+ /** @hide */
+ public boolean allowPrivilegedPlaybackCapture() {
+ return mAllowPrivilegedPlaybackCapture;
+ }
/** @hide */
@Override
@@ -170,12 +180,13 @@
final AudioMixingRule that = (AudioMixingRule) o;
return (this.mTargetMixType == that.mTargetMixType)
- && (areCriteriaEquivalent(this.mCriteria, that.mCriteria));
+ && (areCriteriaEquivalent(this.mCriteria, that.mCriteria)
+ && this.mAllowPrivilegedPlaybackCapture == that.mAllowPrivilegedPlaybackCapture);
}
@Override
public int hashCode() {
- return Objects.hash(mTargetMixType, mCriteria);
+ return Objects.hash(mTargetMixType, mCriteria, mAllowPrivilegedPlaybackCapture);
}
private static boolean isValidSystemApiRule(int rule) {
@@ -239,6 +250,7 @@
public static class Builder {
private ArrayList<AudioMixMatchCriterion> mCriteria;
private int mTargetMixType = AudioMix.MIX_TYPE_INVALID;
+ private boolean mAllowPrivilegedPlaybackCapture = false;
/**
* Constructs a new Builder with no rules.
@@ -343,6 +355,21 @@
}
/**
+ * Set if the audio of app that opted out of audio playback capture should be captured.
+ *
+ * The permission {@link CAPTURE_AUDIO_OUTPUT} or {@link CAPTURE_MEDIA_OUTPUT} is needed
+ * to ignore the opt-out.
+ *
+ * Only affects LOOPBACK|RENDER mix.
+ *
+ * @return the same Builder instance.
+ */
+ public @NonNull Builder allowPrivilegedPlaybackCapture(boolean allow) {
+ mAllowPrivilegedPlaybackCapture = allow;
+ return this;
+ }
+
+ /**
* Add or exclude a rule for the selection of which streams are mixed together.
* Does error checking on the parameters.
* @param rule
@@ -507,7 +534,7 @@
* @return a new {@link AudioMixingRule} object
*/
public AudioMixingRule build() {
- return new AudioMixingRule(mTargetMixType, mCriteria);
+ return new AudioMixingRule(mTargetMixType, mCriteria, mAllowPrivilegedPlaybackCapture);
}
}
}
diff --git a/media/java/android/media/audiopolicy/AudioPolicyConfig.java b/media/java/android/media/audiopolicy/AudioPolicyConfig.java
index a6e63c7..c4ba0c1 100644
--- a/media/java/android/media/audiopolicy/AudioPolicyConfig.java
+++ b/media/java/android/media/audiopolicy/AudioPolicyConfig.java
@@ -96,6 +96,8 @@
dest.writeInt(mix.getFormat().getSampleRate());
dest.writeInt(mix.getFormat().getEncoding());
dest.writeInt(mix.getFormat().getChannelMask());
+ // write opt-out respect
+ dest.writeBoolean(mix.getRule().allowPrivilegedPlaybackCapture());
// write mix rules
final ArrayList<AudioMixMatchCriterion> criteria = mix.getRule().getCriteria();
dest.writeInt(criteria.size());
@@ -124,9 +126,12 @@
final AudioFormat format = new AudioFormat.Builder().setSampleRate(sampleRate)
.setChannelMask(channelMask).setEncoding(encoding).build();
mixBuilder.setFormat(format);
+
+ AudioMixingRule.Builder ruleBuilder = new AudioMixingRule.Builder();
+ // write opt-out respect
+ ruleBuilder.allowPrivilegedPlaybackCapture(in.readBoolean());
// read mix rules
int nbRules = in.readInt();
- AudioMixingRule.Builder ruleBuilder = new AudioMixingRule.Builder();
for (int j = 0 ; j < nbRules ; j++) {
// read the matching rules
ruleBuilder.addRuleFromParcel(in);
@@ -161,7 +166,9 @@
textDump += " rate=" + mix.getFormat().getSampleRate() + "Hz\n";
textDump += " encoding=" + mix.getFormat().getEncoding() + "\n";
textDump += " channels=0x";
- textDump += Integer.toHexString(mix.getFormat().getChannelMask()).toUpperCase() +"\n";
+ textDump += Integer.toHexString(mix.getFormat().getChannelMask()).toUpperCase() + "\n";
+ textDump += " ignore playback capture opt out="
+ + mix.getRule().allowPrivilegedPlaybackCapture() + "\n";
// write mix rules
final ArrayList<AudioMixMatchCriterion> criteria = mix.getRule().getCriteria();
for (AudioMixMatchCriterion criterion : criteria) {
diff --git a/opengl/java/android/opengl/GLUtils.java b/opengl/java/android/opengl/GLUtils.java
index d097335..ca8d5ac 100644
--- a/opengl/java/android/opengl/GLUtils.java
+++ b/opengl/java/android/opengl/GLUtils.java
@@ -44,7 +44,7 @@
if (bitmap.isRecycled()) {
throw new IllegalArgumentException("bitmap is recycled");
}
- int result = native_getInternalFormat(bitmap);
+ int result = native_getInternalFormat(bitmap.getNativeInstance());
if (result < 0) {
throw new IllegalArgumentException("Unknown internalformat");
}
@@ -66,7 +66,7 @@
if (bitmap.isRecycled()) {
throw new IllegalArgumentException("bitmap is recycled");
}
- int result = native_getType(bitmap);
+ int result = native_getType(bitmap.getNativeInstance());
if (result < 0) {
throw new IllegalArgumentException("Unknown type");
}
@@ -103,7 +103,8 @@
if (bitmap.isRecycled()) {
throw new IllegalArgumentException("bitmap is recycled");
}
- if (native_texImage2D(target, level, internalformat, bitmap, -1, border)!=0) {
+ if (native_texImage2D(target, level, internalformat, bitmap.getNativeInstance(), -1,
+ border) != 0) {
throw new IllegalArgumentException("invalid Bitmap format");
}
}
@@ -129,7 +130,8 @@
if (bitmap.isRecycled()) {
throw new IllegalArgumentException("bitmap is recycled");
}
- if (native_texImage2D(target, level, internalformat, bitmap, type, border)!=0) {
+ if (native_texImage2D(target, level, internalformat, bitmap.getNativeInstance(), type,
+ border) != 0) {
throw new IllegalArgumentException("invalid Bitmap format");
}
}
@@ -151,7 +153,7 @@
if (bitmap.isRecycled()) {
throw new IllegalArgumentException("bitmap is recycled");
}
- if (native_texImage2D(target, level, -1, bitmap, -1, border)!=0) {
+ if (native_texImage2D(target, level, -1, bitmap.getNativeInstance(), -1, border) != 0) {
throw new IllegalArgumentException("invalid Bitmap format");
}
}
@@ -187,7 +189,8 @@
throw new IllegalArgumentException("bitmap is recycled");
}
int type = getType(bitmap);
- if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap, -1, type)!=0) {
+ if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap.getNativeInstance(), -1,
+ type) != 0) {
throw new IllegalArgumentException("invalid Bitmap format");
}
}
@@ -211,7 +214,8 @@
if (bitmap.isRecycled()) {
throw new IllegalArgumentException("bitmap is recycled");
}
- if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap, format, type)!=0) {
+ if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap.getNativeInstance(),
+ format, type) != 0) {
throw new IllegalArgumentException("invalid Bitmap format");
}
}
@@ -261,10 +265,10 @@
}
}
- native private static int native_getInternalFormat(Bitmap bitmap);
- native private static int native_getType(Bitmap bitmap);
+ native private static int native_getInternalFormat(long bitmapHandle);
+ native private static int native_getType(long bitmapHandle);
native private static int native_texImage2D(int target, int level, int internalformat,
- Bitmap bitmap, int type, int border);
+ long bitmapHandle, int type, int border);
native private static int native_texSubImage2D(int target, int level, int xoffset, int yoffset,
- Bitmap bitmap, int format, int type);
+ long bitmapHandle, int format, int type);
}
diff --git a/packages/NetworkStack/Android.bp b/packages/NetworkStack/Android.bp
index 52534a8..0bd5c5f 100644
--- a/packages/NetworkStack/Android.bp
+++ b/packages/NetworkStack/Android.bp
@@ -49,6 +49,9 @@
// Resources already included in NetworkStackBase
resource_dirs: [],
jarjar_rules: "jarjar-rules-shared.txt",
+ optimize: {
+ proguard_flags_files: ["proguard.flags"],
+ },
// The permission configuration *must* be included to ensure security of the device
required: ["NetworkStackPermissionStub"],
}
diff --git a/packages/NetworkStack/proguard.flags b/packages/NetworkStack/proguard.flags
new file mode 100644
index 0000000..c60f6c3
--- /dev/null
+++ b/packages/NetworkStack/proguard.flags
@@ -0,0 +1,9 @@
+-keepclassmembers class android.net.ip.IpClient {
+ static final int CMD_*;
+ static final int EVENT_*;
+}
+
+-keepclassmembers class android.net.dhcp.DhcpClient {
+ static final int CMD_*;
+ static final int EVENT_*;
+}
diff --git a/packages/NetworkStack/src/android/net/dhcp/DhcpClient.java b/packages/NetworkStack/src/android/net/dhcp/DhcpClient.java
index c6dd0117..79d6a55 100644
--- a/packages/NetworkStack/src/android/net/dhcp/DhcpClient.java
+++ b/packages/NetworkStack/src/android/net/dhcp/DhcpClient.java
@@ -126,6 +126,7 @@
// DhcpClient uses IpClient's handler.
private static final int PUBLIC_BASE = IpClient.DHCPCLIENT_CMD_BASE;
+ // Below constants are picked up by MessageUtils and exempt from ProGuard optimization.
/* Commands from controller to start/stop DHCP */
public static final int CMD_START_DHCP = PUBLIC_BASE + 1;
public static final int CMD_STOP_DHCP = PUBLIC_BASE + 2;
diff --git a/packages/NetworkStack/src/android/net/ip/IpClient.java b/packages/NetworkStack/src/android/net/ip/IpClient.java
index 346ac68..7a06af4 100644
--- a/packages/NetworkStack/src/android/net/ip/IpClient.java
+++ b/packages/NetworkStack/src/android/net/ip/IpClient.java
@@ -282,6 +282,7 @@
public static final String DUMP_ARG_CONFIRM = "confirm";
+ // Below constants are picked up by MessageUtils and exempt from ProGuard optimization.
private static final int CMD_TERMINATE_AFTER_STOP = 1;
private static final int CMD_STOP = 2;
private static final int CMD_START = 3;
diff --git a/packages/SettingsLib/tests/robotests/src/com/android/settingslib/location/RecentLocationAccessesTest.java b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/location/RecentLocationAccessesTest.java
index c1c5fa9..5d2a0d1d 100644
--- a/packages/SettingsLib/tests/robotests/src/com/android/settingslib/location/RecentLocationAccessesTest.java
+++ b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/location/RecentLocationAccessesTest.java
@@ -16,9 +16,10 @@
import android.os.Process;
import android.os.UserHandle;
import android.os.UserManager;
-
import android.util.LongSparseLongArray;
+
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
@@ -83,6 +84,7 @@
}
@Test
+ @Ignore
public void testGetAppList_shouldFilterRecentAccesses() {
List<RecentLocationAccesses.Access> requests = mRecentLocationAccesses.getAppList();
// Only two of the apps have requested location within 15 min.
@@ -95,6 +97,7 @@
}
@Test
+ @Ignore
public void testGetAppList_shouldNotShowAndroidOS() throws NameNotFoundException {
// Add android OS to the list of apps.
PackageOps androidSystemPackageOps =
diff --git a/packages/SystemUI/res/values/dimens.xml b/packages/SystemUI/res/values/dimens.xml
index baa2055..039eca6 100644
--- a/packages/SystemUI/res/values/dimens.xml
+++ b/packages/SystemUI/res/values/dimens.xml
@@ -37,7 +37,13 @@
<dimen name="navigation_handle_radius">1dp</dimen>
<dimen name="navigation_handle_bottom">6dp</dimen>
<dimen name="navigation_handle_horizontal_margin">30dp</dimen>
- <dimen name="navigation_home_handle_width">280dp</dimen>
+ <dimen name="navigation_handle_sample_horizontal_margin">10dp</dimen>
+ <dimen name="navigation_home_handle_width">72dp</dimen>
+
+ <!-- Luminance threshold to determine black/white contrast for the navigation affordances -->
+ <item name="navigation_luminance_threshold" type="dimen" format="float">0.5</item>
+ <!-- Luminance change threshold that allows applying new value if difference was exceeded -->
+ <item name="navigation_luminance_change_threshold" type="dimen" format="float">0.05</item>
<!-- Height of notification icons in the status bar -->
<dimen name="status_bar_icon_size">@*android:dimen/status_bar_icon_size</dimen>
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java b/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java
index 8faeb15..112f91c 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/KeyguardIndicationController.java
@@ -308,11 +308,23 @@
// Walk down a precedence-ordered list of what indication
// should be shown based on user or device state
if (mDozing) {
+ // When dozing we ignore any text color and use white instead, because
+ // colors can be hard to read in low brightness.
+ mTextView.setTextColor(Color.WHITE);
if (!TextUtils.isEmpty(mTransientIndication)) {
- mTextView.setTextColor(Color.WHITE);
mTextView.switchIndication(mTransientIndication);
+ } else if (mPowerPluggedIn) {
+ String indication = computePowerIndication();
+ if (animate) {
+ animateText(mTextView, indication);
+ } else {
+ mTextView.switchIndication(indication);
+ }
+ } else {
+ String percentage = NumberFormat.getPercentInstance()
+ .format(mBatteryLevel / 100f);
+ mTextView.switchIndication(percentage);
}
- updateAlphas();
return;
}
@@ -353,14 +365,6 @@
}
}
- private void updateAlphas() {
- if (!TextUtils.isEmpty(mTransientIndication)) {
- mTextView.setAlpha(1f);
- } else {
- mTextView.setAlpha(1f - mDarkAmount);
- }
- }
-
// animates textView - textView moves up and bounces down
private void animateText(KeyguardIndicationTextView textView, String indication) {
int yTranslation = mContext.getResources().getInteger(
@@ -523,14 +527,6 @@
pw.println(" computePowerIndication(): " + computePowerIndication());
}
- public void setDarkAmount(float darkAmount) {
- if (mDarkAmount == darkAmount) {
- return;
- }
- mDarkAmount = darkAmount;
- updateAlphas();
- }
-
@Override
public void onStateChanged(int newState) {
// don't care
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
index 2d91d53..a924680 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
@@ -19,6 +19,7 @@
import static android.view.accessibility.AccessibilityNodeInfo.ACTION_CLICK;
import static android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction;
+import static com.android.systemui.doze.util.BurnInHelperKt.getBurnInOffset;
import static com.android.systemui.tuner.LockscreenFragment.LOCKSCREEN_LEFT_BUTTON;
import static com.android.systemui.tuner.LockscreenFragment.LOCKSCREEN_LEFT_UNLOCK;
import static com.android.systemui.tuner.LockscreenFragment.LOCKSCREEN_RIGHT_BUTTON;
@@ -172,6 +173,8 @@
private boolean mDozing;
private int mIndicationBottomMargin;
private float mDarkAmount;
+ private int mBurnInXOffset;
+ private int mBurnInYOffset;
private ActivityIntentHelper mActivityIntentHelper;
public KeyguardBottomAreaView(Context context) {
@@ -252,6 +255,8 @@
mIndicationText = findViewById(R.id.keyguard_indication_text);
mIndicationBottomMargin = getResources().getDimensionPixelSize(
R.dimen.keyguard_indication_margin_bottom);
+ mBurnInYOffset = getResources().getDimensionPixelSize(
+ R.dimen.default_burn_in_prevention_offset);
updateCameraVisibility();
mUnlockMethodCache = UnlockMethodCache.getInstance(getContext());
mUnlockMethodCache.addListener(this);
@@ -321,6 +326,8 @@
super.onConfigurationChanged(newConfig);
mIndicationBottomMargin = getResources().getDimensionPixelSize(
R.dimen.keyguard_indication_margin_bottom);
+ mBurnInYOffset = getResources().getDimensionPixelSize(
+ R.dimen.default_burn_in_prevention_offset);
MarginLayoutParams mlp = (MarginLayoutParams) mIndicationArea.getLayoutParams();
if (mlp.bottomMargin != mIndicationBottomMargin) {
mlp.bottomMargin = mIndicationBottomMargin;
@@ -564,8 +571,8 @@
return;
}
mDarkAmount = darkAmount;
- mIndicationController.setDarkAmount(darkAmount);
mLockIcon.setDarkAmount(darkAmount);
+ dozeTimeTick();
}
/**
@@ -841,6 +848,20 @@
}
}
+ public void dozeTimeTick() {
+ int burnInYOffset = getBurnInOffset(mBurnInYOffset * 2, false /* xAxis */)
+ - mBurnInYOffset;
+ mIndicationArea.setTranslationY(burnInYOffset * mDarkAmount);
+ }
+
+ public void setAntiBurnInOffsetX(int burnInXOffset) {
+ if (mBurnInXOffset == burnInXOffset) {
+ return;
+ }
+ mBurnInXOffset = burnInXOffset;
+ mIndicationArea.setTranslationX(burnInXOffset);
+ }
+
/**
* Sets the alpha of the indication areas and affordances, excluding the lock icon.
*/
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardStatusBarView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardStatusBarView.java
index 4c50d07..2bd8d41 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardStatusBarView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardStatusBarView.java
@@ -17,7 +17,6 @@
package com.android.systemui.statusbar.phone;
import static com.android.systemui.ScreenDecorations.DisplayCutoutView.boundsFromDirection;
-import static com.android.systemui.doze.util.BurnInHelperKt.getBurnInOffset;
import android.annotation.ColorInt;
import android.content.Context;
@@ -102,19 +101,6 @@
*/
private int mCutoutSideNudge = 0;
- /**
- * How much to move icons to avoid burn in.
- */
- private int mBurnInOffset;
- private int mCurrentBurnInOffsetX;
- private int mCurrentBurnInOffsetY;
-
- /**
- * Ratio representing being in ambient mode or not.
- */
- private float mDarkAmount;
- private boolean mDozing;
-
public KeyguardStatusBarView(Context context, AttributeSet attrs) {
super(context, attrs);
}
@@ -186,8 +172,6 @@
R.dimen.system_icons_super_container_avatarless_margin_end);
mCutoutSideNudge = getResources().getDimensionPixelSize(
R.dimen.display_cutout_margin_consumption);
- mBurnInOffset = getResources().getDimensionPixelSize(
- R.dimen.default_burn_in_prevention_offset);
mShowPercentAvailable = getContext().getResources().getBoolean(
com.android.internal.R.bool.config_battery_percentage_setting_available);
}
@@ -211,7 +195,7 @@
mMultiUserSwitch.setVisibility(View.GONE);
}
}
- mBatteryView.setForceShowPercent(mBatteryCharging && mShowPercentAvailable || mDozing);
+ mBatteryView.setForceShowPercent(mBatteryCharging && mShowPercentAvailable);
}
private void updateSystemIconsLayoutParams() {
@@ -348,7 +332,6 @@
mIconManager = new TintedIconManager(findViewById(R.id.statusIcons));
Dependency.get(StatusBarIconController.class).addIconGroup(mIconManager);
onThemeChanged();
- updateDarkState();
}
@Override
@@ -492,7 +475,7 @@
mIconManager.setTint(iconColor);
}
- applyDarkness(R.id.battery, mEmptyRect, intensity * (1f - mDarkAmount), iconColor);
+ applyDarkness(R.id.battery, mEmptyRect, intensity, iconColor);
applyDarkness(R.id.clock, mEmptyRect, intensity, iconColor);
}
@@ -513,48 +496,4 @@
mBatteryView.dump(fd, pw, args);
}
}
-
- public void setDozing(boolean dozing) {
- if (mDozing == dozing) {
- return;
- }
- mDozing = dozing;
- setClipChildren(!dozing);
- setClipToPadding(!dozing);
- updateVisibilities();
- }
-
- public void setDarkAmount(float darkAmount) {
- mDarkAmount = darkAmount;
- if (darkAmount == 0) {
- dozeTimeTick();
- }
- updateDarkState();
- }
-
- public void dozeTimeTick() {
- mCurrentBurnInOffsetX = getBurnInOffset(mBurnInOffset, true /* xAxis */);
- mCurrentBurnInOffsetY = getBurnInOffset(mBurnInOffset, false /* xAxis */);
- updateDarkState();
- }
-
- private void updateDarkState() {
- float alpha = 1f - mDarkAmount;
- int visibility = alpha != 0f ? VISIBLE : INVISIBLE;
- mCarrierLabel.setAlpha(alpha * alpha);
- mStatusIconContainer.setAlpha(alpha);
- mStatusIconContainer.setVisibility(visibility);
-
- float iconsX = -mCurrentBurnInOffsetX;
- if (mMultiUserSwitch.getVisibility() == VISIBLE) {
- // Squared alpha to add a nice easing curve and avoid overlap during animation.
- mMultiUserAvatar.setAlpha(alpha * alpha);
- iconsX += mMultiUserAvatar.getPaddingLeft() + mMultiUserAvatar.getWidth()
- + mMultiUserAvatar.getPaddingRight();
- }
- mSystemIconsContainer.setTranslationX(iconsX * mDarkAmount);
- mSystemIconsContainer.setTranslationY(mCurrentBurnInOffsetY * mDarkAmount);
- updateIconsAndTextColors();
- }
-
}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavBarTintController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavBarTintController.java
index 9cfb1aa..bf5b60a 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavBarTintController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavBarTintController.java
@@ -19,11 +19,14 @@
import static android.view.Display.DEFAULT_DISPLAY;
import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Point;
import android.graphics.Rect;
import android.os.Handler;
import android.view.CompositionSamplingListener;
import android.view.View;
+import com.android.systemui.R;
import com.android.systemui.shared.system.QuickStepContract;
import java.io.PrintWriter;
@@ -37,9 +40,6 @@
public static final int MIN_COLOR_ADAPT_TRANSITION_TIME = 400;
public static final int DEFAULT_COLOR_ADAPT_TRANSITION_TIME = 1700;
- // Passing the threshold of this luminance value will make the button black otherwise white
- private static final float LUMINANCE_THRESHOLD = 0.3f;
-
private final Handler mHandler = new Handler();
private final NavigationBarView mNavigationBarView;
private final LightBarTransitionsController mLightBarController;
@@ -50,9 +50,17 @@
private boolean mSamplingEnabled = false;
private boolean mSamplingListenerRegistered = false;
- private float mLastMediaLuma;
+ private float mLastMedianLuma;
+ private float mCurrentMedianLuma;
private boolean mUpdateOnNextDraw;
+ private final int mNavBarHeight;
+ private final int mNavColorSampleMargin;
+
+ // Passing the threshold of this luminance value will make the button black otherwise white
+ private final float mLuminanceThreshold;
+ private final float mLuminanceChangeThreshold;
+
public NavBarTintController(NavigationBarView navigationBarView,
LightBarTransitionsController lightBarController) {
mSamplingListener = new CompositionSamplingListener(
@@ -66,6 +74,13 @@
mNavigationBarView.addOnAttachStateChangeListener(this);
mNavigationBarView.addOnLayoutChangeListener(this);
mLightBarController = lightBarController;
+
+ final Resources res = navigationBarView.getResources();
+ mNavBarHeight = res.getDimensionPixelSize(R.dimen.navigation_bar_height);
+ mNavColorSampleMargin =
+ res.getDimensionPixelSize(R.dimen.navigation_handle_sample_horizontal_margin);
+ mLuminanceThreshold = res.getFloat(R.dimen.navigation_luminance_threshold);
+ mLuminanceChangeThreshold = res.getFloat(R.dimen.navigation_luminance_change_threshold);
}
void onDraw() {
@@ -109,8 +124,11 @@
if (view != null) {
int[] pos = new int[2];
view.getLocationOnScreen(pos);
- final Rect samplingBounds = new Rect(pos[0], pos[1],
- pos[0] + view.getWidth(), pos[1] + view.getHeight());
+ Point displaySize = new Point();
+ view.getContext().getDisplay().getRealSize(displaySize);
+ final Rect samplingBounds = new Rect(pos[0] - mNavColorSampleMargin,
+ displaySize.y - mNavBarHeight, pos[0] + view.getWidth() + mNavColorSampleMargin,
+ displaySize.y);
if (!samplingBounds.equals(mSamplingBounds)) {
mSamplingBounds.set(samplingBounds);
requestUpdateSamplingListener();
@@ -144,13 +162,19 @@
}
private void updateTint(float medianLuma) {
- mLastMediaLuma = medianLuma;
- if (medianLuma > LUMINANCE_THRESHOLD) {
- // Black
- mLightBarController.setIconsDark(true /* dark */, true /* animate */);
- } else {
- // White
- mLightBarController.setIconsDark(false /* dark */, true /* animate */);
+ mLastMedianLuma = medianLuma;
+
+ // If the difference between the new luma and the current luma is larger than threshold
+ // then apply the current luma, this is to prevent small changes causing colors to flicker
+ if (Math.abs(mCurrentMedianLuma - mLastMedianLuma) > mLuminanceChangeThreshold) {
+ if (medianLuma > mLuminanceThreshold) {
+ // Black
+ mLightBarController.setIconsDark(true /* dark */, true /* animate */);
+ } else {
+ // White
+ mLightBarController.setIconsDark(false /* dark */, true /* animate */);
+ }
+ mCurrentMedianLuma = medianLuma;
}
}
@@ -162,7 +186,8 @@
: "false"));
pw.println(" mSamplingListenerRegistered: " + mSamplingListenerRegistered);
pw.println(" mSamplingBounds: " + mSamplingBounds);
- pw.println(" mLastMediaLuma: " + mLastMediaLuma);
+ pw.println(" mLastMedianLuma: " + mLastMedianLuma);
+ pw.println(" mCurrentMedianLuma: " + mCurrentMedianLuma);
}
public static boolean isEnabled(Context context) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationHandle.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationHandle.java
index 968074c..81a425c 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationHandle.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationHandle.java
@@ -68,7 +68,7 @@
int height = mRadius * 2;
int width = getWidth();
int y = (navHeight - mBottom - height);
- canvas.drawRoundRect(mRadius, y, width - mRadius, y + height, mRadius, mRadius, mPaint);
+ canvas.drawRoundRect(0, y, width, y + height, mRadius, mRadius, mPaint);
}
@Override
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java
index ab1f500..02bad73 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationPanelView.java
@@ -635,6 +635,7 @@
}
mNotificationStackScroller.setIntrinsicPadding(stackScrollerPadding);
mNotificationStackScroller.setAntiBurnInOffsetX(mClockPositionResult.clockX);
+ mKeyguardBottomArea.setAntiBurnInOffsetX(mClockPositionResult.clockX);
mStackScrollerMeasuringPass++;
requestScrollerTopPaddingUpdate(animate);
@@ -1886,7 +1887,7 @@
float newAlpha = Math.min(getKeyguardContentsAlpha(), alphaQsExpansion)
* mKeyguardStatusBarAnimateAlpha;
mKeyguardStatusBar.setAlpha(newAlpha);
- mKeyguardStatusBar.setVisibility(newAlpha != 0f ? VISIBLE : INVISIBLE);
+ mKeyguardStatusBar.setVisibility(newAlpha != 0f && !mDozing ? VISIBLE : INVISIBLE);
}
private void updateKeyguardBottomAreaAlpha() {
@@ -2373,12 +2374,11 @@
positionClockAndNotifications();
}
- private static float interpolate(float t, float start, float end) {
- return (1 - t) * start + t * end;
- }
-
private void updateDozingVisibilities(boolean animate) {
mKeyguardBottomArea.setDozing(mDozing, animate);
+ if (!mDozing && animate) {
+ animateKeyguardStatusBarIn(StackStateAnimator.ANIMATION_DURATION_STANDARD);
+ }
}
@Override
@@ -2814,7 +2814,7 @@
if (mDozing) {
mNotificationStackScroller.setShowDarkShelf(!hasCustomClock());
}
- mKeyguardStatusBar.setDozing(mDozing);
+ mKeyguardBottomArea.setDozing(mDozing, animate);
if (mBarState == StatusBarState.KEYGUARD
|| mBarState == StatusBarState.SHADE_LOCKED) {
@@ -2829,7 +2829,6 @@
public void onDozeAmountChanged(float linearAmount, float amount) {
mInterpolatedDarkAmount = amount;
mLinearDarkAmount = linearAmount;
- mKeyguardStatusBar.setDarkAmount(mInterpolatedDarkAmount);
mKeyguardStatusView.setDarkAmount(mInterpolatedDarkAmount);
mKeyguardBottomArea.setDarkAmount(mInterpolatedDarkAmount);
positionClockAndNotifications();
@@ -2861,7 +2860,7 @@
}
public void dozeTimeTick() {
- mKeyguardStatusBar.dozeTimeTick();
+ mKeyguardBottomArea.dozeTimeTick();
mKeyguardStatusView.dozeTimeTick();
if (mInterpolatedDarkAmount > 0) {
positionClockAndNotifications();
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationPanelViewTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationPanelViewTest.java
index 232c6a2..3b56e45 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationPanelViewTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/NotificationPanelViewTest.java
@@ -60,6 +60,8 @@
@Mock
private KeyguardStatusView mKeyguardStatusView;
@Mock
+ private KeyguardBottomAreaView mKeyguardBottomArea;
+ @Mock
private KeyguardStatusBarView mKeyguardStatusBar;
private NotificationPanelView mNotificationPanelView;
@@ -113,6 +115,7 @@
mNotificationStackScroller = mNotificationStackScrollLayout;
mKeyguardStatusView = NotificationPanelViewTest.this.mKeyguardStatusView;
mKeyguardStatusBar = NotificationPanelViewTest.this.mKeyguardStatusBar;
+ mKeyguardBottomArea = NotificationPanelViewTest.this.mKeyguardBottomArea;
}
}
}
diff --git a/rs/java/android/renderscript/RenderScript.java b/rs/java/android/renderscript/RenderScript.java
index 85c82bc..f4c2777 100644
--- a/rs/java/android/renderscript/RenderScript.java
+++ b/rs/java/android/renderscript/RenderScript.java
@@ -447,27 +447,33 @@
validate();
return rsnAllocationCreateTyped(mContext, type, mip, usage, pointer);
}
- native long rsnAllocationCreateFromBitmap(long con, long type, int mip, Bitmap bmp, int usage);
+ native long rsnAllocationCreateFromBitmap(long con, long type, int mip, long bitmapHandle,
+ int usage);
synchronized long nAllocationCreateFromBitmap(long type, int mip, Bitmap bmp, int usage) {
validate();
- return rsnAllocationCreateFromBitmap(mContext, type, mip, bmp, usage);
+ return rsnAllocationCreateFromBitmap(mContext, type, mip, bmp.getNativeInstance(), usage);
}
- native long rsnAllocationCreateBitmapBackedAllocation(long con, long type, int mip, Bitmap bmp, int usage);
- synchronized long nAllocationCreateBitmapBackedAllocation(long type, int mip, Bitmap bmp, int usage) {
+ native long rsnAllocationCreateBitmapBackedAllocation(long con, long type, int mip, long bitmapHandle,
+ int usage);
+ synchronized long nAllocationCreateBitmapBackedAllocation(long type, int mip, Bitmap bmp,
+ int usage) {
validate();
- return rsnAllocationCreateBitmapBackedAllocation(mContext, type, mip, bmp, usage);
+ return rsnAllocationCreateBitmapBackedAllocation(mContext, type, mip, bmp.getNativeInstance(),
+ usage);
}
- native long rsnAllocationCubeCreateFromBitmap(long con, long type, int mip, Bitmap bmp, int usage);
+ native long rsnAllocationCubeCreateFromBitmap(long con, long type, int mip, long bitmapHandle,
+ int usage);
synchronized long nAllocationCubeCreateFromBitmap(long type, int mip, Bitmap bmp, int usage) {
validate();
- return rsnAllocationCubeCreateFromBitmap(mContext, type, mip, bmp, usage);
+ return rsnAllocationCubeCreateFromBitmap(mContext, type, mip, bmp.getNativeInstance(),
+ usage);
}
- native long rsnAllocationCreateBitmapRef(long con, long type, Bitmap bmp);
+ native long rsnAllocationCreateBitmapRef(long con, long type, long bitmapHandle);
synchronized long nAllocationCreateBitmapRef(long type, Bitmap bmp) {
validate();
- return rsnAllocationCreateBitmapRef(mContext, type, bmp);
+ return rsnAllocationCreateBitmapRef(mContext, type, bmp.getNativeInstance());
}
native long rsnAllocationCreateFromAssetStream(long con, int mips, int assetStream, int usage);
synchronized long nAllocationCreateFromAssetStream(int mips, int assetStream, int usage) {
@@ -475,10 +481,10 @@
return rsnAllocationCreateFromAssetStream(mContext, mips, assetStream, usage);
}
- native void rsnAllocationCopyToBitmap(long con, long alloc, Bitmap bmp);
+ native void rsnAllocationCopyToBitmap(long con, long alloc, long bitmapHandle);
synchronized void nAllocationCopyToBitmap(long alloc, Bitmap bmp) {
validate();
- rsnAllocationCopyToBitmap(mContext, alloc, bmp);
+ rsnAllocationCopyToBitmap(mContext, alloc, bmp.getNativeInstance());
}
native void rsnAllocationSyncAll(long con, long alloc, int src);
@@ -487,8 +493,10 @@
rsnAllocationSyncAll(mContext, alloc, src);
}
- native ByteBuffer rsnAllocationGetByteBuffer(long con, long alloc, long[] stride, int xBytesSize, int dimY, int dimZ);
- synchronized ByteBuffer nAllocationGetByteBuffer(long alloc, long[] stride, int xBytesSize, int dimY, int dimZ) {
+ native ByteBuffer rsnAllocationGetByteBuffer(long con, long alloc, long[] stride,
+ int xBytesSize, int dimY, int dimZ);
+ synchronized ByteBuffer nAllocationGetByteBuffer(long alloc, long[] stride, int xBytesSize,
+ int dimY, int dimZ) {
validate();
return rsnAllocationGetByteBuffer(mContext, alloc, stride, xBytesSize, dimY, dimZ);
}
@@ -529,10 +537,10 @@
validate();
rsnAllocationGenerateMipmaps(mContext, alloc);
}
- native void rsnAllocationCopyFromBitmap(long con, long alloc, Bitmap bmp);
+ native void rsnAllocationCopyFromBitmap(long con, long alloc, long bitmapHandle);
synchronized void nAllocationCopyFromBitmap(long alloc, Bitmap bmp) {
validate();
- rsnAllocationCopyFromBitmap(mContext, alloc, bmp);
+ rsnAllocationCopyFromBitmap(mContext, alloc, bmp.getNativeInstance());
}
diff --git a/rs/jni/android_renderscript_RenderScript.cpp b/rs/jni/android_renderscript_RenderScript.cpp
index 52d0e08e..dfee961 100644
--- a/rs/jni/android_renderscript_RenderScript.cpp
+++ b/rs/jni/android_renderscript_RenderScript.cpp
@@ -1321,10 +1321,10 @@
static jlong
nAllocationCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip,
- jobject jbitmap, jint usage)
+ jlong bitmapPtr, jint usage)
{
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
const void* ptr = bitmap.getPixels();
jlong id = (jlong)(uintptr_t)rsAllocationCreateFromBitmap((RsContext)con,
@@ -1335,10 +1335,10 @@
static jlong
nAllocationCreateBitmapBackedAllocation(JNIEnv *_env, jobject _this, jlong con, jlong type,
- jint mip, jobject jbitmap, jint usage)
+ jint mip, jlong bitmapPtr, jint usage)
{
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
const void* ptr = bitmap.getPixels();
jlong id = (jlong)(uintptr_t)rsAllocationCreateTyped((RsContext)con,
@@ -1349,10 +1349,10 @@
static jlong
nAllocationCubeCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip,
- jobject jbitmap, jint usage)
+ jlong bitmapPtr, jint usage)
{
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
const void* ptr = bitmap.getPixels();
jlong id = (jlong)(uintptr_t)rsAllocationCubeCreateFromBitmap((RsContext)con,
@@ -1362,10 +1362,10 @@
}
static void
-nAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap)
+nAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jlong bitmapPtr)
{
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
int w = bitmap.width();
int h = bitmap.height();
@@ -1376,10 +1376,10 @@
}
static void
-nAllocationCopyToBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap)
+nAllocationCopyToBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jlong bitmapPtr)
{
SkBitmap bitmap;
- GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap);
+ bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
void* ptr = bitmap.getPixels();
rsAllocationCopyToBitmap((RsContext)con, (RsAllocation)alloc, ptr, bitmap.computeByteSize());
@@ -2866,13 +2866,13 @@
{"rsnTypeCreate", "(JJIIIZZI)J", (void*)nTypeCreate },
{"rsnTypeGetNativeData", "(JJ[J)V", (void*)nTypeGetNativeData },
-{"rsnAllocationCreateTyped", "(JJIIJ)J", (void*)nAllocationCreateTyped },
-{"rsnAllocationCreateFromBitmap", "(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCreateFromBitmap },
-{"rsnAllocationCreateBitmapBackedAllocation", "(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCreateBitmapBackedAllocation },
-{"rsnAllocationCubeCreateFromBitmap","(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCubeCreateFromBitmap },
+{"rsnAllocationCreateTyped", "(JJIIJ)J", (void*)nAllocationCreateTyped },
+{"rsnAllocationCreateFromBitmap", "(JJIJI)J", (void*)nAllocationCreateFromBitmap },
+{"rsnAllocationCreateBitmapBackedAllocation", "(JJIJI)J", (void*)nAllocationCreateBitmapBackedAllocation },
+{"rsnAllocationCubeCreateFromBitmap","(JJIJI)J", (void*)nAllocationCubeCreateFromBitmap },
-{"rsnAllocationCopyFromBitmap", "(JJLandroid/graphics/Bitmap;)V", (void*)nAllocationCopyFromBitmap },
-{"rsnAllocationCopyToBitmap", "(JJLandroid/graphics/Bitmap;)V", (void*)nAllocationCopyToBitmap },
+{"rsnAllocationCopyFromBitmap", "(JJJ)V", (void*)nAllocationCopyFromBitmap },
+{"rsnAllocationCopyToBitmap", "(JJJ)V", (void*)nAllocationCopyToBitmap },
{"rsnAllocationSyncAll", "(JJI)V", (void*)nAllocationSyncAll },
{"rsnAllocationSetupBufferQueue", "(JJI)V", (void*)nAllocationSetupBufferQueue },
diff --git a/services/core/java/com/android/server/AlarmManagerService.java b/services/core/java/com/android/server/AlarmManagerService.java
index 3d918fc..0f39029 100644
--- a/services/core/java/com/android/server/AlarmManagerService.java
+++ b/services/core/java/com/android/server/AlarmManagerService.java
@@ -3825,6 +3825,7 @@
Slog.w(TAG, "Failure sending alarm.", e);
}
Trace.traceEnd(Trace.TRACE_TAG_POWER);
+ decrementAlarmCount(alarm.uid);
}
}
@@ -4148,6 +4149,10 @@
public void handleMessage(Message msg) {
switch (msg.what) {
case ALARM_EVENT: {
+ // This code is used when the kernel timer driver is not available, which
+ // shouldn't happen. Here, we try our best to simulate it, which may be useful
+ // when porting Android to a new device. Note that we can't wake up a device
+ // this way, so WAKE_UP alarms will be delivered only when the device is awake.
ArrayList<Alarm> triggerList = new ArrayList<Alarm>();
synchronized (mLock) {
final long nowELAPSED = mInjector.getElapsedRealtime();
@@ -4167,6 +4172,7 @@
removeImpl(alarm.operation, null);
}
}
+ decrementAlarmCount(alarm.uid);
}
break;
}
@@ -4760,7 +4766,6 @@
mAppWakeupHistory.recordAlarmForPackage(alarm.sourcePackage,
UserHandle.getUserId(alarm.creatorUid), nowELAPSED);
}
- decrementAlarmCount(alarm.uid);
final BroadcastStats bs = inflight.mBroadcastStats;
bs.count++;
if (bs.nesting == 0) {
diff --git a/services/core/java/com/android/server/LocationManagerService.java b/services/core/java/com/android/server/LocationManagerService.java
index f0244c3..2ded1e5 100644
--- a/services/core/java/com/android/server/LocationManagerService.java
+++ b/services/core/java/com/android/server/LocationManagerService.java
@@ -200,8 +200,8 @@
private GnssMeasurementCorrectionsProvider mGnssMeasurementCorrectionsProvider;
private GnssNavigationMessageProvider mGnssNavigationMessageProvider;
@GuardedBy("mLock")
- private String mLocationControllerExtraPackage;
- private boolean mLocationControllerExtraPackageEnabled;
+ private String mExtraLocationControllerPackage;
+ private boolean mExtraLocationControllerPackageEnabled;
private IGpsGeofenceHardware mGpsGeofenceProxy;
// list of currently active providers
@@ -3045,35 +3045,35 @@
}
@Override
- public void setLocationControllerExtraPackage(String packageName) {
+ public void setExtraLocationControllerPackage(String packageName) {
mContext.enforceCallingPermission(Manifest.permission.LOCATION_HARDWARE,
Manifest.permission.LOCATION_HARDWARE + " permission required");
synchronized (mLock) {
- mLocationControllerExtraPackage = packageName;
+ mExtraLocationControllerPackage = packageName;
}
}
@Override
- public String getLocationControllerExtraPackage() {
+ public String getExtraLocationControllerPackage() {
synchronized (mLock) {
- return mLocationControllerExtraPackage;
+ return mExtraLocationControllerPackage;
}
}
@Override
- public void setLocationControllerExtraPackageEnabled(boolean enabled) {
+ public void setExtraLocationControllerPackageEnabled(boolean enabled) {
mContext.enforceCallingPermission(Manifest.permission.LOCATION_HARDWARE,
Manifest.permission.LOCATION_HARDWARE + " permission required");
synchronized (mLock) {
- mLocationControllerExtraPackageEnabled = enabled;
+ mExtraLocationControllerPackageEnabled = enabled;
}
}
@Override
- public boolean isLocationControllerExtraPackageEnabled() {
+ public boolean isExtraLocationControllerPackageEnabled() {
synchronized (mLock) {
- return mLocationControllerExtraPackageEnabled
- && (mLocationControllerExtraPackage != null);
+ return mExtraLocationControllerPackageEnabled
+ && (mExtraLocationControllerPackage != null);
}
}
@@ -3610,9 +3610,9 @@
pw.println(" mBlacklist=null");
}
- if (mLocationControllerExtraPackage != null) {
- pw.println(" Location controller extra package: " + mLocationControllerExtraPackage
- + " enabled: " + mLocationControllerExtraPackageEnabled);
+ if (mExtraLocationControllerPackage != null) {
+ pw.println(" Location controller extra package: " + mExtraLocationControllerPackage
+ + " enabled: " + mExtraLocationControllerPackageEnabled);
}
if (!mBackgroundThrottlePackageWhitelist.isEmpty()) {
diff --git a/services/core/java/com/android/server/StorageManagerService.java b/services/core/java/com/android/server/StorageManagerService.java
index 5b9c1f8..1a842f7 100644
--- a/services/core/java/com/android/server/StorageManagerService.java
+++ b/services/core/java/com/android/server/StorageManagerService.java
@@ -17,10 +17,14 @@
package com.android.server;
import static android.Manifest.permission.INSTALL_PACKAGES;
+import static android.Manifest.permission.READ_EXTERNAL_STORAGE;
+import static android.Manifest.permission.WRITE_EXTERNAL_STORAGE;
import static android.Manifest.permission.WRITE_MEDIA_STORAGE;
import static android.app.AppOpsManager.MODE_ALLOWED;
import static android.app.AppOpsManager.OP_LEGACY_STORAGE;
+import static android.app.AppOpsManager.OP_READ_EXTERNAL_STORAGE;
import static android.app.AppOpsManager.OP_REQUEST_INSTALL_PACKAGES;
+import static android.app.AppOpsManager.OP_WRITE_EXTERNAL_STORAGE;
import static android.content.pm.PackageManager.FLAG_PERMISSION_HIDDEN;
import static android.content.pm.PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
import static android.content.pm.PackageManager.GET_PERMISSIONS;
@@ -280,6 +284,7 @@
private static final boolean EMULATE_FBE_SUPPORTED = true;
private static final String TAG = "StorageManagerService";
+ private static final boolean LOCAL_LOGV = Log.isLoggable(TAG, Log.VERBOSE);
private static final String TAG_STORAGE_BENCHMARK = "storage_benchmark";
private static final String TAG_STORAGE_TRIM = "storage_trim";
@@ -3863,44 +3868,57 @@
}
private int getMountMode(int uid, String packageName) {
+ final int mode = getMountModeInternal(uid, packageName);
+ if (LOCAL_LOGV) {
+ Slog.v(TAG, "Resolved mode " + mode + " for " + packageName + "/"
+ + UserHandle.formatUid(uid));
+ }
+ return mode;
+ }
+
+ private int getMountModeInternal(int uid, String packageName) {
try {
+ // Get some easy cases out of the way first
if (Process.isIsolated(uid)) {
return Zygote.MOUNT_EXTERNAL_NONE;
}
- if (mIPackageManager.checkUidPermission(WRITE_MEDIA_STORAGE, uid)
- == PERMISSION_GRANTED) {
- return Zygote.MOUNT_EXTERNAL_FULL;
- } else if (mIAppOpsService.checkOperation(OP_LEGACY_STORAGE, uid,
- packageName) == MODE_ALLOWED) {
- return Zygote.MOUNT_EXTERNAL_LEGACY;
- } else if (mIPackageManager.checkUidPermission(INSTALL_PACKAGES, uid)
- == PERMISSION_GRANTED || mIAppOpsService.checkOperation(
- OP_REQUEST_INSTALL_PACKAGES, uid, packageName) == MODE_ALLOWED) {
- return Zygote.MOUNT_EXTERNAL_INSTALLER;
- } else if (mPmInternal.isInstantApp(packageName, UserHandle.getUserId(uid))) {
+ if (mPmInternal.isInstantApp(packageName, UserHandle.getUserId(uid))) {
return Zygote.MOUNT_EXTERNAL_NONE;
+ }
+
+ // Determine if caller is holding runtime permission
+ final boolean hasRead = StorageManager.checkPermissionAndAppOp(mContext, false, 0,
+ uid, packageName, READ_EXTERNAL_STORAGE, OP_READ_EXTERNAL_STORAGE);
+ final boolean hasWrite = StorageManager.checkPermissionAndAppOp(mContext, false, 0,
+ uid, packageName, WRITE_EXTERNAL_STORAGE, OP_WRITE_EXTERNAL_STORAGE);
+ final boolean hasStorage = hasRead || hasWrite;
+
+ // We're only willing to give out broad access if they also hold
+ // runtime permission; this is a firm CDD requirement
+ final boolean hasFull = mIPackageManager.checkUidPermission(WRITE_MEDIA_STORAGE,
+ uid) == PERMISSION_GRANTED;
+ if (hasFull && hasStorage) {
+ return Zygote.MOUNT_EXTERNAL_FULL;
+ }
+
+ // We're only willing to give out installer access if they also hold
+ // runtime permission; this is a firm CDD requirement
+ final boolean hasInstall = mIPackageManager.checkUidPermission(INSTALL_PACKAGES,
+ uid) == PERMISSION_GRANTED;
+ final boolean hasInstallOp = mIAppOpsService.checkOperation(OP_REQUEST_INSTALL_PACKAGES,
+ uid, packageName) == MODE_ALLOWED;
+ if ((hasInstall || hasInstallOp) && hasStorage) {
+ return Zygote.MOUNT_EXTERNAL_INSTALLER;
+ }
+
+ // Otherwise we're willing to give out sandboxed or non-sandboxed if
+ // they hold the runtime permission
+ final boolean hasLegacy = mIAppOpsService.checkOperation(OP_LEGACY_STORAGE,
+ uid, packageName) == MODE_ALLOWED;
+ final boolean hasGreylist = isLegacyGreylisted(packageName);
+ if ((hasLegacy || hasGreylist) && hasStorage) {
+ return Zygote.MOUNT_EXTERNAL_LEGACY;
} else {
- if (ENABLE_LEGACY_GREYLIST) {
- // STOPSHIP: remove this temporary workaround once developers
- // fix bugs where they're opening _data paths in native code
- switch (packageName) {
- case "com.facebook.katana": // b/123996076
- case "jp.naver.line.android": // b/124767356
- case "com.mxtech.videoplayer.ad": // b/124531483
- case "com.whatsapp": // b/124766614
- case "com.maxmpz.audioplayer": // b/127886230
- case "com.estrongs.android.pop": // b/127926473
- case "com.roidapp.photogrid": // b/128269119
- case "com.cleanmaster.mguard": // b/128384413
- case "com.skype.raider": // b/128487044
- case "org.telegram.messenger": // b/128652960
- case "com.jrtstudio.AnotherMusicPlayer": // b/129084562
- case "ak.alizandro.smartaudiobookplayer": // b/129084042
- case "com.campmobile.snow": // b/128803870
- case "com.qnap.qfile": // b/126374406
- return Zygote.MOUNT_EXTERNAL_LEGACY;
- }
- }
return Zygote.MOUNT_EXTERNAL_WRITE;
}
} catch (RemoteException e) {
@@ -3909,6 +3927,32 @@
return Zygote.MOUNT_EXTERNAL_NONE;
}
+ private boolean isLegacyGreylisted(String packageName) {
+ // TODO: decide legacy defaults at install time based on signals
+ if (ENABLE_LEGACY_GREYLIST) {
+ // STOPSHIP: remove this temporary workaround once developers
+ // fix bugs where they're opening _data paths in native code
+ switch (packageName) {
+ case "com.facebook.katana": // b/123996076
+ case "jp.naver.line.android": // b/124767356
+ case "com.mxtech.videoplayer.ad": // b/124531483
+ case "com.whatsapp": // b/124766614
+ case "com.maxmpz.audioplayer": // b/127886230
+ case "com.estrongs.android.pop": // b/127926473
+ case "com.roidapp.photogrid": // b/128269119
+ case "com.cleanmaster.mguard": // b/128384413
+ case "com.skype.raider": // b/128487044
+ case "org.telegram.messenger": // b/128652960
+ case "com.jrtstudio.AnotherMusicPlayer": // b/129084562
+ case "ak.alizandro.smartaudiobookplayer": // b/129084042
+ case "com.campmobile.snow": // b/128803870
+ case "com.qnap.qfile": // b/126374406
+ return true;
+ }
+ }
+ return false;
+ }
+
private static class Callbacks extends Handler {
private static final int MSG_STORAGE_STATE_CHANGED = 1;
private static final int MSG_VOLUME_STATE_CHANGED = 2;
diff --git a/services/core/java/com/android/server/am/ActiveServices.java b/services/core/java/com/android/server/am/ActiveServices.java
index 1878d00..cef245b 100644
--- a/services/core/java/com/android/server/am/ActiveServices.java
+++ b/services/core/java/com/android/server/am/ActiveServices.java
@@ -1478,7 +1478,6 @@
if (sr.isForeground || sr.fgRequired) {
anyForeground = true;
fgServiceTypes |= sr.foregroundServiceType;
- break;
}
}
mAm.updateProcessForegroundLocked(proc, anyForeground, fgServiceTypes, oomAdj);
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index 73cb17c..73393ed 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -1751,7 +1751,6 @@
? R.string.dump_heap_ready_notification : R.string.dump_heap_notification;
String text = mContext.getString(titleId, procName);
-
Intent deleteIntent = new Intent();
deleteIntent.setAction(DumpHeapActivity.ACTION_DELETE_DUMPHEAP);
Intent intent = new Intent();
@@ -1767,8 +1766,6 @@
Notification notification =
new Notification.Builder(mContext, SystemNotificationChannels.DEVELOPER)
.setSmallIcon(com.android.internal.R.drawable.stat_sys_adb)
- .setWhen(0)
- .setOngoing(true)
.setAutoCancel(true)
.setTicker(text)
.setColor(mContext.getColor(
@@ -5093,11 +5090,9 @@
mContext.registerReceiver(new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
- if (intent.getBooleanExtra(DumpHeapActivity.EXTRA_DELAY_DELETE, false)) {
- mHandler.sendEmptyMessageDelayed(POST_DUMP_HEAP_NOTIFICATION_MSG, 5*60*1000);
- } else {
- mHandler.sendEmptyMessage(POST_DUMP_HEAP_NOTIFICATION_MSG);
- }
+ final long delay = intent.getBooleanExtra(
+ DumpHeapActivity.EXTRA_DELAY_DELETE, false) ? 5 * 60 * 1000 : 0;
+ mHandler.sendEmptyMessageDelayed(DELETE_DUMPHEAP_MSG, delay);
}
}, dumpheapFilter);
@@ -16389,12 +16384,10 @@
@GuardedBy("this")
final void updateProcessForegroundLocked(ProcessRecord proc, boolean isForeground,
int fgServiceTypes, boolean oomAdj) {
- proc.setHasForegroundServices(isForeground, fgServiceTypes);
- final boolean hasFgServiceLocationType =
- (fgServiceTypes & ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION) != 0;
if (isForeground != proc.hasForegroundServices()
- || proc.hasLocationForegroundServices() != hasFgServiceLocationType) {
+ || proc.getForegroundServiceTypes() != fgServiceTypes) {
+ proc.setHasForegroundServices(isForeground, fgServiceTypes);
ArrayList<ProcessRecord> curProcs = mForegroundPackages.get(proc.info.packageName,
proc.info.uid);
if (isForeground) {
@@ -16419,16 +16412,15 @@
}
}
}
- if (oomAdj) {
- updateOomAdjLocked();
- }
- }
- if (proc.getForegroundServiceTypes() != fgServiceTypes) {
proc.setReportedForegroundServiceTypes(fgServiceTypes);
ProcessChangeItem item = enqueueProcessChangeItemLocked(proc.info.uid, proc.pid);
item.changes = ProcessChangeItem.CHANGE_FOREGROUND_SERVICES;
item.foregroundServiceTypes = fgServiceTypes;
+
+ if (oomAdj) {
+ updateOomAdjLocked();
+ }
}
}
diff --git a/services/core/java/com/android/server/audio/AudioService.java b/services/core/java/com/android/server/audio/AudioService.java
index 93f7831..82a4f1df 100644
--- a/services/core/java/com/android/server/audio/AudioService.java
+++ b/services/core/java/com/android/server/audio/AudioService.java
@@ -6360,9 +6360,20 @@
boolean isLoopbackRenderPolicy = policyConfig.getMixes().stream().allMatch(
mix -> mix.getRouteFlags() == (mix.ROUTE_FLAG_RENDER | mix.ROUTE_FLAG_LOOP_BACK));
- // Policy that do not modify the audio routing only need an audio projection
- if (isLoopbackRenderPolicy && canProjectAudio(projection)) {
- return true;
+ if (isLoopbackRenderPolicy) {
+ boolean allowPrivilegedPlaybackCapture = policyConfig.getMixes().stream().anyMatch(
+ mix -> mix.getRule().allowPrivilegedPlaybackCapture());
+ if (allowPrivilegedPlaybackCapture
+ && !(hasPermission(android.Manifest.permission.CAPTURE_AUDIO_OUTPUT)
+ || hasPermission(android.Manifest.permission.CAPTURE_MEDIA_OUTPUT))) {
+ // Opt-out can not be bypassed without a system permission
+ return false;
+ }
+
+ if (canProjectAudio(projection)) {
+ // Policy that do not modify the audio routing only need an audio projection
+ return true;
+ }
}
boolean hasPermissionModifyAudioRouting =
@@ -6373,6 +6384,9 @@
}
return false;
}
+ private boolean hasPermission(String permission) {
+ return PackageManager.PERMISSION_GRANTED == mContext.checkCallingPermission(permission);
+ }
/** @return true if projection is a valid MediaProjection that can project audio. */
private boolean canProjectAudio(IMediaProjection projection) {
diff --git a/services/core/java/com/android/server/connectivity/KeepaliveTracker.java b/services/core/java/com/android/server/connectivity/KeepaliveTracker.java
index ce887eb..d7a57b9 100644
--- a/services/core/java/com/android/server/connectivity/KeepaliveTracker.java
+++ b/services/core/java/com/android/server/connectivity/KeepaliveTracker.java
@@ -154,12 +154,19 @@
// keepalives are sent cannot be reused by another app even if the fd gets closed by
// the user. A null is acceptable here for backward compatibility of PacketKeepalive
// API.
- // TODO: don't accept null fd after legacy packetKeepalive API is removed.
try {
if (fd != null) {
mFd = Os.dup(fd);
} else {
- Log.d(TAG, "uid/pid " + mUid + "/" + mPid + " calls with null fd");
+ Log.d(TAG, toString() + " calls with null fd");
+ if (!mPrivileged) {
+ throw new SecurityException(
+ "null fd is not allowed for unprivileged access.");
+ }
+ if (mType == TYPE_TCP) {
+ throw new IllegalArgumentException(
+ "null fd is not allowed for tcp socket keepalives.");
+ }
mFd = null;
}
} catch (ErrnoException e) {
@@ -480,7 +487,6 @@
}
} else {
// Keepalive successfully stopped, or error.
- ki.mStartedState = KeepaliveInfo.NOT_STARTED;
if (reason == SUCCESS) {
// The message indicated success stopping : don't call handleStopKeepalive.
if (DBG) Log.d(TAG, "Successfully stopped keepalive " + slot + " on " + nai.name());
@@ -490,6 +496,7 @@
handleStopKeepalive(nai, slot, reason);
if (DBG) Log.d(TAG, "Keepalive " + slot + " on " + nai.name() + " error " + reason);
}
+ ki.mStartedState = KeepaliveInfo.NOT_STARTED;
}
}
@@ -531,7 +538,8 @@
try {
ki = new KeepaliveInfo(cb, nai, packet, intervalSeconds,
KeepaliveInfo.TYPE_NATT, fd);
- } catch (InvalidSocketException e) {
+ } catch (InvalidSocketException | IllegalArgumentException | SecurityException e) {
+ Log.e(TAG, "Fail to construct keepalive", e);
notifyErrorCallback(cb, ERROR_INVALID_SOCKET);
return;
}
@@ -570,7 +578,8 @@
try {
ki = new KeepaliveInfo(cb, nai, packet, intervalSeconds,
KeepaliveInfo.TYPE_TCP, fd);
- } catch (InvalidSocketException e) {
+ } catch (InvalidSocketException | IllegalArgumentException | SecurityException e) {
+ Log.e(TAG, "Fail to construct keepalive e=" + e);
notifyErrorCallback(cb, ERROR_INVALID_SOCKET);
return;
}
diff --git a/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java b/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java
index df0dc77..b4c7dd3 100755
--- a/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java
+++ b/services/core/java/com/android/server/hdmi/DeviceDiscoveryAction.java
@@ -335,7 +335,6 @@
current.mDeviceType = params[2] & 0xFF;
current.mDisplayName = HdmiUtils.getDefaultDeviceName(current.mDeviceType);
- // TODO(amyjojo): check if non-TV device needs to update cec switch info.
// This is to manager CEC device separately in case they don't have address.
if (mIsTvDevice) {
tv().updateCecSwitchInfo(current.mLogicalAddress, current.mDeviceType,
diff --git a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java
index 2026957..10f7db5 100644
--- a/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java
+++ b/services/core/java/com/android/server/hdmi/HdmiCecLocalDeviceAudioSystem.java
@@ -314,7 +314,7 @@
super.disableDevice(initiatedByCec, callback);
assertRunOnServiceThread();
mService.unregisterTvInputCallback(mTvInputCallback);
- // TODO(amyjojo): check disableDevice and onStandby behaviors per spec
+ // TODO(b/129088603): check disableDevice and onStandby behaviors per spec
}
@Override
@@ -465,15 +465,6 @@
@Override
@ServiceThreadOnly
- protected boolean handleReportAudioStatus(HdmiCecMessage message) {
- assertRunOnServiceThread();
- // TODO(amyjojo): implement report audio status handler
- HdmiLogger.debug(TAG + "Stub handleReportAudioStatus");
- return true;
- }
-
- @Override
- @ServiceThreadOnly
protected boolean handleInitiateArc(HdmiCecMessage message) {
assertRunOnServiceThread();
// TODO(amyjojo): implement initiate arc handler
diff --git a/services/core/java/com/android/server/hdmi/HdmiControlService.java b/services/core/java/com/android/server/hdmi/HdmiControlService.java
index f5adb01..3398d36 100644
--- a/services/core/java/com/android/server/hdmi/HdmiControlService.java
+++ b/services/core/java/com/android/server/hdmi/HdmiControlService.java
@@ -1764,7 +1764,7 @@
}
@Override
- // TODO(AMYJOJO): add a result callback
+ // TODO(b/128427908): add a result callback
public void askRemoteDeviceToBecomeActiveSource(int physicalAddress) {
enforceAccessPermission();
runOnServiceThread(new Runnable() {
diff --git a/services/core/java/com/android/server/notification/NotificationManagerService.java b/services/core/java/com/android/server/notification/NotificationManagerService.java
index dddb7ef..20b8987 100644
--- a/services/core/java/com/android/server/notification/NotificationManagerService.java
+++ b/services/core/java/com/android/server/notification/NotificationManagerService.java
@@ -2406,6 +2406,11 @@
@Override
public boolean areNotificationsEnabledForPackage(String pkg, int uid) {
checkCallerIsSystemOrSameApp(pkg);
+ if (UserHandle.getCallingUserId() != UserHandle.getUserId(uid)) {
+ getContext().enforceCallingPermission(
+ android.Manifest.permission.INTERACT_ACROSS_USERS,
+ "canNotifyAsPackage for uid " + uid);
+ }
return mPreferencesHelper.getImportance(pkg, uid) != IMPORTANCE_NONE;
}
@@ -2419,6 +2424,13 @@
public boolean areBubblesAllowedForPackage(String pkg, int uid) {
enforceSystemOrSystemUIOrSamePackage(pkg,
"Caller not system or systemui or same package");
+
+ if (UserHandle.getCallingUserId() != UserHandle.getUserId(uid)) {
+ getContext().enforceCallingPermission(
+ android.Manifest.permission.INTERACT_ACROSS_USERS,
+ "canNotifyAsPackage for uid " + uid);
+ }
+
return mPreferencesHelper.areBubblesAllowed(pkg, uid);
}
diff --git a/services/core/java/com/android/server/pm/PackageInstallerService.java b/services/core/java/com/android/server/pm/PackageInstallerService.java
index ad17549..afa5ae9 100644
--- a/services/core/java/com/android/server/pm/PackageInstallerService.java
+++ b/services/core/java/com/android/server/pm/PackageInstallerService.java
@@ -808,7 +808,7 @@
final PackageDeleteObserverAdapter adapter = new PackageDeleteObserverAdapter(mContext,
statusReceiver, versionedPackage.getPackageName(),
- canSilentlyInstallPackage, userId);
+ !canSilentlyInstallPackage, userId);
if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DELETE_PACKAGES)
== PackageManager.PERMISSION_GRANTED) {
// Sweet, call straight through!
diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java
index 81448b7..eec1e53 100644
--- a/services/core/java/com/android/server/pm/PackageManagerService.java
+++ b/services/core/java/com/android/server/pm/PackageManagerService.java
@@ -1315,8 +1315,11 @@
static final int WRITE_SETTINGS_DELAY = 10*1000; // 10 seconds
- // Delay time in millisecs
- static final int BROADCAST_DELAY = 10 * 1000;
+ private static final long BROADCAST_DELAY_DURING_STARTUP = 10 * 1000L; // 10 seconds (in millis)
+ private static final long BROADCAST_DELAY = 1 * 1000L; // 1 second (in millis)
+
+ // When the service constructor finished plus a delay (used for broadcast delay computation)
+ private long mServiceStartWithDelay;
private static final long DEFAULT_UNUSED_STATIC_SHARED_LIB_MIN_CACHE_PERIOD =
2 * 60 * 60 * 1000L; /* two hours */
@@ -3217,6 +3220,8 @@
// once we have a booted system.
mInstaller.setWarnIfHeld(mPackages);
+ mServiceStartWithDelay = SystemClock.uptimeMillis() + (60 * 1000L);
+
Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);
}
@@ -20603,8 +20608,14 @@
mPendingBroadcasts.put(userId, packageName, components);
}
if (!mHandler.hasMessages(SEND_PENDING_BROADCAST)) {
- // Schedule a message
- mHandler.sendEmptyMessageDelayed(SEND_PENDING_BROADCAST, BROADCAST_DELAY);
+ // Schedule a message - if it has been a "reasonably long time" since the
+ // service started, send the broadcast with a delay of one second to avoid
+ // delayed reactions from the receiver, else keep the default ten second delay
+ // to avoid extreme thrashing on service startup.
+ final long broadcastDelay = SystemClock.uptimeMillis() > mServiceStartWithDelay
+ ? BROADCAST_DELAY
+ : BROADCAST_DELAY_DURING_STARTUP;
+ mHandler.sendEmptyMessageDelayed(SEND_PENDING_BROADCAST, broadcastDelay);
}
}
}
diff --git a/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java b/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java
index 5502bb9..0c9f815 100644
--- a/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java
+++ b/services/core/java/com/android/server/wallpaper/WallpaperManagerService.java
@@ -2669,6 +2669,11 @@
}
wallpaper.connection.mReply = null;
}
+ try {
+ wallpaper.connection.mService.detach();
+ } catch (RemoteException e) {
+ Slog.w(TAG, "Failed detaching wallpaper service ", e);
+ }
mContext.unbindService(wallpaper.connection);
wallpaper.connection.forEachDisplayConnector(
WallpaperConnection.DisplayConnector::disconnectLocked);
diff --git a/services/core/jni/com_android_server_location_GnssLocationProvider.cpp b/services/core/jni/com_android_server_location_GnssLocationProvider.cpp
index 7df7ef3..0b47b29 100644
--- a/services/core/jni/com_android_server_location_GnssLocationProvider.cpp
+++ b/services/core/jni/com_android_server_location_GnssLocationProvider.cpp
@@ -1700,8 +1700,12 @@
gnssNavigationMessageIface = gnssNavigationMessage;
}
- if (gnssHal_V2_0 != nullptr) {
- // TODO: getExtensionGnssMeasurement_1_1 from gnssHal_V2_0
+ // Allow all causal combinations between IGnss.hal and IGnssMeasurement.hal. That means,
+ // 2.0@IGnss can be paired with {1.0, 1,1, 2.0}@IGnssMeasurement
+ // 1.1@IGnss can be paired {1.0, 1.1}@IGnssMeasurement
+ // 1.0@IGnss is paired with 1.0@IGnssMeasurement
+ gnssMeasurementIface = nullptr;
+ if (gnssHal_V2_0 != nullptr && gnssMeasurementIface == nullptr) {
auto gnssMeasurement = gnssHal_V2_0->getExtensionGnssMeasurement_2_0();
if (!gnssMeasurement.isOk()) {
ALOGD("Unable to get a handle to GnssMeasurement_V2_0");
@@ -1710,13 +1714,8 @@
gnssMeasurementIface_V1_1 = gnssMeasurementIface_V2_0;
gnssMeasurementIface = gnssMeasurementIface_V2_0;
}
- auto gnssCorrections = gnssHal_V2_0->getExtensionMeasurementCorrections();
- if (!gnssCorrections.isOk()) {
- ALOGD("Unable to get a handle to GnssMeasurementCorrections interface");
- } else {
- gnssCorrectionsIface = gnssCorrections;
- }
- } else if (gnssHal_V1_1 != nullptr) {
+ }
+ if (gnssHal_V1_1 != nullptr && gnssMeasurementIface == nullptr) {
auto gnssMeasurement = gnssHal_V1_1->getExtensionGnssMeasurement_1_1();
if (!gnssMeasurement.isOk()) {
ALOGD("Unable to get a handle to GnssMeasurement_V1_1");
@@ -1724,16 +1723,26 @@
gnssMeasurementIface_V1_1 = gnssMeasurement;
gnssMeasurementIface = gnssMeasurementIface_V1_1;
}
- } else {
- auto gnssMeasurement_V1_0 = gnssHal->getExtensionGnssMeasurement();
- if (!gnssMeasurement_V1_0.isOk()) {
+ }
+ if (gnssMeasurementIface == nullptr) {
+ auto gnssMeasurement = gnssHal->getExtensionGnssMeasurement();
+ if (!gnssMeasurement.isOk()) {
ALOGD("Unable to get a handle to GnssMeasurement");
} else {
- gnssMeasurementIface = gnssMeasurement_V1_0;
+ gnssMeasurementIface = gnssMeasurement;
}
}
if (gnssHal_V2_0 != nullptr) {
+ auto gnssCorrections = gnssHal_V2_0->getExtensionMeasurementCorrections();
+ if (!gnssCorrections.isOk()) {
+ ALOGD("Unable to get a handle to GnssMeasurementCorrections interface");
+ } else {
+ gnssCorrectionsIface = gnssCorrections;
+ }
+ }
+
+ if (gnssHal_V2_0 != nullptr) {
auto gnssDebug = gnssHal_V2_0->getExtensionGnssDebug_2_0();
if (!gnssDebug.isOk()) {
ALOGD("Unable to get a handle to GnssDebug_V2_0");
diff --git a/services/net/Android.bp b/services/net/Android.bp
index 67fbdc4..7ef0ac4 100644
--- a/services/net/Android.bp
+++ b/services/net/Android.bp
@@ -69,7 +69,7 @@
srcs: [
":framework-annotations",
"java/android/net/IpMemoryStoreClient.java",
- "java/android/net/ipmemorystore/**.java",
+ "java/android/net/ipmemorystore/**/*.java",
],
static_libs: [
"ipmemorystore-aidl-interfaces-java",
diff --git a/services/tests/mockingservicestests/src/com/android/server/AlarmManagerServiceTest.java b/services/tests/mockingservicestests/src/com/android/server/AlarmManagerServiceTest.java
index 7c91b64..7a40e44 100644
--- a/services/tests/mockingservicestests/src/com/android/server/AlarmManagerServiceTest.java
+++ b/services/tests/mockingservicestests/src/com/android/server/AlarmManagerServiceTest.java
@@ -26,6 +26,7 @@
import static com.android.dx.mockito.inline.extended.ExtendedMockito.doNothing;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
+import static com.android.dx.mockito.inline.extended.ExtendedMockito.doThrow;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.mock;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession;
import static com.android.dx.mockito.inline.extended.ExtendedMockito.spyOn;
@@ -57,6 +58,8 @@
import android.app.ActivityManager;
import android.app.AlarmManager;
import android.app.IActivityManager;
+import android.app.IAlarmCompleteListener;
+import android.app.IAlarmListener;
import android.app.IUidObserver;
import android.app.PendingIntent;
import android.app.usage.UsageStatsManagerInternal;
@@ -67,6 +70,7 @@
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
+import android.os.RemoteException;
import android.os.UserHandle;
import android.platform.test.annotations.Presubmit;
import android.provider.Settings;
@@ -231,7 +235,7 @@
doReturn(Looper.getMainLooper()).when(Looper::myLooper);
when(mMockContext.getContentResolver()).thenReturn(mMockResolver);
- doReturn("min_futurity=0").when(() ->
+ doReturn("min_futurity=0,min_interval=0").when(() ->
Settings.Global.getString(mMockResolver, Settings.Global.ALARM_MANAGER_CONSTANTS));
mInjector = new Injector(mMockContext);
mService = new AlarmManagerService(mMockContext, mInjector);
@@ -249,6 +253,7 @@
// Other boot phases don't matter
mService.onBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
assertEquals(0, mService.mConstants.MIN_FUTURITY);
+ assertEquals(0, mService.mConstants.MIN_INTERVAL);
mAppStandbyWindow = mService.mConstants.APP_STANDBY_WINDOW;
ArgumentCaptor<UsageStatsManagerInternal.AppIdleStateChangeListener> captor =
ArgumentCaptor.forClass(UsageStatsManagerInternal.AppIdleStateChangeListener.class);
@@ -257,15 +262,28 @@
}
private void setTestAlarm(int type, long triggerTime, PendingIntent operation) {
- setTestAlarm(type, triggerTime, operation, TEST_CALLING_UID);
+ setTestAlarm(type, triggerTime, operation, 0, TEST_CALLING_UID);
}
- private void setTestAlarm(int type, long triggerTime, PendingIntent operation, int callingUid) {
- mService.setImpl(type, triggerTime, AlarmManager.WINDOW_EXACT, 0,
+ private void setRepeatingTestAlarm(int type, long firstTrigger, long interval,
+ PendingIntent pi) {
+ setTestAlarm(type, firstTrigger, pi, interval, TEST_CALLING_UID);
+ }
+
+ private void setTestAlarm(int type, long triggerTime, PendingIntent operation, long interval,
+ int callingUid) {
+ mService.setImpl(type, triggerTime, AlarmManager.WINDOW_EXACT, interval,
operation, null, "test", AlarmManager.FLAG_STANDALONE, null, null,
callingUid, TEST_CALLING_PACKAGE);
}
+ private void setTestAlarmWithListener(int type, long triggerTime, IAlarmListener listener) {
+ mService.setImpl(type, triggerTime, AlarmManager.WINDOW_EXACT, 0,
+ null, listener, "test", AlarmManager.FLAG_STANDALONE, null, null,
+ TEST_CALLING_UID, TEST_CALLING_PACKAGE);
+ }
+
+
private PendingIntent getNewMockPendingIntent() {
return getNewMockPendingIntent(TEST_CALLING_UID);
}
@@ -738,14 +756,14 @@
@Test
public void alarmCountKeyedOnCallingUid() {
final int mockCreatorUid = 431412;
- final PendingIntent pi = getNewMockPendingIntent(mockCreatorUid);
- setTestAlarm(ELAPSED_REALTIME, mNowElapsedTest + 5, pi);
+ setTestAlarm(ELAPSED_REALTIME, mNowElapsedTest + 5,
+ getNewMockPendingIntent(mockCreatorUid));
assertEquals(1, mService.mAlarmsPerUid.get(TEST_CALLING_UID));
assertEquals(-1, mService.mAlarmsPerUid.get(mockCreatorUid, -1));
}
@Test
- public void alarmCountOnSet() {
+ public void alarmCountOnSetPi() {
final int numAlarms = 103;
final int[] types = {RTC_WAKEUP, RTC, ELAPSED_REALTIME_WAKEUP, ELAPSED_REALTIME};
for (int i = 1; i <= numAlarms; i++) {
@@ -755,7 +773,21 @@
}
@Test
- public void alarmCountOnExpiration() throws InterruptedException {
+ public void alarmCountOnSetListener() {
+ final int numAlarms = 103;
+ final int[] types = {RTC_WAKEUP, RTC, ELAPSED_REALTIME_WAKEUP, ELAPSED_REALTIME};
+ for (int i = 1; i <= numAlarms; i++) {
+ setTestAlarmWithListener(types[i % 4], mNowElapsedTest + i, new IAlarmListener.Stub() {
+ @Override
+ public void doAlarm(IAlarmCompleteListener callback) throws RemoteException {
+ }
+ });
+ assertEquals(i, mService.mAlarmsPerUid.get(TEST_CALLING_UID));
+ }
+ }
+
+ @Test
+ public void alarmCountOnExpirationPi() throws InterruptedException {
final int numAlarms = 8; // This test is slow
for (int i = 0; i < numAlarms; i++) {
setTestAlarm(ELAPSED_REALTIME, mNowElapsedTest + i + 10, getNewMockPendingIntent());
@@ -770,6 +802,86 @@
}
@Test
+ public void alarmCountOnExpirationListener() throws InterruptedException {
+ final int numAlarms = 8; // This test is slow
+ for (int i = 0; i < numAlarms; i++) {
+ setTestAlarmWithListener(ELAPSED_REALTIME, mNowElapsedTest + i + 10,
+ new IAlarmListener.Stub() {
+ @Override
+ public void doAlarm(IAlarmCompleteListener callback)
+ throws RemoteException {
+ }
+ });
+ }
+ int expired = 0;
+ while (expired < numAlarms) {
+ mNowElapsedTest = mTestTimer.getElapsed();
+ mTestTimer.expire();
+ expired++;
+ assertEquals(numAlarms - expired, mService.mAlarmsPerUid.get(TEST_CALLING_UID, 0));
+ }
+ }
+
+ @Test
+ public void alarmCountOnExceptionWhileSendingPi() throws Exception {
+ final int numAlarms = 5; // This test is slow
+ for (int i = 0; i < numAlarms; i++) {
+ final PendingIntent pi = getNewMockPendingIntent();
+ doThrow(PendingIntent.CanceledException.class).when(pi).send(eq(mMockContext), eq(0),
+ any(), any(), any(), any(), any());
+ setTestAlarm(ELAPSED_REALTIME, mNowElapsedTest + i + 10, pi);
+ }
+ int expired = 0;
+ while (expired < numAlarms) {
+ mNowElapsedTest = mTestTimer.getElapsed();
+ mTestTimer.expire();
+ expired++;
+ assertEquals(numAlarms - expired, mService.mAlarmsPerUid.get(TEST_CALLING_UID, 0));
+ }
+ }
+
+ @Test
+ public void alarmCountOnExceptionWhileCallingListener() throws Exception {
+ final int numAlarms = 5; // This test is slow
+ for (int i = 0; i < numAlarms; i++) {
+ final IAlarmListener listener = new IAlarmListener.Stub() {
+ @Override
+ public void doAlarm(IAlarmCompleteListener callback) throws RemoteException {
+ throw new RemoteException("For testing behavior on exception");
+ }
+ };
+ setTestAlarmWithListener(ELAPSED_REALTIME, mNowElapsedTest + i + 10, listener);
+ }
+ int expired = 0;
+ while (expired < numAlarms) {
+ mNowElapsedTest = mTestTimer.getElapsed();
+ mTestTimer.expire();
+ expired++;
+ assertEquals(numAlarms - expired, mService.mAlarmsPerUid.get(TEST_CALLING_UID, 0));
+ }
+ }
+
+ @Test
+ public void alarmCountForRepeatingAlarms() throws Exception {
+ final long interval = 1231;
+ final long firstTrigger = mNowElapsedTest + 321;
+ final PendingIntent pi = getNewMockPendingIntent();
+ setRepeatingTestAlarm(ELAPSED_REALTIME, firstTrigger, interval, pi);
+ assertEquals(1, mService.mAlarmsPerUid.get(TEST_CALLING_UID));
+
+ for (int i = 0; i < 5; i++) {
+ mNowElapsedTest = mTestTimer.getElapsed();
+ mTestTimer.expire();
+ assertEquals(1, mService.mAlarmsPerUid.get(TEST_CALLING_UID));
+ }
+ doThrow(PendingIntent.CanceledException.class).when(pi).send(eq(mMockContext), eq(0),
+ any(), any(), any(), any(), any());
+ mNowElapsedTest = mTestTimer.getElapsed();
+ mTestTimer.expire();
+ assertEquals(-1, mService.mAlarmsPerUid.get(TEST_CALLING_UID, -1));
+ }
+
+ @Test
public void alarmCountOnUidRemoved() {
final int numAlarms = 10;
for (int i = 0; i < numAlarms; i++) {
@@ -798,7 +910,7 @@
for (int i = 0; i < numAlarms; i++) {
int mockUid = UserHandle.getUid(mockUserId, 1234 + i);
setTestAlarm(ELAPSED_REALTIME, mNowElapsedTest + i + 10,
- getNewMockPendingIntent(mockUid), mockUid);
+ getNewMockPendingIntent(mockUid), 0, mockUid);
}
assertEquals(numAlarms, mService.mAlarmsPerUid.size());
mService.removeUserLocked(mockUserId);
@@ -820,6 +932,12 @@
}
}
+ @Test
+ public void alarmCountOnInvalidSet() {
+ setTestAlarm(ELAPSED_REALTIME, mNowElapsedTest + 12345, null);
+ assertEquals(-1, mService.mAlarmsPerUid.get(TEST_CALLING_UID, -1));
+ }
+
@After
public void tearDown() {
if (mMockingSession != null) {
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 bd7774a..5b19700 100644
--- a/services/tests/servicestests/src/com/android/server/devicepolicy/DevicePolicyManagerTest.java
+++ b/services/tests/servicestests/src/com/android/server/devicepolicy/DevicePolicyManagerTest.java
@@ -85,10 +85,11 @@
import android.telephony.TelephonyManager;
import android.telephony.data.ApnSetting;
import android.test.MoreAsserts;
-import android.test.suitebuilder.annotation.SmallTest;
import android.util.ArraySet;
import android.util.Pair;
+import androidx.test.filters.SmallTest;
+
import com.android.internal.R;
import com.android.internal.widget.LockPatternUtils;
import com.android.server.LocalServices;
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/BaseLockSettingsServiceTests.java b/services/tests/servicestests/src/com/android/server/locksettings/BaseLockSettingsServiceTests.java
index 3d02576..2fbeebd 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/BaseLockSettingsServiceTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/BaseLockSettingsServiceTests.java
@@ -56,7 +56,7 @@
import java.util.Arrays;
-public class BaseLockSettingsServiceTests extends AndroidTestCase {
+public abstract class BaseLockSettingsServiceTests extends AndroidTestCase {
protected static final int PRIMARY_USER_ID = 0;
protected static final int MANAGED_PROFILE_USER_ID = 12;
protected static final int TURNED_OFF_PROFILE_USER_ID = 17;
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/CachedSyntheticPasswordTests.java b/services/tests/servicestests/src/com/android/server/locksettings/CachedSyntheticPasswordTests.java
index ca4330f..d2a9145 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/CachedSyntheticPasswordTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/CachedSyntheticPasswordTests.java
@@ -26,6 +26,9 @@
import static org.mockito.Mockito.when;
import android.os.RemoteException;
+import android.platform.test.annotations.Presubmit;
+
+import androidx.test.filters.SmallTest;
import com.android.internal.widget.LockPatternUtils;
import com.android.internal.widget.VerifyCredentialResponse;
@@ -40,6 +43,8 @@
* By default, those tests run without caching. Untrusted credential reset depends on caching so
* this class included those tests.
*/
+@SmallTest
+@Presubmit
public class CachedSyntheticPasswordTests extends SyntheticPasswordTests {
@Override
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsServiceTests.java b/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsServiceTests.java
index 255e694b..7ebc745 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsServiceTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsServiceTests.java
@@ -26,8 +26,11 @@
import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_PATTERN;
import android.os.RemoteException;
+import android.platform.test.annotations.Presubmit;
import android.service.gatekeeper.GateKeeperResponse;
+import androidx.test.filters.SmallTest;
+
import com.android.internal.widget.LockPatternUtils;
import com.android.internal.widget.VerifyCredentialResponse;
import com.android.server.locksettings.FakeGateKeeperService.VerifyHandle;
@@ -36,6 +39,8 @@
/**
* runtest frameworks-services -c com.android.server.locksettings.LockSettingsServiceTests
*/
+@SmallTest
+@Presubmit
public class LockSettingsServiceTests extends BaseLockSettingsServiceTests {
@Override
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsShellCommandTest.java b/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsShellCommandTest.java
index fcfc6d2..c00d33b 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsShellCommandTest.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsShellCommandTest.java
@@ -21,7 +21,7 @@
import static com.android.internal.widget.LockPatternUtils.stringToPattern;
-import static junit.framework.Assert.*;
+import static junit.framework.Assert.assertEquals;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.any;
@@ -30,6 +30,10 @@
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
+import static java.io.FileDescriptor.err;
+import static java.io.FileDescriptor.in;
+import static java.io.FileDescriptor.out;
+
import android.app.ActivityManager;
import android.content.Context;
import android.os.Binder;
@@ -51,8 +55,6 @@
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
-import static java.io.FileDescriptor.*;
-
/**
* Test class for {@link LockSettingsShellCommand}.
*
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsStorageTests.java b/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsStorageTests.java
index 6e1f357..8af4edd 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsStorageTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/LockSettingsStorageTests.java
@@ -29,11 +29,14 @@
import android.os.FileUtils;
import android.os.UserManager;
import android.os.storage.StorageManager;
+import android.platform.test.annotations.Presubmit;
import android.test.AndroidTestCase;
import android.util.Log;
import android.util.Log.TerribleFailure;
import android.util.Log.TerribleFailureHandler;
+import androidx.test.filters.SmallTest;
+
import com.android.internal.widget.LockPatternUtils;
import com.android.server.PersistentDataBlockManagerInternal;
import com.android.server.locksettings.LockSettingsStorage.CredentialHash;
@@ -48,6 +51,8 @@
/**
* runtest frameworks-services -c com.android.server.locksettings.LockSettingsStorageTests
*/
+@SmallTest
+@Presubmit
public class LockSettingsStorageTests extends AndroidTestCase {
private static final int SOME_USER_ID = 1034;
private final byte[] PASSWORD_0 = "thepassword0".getBytes();
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/PasswordSlotManagerTests.java b/services/tests/servicestests/src/com/android/server/locksettings/PasswordSlotManagerTests.java
index 1d5a99b..31526b5 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/PasswordSlotManagerTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/PasswordSlotManagerTests.java
@@ -16,8 +16,11 @@
package com.android.server.locksettings;
+import android.platform.test.annotations.Presubmit;
import android.test.AndroidTestCase;
+import androidx.test.filters.SmallTest;
+
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.HashMap;
@@ -25,6 +28,8 @@
import java.util.Map;
import java.util.Set;
+@SmallTest
+@Presubmit
public class PasswordSlotManagerTests extends AndroidTestCase {
PasswordSlotManagerTestable mManager;
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/SP800DeriveTests.java b/services/tests/servicestests/src/com/android/server/locksettings/SP800DeriveTests.java
index fc2dcb9..29d0fc1 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/SP800DeriveTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/SP800DeriveTests.java
@@ -16,10 +16,15 @@
package com.android.server.locksettings;
+import android.platform.test.annotations.Presubmit;
import android.test.AndroidTestCase;
+import androidx.test.filters.SmallTest;
+
import com.android.internal.util.HexDump;
+@SmallTest
+@Presubmit
public class SP800DeriveTests extends AndroidTestCase {
public void testFixedInput() throws Exception {
// CAVP: https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/key-derivation
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/SyntheticPasswordTests.java b/services/tests/servicestests/src/com/android/server/locksettings/SyntheticPasswordTests.java
index 5a9ca0f..0273f76 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/SyntheticPasswordTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/SyntheticPasswordTests.java
@@ -33,6 +33,9 @@
import android.app.admin.PasswordMetrics;
import android.os.RemoteException;
import android.os.UserHandle;
+import android.platform.test.annotations.Presubmit;
+
+import androidx.test.filters.SmallTest;
import com.android.internal.widget.LockPatternUtils;
import com.android.internal.widget.VerifyCredentialResponse;
@@ -48,6 +51,8 @@
/**
* runtest frameworks-services -c com.android.server.locksettings.SyntheticPasswordTests
*/
+@SmallTest
+@Presubmit
public class SyntheticPasswordTests extends BaseLockSettingsServiceTests {
public static final byte[] PAYLOAD = new byte[] {1, 2, -1, -2, 55};
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/WeaverBasedSyntheticPasswordTests.java b/services/tests/servicestests/src/com/android/server/locksettings/WeaverBasedSyntheticPasswordTests.java
index 5e56704..abbf016 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/WeaverBasedSyntheticPasswordTests.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/WeaverBasedSyntheticPasswordTests.java
@@ -1,5 +1,11 @@
package com.android.server.locksettings;
+import android.platform.test.annotations.Presubmit;
+
+import androidx.test.filters.SmallTest;
+
+@SmallTest
+@Presubmit
public class WeaverBasedSyntheticPasswordTests extends SyntheticPasswordTests {
@Override
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 987d46a..a9eb6ec 100644
--- a/services/tests/uiservicestests/src/com/android/server/notification/NotificationManagerServiceTest.java
+++ b/services/tests/uiservicestests/src/com/android/server/notification/NotificationManagerServiceTest.java
@@ -4324,4 +4324,36 @@
assertEquals(IMPORTANCE_LOW, r.getAssistantImportance());
assertEquals(USER_SENTIMENT_NEUTRAL, r.getUserSentiment());
}
+
+ public void testAreNotificationsEnabledForPackage_crossUser() throws Exception {
+ try {
+ mBinderService.areNotificationsEnabledForPackage(mContext.getPackageName(),
+ mUid + UserHandle.PER_USER_RANGE);
+ fail("Cannot call cross user without permission");
+ } catch (SecurityException e) {
+ // pass
+ }
+
+ // cross user, with permission, no problem
+ TestablePermissions perms = mContext.getTestablePermissions();
+ perms.setPermission(android.Manifest.permission.INTERACT_ACROSS_USERS, PERMISSION_GRANTED);
+ mBinderService.areNotificationsEnabledForPackage(mContext.getPackageName(),
+ mUid + UserHandle.PER_USER_RANGE);
+ }
+
+ public void testAreBubblesAllowedForPackage_crossUser() throws Exception {
+ try {
+ mBinderService.areBubblesAllowedForPackage(mContext.getPackageName(),
+ mUid + UserHandle.PER_USER_RANGE);
+ fail("Cannot call cross user without permission");
+ } catch (SecurityException e) {
+ // pass
+ }
+
+ // cross user, with permission, no problem
+ TestablePermissions perms = mContext.getTestablePermissions();
+ perms.setPermission(android.Manifest.permission.INTERACT_ACROSS_USERS, PERMISSION_GRANTED);
+ mBinderService.areBubblesAllowedForPackage(mContext.getPackageName(),
+ mUid + UserHandle.PER_USER_RANGE);
+ }
}
diff --git a/services/usage/java/com/android/server/usage/IntervalStats.java b/services/usage/java/com/android/server/usage/IntervalStats.java
index 8feed7f..a783a40 100644
--- a/services/usage/java/com/android/server/usage/IntervalStats.java
+++ b/services/usage/java/com/android/server/usage/IntervalStats.java
@@ -66,7 +66,7 @@
public final ArrayMap<String, UsageStats> packageStats = new ArrayMap<>();
public final ArrayMap<Configuration, ConfigurationStats> configurations = new ArrayMap<>();
public Configuration activeConfiguration;
- public EventList events = new EventList();
+ public final EventList events = new EventList();
// A string cache. This is important as when we're parsing XML files, we don't want to
// keep hundreds of strings that have the same contents. We will read the string
@@ -82,7 +82,7 @@
public void commitTime(long timeStamp) {
if (curStartTime != 0) {
- duration += timeStamp - duration;
+ duration += timeStamp - curStartTime;
curStartTime = 0;
}
}
@@ -305,7 +305,9 @@
UsageStats usageStats = getOrCreateUsageStats(packageName);
usageStats.update(className, timeStamp, eventType, instanceId);
}
- endTime = timeStamp;
+ if (timeStamp > endTime) {
+ endTime = timeStamp;
+ }
}
/**
@@ -328,6 +330,9 @@
event.mNotificationChannelId = getCachedStringRef(event.mNotificationChannelId);
}
events.insert(event);
+ if (event.mTimeStamp > endTime) {
+ endTime = event.mTimeStamp;
+ }
}
void updateChooserCounts(String packageName, String category, String action) {
@@ -360,8 +365,9 @@
configStats.mActivationCount += 1;
activeConfiguration = configStats.mConfiguration;
}
-
- endTime = timeStamp;
+ if (timeStamp > endTime) {
+ endTime = timeStamp;
+ }
}
void incrementAppLaunchCount(String packageName) {
diff --git a/services/usage/java/com/android/server/usage/UsageStatsDatabase.java b/services/usage/java/com/android/server/usage/UsageStatsDatabase.java
index 485a79d..c55bb3c 100644
--- a/services/usage/java/com/android/server/usage/UsageStatsDatabase.java
+++ b/services/usage/java/com/android/server/usage/UsageStatsDatabase.java
@@ -1166,7 +1166,8 @@
if (beingRestored == null) return null;
beingRestored.activeConfiguration = onDevice.activeConfiguration;
beingRestored.configurations.putAll(onDevice.configurations);
- beingRestored.events = onDevice.events;
+ beingRestored.events.clear();
+ beingRestored.events.merge(onDevice.events);
return beingRestored;
}
diff --git a/services/usage/java/com/android/server/usage/UserUsageStatsService.java b/services/usage/java/com/android/server/usage/UserUsageStatsService.java
index 9498e16..26bfcc9 100644
--- a/services/usage/java/com/android/server/usage/UserUsageStatsService.java
+++ b/services/usage/java/com/android/server/usage/UserUsageStatsService.java
@@ -334,7 +334,7 @@
final IntervalStats diskStats = mDatabase.getLatestUsageStats(
INTERVAL_DAILY);
StringBuilder sb = new StringBuilder(256);
- sb.append("Last 24 hours of UsageStats missing! timeRange : ");
+ sb.append("Recent UsageStats missing! timeRange : ");
sb.append(beginTime);
sb.append(", ");
sb.append(endTime);
diff --git a/telephony/java/android/telephony/SmsManager.java b/telephony/java/android/telephony/SmsManager.java
index dde8057..09046a6 100644
--- a/telephony/java/android/telephony/SmsManager.java
+++ b/telephony/java/android/telephony/SmsManager.java
@@ -27,10 +27,6 @@
import android.annotation.UnsupportedAppUsage;
import android.app.ActivityThread;
import android.app.PendingIntent;
-import android.bluetooth.BluetoothAdapter;
-import android.bluetooth.BluetoothDevice;
-import android.bluetooth.BluetoothMapClient;
-import android.bluetooth.BluetoothProfile;
import android.content.ActivityNotFoundException;
import android.content.ContentValues;
import android.content.Context;
@@ -43,7 +39,6 @@
import android.os.Bundle;
import android.os.RemoteException;
import android.os.ServiceManager;
-import android.telecom.PhoneAccount;
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.Log;
@@ -76,7 +71,6 @@
*/
public final class SmsManager {
private static final String TAG = "SmsManager";
- private static final boolean DBG = false;
/**
* A psuedo-subId that represents the default subId at any given time. The actual subId it
@@ -357,42 +351,11 @@
throw new IllegalArgumentException("Invalid message body");
}
- // A Manager code accessing another manager is *not* acceptable, in Android.
- // In this particular case, it is unavoidable because of the following:
- // If the subscription for this SmsManager instance belongs to a remote SIM
- // then a listener to get BluetoothMapClient proxy needs to be started up.
- // Doing that is possible only in a foreground thread or as a system user.
- // i.e., Can't be done in ISms service.
- // For that reason, SubscriptionManager needs to be accessed here to determine
- // if the subscription belongs to a remote SIM.
- // Ideally, there should be another API in ISms to service messages going thru
- // remote SIM subscriptions (and ISms should be tweaked to be able to access
- // BluetoothMapClient proxy)
- Context context = ActivityThread.currentApplication().getApplicationContext();
- SubscriptionManager manager = (SubscriptionManager) context
- .getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
- int subId = getSubscriptionId();
- SubscriptionInfo info = manager.getActiveSubscriptionInfo(subId);
- if (DBG) {
- Log.d(TAG, "for subId: " + subId + ", subscription-info: " + info);
- }
-
- /* If the Subscription associated with this SmsManager instance belongs to a remote-sim,
- * then send the message thru the remote-sim subscription.
- */
- if (info != null
- && info.getSubscriptionType() == SubscriptionManager.SUBSCRIPTION_TYPE_REMOTE_SIM) {
- if (DBG) Log.d(TAG, "sending message thru bluetooth");
- sendTextMessageBluetooth(destinationAddress, scAddress, text, sentIntent,
- deliveryIntent, info);
- return;
- }
-
try {
// If the subscription is invalid or default, we will use the default phone to send the
// SMS and possibly fail later in the SMS sending process.
- ISms iccISms = getISmsServiceOrThrow();
- iccISms.sendTextForSubscriber(subId, ActivityThread.currentPackageName(),
+ ISms iSms = getISmsServiceOrThrow();
+ iSms.sendTextForSubscriber(getSubscriptionId(), ActivityThread.currentPackageName(),
destinationAddress,
scAddress, text, sentIntent, deliveryIntent,
persistMessage);
@@ -401,82 +364,6 @@
}
}
- private void sendTextMessageBluetooth(String destAddr, String scAddress,
- String text, PendingIntent sentIntent, PendingIntent deliveryIntent,
- SubscriptionInfo info) {
- BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();
- if (btAdapter == null) {
- // No bluetooth service on this platform?
- sendErrorInPendingIntent(sentIntent, SmsManager.RESULT_ERROR_NO_SERVICE);
- return;
- }
- BluetoothDevice device = btAdapter.getRemoteDevice(info.getIccId());
- if (device == null) {
- if (DBG) Log.d(TAG, "Bluetooth device addr invalid: " + info.getIccId());
- sendErrorInPendingIntent(sentIntent, SmsManager.RESULT_ERROR_NO_SERVICE);
- return;
- }
- btAdapter.getProfileProxy(ActivityThread.currentApplication().getApplicationContext(),
- new MapMessageSender(destAddr, text, device, sentIntent, deliveryIntent),
- BluetoothProfile.MAP_CLIENT);
- }
-
- private class MapMessageSender implements BluetoothProfile.ServiceListener {
- final Uri[] mDestAddr;
- private String mMessage;
- final BluetoothDevice mDevice;
- final PendingIntent mSentIntent;
- final PendingIntent mDeliveryIntent;
- MapMessageSender(final String destAddr, final String message, final BluetoothDevice device,
- final PendingIntent sentIntent, final PendingIntent deliveryIntent) {
- super();
- mDestAddr = new Uri[] {new Uri.Builder()
- .appendPath(destAddr)
- .scheme(PhoneAccount.SCHEME_TEL)
- .build()};
- mMessage = message;
- mDevice = device;
- mSentIntent = sentIntent;
- mDeliveryIntent = deliveryIntent;
- }
-
- @Override
- public void onServiceConnected(int profile, BluetoothProfile proxy) {
- if (DBG) Log.d(TAG, "Service connected");
- if (profile != BluetoothProfile.MAP_CLIENT) return;
- BluetoothMapClient mapProfile = (BluetoothMapClient) proxy;
- if (mMessage != null) {
- if (DBG) Log.d(TAG, "Sending message thru bluetooth");
- mapProfile.sendMessage(mDevice, mDestAddr, mMessage, mSentIntent, mDeliveryIntent);
- mMessage = null;
- }
- BluetoothAdapter.getDefaultAdapter()
- .closeProfileProxy(BluetoothProfile.MAP_CLIENT, mapProfile);
- }
-
- @Override
- public void onServiceDisconnected(int profile) {
- if (mMessage != null) {
- if (DBG) Log.d(TAG, "Bluetooth disconnected before sending the message");
- sendErrorInPendingIntent(mSentIntent, SmsManager.RESULT_ERROR_NO_SERVICE);
- mMessage = null;
- }
- }
- }
-
- private void sendErrorInPendingIntent(PendingIntent intent, int errorCode) {
- if (intent == null) {
- return;
- }
- try {
- intent.send(errorCode);
- } catch (PendingIntent.CanceledException e) {
- // PendingIntent is cancelled. ignore sending this error code back to
- // caller.
- if (DBG) Log.d(TAG, "PendingIntent.CanceledException: " + e.getMessage());
- }
- }
-
/**
* Send a text based SMS without writing it into the SMS Provider.
*
@@ -526,8 +413,8 @@
}
try {
- ISms iccISms = getISmsServiceOrThrow();
- iccISms.sendTextForSubscriberWithSelfPermissions(getSubscriptionId(),
+ ISms iSms = getISmsServiceOrThrow();
+ iSms.sendTextForSubscriberWithSelfPermissions(getSubscriptionId(),
ActivityThread.currentPackageName(),
destinationAddress,
scAddress, text, sentIntent, deliveryIntent, persistMessage);
@@ -610,9 +497,9 @@
}
try {
- ISms iccISms = getISmsServiceOrThrow();
- if (iccISms != null) {
- iccISms.sendTextForSubscriberWithOptions(getSubscriptionId(),
+ ISms iSms = getISmsServiceOrThrow();
+ if (iSms != null) {
+ iSms.sendTextForSubscriberWithOptions(getSubscriptionId(),
ActivityThread.currentPackageName(), destinationAddress, scAddress, text,
sentIntent, deliveryIntent, persistMessage, priority, expectMore,
validityPeriod);
@@ -671,9 +558,9 @@
"Invalid pdu format. format must be either 3gpp or 3gpp2");
}
try {
- ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
- if (iccISms != null) {
- iccISms.injectSmsPduForSubscriber(
+ ISms iSms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
+ if (iSms != null) {
+ iSms.injectSmsPduForSubscriber(
getSubscriptionId(), pdu, format, receivedIntent);
}
} catch (RemoteException ex) {
@@ -759,8 +646,8 @@
if (parts.size() > 1) {
try {
- ISms iccISms = getISmsServiceOrThrow();
- iccISms.sendMultipartTextForSubscriber(getSubscriptionId(),
+ ISms iSms = getISmsServiceOrThrow();
+ iSms.sendMultipartTextForSubscriber(getSubscriptionId(),
ActivityThread.currentPackageName(),
destinationAddress, scAddress, parts,
sentIntents, deliveryIntents, persistMessage);
@@ -891,9 +778,9 @@
if (parts.size() > 1) {
try {
- ISms iccISms = getISmsServiceOrThrow();
- if (iccISms != null) {
- iccISms.sendMultipartTextForSubscriberWithOptions(getSubscriptionId(),
+ ISms iSms = getISmsServiceOrThrow();
+ if (iSms != null) {
+ iSms.sendMultipartTextForSubscriberWithOptions(getSubscriptionId(),
ActivityThread.currentPackageName(), destinationAddress, scAddress,
parts, sentIntents, deliveryIntents, persistMessage, priority,
expectMore, validityPeriod);
@@ -979,8 +866,8 @@
}
try {
- ISms iccISms = getISmsServiceOrThrow();
- iccISms.sendDataForSubscriber(getSubscriptionId(), ActivityThread.currentPackageName(),
+ ISms iSms = getISmsServiceOrThrow();
+ iSms.sendDataForSubscriber(getSubscriptionId(), ActivityThread.currentPackageName(),
destinationAddress, scAddress, destinationPort & 0xFFFF,
data, sentIntent, deliveryIntent);
} catch (RemoteException ex) {
@@ -1006,8 +893,8 @@
}
try {
- ISms iccISms = getISmsServiceOrThrow();
- iccISms.sendDataForSubscriberWithSelfPermissions(getSubscriptionId(),
+ ISms iSms = getISmsServiceOrThrow();
+ iSms.sendDataForSubscriberWithSelfPermissions(getSubscriptionId(),
ActivityThread.currentPackageName(), destinationAddress, scAddress,
destinationPort & 0xFFFF, data, sentIntent, deliveryIntent);
} catch (RemoteException ex) {
@@ -1069,9 +956,9 @@
boolean isSmsSimPickActivityNeeded = false;
final Context context = ActivityThread.currentApplication().getApplicationContext();
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- isSmsSimPickActivityNeeded = iccISms.isSmsSimPickActivityNeeded(subId);
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ isSmsSimPickActivityNeeded = iSms.isSmsSimPickActivityNeeded(subId);
}
} catch (RemoteException ex) {
Log.e(TAG, "Exception in getSubscriptionId");
@@ -1102,11 +989,11 @@
* the service does not exist.
*/
private static ISms getISmsServiceOrThrow() {
- ISms iccISms = getISmsService();
- if (iccISms == null) {
+ ISms iSms = getISmsService();
+ if (iSms == null) {
throw new UnsupportedOperationException("Sms is not supported");
}
- return iccISms;
+ return iSms;
}
private static ISms getISmsService() {
@@ -1135,9 +1022,9 @@
throw new IllegalArgumentException("pdu is NULL");
}
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- success = iccISms.copyMessageToIccEfForSubscriber(getSubscriptionId(),
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ success = iSms.copyMessageToIccEfForSubscriber(getSubscriptionId(),
ActivityThread.currentPackageName(),
status, pdu, smsc);
}
@@ -1166,9 +1053,9 @@
Arrays.fill(pdu, (byte)0xff);
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- success = iccISms.updateMessageOnIccEfForSubscriber(getSubscriptionId(),
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ success = iSms.updateMessageOnIccEfForSubscriber(getSubscriptionId(),
ActivityThread.currentPackageName(),
messageIndex, STATUS_ON_ICC_FREE, pdu);
}
@@ -1198,9 +1085,9 @@
boolean success = false;
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- success = iccISms.updateMessageOnIccEfForSubscriber(getSubscriptionId(),
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ success = iSms.updateMessageOnIccEfForSubscriber(getSubscriptionId(),
ActivityThread.currentPackageName(),
messageIndex, newStatus, pdu);
}
@@ -1225,9 +1112,9 @@
List<SmsRawData> records = null;
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- records = iccISms.getAllMessagesFromIccEfForSubscriber(
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ records = iSms.getAllMessagesFromIccEfForSubscriber(
getSubscriptionId(),
ActivityThread.currentPackageName());
}
@@ -1262,9 +1149,9 @@
boolean success = false;
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- success = iccISms.enableCellBroadcastForSubscriber(
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ success = iSms.enableCellBroadcastForSubscriber(
getSubscriptionId(), messageIdentifier, ranType);
}
} catch (RemoteException ex) {
@@ -1298,9 +1185,9 @@
boolean success = false;
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- success = iccISms.disableCellBroadcastForSubscriber(
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ success = iSms.disableCellBroadcastForSubscriber(
getSubscriptionId(), messageIdentifier, ranType);
}
} catch (RemoteException ex) {
@@ -1341,9 +1228,9 @@
throw new IllegalArgumentException("endMessageId < startMessageId");
}
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- success = iccISms.enableCellBroadcastRangeForSubscriber(getSubscriptionId(),
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ success = iSms.enableCellBroadcastRangeForSubscriber(getSubscriptionId(),
startMessageId, endMessageId, ranType);
}
} catch (RemoteException ex) {
@@ -1384,9 +1271,9 @@
throw new IllegalArgumentException("endMessageId < startMessageId");
}
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- success = iccISms.disableCellBroadcastRangeForSubscriber(getSubscriptionId(),
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ success = iSms.disableCellBroadcastRangeForSubscriber(getSubscriptionId(),
startMessageId, endMessageId, ranType);
}
} catch (RemoteException ex) {
@@ -1436,9 +1323,9 @@
public boolean isImsSmsSupported() {
boolean boSupported = false;
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- boSupported = iccISms.isImsSmsSupportedForSubscriber(getSubscriptionId());
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ boSupported = iSms.isImsSmsSupportedForSubscriber(getSubscriptionId());
}
} catch (RemoteException ex) {
// ignore it
@@ -1461,9 +1348,9 @@
public String getImsSmsFormat() {
String format = com.android.internal.telephony.SmsConstants.FORMAT_UNKNOWN;
try {
- ISms iccISms = getISmsService();
- if (iccISms != null) {
- format = iccISms.getImsSmsFormatForSubscriber(getSubscriptionId());
+ ISms iSms = getISmsService();
+ if (iSms != null) {
+ format = iSms.getImsSmsFormatForSubscriber(getSubscriptionId());
}
} catch (RemoteException ex) {
// ignore it
@@ -1477,10 +1364,10 @@
* @return the default SMS subscription id
*/
public static int getDefaultSmsSubscriptionId() {
- ISms iccISms = null;
+ ISms iSms = null;
try {
- iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
- return iccISms.getPreferredSmsSubscription();
+ iSms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
+ return iSms.getPreferredSmsSubscription();
} catch (RemoteException ex) {
return -1;
} catch (NullPointerException ex) {
@@ -1496,10 +1383,10 @@
*/
@UnsupportedAppUsage
public boolean isSMSPromptEnabled() {
- ISms iccISms = null;
+ ISms iSms = null;
try {
- iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
- return iccISms.isSMSPromptEnabled();
+ iSms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
+ return iSms.isSMSPromptEnabled();
} catch (RemoteException ex) {
return false;
} catch (NullPointerException ex) {
@@ -1976,8 +1863,8 @@
throw new IllegalArgumentException("Empty message URI");
}
try {
- ISms iccISms = getISmsServiceOrThrow();
- iccISms.sendStoredText(
+ ISms iSms = getISmsServiceOrThrow();
+ iSms.sendStoredText(
getSubscriptionId(), ActivityThread.currentPackageName(), messageUri,
scAddress, sentIntent, deliveryIntent);
} catch (RemoteException ex) {
@@ -2024,8 +1911,8 @@
throw new IllegalArgumentException("Empty message URI");
}
try {
- ISms iccISms = getISmsServiceOrThrow();
- iccISms.sendStoredMultipartText(
+ ISms iSms = getISmsServiceOrThrow();
+ iSms.sendStoredMultipartText(
getSubscriptionId(), ActivityThread.currentPackageName(), messageUri,
scAddress, sentIntents, deliveryIntents);
} catch (RemoteException ex) {
diff --git a/tests/net/java/com/android/server/ConnectivityServiceTest.java b/tests/net/java/com/android/server/ConnectivityServiceTest.java
index 2fac8e0..b35de59 100644
--- a/tests/net/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/net/java/com/android/server/ConnectivityServiceTest.java
@@ -4066,8 +4066,6 @@
// TODO: 1. Move this outside of ConnectivityServiceTest.
// 2. Make test to verify that Nat-T keepalive socket is created by IpSecService.
// 3. Mock ipsec service.
- // 4. Find a free port instead of a fixed port.
- final int srcPort = 12345;
final InetAddress myIPv4 = InetAddress.getByName("192.0.2.129");
final InetAddress notMyIPv4 = InetAddress.getByName("192.0.2.35");
final InetAddress myIPv6 = InetAddress.getByName("2001:db8::1");
@@ -4078,7 +4076,8 @@
final int invalidKaInterval = 9;
final IpSecManager mIpSec = (IpSecManager) mContext.getSystemService(Context.IPSEC_SERVICE);
- final UdpEncapsulationSocket testSocket = mIpSec.openUdpEncapsulationSocket(srcPort);
+ final UdpEncapsulationSocket testSocket = mIpSec.openUdpEncapsulationSocket();
+ final int srcPort = testSocket.getPort();
LinkProperties lp = new LinkProperties();
lp.setInterfaceName("wlan12");
@@ -4198,6 +4197,7 @@
// Check that keepalive slots start from 1 and increment. The first one gets slot 1.
mWiFiNetworkAgent.setExpectedKeepaliveSlot(1);
+ int srcPort2 = 0;
try (SocketKeepalive ka = mCm.createSocketKeepalive(
myNet, testSocket, myIPv4, dstIPv4, executor, callback)) {
ka.start(validKaInterval);
@@ -4205,7 +4205,8 @@
// The second one gets slot 2.
mWiFiNetworkAgent.setExpectedKeepaliveSlot(2);
- final UdpEncapsulationSocket testSocket2 = mIpSec.openUdpEncapsulationSocket(6789);
+ final UdpEncapsulationSocket testSocket2 = mIpSec.openUdpEncapsulationSocket();
+ srcPort2 = testSocket2.getPort();
TestSocketKeepaliveCallback callback2 = new TestSocketKeepaliveCallback(executor);
try (SocketKeepalive ka2 = mCm.createSocketKeepalive(
myNet, testSocket2, myIPv4, dstIPv4, executor, callback2)) {
@@ -4223,6 +4224,10 @@
}
}
+ // Check that there is no port leaked after all keepalives and sockets are closed.
+ assertFalse(isUdpPortInUse(srcPort));
+ assertFalse(isUdpPortInUse(srcPort2));
+
mWiFiNetworkAgent.disconnect();
waitFor(mWiFiNetworkAgent.getDisconnectedCV());
mWiFiNetworkAgent = null;
@@ -4305,7 +4310,6 @@
}
private void doTestNattSocketKeepalivesFdWithExecutor(Executor executor) throws Exception {
- final int srcPort = 12345;
final InetAddress myIPv4 = InetAddress.getByName("192.0.2.129");
final InetAddress anyIPv4 = InetAddress.getByName("0.0.0.0");
final InetAddress dstIPv4 = InetAddress.getByName("8.8.8.8");
@@ -4324,7 +4328,8 @@
// Prepare the target file descriptor, keep only one instance.
final IpSecManager mIpSec = (IpSecManager) mContext.getSystemService(Context.IPSEC_SERVICE);
- final UdpEncapsulationSocket testSocket = mIpSec.openUdpEncapsulationSocket(srcPort);
+ final UdpEncapsulationSocket testSocket = mIpSec.openUdpEncapsulationSocket();
+ final int srcPort = testSocket.getPort();
final ParcelFileDescriptor testPfd =
ParcelFileDescriptor.dup(testSocket.getFileDescriptor());
testSocket.close();