diff options
39 files changed, 500 insertions, 3109 deletions
diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg index e731138ff40d..68311176a783 100644 --- a/PREUPLOAD.cfg +++ b/PREUPLOAD.cfg @@ -1,8 +1,6 @@ [Hook Scripts] checkstyle_hook = ${REPO_ROOT}/prebuilts/checkstyle/checkstyle.py --sha ${PREUPLOAD_COMMIT} -api_lint_hook = ${REPO_ROOT}/frameworks/base/tools/apilint/apilint_sha.sh ${PREUPLOAD_COMMIT} - strings_lint_hook = ${REPO_ROOT}/frameworks/base/tools/stringslint/stringslint_sha.sh ${PREUPLOAD_COMMIT} hidden_api_txt_checksorted_hook = ${REPO_ROOT}/frameworks/base/tools/hiddenapi/checksorted_sha.sh ${PREUPLOAD_COMMIT} ${REPO_ROOT} diff --git a/core/java/android/os/UserManager.java b/core/java/android/os/UserManager.java index 3476b18ceee0..b096049ebb68 100644 --- a/core/java/android/os/UserManager.java +++ b/core/java/android/os/UserManager.java @@ -2486,6 +2486,8 @@ public class UserManager { /** * Return the number of users currently created on the device. + * <p>This API is not for use by third-party apps. It requires the {@code MANAGE_USERS} + * permission.</p> */ public int getUserCount() { List<UserInfo> users = getUsers(); diff --git a/core/java/android/widget/ListView.java b/core/java/android/widget/ListView.java index 1cb114856a4a..3a197e2277bf 100644 --- a/core/java/android/widget/ListView.java +++ b/core/java/android/widget/ListView.java @@ -120,10 +120,6 @@ import java.util.function.Predicate; * <a href="{@docRoot}training/improving-layouts/smooth-scrolling.html"> * Making ListView Scrolling Smooth</a> for more ways to ensure a smooth user experience.</p> * - * <p>For a more complete example of creating a custom adapter, see the - * <a href="{@docRoot}samples/CustomChoiceList/index.html"> - * Custom Choice List</a> sample app.</p> - * * <p>To specify an action when a user clicks or taps on a single list item, see * <a href="{@docRoot}guide/topics/ui/declaring-layout.html#HandlingUserSelections"> * Handling click events</a>.</p> diff --git a/core/java/android/widget/RelativeLayout.java b/core/java/android/widget/RelativeLayout.java index 6b324a541c42..167010b89bef 100644 --- a/core/java/android/widget/RelativeLayout.java +++ b/core/java/android/widget/RelativeLayout.java @@ -73,7 +73,7 @@ import java.util.TreeSet; * * <p>This behavior has been preserved for apps that set <code>android:targetSdkVersion="17"</code> * or older in their manifest's <code>uses-sdk</code> tag for compatibility. Apps targeting SDK - * version 18 or newer will receive the correct behavior</p> + * version 18 or newer will receive the correct behavior.</p> * * <p>See the <a href="{@docRoot}guide/topics/ui/layout/relative.html">Relative * Layout</a> guide.</p> diff --git a/core/java/com/android/internal/app/IAppOpsService.aidl b/core/java/com/android/internal/app/IAppOpsService.aidl index 3ab0b0d2294b..99bf93e98cd1 100644 --- a/core/java/com/android/internal/app/IAppOpsService.aidl +++ b/core/java/com/android/internal/app/IAppOpsService.aidl @@ -31,19 +31,19 @@ interface IAppOpsService { // be kept in sync with frameworks/native/libs/binder/include/binder/IAppOpsService.h // and not be reordered int checkOperation(int code, int uid, String packageName); - int noteOperation(int code, int uid, String packageName, String featureId); - int startOperation(IBinder token, int code, int uid, String packageName, String featureId, - boolean startIfModeDefault); + int noteOperation(int code, int uid, String packageName, @nullable String featureId); + int startOperation(IBinder token, int code, int uid, String packageName, + @nullable String featureId, boolean startIfModeDefault); @UnsupportedAppUsage void finishOperation(IBinder token, int code, int uid, String packageName, - String featureId); + @nullable String featureId); void startWatchingMode(int op, String packageName, IAppOpsCallback callback); void stopWatchingMode(IAppOpsCallback callback); IBinder getToken(IBinder clientToken); int permissionToOpCode(String permission); int checkAudioOperation(int code, int usage, int uid, String packageName); - void noteAsyncOp(String callingPackageName, int uid, String packageName, int opCode, - String featureId, String message); + void noteAsyncOp(@nullable String callingPackageName, int uid, @nullable String packageName, + int opCode, @nullable String featureId, String message); boolean shouldCollectNotes(int opCode); void setCameraAudioRestriction(int mode); // End of methods also called by native code. diff --git a/core/java/com/android/internal/config/sysui/SystemUiDeviceConfigFlags.java b/core/java/com/android/internal/config/sysui/SystemUiDeviceConfigFlags.java index 36a7a9c91ee4..58e80c7c104f 100644 --- a/core/java/com/android/internal/config/sysui/SystemUiDeviceConfigFlags.java +++ b/core/java/com/android/internal/config/sysui/SystemUiDeviceConfigFlags.java @@ -47,6 +47,20 @@ public final class SystemUiDeviceConfigFlags { */ public static final String NAS_MAX_SUGGESTIONS = "nas_max_suggestions"; + // Flags related to screenshot intelligence + + /** + * (bool) Whether to enable smart actions in screenshot notifications. + */ + public static final String ENABLE_SCREENSHOT_NOTIFICATION_SMART_ACTIONS = + "enable_screenshot_notification_smart_actions"; + + /** + * (int) Timeout value in ms to get smart actions for screenshot notification. + */ + public static final String SCREENSHOT_NOTIFICATION_SMART_ACTIONS_TIMEOUT_MS = + "screenshot_notification_smart_actions_timeout_ms"; + // Flags related to controls /** diff --git a/graphics/java/android/graphics/Paint.java b/graphics/java/android/graphics/Paint.java index b7316ab03618..109d8631284d 100644 --- a/graphics/java/android/graphics/Paint.java +++ b/graphics/java/android/graphics/Paint.java @@ -1114,7 +1114,7 @@ public class Paint { * Return the width for stroking. * <p /> * A value of 0 strokes in hairline mode. - * Hairlines always draws a single pixel independent of the canva's matrix. + * Hairlines always draws a single pixel independent of the canvas's matrix. * * @return the paint's stroke width, used whenever the paint's style is * Stroke or StrokeAndFill. @@ -1126,7 +1126,7 @@ public class Paint { /** * Set the width for stroking. * Pass 0 to stroke in hairline mode. - * Hairlines always draws a single pixel independent of the canva's matrix. + * Hairlines always draws a single pixel independent of the canvas's matrix. * * @param width set the paint's stroke width, used whenever the paint's * style is Stroke or StrokeAndFill. @@ -1958,8 +1958,8 @@ public class Paint { * <code> * Paint paint = new Paint(); * paint.setStartHyphenEdit(Paint.START_HYPHEN_EDIT_INSERT_HYPHEN); - * paint.measureText("abc", 0, 3); // Returns the width of "‐abc" - * Canvas.drawText("abc", 0, 3, 0f, 0f, paint); // Draws "‐abc" + * paint.measureText("abc", 0, 3); // Returns the width of "-abc" + * Canvas.drawText("abc", 0, 3, 0f, 0f, paint); // Draws "-abc" * </code> * </pre> * @@ -1985,8 +1985,8 @@ public class Paint { * <code> * Paint paint = new Paint(); * paint.setEndHyphenEdit(Paint.END_HYPHEN_EDIT_INSERT_HYPHEN); - * paint.measureText("abc", 0, 3); // Returns the width of "abc‐" - * Canvas.drawText("abc", 0, 3, 0f, 0f, paint); // Draws "abc‐" + * paint.measureText("abc", 0, 3); // Returns the width of "abc-" + * Canvas.drawText("abc", 0, 3, 0f, 0f, paint); // Draws "abc-" * </code> * </pre> * diff --git a/media/java/android/media/Image.java b/media/java/android/media/Image.java index 70a343f4de01..7ba122baeca1 100644 --- a/media/java/android/media/Image.java +++ b/media/java/android/media/Image.java @@ -395,7 +395,7 @@ public abstract class Image implements AutoCloseable { * <p>The row stride for this color plane, in bytes.</p> * * <p>This is the distance between the start of two consecutive rows of - * pixels in the image. Note that row stried is undefined for some formats + * pixels in the image. Note that row stride is undefined for some formats * such as * {@link android.graphics.ImageFormat#RAW_PRIVATE RAW_PRIVATE}, * and calling getRowStride on images of these formats will diff --git a/packages/SystemUI/AndroidManifest.xml b/packages/SystemUI/AndroidManifest.xml index b288eb7b5070..cd64a3880803 100644 --- a/packages/SystemUI/AndroidManifest.xml +++ b/packages/SystemUI/AndroidManifest.xml @@ -60,6 +60,9 @@ <uses-permission android:name="android.permission.GET_APP_OPS_STATS" /> <uses-permission android:name="android.permission.USE_RESERVED_DISK" /> + <!-- to invoke ContentSuggestionsService --> + <uses-permission android:name="android.permission.MANAGE_CONTENT_SUGGESTIONS"/> + <!-- Networking and telephony --> <uses-permission android:name="android.permission.BLUETOOTH" /> <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" /> diff --git a/packages/SystemUI/src/com/android/systemui/SystemUIFactory.java b/packages/SystemUI/src/com/android/systemui/SystemUIFactory.java index 0a547b6bf051..b5245973f818 100644 --- a/packages/SystemUI/src/com/android/systemui/SystemUIFactory.java +++ b/packages/SystemUI/src/com/android/systemui/SystemUIFactory.java @@ -33,6 +33,7 @@ import com.android.systemui.dagger.SystemUIRootComponent; import com.android.systemui.keyguard.DismissCallbackRegistry; import com.android.systemui.plugins.FalsingManager; import com.android.systemui.plugins.statusbar.StatusBarStateController; +import com.android.systemui.screenshot.ScreenshotNotificationSmartActionsProvider; import com.android.systemui.statusbar.KeyguardIndicationController; import com.android.systemui.statusbar.NotificationMediaManager; import com.android.systemui.statusbar.notification.NotificationWakeUpCoordinator; @@ -124,6 +125,15 @@ public class SystemUIFactory { return new StatusBarKeyguardViewManager(context, viewMediatorCallback, lockPatternUtils); } + /** + * Creates an instance of ScreenshotNotificationSmartActionsProvider. + * This method is overridden in vendor specific implementation of Sys UI. + */ + public ScreenshotNotificationSmartActionsProvider + createScreenshotNotificationSmartActionsProvider() { + return new ScreenshotNotificationSmartActionsProvider(); + } + public KeyguardBouncer createKeyguardBouncer(Context context, ViewMediatorCallback callback, LockPatternUtils lockPatternUtils, ViewGroup container, DismissCallbackRegistry dismissCallbackRegistry, diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java index 68a2417f90b8..3ff6d0d2278d 100644 --- a/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java +++ b/packages/SystemUI/src/com/android/systemui/screenshot/GlobalScreenshot.java @@ -17,6 +17,7 @@ package com.android.systemui.screenshot; import static android.content.Context.NOTIFICATION_SERVICE; +import static android.os.AsyncTask.THREAD_POOL_EXECUTOR; import static android.provider.DeviceConfig.NAMESPACE_SYSTEMUI; import static android.view.WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS; @@ -29,7 +30,9 @@ import android.animation.AnimatorSet; import android.animation.ValueAnimator; import android.animation.ValueAnimator.AnimatorUpdateListener; import android.annotation.Nullable; +import android.app.ActivityManager; import android.app.ActivityOptions; +import android.app.ActivityTaskManager; import android.app.Notification; import android.app.Notification.BigPictureStyle; import android.app.NotificationManager; @@ -42,6 +45,7 @@ import android.content.ComponentName; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; +import android.content.pm.UserInfo; import android.content.res.Configuration; import android.content.res.Resources; import android.graphics.Bitmap; @@ -64,7 +68,10 @@ import android.os.Looper; import android.os.Message; import android.os.PowerManager; import android.os.Process; +import android.os.RemoteException; +import android.os.SystemClock; import android.os.UserHandle; +import android.os.UserManager; import android.provider.DeviceConfig; import android.provider.MediaStore; import android.text.TextUtils; @@ -82,9 +89,12 @@ import android.view.animation.Interpolator; import android.widget.ImageView; import android.widget.Toast; +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.config.sysui.SystemUiDeviceConfigFlags; import com.android.internal.messages.nano.SystemMessageProto.SystemMessage; import com.android.systemui.R; import com.android.systemui.SystemUI; +import com.android.systemui.SystemUIFactory; import com.android.systemui.dagger.qualifiers.MainResources; import com.android.systemui.shared.system.ActivityManagerWrapper; import com.android.systemui.statusbar.phone.StatusBar; @@ -97,8 +107,11 @@ import java.io.IOException; import java.io.OutputStream; import java.text.DateFormat; import java.text.SimpleDateFormat; +import java.util.Collections; import java.util.Date; +import java.util.List; import java.util.Optional; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; @@ -156,6 +169,8 @@ public class GlobalScreenshot { private final BigPictureStyle mNotificationStyle; private final int mImageWidth; private final int mImageHeight; + private final Handler mHandler; + private final ScreenshotNotificationSmartActionsProvider mSmartActionsProvider; SaveImageInBackgroundTask(Context context, SaveImageInBackgroundData data, NotificationManager nManager) { @@ -167,6 +182,11 @@ public class GlobalScreenshot { String imageDate = new SimpleDateFormat("yyyyMMdd-HHmmss").format(new Date(mImageTime)); mImageFileName = String.format(SCREENSHOT_FILE_NAME_TEMPLATE, imageDate); + // Initialize screenshot notification smart actions provider. + mHandler = new Handler(); + mSmartActionsProvider = + SystemUIFactory.getInstance().createScreenshotNotificationSmartActionsProvider(); + // Create the large notification icon mImageWidth = data.image.getWidth(); mImageHeight = data.image.getHeight(); @@ -242,6 +262,23 @@ public class GlobalScreenshot { mNotificationStyle.bigLargeIcon((Bitmap) null); } + private int getUserHandleOfForegroundApplication(Context context) { + // This logic matches + // com.android.systemui.statusbar.phone.PhoneStatusBarPolicy#updateManagedProfile + try { + return ActivityTaskManager.getService().getLastResumedActivityUserId(); + } catch (RemoteException e) { + Slog.w(TAG, "getUserHandleOfForegroundApplication: ", e); + return context.getUserId(); + } + } + + private boolean isManagedProfile(Context context) { + UserManager manager = UserManager.get(context); + UserInfo info = manager.getUserInfo(getUserHandleOfForegroundApplication(context)); + return info.isManagedProfile(); + } + /** * Generates a new hardware bitmap with specified values, copying the content from the * passed in bitmap. @@ -268,6 +305,12 @@ public class GlobalScreenshot { Context context = mParams.context; Bitmap image = mParams.image; + boolean smartActionsEnabled = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags.ENABLE_SCREENSHOT_NOTIFICATION_SMART_ACTIONS, true); + CompletableFuture<List<Notification.Action>> smartActionsFuture = getSmartActionsFuture( + context, image, mSmartActionsProvider, mHandler, smartActionsEnabled, + isManagedProfile(context)); + Resources r = context.getResources(); try { @@ -378,6 +421,18 @@ public class GlobalScreenshot { mParams.imageUri = uri; mParams.image = null; mParams.errorMsgResId = 0; + + if (smartActionsEnabled) { + int timeoutMs = DeviceConfig.getInt(DeviceConfig.NAMESPACE_SYSTEMUI, + SystemUiDeviceConfigFlags + .SCREENSHOT_NOTIFICATION_SMART_ACTIONS_TIMEOUT_MS, + 1000); + List<Notification.Action> smartActions = getSmartActions(smartActionsFuture, + timeoutMs); + for (Notification.Action action : smartActions) { + mNotificationBuilder.addAction(action); + } + } } catch (Exception e) { // IOException/UnsupportedOperationException may be thrown if external storage is // not mounted @@ -1039,6 +1094,58 @@ public class GlobalScreenshot { nManager.notify(SystemMessage.NOTE_GLOBAL_SCREENSHOT, n); } + @VisibleForTesting + static CompletableFuture<List<Notification.Action>> getSmartActionsFuture(Context context, + Bitmap image, ScreenshotNotificationSmartActionsProvider smartActionsProvider, + Handler handler, boolean smartActionsEnabled, boolean isManagedProfile) { + if (!smartActionsEnabled) { + Slog.i(TAG, "Screenshot Intelligence not enabled, returning empty list."); + return CompletableFuture.completedFuture(Collections.emptyList()); + } + if (image.getConfig() != Bitmap.Config.HARDWARE) { + Slog.w(TAG, String.format( + "Bitmap expected: Hardware, Bitmap found: %s. Returning empty list.", + image.getConfig())); + return CompletableFuture.completedFuture(Collections.emptyList()); + } + + Slog.d(TAG, "Screenshot from a managed profile: " + isManagedProfile); + CompletableFuture<List<Notification.Action>> smartActionsFuture; + try { + ActivityManager.RunningTaskInfo runningTask = + ActivityManagerWrapper.getInstance().getRunningTask(); + ComponentName componentName = + (runningTask != null && runningTask.topActivity != null) + ? runningTask.topActivity + : new ComponentName("", ""); + smartActionsFuture = smartActionsProvider.getActions(image, context, + THREAD_POOL_EXECUTOR, + handler, + componentName, + isManagedProfile); + } catch (Throwable e) { + smartActionsFuture = CompletableFuture.completedFuture(Collections.emptyList()); + Slog.e(TAG, "Failed to get future for screenshot notification smart actions.", e); + } + return smartActionsFuture; + } + + @VisibleForTesting + static List<Notification.Action> getSmartActions( + CompletableFuture<List<Notification.Action>> smartActionsFuture, int timeoutMs) { + try { + long startTimeMs = SystemClock.uptimeMillis(); + List<Notification.Action> actions = smartActionsFuture.get(timeoutMs, + TimeUnit.MILLISECONDS); + Slog.d(TAG, String.format("Wait time for smart actions: %d ms", + SystemClock.uptimeMillis() - startTimeMs)); + return actions; + } catch (Throwable e) { + Slog.e(TAG, "Failed to obtain screenshot notification smart actions.", e); + return Collections.emptyList(); + } + } + /** * Receiver to proxy the share or edit intent, used to clean up the notification and send * appropriate signals to the system (ie. to dismiss the keyguard if necessary). diff --git a/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsProvider.java b/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsProvider.java new file mode 100644 index 000000000000..fa23bf7d5bde --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsProvider.java @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.systemui.screenshot; + +import android.app.Notification; +import android.content.ComponentName; +import android.content.Context; +import android.graphics.Bitmap; +import android.os.Handler; +import android.util.Log; + +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Executor; + +/** + * This class can be overridden by a vendor-specific sys UI implementation, + * in order to provide smart actions in the screenshot notification. + */ +public class ScreenshotNotificationSmartActionsProvider { + private static final String TAG = "ScreenshotActions"; + + /** + * Default implementation that returns an empty list. + * This method is overridden in vendor-specific Sys UI implementation. + * + * @param bitmap The bitmap of the screenshot. The bitmap config must be {@link + * HARDWARE}. + * @param context The current app {@link Context}. + * @param executor A {@link Executor} that can be used to execute tasks in parallel. + * @param handler A {@link Handler} to possibly run UI-thread code. + * @param componentName Contains package and activity class names where the screenshot was + * taken. This is used as an additional signal to generate and rank more + * relevant actions. + * @param isManagedProfile The screenshot was taken for a work profile app. + */ + public CompletableFuture<List<Notification.Action>> getActions(Bitmap bitmap, Context context, + Executor executor, Handler handler, ComponentName componentName, + boolean isManagedProfile) { + Log.d(TAG, "Returning empty smart action list."); + return CompletableFuture.completedFuture(Collections.emptyList()); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsTest.java b/packages/SystemUI/tests/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsTest.java new file mode 100644 index 000000000000..99850e7c922e --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/screenshot/ScreenshotNotificationSmartActionsTest.java @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.systemui.screenshot; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.app.Notification; +import android.graphics.Bitmap; +import android.os.Handler; +import android.testing.AndroidTestingRunner; + +import androidx.test.filters.SmallTest; + +import com.android.systemui.SystemUIFactory; +import com.android.systemui.SysuiTestCase; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +/** + * Tests for exception handling and bitmap configuration in adding smart actions to Screenshot + * Notification. + */ +public class ScreenshotNotificationSmartActionsTest extends SysuiTestCase { + private ScreenshotNotificationSmartActionsProvider mSmartActionsProvider; + private Handler mHandler; + + @Before + public void setup() { + mSmartActionsProvider = mock( + ScreenshotNotificationSmartActionsProvider.class); + mHandler = mock(Handler.class); + } + + // Tests any exception thrown in getting smart actions future does not affect regular + // screenshot flow. + @Test + public void testExceptionHandlingInGetSmartActionsFuture() + throws Exception { + Bitmap bitmap = mock(Bitmap.class); + when(bitmap.getConfig()).thenReturn(Bitmap.Config.HARDWARE); + ScreenshotNotificationSmartActionsProvider smartActionsProvider = mock( + ScreenshotNotificationSmartActionsProvider.class); + when(smartActionsProvider.getActions(any(), any(), any(), any(), any(), + eq(false))).thenThrow( + RuntimeException.class); + CompletableFuture<List<Notification.Action>> smartActionsFuture = + GlobalScreenshot.getSmartActionsFuture(mContext, bitmap, + smartActionsProvider, mHandler, true, false); + Assert.assertNotNull(smartActionsFuture); + List<Notification.Action> smartActions = smartActionsFuture.get(5, TimeUnit.MILLISECONDS); + Assert.assertEquals(Collections.emptyList(), smartActions); + } + + // Tests any exception thrown in waiting for smart actions future to complete does + // not affect regular screenshot flow. + @Test + public void testExceptionHandlingInGetSmartActions() + throws Exception { + CompletableFuture<List<Notification.Action>> smartActionsFuture = mock( + CompletableFuture.class); + int timeoutMs = 1000; + when(smartActionsFuture.get(timeoutMs, TimeUnit.MILLISECONDS)).thenThrow( + RuntimeException.class); + List<Notification.Action> actions = GlobalScreenshot.getSmartActions( + smartActionsFuture, timeoutMs); + Assert.assertEquals(Collections.emptyList(), actions); + } + + // Tests for a non-hardware bitmap, ScreenshotNotificationSmartActionsProvider is never invoked + // and a completed future is returned. + @Test + public void testUnsupportedBitmapConfiguration() + throws Exception { + Bitmap bitmap = mock(Bitmap.class); + when(bitmap.getConfig()).thenReturn(Bitmap.Config.RGB_565); + CompletableFuture<List<Notification.Action>> smartActionsFuture = + GlobalScreenshot.getSmartActionsFuture(mContext, bitmap, + mSmartActionsProvider, mHandler, true, true); + verify(mSmartActionsProvider, never()).getActions(any(), any(), any(), any(), any(), + eq(false)); + Assert.assertNotNull(smartActionsFuture); + List<Notification.Action> smartActions = smartActionsFuture.get(5, TimeUnit.MILLISECONDS); + Assert.assertEquals(Collections.emptyList(), smartActions); + } + + // Tests for a hardware bitmap, ScreenshotNotificationSmartActionsProvider is invoked once. + @Test + public void testScreenshotNotificationSmartActionsProviderInvokedOnce() { + Bitmap bitmap = mock(Bitmap.class); + when(bitmap.getConfig()).thenReturn(Bitmap.Config.HARDWARE); + GlobalScreenshot.getSmartActionsFuture(mContext, bitmap, mSmartActionsProvider, + mHandler, true, true); + verify(mSmartActionsProvider, times(1)) + .getActions(any(), any(), any(), any(), any(), eq(true)); + } + + // Tests for a hardware bitmap, a completed future is returned. + @Test + public void testSupportedBitmapConfiguration() + throws Exception { + Bitmap bitmap = mock(Bitmap.class); + when(bitmap.getConfig()).thenReturn(Bitmap.Config.HARDWARE); + ScreenshotNotificationSmartActionsProvider actionsProvider = + SystemUIFactory.getInstance().createScreenshotNotificationSmartActionsProvider(); + CompletableFuture<List<Notification.Action>> smartActionsFuture = + GlobalScreenshot.getSmartActionsFuture(mContext, bitmap, + actionsProvider, + mHandler, true, true); + Assert.assertNotNull(smartActionsFuture); + List<Notification.Action> smartActions = smartActionsFuture.get(5, TimeUnit.MILLISECONDS); + Assert.assertEquals(smartActions.size(), 0); + } +} diff --git a/services/contentsuggestions/java/com/android/server/contentsuggestions/ContentSuggestionsManagerService.java b/services/contentsuggestions/java/com/android/server/contentsuggestions/ContentSuggestionsManagerService.java index ecea251cc1ac..9cdb58d8c019 100644 --- a/services/contentsuggestions/java/com/android/server/contentsuggestions/ContentSuggestionsManagerService.java +++ b/services/contentsuggestions/java/com/android/server/contentsuggestions/ContentSuggestionsManagerService.java @@ -16,7 +16,6 @@ package com.android.server.contentsuggestions; -import static android.Manifest.permission.BIND_CONTENT_SUGGESTIONS_SERVICE; import static android.Manifest.permission.MANAGE_CONTENT_SUGGESTIONS; import static android.content.pm.PackageManager.PERMISSION_GRANTED; @@ -96,7 +95,7 @@ public class ContentSuggestionsManagerService extends private void enforceCaller(int userId, String func) { Context ctx = getContext(); - if (ctx.checkCallingPermission(BIND_CONTENT_SUGGESTIONS_SERVICE) == PERMISSION_GRANTED + if (ctx.checkCallingPermission(MANAGE_CONTENT_SUGGESTIONS) == PERMISSION_GRANTED || mServiceNameResolver.isTemporary(userId) || mActivityTaskManagerInternal.isCallerRecents(Binder.getCallingUid())) { return; diff --git a/services/core/java/com/android/server/appop/AppOpsService.java b/services/core/java/com/android/server/appop/AppOpsService.java index 2e36a4305fad..7e9a17bb8dbc 100644 --- a/services/core/java/com/android/server/appop/AppOpsService.java +++ b/services/core/java/com/android/server/appop/AppOpsService.java @@ -47,8 +47,8 @@ import android.app.AppOpsManager; import android.app.AppOpsManager.HistoricalOps; import android.app.AppOpsManager.HistoricalOpsRequest; import android.app.AppOpsManager.Mode; -import android.app.AppOpsManager.OpFeatureEntry; import android.app.AppOpsManager.OpEntry; +import android.app.AppOpsManager.OpFeatureEntry; import android.app.AppOpsManager.OpFlags; import android.app.AppOpsManagerInternal; import android.app.AppOpsManagerInternal.CheckOpsDelegate; @@ -119,6 +119,12 @@ import com.android.internal.util.function.pooled.PooledLambda; import com.android.server.LocalServices; import com.android.server.LockGuard; +import libcore.util.EmptyArray; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; +import org.xmlpull.v1.XmlSerializer; + import java.io.File; import java.io.FileDescriptor; import java.io.FileInputStream; @@ -138,12 +144,6 @@ import java.util.List; import java.util.Map; import java.util.Objects; -import libcore.util.EmptyArray; - -import org.xmlpull.v1.XmlPullParser; -import org.xmlpull.v1.XmlPullParserException; -import org.xmlpull.v1.XmlSerializer; - public class AppOpsService extends IAppOpsService.Stub { static final String TAG = "AppOps"; static final boolean DEBUG = false; @@ -2356,7 +2356,6 @@ public class AppOpsService extends IAppOpsService.Stub { public void noteAsyncOp(String callingPackageName, int uid, String packageName, int opCode, String featureId, String message) { Preconditions.checkNotNull(message); - Preconditions.checkNotNull(packageName); verifyAndGetIsPrivileged(uid, packageName); verifyIncomingUid(uid); diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java index 340720e2f1fb..936d88d5ba84 100644 --- a/services/core/java/com/android/server/pm/PackageManagerService.java +++ b/services/core/java/com/android/server/pm/PackageManagerService.java @@ -22256,8 +22256,9 @@ public class PackageManagerService extends IPackageManager.Stub continue; } final String packageName = ps.pkg.packageName; - // Skip over if system app - if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0) { + // Skip over if system app or static shared library + if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0 + || !TextUtils.isEmpty(ps.pkg.staticSharedLibName)) { continue; } if (DEBUG_CLEAN_APKS) { diff --git a/services/core/java/com/android/server/wm/ActivityRecord.java b/services/core/java/com/android/server/wm/ActivityRecord.java index cfacbd8117c8..8aa5e77a01b1 100644 --- a/services/core/java/com/android/server/wm/ActivityRecord.java +++ b/services/core/java/com/android/server/wm/ActivityRecord.java @@ -1167,7 +1167,7 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A TaskStack getStack() { final Task task = getTask(); if (task != null) { - return task.mStack; + return task.getTaskStack(); } else { return null; } @@ -1210,8 +1210,8 @@ final class ActivityRecord extends WindowToken implements WindowManagerService.A if (getDisplayContent() != null) { getDisplayContent().mClosingApps.remove(this); } - } else if (mLastParent != null && mLastParent.mStack != null) { - task.mStack.mExitingActivities.remove(this); + } else if (mLastParent != null && mLastParent.getTaskStack() != null) { + task.getTaskStack().mExitingActivities.remove(this); } final TaskStack stack = getStack(); diff --git a/services/core/java/com/android/server/wm/RootActivityContainer.java b/services/core/java/com/android/server/wm/RootActivityContainer.java index dc78922ef4fc..2ca929e9581f 100644 --- a/services/core/java/com/android/server/wm/RootActivityContainer.java +++ b/services/core/java/com/android/server/wm/RootActivityContainer.java @@ -1628,7 +1628,7 @@ class RootActivityContainer extends ConfigurationContainer return false; } - <T extends ActivityStack> T getLaunchStack(@Nullable ActivityRecord r, + ActivityStack getLaunchStack(@Nullable ActivityRecord r, @Nullable ActivityOptions options, @Nullable TaskRecord candidateTask, boolean onTop) { return getLaunchStack(r, options, candidateTask, onTop, null /* launchParams */, -1 /* no realCallingPid */, -1 /* no realCallingUid */); @@ -1646,7 +1646,7 @@ class RootActivityContainer extends ConfigurationContainer * * @return The stack to use for the launch or INVALID_STACK_ID. */ - <T extends ActivityStack> T getLaunchStack(@Nullable ActivityRecord r, + ActivityStack getLaunchStack(@Nullable ActivityRecord r, @Nullable ActivityOptions options, @Nullable TaskRecord candidateTask, boolean onTop, @Nullable LaunchParamsController.LaunchParams launchParams, int realCallingPid, int realCallingUid) { @@ -1674,7 +1674,7 @@ class RootActivityContainer extends ConfigurationContainer } final int activityType = resolveActivityType(r, options, candidateTask); - T stack; + ActivityStack stack; // Next preference for stack goes to the display Id set the candidate display. if (launchParams != null && launchParams.mPreferredDisplayId != INVALID_DISPLAY) { @@ -1690,7 +1690,7 @@ class RootActivityContainer extends ConfigurationContainer if (displayId != INVALID_DISPLAY && (canLaunchOnDisplay(r, displayId) || canLaunchOnDisplayFromStartRequest)) { if (r != null) { - stack = (T) getValidLaunchStackOnDisplay(displayId, r, candidateTask, options, + stack = getValidLaunchStackOnDisplay(displayId, r, candidateTask, options, launchParams); if (stack != null) { return stack; diff --git a/services/core/java/com/android/server/wm/Task.java b/services/core/java/com/android/server/wm/Task.java index a4a91bda0bcf..183ca074ec7f 100644 --- a/services/core/java/com/android/server/wm/Task.java +++ b/services/core/java/com/android/server/wm/Task.java @@ -68,8 +68,6 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta final ActivityTaskManagerService mAtmService; - // TODO: Track parent marks like this in WindowContainer. - TaskStack mStack; /* Unique identifier for this task. */ final int mTaskId; /* User for which this task was created. */ @@ -129,7 +127,6 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta super(atm.mWindowManager); mAtmService = atm; mTaskId = taskId; - mStack = stack; mUserId = userId; mResizeMode = resizeMode; mSupportsPictureInPicture = supportsPictureInPicture; @@ -140,12 +137,16 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta // Tasks have no set orientation value (including SCREEN_ORIENTATION_UNSPECIFIED). setOrientation(SCREEN_ORIENTATION_UNSET); // TODO(task-merge): Is this really needed? - setBounds(getResolvedOverrideBounds()); + //setBounds(getResolvedOverrideBounds()); } @Override DisplayContent getDisplayContent() { - return mStack != null ? mStack.getDisplayContent() : null; + return getTaskStack() != null ? getTaskStack().getDisplayContent() : null; + } + + TaskStack getTaskStack() { + return (TaskStack) getParent(); } int getAdjustedAddPosition(ActivityRecord r, int suggestedPosition) { @@ -200,7 +201,7 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta // No reason to defer removal of a Task that doesn't have any child. return false; } - return hasWindowsAlive() && mStack.isAnimating(TRANSITION | CHILDREN); + return hasWindowsAlive() && getTaskStack().isAnimating(TRANSITION | CHILDREN); } @Override @@ -222,10 +223,10 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta // TODO: Consolidate this with TaskRecord.reparent() void reparent(TaskStack stack, int position, boolean moveParents, String reason) { if (DEBUG_STACK) Slog.i(TAG, "reParentTask: removing taskId=" + mTaskId - + " from stack=" + mStack); + + " from stack=" + getTaskStack()); EventLog.writeEvent(WM_TASK_REMOVED, mTaskId, "reParentTask"); - final ActivityStack prevStack = mStack.mActivityStack; + final ActivityStack prevStack = getTaskStack().mActivityStack; final boolean wasTopFocusedStack = mAtmService.mRootActivityContainer.isTopDisplayFocusedStack(prevStack); final ActivityDisplay prevStackDisplay = prevStack.getDisplay(); @@ -237,8 +238,8 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta prevStack.moveHomeStackToFrontIfNeeded(wasTopFocusedStack, prevStackDisplay, reason); } - mStack = stack; - stack.positionChildAt(position, this, moveParents); + // TODO(task-merge): Remove cast. + stack.positionChildAt(position, (TaskRecord) this, moveParents); // If we are moving from the fullscreen stack to the pinned stack then we want to preserve // our insets so that there will not be a jump in the area covered by system decorations. @@ -248,7 +249,8 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta /** @see ActivityTaskManagerService#positionTaskInStack(int, int, int). */ void positionAt(int position) { - mStack.positionChildAt(position, this, false /* includingParents */); + // TODO(task-merge): Remove cast. + getTaskStack().positionChildAt(position, (TaskRecord) this, false /* includingParents */); } void setSendingToBottom(boolean toBottom) { @@ -272,7 +274,8 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta @Override public int setBounds(Rect bounds) { int rotation = Surface.ROTATION_0; - final DisplayContent displayContent = mStack != null ? mStack.getDisplayContent() : null; + final DisplayContent displayContent = getTaskStack() != null + ? getTaskStack().getDisplayContent() : null; if (displayContent != null) { rotation = displayContent.getDisplayInfo().rotation; } else if (bounds == null) { @@ -463,7 +466,7 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta /** Bounds of the task to be used for dimming, as well as touch related tests. */ public void getDimBounds(Rect out) { - final DisplayContent displayContent = mStack.getDisplayContent(); + final DisplayContent displayContent = getTaskStack().getDisplayContent(); // It doesn't matter if we in particular are part of the resize, since we couldn't have // a DimLayer anyway if we weren't visible. final boolean dockedResizing = displayContent != null @@ -480,9 +483,9 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta // stack bounds and so we don't even want to use them. Even if the app should not be // resized the Dim should keep up with the divider. if (dockedResizing) { - mStack.getBounds(out); + getTaskStack().getBounds(out); } else { - mStack.getBounds(mTmpRect); + getTaskStack().getBounds(mTmpRect); mTmpRect.intersect(getBounds()); out.set(mTmpRect); } @@ -495,9 +498,9 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta void setDragResizing(boolean dragResizing, int dragResizeMode) { if (mDragResizing != dragResizing) { // No need to check if the mode is allowed if it's leaving dragResize - if (dragResizing && !DragResizeMode.isModeAllowedForStack(mStack, dragResizeMode)) { + if (dragResizing && !DragResizeMode.isModeAllowedForStack(getTaskStack(), dragResizeMode)) { throw new IllegalArgumentException("Drag resize mode not allow for stack stackId=" - + mStack.mStackId + " dragResizeMode=" + dragResizeMode); + + getTaskStack().mStackId + " dragResizeMode=" + dragResizeMode); } mDragResizing = dragResizing; mDragResizeMode = dragResizeMode; @@ -587,7 +590,7 @@ class Task extends WindowContainer<ActivityRecord> implements ConfigurationConta */ boolean isFloating() { return getWindowConfiguration().tasksAreFloating() - && !mStack.isAnimatingBoundsToFullscreen() && !mPreserveNonFloatingState; + && !getTaskStack().isAnimatingBoundsToFullscreen() && !mPreserveNonFloatingState; } @Override diff --git a/services/core/java/com/android/server/wm/TaskPositioner.java b/services/core/java/com/android/server/wm/TaskPositioner.java index 478b1b533f4c..f7b802da8860 100644 --- a/services/core/java/com/android/server/wm/TaskPositioner.java +++ b/services/core/java/com/android/server/wm/TaskPositioner.java @@ -30,6 +30,7 @@ import static com.android.server.wm.WindowState.MINIMUM_VISIBLE_HEIGHT_IN_DP; import static com.android.server.wm.WindowState.MINIMUM_VISIBLE_WIDTH_IN_DP; import android.annotation.IntDef; +import android.annotation.NonNull; import android.app.IActivityTaskManager; import android.graphics.Point; import android.graphics.Rect; @@ -104,6 +105,7 @@ class TaskPositioner implements IBinder.DeathRecipient { @VisibleForTesting Task mTask; + WindowState mWindow; private boolean mResizing; private boolean mPreserveOrientation; private boolean mStartOrientationWasLandscape; @@ -238,8 +240,9 @@ class TaskPositioner implements IBinder.DeathRecipient { /** * @param displayContent The Display that the window being dragged is on. + * @param win The window which will be dragged. */ - void register(DisplayContent displayContent) { + void register(DisplayContent displayContent, @NonNull WindowState win) { final Display display = displayContent.getDisplay(); if (DEBUG_TASK_POSITIONING) { @@ -309,6 +312,17 @@ class TaskPositioner implements IBinder.DeathRecipient { display.getRealSize(mMaxVisibleSize); mDragEnded = false; + + try { + mClientCallback = win.mClient.asBinder(); + mClientCallback.linkToDeath(this, 0 /* flags */); + } catch (RemoteException e) { + // The caller has died, so clean up TaskPositioningController. + mService.mTaskPositioningController.finishTaskPositioning(); + return; + } + mWindow = win; + mTask = win.getTask(); } void unregister() { @@ -341,25 +355,19 @@ class TaskPositioner implements IBinder.DeathRecipient { ProtoLog.d(WM_DEBUG_ORIENTATION, "Resuming rotation after re-position"); mDisplayContent.getDisplayRotation().resume(); mDisplayContent = null; - mClientCallback.unlinkToDeath(this, 0 /* flags */); + if (mClientCallback != null) { + mClientCallback.unlinkToDeath(this, 0 /* flags */); + } + mWindow = null; } - void startDrag(WindowState win, boolean resize, boolean preserveOrientation, float startX, - float startY) { + void startDrag(boolean resize, boolean preserveOrientation, float startX, + float startY) { if (DEBUG_TASK_POSITIONING) { - Slog.d(TAG, "startDrag: win=" + win + ", resize=" + resize + Slog.d(TAG, "startDrag: win=" + mWindow + ", resize=" + resize + ", preserveOrientation=" + preserveOrientation + ", {" + startX + ", " + startY + "}"); } - try { - mClientCallback = win.mClient.asBinder(); - mClientCallback.linkToDeath(this, 0 /* flags */); - } catch (RemoteException e) { - // The caller has died, so clean up TaskPositioningController. - mService.mTaskPositioningController.finishTaskPositioning(); - return; - } - mTask = win.getTask(); // Use the bounds of the task which accounts for // multiple app windows. Don't use any bounds from win itself as it // may not be the same size as the task. @@ -441,7 +449,7 @@ class TaskPositioner implements IBinder.DeathRecipient { } // This is a moving or scrolling operation. - mTask.mStack.getDimBounds(mTmpRect); + mTask.getTaskStack().getDimBounds(mTmpRect); // If a target window is covered by system bar, there is no way to move it again by touch. // So we exclude them from stack bounds. and then it will be shown inside stable area. Rect stableBounds = new Rect(); diff --git a/services/core/java/com/android/server/wm/TaskPositioningController.java b/services/core/java/com/android/server/wm/TaskPositioningController.java index e1123fa05b7d..c38e63e54239 100644 --- a/services/core/java/com/android/server/wm/TaskPositioningController.java +++ b/services/core/java/com/android/server/wm/TaskPositioningController.java @@ -169,7 +169,7 @@ class TaskPositioningController { mPositioningDisplay = displayContent; mTaskPositioner = TaskPositioner.create(mService); - mTaskPositioner.register(displayContent); + mTaskPositioner.register(displayContent, win); // We need to grab the touch focus so that the touch events during the // resizing/scrolling are not sent to the app. 'win' is the main window @@ -187,7 +187,7 @@ class TaskPositioningController { return false; } - mTaskPositioner.startDrag(win, resize, preserveOrientation, startX, startY); + mTaskPositioner.startDrag(resize, preserveOrientation, startX, startY); return true; } diff --git a/services/core/java/com/android/server/wm/TaskRecord.java b/services/core/java/com/android/server/wm/TaskRecord.java index 672827fbb5ee..56f4d32c6183 100644 --- a/services/core/java/com/android/server/wm/TaskRecord.java +++ b/services/core/java/com/android/server/wm/TaskRecord.java @@ -835,8 +835,8 @@ class TaskRecord extends Task { mNextAffiliateTaskId = nextAffiliate == null ? INVALID_TASK_ID : nextAffiliate.mTaskId; } - <T extends ActivityStack> T getStack() { - return (T) mStack; + ActivityStack getStack() { + return mStack; } // TODO(stack-unify): Can be removed on stack unified. diff --git a/services/core/java/com/android/server/wm/TaskStack.java b/services/core/java/com/android/server/wm/TaskStack.java index 68b76fb14174..e82525ae8c96 100644 --- a/services/core/java/com/android/server/wm/TaskStack.java +++ b/services/core/java/com/android/server/wm/TaskStack.java @@ -84,7 +84,7 @@ import java.io.PrintWriter; import java.util.ArrayList; import java.util.List; -public class TaskStack extends WindowContainer<Task> implements +public class TaskStack extends WindowContainer<TaskRecord> implements BoundsAnimationTarget, ConfigurationContainerListener { /** Minimum size of an adjusted stack bounds relative to original stack bounds. Used to * restrict IME adjustment so that a min portion of top stack remains visible.*/ @@ -102,7 +102,6 @@ public class TaskStack extends WindowContainer<Task> implements private Rect mTmpRect3 = new Rect(); /** For Pinned stack controlling. */ - private Rect mTmpFromBounds = new Rect(); private Rect mTmpToBounds = new Rect(); /** Stack bounds adjusted to screen content area (taking into account IM windows, etc.) */ @@ -489,20 +488,18 @@ public class TaskStack extends WindowContainer<Task> implements * @param position Target position to add the task to. * @param showForAllUsers Whether to show the task regardless of the current user. */ - void addChild(Task task, int position, boolean showForAllUsers, boolean moveParents) { + void addChild(TaskRecord task, int position, boolean showForAllUsers, boolean moveParents) { // Add child task. - task.mStack = this; addChild(task, null); // Move child to a proper position, as some restriction for position might apply. position = positionChildAt( position, task, moveParents /* includingParents */, showForAllUsers); - // TODO(task-merge): Remove cast. - mActivityStack.onChildAdded((TaskRecord) task, position); + mActivityStack.onChildAdded(task, position); } @Override - void addChild(Task task, int position) { + void addChild(TaskRecord task, int position) { addChild(task, position, task.showForAllUsers(), false /* includingParents */); } @@ -520,7 +517,7 @@ public class TaskStack extends WindowContainer<Task> implements getDisplayContent().layoutAndAssignWindowLayersIfNeeded(); } - void positionChildAtTop(Task child, boolean includingParents) { + void positionChildAtTop(TaskRecord child, boolean includingParents) { if (child == null) { // TODO: Fix the call-points that cause this to happen. return; @@ -535,7 +532,7 @@ public class TaskStack extends WindowContainer<Task> implements displayContent.layoutAndAssignWindowLayersIfNeeded(); } - void positionChildAtBottom(Task child, boolean includingParents) { + void positionChildAtBottom(TaskRecord child, boolean includingParents) { if (child == null) { // TODO: Fix the call-points that cause this to happen. return; @@ -550,7 +547,7 @@ public class TaskStack extends WindowContainer<Task> implements } @Override - void positionChildAt(int position, Task child, boolean includingParents) { + void positionChildAt(int position, TaskRecord child, boolean includingParents) { positionChildAt(position, child, includingParents, child.showForAllUsers()); } @@ -559,7 +556,7 @@ public class TaskStack extends WindowContainer<Task> implements * {@link TaskStack#addChild(Task, int, boolean showForAllUsers, boolean)}, as it can receive * showForAllUsers param from {@link ActivityRecord} instead of {@link Task#showForAllUsers()}. */ - int positionChildAt(int position, Task child, boolean includingParents, + int positionChildAt(int position, TaskRecord child, boolean includingParents, boolean showForAllUsers) { final int targetPosition = findPositionForTask(child, position, showForAllUsers); super.positionChildAt(targetPosition, child, includingParents); @@ -666,7 +663,7 @@ public class TaskStack extends WindowContainer<Task> implements * @param task The Task to delete. */ @Override - void removeChild(Task task) { + void removeChild(TaskRecord task) { if (!mChildren.contains(task)) { // Not really in this stack anymore... return; @@ -674,10 +671,8 @@ public class TaskStack extends WindowContainer<Task> implements if (DEBUG_TASK_MOVEMENT) Slog.d(TAG_WM, "removeChild: task=" + task); super.removeChild(task); - task.mStack = null; - // TODO(task-merge): Remove cast. - mActivityStack.onChildRemoved((TaskRecord) task, mDisplayContent); + mActivityStack.onChildRemoved(task, mDisplayContent); } @Override @@ -963,7 +958,7 @@ public class TaskStack extends WindowContainer<Task> implements super.switchUser(); int top = mChildren.size(); for (int taskNdx = 0; taskNdx < top; ++taskNdx) { - Task task = mChildren.get(taskNdx); + TaskRecord task = mChildren.get(taskNdx); if (mWmService.isCurrentProfileLocked(task.mUserId) || task.showForAllUsers()) { mChildren.remove(taskNdx); mChildren.add(task); diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java index ab937e0a4e23..2c56b1124f9f 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -4361,7 +4361,7 @@ public class WindowManagerService extends IWindowManager.Stub final DisplayContent topFocusedDisplay = mRoot.getTopFocusedDisplayContent(); final ActivityRecord focusedApp = topFocusedDisplay.mFocusedApp; return (focusedApp != null && focusedApp.getTask() != null) - ? focusedApp.getTask().mStack : null; + ? focusedApp.getTask().getTaskStack() : null; } public boolean detectSafeMode() { @@ -7657,7 +7657,7 @@ public class WindowManagerService extends IWindowManager.Stub return; } - final TaskStack stack = task.mStack; + final TaskStack stack = task.getTaskStack(); // We ignore home stack since we don't want home stack to move to front when touched. // Specifically, in freeform we don't want tapping on home to cause the freeform apps to go // behind home. See b/117376413 diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java index 344befad8fa9..d196c3425d0d 100644 --- a/services/core/java/com/android/server/wm/WindowState.java +++ b/services/core/java/com/android/server/wm/WindowState.java @@ -1283,7 +1283,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP // notify the client of frame changes in this case. Not only is it a lot of churn, but // the frame may not correspond to the surface size or the onscreen area at various // phases in the animation, and the client will become sad and confused. - if (task != null && task.mStack.isAnimatingBounds()) { + if (task != null && task.getTaskStack().isAnimatingBounds()) { return; } @@ -1423,8 +1423,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP TaskStack getStack() { Task task = getTask(); if (task != null) { - if (task.mStack != null) { - return task.mStack; + if (task.getTaskStack() != null) { + return task.getTaskStack(); } } // Some system windows (e.g. "Power off" dialog) don't have a task, but we would still @@ -1443,7 +1443,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP bounds.setEmpty(); mTmpRect.setEmpty(); if (intersectWithStackBounds) { - final TaskStack stack = task.mStack; + final TaskStack stack = task.getTaskStack(); if (stack != null) { stack.getDimBounds(mTmpRect); } else { @@ -1845,8 +1845,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP final int top = mWindowFrames.mFrame.top; final Task task = getTask(); final boolean adjustedForMinimizedDockOrIme = task != null - && (task.mStack.isAdjustedForMinimizedDockedStack() - || task.mStack.isAdjustedForIme()); + && (task.getTaskStack().isAdjustedForMinimizedDockedStack() + || task.getTaskStack().isAdjustedForIme()); if (mToken.okToAnimate() && (mAttrs.privateFlags & PRIVATE_FLAG_NO_MOVE_ANIMATION) == 0 && !isDragResizing() && !adjustedForMinimizedDockOrIme @@ -1882,7 +1882,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP boolean isObscuringDisplay() { Task task = getTask(); - if (task != null && task.mStack != null && !task.mStack.fillsParent()) { + if (task != null && task.getTaskStack() != null && !task.getTaskStack().fillsParent()) { return false; } return isOpaqueDrawn() && fillsDisplay(); @@ -2301,8 +2301,8 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP void applyAdjustForImeIfNeeded() { final Task task = getTask(); - if (task != null && task.mStack != null && task.mStack.isAdjustedForIme()) { - task.mStack.applyAdjustForImeIfNeeded(task); + if (task != null && task.getTaskStack() != null && task.getTaskStack().isAdjustedForIme()) { + task.getTaskStack().applyAdjustForImeIfNeeded(task); } } @@ -2633,7 +2633,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP return false; } - return mActivityRecord.getTask().mStack.shouldIgnoreInput() + return mActivityRecord.getTask().getTaskStack().shouldIgnoreInput() || mActivityRecord.hiddenRequested || isAnimatingToRecents(); } @@ -3153,7 +3153,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP return; } - final TaskStack stack = task.mStack; + final TaskStack stack = task.getTaskStack(); if (stack == null) { return; } @@ -3167,7 +3167,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP return; } - final TaskStack stack = task.mStack; + final TaskStack stack = task.getTaskStack(); if (stack == null) { return; } diff --git a/services/core/java/com/android/server/wm/WindowStateAnimator.java b/services/core/java/com/android/server/wm/WindowStateAnimator.java index fef3a9d362eb..a853828317c9 100644 --- a/services/core/java/com/android/server/wm/WindowStateAnimator.java +++ b/services/core/java/com/android/server/wm/WindowStateAnimator.java @@ -892,10 +892,10 @@ class WindowStateAnimator { int posX = 0; int posY = 0; - task.mStack.getDimBounds(mTmpStackBounds); + task.getTaskStack().getDimBounds(mTmpStackBounds); boolean allowStretching = false; - task.mStack.getFinalAnimationSourceHintBounds(mTmpSourceBounds); + task.getTaskStack().getFinalAnimationSourceHintBounds(mTmpSourceBounds); // If we don't have source bounds, we can attempt to use the content insets // in the following scenario: // 1. We have content insets. @@ -905,8 +905,8 @@ class WindowStateAnimator { // because of the force-scale until resize state. if (mTmpSourceBounds.isEmpty() && (mWin.mLastRelayoutContentInsets.width() > 0 || mWin.mLastRelayoutContentInsets.height() > 0) - && !task.mStack.lastAnimatingBoundsWasToFullscreen()) { - mTmpSourceBounds.set(task.mStack.mPreAnimationBounds); + && !task.getTaskStack().lastAnimatingBoundsWasToFullscreen()) { + mTmpSourceBounds.set(task.getTaskStack().mPreAnimationBounds); mTmpSourceBounds.inset(mWin.mLastRelayoutContentInsets); allowStretching = true; } @@ -920,7 +920,7 @@ class WindowStateAnimator { if (!mTmpSourceBounds.isEmpty()) { // Get the final target stack bounds, if we are not animating, this is just the // current stack bounds - task.mStack.getFinalAnimationBounds(mTmpAnimatingBounds); + task.getTaskStack().getFinalAnimationBounds(mTmpAnimatingBounds); // Calculate the current progress and interpolate the difference between the target // and source bounds @@ -1499,7 +1499,7 @@ class WindowStateAnimator { */ boolean isForceScaled() { final Task task = mWin.getTask(); - if (task != null && task.mStack.isForceScaled()) { + if (task != null && task.getTaskStack().isForceScaled()) { return true; } return mForceScaleUntilResize; diff --git a/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java b/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java index c5301b8a8c6e..7b9be3d2746b 100644 --- a/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/AppChangeTransitionTests.java @@ -62,7 +62,7 @@ public class AppChangeTransitionTests extends WindowTestsBase { public void setUpOnDisplay(DisplayContent dc) { mActivity = createTestActivityRecord(dc, WINDOWING_MODE_UNDEFINED, ACTIVITY_TYPE_STANDARD); mTask = mActivity.getTask(); - mStack = mTask.mStack; + mStack = mTask.getTaskStack(); // Set a remote animator with snapshot disabled. Snapshots don't work in wmtests. RemoteAnimationDefinition definition = new RemoteAnimationDefinition(); diff --git a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java index 01489c6c8c1b..bd137fb573e2 100644 --- a/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/DisplayContentTests.java @@ -119,7 +119,7 @@ public class DisplayContentTests extends WindowTestsBase { waitUntilHandlersIdle(); exitingApp.mIsExiting = true; - exitingApp.getTask().mStack.mExitingActivities.add(exitingApp); + exitingApp.getTask().getTaskStack().mExitingActivities.add(exitingApp); assertForAllWindowsOrder(Arrays.asList( mWallpaperWindow, diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java index 012eb5252c50..9275512bc719 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskPositionerTests.java @@ -66,7 +66,6 @@ public class TaskPositionerTests extends WindowTestsBase { private int mMinVisibleWidth; private int mMinVisibleHeight; private TaskPositioner mPositioner; - private WindowState mWindow; @Before public void setUp() { @@ -81,17 +80,16 @@ public class TaskPositionerTests extends WindowTestsBase { mMinVisibleHeight = dipToPixel(MINIMUM_VISIBLE_HEIGHT_IN_DP, dm); removeGlobalMinSizeRestriction(); + WindowState win = createWindow(null, TYPE_BASE_APPLICATION, "window"); mPositioner = new TaskPositioner(mWm, mWm.mAtmService); - mPositioner.register(mDisplayContent); - mWindow = createWindow(null, TYPE_BASE_APPLICATION, "window"); - mPositioner.mTask = mWindow.getTask(); - mWindow.getStack().setWindowingMode(WINDOWING_MODE_FREEFORM); + mPositioner.register(mDisplayContent, win); + + win.getStack().setWindowingMode(WINDOWING_MODE_FREEFORM); } @After public void tearDown() { - mWindow = null; mPositioner = null; } @@ -122,8 +120,8 @@ public class TaskPositionerTests extends WindowTestsBase { mPositioner.mTask.setBounds(r, true); // Start a drag resize starting upper left. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, + r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); assertBoundsEquals(r, mPositioner.getWindowDragBounds()); // Drag to a good landscape size. @@ -149,8 +147,8 @@ public class TaskPositionerTests extends WindowTestsBase { mPositioner.getWindowDragBounds()); // Start a drag resize left and see that only the left coord changes.. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, r.left - MOUSE_DELTA_X, midY); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, + r.left - MOUSE_DELTA_X, midY); // Drag to the left. mPositioner.resizeDrag(0.0f, midY); @@ -184,8 +182,8 @@ public class TaskPositionerTests extends WindowTestsBase { mPositioner.mTask.setBounds(r, true); // Drag upper left. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, + r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); mPositioner.resizeDrag(0.0f, 0.0f); assertNotEquals(r.left, mPositioner.getWindowDragBounds().left); assertEquals(r.right, mPositioner.getWindowDragBounds().right); @@ -193,8 +191,8 @@ public class TaskPositionerTests extends WindowTestsBase { assertEquals(r.bottom, mPositioner.getWindowDragBounds().bottom); // Drag upper. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, midX, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, midX, + r.top - MOUSE_DELTA_Y); mPositioner.resizeDrag(0.0f, 0.0f); assertEquals(r.left, mPositioner.getWindowDragBounds().left); assertEquals(r.right, mPositioner.getWindowDragBounds().right); @@ -202,8 +200,8 @@ public class TaskPositionerTests extends WindowTestsBase { assertEquals(r.bottom, mPositioner.getWindowDragBounds().bottom); // Drag upper right. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, r.right + MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, + r.right + MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); mPositioner.resizeDrag(r.right + 100, 0.0f); assertEquals(r.left, mPositioner.getWindowDragBounds().left); assertNotEquals(r.right, mPositioner.getWindowDragBounds().right); @@ -211,8 +209,8 @@ public class TaskPositionerTests extends WindowTestsBase { assertEquals(r.bottom, mPositioner.getWindowDragBounds().bottom); // Drag right. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, r.right + MOUSE_DELTA_X, midY); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, + r.right + MOUSE_DELTA_X, midY); mPositioner.resizeDrag(r.right + 100, 0.0f); assertEquals(r.left, mPositioner.getWindowDragBounds().left); assertNotEquals(r.right, mPositioner.getWindowDragBounds().right); @@ -220,8 +218,7 @@ public class TaskPositionerTests extends WindowTestsBase { assertEquals(r.bottom, mPositioner.getWindowDragBounds().bottom); // Drag bottom right. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, r.right + MOUSE_DELTA_X, r.bottom + MOUSE_DELTA_Y); mPositioner.resizeDrag(r.right + 100, r.bottom + 100); assertEquals(r.left, mPositioner.getWindowDragBounds().left); @@ -230,8 +227,8 @@ public class TaskPositionerTests extends WindowTestsBase { assertNotEquals(r.bottom, mPositioner.getWindowDragBounds().bottom); // Drag bottom. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, midX, r.bottom + MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, midX, + r.bottom + MOUSE_DELTA_Y); mPositioner.resizeDrag(r.right + 100, r.bottom + 100); assertEquals(r.left, mPositioner.getWindowDragBounds().left); assertEquals(r.right, mPositioner.getWindowDragBounds().right); @@ -239,8 +236,8 @@ public class TaskPositionerTests extends WindowTestsBase { assertNotEquals(r.bottom, mPositioner.getWindowDragBounds().bottom); // Drag bottom left. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, r.left - MOUSE_DELTA_X, r.bottom + MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, + r.left - MOUSE_DELTA_X, r.bottom + MOUSE_DELTA_Y); mPositioner.resizeDrag(0.0f, r.bottom + 100); assertNotEquals(r.left, mPositioner.getWindowDragBounds().left); assertEquals(r.right, mPositioner.getWindowDragBounds().right); @@ -248,8 +245,8 @@ public class TaskPositionerTests extends WindowTestsBase { assertNotEquals(r.bottom, mPositioner.getWindowDragBounds().bottom); // Drag left. - mPositioner.startDrag(mWindow, true /* resizing */, - false /* preserveOrientation */, r.left - MOUSE_DELTA_X, midY); + mPositioner.startDrag(true /* resizing */, false /* preserveOrientation */, + r.left - MOUSE_DELTA_X, midY); mPositioner.resizeDrag(0.0f, r.bottom + 100); assertNotEquals(r.left, mPositioner.getWindowDragBounds().left); assertEquals(r.right, mPositioner.getWindowDragBounds().right); @@ -266,8 +263,8 @@ public class TaskPositionerTests extends WindowTestsBase { final Rect r = new Rect(100, 220, 700, 520); mPositioner.mTask.setBounds(r, true); - mPositioner.startDrag(mWindow, true /* resizing */, - true /* preserveOrientation */, r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, true /* preserveOrientation */, + r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); assertBoundsEquals(r, mPositioner.getWindowDragBounds()); // Drag to a good landscape size. @@ -305,8 +302,8 @@ public class TaskPositionerTests extends WindowTestsBase { final int midY = (r.top + r.bottom) / 2; mPositioner.mTask.setBounds(r, true); - mPositioner.startDrag(mWindow, true /* resizing */, - true /* preserveOrientation */, r.left - MOUSE_DELTA_X, midY); + mPositioner.startDrag(true /* resizing */, true /* preserveOrientation */, + r.left - MOUSE_DELTA_X, midY); // Drag to the left. mPositioner.resizeDrag(0.0f, midY); @@ -346,8 +343,8 @@ public class TaskPositionerTests extends WindowTestsBase { final int midX = (r.left + r.right) / 2; mPositioner.mTask.setBounds(r, true); - mPositioner.startDrag(mWindow, true /*resizing*/, - true /*preserveOrientation*/, midX, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /*resizing*/, true /*preserveOrientation*/, midX, + r.top - MOUSE_DELTA_Y); // Drag to the left (no change). mPositioner.resizeDrag(0.0f, r.top); @@ -382,8 +379,8 @@ public class TaskPositionerTests extends WindowTestsBase { final Rect r = new Rect(330, 100, 630, 600); mPositioner.mTask.setBounds(r, true); - mPositioner.startDrag(mWindow, true /*resizing*/, - true /*preserveOrientation*/, r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /*resizing*/, true /*preserveOrientation*/, + r.left - MOUSE_DELTA_X, r.top - MOUSE_DELTA_Y); assertBoundsEquals(r, mPositioner.getWindowDragBounds()); // Drag to a good landscape size. @@ -416,8 +413,8 @@ public class TaskPositionerTests extends WindowTestsBase { final int midY = (r.top + r.bottom) / 2; mPositioner.mTask.setBounds(r, true); - mPositioner.startDrag(mWindow, true /* resizing */, - true /* preserveOrientation */, r.left - MOUSE_DELTA_X, midY); + mPositioner.startDrag(true /* resizing */, true /* preserveOrientation */, + r.left - MOUSE_DELTA_X, midY); // Drag to the left. mPositioner.resizeDrag(0.0f, midY); @@ -459,8 +456,8 @@ public class TaskPositionerTests extends WindowTestsBase { final int midX = (r.left + r.right) / 2; mPositioner.mTask.setBounds(r, true); - mPositioner.startDrag(mWindow, true /* resizing */, - true /* preserveOrientation */, midX, r.top - MOUSE_DELTA_Y); + mPositioner.startDrag(true /* resizing */, true /* preserveOrientation */, midX, + r.top - MOUSE_DELTA_Y); // Drag to the left (no change). mPositioner.resizeDrag(0.0f, r.top); @@ -502,7 +499,7 @@ public class TaskPositionerTests extends WindowTestsBase { public void testFinishingMovingWhenBinderDied() { spyOn(mWm.mTaskPositioningController); - mPositioner.startDrag(mWindow, false, false, 0 /* startX */, 0 /* startY */); + mPositioner.startDrag(false, false, 0 /* startX */, 0 /* startY */); verify(mWm.mTaskPositioningController, never()).finishTaskPositioning(); mPositioner.binderDied(); verify(mWm.mTaskPositioningController).finishTaskPositioning(); diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskStackContainersTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskStackContainersTests.java index a66c79ced83c..78970479228c 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskStackContainersTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskStackContainersTests.java @@ -121,7 +121,7 @@ public class TaskStackContainersTests extends WindowTestsBase { false /* includingParents */); // Move the task of {@code mDisplayContent} to top. - stack.positionChildAt(WindowContainer.POSITION_TOP, task, true /* includingParents */); + stack.positionChildAt(WindowContainer.POSITION_TOP, (TaskRecord) task, true /* includingParents */); final int indexOfDisplayWithPinnedStack = mWm.mRoot.mChildren.indexOf(mDisplayContent); assertEquals("The testing DisplayContent should be moved to top with task", diff --git a/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java b/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java index 164d28d57cb0..a9d0ea11f21f 100644 --- a/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java +++ b/services/tests/wmtests/src/com/android/server/wm/TaskStackTests.java @@ -58,12 +58,12 @@ public class TaskStackTests extends WindowTestsBase { final Task task2 = createTaskInStack(stack, 1 /* userId */); // Current user task should be moved to top. - stack.positionChildAt(WindowContainer.POSITION_TOP, task1, false /* includingParents */); + stack.positionChildAt(WindowContainer.POSITION_TOP, (TaskRecord) task1, false /* includingParents */); assertEquals(stack.mChildren.get(0), task2); assertEquals(stack.mChildren.get(1), task1); // Non-current user won't be moved to top. - stack.positionChildAt(WindowContainer.POSITION_TOP, task2, false /* includingParents */); + stack.positionChildAt(WindowContainer.POSITION_TOP, (TaskRecord) task2, false /* includingParents */); assertEquals(stack.mChildren.get(0), task2); assertEquals(stack.mChildren.get(1), task1); } @@ -112,12 +112,12 @@ public class TaskStackTests extends WindowTestsBase { public void testStackRemoveImmediately() { final TaskStack stack = createTaskStackOnDisplay(mDisplayContent); final Task task = createTaskInStack(stack, 0 /* userId */); - assertEquals(stack, task.mStack); + assertEquals(stack, task.getTaskStack()); // Remove stack and check if its child is also removed. stack.removeImmediately(); assertNull(stack.getDisplayContent()); - assertNull(task.mStack); + assertNull(task.getTaskStack()); } @Test @@ -133,7 +133,7 @@ public class TaskStackTests extends WindowTestsBase { assertEquals(0, stack.getChildCount()); assertNull(stack.getDisplayContent()); assertNull(task.getDisplayContent()); - assertNull(task.mStack); + assertNull(task.getTaskStack()); } @Test diff --git a/tests/RollbackTest/RollbackTest/src/com/android/tests/rollback/StagedRollbackTest.java b/tests/RollbackTest/RollbackTest/src/com/android/tests/rollback/StagedRollbackTest.java index 8f36b6e95c32..06be5e2a0b9d 100644 --- a/tests/RollbackTest/RollbackTest/src/com/android/tests/rollback/StagedRollbackTest.java +++ b/tests/RollbackTest/RollbackTest/src/com/android/tests/rollback/StagedRollbackTest.java @@ -251,11 +251,11 @@ public class StagedRollbackTest { @Test public void testNetworkFailedRollback_Phase3() throws Exception { - // Sleep for > health check deadline + // Sleep for > health check deadline (120s to trigger rollback + 120s to reboot) // The device is expected to reboot during sleeping. This device method will fail and // the host will catch the assertion. If reboot doesn't happen, the host will fail the // assertion. - Thread.sleep(TimeUnit.SECONDS.toMillis(120)); + Thread.sleep(TimeUnit.SECONDS.toMillis(240)); } @Test diff --git a/tests/RollbackTest/StagedRollbackTest/src/com/android/tests/rollback/host/StagedRollbackTest.java b/tests/RollbackTest/StagedRollbackTest/src/com/android/tests/rollback/host/StagedRollbackTest.java index bfd5dd5a33de..557d498ce8ee 100644 --- a/tests/RollbackTest/StagedRollbackTest/src/com/android/tests/rollback/host/StagedRollbackTest.java +++ b/tests/RollbackTest/StagedRollbackTest/src/com/android/tests/rollback/host/StagedRollbackTest.java @@ -22,6 +22,7 @@ import static org.testng.Assert.assertThrows; import com.android.tradefed.testtype.DeviceJUnit4ClassRunner; import com.android.tradefed.testtype.junit4.BaseHostJUnit4Test; +import org.junit.Before; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; @@ -47,6 +48,11 @@ public class StagedRollbackTest extends BaseHostJUnit4Test { phase)); } + @Before + public void setUp() throws Exception { + getDevice().reboot(); + } + /** * Tests watchdog triggered staged rollbacks involving only apks. */ diff --git a/tools/apilint/apilint b/tools/apilint/apilint deleted file mode 100755 index e42857f1a190..000000000000 --- a/tools/apilint/apilint +++ /dev/null @@ -1,147 +0,0 @@ -#!/bin/bash - -# Copyright (C) 2019 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the 'License'); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an 'AS IS' BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -if [ "$1" == "--help" -o "$1" == "-h" ]; then -echo "Usage: apilint [FILTERS...]" -echo " Shows lint from currently open files (as diffed from HEAD), i.e. errors" -echo " you will receive if you upload this CL." -echo -echo "Usage: apilint --all [FILTERS...]" -echo " Shows all lint errors present in the current working directory, regardless" -echo " of when they were added." -echo -echo "Usage: apilint --level API_LEVEL [FILTERS...]" -echo " Shows lint as it stands in API_LEVEL" -echo -echo "Usage: apilint --shal SHA [FILTERS...]" -echo " Shows lint from locally commited git change SHA." -echo -echo "Usage: apilint --unreleased [FILTERS...]" -echo " Shows all lint errors in the current working directory directory added since" -echo " the last released SDK version." -echo -echo "FILTERS" -echo " List of class or package names by which to filter the results." -echo -exit -fi - -if [ \( -z "$ANDROID_BUILD_TOP" \) \ - -a \( ! -f frameworks/base/api/current.txt \) \ - -a \( ! -f frameworks/base/api/system-current.txt \) \ - ]; then - echo "apilint must be run either with ANDROID_BUILD_TOP set or from the" 1>&2 - echo "root of the android source tree" 1>&2 - exit 1 -fi - -if [ ${ANDROID_BUILD_TOP:0:1} != "/" ]; then - echo "ANDROID_BUILD_TOP must be an absolute path, not: $ANDROID_BUILD_TOP" 1>&2 - exit 1 -fi - -if [ -z "$ANDROID_BUILD_TOP" ]; then - ANDROID_BUILD_TOP=$(pwd) -fi - -FW_BASE=$ANDROID_BUILD_TOP/frameworks/base - -MODE=open - -OPTIONS=$(getopt -n apilint -o "" -l "all,sha:,unreleased" -- "$@") - -[ $? -eq 0 ] || { - exit 1 -} - -eval set -- "$OPTIONS" -while true; do - case "$1" in - --all) - MODE=all - ;; - --sha) - shift; # The arg is next in position args - MODE=sha - SHA=$1 - ;; - --unreleased) - MODE=unreleased - ;; - --) - shift - break - ;; - esac - shift -done -FILTERS= -for var in "$@" -do - FILTERS="$FILTERS --filter $var" -done - -if [ $MODE = "all" ]; then - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SDK" \ - $FILTERS \ - $ANDROID_BUILD_TOP/frameworks/base/api/current.txt - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SystemApi" \ - $FILTERS \ - --base-current $ANDROID_BUILD_TOP/frameworks/base/api/current.txt \ - $ANDROID_BUILD_TOP/frameworks/base/api/system-current.txt -elif [ $MODE = "open" ]; then - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SDK" \ - $FILTERS \ - $ANDROID_BUILD_TOP/frameworks/base/api/current.txt \ - <(cd $FW_BASE ; git show HEAD:api/current.txt) - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SystemApi" \ - $FILTERS \ - --base-current $ANDROID_BUILD_TOP/frameworks/base/api/current.txt \ - --base-previous <(cd $FW_BASE ; git show HEAD:api/current.txt) \ - $ANDROID_BUILD_TOP/frameworks/base/api/system-current.txt \ - <(cd $FW_BASE ; git show HEAD:api/system-current.txt) -elif [ $MODE = "sha" ]; then - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SDK" \ - $FILTERS \ - <(cd $FW_BASE ; git show $SHA:api/current.txt) \ - <(cd $FW_BASE ; git show $SHA^:api/current.txt) - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SystemApi" \ - $FILTERS \ - --base-current <(cd $FW_BASE ; git show $SHA:api/current.txt) \ - --base-previous <(cd $FW_BASE ; git show $SHA^:api/current.txt) \ - <(cd $FW_BASE ; git show $SHA:api/system-current.txt) \ - <(cd $FW_BASE ; git show $SHA^:api/system-current.txt) -elif [ $MODE = "unreleased" ]; then - LAST_SDK=$(ls $ANDROID_BUILD_TOP/prebuilts/sdk | grep "^[0-9][0-9]*$" | sort -n | tail -n 1) - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SDK" \ - $FILTERS \ - $ANDROID_BUILD_TOP/frameworks/base/api/current.txt \ - $ANDROID_BUILD_TOP/prebuilts/sdk/$LAST_SDK/public/api/android.txt - python2.7 -B $ANDROID_BUILD_TOP/frameworks/base/tools/apilint/apilint.py \ - --title "SystemApi" \ - $FILTERS \ - --base-current $ANDROID_BUILD_TOP/frameworks/base/api/current.txt \ - --base-previous $ANDROID_BUILD_TOP/prebuilts/sdk/$LAST_SDK/public/api/android.txt \ - $ANDROID_BUILD_TOP/frameworks/base/api/system-current.txt \ - $ANDROID_BUILD_TOP/prebuilts/sdk/$LAST_SDK/system/api/android.txt -fi diff --git a/tools/apilint/apilint.py b/tools/apilint/apilint.py deleted file mode 100644 index 912c1ad377c1..000000000000 --- a/tools/apilint/apilint.py +++ /dev/null @@ -1,2353 +0,0 @@ -#!/usr/bin/env python - -# Copyright (C) 2014 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the 'License'); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an 'AS IS' BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -""" -Enforces common Android public API design patterns. It ignores lint messages from -a previous API level, if provided. - -Usage: apilint.py current.txt -Usage: apilint.py current.txt previous.txt - -You can also splice in blame details like this: -$ git blame api/current.txt -t -e > /tmp/currentblame.txt -$ apilint.py /tmp/currentblame.txt previous.txt --no-color -""" - -import re, sys, collections, traceback, argparse, itertools - - -BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8) - -ALLOW_GOOGLE = False -USE_COLOR = True - -def format(fg=None, bg=None, bright=False, bold=False, dim=False, reset=False): - # manually derived from http://en.wikipedia.org/wiki/ANSI_escape_code#Codes - if not USE_COLOR: return "" - codes = [] - if reset: codes.append("0") - else: - if not fg is None: codes.append("3%d" % (fg)) - if not bg is None: - if not bright: codes.append("4%d" % (bg)) - else: codes.append("10%d" % (bg)) - if bold: codes.append("1") - elif dim: codes.append("2") - else: codes.append("22") - return "\033[%sm" % (";".join(codes)) - - -class Field(): - def __init__(self, clazz, line, raw, blame, sig_format = 1): - self.clazz = clazz - self.line = line - self.raw = raw.strip(" {;") - self.blame = blame - - if sig_format == 2: - V2LineParser(raw).parse_into_field(self) - elif sig_format == 1: - # drop generics for now; may need multiple passes - raw = re.sub("<[^<]+?>", "", raw) - raw = re.sub("<[^<]+?>", "", raw) - - raw = raw.split() - self.split = list(raw) - - for r in ["field", "volatile", "transient", "public", "protected", "static", "final", "deprecated"]: - while r in raw: raw.remove(r) - - # ignore annotations for now - raw = [ r for r in raw if not r.startswith("@") ] - - self.typ = raw[0] - self.name = raw[1].strip(";") - if len(raw) >= 4 and raw[2] == "=": - self.value = raw[3].strip(';"') - else: - self.value = None - self.annotations = [] - - self.ident = "-".join((self.typ, self.name, self.value or "")) - - def __hash__(self): - return hash(self.raw) - - def __repr__(self): - return self.raw - - -class Argument(object): - - __slots__ = ["type", "annotations", "name", "default"] - - def __init__(self, type): - self.type = type - self.annotations = [] - self.name = None - self.default = None - - -class Method(): - def __init__(self, clazz, line, raw, blame, sig_format = 1): - self.clazz = clazz - self.line = line - self.raw = raw.strip(" {;") - self.blame = blame - - if sig_format == 2: - V2LineParser(raw).parse_into_method(self) - elif sig_format == 1: - # drop generics for now; may need multiple passes - raw = re.sub("<[^<]+?>", "", raw) - raw = re.sub("<[^<]+?>", "", raw) - - # handle each clause differently - raw_prefix, raw_args, _, raw_throws = re.match(r"(.*?)\((.*?)\)( throws )?(.*?);$", raw).groups() - - # parse prefixes - raw = re.split("[\s]+", raw_prefix) - for r in ["", ";"]: - while r in raw: raw.remove(r) - self.split = list(raw) - - for r in ["method", "public", "protected", "static", "final", "deprecated", "abstract", "default", "operator", "synchronized"]: - while r in raw: raw.remove(r) - - self.typ = raw[0] - self.name = raw[1] - - # parse args - self.detailed_args = [] - for arg in re.split(",\s*", raw_args): - arg = re.split("\s", arg) - # ignore annotations for now - arg = [ a for a in arg if not a.startswith("@") ] - if len(arg[0]) > 0: - self.detailed_args.append(Argument(arg[0])) - - # parse throws - self.throws = [] - for throw in re.split(",\s*", raw_throws): - self.throws.append(throw) - - self.annotations = [] - else: - raise ValueError("Unknown signature format: " + sig_format) - - self.args = map(lambda a: a.type, self.detailed_args) - self.ident = "-".join((self.typ, self.name, "-".join(self.args))) - - def sig_matches(self, typ, name, args): - return typ == self.typ and name == self.name and args == self.args - - def __hash__(self): - return hash(self.raw) - - def __repr__(self): - return self.raw - - -class Class(): - def __init__(self, pkg, line, raw, blame, sig_format = 1): - self.pkg = pkg - self.line = line - self.raw = raw.strip(" {;") - self.blame = blame - self.ctors = [] - self.fields = [] - self.methods = [] - self.annotations = [] - - if sig_format == 2: - V2LineParser(raw).parse_into_class(self) - elif sig_format == 1: - # drop generics for now; may need multiple passes - raw = re.sub("<[^<]+?>", "", raw) - raw = re.sub("<[^<]+?>", "", raw) - - raw = raw.split() - self.split = list(raw) - if "class" in raw: - self.fullname = raw[raw.index("class")+1] - elif "interface" in raw: - self.fullname = raw[raw.index("interface")+1] - elif "@interface" in raw: - self.fullname = raw[raw.index("@interface")+1] - else: - raise ValueError("Funky class type %s" % (self.raw)) - - if "extends" in raw: - self.extends = raw[raw.index("extends")+1] - else: - self.extends = None - - if "implements" in raw: - self.implements = raw[raw.index("implements")+1] - self.implements_all = [self.implements] - else: - self.implements = None - self.implements_all = [] - else: - raise ValueError("Unknown signature format: " + sig_format) - - self.fullname = self.pkg.name + "." + self.fullname - self.fullname_path = self.fullname.split(".") - - if self.extends is not None: - self.extends_path = self.extends.split(".") - else: - self.extends_path = [] - - self.name = self.fullname[self.fullname.rindex(".")+1:] - - def merge_from(self, other): - self.ctors.extend(other.ctors) - self.fields.extend(other.fields) - self.methods.extend(other.methods) - - def __hash__(self): - return hash((self.raw, tuple(self.ctors), tuple(self.fields), tuple(self.methods))) - - def __repr__(self): - return self.raw - - -class Package(): - NAME = re.compile("package(?: .*)? ([A-Za-z0-9.]+)") - - def __init__(self, line, raw, blame): - self.line = line - self.raw = raw.strip(" {;") - self.blame = blame - - self.name = Package.NAME.match(raw).group(1) - self.name_path = self.name.split(".") - - def __repr__(self): - return self.raw - -class V2Tokenizer(object): - __slots__ = ["raw"] - - SIGNATURE_PREFIX = "// Signature format: " - DELIMITER = re.compile(r'\s+|[()@<>;,={}/"!?]|\[\]|\.\.\.') - STRING_SPECIAL = re.compile(r'["\\]') - - def __init__(self, raw): - self.raw = raw - - def tokenize(self): - tokens = [] - current = 0 - raw = self.raw - length = len(raw) - - while current < length: - while current < length: - start = current - match = V2Tokenizer.DELIMITER.search(raw, start) - if match is not None: - match_start = match.start() - if match_start == current: - end = match.end() - else: - end = match_start - else: - end = length - - token = raw[start:end] - current = end - - if token == "" or token[0] == " ": - continue - else: - break - - if token == "@": - if raw[start:start+11] == "@interface ": - current = start + 11 - tokens.append("@interface") - continue - elif token == '/': - if raw[start:start+2] == "//": - current = length - continue - elif token == '"': - current, string_token = self.tokenize_string(raw, length, current) - tokens.append(token + string_token) - continue - - tokens.append(token) - - return tokens - - def tokenize_string(self, raw, length, current): - start = current - end = length - while start < end: - match = V2Tokenizer.STRING_SPECIAL.search(raw, start) - if match: - if match.group() == '"': - end = match.end() - break - elif match.group() == '\\': - # ignore whatever is after the slash - start += 2 - else: - raise ValueError("Unexpected match: `%s`" % (match.group())) - else: - raise ValueError("Unexpected EOF tokenizing string: `%s`" % (raw[current - 1:],)) - - token = raw[current:end] - return end, token - -class V2LineParser(object): - __slots__ = ["tokenized", "current", "len"] - - FIELD_KINDS = ("field", "property", "enum_constant") - MODIFIERS = set("public protected internal private abstract default static final transient volatile synchronized native operator sealed strictfp infix inline suspend vararg".split()) - JAVA_LANG_TYPES = set("AbstractMethodError AbstractStringBuilder Appendable ArithmeticException ArrayIndexOutOfBoundsException ArrayStoreException AssertionError AutoCloseable Boolean BootstrapMethodError Byte Character CharSequence Class ClassCastException ClassCircularityError ClassFormatError ClassLoader ClassNotFoundException Cloneable CloneNotSupportedException Comparable Compiler Deprecated Double Enum EnumConstantNotPresentException Error Exception ExceptionInInitializerError Float FunctionalInterface IllegalAccessError IllegalAccessException IllegalArgumentException IllegalMonitorStateException IllegalStateException IllegalThreadStateException IncompatibleClassChangeError IndexOutOfBoundsException InheritableThreadLocal InstantiationError InstantiationException Integer InternalError InterruptedException Iterable LinkageError Long Math NegativeArraySizeException NoClassDefFoundError NoSuchFieldError NoSuchFieldException NoSuchMethodError NoSuchMethodException NullPointerException Number NumberFormatException Object OutOfMemoryError Override Package package-info.java Process ProcessBuilder ProcessEnvironment ProcessImpl Readable ReflectiveOperationException Runnable Runtime RuntimeException RuntimePermission SafeVarargs SecurityException SecurityManager Short StackOverflowError StackTraceElement StrictMath String StringBuffer StringBuilder StringIndexOutOfBoundsException SuppressWarnings System Thread ThreadDeath ThreadGroup ThreadLocal Throwable TypeNotPresentException UNIXProcess UnknownError UnsatisfiedLinkError UnsupportedClassVersionError UnsupportedOperationException VerifyError VirtualMachineError Void".split()) - - def __init__(self, raw): - self.tokenized = V2Tokenizer(raw).tokenize() - self.current = 0 - self.len = len(self.tokenized) - - def parse_into_method(self, method): - method.split = [] - kind = self.parse_one_of("ctor", "method") - method.split.append(kind) - method.annotations = self.parse_annotations() - method.split.extend(self.parse_modifiers()) - self.parse_matching_paren("<", ">") - if "@Deprecated" in method.annotations: - method.split.append("deprecated") - if kind == "ctor": - method.typ = "ctor" - else: - method.typ = self.parse_type() - method.split.append(method.typ) - method.name = self.parse_name() - method.split.append(method.name) - self.parse_token("(") - method.detailed_args = self.parse_args() - self.parse_token(")") - method.throws = self.parse_throws() - if "@interface" in method.clazz.split: - self.parse_annotation_default() - self.parse_token(";") - self.parse_eof() - - def parse_into_class(self, clazz): - clazz.split = [] - clazz.annotations = self.parse_annotations() - if "@Deprecated" in clazz.annotations: - clazz.split.append("deprecated") - clazz.split.extend(self.parse_modifiers()) - kind = self.parse_one_of("class", "interface", "@interface", "enum") - if kind == "enum": - # enums are implicitly final - clazz.split.append("final") - clazz.split.append(kind) - clazz.fullname = self.parse_name() - self.parse_matching_paren("<", ">") - extends = self.parse_extends() - clazz.extends = extends[0] if extends else None - clazz.implements_all = self.parse_implements() - # The checks assume that interfaces are always found in implements, which isn't true for - # subinterfaces. - if not clazz.implements_all and "interface" in clazz.split: - clazz.implements_all = [clazz.extends] - clazz.implements = clazz.implements_all[0] if clazz.implements_all else None - self.parse_token("{") - self.parse_eof() - - def parse_into_field(self, field): - kind = self.parse_one_of(*V2LineParser.FIELD_KINDS) - field.split = [kind] - field.annotations = self.parse_annotations() - if "@Deprecated" in field.annotations: - field.split.append("deprecated") - field.split.extend(self.parse_modifiers()) - field.typ = self.parse_type() - field.split.append(field.typ) - field.name = self.parse_name() - field.split.append(field.name) - if self.parse_if("="): - field.value = self.parse_value_stripped() - else: - field.value = None - - self.parse_token(";") - self.parse_eof() - - def lookahead(self): - return self.tokenized[self.current] - - def parse_one_of(self, *options): - found = self.lookahead() - if found not in options: - raise ValueError("Parsing failed, expected one of `%s` but found `%s` in %s" % (options, found, repr(self.tokenized))) - return self.parse_token() - - def parse_token(self, tok = None): - found = self.lookahead() - if tok is not None and found != tok: - raise ValueError("Parsing failed, expected `%s` but found `%s` in %s" % (tok, found, repr(self.tokenized))) - self.current += 1 - return found - - def eof(self): - return self.current == self.len - - def parse_eof(self): - if not self.eof(): - raise ValueError("Parsing failed, expected EOF, but %s has not been parsed in %s" % (self.tokenized[self.current:], self.tokenized)) - - def parse_if(self, tok): - if not self.eof() and self.lookahead() == tok: - self.parse_token() - return True - return False - - def parse_annotations(self): - ret = [] - while self.lookahead() == "@": - ret.append(self.parse_annotation()) - return ret - - def parse_annotation(self): - ret = self.parse_token("@") + self.parse_token() - self.parse_matching_paren("(", ")") - return ret - - def parse_matching_paren(self, open, close): - start = self.current - if not self.parse_if(open): - return - length = len(self.tokenized) - count = 1 - while count > 0: - if self.current == length: - raise ValueError("Unexpected EOF looking for closing paren: `%s`" % (self.tokenized[start:],)) - t = self.parse_token() - if t == open: - count += 1 - elif t == close: - count -= 1 - return self.tokenized[start:self.current] - - def parse_modifiers(self): - ret = [] - while self.lookahead() in V2LineParser.MODIFIERS: - ret.append(self.parse_token()) - return ret - - def parse_kotlin_nullability(self): - t = self.lookahead() - if t == "?" or t == "!": - return self.parse_token() - return None - - def parse_type(self): - self.parse_annotations() - type = self.parse_token() - if type[-1] == '.': - self.parse_annotations() - type += self.parse_token() - if type in V2LineParser.JAVA_LANG_TYPES: - type = "java.lang." + type - self.parse_matching_paren("<", ">") - while True: - t = self.lookahead() - if t == "@": - self.parse_annotation() - elif t == "[]": - type += self.parse_token() - elif self.parse_kotlin_nullability() is not None: - pass # discard nullability for now - else: - break - return type - - def parse_arg_type(self): - type = self.parse_type() - if self.parse_if("..."): - type += "..." - self.parse_kotlin_nullability() # discard nullability for now - return type - - def parse_name(self): - return self.parse_token() - - def parse_args(self): - args = [] - if self.lookahead() == ")": - return args - - while True: - args.append(self.parse_arg()) - if self.lookahead() == ")": - return args - self.parse_token(",") - - def parse_arg(self): - self.parse_if("vararg") # kotlin vararg - annotations = self.parse_annotations() - arg = Argument(self.parse_arg_type()) - arg.annotations = annotations - l = self.lookahead() - if l != "," and l != ")": - if self.lookahead() != '=': - arg.name = self.parse_token() # kotlin argument name - if self.parse_if('='): # kotlin default value - arg.default = self.parse_expression() - return arg - - def parse_expression(self): - while not self.lookahead() in [')', ',', ';']: - (self.parse_matching_paren('(', ')') or - self.parse_matching_paren('{', '}') or - self.parse_token()) - - def parse_throws(self): - ret = [] - if self.parse_if("throws"): - ret.append(self.parse_type()) - while self.parse_if(","): - ret.append(self.parse_type()) - return ret - - def parse_extends(self): - if self.parse_if("extends"): - return self.parse_space_delimited_type_list() - return [] - - def parse_implements(self): - if self.parse_if("implements"): - return self.parse_space_delimited_type_list() - return [] - - def parse_space_delimited_type_list(self, terminals = ["implements", "{"]): - types = [] - while True: - types.append(self.parse_type()) - if self.lookahead() in terminals: - return types - - def parse_annotation_default(self): - if self.parse_if("default"): - self.parse_expression() - - def parse_value(self): - if self.lookahead() == "{": - return " ".join(self.parse_matching_paren("{", "}")) - elif self.lookahead() == "(": - return " ".join(self.parse_matching_paren("(", ")")) - else: - return self.parse_token() - - def parse_value_stripped(self): - value = self.parse_value() - if value[0] == '"': - return value[1:-1] - return value - - -def _parse_stream(f, clazz_cb=None, base_f=None, out_classes_with_base=None, - in_classes_with_base=[]): - api = {} - in_classes_with_base = _retry_iterator(in_classes_with_base) - - if base_f: - base_classes = _retry_iterator(_parse_stream_to_generator(base_f)) - else: - base_classes = [] - - def handle_class(clazz): - if clazz_cb: - clazz_cb(clazz) - else: # In callback mode, don't keep track of the full API - api[clazz.fullname] = clazz - - def handle_missed_classes_with_base(clazz): - for c in _yield_until_matching_class(in_classes_with_base, clazz): - base_class = _skip_to_matching_class(base_classes, c) - if base_class: - handle_class(base_class) - - for clazz in _parse_stream_to_generator(f): - # Before looking at clazz, let's see if there's some classes that were not present, but - # may have an entry in the base stream. - handle_missed_classes_with_base(clazz) - - base_class = _skip_to_matching_class(base_classes, clazz) - if base_class: - clazz.merge_from(base_class) - if out_classes_with_base is not None: - out_classes_with_base.append(clazz) - handle_class(clazz) - - handle_missed_classes_with_base(None) - - return api - -def _parse_stream_to_generator(f): - line = 0 - pkg = None - clazz = None - blame = None - sig_format = 1 - - re_blame = re.compile(r"^(\^?[a-z0-9]{7,}) \(<([^>]+)>.+?\) (.+?)$") - - field_prefixes = map(lambda kind: " %s" % (kind,), V2LineParser.FIELD_KINDS) - def startsWithFieldPrefix(raw): - for prefix in field_prefixes: - if raw.startswith(prefix): - return True - return False - - for raw in f: - line += 1 - raw = raw.rstrip() - match = re_blame.match(raw) - if match is not None: - blame = match.groups()[0:2] - if blame[0].startswith("^"): # Outside of blame range - blame = None - raw = match.groups()[2] - else: - blame = None - - if line == 1 and V2Tokenizer.SIGNATURE_PREFIX in raw: - sig_format_string = raw[len(V2Tokenizer.SIGNATURE_PREFIX):] - if sig_format_string in ["2.0", "3.0"]: - sig_format = 2 - else: - raise ValueError("Unknown format: %s" % (sig_format_string,)) - elif raw.startswith("package"): - pkg = Package(line, raw, blame) - elif raw.startswith(" ") and raw.endswith("{"): - clazz = Class(pkg, line, raw, blame, sig_format=sig_format) - elif raw.startswith(" ctor"): - clazz.ctors.append(Method(clazz, line, raw, blame, sig_format=sig_format)) - elif raw.startswith(" method"): - clazz.methods.append(Method(clazz, line, raw, blame, sig_format=sig_format)) - elif startsWithFieldPrefix(raw): - clazz.fields.append(Field(clazz, line, raw, blame, sig_format=sig_format)) - elif raw.startswith(" }") and clazz: - yield clazz - -def _retry_iterator(it): - """Wraps an iterator, such that calling send(True) on it will redeliver the same element""" - for e in it: - while True: - retry = yield e - if not retry: - break - # send() was called, asking us to redeliver clazz on next(). Still need to yield - # a dummy value to the send() first though. - if (yield "Returning clazz on next()"): - raise TypeError("send() must be followed by next(), not send()") - -def _skip_to_matching_class(classes, needle): - """Takes a classes iterator and consumes entries until it returns the class we're looking for - - This relies on classes being sorted by package and class name.""" - - for clazz in classes: - if clazz.pkg.name < needle.pkg.name: - # We haven't reached the right package yet - continue - if clazz.pkg.name == needle.pkg.name and clazz.fullname < needle.fullname: - # We're in the right package, but not the right class yet - continue - if clazz.fullname == needle.fullname: - return clazz - # We ran past the right class. Send it back into the generator, then report failure. - classes.send(clazz) - return None - -def _yield_until_matching_class(classes, needle): - """Takes a class iterator and yields entries it until it reaches the class we're looking for. - - This relies on classes being sorted by package and class name.""" - - for clazz in classes: - if needle is None: - yield clazz - elif clazz.pkg.name < needle.pkg.name: - # We haven't reached the right package yet - yield clazz - elif clazz.pkg.name == needle.pkg.name and clazz.fullname < needle.fullname: - # We're in the right package, but not the right class yet - yield clazz - elif clazz.fullname == needle.fullname: - # Class found, abort. - return - else: - # We ran past the right class. Send it back into the iterator, then abort. - classes.send(clazz) - return - -class Failure(): - def __init__(self, sig, clazz, detail, error, rule, msg): - self.clazz = clazz - self.sig = sig - self.error = error - self.rule = rule - self.msg = msg - - if error: - self.head = "Error %s" % (rule) if rule else "Error" - dump = "%s%s:%s %s" % (format(fg=RED, bg=BLACK, bold=True), self.head, format(reset=True), msg) - else: - self.head = "Warning %s" % (rule) if rule else "Warning" - dump = "%s%s:%s %s" % (format(fg=YELLOW, bg=BLACK, bold=True), self.head, format(reset=True), msg) - - self.line = clazz.line - blame = clazz.blame - if detail is not None: - dump += "\n in " + repr(detail) - self.line = detail.line - blame = detail.blame - dump += "\n in " + repr(clazz) - dump += "\n in " + repr(clazz.pkg) - dump += "\n at line " + repr(self.line) - if blame is not None: - dump += "\n last modified by %s in %s" % (blame[1], blame[0]) - - self.dump = dump - - def __repr__(self): - return self.dump - - -failures = {} - -def _fail(clazz, detail, error, rule, msg): - """Records an API failure to be processed later.""" - global failures - - sig = "%s-%s-%s" % (clazz.fullname, detail.ident if detail else None, msg) - sig = sig.replace(" deprecated ", " ") - - failures[sig] = Failure(sig, clazz, detail, error, rule, msg) - - -def warn(clazz, detail, rule, msg): - _fail(clazz, detail, False, rule, msg) - -def error(clazz, detail, rule, msg): - _fail(clazz, detail, True, rule, msg) - - -noticed = {} - -def notice(clazz): - global noticed - - noticed[clazz.fullname] = hash(clazz) - - -verifiers = {} - -def verifier(f): - verifiers[f.__name__] = f - return f - - -@verifier -def verify_constants(clazz): - """All static final constants must be FOO_NAME style.""" - if re.match("android\.R\.[a-z]+", clazz.fullname): return - if clazz.fullname.startswith("android.os.Build"): return - if clazz.fullname == "android.system.OsConstants": return - - req = ["java.lang.String","byte","short","int","long","float","double","boolean","char"] - for f in clazz.fields: - if "static" in f.split and "final" in f.split: - if re.match("[A-Z0-9_]+", f.name) is None: - error(clazz, f, "C2", "Constant field names must be FOO_NAME") - if f.typ != "java.lang.String": - if f.name.startswith("MIN_") or f.name.startswith("MAX_"): - warn(clazz, f, "C8", "If min/max could change in future, make them dynamic methods") - if f.typ in req and f.value is None: - error(clazz, f, None, "All constants must be defined at compile time") - -@verifier -def verify_enums(clazz): - """Enums are bad, mmkay?""" - if clazz.extends == "java.lang.Enum" or "enum" in clazz.split: - error(clazz, None, "F5", "Enums are not allowed") - -@verifier -def verify_class_names(clazz): - """Try catching malformed class names like myMtp or MTPUser.""" - if clazz.fullname.startswith("android.opengl"): return - if clazz.fullname.startswith("android.renderscript"): return - if re.match("android\.R\.[a-z]+", clazz.fullname): return - - if re.search("[A-Z]{2,}", clazz.name) is not None: - warn(clazz, None, "S1", "Class names with acronyms should be Mtp not MTP") - if re.match("[^A-Z]", clazz.name): - error(clazz, None, "S1", "Class must start with uppercase char") - if clazz.name.endswith("Impl"): - error(clazz, None, None, "Don't expose your implementation details") - - -@verifier -def verify_method_names(clazz): - """Try catching malformed method names, like Foo() or getMTU().""" - if clazz.fullname.startswith("android.opengl"): return - if clazz.fullname.startswith("android.renderscript"): return - if clazz.fullname == "android.system.OsConstants": return - - for m in clazz.methods: - if re.search("[A-Z]{2,}", m.name) is not None: - warn(clazz, m, "S1", "Method names with acronyms should be getMtu() instead of getMTU()") - if re.match("[^a-z]", m.name): - error(clazz, m, "S1", "Method name must start with lowercase char") - - -@verifier -def verify_callbacks(clazz): - """Verify Callback classes. - All methods must follow onFoo() naming style.""" - if clazz.fullname == "android.speech.tts.SynthesisCallback": return - - if clazz.name.endswith("Callbacks"): - error(clazz, None, "L1", "Callback class names should be singular") - if clazz.name.endswith("Observer"): - warn(clazz, None, "L1", "Class should be named FooCallback") - - if clazz.name.endswith("Callback"): - for m in clazz.methods: - if not re.match("on[A-Z][a-z]*", m.name): - error(clazz, m, "L1", "Callback method names must be onFoo() style") - - -@verifier -def verify_listeners(clazz): - """Verify Listener classes. - All Listener classes must be interface. - All methods must follow onFoo() naming style. - If only a single method, it must match class name: - interface OnFooListener { void onFoo() }""" - - if clazz.name.endswith("Listener"): - if "abstract" in clazz.split and "class" in clazz.split: - error(clazz, None, "L1", "Listeners should be an interface, or otherwise renamed Callback") - - for m in clazz.methods: - if not re.match("on[A-Z][a-z]*", m.name): - error(clazz, m, "L1", "Listener method names must be onFoo() style") - - if len(clazz.methods) == 1 and clazz.name.startswith("On"): - m = clazz.methods[0] - if (m.name + "Listener").lower() != clazz.name.lower(): - error(clazz, m, "L1", "Single listener method name must match class name") - - -@verifier -def verify_actions(clazz): - """Verify intent actions. - All action names must be named ACTION_FOO. - All action values must be scoped by package and match name: - package android.foo { - String ACTION_BAR = "android.foo.action.BAR"; - }""" - for f in clazz.fields: - if f.value is None: continue - if f.name.startswith("EXTRA_"): continue - if f.name == "SERVICE_INTERFACE" or f.name == "PROVIDER_INTERFACE": continue - if "INTERACTION" in f.name: continue - - if "static" in f.split and "final" in f.split and f.typ == "java.lang.String": - if "_ACTION" in f.name or "ACTION_" in f.name or ".action." in f.value.lower(): - if not f.name.startswith("ACTION_"): - error(clazz, f, "C3", "Intent action constant name must be ACTION_FOO") - else: - if clazz.fullname == "android.content.Intent": - prefix = "android.intent.action" - elif clazz.fullname == "android.provider.Settings": - prefix = "android.settings" - elif clazz.fullname == "android.app.admin.DevicePolicyManager" or clazz.fullname == "android.app.admin.DeviceAdminReceiver": - prefix = "android.app.action" - else: - prefix = clazz.pkg.name + ".action" - expected = prefix + "." + f.name[7:] - if f.value != expected: - error(clazz, f, "C4", "Inconsistent action value; expected '%s'" % (expected)) - - -@verifier -def verify_extras(clazz): - """Verify intent extras. - All extra names must be named EXTRA_FOO. - All extra values must be scoped by package and match name: - package android.foo { - String EXTRA_BAR = "android.foo.extra.BAR"; - }""" - if clazz.fullname == "android.app.Notification": return - if clazz.fullname == "android.appwidget.AppWidgetManager": return - - for f in clazz.fields: - if f.value is None: continue - if f.name.startswith("ACTION_"): continue - - if "static" in f.split and "final" in f.split and f.typ == "java.lang.String": - if "_EXTRA" in f.name or "EXTRA_" in f.name or ".extra" in f.value.lower(): - if not f.name.startswith("EXTRA_"): - error(clazz, f, "C3", "Intent extra must be EXTRA_FOO") - else: - if clazz.pkg.name == "android.content" and clazz.name == "Intent": - prefix = "android.intent.extra" - elif clazz.pkg.name == "android.app.admin": - prefix = "android.app.extra" - else: - prefix = clazz.pkg.name + ".extra" - expected = prefix + "." + f.name[6:] - if f.value != expected: - error(clazz, f, "C4", "Inconsistent extra value; expected '%s'" % (expected)) - - -@verifier -def verify_equals(clazz): - """Verify that equals() and hashCode() must be overridden together.""" - eq = False - hc = False - for m in clazz.methods: - if "static" in m.split: continue - if m.sig_matches("boolean", "equals", ["java.lang.Object"]): eq = True - if m.sig_matches("int", "hashCode", []): hc = True - if eq != hc: - error(clazz, None, "M8", "Must override both equals and hashCode; missing one") - - -@verifier -def verify_parcelable(clazz): - """Verify that Parcelable objects aren't hiding required bits.""" - if clazz.implements == "android.os.Parcelable": - creator = [ i for i in clazz.fields if i.name == "CREATOR" ] - write = [ i for i in clazz.methods if i.name == "writeToParcel" ] - describe = [ i for i in clazz.methods if i.name == "describeContents" ] - - if len(creator) == 0 or len(write) == 0 or len(describe) == 0: - error(clazz, None, "FW3", "Parcelable requires CREATOR, writeToParcel, and describeContents; missing one") - - if "final" not in clazz.split: - error(clazz, None, "FW8", "Parcelable classes must be final") - - for c in clazz.ctors: - if c.args == ["android.os.Parcel"]: - error(clazz, c, "FW3", "Parcelable inflation is exposed through CREATOR, not raw constructors") - - -@verifier -def verify_protected(clazz): - """Verify that no protected methods or fields are allowed.""" - for m in clazz.methods: - if m.name == "finalize": continue - if "protected" in m.split: - error(clazz, m, "M7", "Protected methods not allowed; must be public") - for f in clazz.fields: - if "protected" in f.split: - error(clazz, f, "M7", "Protected fields not allowed; must be public") - - -@verifier -def verify_fields(clazz): - """Verify that all exposed fields are final. - Exposed fields must follow myName style. - Catch internal mFoo objects being exposed.""" - - IGNORE_BARE_FIELDS = [ - "android.app.ActivityManager.RecentTaskInfo", - "android.app.Notification", - "android.content.pm.ActivityInfo", - "android.content.pm.ApplicationInfo", - "android.content.pm.ComponentInfo", - "android.content.pm.ResolveInfo", - "android.content.pm.FeatureGroupInfo", - "android.content.pm.InstrumentationInfo", - "android.content.pm.PackageInfo", - "android.content.pm.PackageItemInfo", - "android.content.res.Configuration", - "android.graphics.BitmapFactory.Options", - "android.os.Message", - "android.system.StructPollfd", - ] - - for f in clazz.fields: - if not "final" in f.split: - if clazz.fullname in IGNORE_BARE_FIELDS: - pass - elif clazz.fullname.endswith("LayoutParams"): - pass - elif clazz.fullname.startswith("android.util.Mutable"): - pass - else: - error(clazz, f, "F2", "Bare fields must be marked final, or add accessors if mutable") - - if "static" not in f.split and "property" not in f.split: - if not re.match("[a-z]([a-zA-Z]+)?", f.name): - error(clazz, f, "S1", "Non-static fields must be named using myField style") - - if re.match("[ms][A-Z]", f.name): - error(clazz, f, "F1", "Internal objects must not be exposed") - - if re.match("[A-Z_]+", f.name): - if "static" not in f.split or "final" not in f.split: - error(clazz, f, "C2", "Constants must be marked static final") - - -@verifier -def verify_register(clazz): - """Verify parity of registration methods. - Callback objects use register/unregister methods. - Listener objects use add/remove methods.""" - methods = [ m.name for m in clazz.methods ] - for m in clazz.methods: - if "Callback" in m.raw: - if m.name.startswith("register"): - other = "unregister" + m.name[8:] - if other not in methods: - error(clazz, m, "L2", "Missing unregister method") - if m.name.startswith("unregister"): - other = "register" + m.name[10:] - if other not in methods: - error(clazz, m, "L2", "Missing register method") - - if m.name.startswith("add") or m.name.startswith("remove"): - error(clazz, m, "L3", "Callback methods should be named register/unregister") - - if "Listener" in m.raw: - if m.name.startswith("add"): - other = "remove" + m.name[3:] - if other not in methods: - error(clazz, m, "L2", "Missing remove method") - if m.name.startswith("remove") and not m.name.startswith("removeAll"): - other = "add" + m.name[6:] - if other not in methods: - error(clazz, m, "L2", "Missing add method") - - if m.name.startswith("register") or m.name.startswith("unregister"): - error(clazz, m, "L3", "Listener methods should be named add/remove") - - -@verifier -def verify_sync(clazz): - """Verify synchronized methods aren't exposed.""" - for m in clazz.methods: - if "synchronized" in m.split: - error(clazz, m, "M5", "Internal locks must not be exposed") - - -@verifier -def verify_intent_builder(clazz): - """Verify that Intent builders are createFooIntent() style.""" - if clazz.name == "Intent": return - - for m in clazz.methods: - if m.typ == "android.content.Intent": - if m.name.startswith("create") and m.name.endswith("Intent"): - pass - else: - warn(clazz, m, "FW1", "Methods creating an Intent should be named createFooIntent()") - - -@verifier -def verify_helper_classes(clazz): - """Verify that helper classes are named consistently with what they extend. - All developer extendable methods should be named onFoo().""" - test_methods = False - if clazz.extends == "android.app.Service": - test_methods = True - if not clazz.name.endswith("Service"): - error(clazz, None, "CL4", "Inconsistent class name; should be FooService") - - found = False - for f in clazz.fields: - if f.name == "SERVICE_INTERFACE": - found = True - if f.value != clazz.fullname: - error(clazz, f, "C4", "Inconsistent interface constant; expected '%s'" % (clazz.fullname)) - - if clazz.extends == "android.content.ContentProvider": - test_methods = True - if not clazz.name.endswith("Provider"): - error(clazz, None, "CL4", "Inconsistent class name; should be FooProvider") - - found = False - for f in clazz.fields: - if f.name == "PROVIDER_INTERFACE": - found = True - if f.value != clazz.fullname: - error(clazz, f, "C4", "Inconsistent interface constant; expected '%s'" % (clazz.fullname)) - - if clazz.extends == "android.content.BroadcastReceiver": - test_methods = True - if not clazz.name.endswith("Receiver"): - error(clazz, None, "CL4", "Inconsistent class name; should be FooReceiver") - - if clazz.extends == "android.app.Activity": - test_methods = True - if not clazz.name.endswith("Activity"): - error(clazz, None, "CL4", "Inconsistent class name; should be FooActivity") - - if test_methods: - for m in clazz.methods: - if "final" in m.split: continue - if not re.match("on[A-Z]", m.name): - if "abstract" in m.split: - warn(clazz, m, None, "Methods implemented by developers should be named onFoo()") - else: - warn(clazz, m, None, "If implemented by developer, should be named onFoo(); otherwise consider marking final") - - -@verifier -def verify_builder(clazz): - """Verify builder classes. - Methods should return the builder to enable chaining.""" - if clazz.extends: return - if not clazz.name.endswith("Builder"): return - - if clazz.name != "Builder": - warn(clazz, None, None, "Builder should be defined as inner class") - - has_build = False - for m in clazz.methods: - if m.name == "build": - has_build = True - continue - - if m.name.startswith("get"): continue - if m.name.startswith("clear"): continue - - if m.name.startswith("with"): - warn(clazz, m, None, "Builder methods names should use setFoo() style") - - if m.name.startswith("set"): - if not m.typ.endswith(clazz.fullname): - warn(clazz, m, "M4", "Methods must return the builder object") - - if not has_build: - warn(clazz, None, None, "Missing build() method") - - if "final" not in clazz.split: - error(clazz, None, None, "Builder should be final") - - -@verifier -def verify_aidl(clazz): - """Catch people exposing raw AIDL.""" - if clazz.extends == "android.os.Binder" or clazz.implements == "android.os.IInterface": - error(clazz, None, None, "Raw AIDL interfaces must not be exposed") - - -@verifier -def verify_internal(clazz): - """Catch people exposing internal classes.""" - if clazz.pkg.name.startswith("com.android"): - error(clazz, None, None, "Internal classes must not be exposed") - -def layering_build_ranking(ranking_list): - r = {} - for rank, ps in enumerate(ranking_list): - if not isinstance(ps, list): - ps = [ps] - for p in ps: - rs = r - for n in p.split('.'): - if n not in rs: - rs[n] = {} - rs = rs[n] - rs['-rank'] = rank - return r - -LAYERING_PACKAGE_RANKING = layering_build_ranking([ - ["android.service","android.accessibilityservice","android.inputmethodservice","android.printservice","android.appwidget","android.webkit","android.preference","android.gesture","android.print"], - "android.app", - "android.widget", - "android.view", - "android.animation", - "android.provider", - ["android.content","android.graphics.drawable"], - "android.database", - "android.text", - "android.graphics", - "android.os", - "android.util" -]) - -@verifier -def verify_layering(clazz): - """Catch package layering violations. - For example, something in android.os depending on android.app.""" - - def rank(p): - r = None - l = LAYERING_PACKAGE_RANKING - for n in p.split('.'): - if n in l: - l = l[n] - if '-rank' in l: - r = l['-rank'] - else: - break - return r - - cr = rank(clazz.pkg.name) - if cr is None: return - - for f in clazz.fields: - ir = rank(f.typ) - if ir is not None and ir < cr: - warn(clazz, f, "FW6", "Field type violates package layering") - - for m in itertools.chain(clazz.methods, clazz.ctors): - ir = rank(m.typ) - if ir is not None and ir < cr: - warn(clazz, m, "FW6", "Method return type violates package layering") - for arg in m.args: - ir = rank(arg) - if ir is not None and ir < cr: - warn(clazz, m, "FW6", "Method argument type violates package layering") - - -@verifier -def verify_boolean(clazz): - """Verifies that boolean accessors are named correctly. - For example, hasFoo() and setHasFoo().""" - - def is_get(m): return len(m.args) == 0 and m.typ == "boolean" - def is_set(m): return len(m.args) == 1 and m.args[0] == "boolean" - - gets = [ m for m in clazz.methods if is_get(m) ] - sets = [ m for m in clazz.methods if is_set(m) ] - - def error_if_exists(methods, trigger, expected, actual): - for m in methods: - if m.name == actual: - error(clazz, m, "M6", "Symmetric method for %s must be named %s" % (trigger, expected)) - - for m in clazz.methods: - if is_get(m): - if re.match("is[A-Z]", m.name): - target = m.name[2:] - expected = "setIs" + target - error_if_exists(sets, m.name, expected, "setHas" + target) - elif re.match("has[A-Z]", m.name): - target = m.name[3:] - expected = "setHas" + target - error_if_exists(sets, m.name, expected, "setIs" + target) - error_if_exists(sets, m.name, expected, "set" + target) - elif re.match("get[A-Z]", m.name): - target = m.name[3:] - expected = "set" + target - error_if_exists(sets, m.name, expected, "setIs" + target) - error_if_exists(sets, m.name, expected, "setHas" + target) - - if is_set(m): - if re.match("set[A-Z]", m.name): - target = m.name[3:] - expected = "get" + target - error_if_exists(sets, m.name, expected, "is" + target) - error_if_exists(sets, m.name, expected, "has" + target) - - -@verifier -def verify_collections(clazz): - """Verifies that collection types are interfaces.""" - if clazz.fullname == "android.os.Bundle": return - if clazz.fullname == "android.os.Parcel": return - - bad = ["java.util.Vector", "java.util.LinkedList", "java.util.ArrayList", "java.util.Stack", - "java.util.HashMap", "java.util.HashSet", "android.util.ArraySet", "android.util.ArrayMap"] - for m in clazz.methods: - if m.typ in bad: - error(clazz, m, "CL2", "Return type is concrete collection; must be higher-level interface") - for arg in m.args: - if arg in bad: - error(clazz, m, "CL2", "Argument is concrete collection; must be higher-level interface") - - -@verifier -def verify_uris(clazz): - bad = ["java.net.URL", "java.net.URI", "android.net.URL"] - - for f in clazz.fields: - if f.typ in bad: - error(clazz, f, None, "Field must be android.net.Uri instead of " + f.typ) - - for m in clazz.methods + clazz.ctors: - if m.typ in bad: - error(clazz, m, None, "Must return android.net.Uri instead of " + m.typ) - for arg in m.args: - if arg in bad: - error(clazz, m, None, "Argument must take android.net.Uri instead of " + arg) - - -@verifier -def verify_flags(clazz): - """Verifies that flags are non-overlapping.""" - known = collections.defaultdict(int) - for f in clazz.fields: - if "FLAG_" in f.name: - try: - val = int(f.value) - except: - continue - - scope = f.name[0:f.name.index("FLAG_")] - if val & known[scope]: - warn(clazz, f, "C1", "Found overlapping flag constant value") - known[scope] |= val - - -@verifier -def verify_exception(clazz): - """Verifies that methods don't throw generic exceptions.""" - for m in clazz.methods: - for t in m.throws: - if t in ["java.lang.Exception", "java.lang.Throwable", "java.lang.Error"]: - error(clazz, m, "S1", "Methods must not throw generic exceptions") - - if t in ["android.os.RemoteException"]: - if clazz.fullname == "android.content.ContentProviderClient": continue - if clazz.fullname == "android.os.Binder": continue - if clazz.fullname == "android.os.IBinder": continue - - error(clazz, m, "FW9", "Methods calling into system server should rethrow RemoteException as RuntimeException") - - if len(m.args) == 0 and t in ["java.lang.IllegalArgumentException", "java.lang.NullPointerException"]: - warn(clazz, m, "S1", "Methods taking no arguments should throw IllegalStateException") - - -GOOGLE_IGNORECASE = re.compile("google", re.IGNORECASE) - -# Not marked as @verifier, because it is only conditionally applied. -def verify_google(clazz): - """Verifies that APIs never reference Google.""" - - if GOOGLE_IGNORECASE.search(clazz.raw) is not None: - error(clazz, None, None, "Must never reference Google") - - for test in clazz.ctors, clazz.fields, clazz.methods: - for t in test: - if GOOGLE_IGNORECASE.search(t.raw) is not None: - error(clazz, t, None, "Must never reference Google") - - -@verifier -def verify_bitset(clazz): - """Verifies that we avoid using heavy BitSet.""" - - for f in clazz.fields: - if f.typ == "java.util.BitSet": - error(clazz, f, None, "Field type must not be heavy BitSet") - - for m in clazz.methods: - if m.typ == "java.util.BitSet": - error(clazz, m, None, "Return type must not be heavy BitSet") - for arg in m.args: - if arg == "java.util.BitSet": - error(clazz, m, None, "Argument type must not be heavy BitSet") - - -@verifier -def verify_manager(clazz): - """Verifies that FooManager is only obtained from Context.""" - - if not clazz.name.endswith("Manager"): return - - for c in clazz.ctors: - error(clazz, c, None, "Managers must always be obtained from Context; no direct constructors") - - for m in clazz.methods: - if m.typ == clazz.fullname: - error(clazz, m, None, "Managers must always be obtained from Context") - - -@verifier -def verify_boxed(clazz): - """Verifies that methods avoid boxed primitives.""" - - boxed = ["java.lang.Number","java.lang.Byte","java.lang.Double","java.lang.Float","java.lang.Integer","java.lang.Long","java.lang.Short"] - - for c in clazz.ctors: - for arg in c.args: - if arg in boxed: - error(clazz, c, "M11", "Must avoid boxed primitives") - - for f in clazz.fields: - if f.typ in boxed: - error(clazz, f, "M11", "Must avoid boxed primitives") - - for m in clazz.methods: - if m.typ in boxed: - error(clazz, m, "M11", "Must avoid boxed primitives") - for arg in m.args: - if arg in boxed: - error(clazz, m, "M11", "Must avoid boxed primitives") - - -@verifier -def verify_static_utils(clazz): - """Verifies that helper classes can't be constructed.""" - if clazz.fullname.startswith("android.opengl"): return - if clazz.fullname.startswith("android.R"): return - - # Only care about classes with default constructors - if len(clazz.ctors) == 1 and len(clazz.ctors[0].args) == 0: - test = [] - test.extend(clazz.fields) - test.extend(clazz.methods) - - if len(test) == 0: return - for t in test: - if "static" not in t.split: - return - - error(clazz, None, None, "Fully-static utility classes must not have constructor") - - -# @verifier # Disabled for now -def verify_overload_args(clazz): - """Verifies that method overloads add new arguments at the end.""" - if clazz.fullname.startswith("android.opengl"): return - - overloads = collections.defaultdict(list) - for m in clazz.methods: - if "deprecated" in m.split: continue - overloads[m.name].append(m) - - for name, methods in overloads.items(): - if len(methods) <= 1: continue - - # Look for arguments common across all overloads - def cluster(args): - count = collections.defaultdict(int) - res = set() - for i in range(len(args)): - a = args[i] - res.add("%s#%d" % (a, count[a])) - count[a] += 1 - return res - - common_args = cluster(methods[0].args) - for m in methods: - common_args = common_args & cluster(m.args) - - if len(common_args) == 0: continue - - # Require that all common arguments are present at start of signature - locked_sig = None - for m in methods: - sig = m.args[0:len(common_args)] - if not common_args.issubset(cluster(sig)): - warn(clazz, m, "M2", "Expected common arguments [%s] at beginning of overloaded method" % (", ".join(common_args))) - elif not locked_sig: - locked_sig = sig - elif locked_sig != sig: - error(clazz, m, "M2", "Expected consistent argument ordering between overloads: %s..." % (", ".join(locked_sig))) - - -@verifier -def verify_callback_handlers(clazz): - """Verifies that methods adding listener/callback have overload - for specifying delivery thread.""" - - # Ignore UI packages which assume main thread - skip = [ - "animation", - "view", - "graphics", - "transition", - "widget", - "webkit", - ] - for s in skip: - if s in clazz.pkg.name_path: return - if s in clazz.extends_path: return - - # Ignore UI classes which assume main thread - if "app" in clazz.pkg.name_path or "app" in clazz.extends_path: - for s in ["ActionBar","Dialog","Application","Activity","Fragment","Loader"]: - if s in clazz.fullname: return - if "content" in clazz.pkg.name_path or "content" in clazz.extends_path: - for s in ["Loader"]: - if s in clazz.fullname: return - - found = {} - by_name = collections.defaultdict(list) - examine = clazz.ctors + clazz.methods - for m in examine: - if m.name.startswith("unregister"): continue - if m.name.startswith("remove"): continue - if re.match("on[A-Z]+", m.name): continue - - by_name[m.name].append(m) - - for a in m.args: - if a.endswith("Listener") or a.endswith("Callback") or a.endswith("Callbacks"): - found[m.name] = m - - for f in found.values(): - takes_handler = False - takes_exec = False - for m in by_name[f.name]: - if "android.os.Handler" in m.args: - takes_handler = True - if "java.util.concurrent.Executor" in m.args: - takes_exec = True - if not takes_exec: - warn(clazz, f, "L1", "Registration methods should have overload that accepts delivery Executor") - - -@verifier -def verify_context_first(clazz): - """Verifies that methods accepting a Context keep it the first argument.""" - examine = clazz.ctors + clazz.methods - for m in examine: - if len(m.args) > 1 and m.args[0] != "android.content.Context": - if "android.content.Context" in m.args[1:]: - error(clazz, m, "M3", "Context is distinct, so it must be the first argument") - if len(m.args) > 1 and m.args[0] != "android.content.ContentResolver": - if "android.content.ContentResolver" in m.args[1:]: - error(clazz, m, "M3", "ContentResolver is distinct, so it must be the first argument") - - -@verifier -def verify_listener_last(clazz): - """Verifies that methods accepting a Listener or Callback keep them as last arguments.""" - examine = clazz.ctors + clazz.methods - for m in examine: - if "Listener" in m.name or "Callback" in m.name: continue - found = False - for a in m.args: - if a.endswith("Callback") or a.endswith("Callbacks") or a.endswith("Listener"): - found = True - elif found: - warn(clazz, m, "M3", "Listeners should always be at end of argument list") - - -@verifier -def verify_resource_names(clazz): - """Verifies that resource names have consistent case.""" - if not re.match("android\.R\.[a-z]+", clazz.fullname): return - - # Resources defined by files are foo_bar_baz - if clazz.name in ["anim","animator","color","dimen","drawable","interpolator","layout","transition","menu","mipmap","string","plurals","raw","xml"]: - for f in clazz.fields: - if re.match("config_[a-z][a-zA-Z1-9]*$", f.name): continue - if f.name.startswith("config_"): - error(clazz, f, None, "Expected config name to be config_fooBarBaz style") - - if re.match("[a-z1-9_]+$", f.name): continue - error(clazz, f, None, "Expected resource name in this class to be foo_bar_baz style") - - # Resources defined inside files are fooBarBaz - if clazz.name in ["array","attr","id","bool","fraction","integer"]: - for f in clazz.fields: - if re.match("config_[a-z][a-zA-Z1-9]*$", f.name): continue - if re.match("layout_[a-z][a-zA-Z1-9]*$", f.name): continue - if re.match("state_[a-z_]*$", f.name): continue - - if re.match("[a-z][a-zA-Z1-9]*$", f.name): continue - error(clazz, f, "C7", "Expected resource name in this class to be fooBarBaz style") - - # Styles are FooBar_Baz - if clazz.name in ["style"]: - for f in clazz.fields: - if re.match("[A-Z][A-Za-z1-9]+(_[A-Z][A-Za-z1-9]+?)*$", f.name): continue - error(clazz, f, "C7", "Expected resource name in this class to be FooBar_Baz style") - - -@verifier -def verify_files(clazz): - """Verifies that methods accepting File also accept streams.""" - - has_file = set() - has_stream = set() - - test = [] - test.extend(clazz.ctors) - test.extend(clazz.methods) - - for m in test: - if "java.io.File" in m.args: - has_file.add(m) - if "java.io.FileDescriptor" in m.args or "android.os.ParcelFileDescriptor" in m.args or "java.io.InputStream" in m.args or "java.io.OutputStream" in m.args: - has_stream.add(m.name) - - for m in has_file: - if m.name not in has_stream: - warn(clazz, m, "M10", "Methods accepting File should also accept FileDescriptor or streams") - - -@verifier -def verify_manager_list(clazz): - """Verifies that managers return List<? extends Parcelable> instead of arrays.""" - - if not clazz.name.endswith("Manager"): return - - for m in clazz.methods: - if m.typ.startswith("android.") and m.typ.endswith("[]"): - warn(clazz, m, None, "Methods should return List<? extends Parcelable> instead of Parcelable[] to support ParceledListSlice under the hood") - - -@verifier -def verify_abstract_inner(clazz): - """Verifies that abstract inner classes are static.""" - - if re.match(".+?\.[A-Z][^\.]+\.[A-Z]", clazz.fullname): - if "abstract" in clazz.split and "static" not in clazz.split: - warn(clazz, None, None, "Abstract inner classes should be static to improve testability") - - -@verifier -def verify_runtime_exceptions(clazz): - """Verifies that runtime exceptions aren't listed in throws.""" - - banned = [ - "java.lang.NullPointerException", - "java.lang.ClassCastException", - "java.lang.IndexOutOfBoundsException", - "java.lang.reflect.UndeclaredThrowableException", - "java.lang.reflect.MalformedParametersException", - "java.lang.reflect.MalformedParameterizedTypeException", - "java.lang.invoke.WrongMethodTypeException", - "java.lang.EnumConstantNotPresentException", - "java.lang.IllegalMonitorStateException", - "java.lang.SecurityException", - "java.lang.UnsupportedOperationException", - "java.lang.annotation.AnnotationTypeMismatchException", - "java.lang.annotation.IncompleteAnnotationException", - "java.lang.TypeNotPresentException", - "java.lang.IllegalStateException", - "java.lang.ArithmeticException", - "java.lang.IllegalArgumentException", - "java.lang.ArrayStoreException", - "java.lang.NegativeArraySizeException", - "java.util.MissingResourceException", - "java.util.EmptyStackException", - "java.util.concurrent.CompletionException", - "java.util.concurrent.RejectedExecutionException", - "java.util.IllformedLocaleException", - "java.util.ConcurrentModificationException", - "java.util.NoSuchElementException", - "java.io.UncheckedIOException", - "java.time.DateTimeException", - "java.security.ProviderException", - "java.nio.BufferUnderflowException", - "java.nio.BufferOverflowException", - ] - - examine = clazz.ctors + clazz.methods - for m in examine: - for t in m.throws: - if t in banned: - error(clazz, m, None, "Methods must not mention RuntimeException subclasses in throws clauses") - - -@verifier -def verify_error(clazz): - """Verifies that we always use Exception instead of Error.""" - if not clazz.extends: return - if clazz.extends.endswith("Error"): - error(clazz, None, None, "Trouble must be reported through an Exception, not Error") - if clazz.extends.endswith("Exception") and not clazz.name.endswith("Exception"): - error(clazz, None, None, "Exceptions must be named FooException") - - -@verifier -def verify_units(clazz): - """Verifies that we use consistent naming for units.""" - - # If we find K, recommend replacing with V - bad = { - "Ns": "Nanos", - "Ms": "Millis or Micros", - "Sec": "Seconds", "Secs": "Seconds", - "Hr": "Hours", "Hrs": "Hours", - "Mo": "Months", "Mos": "Months", - "Yr": "Years", "Yrs": "Years", - "Byte": "Bytes", "Space": "Bytes", - } - - for m in clazz.methods: - if m.typ not in ["short","int","long"]: continue - for k, v in bad.iteritems(): - if m.name.endswith(k): - error(clazz, m, None, "Expected method name units to be " + v) - if m.name.endswith("Nanos") or m.name.endswith("Micros"): - warn(clazz, m, None, "Returned time values are strongly encouraged to be in milliseconds unless you need the extra precision") - if m.name.endswith("Seconds"): - error(clazz, m, None, "Returned time values must be in milliseconds") - - for m in clazz.methods: - typ = m.typ - if typ == "void": - if len(m.args) != 1: continue - typ = m.args[0] - - if m.name.endswith("Fraction") and typ != "float": - error(clazz, m, None, "Fractions must use floats") - if m.name.endswith("Percentage") and typ != "int": - error(clazz, m, None, "Percentage must use ints") - - -@verifier -def verify_closable(clazz): - """Verifies that classes are AutoClosable.""" - if "java.lang.AutoCloseable" in clazz.implements_all: return - if "java.io.Closeable" in clazz.implements_all: return - - for m in clazz.methods: - if len(m.args) > 0: continue - if m.name in ["close","release","destroy","finish","finalize","disconnect","shutdown","stop","free","quit"]: - warn(clazz, m, None, "Classes that release resources should implement AutoClosable and CloseGuard") - return - - -@verifier -def verify_member_name_not_kotlin_keyword(clazz): - """Prevent method names which are keywords in Kotlin.""" - - # https://kotlinlang.org/docs/reference/keyword-reference.html#hard-keywords - # This list does not include Java keywords as those are already impossible to use. - keywords = [ - 'as', - 'fun', - 'in', - 'is', - 'object', - 'typealias', - 'val', - 'var', - 'when', - ] - - for m in clazz.methods: - if m.name in keywords: - error(clazz, m, None, "Method name must not be a Kotlin keyword") - for f in clazz.fields: - if f.name in keywords: - error(clazz, f, None, "Field name must not be a Kotlin keyword") - - -@verifier -def verify_method_name_not_kotlin_operator(clazz): - """Warn about method names which become operators in Kotlin.""" - - binary = set() - - def unique_binary_op(m, op): - if op in binary: - error(clazz, m, None, "Only one of '{0}' and '{0}Assign' methods should be present for Kotlin".format(op)) - binary.add(op) - - for m in clazz.methods: - if 'static' in m.split or 'operator' in m.split: - continue - - # https://kotlinlang.org/docs/reference/operator-overloading.html#unary-prefix-operators - if m.name in ['unaryPlus', 'unaryMinus', 'not'] and len(m.args) == 0: - warn(clazz, m, None, "Method can be invoked as a unary operator from Kotlin") - - # https://kotlinlang.org/docs/reference/operator-overloading.html#increments-and-decrements - if m.name in ['inc', 'dec'] and len(m.args) == 0 and m.typ != 'void': - # This only applies if the return type is the same or a subtype of the enclosing class, but we have no - # practical way of checking that relationship here. - warn(clazz, m, None, "Method can be invoked as a pre/postfix inc/decrement operator from Kotlin") - - # https://kotlinlang.org/docs/reference/operator-overloading.html#arithmetic - if m.name in ['plus', 'minus', 'times', 'div', 'rem', 'mod', 'rangeTo'] and len(m.args) == 1: - warn(clazz, m, None, "Method can be invoked as a binary operator from Kotlin") - unique_binary_op(m, m.name) - - # https://kotlinlang.org/docs/reference/operator-overloading.html#in - if m.name == 'contains' and len(m.args) == 1 and m.typ == 'boolean': - warn(clazz, m, None, "Method can be invoked as a 'in' operator from Kotlin") - - # https://kotlinlang.org/docs/reference/operator-overloading.html#indexed - if (m.name == 'get' and len(m.args) > 0) or (m.name == 'set' and len(m.args) > 1): - warn(clazz, m, None, "Method can be invoked with an indexing operator from Kotlin") - - # https://kotlinlang.org/docs/reference/operator-overloading.html#invoke - if m.name == 'invoke': - warn(clazz, m, None, "Method can be invoked with function call syntax from Kotlin") - - # https://kotlinlang.org/docs/reference/operator-overloading.html#assignments - if m.name in ['plusAssign', 'minusAssign', 'timesAssign', 'divAssign', 'remAssign', 'modAssign'] \ - and len(m.args) == 1 \ - and m.typ == 'void': - warn(clazz, m, None, "Method can be invoked as a compound assignment operator from Kotlin") - unique_binary_op(m, m.name[:-6]) # Remove 'Assign' suffix - - -@verifier -def verify_collections_over_arrays(clazz): - """Warn that [] should be Collections.""" - - if "@interface" in clazz.split: - return - - safe = ["java.lang.String[]","byte[]","short[]","int[]","long[]","float[]","double[]","boolean[]","char[]"] - for m in clazz.methods: - if m.typ.endswith("[]") and m.typ not in safe: - warn(clazz, m, None, "Method should return Collection<> (or subclass) instead of raw array") - for arg in m.args: - if arg.endswith("[]") and arg not in safe: - warn(clazz, m, None, "Method argument should be Collection<> (or subclass) instead of raw array") - - -@verifier -def verify_user_handle(clazz): - """Methods taking UserHandle should be ForUser or AsUser.""" - if clazz.name.endswith("Listener") or clazz.name.endswith("Callback") or clazz.name.endswith("Callbacks"): return - if clazz.fullname == "android.app.admin.DeviceAdminReceiver": return - if clazz.fullname == "android.content.pm.LauncherApps": return - if clazz.fullname == "android.os.UserHandle": return - if clazz.fullname == "android.os.UserManager": return - - for m in clazz.methods: - if re.match("on[A-Z]+", m.name): continue - - has_arg = "android.os.UserHandle" in m.args - has_name = m.name.endswith("AsUser") or m.name.endswith("ForUser") - - if clazz.fullname.endswith("Manager") and has_arg: - warn(clazz, m, None, "When a method overload is needed to target a specific " - "UserHandle, callers should be directed to use " - "Context.createPackageContextAsUser() and re-obtain the relevant " - "Manager, and no new API should be added") - elif has_arg and not has_name: - warn(clazz, m, None, "Method taking UserHandle should be named 'doFooAsUser' " - "or 'queryFooForUser'") - - -@verifier -def verify_params(clazz): - """Parameter classes should be 'Params'.""" - if clazz.name.endswith("Params"): return - if clazz.fullname == "android.app.ActivityOptions": return - if clazz.fullname == "android.app.BroadcastOptions": return - if clazz.fullname == "android.os.Bundle": return - if clazz.fullname == "android.os.BaseBundle": return - if clazz.fullname == "android.os.PersistableBundle": return - - bad = ["Param","Parameter","Parameters","Args","Arg","Argument","Arguments","Options","Bundle"] - for b in bad: - if clazz.name.endswith(b): - error(clazz, None, None, "Classes holding a set of parameters should be called 'FooParams'") - - -@verifier -def verify_services(clazz): - """Service name should be FOO_BAR_SERVICE = 'foo_bar'.""" - if clazz.fullname != "android.content.Context": return - - for f in clazz.fields: - if f.typ != "java.lang.String": continue - found = re.match(r"([A-Z_]+)_SERVICE", f.name) - if found: - expected = found.group(1).lower() - if f.value != expected: - error(clazz, f, "C4", "Inconsistent service value; expected '%s'" % (expected)) - - -@verifier -def verify_tense(clazz): - """Verify tenses of method names.""" - if clazz.fullname.startswith("android.opengl"): return - - for m in clazz.methods: - if m.name.endswith("Enable"): - warn(clazz, m, None, "Unexpected tense; probably meant 'enabled'") - - -@verifier -def verify_icu(clazz): - """Verifies that richer ICU replacements are used.""" - better = { - "java.util.TimeZone": "android.icu.util.TimeZone", - "java.util.Calendar": "android.icu.util.Calendar", - "java.util.Locale": "android.icu.util.ULocale", - "java.util.ResourceBundle": "android.icu.util.UResourceBundle", - "java.util.SimpleTimeZone": "android.icu.util.SimpleTimeZone", - "java.util.StringTokenizer": "android.icu.util.StringTokenizer", - "java.util.GregorianCalendar": "android.icu.util.GregorianCalendar", - "java.lang.Character": "android.icu.lang.UCharacter", - "java.text.BreakIterator": "android.icu.text.BreakIterator", - "java.text.Collator": "android.icu.text.Collator", - "java.text.DecimalFormatSymbols": "android.icu.text.DecimalFormatSymbols", - "java.text.NumberFormat": "android.icu.text.NumberFormat", - "java.text.DateFormatSymbols": "android.icu.text.DateFormatSymbols", - "java.text.DateFormat": "android.icu.text.DateFormat", - "java.text.SimpleDateFormat": "android.icu.text.SimpleDateFormat", - "java.text.MessageFormat": "android.icu.text.MessageFormat", - "java.text.DecimalFormat": "android.icu.text.DecimalFormat", - } - - for m in clazz.ctors + clazz.methods: - types = [] - types.extend(m.typ) - types.extend(m.args) - for arg in types: - if arg in better: - warn(clazz, m, None, "Type %s should be replaced with richer ICU type %s" % (arg, better[arg])) - - -@verifier -def verify_clone(clazz): - """Verify that clone() isn't implemented; see EJ page 61.""" - for m in clazz.methods: - if m.name == "clone": - error(clazz, m, None, "Provide an explicit copy constructor instead of implementing clone()") - - -@verifier -def verify_pfd(clazz): - """Verify that android APIs use PFD over FD.""" - if clazz.fullname == "android.os.FileUtils" or clazz.fullname == "android.system.Os": - return - - examine = clazz.ctors + clazz.methods - for m in examine: - if m.typ == "java.io.FileDescriptor": - error(clazz, m, "FW11", "Must use ParcelFileDescriptor") - if m.typ == "int": - if "Fd" in m.name or "FD" in m.name or "FileDescriptor" in m.name: - error(clazz, m, "FW11", "Must use ParcelFileDescriptor") - for arg in m.args: - if arg == "java.io.FileDescriptor": - error(clazz, m, "FW11", "Must use ParcelFileDescriptor") - - for f in clazz.fields: - if f.typ == "java.io.FileDescriptor": - error(clazz, f, "FW11", "Must use ParcelFileDescriptor") - - -@verifier -def verify_numbers(clazz): - """Discourage small numbers types like short and byte.""" - - discouraged = ["short","byte"] - - for c in clazz.ctors: - for arg in c.args: - if arg in discouraged: - warn(clazz, c, "FW12", "Should avoid odd sized primitives; use int instead") - - for f in clazz.fields: - if f.typ in discouraged: - warn(clazz, f, "FW12", "Should avoid odd sized primitives; use int instead") - - for m in clazz.methods: - if m.typ in discouraged: - warn(clazz, m, "FW12", "Should avoid odd sized primitives; use int instead") - for arg in m.args: - if arg in discouraged: - warn(clazz, m, "FW12", "Should avoid odd sized primitives; use int instead") - - -PRIMITIVES = {"void", "int", "float", "boolean", "short", "char", "byte", "long", "double"} - -@verifier -def verify_nullability(clazz): - """Catches missing nullability annotations""" - - for f in clazz.fields: - if "enum_constant" in f.split: - continue # Enum constants are never null - if f.value is not None and 'final' in f.split: - continue # Nullability of constants can be inferred. - if f.typ not in PRIMITIVES and not has_nullability(f.annotations): - error(clazz, f, "M12", "Field must be marked either @NonNull or @Nullable") - - for c in clazz.ctors: - verify_nullability_args(clazz, c) - - for m in clazz.methods: - if m.name == "writeToParcel" or m.name == "onReceive" or m.name == "onBind": - continue # Parcelable.writeToParcel(), BroadcastReceiver.onReceive(), and Service.onBind() are not yet annotated - - if (m.name == "equals" and m.args == ["java.lang.Object"] or - m.name == "toString" and m.args == []): - continue # Nullability of equals and toString is implicit. - - if m.typ not in PRIMITIVES and not has_nullability(m.annotations): - error(clazz, m, "M12", "Return value must be marked either @NonNull or @Nullable") - verify_nullability_args(clazz, m) - -def verify_nullability_args(clazz, m): - for i, arg in enumerate(m.detailed_args): - if arg.type not in PRIMITIVES and not has_nullability(arg.annotations): - error(clazz, m, "M12", "Argument %d must be marked either @NonNull or @Nullable" % (i+1,)) - -def has_nullability(annotations): - return "@NonNull" in annotations or "@Nullable" in annotations - - -@verifier -def verify_intdef(clazz): - """intdefs must be @hide, because the constant names cannot be stored in - the stubs (only the values are, which is not useful)""" - if "@interface" not in clazz.split: - return - if "@IntDef" in clazz.annotations or "@LongDef" in clazz.annotations: - error(clazz, None, None, "@IntDef and @LongDef annotations must be @hide") - - -@verifier -def verify_singleton(clazz): - """Catch singleton objects with constructors.""" - - singleton = False - for m in clazz.methods: - if m.name.startswith("get") and m.name.endswith("Instance") and " static " in m.raw: - singleton = True - - if singleton: - for c in clazz.ctors: - error(clazz, c, None, "Singleton classes should use getInstance() methods") - - - -def is_interesting(clazz): - """Test if given class is interesting from an Android PoV.""" - - if clazz.pkg.name.startswith("java"): return False - if clazz.pkg.name.startswith("junit"): return False - if clazz.pkg.name.startswith("org.apache"): return False - if clazz.pkg.name.startswith("org.xml"): return False - if clazz.pkg.name.startswith("org.json"): return False - if clazz.pkg.name.startswith("org.w3c"): return False - if clazz.pkg.name.startswith("android.icu."): return False - return True - - -def examine_clazz(clazz): - """Find all style issues in the given class.""" - - notice(clazz) - - if not is_interesting(clazz): return - - for v in verifiers.itervalues(): - v(clazz) - - if not ALLOW_GOOGLE: verify_google(clazz) - - -def examine_stream(stream, base_stream=None, in_classes_with_base=[], out_classes_with_base=None): - """Find all style issues in the given API stream.""" - global failures, noticed - failures = {} - noticed = {} - _parse_stream(stream, examine_clazz, base_f=base_stream, - in_classes_with_base=in_classes_with_base, - out_classes_with_base=out_classes_with_base) - return (failures, noticed) - - -def examine_api(api): - """Find all style issues in the given parsed API.""" - global failures - failures = {} - for key in sorted(api.keys()): - examine_clazz(api[key]) - return failures - - -def verify_compat(cur, prev): - """Find any incompatible API changes between two levels.""" - global failures - - def class_exists(api, test): - return test.fullname in api - - def ctor_exists(api, clazz, test): - for m in clazz.ctors: - if m.ident == test.ident: return True - return False - - def all_methods(api, clazz): - methods = list(clazz.methods) - if clazz.extends is not None: - methods.extend(all_methods(api, api[clazz.extends])) - return methods - - def method_exists(api, clazz, test): - methods = all_methods(api, clazz) - for m in methods: - if m.ident == test.ident: return True - return False - - def field_exists(api, clazz, test): - for f in clazz.fields: - if f.ident == test.ident: return True - return False - - failures = {} - for key in sorted(prev.keys()): - prev_clazz = prev[key] - - if not class_exists(cur, prev_clazz): - error(prev_clazz, None, None, "Class removed or incompatible change") - continue - - cur_clazz = cur[key] - - for test in prev_clazz.ctors: - if not ctor_exists(cur, cur_clazz, test): - error(prev_clazz, prev_ctor, None, "Constructor removed or incompatible change") - - methods = all_methods(prev, prev_clazz) - for test in methods: - if not method_exists(cur, cur_clazz, test): - error(prev_clazz, test, None, "Method removed or incompatible change") - - for test in prev_clazz.fields: - if not field_exists(cur, cur_clazz, test): - error(prev_clazz, test, None, "Field removed or incompatible change") - - return failures - - -def match_filter(filters, fullname): - for f in filters: - if fullname == f: - return True - if fullname.startswith(f + '.'): - return True - return False - - -def show_deprecations_at_birth(cur, prev): - """Show API deprecations at birth.""" - global failures - - # Remove all existing things so we're left with new - for prev_clazz in prev.values(): - if prev_clazz.fullname not in cur: - # The class was removed this release; we can safely ignore it. - continue - - cur_clazz = cur[prev_clazz.fullname] - if not is_interesting(cur_clazz): continue - - sigs = { i.ident: i for i in prev_clazz.ctors } - cur_clazz.ctors = [ i for i in cur_clazz.ctors if i.ident not in sigs ] - sigs = { i.ident: i for i in prev_clazz.methods } - cur_clazz.methods = [ i for i in cur_clazz.methods if i.ident not in sigs ] - sigs = { i.ident: i for i in prev_clazz.fields } - cur_clazz.fields = [ i for i in cur_clazz.fields if i.ident not in sigs ] - - # Forget about class entirely when nothing new - if len(cur_clazz.ctors) == 0 and len(cur_clazz.methods) == 0 and len(cur_clazz.fields) == 0: - del cur[prev_clazz.fullname] - - for clazz in cur.values(): - if not is_interesting(clazz): continue - - if "deprecated" in clazz.split and not clazz.fullname in prev: - error(clazz, None, None, "Found API deprecation at birth") - - for i in clazz.ctors + clazz.methods + clazz.fields: - if "deprecated" in i.split: - error(clazz, i, None, "Found API deprecation at birth") - - print "%s Deprecated at birth %s\n" % ((format(fg=WHITE, bg=BLUE, bold=True), - format(reset=True))) - for f in sorted(failures): - print failures[f] - print - - -def show_stats(cur, prev): - """Show API stats.""" - - stats = collections.defaultdict(int) - for cur_clazz in cur.values(): - if not is_interesting(cur_clazz): continue - - if cur_clazz.fullname not in prev: - stats['new_classes'] += 1 - stats['new_ctors'] += len(cur_clazz.ctors) - stats['new_methods'] += len(cur_clazz.methods) - stats['new_fields'] += len(cur_clazz.fields) - else: - prev_clazz = prev[cur_clazz.fullname] - - sigs = { i.ident: i for i in prev_clazz.ctors } - ctors = len([ i for i in cur_clazz.ctors if i.ident not in sigs ]) - sigs = { i.ident: i for i in prev_clazz.methods } - methods = len([ i for i in cur_clazz.methods if i.ident not in sigs ]) - sigs = { i.ident: i for i in prev_clazz.fields } - fields = len([ i for i in cur_clazz.fields if i.ident not in sigs ]) - - if ctors + methods + fields > 0: - stats['extend_classes'] += 1 - stats['extend_ctors'] += ctors - stats['extend_methods'] += methods - stats['extend_fields'] += fields - - print "#", "".join([ k.ljust(20) for k in sorted(stats.keys()) ]) - print " ", "".join([ str(stats[k]).ljust(20) for k in sorted(stats.keys()) ]) - - -def main(): - parser = argparse.ArgumentParser(description="Enforces common Android public API design \ - patterns. It ignores lint messages from a previous API level, if provided.") - parser.add_argument("--base-current", nargs='?', type=argparse.FileType('r'), default=None, - help="The base current.txt to use when examining system-current.txt or" - " test-current.txt") - parser.add_argument("--base-previous", nargs='?', type=argparse.FileType('r'), default=None, - help="The base previous.txt to use when examining system-previous.txt or" - " test-previous.txt") - parser.add_argument("--no-color", action='store_const', const=True, - help="Disable terminal colors") - parser.add_argument("--color", action='store_const', const=True, - help="Use terminal colors") - parser.add_argument("--allow-google", action='store_const', const=True, - help="Allow references to Google") - parser.add_argument("--show-noticed", action='store_const', const=True, - help="Show API changes noticed") - parser.add_argument("--show-deprecations-at-birth", action='store_const', const=True, - help="Show API deprecations at birth") - parser.add_argument("--show-stats", action='store_const', const=True, - help="Show API stats") - parser.add_argument("--title", action='store', default=None, - help="Title to put in for display purposes") - parser.add_argument("--filter", action="append", - help="If provided, only show lint for the given packages or classes.") - parser.add_argument("current.txt", type=argparse.FileType('r'), help="current.txt") - parser.add_argument("previous.txt", nargs='?', type=argparse.FileType('r'), default=None, - help="previous.txt") - args = vars(parser.parse_args()) - - if args['no_color']: - USE_COLOR = False - elif args['color']: - USE_COLOR = True - else: - USE_COLOR = sys.stdout.isatty() - - if args['allow_google']: - ALLOW_GOOGLE = True - - current_file = args['current.txt'] - base_current_file = args['base_current'] - previous_file = args['previous.txt'] - base_previous_file = args['base_previous'] - filters = args['filter'] - if not filters: - filters = [] - title = args['title'] - if not title: - title = current_file.name - - if args['show_deprecations_at_birth']: - with current_file as f: - cur = _parse_stream(f) - with previous_file as f: - prev = _parse_stream(f) - show_deprecations_at_birth(cur, prev) - sys.exit() - - if args['show_stats']: - with current_file as f: - cur = _parse_stream(f) - with previous_file as f: - prev = _parse_stream(f) - show_stats(cur, prev) - sys.exit() - - classes_with_base = [] - - with current_file as f: - if base_current_file: - with base_current_file as base_f: - cur_fail, cur_noticed = examine_stream(f, base_f, - out_classes_with_base=classes_with_base) - else: - cur_fail, cur_noticed = examine_stream(f, out_classes_with_base=classes_with_base) - - if not previous_file is None: - with previous_file as f: - if base_previous_file: - with base_previous_file as base_f: - prev_fail, prev_noticed = examine_stream(f, base_f, - in_classes_with_base=classes_with_base) - else: - prev_fail, prev_noticed = examine_stream(f, in_classes_with_base=classes_with_base) - - # ignore errors from previous API level - for p in prev_fail: - if p in cur_fail: - del cur_fail[p] - - # ignore classes unchanged from previous API level - for k, v in prev_noticed.iteritems(): - if k in cur_noticed and v == cur_noticed[k]: - del cur_noticed[k] - - """ - # NOTE: disabled because of memory pressure - # look for compatibility issues - compat_fail = verify_compat(cur, prev) - - print "%s API compatibility issues %s\n" % ((format(fg=WHITE, bg=BLUE, bold=True), format(reset=True))) - for f in sorted(compat_fail): - print compat_fail[f] - print - """ - - # ignore everything but the given filters, if provided - if filters: - cur_fail = dict([(key, failure) for key, failure in cur_fail.iteritems() - if match_filter(filters, failure.clazz.fullname)]) - - if args['show_noticed'] and len(cur_noticed) != 0: - print "%s API changes noticed %s\n" % ((format(fg=WHITE, bg=BLUE, bold=True), format(reset=True))) - for f in sorted(cur_noticed.keys()): - print f - print - - if len(cur_fail) != 0: - print "%s API style issues: %s %s" % ((format(fg=WHITE, bg=BLUE, bold=True), - title, format(reset=True))) - for f in filters: - print "%s filter: %s %s" % ((format(fg=WHITE, bg=BLUE, bold=True), - f, format(reset=True))) - print - for f in sorted(cur_fail): - print cur_fail[f] - print - print "%d errors" % len(cur_fail) - sys.exit(77) - -if __name__ == "__main__": - try: - main() - except KeyboardInterrupt: - sys.exit(1) diff --git a/tools/apilint/apilint_sha.sh b/tools/apilint/apilint_sha.sh deleted file mode 100755 index 2a45b10392d7..000000000000 --- a/tools/apilint/apilint_sha.sh +++ /dev/null @@ -1,4 +0,0 @@ -#!/bin/bash -if git show --name-only --pretty=format: $1 | grep api/ > /dev/null; then - python tools/apilint/apilint.py <(git show $1:api/current.txt) <(git show $1^:api/current.txt) -fi diff --git a/tools/apilint/apilint_sha_system.sh b/tools/apilint/apilint_sha_system.sh deleted file mode 100755 index 8538a3d904f5..000000000000 --- a/tools/apilint/apilint_sha_system.sh +++ /dev/null @@ -1,23 +0,0 @@ -#!/bin/bash - -# Copyright (C) 2018 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the 'License'); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an 'AS IS' BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -if git show --name-only --pretty=format: $1 | grep api/ > /dev/null; then - python tools/apilint/apilint.py \ - --base-current <(git show $1:api/current.txt) \ - --base-previous <(git show $1^:api/current.txt) \ - <(git show $1:api/system-current.txt) \ - <(git show $1^:api/system-current.txt) -fi diff --git a/tools/apilint/apilint_stats.sh b/tools/apilint/apilint_stats.sh deleted file mode 100755 index 052d9a5265fe..000000000000 --- a/tools/apilint/apilint_stats.sh +++ /dev/null @@ -1,7 +0,0 @@ -#!/bin/bash -API=28 -while [ $API -gt 14 ]; do - echo "# Changes in API $((API))" - python tools/apilint/apilint.py --show-stats ../../prebuilts/sdk/$((API))/public/api/android.txt ../../prebuilts/sdk/$((API-1))/public/api/android.txt - let API=API-1 -done diff --git a/tools/apilint/apilint_test.py b/tools/apilint/apilint_test.py deleted file mode 100644 index 811cb9aa23d5..000000000000 --- a/tools/apilint/apilint_test.py +++ /dev/null @@ -1,414 +0,0 @@ -#!/usr/bin/env python - -# Copyright (C) 2018 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the 'License'); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an 'AS IS' BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import unittest - -import apilint - -def cls(pkg, name): - return apilint.Class(apilint.Package(999, "package %s {" % pkg, None), 999, - "public final class %s {" % name, None) - -_ri = apilint._retry_iterator - -c1 = cls("android.app", "ActivityManager") -c2 = cls("android.app", "Notification") -c3 = cls("android.app", "Notification.Action") -c4 = cls("android.graphics", "Bitmap") - -class UtilTests(unittest.TestCase): - def test_retry_iterator(self): - it = apilint._retry_iterator([1, 2, 3, 4]) - self.assertEqual(it.next(), 1) - self.assertEqual(it.next(), 2) - self.assertEqual(it.next(), 3) - it.send("retry") - self.assertEqual(it.next(), 3) - self.assertEqual(it.next(), 4) - with self.assertRaises(StopIteration): - it.next() - - def test_retry_iterator_one(self): - it = apilint._retry_iterator([1]) - self.assertEqual(it.next(), 1) - it.send("retry") - self.assertEqual(it.next(), 1) - with self.assertRaises(StopIteration): - it.next() - - def test_retry_iterator_one(self): - it = apilint._retry_iterator([1]) - self.assertEqual(it.next(), 1) - it.send("retry") - self.assertEqual(it.next(), 1) - with self.assertRaises(StopIteration): - it.next() - - def test_skip_to_matching_class_found(self): - it = _ri([c1, c2, c3, c4]) - self.assertEquals(apilint._skip_to_matching_class(it, c3), - c3) - self.assertEqual(it.next(), c4) - - def test_skip_to_matching_class_not_found(self): - it = _ri([c1, c2, c3, c4]) - self.assertEquals(apilint._skip_to_matching_class(it, cls("android.content", "ContentProvider")), - None) - self.assertEqual(it.next(), c4) - - def test_yield_until_matching_class_found(self): - it = _ri([c1, c2, c3, c4]) - self.assertEquals(list(apilint._yield_until_matching_class(it, c3)), - [c1, c2]) - self.assertEqual(it.next(), c4) - - def test_yield_until_matching_class_not_found(self): - it = _ri([c1, c2, c3, c4]) - self.assertEquals(list(apilint._yield_until_matching_class(it, cls("android.content", "ContentProvider"))), - [c1, c2, c3]) - self.assertEqual(it.next(), c4) - - def test_yield_until_matching_class_None(self): - it = _ri([c1, c2, c3, c4]) - self.assertEquals(list(apilint._yield_until_matching_class(it, None)), - [c1, c2, c3, c4]) - - -faulty_current_txt = """ -// Signature format: 2.0 -package android.app { - public final class Activity { - } - - public final class WallpaperColors implements android.os.Parcelable { - ctor public WallpaperColors(@NonNull android.os.Parcel); - method public int describeContents(); - method public void writeToParcel(@NonNull android.os.Parcel, int); - field @NonNull public static final android.os.Parcelable.Creator<android.app.WallpaperColors> CREATOR; - } -} -""".strip().split('\n') - -ok_current_txt = """ -// Signature format: 2.0 -package android.app { - public final class Activity { - } - - public final class WallpaperColors implements android.os.Parcelable { - ctor public WallpaperColors(); - method public int describeContents(); - method public void writeToParcel(@NonNull android.os.Parcel, int); - field @NonNull public static final android.os.Parcelable.Creator<android.app.WallpaperColors> CREATOR; - } -} -""".strip().split('\n') - -system_current_txt = """ -// Signature format: 2.0 -package android.app { - public final class WallpaperColors implements android.os.Parcelable { - method public int getSomething(); - } -} -""".strip().split('\n') - - - -class BaseFileTests(unittest.TestCase): - def test_base_file_avoids_errors(self): - failures, _ = apilint.examine_stream(system_current_txt, ok_current_txt) - self.assertEquals(failures, {}) - - def test_class_with_base_finds_same_errors(self): - failures_with_classes_with_base, _ = apilint.examine_stream("", faulty_current_txt, - in_classes_with_base=[cls("android.app", "WallpaperColors")]) - failures_with_system_txt, _ = apilint.examine_stream(system_current_txt, faulty_current_txt) - - self.assertEquals(failures_with_classes_with_base.keys(), failures_with_system_txt.keys()) - - def test_classes_with_base_is_emited(self): - classes_with_base = [] - _, _ = apilint.examine_stream(system_current_txt, faulty_current_txt, - out_classes_with_base=classes_with_base) - self.assertEquals(map(lambda x: x.fullname, classes_with_base), ["android.app.WallpaperColors"]) - -class ParseV2Stream(unittest.TestCase): - def test_field_kinds(self): - api = apilint._parse_stream(""" -// Signature format: 2.0 -package android { - public enum SomeEnum { - enum_constant public static final android.SomeEnum ENUM_CONST; - field public static final int FIELD_CONST; - property public final int someProperty; - ctor public SomeEnum(); - method public Object? getObject(); - } -} - """.strip().split('\n')) - - self.assertEquals(api['android.SomeEnum'].fields[0].split[0], 'enum_constant') - self.assertEquals(api['android.SomeEnum'].fields[1].split[0], 'field') - self.assertEquals(api['android.SomeEnum'].fields[2].split[0], 'property') - self.assertEquals(api['android.SomeEnum'].ctors[0].split[0], 'ctor') - self.assertEquals(api['android.SomeEnum'].methods[0].split[0], 'method') - -class ParseV3Stream(unittest.TestCase): - def test_field_kinds(self): - api = apilint._parse_stream(""" -// Signature format: 3.0 -package a { - - public final class ContextKt { - method public static inline <reified T> T! getSystemService(android.content.Context); - method public static inline void withStyledAttributes(android.content.Context, android.util.AttributeSet? set = null, int[] attrs, @AttrRes int defStyleAttr = 0, @StyleRes int defStyleRes = 0, kotlin.jvm.functions.Function1<? super android.content.res.TypedArray,kotlin.Unit> block); - } -} - """.strip().split('\n')) - self.assertEquals(api['a.ContextKt'].methods[0].name, 'getSystemService') - self.assertEquals(api['a.ContextKt'].methods[0].split[:4], ['method', 'public', 'static', 'inline']) - self.assertEquals(api['a.ContextKt'].methods[1].name, 'withStyledAttributes') - self.assertEquals(api['a.ContextKt'].methods[1].split[:4], ['method', 'public', 'static', 'inline']) - -class V2TokenizerTests(unittest.TestCase): - def _test(self, raw, expected): - self.assertEquals(apilint.V2Tokenizer(raw).tokenize(), expected) - - def test_simple(self): - self._test(" method public some.Type someName(some.Argument arg, int arg);", - ['method', 'public', 'some.Type', 'someName', '(', 'some.Argument', - 'arg', ',', 'int', 'arg', ')', ';']) - self._test("class Some.Class extends SomeOther {", - ['class', 'Some.Class', 'extends', 'SomeOther', '{']) - - def test_varargs(self): - self._test("name(String...)", - ['name', '(', 'String', '...', ')']) - - def test_kotlin(self): - self._test("String? name(String!...)", - ['String', '?', 'name', '(', 'String', '!', '...', ')']) - - def test_annotation(self): - self._test("method @Nullable public void name();", - ['method', '@', 'Nullable', 'public', 'void', 'name', '(', ')', ';']) - - def test_annotation_args(self): - self._test("@Some(val=1, other=2) class Class {", - ['@', 'Some', '(', 'val', '=', '1', ',', 'other', '=', '2', ')', - 'class', 'Class', '{']) - def test_comment(self): - self._test("some //comment", ['some']) - - def test_strings(self): - self._test(r'"" "foo" "\"" "\\"', ['""', '"foo"', r'"\""', r'"\\"']) - - def test_at_interface(self): - self._test("public @interface Annotation {", - ['public', '@interface', 'Annotation', '{']) - - def test_array_type(self): - self._test("int[][]", ['int', '[]', '[]']) - - def test_generics(self): - self._test("<>foobar<A extends Object>", - ['<', '>', 'foobar', '<', 'A', 'extends', 'Object', '>']) - -class V2ParserTests(unittest.TestCase): - def _cls(self, raw): - pkg = apilint.Package(999, "package pkg {", None) - return apilint.Class(pkg, 1, raw, '', sig_format=2) - - def _method(self, raw, cls=None): - if not cls: - cls = self._cls("class Class {") - return apilint.Method(cls, 1, raw, '', sig_format=2) - - def _field(self, raw): - cls = self._cls("class Class {") - return apilint.Field(cls, 1, raw, '', sig_format=2) - - def test_parse_package(self): - pkg = apilint.Package(999, "package wifi.p2p {", None) - self.assertEquals("wifi.p2p", pkg.name) - - def test_class(self): - cls = self._cls("@Deprecated @IntRange(from=1, to=2) public static abstract class Some.Name extends Super<Class> implements Interface<Class> {") - self.assertTrue('deprecated' in cls.split) - self.assertTrue('static' in cls.split) - self.assertTrue('abstract' in cls.split) - self.assertTrue('class' in cls.split) - self.assertEquals('Super', cls.extends) - self.assertEquals('Interface', cls.implements) - self.assertEquals('pkg.Some.Name', cls.fullname) - - def test_enum(self): - cls = self._cls("public enum Some.Name {") - self._field("enum_constant public static final android.ValueType COLOR;") - - def test_interface(self): - cls = self._cls("@Deprecated @IntRange(from=1, to=2) public interface Some.Name extends Interface<Class> {") - self.assertTrue('deprecated' in cls.split) - self.assertTrue('interface' in cls.split) - self.assertEquals('Interface', cls.extends) - self.assertEquals('Interface', cls.implements) - self.assertEquals('pkg.Some.Name', cls.fullname) - - def test_at_interface(self): - cls = self._cls("@java.lang.annotation.Target({java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.CONSTRUCTOR, java.lang.annotation.ElementType.LOCAL_VARIABLE}) @java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.CLASS) public @interface SuppressLint {") - self.assertTrue('@interface' in cls.split) - self.assertEquals('pkg.SuppressLint', cls.fullname) - - def test_parse_method(self): - m = self._method("method @Deprecated public static native <T> Class<T>[][] name(" - + "Class<T[]>[][], Class<T[][][]>[][]...) throws Exception, T;") - self.assertTrue('static' in m.split) - self.assertTrue('public' in m.split) - self.assertTrue('method' in m.split) - self.assertTrue('native' in m.split) - self.assertTrue('deprecated' in m.split) - self.assertEquals('java.lang.Class[][]', m.typ) - self.assertEquals('name', m.name) - self.assertEquals(['java.lang.Class[][]', 'java.lang.Class[][]...'], m.args) - self.assertEquals(['java.lang.Exception', 'T'], m.throws) - - def test_ctor(self): - m = self._method("ctor @Deprecated <T> ClassName();") - self.assertTrue('ctor' in m.split) - self.assertTrue('deprecated' in m.split) - self.assertEquals('ctor', m.typ) - self.assertEquals('ClassName', m.name) - - def test_parse_annotation_method(self): - cls = self._cls("@interface Annotation {") - self._method('method abstract String category() default "";', cls=cls) - self._method('method abstract boolean deepExport() default false;', cls=cls) - self._method('method abstract ViewDebug.FlagToString[] flagMapping() default {};', cls=cls) - self._method('method abstract ViewDebug.FlagToString[] flagMapping() default (double)java.lang.Float.NEGATIVE_INFINITY;', cls=cls) - - def test_parse_string_field(self): - f = self._field('field @Deprecated public final String SOME_NAME = "value";') - self.assertTrue('field' in f.split) - self.assertTrue('deprecated' in f.split) - self.assertTrue('final' in f.split) - self.assertEquals('java.lang.String', f.typ) - self.assertEquals('SOME_NAME', f.name) - self.assertEquals('value', f.value) - - def test_parse_field(self): - f = self._field('field public Object SOME_NAME;') - self.assertTrue('field' in f.split) - self.assertEquals('java.lang.Object', f.typ) - self.assertEquals('SOME_NAME', f.name) - self.assertEquals(None, f.value) - - def test_parse_int_field(self): - f = self._field('field public int NAME = 123;') - self.assertTrue('field' in f.split) - self.assertEquals('int', f.typ) - self.assertEquals('NAME', f.name) - self.assertEquals('123', f.value) - - def test_parse_quotient_field(self): - f = self._field('field public int NAME = (0.0/0.0);') - self.assertTrue('field' in f.split) - self.assertEquals('int', f.typ) - self.assertEquals('NAME', f.name) - self.assertEquals('( 0.0 / 0.0 )', f.value) - - def test_kotlin_types(self): - self._field('field public List<Integer[]?[]!>?[]![]? NAME;') - self._method("method <T?> Class<T!>?[]![][]? name(Type!, Type argname," - + "Class<T?>[][]?[]!...!) throws Exception, T;") - self._method("method <T> T name(T a = 1, T b = A(1), Lambda f = { false }, N? n = null, " - + """double c = (1/0), float d = 1.0f, String s = "heyo", char c = 'a');""") - - def test_kotlin_operator(self): - self._method('method public operator void unaryPlus(androidx.navigation.NavDestination);') - self._method('method public static operator androidx.navigation.NavDestination get(androidx.navigation.NavGraph, @IdRes int id);') - self._method('method public static operator <T> T get(androidx.navigation.NavigatorProvider, kotlin.reflect.KClass<T> clazz);') - - def test_kotlin_property(self): - self._field('property public VM value;') - self._field('property public final String? action;') - - def test_kotlin_varargs(self): - self._method('method public void error(int p = "42", Integer int2 = "null", int p1 = "42", vararg String args);') - - def test_kotlin_default_values(self): - self._method('method public void foo(String! = null, String! = "Hello World", int = 42);') - self._method('method void method(String, String firstArg = "hello", int secondArg = "42", String thirdArg = "world");') - self._method('method void method(String, String firstArg = "hello", int secondArg = "42");') - self._method('method void method(String, String firstArg = "hello");') - self._method('method void edit(android.Type, boolean commit = false, Function1<? super Editor,kotlin.Unit> action);') - self._method('method <K, V> LruCache<K,V> lruCache(int maxSize, Function2<? super K,? super V,java.lang.Integer> sizeOf = { _, _ -> 1 }, Function1<? extends V> create = { (V)null }, Function4<kotlin.Unit> onEntryRemoved = { _, _, _, _ -> });') - self._method('method android.Bitmap? drawToBitmap(android.View, android.Config config = android.graphics.Bitmap.Config.ARGB_8888);') - self._method('method void emptyLambda(Function0<kotlin.Unit> sizeOf = {});') - self._method('method void method1(int p = 42, Integer? int2 = null, int p1 = 42, String str = "hello world", java.lang.String... args);') - self._method('method void method2(int p, int int2 = (2 * int) * some.other.pkg.Constants.Misc.SIZE);') - self._method('method void method3(String str, int p, int int2 = double(int) + str.length);') - self._method('method void print(test.pkg.Foo foo = test.pkg.Foo());') - - def test_type_use_annotation(self): - self._method('method public static int codePointAt(char @NonNull [], int);') - self._method('method @NonNull public java.util.Set<java.util.Map.@NonNull Entry<K,V>> entrySet();') - - m = self._method('method @NonNull public java.lang.annotation.@NonNull Annotation @NonNull [] getAnnotations();') - self.assertEquals('java.lang.annotation.Annotation[]', m.typ) - - m = self._method('method @NonNull public abstract java.lang.annotation.@NonNull Annotation @NonNull [] @NonNull [] getParameterAnnotations();') - self.assertEquals('java.lang.annotation.Annotation[][]', m.typ) - - m = self._method('method @NonNull public @NonNull String @NonNull [] split(@NonNull String, int);') - self.assertEquals('java.lang.String[]', m.typ) - -class PackageTests(unittest.TestCase): - def _package(self, raw): - return apilint.Package(123, raw, "blame") - - def test_regular_package(self): - p = self._package("package an.pref.int {") - self.assertEquals('an.pref.int', p.name) - - def test_annotation_package(self): - p = self._package("package @RestrictTo(a.b.C) an.pref.int {") - self.assertEquals('an.pref.int', p.name) - - def test_multi_annotation_package(self): - p = self._package("package @Rt(a.b.L_G_P) @RestrictTo(a.b.C) an.pref.int {") - self.assertEquals('an.pref.int', p.name) - -class FilterTests(unittest.TestCase): - def test_filter_match_prefix(self): - self.assertTrue(apilint.match_filter(["a"], "a.B")) - self.assertTrue(apilint.match_filter(["a.B"], "a.B.C")) - - def test_filter_dont_match_prefix(self): - self.assertFalse(apilint.match_filter(["c"], "a.B")) - self.assertFalse(apilint.match_filter(["a."], "a.B")) - self.assertFalse(apilint.match_filter(["a.B."], "a.B.C")) - - def test_filter_match_exact(self): - self.assertTrue(apilint.match_filter(["a.B"], "a.B")) - - def test_filter_dont_match_exact(self): - self.assertFalse(apilint.match_filter([""], "a.B")) - self.assertFalse(apilint.match_filter(["a.C"], "a.B")) - self.assertFalse(apilint.match_filter(["a.C"], "a.B")) - -if __name__ == "__main__": - unittest.main() |