Merge "Fix build."
diff --git a/Android.mk b/Android.mk
index 9828ea6..56374bf 100644
--- a/Android.mk
+++ b/Android.mk
@@ -171,7 +171,6 @@
core/java/android/nfc/INfcAdapterExtras.aidl \
core/java/android/nfc/INfcTag.aidl \
core/java/android/nfc/INfcCardEmulation.aidl \
- core/java/android/nfc/INfcUnlockSettings.aidl \
core/java/android/os/IBatteryPropertiesListener.aidl \
core/java/android/os/IBatteryPropertiesRegistrar.aidl \
core/java/android/os/ICancellationSignal.aidl \
diff --git a/api/current.txt b/api/current.txt
index fe2e228..a81f383 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -5278,6 +5278,80 @@
}
+package android.app.wearable {
+
+ public final class WearableActionExtensions implements android.app.Notification.Action.Builder.Extender android.os.Parcelable {
+ method public android.app.Notification.Action.Builder applyTo(android.app.Notification.Action.Builder);
+ method public int describeContents();
+ method public static android.app.wearable.WearableActionExtensions from(android.app.Notification.Action);
+ method public boolean isAvailableOffline();
+ method public void writeToParcel(android.os.Parcel, int);
+ }
+
+ public static final class WearableActionExtensions.Builder {
+ ctor public WearableActionExtensions.Builder();
+ ctor public WearableActionExtensions.Builder(android.app.wearable.WearableActionExtensions);
+ method public android.app.wearable.WearableActionExtensions build();
+ method public android.app.wearable.WearableActionExtensions.Builder setAvailableOffline(boolean);
+ }
+
+ public final class WearableNotificationExtensions implements android.app.Notification.Builder.Extender android.os.Parcelable {
+ method public android.app.Notification.Builder applyTo(android.app.Notification.Builder);
+ method public int describeContents();
+ method public static android.app.wearable.WearableNotificationExtensions from(android.app.Notification);
+ method public android.app.Notification.Action getAction(int);
+ method public int getActionCount();
+ method public android.app.Notification.Action[] getActions();
+ method public android.graphics.Bitmap getBackground();
+ method public int getContentAction();
+ method public int getContentIcon();
+ method public int getContentIconGravity();
+ method public boolean getContentIntentAvailableOffline();
+ method public int getCustomContentHeight();
+ method public int getCustomSizePreset();
+ method public android.app.PendingIntent getDisplayIntent();
+ method public int getGravity();
+ method public boolean getHintHideIcon();
+ method public boolean getHintShowBackgroundOnly();
+ method public android.app.Notification[] getPages();
+ method public boolean getStartScrollBottom();
+ method public void writeToParcel(android.os.Parcel, int);
+ field public static final android.os.Parcelable.Creator CREATOR;
+ field public static final int SIZE_DEFAULT = 0; // 0x0
+ field public static final int SIZE_FULLSCREEN = 16; // 0x10
+ field public static final int SIZE_LARGE = 256; // 0x100
+ field public static final int SIZE_MEDIUM = 128; // 0x80
+ field public static final int SIZE_SMALL = 64; // 0x40
+ field public static final int SIZE_XSMALL = 32; // 0x20
+ field public static final int UNSET_ACTION_INDEX = -1; // 0xffffffff
+ }
+
+ public static final class WearableNotificationExtensions.Builder {
+ ctor public WearableNotificationExtensions.Builder();
+ ctor public WearableNotificationExtensions.Builder(android.app.wearable.WearableNotificationExtensions);
+ method public android.app.wearable.WearableNotificationExtensions.Builder addAction(android.app.Notification.Action);
+ method public android.app.wearable.WearableNotificationExtensions.Builder addActions(java.util.List<android.app.Notification.Action>);
+ method public android.app.wearable.WearableNotificationExtensions.Builder addPage(android.app.Notification);
+ method public android.app.wearable.WearableNotificationExtensions.Builder addPages(java.util.List<android.app.Notification>);
+ method public android.app.wearable.WearableNotificationExtensions build();
+ method public android.app.wearable.WearableNotificationExtensions.Builder clearActions();
+ method public android.app.wearable.WearableNotificationExtensions.Builder clearPages();
+ method public android.app.wearable.WearableNotificationExtensions.Builder setBackground(android.graphics.Bitmap);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setContentAction(int);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setContentIcon(int);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setContentIconGravity(int);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setContentIntentAvailableOffline(boolean);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setCustomContentHeight(int);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setCustomSizePreset(int);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setDisplayIntent(android.app.PendingIntent);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setGravity(int);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setHintHideIcon(boolean);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setHintShowBackgroundOnly(boolean);
+ method public android.app.wearable.WearableNotificationExtensions.Builder setStartScrollBottom(boolean);
+ }
+
+}
+
package android.appwidget {
public class AppWidgetHost {
@@ -10425,10 +10499,10 @@
ctor public Outline();
ctor public Outline(android.graphics.Outline);
method public boolean canClip();
- method public boolean isValid();
- method public void reset();
+ method public boolean isEmpty();
method public void set(android.graphics.Outline);
method public void setConvexPath(android.graphics.Path);
+ method public void setEmpty();
method public void setOval(int, int, int, int);
method public void setOval(android.graphics.Rect);
method public void setRect(int, int, int, int);
@@ -17574,11 +17648,6 @@
method public android.nfc.NfcAdapter getDefaultAdapter();
}
- public class NfcUnlock {
- method public static synchronized android.nfc.NfcUnlock getInstance(android.nfc.NfcAdapter);
- method public boolean getNfcUnlockEnabled();
- }
-
public final class Tag implements android.os.Parcelable {
method public int describeContents();
method public byte[] getId();
@@ -23939,7 +24008,6 @@
field public static final java.lang.String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern";
field public static final deprecated java.lang.String LOGGING_ID = "logging_id";
field public static final deprecated java.lang.String NETWORK_PREFERENCE = "network_preference";
- field public static final java.lang.String NFC_UNLOCK_ENABLED = "nfc_unlock_enabled";
field public static final java.lang.String PARENTAL_CONTROL_ENABLED = "parental_control_enabled";
field public static final java.lang.String PARENTAL_CONTROL_LAST_UPDATE = "parental_control_last_update";
field public static final java.lang.String PARENTAL_CONTROL_REDIRECT_URL = "parental_control_redirect_url";
diff --git a/core/java/android/app/ContextImpl.java b/core/java/android/app/ContextImpl.java
index 6324d4c..b247580 100644
--- a/core/java/android/app/ContextImpl.java
+++ b/core/java/android/app/ContextImpl.java
@@ -1377,7 +1377,7 @@
ActivityManagerNative.getDefault().broadcastIntent(
mMainThread.getApplicationThread(), intent, resolvedType, rd,
initialCode, initialData, initialExtras, receiverPermission,
- AppOpsManager.OP_NONE, true, false, user.getIdentifier());
+ appOp, true, false, user.getIdentifier());
} catch (RemoteException e) {
}
}
diff --git a/core/java/android/app/wearable/WearableActionExtensions.java b/core/java/android/app/wearable/WearableActionExtensions.java
new file mode 100644
index 0000000..1888fcf
--- /dev/null
+++ b/core/java/android/app/wearable/WearableActionExtensions.java
@@ -0,0 +1,162 @@
+/*
+ * 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.
+ */
+
+package android.app.wearable;
+
+import android.app.Notification;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * Wearable extensions to notification actions. To add extensions to an action,
+ * create a new {@link WearableActionExtensions} object using
+ * {@link WearableActionExtensions.Builder} and apply it to a
+ * {@link android.app.Notification.Action.Builder}.
+ *
+ * <pre class="prettyprint">
+ * Notification.Action action = new Notification.Action.Builder(
+ * R.drawable.archive_all, "Archive all", actionIntent)
+ * .apply(new WearableActionExtensions.Builder()
+ * .setAvailableOffline(false)
+ * .build())
+ * .build();
+ * </pre>
+ */
+public final class WearableActionExtensions implements Notification.Action.Builder.Extender,
+ Parcelable {
+ /** Notification action extra which contains wearable extensions */
+ static final String EXTRA_WEARABLE_EXTENSIONS = "android.wearable.EXTENSIONS";
+
+ // Flags bitwise-ored to mFlags
+ static final int FLAG_AVAILABLE_OFFLINE = 1 << 0;
+
+ // Default value for flags integer
+ static final int DEFAULT_FLAGS = FLAG_AVAILABLE_OFFLINE;
+
+ private final int mFlags;
+
+ private WearableActionExtensions(int flags) {
+ mFlags = flags;
+ }
+
+ private WearableActionExtensions(Parcel in) {
+ mFlags = in.readInt();
+ }
+
+ /**
+ * Create a {@link WearableActionExtensions} by reading wearable extensions present on an
+ * existing notification action.
+ * @param action the notification action to inspect.
+ * @return a new {@link WearableActionExtensions} object.
+ */
+ public static WearableActionExtensions from(Notification.Action action) {
+ WearableActionExtensions extensions = action.getExtras().getParcelable(
+ EXTRA_WEARABLE_EXTENSIONS);
+ if (extensions != null) {
+ return extensions;
+ } else {
+ // Return a WearableActionExtensions with default values.
+ return new Builder().build();
+ }
+ }
+
+ /**
+ * Get whether this action is available when the wearable device is not connected to
+ * a companion device. The user can still trigger this action when the wearable device is
+ * offline, but a visual hint will indicate that the action may not be available.
+ * Defaults to true.
+ */
+ public boolean isAvailableOffline() {
+ return (mFlags & FLAG_AVAILABLE_OFFLINE) != 0;
+ }
+
+ @Override
+ public Notification.Action.Builder applyTo(Notification.Action.Builder builder) {
+ builder.getExtras().putParcelable(EXTRA_WEARABLE_EXTENSIONS, this);
+ return builder;
+ }
+
+ @Override
+ public int describeContents() {
+ return 0;
+ }
+
+ @Override
+ public void writeToParcel(Parcel out, int flags) {
+ out.writeInt(mFlags);
+ }
+
+ /**
+ * Builder for {@link WearableActionExtensions} objects, which adds wearable extensions to
+ * notification actions. To extend an action, create an instance of this class, call the set
+ * methods present, call {@link #build}, and finally apply the options to a
+ * {@link Notification.Builder} using its {@link android.app.Notification.Builder#apply} method.
+ */
+ public static final class Builder {
+ private int mFlags = DEFAULT_FLAGS;
+
+ /**
+ * Construct a builder to be used for adding wearable extensions to notification actions.
+ *
+ * <pre class="prettyprint">
+ * Notification.Action action = new Notification.Action.Builder(
+ * R.drawable.archive_all, "Archive all", actionIntent)
+ * .apply(new WearableActionExtensions.Builder()
+ * .setAvailableOffline(false)
+ * .build())
+ * .build();</pre>
+ */
+ public Builder() {
+ }
+
+ /**
+ * Create a {@link Builder} by reading wearable extensions present on an
+ * existing {@code WearableActionExtensions} object.
+ * @param other the existing extensions to inspect.
+ */
+ public Builder(WearableActionExtensions other) {
+ mFlags = other.mFlags;
+ }
+
+ /**
+ * Set whether this action is available when the wearable device is not connected to
+ * a companion device. The user can still trigger this action when the wearable device is
+ * offline, but a visual hint will indicate that the action may not be available.
+ * Defaults to true.
+ */
+ public Builder setAvailableOffline(boolean availableOffline) {
+ setFlag(FLAG_AVAILABLE_OFFLINE, availableOffline);
+ return this;
+ }
+
+ /**
+ * Build a new {@link WearableActionExtensions} object with the extensions
+ * currently present on this builder.
+ * @return the extensions object.
+ */
+ public WearableActionExtensions build() {
+ return new WearableActionExtensions(mFlags);
+ }
+
+ private void setFlag(int mask, boolean value) {
+ if (value) {
+ mFlags |= mask;
+ } else {
+ mFlags &= ~mask;
+ }
+ }
+ }
+}
diff --git a/core/java/android/app/wearable/WearableNotificationExtensions.java b/core/java/android/app/wearable/WearableNotificationExtensions.java
new file mode 100644
index 0000000..75f7f85
--- /dev/null
+++ b/core/java/android/app/wearable/WearableNotificationExtensions.java
@@ -0,0 +1,712 @@
+/*
+ * 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.
+ */
+
+package android.app.wearable;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.graphics.Bitmap;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.view.Gravity;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Helper class that contains wearable extensions for notifications.
+ * <p class="note"> See
+ * <a href="{@docRoot}wear/notifications/creating.html">Creating Notifications
+ * for Android Wear</a> for more information on how to use this class.
+ * <p>
+ * To create a notification with wearable extensions:
+ * <ol>
+ * <li>Create a {@link Notification.Builder}, setting any desired
+ * properties.
+ * <li>Create a {@link WearableNotificationExtensions.Builder}.
+ * <li>Set wearable-specific properties using the
+ * {@code add} and {@code set} methods of {@link WearableNotificationExtensions.Builder}.
+ * <li>Call {@link WearableNotificationExtensions.Builder#build} to build the extensions
+ * object.
+ * <li>Call {@link Notification.Builder#apply} to apply the extensions to a notification.
+ * <li>Post the notification to the notification system with the
+ * {@code NotificationManager.notify(...)} methods.
+ * </ol>
+ *
+ * <pre class="prettyprint">
+ * Notification notif = new Notification.Builder(mContext)
+ * .setContentTitle("New mail from " + sender.toString())
+ * .setContentText(subject)
+ * .setSmallIcon(R.drawable.new_mail)
+ * .apply(new new WearableNotificationExtensions.Builder()
+ * .setContentIcon(R.drawable.new_mail)
+ * .build())
+ * .build();
+ * NotificationManager notificationManger =
+ * (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+ * notificationManger.notify(0, notif);</pre>
+ *
+ * <p>Wearable extensions can be accessed on an existing notification by using the
+ * {@link WearableNotificationExtensions#from} function.
+ *
+ * <pre class="prettyprint">
+ * WearableNotificationExtensions wearableExtensions = WearableNotificationExtensions.from(
+ * notification);
+ * Notification[] pages = wearableExtensions.getPages();
+ * </pre>
+ */
+public final class WearableNotificationExtensions implements Notification.Builder.Extender,
+ Parcelable {
+ /**
+ * Sentinel value for an action index that is unset.
+ */
+ public static final int UNSET_ACTION_INDEX = -1;
+
+ /**
+ * Size value for use with {@link Builder#setCustomSizePreset} to show this notification with
+ * default sizing.
+ * <p>For custom display notifications created using {@link Builder#setDisplayIntent},
+ * the default is {@link #SIZE_LARGE}. All other notifications size automatically based
+ * on their content.
+ */
+ public static final int SIZE_DEFAULT = 0;
+
+ /**
+ * Size value for use with {@link Builder#setCustomSizePreset} to show this notification full
+ * screen.
+ */
+ public static final int SIZE_FULLSCREEN = 1 << 4;
+
+ /**
+ * Size value for use with {@link Builder#setCustomSizePreset} to show this notification
+ * with an extra small size.
+ * <p>This value is only applicable for custom display notifications created using
+ * {@link Builder#setDisplayIntent}.
+ */
+ public static final int SIZE_XSMALL = 1 << 5;
+
+ /**
+ * Size value for use with {@link Builder#setCustomSizePreset} to show this notification
+ * with a small size.
+ * <p>This value is only applicable for custom display notifications created using
+ * {@link Builder#setDisplayIntent}.
+ */
+ public static final int SIZE_SMALL = 1 << 6;
+
+ /**
+ * Size value for use with {@link Builder#setCustomSizePreset} to show this notification
+ * with a medium size.
+ * <p>This value is only applicable for custom display notifications created using
+ * {@link Builder#setDisplayIntent}.
+ */
+ public static final int SIZE_MEDIUM = 1 << 7;
+
+ /**
+ * Size value for use with {@link Builder#setCustomSizePreset} to show this notification
+ * with a large size.
+ * <p>This value is only applicable for custom display notifications created using
+ * {@link Builder#setDisplayIntent}.
+ */
+ public static final int SIZE_LARGE = 1 << 8;
+
+ /** Notification extra which contains wearable extensions */
+ static final String EXTRA_WEARABLE_EXTENSIONS = "android.wearable.EXTENSIONS";
+
+ // Flags bitwise-ored to mFlags
+ static final int FLAG_CONTENT_INTENT_AVAILABLE_OFFLINE = 1 << 0;
+ static final int FLAG_HINT_HIDE_ICON = 1 << 1;
+ static final int FLAG_HINT_SHOW_BACKGROUND_ONLY = 1 << 2;
+ static final int FLAG_START_SCROLL_BOTTOM = 1 << 3;
+ static final int FLAG_SIZE_FULLSCREEN = SIZE_FULLSCREEN;
+ static final int FLAG_SIZE_XSMALL = SIZE_XSMALL;
+ static final int FLAG_SIZE_SMALL = SIZE_SMALL;
+ static final int FLAG_SIZE_MEDIUM = SIZE_MEDIUM;
+ static final int FLAG_SIZE_LARGE = SIZE_LARGE;
+
+ // Default value for flags integer
+ static final int DEFAULT_FLAGS = FLAG_CONTENT_INTENT_AVAILABLE_OFFLINE;
+
+ // Mask that will match all mutually exclusive size flags
+ static final int SIZE_FLAGS_MASK = FLAG_SIZE_XSMALL | FLAG_SIZE_SMALL | FLAG_SIZE_MEDIUM
+ | FLAG_SIZE_LARGE | FLAG_SIZE_FULLSCREEN;
+
+ private final Notification.Action[] mActions;
+ private final int mFlags;
+ private final PendingIntent mDisplayIntent;
+ private final Notification[] mPages;
+ private final Bitmap mBackground;
+ private final int mContentIcon;
+ private final int mContentIconGravity;
+ private final int mContentActionIndex;
+ private final int mCustomContentHeight;
+ private final int mGravity;
+
+ private WearableNotificationExtensions(Notification.Action[] actions, int flags,
+ PendingIntent displayIntent, Notification[] pages, Bitmap background,
+ int contentIcon, int contentIconGravity, int contentActionIndex,
+ int customContentHeight, int gravity) {
+ mActions = actions;
+ mFlags = flags;
+ mDisplayIntent = displayIntent;
+ mPages = pages;
+ mBackground = background;
+ mContentIcon = contentIcon;
+ mContentIconGravity = contentIconGravity;
+ mContentActionIndex = contentActionIndex;
+ mCustomContentHeight = customContentHeight;
+ mGravity = gravity;
+ }
+
+ private WearableNotificationExtensions(Parcel in) {
+ mActions = in.createTypedArray(Notification.Action.CREATOR);
+ mFlags = in.readInt();
+ mDisplayIntent = in.readParcelable(PendingIntent.class.getClassLoader());
+ mPages = in.createTypedArray(Notification.CREATOR);
+ mBackground = in.readParcelable(Bitmap.class.getClassLoader());
+ mContentIcon = in.readInt();
+ mContentIconGravity = in.readInt();
+ mContentActionIndex = in.readInt();
+ mCustomContentHeight = in.readInt();
+ mGravity = in.readInt();
+ }
+
+ /**
+ * Create a {@link WearableNotificationExtensions} by reading wearable extensions present on an
+ * existing notification.
+ * @param notif the notification to inspect.
+ * @return a new {@link WearableNotificationExtensions} object.
+ */
+ public static WearableNotificationExtensions from(Notification notif) {
+ WearableNotificationExtensions extensions = notif.extras.getParcelable(
+ EXTRA_WEARABLE_EXTENSIONS);
+ if (extensions != null) {
+ return extensions;
+ } else {
+ // Return a WearableNotificationExtensions with default values.
+ return new Builder().build();
+ }
+ }
+
+ /**
+ * Apply wearable extensions to a notification that is being built. This is typically
+ * called by {@link Notification.Builder#apply} method of {@link Notification.Builder}.
+ */
+ @Override
+ public Notification.Builder applyTo(Notification.Builder builder) {
+ builder.getExtras().putParcelable(EXTRA_WEARABLE_EXTENSIONS, this);
+ return builder;
+ }
+
+ /**
+ * Get the number of wearable actions present on this notification.
+ *
+ * @return the number of wearable actions for this notification
+ */
+ public int getActionCount() {
+ return mActions.length;
+ }
+
+ /**
+ * Get a {@link Notification.Action} for the wearable action at {@code actionIndex}.
+ * @param actionIndex the index of the desired wearable action
+ */
+ public Notification.Action getAction(int actionIndex) {
+ return mActions[actionIndex];
+ }
+
+ /**
+ * Get the wearable actions present on this notification.
+ */
+ public Notification.Action[] getActions() {
+ return mActions;
+ }
+
+ /**
+ * Get the intent to launch inside of an activity view when displaying this
+ * notification. This {@code PendingIntent} should be for an activity.
+ */
+ public PendingIntent getDisplayIntent() {
+ return mDisplayIntent;
+ }
+
+ /**
+ * Get the array of additional pages of content for displaying this notification. The
+ * current notification forms the first page, and elements within this array form
+ * subsequent pages. This field can be used to separate a notification into multiple
+ * sections.
+ * @return the pages for this notification
+ */
+ public Notification[] getPages() {
+ return mPages;
+ }
+
+ /**
+ * Get a background image to be displayed behind the notification content.
+ * Contrary to the {@link Notification.BigPictureStyle}, this background
+ * will work with any notification style.
+ *
+ * @return the background image
+ * @see Builder#setBackground
+ */
+ public Bitmap getBackground() {
+ return mBackground;
+ }
+
+ /**
+ * Get an icon that goes with the content of this notification.
+ */
+ public int getContentIcon() {
+ return mContentIcon;
+ }
+
+ /**
+ * Get the gravity that the content icon should have within the notification display.
+ * Supported values include {@link Gravity#START} and {@link Gravity#END}. The default
+ * value is {@link android.view.Gravity#END}.
+ * @see #getContentIcon
+ */
+ public int getContentIconGravity() {
+ return mContentIconGravity;
+ }
+
+ /**
+ * Get the action index of an action from this notification to show as clickable with
+ * the content of this notification page. When the user clicks this notification page,
+ * this action will trigger. This action will no longer display separately from the
+ * notification content. The action's icon will display with optional subtext provided
+ * by the action's title.
+ *
+ * <p>If wearable specific actions are present, this index will apply to that list,
+ * otherwise it will apply to the main notification's actions list.
+ */
+ public int getContentAction() {
+ return mContentActionIndex;
+ }
+
+ /**
+ * Get the gravity that this notification should have within the available viewport space.
+ * Supported values include {@link Gravity#TOP}, {@link Gravity#CENTER_VERTICAL} and
+ * {@link android.view.Gravity#BOTTOM}. The default value is
+ * {@link android.view.Gravity#BOTTOM}.
+ */
+ public int getGravity() {
+ return mGravity;
+ }
+
+ /**
+ * Get the custom size preset for the display of this notification out of the available
+ * presets found in {@link WearableNotificationExtensions}, e.g. {@link #SIZE_LARGE}.
+ * <p>Some custom size presets are only applicable for custom display notifications created
+ * using {@link Builder#setDisplayIntent}. Check the documentation for the preset in question.
+ * See also {@link Builder#setCustomContentHeight} and {@link Builder#setCustomSizePreset}.
+ */
+ public int getCustomSizePreset() {
+ return mFlags & SIZE_FLAGS_MASK;
+ }
+
+ /**
+ * Get the custom height in pixels for the display of this notification's content.
+ * <p>This option is only available for custom display notifications created
+ * using {@link Builder#setDisplayIntent}. See also {@link Builder#setCustomSizePreset} and
+ * {@link Builder#setCustomContentHeight}.
+ */
+ public int getCustomContentHeight() {
+ return mCustomContentHeight;
+ }
+
+ /**
+ * Get whether the scrolling position for the contents of this notification should start
+ * at the bottom of the contents instead of the top when the contents are too long to
+ * display within the screen. Default is false (start scroll at the top).
+ */
+ public boolean getStartScrollBottom() {
+ return (mFlags & FLAG_START_SCROLL_BOTTOM) != 0;
+ }
+
+ /**
+ * Get whether the content intent is available when the wearable device is not connected
+ * to a companion device. The user can still trigger this intent when the wearable device is
+ * offline, but a visual hint will indicate that the content intent may not be available.
+ * Defaults to true.
+ */
+ public boolean getContentIntentAvailableOffline() {
+ return (mFlags & FLAG_CONTENT_INTENT_AVAILABLE_OFFLINE) != 0;
+ }
+
+ /**
+ * Get a hint that this notification's icon should not be displayed.
+ * @return {@code true} if this icon should not be displayed, false otherwise.
+ * The default value is {@code false} if this was never set.
+ */
+ public boolean getHintHideIcon() {
+ return (mFlags & FLAG_HINT_HIDE_ICON) != 0;
+ }
+
+ /**
+ * Get a visual hint that only the background image of this notification should be
+ * displayed, and other semantic content should be hidden. This hint is only applicable
+ * to sub-pages added using {@link Builder#addPage}.
+ */
+ public boolean getHintShowBackgroundOnly() {
+ return (mFlags & FLAG_HINT_SHOW_BACKGROUND_ONLY) != 0;
+ }
+
+ @Override
+ public int describeContents() {
+ return 0;
+ }
+
+ @Override
+ public void writeToParcel(Parcel out, int flags) {
+ out.writeTypedArray(mActions, flags);
+ out.writeInt(mFlags);
+ out.writeParcelable(mDisplayIntent, flags);
+ out.writeTypedArray(mPages, flags);
+ out.writeParcelable(mBackground, flags);
+ out.writeInt(mContentIcon);
+ out.writeInt(mContentIconGravity);
+ out.writeInt(mContentActionIndex);
+ out.writeInt(mCustomContentHeight);
+ out.writeInt(mGravity);
+ }
+
+ /**
+ * Builder to apply wearable notification extensions to a {@link Notification.Builder}
+ * object.
+ *
+ * <p>You can chain the "set" methods for this builder in any order,
+ * but you must call the {@link #build} method and then the {@link Notification.Builder#apply}
+ * method to apply your extensions to a notification.
+ *
+ * <pre class="prettyprint">
+ * Notification notif = new Notification.Builder(mContext)
+ * .setContentTitle("New mail from " + sender.toString())
+ * .setContentText(subject)
+ * .setSmallIcon(R.drawable.new_mail);
+ * .apply(new WearableNotificationExtensions.Builder()
+ * .setContentIcon(R.drawable.new_mail)
+ * .build())
+ * .build();
+ * NotificationManager notificationManger =
+ * (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+ * notificationManager.notify(0, notif);</pre>
+ */
+ public static final class Builder {
+ private final List<Notification.Action> mActions =
+ new ArrayList<Notification.Action>();
+ private int mFlags = DEFAULT_FLAGS;
+ private PendingIntent mDisplayIntent;
+ private final List<Notification> mPages = new ArrayList<Notification>();
+ private Bitmap mBackground;
+ private int mContentIcon;
+ private int mContentIconGravity = Gravity.END;
+ private int mContentActionIndex = UNSET_ACTION_INDEX;
+ private int mCustomContentHeight;
+ private int mGravity = Gravity.BOTTOM;
+
+ /**
+ * Construct a builder to be used for adding wearable extensions to notifications.
+ *
+ * <pre class="prettyprint">
+ * Notification notif = new Notification.Builder(mContext)
+ * .setContentTitle("New mail from " + sender.toString())
+ * .setContentText(subject)
+ * .setSmallIcon(R.drawable.new_mail);
+ * .apply(new WearableNotificationExtensions.Builder()
+ * .setContentIcon(R.drawable.new_mail)
+ * .build())
+ * .build();
+ * NotificationManager notificationManger =
+ * (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+ * notificationManager.notify(0, notif);</pre>
+ */
+ public Builder() {
+ }
+
+ /**
+ * Create a {@link Builder} by reading wearable extensions present on an
+ * existing {@code WearableNotificationExtensions} object.
+ * @param other the existing extensions to inspect.
+ */
+ public Builder(WearableNotificationExtensions other) {
+ Collections.addAll(mActions, other.mActions);
+ mFlags = other.mFlags;
+ mDisplayIntent = other.mDisplayIntent;
+ Collections.addAll(mPages, other.mPages);
+ mBackground = other.mBackground;
+ mContentIcon = other.mContentIcon;
+ mContentIconGravity = other.mContentIconGravity;
+ mContentActionIndex = other.mContentActionIndex;
+ mCustomContentHeight = other.mCustomContentHeight;
+ mGravity = other.mGravity;
+ }
+
+ /**
+ * Add a wearable action to this notification.
+ *
+ * <p>When wearable actions are added using this method, the set of actions that
+ * show on a wearable device splits from devices that only show actions added
+ * using {@link android.app.Notification.Builder#addAction}. This allows for customization
+ * of which actions display on different devices.
+ *
+ * @param action the action to add to this notification
+ * @return this object for method chaining
+ * @see Notification.Action
+ */
+ public Builder addAction(Notification.Action action) {
+ mActions.add(action);
+ return this;
+ }
+
+ /**
+ * Adds wearable actions to this notification.
+ *
+ * <p>When wearable actions are added using this method, the set of actions that
+ * show on a wearable device splits from devices that only show actions added
+ * using {@link android.app.Notification.Builder#addAction}. This allows for customization
+ * of which actions display on different devices.
+ *
+ * @param actions the actions to add to this notification
+ * @return this object for method chaining
+ * @see Notification.Action
+ */
+ public Builder addActions(List<Notification.Action> actions) {
+ mActions.addAll(actions);
+ return this;
+ }
+
+ /**
+ * Clear all wearable actions present on this builder.
+ * @return this object for method chaining.
+ * @see #addAction
+ */
+ public Builder clearActions() {
+ mActions.clear();
+ return this;
+ }
+
+ /**
+ * Set an intent to launch inside of an activity view when displaying
+ * this notification. This {@link android.app.PendingIntent} should be for an activity.
+ *
+ * @param intent the {@link android.app.PendingIntent} for an activity
+ * @return this object for method chaining
+ * @see WearableNotificationExtensions#getDisplayIntent
+ */
+ public Builder setDisplayIntent(PendingIntent intent) {
+ mDisplayIntent = intent;
+ return this;
+ }
+
+ /**
+ * Add an additional page of content to display with this notification. The current
+ * notification forms the first page, and pages added using this function form
+ * subsequent pages. This field can be used to separate a notification into multiple
+ * sections.
+ *
+ * @param page the notification to add as another page
+ * @return this object for method chaining
+ * @see WearableNotificationExtensions#getPages
+ */
+ public Builder addPage(Notification page) {
+ mPages.add(page);
+ return this;
+ }
+
+ /**
+ * Add additional pages of content to display with this notification. The current
+ * notification forms the first page, and pages added using this function form
+ * subsequent pages. This field can be used to separate a notification into multiple
+ * sections.
+ *
+ * @param pages a list of notifications
+ * @return this object for method chaining
+ * @see WearableNotificationExtensions#getPages
+ */
+ public Builder addPages(List<Notification> pages) {
+ mPages.addAll(pages);
+ return this;
+ }
+
+ /**
+ * Clear all additional pages present on this builder.
+ * @return this object for method chaining.
+ * @see #addPage
+ */
+ public Builder clearPages() {
+ mPages.clear();
+ return this;
+ }
+
+ /**
+ * Set a background image to be displayed behind the notification content.
+ * Contrary to the {@link Notification.BigPictureStyle}, this background
+ * will work with any notification style.
+ *
+ * @param background the background bitmap
+ * @return this object for method chaining
+ * @see WearableNotificationExtensions#getBackground
+ */
+ public Builder setBackground(Bitmap background) {
+ mBackground = background;
+ return this;
+ }
+
+ /**
+ * Set an icon that goes with the content of this notification.
+ */
+ public Builder setContentIcon(int icon) {
+ mContentIcon = icon;
+ return this;
+ }
+
+ /**
+ * Set the gravity that the content icon should have within the notification display.
+ * Supported values include {@link Gravity#START} and {@link Gravity#END}. The default
+ * value is {@link android.view.Gravity#END}.
+ * @see #setContentIcon
+ */
+ public Builder setContentIconGravity(int contentIconGravity) {
+ mContentIconGravity = contentIconGravity;
+ return this;
+ }
+
+ /**
+ * Set an action from this notification's actions to be clickable with the content of
+ * this notification page. This action will no longer display separately from the
+ * notification content. This action's icon will display with optional subtext provided
+ * by the action's title.
+ * @param actionIndex The index of the action to hoist on the current notification page.
+ * If wearable actions are present, this index will apply to that list,
+ * otherwise it will apply to the main notification's actions list.
+ */
+ public Builder setContentAction(int actionIndex) {
+ mContentActionIndex = actionIndex;
+ return this;
+ }
+
+ /**
+ * Set the gravity that this notification should have within the available viewport space.
+ * Supported values include {@link Gravity#TOP}, {@link Gravity#CENTER_VERTICAL} and
+ * {@link Gravity#BOTTOM}. The default value is {@link Gravity#BOTTOM}.
+ */
+ public Builder setGravity(int gravity) {
+ mGravity = gravity;
+ return this;
+ }
+
+ /**
+ * Set the custom size preset for the display of this notification out of the available
+ * presets found in {@link WearableNotificationExtensions}, e.g. {@link #SIZE_LARGE}.
+ * <p>Some custom size presets are only applicable for custom display notifications created
+ * using {@link Builder#setDisplayIntent}. Check the documentation for the preset in
+ * question. See also {@link Builder#setCustomContentHeight} and
+ * {@link #getCustomSizePreset}.
+ */
+ public Builder setCustomSizePreset(int sizePreset) {
+ mFlags &= ~SIZE_FLAGS_MASK; // Clear existing size preset bits
+ mFlags |= sizePreset & SIZE_FLAGS_MASK; // And merge in the new value with protection
+ return this;
+ }
+
+ /**
+ * Set the custom height in pixels for the display of this notification's content.
+ * <p>This option is only available for custom display notifications created
+ * using {@link Builder#setDisplayIntent}. See also {@link Builder#setCustomSizePreset} and
+ * {@link #getCustomContentHeight}.
+ */
+ public Builder setCustomContentHeight(int height) {
+ mCustomContentHeight = height;
+ return this;
+ }
+
+ /**
+ * Set whether the scrolling position for the contents of this notification should start
+ * at the bottom of the contents instead of the top when the contents are too long to
+ * display within the screen. Default is false (start scroll at the top).
+ */
+ public Builder setStartScrollBottom(boolean startScrollBottom) {
+ setFlag(FLAG_START_SCROLL_BOTTOM, startScrollBottom);
+ return this;
+ }
+
+ /**
+ * Set whether the content intent is available when the wearable device is not connected
+ * to a companion device. The user can still trigger this intent when the wearable device
+ * is offline, but a visual hint will indicate that the content intent may not be available.
+ * Defaults to true.
+ */
+ public Builder setContentIntentAvailableOffline(boolean contentIntentAvailableOffline) {
+ setFlag(FLAG_CONTENT_INTENT_AVAILABLE_OFFLINE, contentIntentAvailableOffline);
+ return this;
+ }
+
+ /**
+ * Set a hint that this notification's icon should not be displayed.
+ * @param hintHideIcon {@code true} to hide the icon, {@code false} otherwise.
+ * @return this object for method chaining
+ */
+ public Builder setHintHideIcon(boolean hintHideIcon) {
+ setFlag(FLAG_HINT_HIDE_ICON, hintHideIcon);
+ return this;
+ }
+
+ /**
+ * Set a visual hint that only the background image of this notification should be
+ * displayed, and other semantic content should be hidden. This hint is only applicable
+ * to sub-pages added using {@link #addPage}.
+ */
+ public Builder setHintShowBackgroundOnly(boolean hintShowBackgroundOnly) {
+ setFlag(FLAG_HINT_SHOW_BACKGROUND_ONLY, hintShowBackgroundOnly);
+ return this;
+ }
+
+ /**
+ * Build a new {@link WearableNotificationExtensions} object with the extensions
+ * currently present on this builder.
+ * @return the extensions object.
+ */
+ public WearableNotificationExtensions build() {
+ return new WearableNotificationExtensions(
+ mActions.toArray(new Notification.Action[mActions.size()]), mFlags,
+ mDisplayIntent, mPages.toArray(new Notification[mPages.size()]),
+ mBackground, mContentIcon, mContentIconGravity, mContentActionIndex,
+ mCustomContentHeight, mGravity);
+ }
+
+ private void setFlag(int mask, boolean value) {
+ if (value) {
+ mFlags |= mask;
+ } else {
+ mFlags &= ~mask;
+ }
+ }
+ }
+
+ public static final Creator<WearableNotificationExtensions> CREATOR =
+ new Creator<WearableNotificationExtensions>() {
+ @Override
+ public WearableNotificationExtensions createFromParcel(Parcel in) {
+ return new WearableNotificationExtensions(in);
+ }
+
+ @Override
+ public WearableNotificationExtensions[] newArray(int size) {
+ return new WearableNotificationExtensions[size];
+ }
+ };
+}
diff --git a/core/java/android/nfc/INfcAdapter.aidl b/core/java/android/nfc/INfcAdapter.aidl
index 635a50f..9218c11 100644
--- a/core/java/android/nfc/INfcAdapter.aidl
+++ b/core/java/android/nfc/INfcAdapter.aidl
@@ -25,7 +25,6 @@
import android.nfc.INfcAdapterExtras;
import android.nfc.INfcTag;
import android.nfc.INfcCardEmulation;
-import android.nfc.INfcUnlockSettings;
import android.os.Bundle;
/**
@@ -36,7 +35,6 @@
INfcTag getNfcTagInterface();
INfcCardEmulation getNfcCardEmulationInterface();
INfcAdapterExtras getNfcAdapterExtrasInterface(in String pkg);
- INfcUnlockSettings getNfcUnlockSettingsInterface();
int getState();
boolean disable(boolean saveState);
diff --git a/core/java/android/nfc/INfcUnlockSettings.aidl b/core/java/android/nfc/INfcUnlockSettings.aidl
deleted file mode 100644
index 649eeed..0000000
--- a/core/java/android/nfc/INfcUnlockSettings.aidl
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.nfc;
-
-import android.nfc.Tag;
-import java.util.List;
-
-/**
- * Interface to NFC unlock functionality.
- *
- * @hide
- */
-interface INfcUnlockSettings {
-
- /**
- * Checks the validity of the tag and attempts to unlock the screen.
- *
- * @return true if the screen was successfuly unlocked.
- */
- boolean tryUnlock(int userId, in Tag tag);
-
- /**
- * Registers the given tag as an unlock tag. Subsequent calls to {@code tryUnlock}
- * with the same {@code tag} should succeed.
- *
- * @return true if the tag was successfully registered.
- */
- boolean registerTag(int userId, in Tag tag);
-
- /**
- * Deregisters the tag with the corresponding timestamp.
- * Subsequent calls to {@code tryUnlock} with the same tag should fail.
- *
- * @return true if the tag was successfully deleted.
- */
- boolean deregisterTag(int userId, long timestamp);
-
- /**
- * Used for user-visible rendering of registered tags.
- *
- * @return a list of the times in millis since epoch when the registered tags were paired.
- */
- long[] getTagRegistryTimes(int userId);
-
- /**
- * Determines the state of the NFC unlock feature.
- *
- * @return true if NFC unlock is enabled.
- */
- boolean getNfcUnlockEnabled(int userId);
-
- /**
- * Sets the state [ON | OFF] of the NFC unlock feature.
- */
- void setNfcUnlockEnabled(int userId, boolean enabled);
-}
diff --git a/core/java/android/nfc/NfcAdapter.java b/core/java/android/nfc/NfcAdapter.java
index 96a3947..dd8e41c 100644
--- a/core/java/android/nfc/NfcAdapter.java
+++ b/core/java/android/nfc/NfcAdapter.java
@@ -292,7 +292,6 @@
static INfcAdapter sService;
static INfcTag sTagService;
static INfcCardEmulation sCardEmulationService;
- static INfcUnlockSettings sNfcUnlockSettingsService;
/**
* The NfcAdapter object for each application context.
@@ -433,13 +432,6 @@
throw new UnsupportedOperationException();
}
- try {
- sNfcUnlockSettingsService = sService.getNfcUnlockSettingsInterface();
- } catch (RemoteException e) {
- Log.e(TAG, "could not retrieve NFC unlock settings service");
- sNfcUnlockSettingsService = null;
- }
-
sIsInitialized = true;
}
if (context == null) {
@@ -557,22 +549,6 @@
}
/**
- * Returns the binder interface to the NFC unlock service.
- *
- * @throws UnsupportedOperationException if the service is not available.
- * @hide
- */
- public INfcUnlockSettings getNfcUnlockSettingsService() throws UnsupportedOperationException {
- isEnabled();
-
- if (sNfcUnlockSettingsService == null) {
- throw new UnsupportedOperationException("NfcUnlockSettingsService not available");
- }
-
- return sNfcUnlockSettingsService;
- }
-
- /**
* NFC service dead - attempt best effort recovery
* @hide
*/
diff --git a/core/java/android/nfc/NfcUnlock.java b/core/java/android/nfc/NfcUnlock.java
deleted file mode 100644
index 82dcd96..0000000
--- a/core/java/android/nfc/NfcUnlock.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright (C) 2013 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.nfc;
-
-import static com.android.internal.util.Preconditions.checkNotNull;
-
-import android.annotation.Nullable;
-import android.app.ActivityManager;
-import android.content.Context;
-import android.os.RemoteException;
-import android.os.SystemProperties;
-import android.util.Log;
-
-import java.util.HashMap;
-
-/**
- * Provides an interface to read and update NFC unlock settings.
- * <p/>
- * Allows system services (currently exclusively LockSettingsService) to
- * register NFC tags to be used to unlock the device, as well as the ability
- * to enable/disable the service entirely.
- *
- */
-public class NfcUnlock {
-
- /**
- * Action to unlock the device.
- *
- * @hide
- */
- public static final String ACTION_NFC_UNLOCK = "android.nfc.ACTION_NFC_UNLOCK";
- /**
- * Permission to unlock the device.
- *
- * @hide
- */
- public static final String NFC_UNLOCK_PERMISSION = "android.permission.NFC_UNLOCK";
-
- /**
- * Property to enable NFC Unlock
- *
- * @hide
- */
- public static final String PROPERTY = "ro.com.android.nfc.unlock";
-
- private static final String TAG = "NfcUnlock";
- private static HashMap<Context, NfcUnlock> sNfcUnlocks = new HashMap<Context, NfcUnlock>();
-
- private final Context mContext;
- private final boolean mEnabled;
- private INfcUnlockSettings sService;
-
- private NfcUnlock(Context context, INfcUnlockSettings service) {
- this.mContext = checkNotNull(context);
- this.sService = checkNotNull(service);
- this.mEnabled = getPropertyEnabled();
- }
-
- /**
- * Returns an instance of {@link NfcUnlock}.
- */
- public static synchronized NfcUnlock getInstance(NfcAdapter nfcAdapter) {
- Context context = nfcAdapter.getContext();
- if (context == null) {
- Log.e(TAG, "NfcAdapter context is null");
- throw new UnsupportedOperationException();
- }
-
- NfcUnlock manager = sNfcUnlocks.get(context);
- if (manager == null) {
- INfcUnlockSettings service = nfcAdapter.getNfcUnlockSettingsService();
- manager = new NfcUnlock(context, service);
- sNfcUnlocks.put(context, manager);
- }
-
- return manager;
- }
-
- /**
- * Registers the given {@code tag} as an unlock tag.
- *
- * @return true if the tag was successfully registered.
- * @hide
- */
- public boolean registerTag(Tag tag) {
- enforcePropertyEnabled();
-
- int currentUser = ActivityManager.getCurrentUser();
-
- try {
- return sService.registerTag(currentUser, tag);
- } catch (RemoteException e) {
- recoverService();
- if (sService == null) {
- Log.e(TAG, "Failed to recover NfcUnlockSettingsService");
- return false;
- }
-
- try {
- return sService.registerTag(currentUser, tag);
- } catch (RemoteException ee) {
- Log.e(TAG, "Failed to reach NfcUnlockSettingsService", ee);
- return false;
- }
- }
- }
-
- /**
- * Deregisters the given {@code tag} as an unlock tag.
- *
- * @return true if the tag was successfully deregistered.
- * @hide
- */
- public boolean deregisterTag(long timestamp) {
- enforcePropertyEnabled();
- int currentUser = ActivityManager.getCurrentUser();
-
- try {
- return sService.deregisterTag(currentUser, timestamp);
- } catch (RemoteException e) {
- recoverService();
- if (sService == null) {
- Log.e(TAG, "Failed to recover NfcUnlockSettingsService");
- return false;
- }
-
- try {
- return sService.deregisterTag(currentUser, timestamp);
- } catch (RemoteException ee) {
- Log.e(TAG, "Failed to reach NfcUnlockSettingsService", ee);
- return false;
- }
- }
- }
-
- /**
- * Determines the enable state of the NFC unlock feature.
- *
- * @return true if NFC unlock is enabled.
- */
- public boolean getNfcUnlockEnabled() {
- enforcePropertyEnabled();
- int currentUser = ActivityManager.getCurrentUser();
-
- try {
- return sService.getNfcUnlockEnabled(currentUser);
- } catch (RemoteException e) {
- recoverService();
- if (sService == null) {
- Log.e(TAG, "Failed to recover NfcUnlockSettingsService");
- return false;
- }
-
- try {
- return sService.getNfcUnlockEnabled(currentUser);
- } catch (RemoteException ee) {
- Log.e(TAG, "Failed to reach NfcUnlockSettingsService", ee);
- return false;
- }
- }
- }
-
- /**
- * Set the enable state of the NFC unlock feature.
- *
- * @return true if the setting was successfully persisted.
- * @hide
- */
- public boolean setNfcUnlockEnabled(boolean enabled) {
- enforcePropertyEnabled();
- int currentUser = ActivityManager.getCurrentUser();
-
- try {
- sService.setNfcUnlockEnabled(currentUser, enabled);
- return true;
- } catch (RemoteException e) {
- recoverService();
- if (sService == null) {
- Log.e(TAG, "Failed to recover NfcUnlockSettingsService");
- return false;
- }
-
- try {
- sService.setNfcUnlockEnabled(currentUser, enabled);
- return true;
- } catch (RemoteException ee) {
- Log.e(TAG, "Failed to reach NfcUnlockSettingsService", ee);
- return false;
- }
-
- }
- }
-
- /**
- * Returns a list of times (in millis since epoch) corresponding to when
- * unlock tags were registered.
- *
- * @hide
- */
- @Nullable
- public long[] getTagRegistryTimes() {
- enforcePropertyEnabled();
- int currentUser = ActivityManager.getCurrentUser();
-
- try {
- return sService.getTagRegistryTimes(currentUser);
- } catch (RemoteException e) {
- recoverService();
- if (sService == null) {
- Log.e(TAG, "Failed to recover NfcUnlockSettingsService");
- return null;
- }
-
- try {
- return sService.getTagRegistryTimes(currentUser);
- } catch (RemoteException ee) {
- Log.e(TAG, "Failed to reach NfcUnlockSettingsService", ee);
- return null;
- }
- }
- }
-
- /**
- * @hide
- */
- public static boolean getPropertyEnabled() {
- return SystemProperties.get(PROPERTY).equals("ON");
- }
-
- private void recoverService() {
- NfcAdapter adapter = NfcAdapter.getDefaultAdapter(mContext);
- sService = adapter.getNfcUnlockSettingsService();
- }
-
-
- private void enforcePropertyEnabled() {
- if (!mEnabled) {
- throw new UnsupportedOperationException("NFC Unlock property is not enabled");
- }
- }
-}
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 2d03e1d..e9ffc52 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -3477,11 +3477,6 @@
public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern";
/**
- * Whether the NFC unlock feature is enabled (0 = false, 1 = true)
- */
- public static final String NFC_UNLOCK_ENABLED = "nfc_unlock_enabled";
-
- /**
* Whether lock pattern will vibrate as user enters (0 = false, 1 =
* true)
*
diff --git a/core/java/android/view/RenderNode.java b/core/java/android/view/RenderNode.java
index b2839cb..cf125bc 100644
--- a/core/java/android/view/RenderNode.java
+++ b/core/java/android/view/RenderNode.java
@@ -366,10 +366,8 @@
* Deep copies the data into native to simplify reference ownership.
*/
public void setOutline(Outline outline) {
- if (outline == null) {
+ if (outline == null || outline.isEmpty()) {
nSetOutlineEmpty(mNativeRenderNode);
- } else if (!outline.isValid()) {
- throw new IllegalArgumentException("Outline must be valid");
} else if (outline.mRect != null) {
nSetOutlineRoundRect(mNativeRenderNode, outline.mRect.left, outline.mRect.top,
outline.mRect.right, outline.mRect.bottom, outline.mRadius);
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 6dc7286..0f21c1d 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -10680,24 +10680,30 @@
}
/**
- * Sets the outline of the view, which defines the shape of the shadow it
- * casts.
+ * Sets the {@link Outline} of the view, which defines the shape of the shadow it
+ * casts, and enables outline clipping.
* <p>
- * If the outline is not set or is null, shadows will be cast from the
+ * By default, a View queries its Outline from its background drawable, via
+ * {@link Drawable#getOutline(Outline)}. Manually setting the Outline with this method allows
+ * this behavior to be overridden.
+ * <p>
+ * If the outline is empty or is null, shadows will be cast from the
* bounds of the View.
+ * <p>
+ * Only outlines that return true from {@link Outline#canClip()} may be used for clipping.
*
* @param outline The new outline of the view.
- * Must be {@link android.graphics.Outline#isValid() valid.}
+ *
+ * @see #setClipToOutline(boolean)
+ * @see #getClipToOutline()
*/
public void setOutline(@Nullable Outline outline) {
- if (outline != null && !outline.isValid()) {
- throw new IllegalArgumentException("Outline must not be invalid");
- }
-
mPrivateFlags3 |= PFLAG3_OUTLINE_DEFINED;
- if (outline == null) {
- mOutline = null;
+ if (outline == null || outline.isEmpty()) {
+ if (mOutline != null) {
+ mOutline.setEmpty();
+ }
} else {
// always copy the path since caller may reuse
if (mOutline == null) {
@@ -10708,12 +10714,30 @@
mRenderNode.setOutline(mOutline);
}
+ /**
+ * Returns whether the Outline should be used to clip the contents of the View.
+ * <p>
+ * Note that this flag will only be respected if the View's Outline returns true from
+ * {@link Outline#canClip()}.
+ *
+ * @see #setOutline(Outline)
+ * @see #setClipToOutline(boolean)
+ */
public final boolean getClipToOutline() {
return mRenderNode.getClipToOutline();
}
+ /**
+ * Sets whether the View's Outline should be used to clip the contents of the View.
+ * <p>
+ * Note that this flag will only be respected if the View's Outline returns true from
+ * {@link Outline#canClip()}.
+ *
+ * @see #setOutline(Outline)
+ * @see #getClipToOutline()
+ */
public void setClipToOutline(boolean clipToOutline) {
- // TODO: add a fast invalidation here
+ damageInParent();
if (getClipToOutline() != clipToOutline) {
mRenderNode.setClipToOutline(clipToOutline);
}
@@ -10726,10 +10750,10 @@
mOutline = new Outline();
} else {
//invalidate outline, to ensure background calculates it
- mOutline.reset();
+ mOutline.setEmpty();
}
if (mBackground.getOutline(mOutline)) {
- if (!mOutline.isValid()) {
+ if (mOutline.isEmpty()) {
throw new IllegalStateException("Background drawable failed to build outline");
}
mRenderNode.setOutline(mOutline);
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index a97d5fc..7b200c4 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -833,15 +833,8 @@
<!-- Allows access to the loop radio (Android@Home mesh network) device.
@hide -->
<permission android:name="android.permission.LOOP_RADIO"
- android:permissionGroup="android.permission-group.NETWORK"
- android:protectionLevel="signature|system" />
-
- <!-- Allows for the NFC process to unlock the device
- @hide This should only be used by the Nfc apk
- -->
- <permission android:name="android.permission.NFC_UNLOCK"
- android:permissionGroup="android.permission-group.SYSTEM_TOOLS"
- android:protectionLevel="signature" />
+ android:permissionGroup="android.permission-group.NETWORK"
+ android:protectionLevel="signature|system" />
<!-- ================================== -->
<!-- Permissions for accessing accounts -->
diff --git a/graphics/java/android/graphics/Outline.java b/graphics/java/android/graphics/Outline.java
index c6ba75c..d87c3cb 100644
--- a/graphics/java/android/graphics/Outline.java
+++ b/graphics/java/android/graphics/Outline.java
@@ -23,9 +23,9 @@
/**
* Defines a simple shape, used for bounding graphical regions.
- *
+ * <p>
* Can be used with a View, or computed by a Drawable, to drive the shape of shadows cast by a
- * View.
+ * View, or to clip the contents of the View.
*
* @see View#setOutline(Outline)
* @see Drawable#getOutline(Outline)
@@ -41,7 +41,7 @@
public Path mPath;
/**
- * Constructs an invalid Outline. Call one of the setter methods to make
+ * Constructs an empty Outline. Call one of the setter methods to make
* the outline valid for use with a View.
*/
public Outline() {}
@@ -49,23 +49,31 @@
/**
* Constructs an Outline with a copy of the data in src.
*/
- public Outline(@Nullable Outline src) {
+ public Outline(@NonNull Outline src) {
set(src);
}
- public void reset() {
+ /**
+ * Sets the outline to be empty.
+ *
+ * @see #isEmpty()
+ */
+ public void setEmpty() {
mRadius = 0;
mRect = null;
mPath = null;
}
/**
- * Returns whether the Outline is valid for use with a View.
+ * Returns whether the Outline is empty.
* <p>
- * Outlines are invalid when constructed until a setter method is called.
+ * Outlines are empty when constructed, or if {@link #setEmpty()} is called,
+ * until a setter method is called
+ *
+ * @see #setEmpty()
*/
- public boolean isValid() {
- return mRect != null || mPath != null;
+ public boolean isEmpty() {
+ return mRect == null && mPath == null;
}
/**
diff --git a/graphics/java/android/graphics/drawable/Drawable.java b/graphics/java/android/graphics/drawable/Drawable.java
index 911fb96..3ef1d68 100644
--- a/graphics/java/android/graphics/drawable/Drawable.java
+++ b/graphics/java/android/graphics/drawable/Drawable.java
@@ -16,6 +16,7 @@
package android.graphics.drawable;
+import android.annotation.NonNull;
import android.graphics.Insets;
import android.graphics.Xfermode;
import android.os.Trace;
@@ -816,11 +817,12 @@
/**
* Return in padding the insets suggested by this Drawable for placing
* content inside the drawable's bounds. Positive values move toward the
- * center of the Drawable (set Rect.inset). Returns true if this drawable
- * actually has a padding, else false. When false is returned, the padding
- * is always set to 0.
+ * center of the Drawable (set Rect.inset).
+ *
+ * @return true if this drawable actually has a padding, else false. When false is returned,
+ * the padding is always set to 0.
*/
- public boolean getPadding(Rect padding) {
+ public boolean getPadding(@NonNull Rect padding) {
padding.set(0, 0, 0, 0);
return false;
}
@@ -841,13 +843,16 @@
* This method will be called by a View on its background Drawable after bounds change, or its
* Drawable is invalidated, if the View's Outline isn't set explicitly. This allows the
* background Drawable to define the shape of the shadow cast by the View.
- *
+ * <p>
* The default behavior defines the outline to be the bounding rectangle. Subclasses that wish
* to convey a different shape must override this method.
*
+ * @return true if this drawable actually has an outline, else false. The outline must be
+ * populated by the drawable if true is returned.
+ *
* @see View#setOutline(android.graphics.Outline)
*/
- public boolean getOutline(Outline outline) {
+ public boolean getOutline(@NonNull Outline outline) {
outline.setRect(getBounds());
return true;
}
diff --git a/packages/Keyguard/src/com/android/keyguard/KeyguardHostView.java b/packages/Keyguard/src/com/android/keyguard/KeyguardHostView.java
index f85e29f..2685447 100644
--- a/packages/Keyguard/src/com/android/keyguard/KeyguardHostView.java
+++ b/packages/Keyguard/src/com/android/keyguard/KeyguardHostView.java
@@ -16,8 +16,6 @@
package com.android.keyguard;
-import android.nfc.NfcUnlock;
-
import com.android.internal.widget.LockPatternUtils;
import com.android.keyguard.KeyguardSecurityModel.SecurityMode;
import com.android.keyguard.KeyguardUpdateMonitor.DisplayClientState;
@@ -46,6 +44,7 @@
import android.provider.Settings;
import android.util.AttributeSet;
import android.util.Log;
+import android.util.Slog;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
@@ -264,12 +263,6 @@
}
}
}
- @Override
- public void onNfcUnlock() {
- if (NfcUnlock.getPropertyEnabled()) {
- dismiss(true);
- }
- }
};
private static final boolean isMusicPlaying(int playbackState) {
diff --git a/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitor.java b/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitor.java
index d6351df..0bcd916 100644
--- a/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitor.java
+++ b/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitor.java
@@ -37,7 +37,6 @@
import static android.os.BatteryManager.EXTRA_HEALTH;
import android.media.AudioManager;
import android.media.IRemoteControlDisplay;
-import android.nfc.NfcUnlock;
import android.os.BatteryManager;
import android.os.Bundle;
import android.os.Handler;
@@ -98,7 +97,6 @@
protected static final int MSG_REPORT_EMERGENCY_CALL_ACTION = 318;
private static final int MSG_SCREEN_TURNED_ON = 319;
private static final int MSG_SCREEN_TURNED_OFF = 320;
- private static final int MSG_NFC_UNLOCK = 321;
private static final int MSG_KEYGUARD_BOUNCER_CHANGED = 322;
private static KeyguardUpdateMonitor sInstance;
@@ -204,9 +202,6 @@
case MSG_SCREEN_TURNED_ON:
handleScreenTurnedOn();
break;
- case MSG_NFC_UNLOCK:
- handleNfcUnlock();
- break;
}
}
};
@@ -356,15 +351,6 @@
}
};
- private final BroadcastReceiver mNfcUnlockReceiver = new BroadcastReceiver() {
- @Override
- public void onReceive(Context context, Intent intent) {
- if (NfcUnlock.ACTION_NFC_UNLOCK.equals(intent.getAction())) {
- mHandler.sendEmptyMessage(MSG_NFC_UNLOCK);
- }
- }
- }
- ;
/**
* When we receive a
* {@link com.android.internal.telephony.TelephonyIntents#ACTION_SIM_STATE_CHANGED} broadcast,
@@ -549,15 +535,6 @@
}
}
- private void handleNfcUnlock() {
- for (int i = 0; i < mCallbacks.size(); i++) {
- KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get();
- if (cb != null) {
- cb.onNfcUnlock();
- }
- }
- }
-
private KeyguardUpdateMonitor(Context context) {
mContext = context;
@@ -587,11 +564,6 @@
filter.addAction(Intent.ACTION_USER_REMOVED);
context.registerReceiver(mBroadcastReceiver, filter);
- final IntentFilter nfcUnlockIntentFilter = new IntentFilter();
- nfcUnlockIntentFilter.addAction(NfcUnlock.ACTION_NFC_UNLOCK);
- context.registerReceiver(mNfcUnlockReceiver, nfcUnlockIntentFilter,
- NfcUnlock.NFC_UNLOCK_PERMISSION, null /* run on default scheduler */);
-
final IntentFilter bootCompleteFilter = new IntentFilter();
bootCompleteFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
bootCompleteFilter.addAction(Intent.ACTION_BOOT_COMPLETED);
diff --git a/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitorCallback.java b/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitorCallback.java
index 91a024f..76206f7 100644
--- a/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitorCallback.java
+++ b/packages/Keyguard/src/com/android/keyguard/KeyguardUpdateMonitorCallback.java
@@ -179,10 +179,4 @@
* {@link WindowManagerPolicy#OFF_BECAUSE_OF_TIMEOUT}.
*/
public void onScreenTurnedOff(int why) { }
-
- /**
- * Called when the NFC Service has found a tag that is registered for NFC unlock.
- */
- public void onNfcUnlock() { }
-
}
diff --git a/packages/SystemUI/src/com/android/systemui/recents/AlternateRecentsComponent.java b/packages/SystemUI/src/com/android/systemui/recents/AlternateRecentsComponent.java
index 6df2a19..ffd64d4 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/AlternateRecentsComponent.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/AlternateRecentsComponent.java
@@ -64,10 +64,12 @@
mSingleCountFirstTaskRect.offset(0, (int) statusBarHeight);
mMultipleCountFirstTaskRect = replyData.getParcelable(KEY_MULTIPLE_TASK_STACK_RECT);
mMultipleCountFirstTaskRect.offset(0, (int) statusBarHeight);
- Console.log(Constants.Log.App.RecentsComponent,
- "[RecentsComponent|RecentsMessageHandler|handleMessage]",
- "singleTaskRect: " + mSingleCountFirstTaskRect +
- " multipleTaskRect: " + mMultipleCountFirstTaskRect);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.RecentsComponent,
+ "[RecentsComponent|RecentsMessageHandler|handleMessage]",
+ "singleTaskRect: " + mSingleCountFirstTaskRect +
+ " multipleTaskRect: " + mMultipleCountFirstTaskRect);
+ }
// If we had the update the animation rects as a result of onServiceConnected, then
// we check for whether we need to toggle the recents here.
@@ -83,9 +85,11 @@
class RecentsServiceConnection implements ServiceConnection {
@Override
public void onServiceConnected(ComponentName className, IBinder service) {
- Console.log(Constants.Log.App.RecentsComponent,
- "[RecentsComponent|ServiceConnection|onServiceConnected]",
- "toggleRecents: " + mToggleRecentsUponServiceBound);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.RecentsComponent,
+ "[RecentsComponent|ServiceConnection|onServiceConnected]",
+ "toggleRecents: " + mToggleRecentsUponServiceBound);
+ }
mService = new Messenger(service);
mServiceIsBound = true;
@@ -103,8 +107,10 @@
@Override
public void onServiceDisconnected(ComponentName className) {
- Console.log(Constants.Log.App.RecentsComponent,
- "[RecentsComponent|ServiceConnection|onServiceDisconnected]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.RecentsComponent,
+ "[RecentsComponent|ServiceConnection|onServiceDisconnected]");
+ }
mService = null;
mServiceIsBound = false;
}
@@ -159,7 +165,9 @@
}
public void onStart() {
- Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|start]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|start]");
+ }
// Try to create a long-running connection to the recents service
bindToRecentsService(false);
@@ -167,7 +175,9 @@
/** Shows the recents */
public void onShowRecents(boolean triggeredFromAltTab, View statusBarView) {
- Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|showRecents]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|showRecents]");
+ }
mStatusBarView = statusBarView;
mTriggeredFromAltTab = triggeredFromAltTab;
if (!mServiceIsBound) {
@@ -186,7 +196,9 @@
/** Hides the recents */
public void onHideRecents(boolean triggeredFromAltTab) {
- Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|hideRecents]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|hideRecents]");
+ }
if (mServiceIsBound) {
// Notify recents to close it
try {
@@ -202,12 +214,14 @@
/** Toggles the alternate recents activity */
public void onToggleRecents(View statusBarView) {
- Console.logStartTracingTime(Constants.Log.App.TimeRecentsStartup,
- Constants.Log.App.TimeRecentsStartupKey);
- Console.logStartTracingTime(Constants.Log.App.TimeRecentsLaunchTask,
- Constants.Log.App.TimeRecentsLaunchKey);
- Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|toggleRecents]",
- "serviceIsBound: " + mServiceIsBound);
+ if (Console.Enabled) {
+ Console.logStartTracingTime(Constants.Log.App.TimeRecentsStartup,
+ Constants.Log.App.TimeRecentsStartupKey);
+ Console.logStartTracingTime(Constants.Log.App.TimeRecentsLaunchTask,
+ Constants.Log.App.TimeRecentsLaunchKey);
+ Console.log(Constants.Log.App.RecentsComponent, "[RecentsComponent|toggleRecents]",
+ "serviceIsBound: " + mServiceIsBound);
+ }
mStatusBarView = statusBarView;
mTriggeredFromAltTab = false;
if (!mServiceIsBound) {
diff --git a/packages/SystemUI/src/com/android/systemui/recents/Console.java b/packages/SystemUI/src/com/android/systemui/recents/Console.java
index c8d97cc..33e05dd 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/Console.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/Console.java
@@ -42,6 +42,9 @@
public static final String AnsiCyan = "\u001B[36m"; // ClickEvents
public static final String AnsiWhite = "\u001B[37m";
+ // Console enabled state
+ public static final boolean Enabled = false;
+
/** Logs a key */
public static void log(String key) {
log(true, key, "", AnsiReset);
diff --git a/packages/SystemUI/src/com/android/systemui/recents/RecentsActivity.java b/packages/SystemUI/src/com/android/systemui/recents/RecentsActivity.java
index de696db..e7119f6 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/RecentsActivity.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/RecentsActivity.java
@@ -80,8 +80,10 @@
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
- Console.log(Constants.Log.App.SystemUIHandshake,
- "[RecentsActivity|serviceBroadcast]", action, Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake,
+ "[RecentsActivity|serviceBroadcast]", action, Console.AnsiRed);
+ }
if (action.equals(RecentsService.ACTION_HIDE_RECENTS_ACTIVITY)) {
if (intent.getBooleanExtra(RecentsService.EXTRA_TRIGGERED_FROM_ALT_TAB, false)) {
// Dismiss recents, launching the focused task
@@ -164,10 +166,12 @@
ssp.unbindSearchAppWidget(mAppWidgetHost, appWidgetId);
appWidgetId = -1;
}
- Console.log(Constants.Log.App.SystemUIHandshake,
- "[RecentsActivity|onCreate|settings|appWidgetId]",
- "Id: " + appWidgetId,
- Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake,
+ "[RecentsActivity|onCreate|settings|appWidgetId]",
+ "Id: " + appWidgetId,
+ Console.AnsiBlue);
+ }
}
// If there is no id, then bind a new search app widget
@@ -175,10 +179,12 @@
Pair<Integer, AppWidgetProviderInfo> widgetInfo =
ssp.bindSearchAppWidget(mAppWidgetHost);
if (widgetInfo != null) {
- Console.log(Constants.Log.App.SystemUIHandshake,
- "[RecentsActivity|onCreate|searchWidget]",
- "Id: " + widgetInfo.first + " Info: " + widgetInfo.second,
- Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake,
+ "[RecentsActivity|onCreate|searchWidget]",
+ "Id: " + widgetInfo.first + " Info: " + widgetInfo.second,
+ Console.AnsiBlue);
+ }
// Save the app widget id into the settings
config.updateSearchBarAppWidgetId(this, widgetInfo.first);
@@ -194,10 +200,12 @@
RecentsConfiguration config = RecentsConfiguration.getInstance();
int appWidgetId = config.searchBarAppWidgetId;
if (appWidgetId >= 0) {
- Console.log(Constants.Log.App.SystemUIHandshake,
- "[RecentsActivity|onCreate|addSearchAppWidgetView]",
- "Id: " + appWidgetId,
- Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake,
+ "[RecentsActivity|onCreate|addSearchAppWidgetView]",
+ "Id: " + appWidgetId,
+ Console.AnsiBlue);
+ }
mSearchAppWidgetHostView = mAppWidgetHost.createView(this, appWidgetId,
mSearchAppWidgetInfo);
Bundle opts = new Bundle();
@@ -230,11 +238,13 @@
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
- Console.logDivider(Constants.Log.App.SystemUIHandshake);
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onCreate]",
- getIntent().getAction() + " visible: " + mVisible, Console.AnsiRed);
- Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
- Constants.Log.App.TimeRecentsStartupKey, "onCreate");
+ if (Console.Enabled) {
+ Console.logDivider(Constants.Log.App.SystemUIHandshake);
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onCreate]",
+ getIntent().getAction() + " visible: " + mVisible, Console.AnsiRed);
+ Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
+ Constants.Log.App.TimeRecentsStartupKey, "onCreate");
+ }
// Initialize the loader and the configuration
RecentsTaskLoader.initialize(this);
@@ -277,11 +287,13 @@
// Reset the task launched flag if we encounter an onNewIntent() before onStop()
mTaskLaunched = false;
- Console.logDivider(Constants.Log.App.SystemUIHandshake);
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onNewIntent]",
- intent.getAction() + " visible: " + mVisible, Console.AnsiRed);
- Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
- Constants.Log.App.TimeRecentsStartupKey, "onNewIntent");
+ if (Console.Enabled) {
+ Console.logDivider(Constants.Log.App.SystemUIHandshake);
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onNewIntent]",
+ intent.getAction() + " visible: " + mVisible, Console.AnsiRed);
+ Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
+ Constants.Log.App.TimeRecentsStartupKey, "onNewIntent");
+ }
// Initialize the loader and the configuration
RecentsTaskLoader.initialize(this);
@@ -296,8 +308,10 @@
@Override
protected void onStart() {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onStart]", "",
- Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onStart]", "",
+ Console.AnsiRed);
+ }
super.onStart();
mAppWidgetHost.startListening();
mVisible = true;
@@ -305,16 +319,20 @@
@Override
protected void onResume() {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onResume]", "",
- Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onResume]", "",
+ Console.AnsiRed);
+ }
super.onResume();
}
@Override
public void onAttachedToWindow() {
- Console.log(Constants.Log.App.SystemUIHandshake,
- "[RecentsActivity|onAttachedToWindow]", "",
- Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake,
+ "[RecentsActivity|onAttachedToWindow]", "",
+ Console.AnsiRed);
+ }
super.onAttachedToWindow();
// Register the broadcast receiver to handle messages from our service
@@ -334,9 +352,11 @@
@Override
public void onDetachedFromWindow() {
- Console.log(Constants.Log.App.SystemUIHandshake,
- "[RecentsActivity|onDetachedFromWindow]", "",
- Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake,
+ "[RecentsActivity|onDetachedFromWindow]", "",
+ Console.AnsiRed);
+ }
super.onDetachedFromWindow();
// Unregister any broadcast receivers we have registered
@@ -347,15 +367,19 @@
@Override
protected void onPause() {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onPause]", "",
- Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onPause]", "",
+ Console.AnsiRed);
+ }
super.onPause();
}
@Override
protected void onStop() {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onStop]", "",
- Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onStop]", "",
+ Console.AnsiRed);
+ }
super.onStop();
mAppWidgetHost.stopListening();
@@ -365,8 +389,10 @@
@Override
protected void onDestroy() {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onDestroy]", "",
- Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsActivity|onDestroy]", "",
+ Console.AnsiRed);
+ }
super.onDestroy();
}
diff --git a/packages/SystemUI/src/com/android/systemui/recents/RecentsConfiguration.java b/packages/SystemUI/src/com/android/systemui/recents/RecentsConfiguration.java
index 8399551..d899c7b 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/RecentsConfiguration.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/RecentsConfiguration.java
@@ -95,9 +95,11 @@
Configuration.ORIENTATION_LANDSCAPE;
transposeSearchLayoutWithOrientation =
res.getBoolean(R.bool.recents_transpose_search_layout_with_orientation);
- Console.log(Constants.Log.UI.MeasureAndLayout,
- "[RecentsConfiguration|orientation]", isLandscape ? "Landscape" : "Portrait",
- Console.AnsiGreen);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.MeasureAndLayout,
+ "[RecentsConfiguration|orientation]", isLandscape ? "Landscape" : "Portrait",
+ Console.AnsiGreen);
+ }
displayRect.set(0, 0, dm.widthPixels, dm.heightPixels);
animationPxMovementPerSecond =
diff --git a/packages/SystemUI/src/com/android/systemui/recents/RecentsService.java b/packages/SystemUI/src/com/android/systemui/recents/RecentsService.java
index 1c04cb1..4bdbb20 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/RecentsService.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/RecentsService.java
@@ -45,8 +45,10 @@
@Override
public void handleMessage(Message msg) {
- Console.log(Constants.Log.App.SystemUIHandshake,
- "[RecentsService|handleMessage]", msg);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake,
+ "[RecentsService|handleMessage]", msg);
+ }
Context context = mContext.get();
if (context == null) return;
@@ -139,31 +141,41 @@
@Override
public void onCreate() {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onCreate]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onCreate]");
+ }
super.onCreate();
}
@Override
public IBinder onBind(Intent intent) {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onBind]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onBind]");
+ }
return mSystemUIMessenger.getBinder();
}
@Override
public boolean onUnbind(Intent intent) {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onUnbind]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onUnbind]");
+ }
return super.onUnbind(intent);
}
@Override
public void onRebind(Intent intent) {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onRebind]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onRebind]");
+ }
super.onRebind(intent);
}
@Override
public void onDestroy() {
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onDestroy]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsService|onDestroy]");
+ }
super.onDestroy();
}
diff --git a/packages/SystemUI/src/com/android/systemui/recents/RecentsTaskLoader.java b/packages/SystemUI/src/com/android/systemui/recents/RecentsTaskLoader.java
index 1c12ac2..4685186 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/RecentsTaskLoader.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/RecentsTaskLoader.java
@@ -50,7 +50,9 @@
/** Adds a new task to the load queue */
void addTask(Task t, boolean forceLoad) {
- Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|addTask]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|addTask]");
+ }
if (!mQueue.contains(t)) {
mQueue.add(t);
}
@@ -67,7 +69,9 @@
* force reloaded.
*/
Pair<Task, Boolean> nextTask() {
- Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|nextTask]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|nextTask]");
+ }
Task task = mQueue.poll();
Boolean forceLoadTask = null;
if (task != null) {
@@ -81,14 +85,18 @@
/** Removes a task from the load queue */
void removeTask(Task t) {
- Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|removeTask]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|removeTask]");
+ }
mQueue.remove(t);
mForceLoadSet.remove(t.key);
}
/** Clears all the tasks from the load queue */
void clearTasks() {
- Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|clearTasks]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, " [TaskResourceLoadQueue|clearTasks]");
+ }
mQueue.clear();
mForceLoadSet.clear();
}
@@ -131,7 +139,9 @@
/** Restarts the loader thread */
void start(Context context) {
- Console.log(Constants.Log.App.TaskDataLoader, "[TaskResourceLoader|start]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, "[TaskResourceLoader|start]");
+ }
mContext = context;
mCancelled = false;
mSystemServicesProxy = new SystemServicesProxy(context);
@@ -143,7 +153,9 @@
/** Requests the loader thread to stop after the current iteration */
void stop() {
- Console.log(Constants.Log.App.TaskDataLoader, "[TaskResourceLoader|stop]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, "[TaskResourceLoader|stop]");
+ }
// Mark as cancelled for the thread to pick up
mCancelled = true;
mSystemServicesProxy = null;
@@ -157,19 +169,25 @@
@Override
public void run() {
while (true) {
- Console.log(Constants.Log.App.TaskDataLoader,
- "[TaskResourceLoader|run|" + Thread.currentThread().getId() + "]");
- if (mCancelled) {
+ if (Console.Enabled) {
Console.log(Constants.Log.App.TaskDataLoader,
- "[TaskResourceLoader|cancel|" + Thread.currentThread().getId() + "]");
+ "[TaskResourceLoader|run|" + Thread.currentThread().getId() + "]");
+ }
+ if (mCancelled) {
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[TaskResourceLoader|cancel|" + Thread.currentThread().getId() + "]");
+ }
// We have to unset the context here, since the background thread may be using it
// when we call stop()
mContext = null;
// If we are cancelled, then wait until we are started again
synchronized(mLoadThread) {
try {
- Console.log(Constants.Log.App.TaskDataLoader,
- "[TaskResourceLoader|waitOnLoadThreadCancelled]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[TaskResourceLoader|waitOnLoadThreadCancelled]");
+ }
mLoadThread.wait();
} catch (InterruptedException ie) {
ie.printStackTrace();
@@ -185,10 +203,12 @@
if (t != null) {
Drawable loadIcon = mApplicationIconCache.get(t.key);
Bitmap loadThumbnail = mThumbnailCache.get(t.key);
- Console.log(Constants.Log.App.TaskDataLoader,
- " [TaskResourceLoader|load]",
- t + " icon: " + loadIcon + " thumbnail: " + loadThumbnail +
- " forceLoad: " + forceLoadTask);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ " [TaskResourceLoader|load]",
+ t + " icon: " + loadIcon + " thumbnail: " + loadThumbnail +
+ " forceLoad: " + forceLoadTask);
+ }
// Load the application icon
if (loadIcon == null || forceLoadTask) {
ActivityInfo info = ssp.getActivityInfo(t.key.baseIntent.getComponent(),
@@ -196,9 +216,10 @@
Drawable icon = ssp.getActivityIcon(info, t.userId);
if (!mCancelled) {
if (icon != null) {
- Console.log(Constants.Log.App.TaskDataLoader,
- " [TaskResourceLoader|loadIcon]",
- icon);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ " [TaskResourceLoader|loadIcon]", icon);
+ }
loadIcon = icon;
mApplicationIconCache.put(t.key, icon);
}
@@ -209,9 +230,10 @@
Bitmap thumbnail = ssp.getTaskThumbnail(t.key.id);
if (!mCancelled) {
if (thumbnail != null) {
- Console.log(Constants.Log.App.TaskDataLoader,
- " [TaskResourceLoader|loadThumbnail]",
- thumbnail);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ " [TaskResourceLoader|loadThumbnail]", thumbnail);
+ }
thumbnail.setHasAlpha(false);
loadThumbnail = thumbnail;
mThumbnailCache.put(t.key, thumbnail);
@@ -239,8 +261,10 @@
if (!mCancelled && mLoadQueue.isEmpty()) {
synchronized(mLoadQueue) {
try {
- Console.log(Constants.Log.App.TaskDataLoader,
- "[TaskResourceLoader|waitOnLoadQueue]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[TaskResourceLoader|waitOnLoadQueue]");
+ }
mWaitingOnLoadQueue = true;
mLoadQueue.wait();
mWaitingOnLoadQueue = false;
@@ -320,9 +344,11 @@
int thumbnailCacheSize = Constants.DebugFlags.App.DisableBackgroundCache ? 1 :
mMaxThumbnailCacheSize;
- Console.log(Constants.Log.App.TaskDataLoader,
- "[RecentsTaskLoader|init]", "thumbnailCache: " + thumbnailCacheSize +
- " iconCache: " + iconCacheSize);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[RecentsTaskLoader|init]", "thumbnailCache: " + thumbnailCacheSize +
+ " iconCache: " + iconCacheSize);
+ }
// Initialize the proxy, cache and loaders
mSystemServicesProxy = new SystemServicesProxy(context);
@@ -338,9 +364,11 @@
mDefaultThumbnail = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
mDefaultThumbnail.eraseColor(0x00000000);
mDefaultApplicationIcon = new BitmapDrawable(context.getResources(), icon);
- Console.log(Constants.Log.App.TaskDataLoader,
- "[RecentsTaskLoader|defaultBitmaps]",
- "icon: " + mDefaultApplicationIcon + " thumbnail: " + mDefaultThumbnail, Console.AnsiRed);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[RecentsTaskLoader|defaultBitmaps]",
+ "icon: " + mDefaultApplicationIcon + " thumbnail: " + mDefaultThumbnail, Console.AnsiRed);
+ }
}
/** Initializes the recents task loader */
@@ -368,11 +396,13 @@
List<ActivityManager.RecentTaskInfo> tasks =
ssp.getRecentTasks(25, UserHandle.CURRENT.getIdentifier());
Collections.reverse(tasks);
- Console.log(Constants.Log.App.TimeSystemCalls,
- "[RecentsTaskLoader|getRecentTasks]",
- "" + (System.currentTimeMillis() - t1) + "ms");
- Console.log(Constants.Log.App.TaskDataLoader,
- "[RecentsTaskLoader|tasks]", "" + tasks.size());
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TimeSystemCalls,
+ "[RecentsTaskLoader|getRecentTasks]",
+ "" + (System.currentTimeMillis() - t1) + "ms");
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[RecentsTaskLoader|tasks]", "" + tasks.size());
+ }
return tasks;
}
@@ -381,7 +411,9 @@
SpaceNode reload(Context context, int preloadCount) {
long t1 = System.currentTimeMillis();
- Console.log(Constants.Log.App.TaskDataLoader, "[RecentsTaskLoader|reload]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, "[RecentsTaskLoader|reload]");
+ }
Resources res = context.getResources();
ArrayList<Task> tasksToForceLoad = new ArrayList<Task>();
TaskStack stack = new TaskStack(context);
@@ -419,9 +451,11 @@
// Preload the specified number of apps
if (i >= (taskCount - preloadCount)) {
- Console.log(Constants.Log.App.TaskDataLoader,
- "[RecentsTaskLoader|preloadTask]",
- "i: " + i + " task: " + t.baseIntent.getComponent().getPackageName());
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[RecentsTaskLoader|preloadTask]",
+ "i: " + i + " task: " + t.baseIntent.getComponent().getPackageName());
+ }
// Load the icon (if possible and not the foremost task, from the cache)
if (!isForemostTask) {
@@ -451,8 +485,10 @@
}
}
if (task.thumbnail == null) {
- Console.log(Constants.Log.App.TaskDataLoader,
- "[RecentsTaskLoader|loadingTaskThumbnail]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[RecentsTaskLoader|loadingTaskThumbnail]");
+ }
task.thumbnail = ssp.getTaskThumbnail(task.key.id);
if (task.thumbnail != null) {
task.thumbnail.setHasAlpha(false);
@@ -464,13 +500,17 @@
}
// Add the task to the stack
- Console.log(Constants.Log.App.TaskDataLoader,
- " [RecentsTaskLoader|task]", t.baseIntent.getComponent().getPackageName());
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ " [RecentsTaskLoader|task]", t.baseIntent.getComponent().getPackageName());
+ }
stack.addTask(task);
}
- Console.log(Constants.Log.App.TimeSystemCalls,
- "[RecentsTaskLoader|getAllTaskTopThumbnail]",
- "" + (System.currentTimeMillis() - t1) + "ms");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TimeSystemCalls,
+ "[RecentsTaskLoader|getAllTaskTopThumbnail]",
+ "" + (System.currentTimeMillis() - t1) + "ms");
+ }
/*
// Get all the stacks
@@ -505,9 +545,11 @@
Drawable applicationIcon = mApplicationIconCache.get(t.key);
Bitmap thumbnail = mThumbnailCache.get(t.key);
- Console.log(Constants.Log.App.TaskDataLoader, "[RecentsTaskLoader|loadTask]",
- t + " applicationIcon: " + applicationIcon + " thumbnail: " + thumbnail +
- " thumbnailCacheSize: " + mThumbnailCache.size());
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, "[RecentsTaskLoader|loadTask]",
+ t + " applicationIcon: " + applicationIcon + " thumbnail: " + thumbnail +
+ " thumbnailCacheSize: " + mThumbnailCache.size());
+ }
boolean requiresLoad = false;
if (applicationIcon == null) {
@@ -526,9 +568,11 @@
/** Releases the task resource data back into the pool. */
public void unloadTaskData(Task t) {
- Console.log(Constants.Log.App.TaskDataLoader,
- "[RecentsTaskLoader|unloadTask]", t +
- " thumbnailCacheSize: " + mThumbnailCache.size());
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[RecentsTaskLoader|unloadTask]", t +
+ " thumbnailCacheSize: " + mThumbnailCache.size());
+ }
mLoadQueue.removeTask(t);
t.notifyTaskDataUnloaded(mDefaultThumbnail, mDefaultApplicationIcon);
@@ -536,8 +580,10 @@
/** Completely removes the resource data from the pool. */
public void deleteTaskData(Task t, boolean notifyTaskDataUnloaded) {
- Console.log(Constants.Log.App.TaskDataLoader,
- "[RecentsTaskLoader|deleteTask]", t);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader,
+ "[RecentsTaskLoader|deleteTask]", t);
+ }
mLoadQueue.removeTask(t);
mThumbnailCache.remove(t.key);
@@ -549,7 +595,9 @@
/** Stops the task loader and clears all pending tasks */
void stopLoader() {
- Console.log(Constants.Log.App.TaskDataLoader, "[RecentsTaskLoader|stopLoader]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.TaskDataLoader, "[RecentsTaskLoader|stopLoader]");
+ }
mLoader.stop();
mLoadQueue.clearTasks();
}
@@ -570,8 +618,10 @@
* out of memory.
*/
void onTrimMemory(int level) {
- Console.log(Constants.Log.App.Memory, "[RecentsTaskLoader|onTrimMemory]",
- Console.trimMemoryLevelToString(level));
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.Memory, "[RecentsTaskLoader|onTrimMemory]",
+ Console.trimMemoryLevelToString(level));
+ }
switch (level) {
case ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN:
diff --git a/packages/SystemUI/src/com/android/systemui/recents/SystemServicesProxy.java b/packages/SystemUI/src/com/android/systemui/recents/SystemServicesProxy.java
index 59d0ea6..7a3ffb8 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/SystemServicesProxy.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/SystemServicesProxy.java
@@ -106,7 +106,8 @@
rti.description = description;
if (i % 2 == 0) {
rti.taskDescription = new ActivityManager.TaskDescription(description,
- Bitmap.createBitmap(mDummyIcon), new Random().nextInt());
+ Bitmap.createBitmap(mDummyIcon),
+ 0xFF000000 | (0xFFFFFF & new Random().nextInt()));
} else {
rti.taskDescription = new ActivityManager.TaskDescription();
}
diff --git a/packages/SystemUI/src/com/android/systemui/recents/views/RecentsView.java b/packages/SystemUI/src/com/android/systemui/recents/views/RecentsView.java
index cad54fa..cad9ce5 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/views/RecentsView.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/views/RecentsView.java
@@ -110,16 +110,20 @@
TaskView tv = (TaskView) stackView.getChildAt(j);
Task task = tv.getTask();
if (tv.isFocusedTask()) {
- Console.log(Constants.Log.UI.Focus, "[RecentsView|launchFocusedTask]",
- "Found focused Task");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Focus, "[RecentsView|launchFocusedTask]",
+ "Found focused Task");
+ }
onTaskLaunched(stackView, tv, stack, task);
return true;
}
}
}
}
- Console.log(Constants.Log.UI.Focus, "[RecentsView|launchFocusedTask]",
- "No Tasks focused");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Focus, "[RecentsView|launchFocusedTask]",
+ "No Tasks focused");
+ }
return false;
}
@@ -168,9 +172,11 @@
mSearchBar.setVisibility(mHasTasks ? View.VISIBLE : View.GONE);
addView(mSearchBar);
- Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsView|setSearchBar]",
- "" + (mSearchBar.getVisibility() == View.VISIBLE),
- Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.App.SystemUIHandshake, "[RecentsView|setSearchBar]",
+ "" + (mSearchBar.getVisibility() == View.VISIBLE),
+ Console.AnsiBlue);
+ }
}
}
}
@@ -185,10 +191,12 @@
int height = MeasureSpec.getSize(heightMeasureSpec);
int heightMode = MeasureSpec.getMode(heightMeasureSpec);
- Console.log(Constants.Log.UI.MeasureAndLayout, "[RecentsView|measure]",
- "width: " + width + " height: " + height, Console.AnsiGreen);
- Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
- Constants.Log.App.TimeRecentsStartupKey, "RecentsView.onMeasure");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.MeasureAndLayout, "[RecentsView|measure]",
+ "width: " + width + " height: " + height, Console.AnsiGreen);
+ Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
+ Constants.Log.App.TimeRecentsStartupKey, "RecentsView.onMeasure");
+ }
// Get the search bar bounds and measure the search bar layout
RecentsConfiguration config = RecentsConfiguration.getInstance();
@@ -227,10 +235,12 @@
*/
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
- Console.log(Constants.Log.UI.MeasureAndLayout, "[RecentsView|layout]",
- new Rect(left, top, right, bottom) + " changed: " + changed, Console.AnsiGreen);
- Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
- Constants.Log.App.TimeRecentsStartupKey, "RecentsView.onLayout");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.MeasureAndLayout, "[RecentsView|layout]",
+ new Rect(left, top, right, bottom) + " changed: " + changed, Console.AnsiGreen);
+ Console.logTraceTime(Constants.Log.App.TimeRecentsStartup,
+ Constants.Log.App.TimeRecentsStartupKey, "RecentsView.onLayout");
+ }
// Get the search bar bounds so that we lay it out
RecentsConfiguration config = RecentsConfiguration.getInstance();
@@ -283,15 +293,19 @@
@Override
protected void dispatchDraw(Canvas canvas) {
- Console.log(Constants.Log.UI.Draw, "[RecentsView|dispatchDraw]", "",
- Console.AnsiPurple);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Draw, "[RecentsView|dispatchDraw]", "",
+ Console.AnsiPurple);
+ }
super.dispatchDraw(canvas);
}
@Override
public WindowInsets onApplyWindowInsets(WindowInsets insets) {
- Console.log(Constants.Log.UI.MeasureAndLayout,
- "[RecentsView|fitSystemWindows]", "insets: " + insets, Console.AnsiGreen);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.MeasureAndLayout,
+ "[RecentsView|fitSystemWindows]", "insets: " + insets, Console.AnsiGreen);
+ }
// Update the configuration with the latest system insets and trigger a relayout
RecentsConfiguration config = RecentsConfiguration.getInstance();
diff --git a/packages/SystemUI/src/com/android/systemui/recents/views/SwipeHelper.java b/packages/SystemUI/src/com/android/systemui/recents/views/SwipeHelper.java
index c34300c..3ee0545 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/views/SwipeHelper.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/views/SwipeHelper.java
@@ -178,9 +178,11 @@
}
public boolean onInterceptTouchEvent(MotionEvent ev) {
- Console.log(Constants.Log.UI.TouchEvents,
- "[SwipeHelper|interceptTouchEvent]",
- Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.TouchEvents,
+ "[SwipeHelper|interceptTouchEvent]",
+ Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ }
final int action = ev.getAction();
switch (action) {
@@ -291,9 +293,11 @@
}
public boolean onTouchEvent(MotionEvent ev) {
- Console.log(Constants.Log.UI.TouchEvents,
- "[SwipeHelper|touchEvent]",
- Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.TouchEvents,
+ "[SwipeHelper|touchEvent]",
+ Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ }
if (!mDragging) {
if (!onInterceptTouchEvent(ev)) {
diff --git a/packages/SystemUI/src/com/android/systemui/recents/views/TaskStackView.java b/packages/SystemUI/src/com/android/systemui/recents/views/TaskStackView.java
index 0687222..3e418ca 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/views/TaskStackView.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/views/TaskStackView.java
@@ -113,8 +113,10 @@
requestSynchronizeStackViewsWithModel(0);
}
void requestSynchronizeStackViewsWithModel(int duration) {
- Console.log(Constants.Log.TaskStack.SynchronizeViewsWithModel,
- "[TaskStackView|requestSynchronize]", "" + duration + "ms", Console.AnsiYellow);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.TaskStack.SynchronizeViewsWithModel,
+ "[TaskStackView|requestSynchronize]", "" + duration + "ms", Console.AnsiYellow);
+ }
if (!mStackViewsDirty) {
invalidate();
}
@@ -221,9 +223,11 @@
/** Synchronizes the views with the model */
void synchronizeStackViewsWithModel() {
- Console.log(Constants.Log.TaskStack.SynchronizeViewsWithModel,
- "[TaskStackView|synchronizeViewsWithModel]",
- "mStackViewsDirty: " + mStackViewsDirty, Console.AnsiYellow);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.TaskStack.SynchronizeViewsWithModel,
+ "[TaskStackView|synchronizeViewsWithModel]",
+ "mStackViewsDirty: " + mStackViewsDirty, Console.AnsiYellow);
+ }
if (mStackViewsDirty) {
// XXX: Consider using TaskViewTransform pool to prevent allocations
// XXX: Iterate children views, update transforms and remove all that are not visible
@@ -277,8 +281,10 @@
}
}
- Console.log(Constants.Log.TaskStack.SynchronizeViewsWithModel,
- " [TaskStackView|viewChildren]", "" + getChildCount());
+ if (Console.Enabled) {
+ Console.log(Constants.Log.TaskStack.SynchronizeViewsWithModel,
+ " [TaskStackView|viewChildren]", "" + getChildCount());
+ }
mStackViewsAnimationDuration = 0;
mStackViewsDirty = false;
@@ -445,7 +451,9 @@
/** Focuses the task at the specified index in the stack */
void focusTask(int taskIndex, boolean scrollToNewPosition) {
- Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusTask]", "" + taskIndex);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusTask]", "" + taskIndex);
+ }
if (0 <= taskIndex && taskIndex < mStack.getTaskCount()) {
mFocusedTaskIndex = taskIndex;
@@ -455,7 +463,9 @@
Runnable postScrollRunnable = null;
if (tv != null) {
tv.setFocusedTask();
- Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusTask]", "Requesting focus");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusTask]", "Requesting focus");
+ }
} else {
postScrollRunnable = new Runnable() {
@Override
@@ -464,8 +474,10 @@
TaskView tv = getChildViewForTask(t);
if (tv != null) {
tv.setFocusedTask();
- Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusTask]",
- "Requesting focus after scroll animation");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusTask]",
+ "Requesting focus after scroll animation");
+ }
}
}
};
@@ -487,7 +499,10 @@
/** Focuses the next task in the stack */
void focusNextTask(boolean forward) {
- Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusNextTask]", "" + mFocusedTaskIndex);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Focus, "[TaskStackView|focusNextTask]", "" +
+ mFocusedTaskIndex);
+ }
// Find the next index to focus
int numTasks = mStack.getTaskCount();
@@ -503,9 +518,11 @@
/** Enables the hw layers and increments the hw layer requirement ref count */
void addHwLayersRefCount(String reason) {
- Console.log(Constants.Log.UI.HwLayers,
- "[TaskStackView|addHwLayersRefCount] refCount: " +
- mHwLayersRefCount + "->" + (mHwLayersRefCount + 1) + " " + reason);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.HwLayers,
+ "[TaskStackView|addHwLayersRefCount] refCount: " +
+ mHwLayersRefCount + "->" + (mHwLayersRefCount + 1) + " " + reason);
+ }
if (mHwLayersRefCount == 0) {
// Enable hw layers on each of the children
int childCount = getChildCount();
@@ -520,9 +537,11 @@
/** Decrements the hw layer requirement ref count and disables the hw layers when we don't
need them anymore. */
void decHwLayersRefCount(String reason) {
- Console.log(Constants.Log.UI.HwLayers,
- "[TaskStackView|decHwLayersRefCount] refCount: " +
- mHwLayersRefCount + "->" + (mHwLayersRefCount - 1) + " " + reason);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.HwLayers,
+ "[TaskStackView|decHwLayersRefCount] refCount: " +
+ mHwLayersRefCount + "->" + (mHwLayersRefCount - 1) + " " + reason);
+ }
mHwLayersRefCount--;
if (mHwLayersRefCount == 0) {
// Disable hw layers on each of the children
@@ -562,8 +581,10 @@
@Override
public void dispatchDraw(Canvas canvas) {
- Console.log(Constants.Log.UI.Draw, "[TaskStackView|dispatchDraw]", "",
- Console.AnsiPurple);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.Draw, "[TaskStackView|dispatchDraw]", "",
+ Console.AnsiPurple);
+ }
synchronizeStackViewsWithModel();
super.dispatchDraw(canvas);
}
@@ -647,9 +668,11 @@
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int width = MeasureSpec.getSize(widthMeasureSpec);
int height = MeasureSpec.getSize(heightMeasureSpec);
- Console.log(Constants.Log.UI.MeasureAndLayout, "[TaskStackView|measure]",
- "width: " + width + " height: " + height +
- " awaitingFirstLayout: " + mAwaitingFirstLayout, Console.AnsiGreen);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.MeasureAndLayout, "[TaskStackView|measure]",
+ "width: " + width + " height: " + height +
+ " awaitingFirstLayout: " + mAwaitingFirstLayout, Console.AnsiGreen);
+ }
// Compute our stack/task rects
RecentsConfiguration config = RecentsConfiguration.getInstance();
@@ -704,8 +727,10 @@
*/
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
- Console.log(Constants.Log.UI.MeasureAndLayout, "[TaskStackView|layout]",
- "" + new Rect(left, top, right, bottom), Console.AnsiGreen);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.MeasureAndLayout, "[TaskStackView|layout]",
+ "" + new Rect(left, top, right, bottom), Console.AnsiGreen);
+ }
// Debug logging
if (Constants.Log.UI.MeasureAndLayout) {
@@ -971,7 +996,9 @@
@Override
public TaskView createView(Context context) {
- Console.log(Constants.Log.ViewPool.PoolCallbacks, "[TaskStackView|createPoolView]");
+ if (Console.Enabled) {
+ Console.log(Constants.Log.ViewPool.PoolCallbacks, "[TaskStackView|createPoolView]");
+ }
return (TaskView) mInflater.inflate(R.layout.recents_task_view, this, false);
}
@@ -979,8 +1006,10 @@
public void prepareViewToEnterPool(TaskView tv) {
Task task = tv.getTask();
tv.resetViewProperties();
- Console.log(Constants.Log.ViewPool.PoolCallbacks, "[TaskStackView|returnToPool]",
- tv.getTask() + " tv: " + tv);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.ViewPool.PoolCallbacks, "[TaskStackView|returnToPool]",
+ tv.getTask() + " tv: " + tv);
+ }
// Report that this tasks's data is no longer being used
RecentsTaskLoader loader = RecentsTaskLoader.getInstance();
@@ -995,8 +1024,10 @@
@Override
public void prepareViewToLeavePool(TaskView tv, Task prepareData, boolean isNewView) {
- Console.log(Constants.Log.ViewPool.PoolCallbacks, "[TaskStackView|leavePool]",
- "isNewView: " + isNewView);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.ViewPool.PoolCallbacks, "[TaskStackView|leavePool]",
+ "isNewView: " + isNewView);
+ }
// Setup and attach the view to the window
Task task = prepareData;
@@ -1018,8 +1049,10 @@
}
// Add/attach the view to the hierarchy
- Console.log(Constants.Log.ViewPool.PoolCallbacks, " [TaskStackView|insertIndex]",
- "" + insertIndex);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.ViewPool.PoolCallbacks, " [TaskStackView|insertIndex]",
+ "" + insertIndex);
+ }
if (isNewView) {
addView(tv, insertIndex);
@@ -1045,9 +1078,11 @@
@Override
public void onTaskIconClicked(TaskView tv) {
- Console.log(Constants.Log.UI.ClickEvents, "[TaskStack|Clicked|Icon]",
- tv.getTask() + " is currently filtered: " + mStack.hasFilteredTasks(),
- Console.AnsiCyan);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.ClickEvents, "[TaskStack|Clicked|Icon]",
+ tv.getTask() + " is currently filtered: " + mStack.hasFilteredTasks(),
+ Console.AnsiCyan);
+ }
if (Constants.DebugFlags.App.EnableTaskFiltering) {
if (mStack.hasFilteredTasks()) {
mStack.unfilterTasks();
@@ -1079,8 +1114,10 @@
public void onClick(View v) {
TaskView tv = (TaskView) v;
Task task = tv.getTask();
- Console.log(Constants.Log.UI.ClickEvents, "[TaskStack|Clicked|Thumbnail]",
- task + " cb: " + mCb);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.ClickEvents, "[TaskStack|Clicked|Thumbnail]",
+ task + " cb: " + mCb);
+ }
if (mCb != null) {
mCb.onTaskLaunched(this, tv, mStack, task);
@@ -1190,9 +1227,11 @@
/** Touch preprocessing for handling below */
public boolean onInterceptTouchEvent(MotionEvent ev) {
- Console.log(Constants.Log.UI.TouchEvents,
- "[TaskStackViewTouchHandler|interceptTouchEvent]",
- Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.TouchEvents,
+ "[TaskStackViewTouchHandler|interceptTouchEvent]",
+ Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ }
// Return early if we have no children
boolean hasChildren = (mSv.getChildCount() > 0);
@@ -1274,9 +1313,11 @@
/** Handles touch events once we have intercepted them */
public boolean onTouchEvent(MotionEvent ev) {
- Console.log(Constants.Log.UI.TouchEvents,
- "[TaskStackViewTouchHandler|touchEvent]",
- Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.TouchEvents,
+ "[TaskStackViewTouchHandler|touchEvent]",
+ Console.motionEventActionToString(ev.getAction()), Console.AnsiBlue);
+ }
// Short circuit if we have no children
boolean hasChildren = (mSv.getChildCount() > 0);
@@ -1377,12 +1418,14 @@
Math.abs((float) velocity / mMaximumVelocity)) *
Constants.Values.TaskStackView.TaskStackOverscrollRange);
- Console.log(Constants.Log.UI.TouchEvents,
- "[TaskStackViewTouchHandler|fling]",
- "scroll: " + mSv.getStackScroll() + " velocity: " + velocity +
- " maxVelocity: " + mMaximumVelocity +
- " overscrollRange: " + overscrollRange,
- Console.AnsiGreen);
+ if (Console.Enabled) {
+ Console.log(Constants.Log.UI.TouchEvents,
+ "[TaskStackViewTouchHandler|fling]",
+ "scroll: " + mSv.getStackScroll() + " velocity: " + velocity +
+ " maxVelocity: " + mMaximumVelocity +
+ " overscrollRange: " + overscrollRange,
+ Console.AnsiGreen);
+ }
// Fling scroll
mSv.mScroller.fling(0, mSv.getStackScroll(),
diff --git a/packages/SystemUI/src/com/android/systemui/recents/views/TaskView.java b/packages/SystemUI/src/com/android/systemui/recents/views/TaskView.java
index 780f274..16a3f45 100644
--- a/packages/SystemUI/src/com/android/systemui/recents/views/TaskView.java
+++ b/packages/SystemUI/src/com/android/systemui/recents/views/TaskView.java
@@ -292,7 +292,6 @@
float dim = (1f - getScaleX()) / scaleRange;
dim = mDimInterpolator.getInterpolation(Math.min(dim, 1f));
mDim = Math.max(0, Math.min(mMaxDim, (int) (dim * 255)));
- invalidate();
}
@Override
@@ -406,4 +405,4 @@
}
return false;
}
-}
\ No newline at end of file
+}