Merge "Fix ConditionVariable.block to use elapsedRealtime."
diff --git a/cmds/statsd/src/atoms.proto b/cmds/statsd/src/atoms.proto
index d34b077..cadc3a0 100644
--- a/cmds/statsd/src/atoms.proto
+++ b/cmds/statsd/src/atoms.proto
@@ -257,6 +257,8 @@
NetworkStackReported network_stack_reported = 182;
AppMovedStorageReported app_moved_storage_reported = 183;
BiometricEnrolled biometric_enrolled = 184;
+ SystemServerWatchdogOccurred system_server_watchdog_occurred = 185;
+ TombStoneOccurred tomb_stone_occurred = 186;
}
// Pulled events will start at field 10000.
@@ -3493,6 +3495,23 @@
optional string package_name = 3;
}
+/**
+ * Logs when system server watchdog occurs.
+ * Logged from:
+ * frameworks/base/services/core/java/com/android/server/Watchdog.java
+ */
+message SystemServerWatchdogOccurred {
+ optional string subject = 1;
+}
+
+/**
+ * Logs when new file added to tombstones.
+ * Logged from:
+ * frameworks/base/core/java/com/android/server/BootReceiver.java
+ */
+message TombStoneOccurred {
+}
+
//////////////////////////////////////////////////////////////////////
// Pulled atoms below this line //
//////////////////////////////////////////////////////////////////////
diff --git a/core/java/android/app/Activity.java b/core/java/android/app/Activity.java
index b039a60..883bcb8 100644
--- a/core/java/android/app/Activity.java
+++ b/core/java/android/app/Activity.java
@@ -157,8 +157,9 @@
* creating a window for you in which you can place your UI with
* {@link #setContentView}. While activities are often presented to the user
* as full-screen windows, they can also be used in other ways: as floating
- * windows (via a theme with {@link android.R.attr#windowIsFloating} set)
- * or embedded inside of another activity (using {@link ActivityGroup}).
+ * windows (via a theme with {@link android.R.attr#windowIsFloating} set),
+ * <a href="https://developer.android.com/guide/topics/ui/multi-window">
+ * Multi-Window mode</a> or embedded into other windows.
*
* There are two methods almost all subclasses of Activity will implement:
*
@@ -169,10 +170,11 @@
* to retrieve the widgets in that UI that you need to interact with
* programmatically.
*
- * <li> {@link #onPause} is where you deal with the user leaving your
- * activity. Most importantly, any changes made by the user should at this
- * point be committed (usually to the
- * {@link android.content.ContentProvider} holding the data).
+ * <li> {@link #onPause} is where you deal with the user pausing active
+ * interaction with the activity. Any changes made by the user should at
+ * this point be committed (usually to the
+ * {@link android.content.ContentProvider} holding the data). In this
+ * state the activity is still visible on screen.
* </ul>
*
* <p>To be of use with {@link android.content.Context#startActivity Context.startActivity()}, all
@@ -220,32 +222,31 @@
* <a name="ActivityLifecycle"></a>
* <h3>Activity Lifecycle</h3>
*
- * <p>Activities in the system are managed as an <em>activity stack</em>.
- * When a new activity is started, it is placed on the top of the stack
- * and becomes the running activity -- the previous activity always remains
+ * <p>Activities in the system are managed as
+ * <a href="https://developer.android.com/guide/components/activities/tasks-and-back-stack">
+ * activity stacks</a>. When a new activity is started, it is usually placed on the top of the
+ * current stack and becomes the running activity -- the previous activity always remains
* below it in the stack, and will not come to the foreground again until
- * the new activity exits.</p>
+ * the new activity exits. There can be one or multiple activity stacks visible
+ * on screen.</p>
*
* <p>An activity has essentially four states:</p>
* <ul>
- * <li> If an activity is in the foreground of the screen (at the top of
- * the stack),
- * it is <em>active</em> or <em>running</em>. </li>
- * <li>If an activity has lost focus but is still visible (that is, a new non-full-sized
- * or transparent activity has focus on top of your activity), it
- * is <em>paused</em>. A paused activity is completely alive (it
- * maintains all state and member information and remains attached to
- * the window manager), but can be killed by the system in extreme
- * low memory situations.
+ * <li>If an activity is in the foreground of the screen (at the highest position of the topmost
+ * stack), it is <em>active</em> or <em>running</em>. This is usually the activity that the
+ * user is currently interacting with.</li>
+ * <li>If an activity has lost focus but is still presented to the user, it is <em>visible</em>.
+ * It is possible if a new non-full-sized or transparent activity has focus on top of your
+ * activity, another activity has higher position in multi-window mode, or the activity
+ * itself is not focusable in current windowing mode. Such activity is completely alive (it
+ * maintains all state and member information and remains attached to the window manager).
* <li>If an activity is completely obscured by another activity,
- * it is <em>stopped</em>. It still retains all state and member information,
- * however, it is no longer visible to the user so its window is hidden
- * and it will often be killed by the system when memory is needed
- * elsewhere.</li>
- * <li>If an activity is paused or stopped, the system can drop the activity
- * from memory by either asking it to finish, or simply killing its
- * process. When it is displayed again to the user, it must be
- * completely restarted and restored to its previous state.</li>
+ * it is <em>stopped</em> or <em>hidden</em>. It still retains all state and member
+ * information, however, it is no longer visible to the user so its window is hidden
+ * and it will often be killed by the system when memory is needed elsewhere.</li>
+ * <li>The system can drop the activity from memory by either asking it to finish,
+ * or simply killing its process, making it <em>destroyed</em>. When it is displayed again
+ * to the user, it must be completely restarted and restored to its previous state.</li>
* </ul>
*
* <p>The following diagram shows the important state paths of an Activity.
@@ -283,7 +284,7 @@
* <li>The <b>foreground lifetime</b> of an activity happens between a call to
* {@link android.app.Activity#onResume} until a corresponding call to
* {@link android.app.Activity#onPause}. During this time the activity is
- * in front of all other activities and interacting with the user. An activity
+ * in visible, active and interacting with the user. An activity
* can frequently go between the resumed and paused states -- for example when
* the device goes to sleep, when an activity result is delivered, when a new
* intent is delivered -- so the code in these methods should be fairly
@@ -296,7 +297,8 @@
* activities will implement {@link android.app.Activity#onCreate}
* to do their initial setup; many will also implement
* {@link android.app.Activity#onPause} to commit changes to data and
- * otherwise prepare to stop interacting with the user. You should always
+ * prepare to pause interacting with the user, and {@link android.app.Activity#onStop}
+ * to handle no longer being visible on screen. You should always
* call up to your superclass when implementing these methods.</p>
*
* </p>
@@ -364,17 +366,17 @@
* <td align="left" border="0">{@link android.app.Activity#onResume onResume()}</td>
* <td>Called when the activity will start
* interacting with the user. At this point your activity is at
- * the top of the activity stack, with user input going to it.
+ * the top of its activity stack, with user input going to it.
* <p>Always followed by <code>onPause()</code>.</td>
* <td align="center">No</td>
* <td align="center"><code>onPause()</code></td>
* </tr>
*
* <tr><td align="left" border="0">{@link android.app.Activity#onPause onPause()}</td>
- * <td>Called when the system is about to start resuming a previous
- * activity. This is typically used to commit unsaved changes to
- * persistent data, stop animations and other things that may be consuming
- * CPU, etc. Implementations of this method must be very quick because
+ * <td>Called when the activity loses foreground state, is no longer focusable or before
+ * transition to stopped/hidden or destroyed state. The activity is still visible to
+ * user, so it's recommended to keep it visually active and continue updating the UI.
+ * Implementations of this method must be very quick because
* the next activity will not be resumed until this method returns.
* <p>Followed by either <code>onResume()</code> if the activity
* returns back to the front, or <code>onStop()</code> if it becomes
@@ -385,11 +387,10 @@
* </tr>
*
* <tr><td colspan="2" align="left" border="0">{@link android.app.Activity#onStop onStop()}</td>
- * <td>Called when the activity is no longer visible to the user, because
- * another activity has been resumed and is covering this one. This
- * may happen either because a new activity is being started, an existing
- * one is being brought in front of this one, or this one is being
- * destroyed.
+ * <td>Called when the activity is no longer visible to the user. This may happen either
+ * because a new activity is being started on top, an existing one is being brought in
+ * front of this one, or this one is being destroyed. This is typically used to stop
+ * animations and refreshing the UI, etc.
* <p>Followed by either <code>onRestart()</code> if
* this activity is coming back to interact with the user, or
* <code>onDestroy()</code> if this activity is going away.</td>
@@ -446,8 +447,9 @@
* <p>For those methods that are not marked as being killable, the activity's
* process will not be killed by the system starting from the time the method
* is called and continuing after it returns. Thus an activity is in the killable
- * state, for example, between after <code>onPause()</code> to the start of
- * <code>onResume()</code>.</p>
+ * state, for example, between after <code>onStop()</code> to the start of
+ * <code>onResume()</code>. Keep in mind that under extreme memory pressure the
+ * system can kill the application process at any time.</p>
*
* <a name="ConfigurationChanges"></a>
* <h3>Configuration Changes</h3>
@@ -582,8 +584,8 @@
* <p>This model is designed to prevent data loss when a user is navigating
* between activities, and allows the system to safely kill an activity (because
* system resources are needed somewhere else) at any time after it has been
- * paused. Note this implies
- * that the user pressing BACK from your activity does <em>not</em>
+ * stopped (or paused on platform versions before {@link android.os.Build.VERSION_CODES#HONEYCOMB}).
+ * Note this implies that the user pressing BACK from your activity does <em>not</em>
* mean "cancel" -- it means to leave the activity with its current contents
* saved away. Canceling edits in an activity must be provided through
* some other mechanism, such as an explicit "revert" or "undo" option.</p>
@@ -684,11 +686,12 @@
* reached a memory paging state, so this is required in order to keep the user
* interface responsive.
* <li> <p>A <b>visible activity</b> (an activity that is visible to the user
- * but not in the foreground, such as one sitting behind a foreground dialog)
+ * but not in the foreground, such as one sitting behind a foreground dialog
+ * or next to other activities in multi-window mode)
* is considered extremely important and will not be killed unless that is
* required to keep the foreground activity running.
* <li> <p>A <b>background activity</b> (an activity that is not visible to
- * the user and has been paused) is no longer critical, so the system may
+ * the user and has been stopped) is no longer critical, so the system may
* safely kill its process to reclaim memory for other foreground or
* visible processes. If its process needs to be killed, when the user navigates
* back to the activity (making it visible on the screen again), its
@@ -1685,7 +1688,12 @@
/**
* Called after {@link #onCreate} — or after {@link #onRestart} when
* the activity had been stopped, but is now again being displayed to the
- * user. It will be followed by {@link #onResume}.
+ * user. It will usually be followed by {@link #onResume}. This is a good place to begin
+ * drawing visual elements, running animations, etc.
+ *
+ * <p>You can call {@link #finish} from within this function, in
+ * which case {@link #onStop} will be immediately called after {@link #onStart} without the
+ * lifecycle transitions in-between ({@link #onResume}, {@link #onPause}, etc) executing.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
@@ -1751,14 +1759,15 @@
/**
* Called after {@link #onRestoreInstanceState}, {@link #onRestart}, or
- * {@link #onPause}, for your activity to start interacting with the user.
- * This is a good place to begin animations, open exclusive-access devices
- * (such as the camera), etc.
+ * {@link #onPause}, for your activity to start interacting with the user. This is an indicator
+ * that the activity became active and ready to receive input. It is on top of an activity stack
+ * and visible to user.
*
- * <p>Keep in mind that onResume is not the best indicator that your activity
- * is visible to the user; a system window such as the keyguard may be in
- * front. Use {@link #onWindowFocusChanged} to know for certain that your
- * activity is visible to the user (for example, to resume a game).
+ * <p>On platform versions prior to {@link android.os.Build.VERSION_CODES#Q} this is also a good
+ * place to try to open exclusive-access devices or to get access to singleton resources.
+ * Starting with {@link android.os.Build.VERSION_CODES#Q} there can be multiple resumed
+ * activities in the system simultaneously, so {@link #onTopResumedActivityChanged(boolean)}
+ * should be used for that purpose instead.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
@@ -1768,6 +1777,7 @@
* @see #onRestart
* @see #onPostResume
* @see #onPause
+ * @see #onTopResumedActivityChanged(boolean)
*/
@CallSuper
protected void onResume() {
@@ -1816,7 +1826,7 @@
}
/**
- * Called when activity gets or looses the top resumed position in the system.
+ * Called when activity gets or loses the top resumed position in the system.
*
* <p>Starting with {@link android.os.Build.VERSION_CODES#Q} multiple activities can be resumed
* at the same time in multi-window and multi-display modes. This callback should be used
@@ -1981,8 +1991,12 @@
* called on the existing instance with the Intent that was used to
* re-launch it.
*
- * <p>An activity will always be paused before receiving a new intent, so
- * you can count on {@link #onResume} being called after this method.
+ * <p>An activity can never receive a new intent in the resumed state. You can count on
+ * {@link #onResume} being called after this method, though not necessarily immediately after
+ * the completion this callback. If the activity was resumed, it will be paused and new intent
+ * will be delivered, followed by {@link #onResume}. If the activity wasn't in the resumed
+ * state, then new intent can be delivered immediately, with {@link #onResume()} called
+ * sometime later when activity becomes active again.
*
* <p>Note that {@link #getIntent} still returns the original Intent. You
* can use {@link #setIntent} to update it to this new Intent.
@@ -2048,14 +2062,13 @@
* returns to activity A, the state of the user interface can be restored
* via {@link #onCreate} or {@link #onRestoreInstanceState}.
*
- * <p>Do not confuse this method with activity lifecycle callbacks such as
- * {@link #onPause}, which is always called when an activity is being placed
- * in the background or on its way to destruction, or {@link #onStop} which
- * is called before destruction. One example of when {@link #onPause} and
- * {@link #onStop} is called and not this method is when a user navigates back
- * from activity B to activity A: there is no need to call {@link #onSaveInstanceState}
- * on B because that particular instance will never be restored, so the
- * system avoids calling it. An example when {@link #onPause} is called and
+ * <p>Do not confuse this method with activity lifecycle callbacks such as {@link #onPause},
+ * which is always called when the user no longer actively interacts with an activity, or
+ * {@link #onStop} which is called when activity becomes invisible. One example of when
+ * {@link #onPause} and {@link #onStop} is called and not this method is when a user navigates
+ * back from activity B to activity A: there is no need to call {@link #onSaveInstanceState}
+ * on B because that particular instance will never be restored,
+ * so the system avoids calling it. An example when {@link #onPause} is called and
* not {@link #onSaveInstanceState} is when activity B is launched in front of activity A:
* the system may avoid calling {@link #onSaveInstanceState} on activity A if it isn't
* killed during the lifetime of B since the state of the user interface of
@@ -2154,9 +2167,8 @@
/**
- * Called as part of the activity lifecycle when an activity is going into
- * the background, but has not (yet) been killed. The counterpart to
- * {@link #onResume}.
+ * Called as part of the activity lifecycle when the user no longer actively interacts with the
+ * activity, but it is still visible on screen. The counterpart to {@link #onResume}.
*
* <p>When activity B is launched in front of activity A, this callback will
* be invoked on A. B will not be created until A's {@link #onPause} returns,
@@ -2166,22 +2178,20 @@
* activity is editing, to present a "edit in place" model to the user and
* making sure nothing is lost if there are not enough resources to start
* the new activity without first killing this one. This is also a good
- * place to do things like stop animations and other things that consume a
- * noticeable amount of CPU in order to make the switch to the next activity
- * as fast as possible, or to close resources that are exclusive access
- * such as the camera.
+ * place to stop things that consume a noticeable amount of CPU in order to
+ * make the switch to the next activity as fast as possible.
*
- * <p>In situations where the system needs more memory it may kill paused
- * processes to reclaim resources. Because of this, you should be sure
- * that all of your state is saved by the time you return from
- * this function. In general {@link #onSaveInstanceState} is used to save
- * per-instance state in the activity and this method is used to store
- * global persistent data (in content providers, files, etc.)
+ * <p>On platform versions prior to {@link android.os.Build.VERSION_CODES#Q} this is also a good
+ * place to try to close exclusive-access devices or to release access to singleton resources.
+ * Starting with {@link android.os.Build.VERSION_CODES#Q} there can be multiple resumed
+ * activities in the system at the same time, so {@link #onTopResumedActivityChanged(boolean)}
+ * should be used for that purpose instead.
*
- * <p>After receiving this call you will usually receive a following call
- * to {@link #onStop} (after the next activity has been resumed and
- * displayed), however in some cases there will be a direct call back to
- * {@link #onResume} without going through the stopped state.
+ * <p>If an activity is launched on top, after receiving this call you will usually receive a
+ * following call to {@link #onStop} (after the next activity has been resumed and displayed
+ * above). However in some cases there will be a direct call back to {@link #onResume} without
+ * going through the stopped state. An activity can also rest in paused state in some cases when
+ * in multi-window mode, still visible to user.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
@@ -2364,7 +2374,8 @@
/**
* Called when you are no longer visible to the user. You will next
* receive either {@link #onRestart}, {@link #onDestroy}, or nothing,
- * depending on later user activity.
+ * depending on later user activity. This is a good place to stop
+ * refreshing UI, running animations and other visual things.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
@@ -3716,18 +3727,18 @@
/**
* Called when the current {@link Window} of the activity gains or loses
- * focus. This is the best indicator of whether this activity is visible
- * to the user. The default implementation clears the key tracking
- * state, so should always be called.
+ * focus. This is the best indicator of whether this activity is the entity
+ * with which the user actively interacts. The default implementation
+ * clears the key tracking state, so should always be called.
*
* <p>Note that this provides information about global focus state, which
- * is managed independently of activity lifecycles. As such, while focus
+ * is managed independently of activity lifecycle. As such, while focus
* changes will generally have some relation to lifecycle changes (an
* activity that is stopped will not generally get window focus), you
* should not rely on any particular order between the callbacks here and
* those in the other lifecycle methods such as {@link #onResume}.
*
- * <p>As a general rule, however, a resumed activity will have window
+ * <p>As a general rule, however, a foreground activity will have window
* focus... unless it has displayed other dialogs or popups that take
* input focus, in which case the activity itself will not have focus
* when the other windows have it. Likewise, the system may display
@@ -3735,11 +3746,24 @@
* a system alert) which will temporarily take window input focus without
* pausing the foreground activity.
*
+ * <p>Starting with {@link android.os.Build.VERSION_CODES#Q} there can be
+ * multiple resumed activities at the same time in multi-window mode, so
+ * resumed state does not guarantee window focus even if there are no
+ * overlays above.
+ *
+ * <p>If the intent is to know when an activity is the topmost active, the
+ * one the user interacted with last among all activities but not including
+ * non-activity windows like dialogs and popups, then
+ * {@link #onTopResumedActivityChanged(boolean)} should be used. On platform
+ * versions prior to {@link android.os.Build.VERSION_CODES#Q},
+ * {@link #onResume} is the best indicator.
+ *
* @param hasFocus Whether the window of this activity has focus.
*
* @see #hasWindowFocus()
* @see #onResume
* @see View#onWindowFocusChanged(boolean)
+ * @see #onTopResumedActivityChanged(boolean)
*/
public void onWindowFocusChanged(boolean hasFocus) {
}
diff --git a/core/java/android/app/usage/UsageStatsManager.java b/core/java/android/app/usage/UsageStatsManager.java
index 26c8218..eb1ea90 100644
--- a/core/java/android/app/usage/UsageStatsManager.java
+++ b/core/java/android/app/usage/UsageStatsManager.java
@@ -298,7 +298,10 @@
*
* @param intervalType The time interval by which the stats are aggregated.
* @param beginTime The inclusive beginning of the range of stats to include in the results.
- * @param endTime The exclusive end of the range of stats to include in the results.
+ * Defined in terms of "Unix time", see
+ * {@link java.lang.System#currentTimeMillis}.
+ * @param endTime The exclusive end of the range of stats to include in the results. Defined
+ * in terms of "Unix time", see {@link java.lang.System#currentTimeMillis}.
* @return A list of {@link UsageStats}
*
* @see #INTERVAL_DAILY
@@ -329,7 +332,10 @@
*
* @param intervalType The time interval by which the stats are aggregated.
* @param beginTime The inclusive beginning of the range of stats to include in the results.
- * @param endTime The exclusive end of the range of stats to include in the results.
+ * Defined in terms of "Unix time", see
+ * {@link java.lang.System#currentTimeMillis}.
+ * @param endTime The exclusive end of the range of stats to include in the results. Defined
+ * in terms of "Unix time", see {@link java.lang.System#currentTimeMillis}.
* @return A list of {@link ConfigurationStats}
*/
public List<ConfigurationStats> queryConfigurations(int intervalType, long beginTime,
@@ -364,7 +370,10 @@
*
* @param intervalType The time interval by which the stats are aggregated.
* @param beginTime The inclusive beginning of the range of stats to include in the results.
- * @param endTime The exclusive end of the range of stats to include in the results.
+ * Defined in terms of "Unix time", see
+ * {@link java.lang.System#currentTimeMillis}.
+ * @param endTime The exclusive end of the range of stats to include in the results. Defined
+ * in terms of "Unix time", see {@link java.lang.System#currentTimeMillis}.
* @return A list of {@link EventStats}
*
* @see #INTERVAL_DAILY
@@ -393,7 +402,10 @@
* <p> The caller must have {@link android.Manifest.permission#PACKAGE_USAGE_STATS} </p>
*
* @param beginTime The inclusive beginning of the range of events to include in the results.
- * @param endTime The exclusive end of the range of events to include in the results.
+ * Defined in terms of "Unix time", see
+ * {@link java.lang.System#currentTimeMillis}.
+ * @param endTime The exclusive end of the range of events to include in the results. Defined
+ * in terms of "Unix time", see {@link java.lang.System#currentTimeMillis}.
* @return A {@link UsageEvents}.
*/
public UsageEvents queryEvents(long beginTime, long endTime) {
@@ -413,7 +425,10 @@
* Like {@link #queryEvents(long, long)}, but only returns events for the calling package.
*
* @param beginTime The inclusive beginning of the range of events to include in the results.
- * @param endTime The exclusive end of the range of events to include in the results.
+ * Defined in terms of "Unix time", see
+ * {@link java.lang.System#currentTimeMillis}.
+ * @param endTime The exclusive end of the range of events to include in the results. Defined
+ * in terms of "Unix time", see {@link java.lang.System#currentTimeMillis}.
* @return A {@link UsageEvents} object.
*
* @see #queryEvents(long, long)
@@ -438,7 +453,10 @@
* <p> The caller must have {@link android.Manifest.permission#PACKAGE_USAGE_STATS} </p>
*
* @param beginTime The inclusive beginning of the range of stats to include in the results.
- * @param endTime The exclusive end of the range of stats to include in the results.
+ * Defined in terms of "Unix time", see
+ * {@link java.lang.System#currentTimeMillis}.
+ * @param endTime The exclusive end of the range of stats to include in the results. Defined
+ * in terms of "Unix time", see {@link java.lang.System#currentTimeMillis}.
* @return A {@link java.util.Map} keyed by package name
*/
public Map<String, UsageStats> queryAndAggregateUsageStats(long beginTime, long endTime) {
diff --git a/core/java/android/content/om/OverlayInfo.java b/core/java/android/content/om/OverlayInfo.java
index 597c083..91424f4 100644
--- a/core/java/android/content/om/OverlayInfo.java
+++ b/core/java/android/content/om/OverlayInfo.java
@@ -46,7 +46,8 @@
STATE_ENABLED,
STATE_ENABLED_STATIC,
// @Deprecated STATE_TARGET_UPGRADING,
- STATE_OVERLAY_UPGRADING,
+ STATE_TARGET_IS_BEING_REPLACED,
+ STATE_OVERLAY_IS_BEING_REPLACED,
})
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@@ -94,8 +95,8 @@
public static final int STATE_ENABLED = 3;
/**
- * The target package is currently being upgraded; the state will change
- * once the package installation has finished.
+ * The target package is currently being upgraded or downgraded; the state
+ * will change once the package installation has finished.
* @hide
*
* @deprecated No longer used. Caused invalid transitions from enabled -> upgrading -> enabled,
@@ -105,14 +106,14 @@
* irrelevant.
*/
@Deprecated
- public static final int STATE_TARGET_UPGRADING = 4;
+ public static final int STATE_TARGET_IS_BEING_REPLACED = 4;
/**
- * The overlay package is currently being upgraded; the state will change
- * once the package installation has finished.
+ * The overlay package is currently being upgraded or downgraded; the state
+ * will change once the package installation has finished.
* @hide
*/
- public static final int STATE_OVERLAY_UPGRADING = 5;
+ public static final int STATE_OVERLAY_IS_BEING_REPLACED = 5;
/**
* The overlay package is currently enabled because it is marked as
@@ -306,8 +307,8 @@
case STATE_DISABLED:
case STATE_ENABLED:
case STATE_ENABLED_STATIC:
- case STATE_TARGET_UPGRADING:
- case STATE_OVERLAY_UPGRADING:
+ case STATE_TARGET_IS_BEING_REPLACED:
+ case STATE_OVERLAY_IS_BEING_REPLACED:
break;
default:
throw new IllegalArgumentException("State " + state + " is not a valid state");
@@ -386,10 +387,10 @@
return "STATE_ENABLED";
case STATE_ENABLED_STATIC:
return "STATE_ENABLED_STATIC";
- case STATE_TARGET_UPGRADING:
- return "STATE_TARGET_UPGRADING";
- case STATE_OVERLAY_UPGRADING:
- return "STATE_OVERLAY_UPGRADING";
+ case STATE_TARGET_IS_BEING_REPLACED:
+ return "STATE_TARGET_IS_BEING_REPLACED";
+ case STATE_OVERLAY_IS_BEING_REPLACED:
+ return "STATE_OVERLAY_IS_BEING_REPLACED";
default:
return "<unknown state>";
}
diff --git a/core/java/com/android/internal/colorextraction/types/Tonal.java b/core/java/com/android/internal/colorextraction/types/Tonal.java
index 9d85a03..b9aab21 100644
--- a/core/java/com/android/internal/colorextraction/types/Tonal.java
+++ b/core/java/com/android/internal/colorextraction/types/Tonal.java
@@ -109,42 +109,20 @@
final int mainColorsSize = mainColors.size();
final int hints = inWallpaperColors.getColorHints();
final boolean supportsDarkText = (hints & WallpaperColors.HINT_SUPPORTS_DARK_TEXT) != 0;
- final boolean generatedFromBitmap = (hints & WallpaperColors.HINT_FROM_BITMAP) != 0;
if (mainColorsSize == 0) {
return false;
}
- // Decide what's the best color to use.
- // We have 2 options:
- // • Just pick the primary color
- // • Filter out blacklisted colors. This is useful when palette is generated
- // automatically from a bitmap.
- Color bestColor = null;
- final float[] hsl = new float[3];
- for (int i = 0; i < mainColorsSize; i++) {
- final Color color = mainColors.get(i);
- final int colorValue = color.toArgb();
- ColorUtils.RGBToHSL(Color.red(colorValue), Color.green(colorValue),
- Color.blue(colorValue), hsl);
-
- // Stop when we find a color that meets our criteria
- if (!generatedFromBitmap) {
- bestColor = color;
- break;
- }
- }
-
- // Fail if not found
- if (bestColor == null) {
- return false;
- }
+ // Pick the primary color as the best color to use.
+ final Color bestColor = mainColors.get(0);
// Tonal is not really a sort, it takes a color from the extracted
// palette and finds a best fit amongst a collection of pre-defined
// palettes. The best fit is tweaked to be closer to the source color
// and replaces the original palette.
int colorValue = bestColor.toArgb();
+ final float[] hsl = new float[3];
ColorUtils.RGBToHSL(Color.red(colorValue), Color.green(colorValue), Color.blue(colorValue),
hsl);
diff --git a/core/java/com/android/server/BootReceiver.java b/core/java/com/android/server/BootReceiver.java
index 621d5a6..a087d68 100644
--- a/core/java/com/android/server/BootReceiver.java
+++ b/core/java/com/android/server/BootReceiver.java
@@ -267,6 +267,7 @@
if (file.isFile() && file.getName().startsWith("tombstone_")) {
addFileToDropBox(db, timestamps, headers, file.getPath(), LOG_SIZE,
TAG_TOMBSTONE);
+ StatsLog.write(StatsLog.TOMB_STONE_OCCURRED);
}
} catch (IOException e) {
Slog.e(TAG, "Can't log tombstone", e);
diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml
index 5cbe003..726dccb 100644
--- a/core/res/res/values/config.xml
+++ b/core/res/res/values/config.xml
@@ -3971,7 +3971,7 @@
M5,17.5 V12 H3 L7,4.5 V10 h2 L5,17.5 z
</string>
<string name="config_batterymeterPowersavePath" translatable="false">
- M9.75,10l-2.5,0l0,-2.5l-2.5,0l0,2.5l-2.5,0l0,2.5l2.5,0l0,2.5l2.5,0l0,-2.5l2.5,0z
+ M9,10l-2,0l0,-2l-2,0l0,2l-2,0l0,2l2,0l0,2l2,0l0,-2l2,0z
</string>
<!-- A dual tone battery meter draws the perimeter path twice - once to define the shape
diff --git a/media/java/android/media/MediaPlayer.java b/media/java/android/media/MediaPlayer.java
index 040152a..1937edd 100644
--- a/media/java/android/media/MediaPlayer.java
+++ b/media/java/android/media/MediaPlayer.java
@@ -1103,7 +1103,7 @@
setDataSource(afd);
return true;
} catch (NullPointerException | SecurityException | IOException ex) {
- Log.w(TAG, "Couldn't open " + uri == null ? "null uri" : uri.toSafeString(), ex);
+ Log.w(TAG, "Couldn't open " + (uri == null ? "null uri" : uri.toSafeString()), ex);
return false;
}
}
diff --git a/packages/SettingsLib/src/com/android/settingslib/graph/ThemedBatteryDrawable.kt b/packages/SettingsLib/src/com/android/settingslib/graph/ThemedBatteryDrawable.kt
index 1bb6c44..239b1d4 100644
--- a/packages/SettingsLib/src/com/android/settingslib/graph/ThemedBatteryDrawable.kt
+++ b/packages/SettingsLib/src/com/android/settingslib/graph/ThemedBatteryDrawable.kt
@@ -130,11 +130,12 @@
}
private val errorPaint = Paint(Paint.ANTI_ALIAS_FLAG).also { p ->
- p.color = Utils.getColorErrorDefaultColor(context)
+ p.color = Utils.getColorStateListDefaultColor(context, R.color.batterymeter_plus_color)
p.alpha = 255
p.isDither = true
p.strokeWidth = 0f
p.style = Paint.Style.FILL_AND_STROKE
+ p.blendMode = BlendMode.SRC
}
// Only used if dualTone is set to true
@@ -201,10 +202,6 @@
if (!invertFillIcon) {
c.drawPath(scaledBolt, fillPaint)
}
- } else if (powerSaveEnabled) {
- // Clip out the plus shape
- unifiedPath.op(scaledPlus, Path.Op.DIFFERENCE)
- c.drawPath(scaledPlus, errorPaint)
}
if (dualTone) {
@@ -243,10 +240,8 @@
} else if (powerSaveEnabled) {
// If power save is enabled draw the perimeter path with colorError
c.drawPath(scaledPerimeter, errorPaint)
-
- // But always put path protection around the plus sign
- c.clipOutPath(scaledPlus)
- c.drawPath(scaledPlus, fillColorStrokeProtection)
+ // And draw the plus sign on top of the fill
+ c.drawPath(scaledPlus, errorPaint)
}
}
diff --git a/packages/SystemUI/res/values/styles.xml b/packages/SystemUI/res/values/styles.xml
index a6a6e6b..7c123ef 100644
--- a/packages/SystemUI/res/values/styles.xml
+++ b/packages/SystemUI/res/values/styles.xml
@@ -316,6 +316,7 @@
<style name="qs_theme" parent="@*android:style/Theme.DeviceDefault.QuickSettings">
<item name="lightIconTheme">@style/QSIconTheme</item>
<item name="darkIconTheme">@style/QSIconTheme</item>
+ <item name="android:colorError">@*android:color/error_color_material_dark</item>
<item name="android:windowIsFloating">true</item>
</style>
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
index 7e06232..ed66b4b 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
@@ -3582,6 +3582,9 @@
updateHideIconsForBouncer(true /* animate */);
mCommandQueue.recomputeDisableFlags(mDisplayId, true /* animate */);
updateScrimController();
+ if (!mBouncerShowing) {
+ updatePanelExpansionForKeyguard();
+ }
}
/**
diff --git a/services/core/java/com/android/server/Watchdog.java b/services/core/java/com/android/server/Watchdog.java
index 1aeb689..afcf954 100644
--- a/services/core/java/com/android/server/Watchdog.java
+++ b/services/core/java/com/android/server/Watchdog.java
@@ -40,6 +40,7 @@
import android.util.EventLog;
import android.util.Log;
import android.util.Slog;
+import android.util.StatsLog;
import com.android.internal.os.ZygoteConnectionConstants;
import com.android.server.am.ActivityManagerService;
@@ -539,6 +540,7 @@
mActivity.addErrorToDropBox(
"watchdog", null, "system_server", null, null, null,
subject, null, stack, null);
+ StatsLog.write(StatsLog.SYSTEM_SERVER_WATCHDOG_OCCURRED, subject);
}
};
dropboxThread.start();
diff --git a/services/core/java/com/android/server/om/OverlayManagerService.java b/services/core/java/com/android/server/om/OverlayManagerService.java
index 13ff873..6e98d6e 100644
--- a/services/core/java/com/android/server/om/OverlayManagerService.java
+++ b/services/core/java/com/android/server/om/OverlayManagerService.java
@@ -345,7 +345,7 @@
switch (action) {
case ACTION_PACKAGE_ADDED:
if (replacing) {
- onPackageUpgraded(packageName, userIds);
+ onPackageReplaced(packageName, userIds);
} else {
onPackageAdded(packageName, userIds);
}
@@ -355,7 +355,7 @@
break;
case ACTION_PACKAGE_REMOVED:
if (replacing) {
- onPackageUpgrading(packageName, userIds);
+ onPackageReplacing(packageName, userIds);
} else {
onPackageRemoved(packageName, userIds);
}
@@ -412,16 +412,16 @@
}
}
- private void onPackageUpgrading(@NonNull final String packageName,
+ private void onPackageReplacing(@NonNull final String packageName,
@NonNull final int[] userIds) {
try {
- traceBegin(TRACE_TAG_RRO, "OMS#onPackageUpgrading " + packageName);
+ traceBegin(TRACE_TAG_RRO, "OMS#onPackageReplacing " + packageName);
for (int userId : userIds) {
synchronized (mLock) {
mPackageManager.forgetPackageInfo(packageName, userId);
final OverlayInfo oi = mImpl.getOverlayInfo(packageName, userId);
if (oi != null) {
- mImpl.onOverlayPackageUpgrading(packageName, userId);
+ mImpl.onOverlayPackageReplacing(packageName, userId);
}
}
}
@@ -430,10 +430,10 @@
}
}
- private void onPackageUpgraded(@NonNull final String packageName,
+ private void onPackageReplaced(@NonNull final String packageName,
@NonNull final int[] userIds) {
try {
- traceBegin(TRACE_TAG_RRO, "OMS#onPackageUpgraded " + packageName);
+ traceBegin(TRACE_TAG_RRO, "OMS#onPackageReplaced " + packageName);
for (int userId : userIds) {
synchronized (mLock) {
final PackageInfo pi = mPackageManager.getPackageInfo(packageName, userId,
@@ -441,9 +441,9 @@
if (pi != null) {
mPackageManager.cachePackageInfo(packageName, userId, pi);
if (pi.isOverlayPackage()) {
- mImpl.onOverlayPackageUpgraded(packageName, userId);
+ mImpl.onOverlayPackageReplaced(packageName, userId);
} else {
- mImpl.onTargetPackageUpgraded(packageName, userId);
+ mImpl.onTargetPackageReplaced(packageName, userId);
}
}
}
diff --git a/services/core/java/com/android/server/om/OverlayManagerServiceImpl.java b/services/core/java/com/android/server/om/OverlayManagerServiceImpl.java
index a3d6380..ec53e98 100644
--- a/services/core/java/com/android/server/om/OverlayManagerServiceImpl.java
+++ b/services/core/java/com/android/server/om/OverlayManagerServiceImpl.java
@@ -21,7 +21,8 @@
import static android.content.om.OverlayInfo.STATE_ENABLED_STATIC;
import static android.content.om.OverlayInfo.STATE_MISSING_TARGET;
import static android.content.om.OverlayInfo.STATE_NO_IDMAP;
-import static android.content.om.OverlayInfo.STATE_OVERLAY_UPGRADING;
+import static android.content.om.OverlayInfo.STATE_OVERLAY_IS_BEING_REPLACED;
+import static android.content.om.OverlayInfo.STATE_TARGET_IS_BEING_REPLACED;
import static com.android.server.om.OverlayManagerService.DEBUG;
import static com.android.server.om.OverlayManagerService.TAG;
@@ -56,15 +57,14 @@
* @see OverlayManagerService
*/
final class OverlayManagerServiceImpl {
-
/**
* @deprecated Not used. See {@link android.content.om.OverlayInfo#STATE_TARGET_UPGRADING}.
*/
@Deprecated
- private static final int FLAG_TARGET_IS_UPGRADING = 1 << 0;
+ private static final int FLAG_TARGET_IS_BEING_REPLACED = 1 << 0;
// Flags to use in conjunction with updateState.
- private static final int FLAG_OVERLAY_IS_UPGRADING = 1 << 1;
+ private static final int FLAG_OVERLAY_IS_BEING_REPLACED = 1 << 1;
private final PackageManagerHelper mPackageManager;
private final IdmapManager mIdmapManager;
@@ -266,9 +266,18 @@
updateAndRefreshOverlaysForTarget(packageName, userId, 0);
}
- void onTargetPackageUpgraded(@NonNull final String packageName, final int userId) {
+ void onTargetPackageReplacing(@NonNull final String packageName, final int userId) {
if (DEBUG) {
- Slog.d(TAG, "onTargetPackageUpgraded packageName=" + packageName + " userId=" + userId);
+ Slog.d(TAG, "onTargetPackageReplacing packageName=" + packageName + " userId="
+ + userId);
+ }
+
+ updateAndRefreshOverlaysForTarget(packageName, userId, 0);
+ }
+
+ void onTargetPackageReplaced(@NonNull final String packageName, final int userId) {
+ if (DEBUG) {
+ Slog.d(TAG, "onTargetPackageReplaced packageName=" + packageName + " userId=" + userId);
}
updateAndRefreshOverlaysForTarget(packageName, userId, 0);
@@ -388,15 +397,16 @@
}
}
- void onOverlayPackageUpgrading(@NonNull final String packageName, final int userId) {
+ void onOverlayPackageReplacing(@NonNull final String packageName, final int userId) {
if (DEBUG) {
- Slog.d(TAG, "onOverlayPackageUpgrading packageName=" + packageName + " userId="
+ Slog.d(TAG, "onOverlayPackageReplacing packageName=" + packageName + " userId="
+ userId);
}
try {
final OverlayInfo oi = mSettings.getOverlayInfo(packageName, userId);
- if (updateState(oi.targetPackageName, packageName, userId, FLAG_OVERLAY_IS_UPGRADING)) {
+ if (updateState(oi.targetPackageName, packageName, userId,
+ FLAG_OVERLAY_IS_BEING_REPLACED)) {
removeIdmapIfPossible(oi);
mListener.onOverlaysChanged(oi.targetPackageName, userId);
}
@@ -405,15 +415,15 @@
}
}
- void onOverlayPackageUpgraded(@NonNull final String packageName, final int userId) {
+ void onOverlayPackageReplaced(@NonNull final String packageName, final int userId) {
if (DEBUG) {
- Slog.d(TAG, "onOverlayPackageUpgraded packageName=" + packageName + " userId="
+ Slog.d(TAG, "onOverlayPackageReplaced packageName=" + packageName + " userId="
+ userId);
}
final PackageInfo pkg = mPackageManager.getPackageInfo(packageName, userId);
if (pkg == null) {
- Slog.w(TAG, "overlay package " + packageName + " was upgraded, but couldn't be found");
+ Slog.w(TAG, "overlay package " + packageName + " was replaced, but couldn't be found");
onOverlayPackageRemoved(packageName, userId);
return;
}
@@ -694,8 +704,12 @@
@Nullable final PackageInfo overlayPackage, final int userId, final int flags)
throws OverlayManagerSettings.BadKeyException {
- if ((flags & FLAG_OVERLAY_IS_UPGRADING) != 0) {
- return STATE_OVERLAY_UPGRADING;
+ if ((flags & FLAG_TARGET_IS_BEING_REPLACED) != 0) {
+ return STATE_TARGET_IS_BEING_REPLACED;
+ }
+
+ if ((flags & FLAG_OVERLAY_IS_BEING_REPLACED) != 0) {
+ return STATE_OVERLAY_IS_BEING_REPLACED;
}
// assert expectation on overlay package: can only be null if the flags are used
diff --git a/services/core/java/com/android/server/om/OverlayManagerSettings.java b/services/core/java/com/android/server/om/OverlayManagerSettings.java
index 667dfa1..36b5beb 100644
--- a/services/core/java/com/android/server/om/OverlayManagerSettings.java
+++ b/services/core/java/com/android/server/om/OverlayManagerSettings.java
@@ -309,7 +309,6 @@
pw.println("mTargetOverlayableName.: " + item.getTargetOverlayableName());
pw.println("mBaseCodePath..........: " + item.getBaseCodePath());
pw.println("mState.................: " + OverlayInfo.stateToString(item.getState()));
- pw.println("mState.................: " + OverlayInfo.stateToString(item.getState()));
pw.println("mIsEnabled.............: " + item.isEnabled());
pw.println("mIsStatic..............: " + item.isStatic());
pw.println("mPriority..............: " + item.mPriority);
diff --git a/services/core/java/com/android/server/storage/CacheQuotaStrategy.java b/services/core/java/com/android/server/storage/CacheQuotaStrategy.java
index 7a35bf7..2df7370 100644
--- a/services/core/java/com/android/server/storage/CacheQuotaStrategy.java
+++ b/services/core/java/com/android/server/storage/CacheQuotaStrategy.java
@@ -66,7 +66,6 @@
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
-import java.util.Map;
/**
* CacheQuotaStrategy is a strategy for determining cache quotas using usage stats and foreground
@@ -296,26 +295,24 @@
* @return the number of bytes that were free on the device when the quotas were last calced.
*/
public long setupQuotasFromFile() throws IOException {
- FileInputStream stream;
- try {
- stream = mPreviousValuesFile.openRead();
+ Pair<Long, List<CacheQuotaHint>> cachedValues = null;
+ try (FileInputStream stream = mPreviousValuesFile.openRead()) {
+ try {
+ cachedValues = readFromXml(stream);
+ } catch (XmlPullParserException e) {
+ throw new IllegalStateException(e.getMessage());
+ }
} catch (FileNotFoundException e) {
// The file may not exist yet -- this isn't truly exceptional.
return -1;
}
- Pair<Long, List<CacheQuotaHint>> cachedValues = null;
- try {
- cachedValues = readFromXml(stream);
- } catch (XmlPullParserException e) {
- throw new IllegalStateException(e.getMessage());
- }
-
if (cachedValues == null) {
Slog.e(TAG, "An error occurred while parsing the cache quota file.");
return -1;
}
pushProcessedQuotas(cachedValues.second);
+
return cachedValues.first;
}
diff --git a/telephony/java/android/provider/Telephony.java b/telephony/java/android/provider/Telephony.java
index 3106e40..52e0ebd 100644
--- a/telephony/java/android/provider/Telephony.java
+++ b/telephony/java/android/provider/Telephony.java
@@ -35,6 +35,7 @@
import android.database.sqlite.SqliteWrapper;
import android.net.Uri;
import android.os.Build;
+import android.os.Parcel;
import android.telephony.Rlog;
import android.telephony.ServiceState;
import android.telephony.SmsMessage;
@@ -4130,32 +4131,24 @@
*/
public static ContentValues getContentValuesForServiceState(ServiceState state) {
ContentValues values = new ContentValues();
- values.put(VOICE_REG_STATE, state.getVoiceRegState());
- values.put(DATA_REG_STATE, state.getDataRegState());
- values.put(VOICE_ROAMING_TYPE, state.getVoiceRoamingType());
- values.put(DATA_ROAMING_TYPE, state.getDataRoamingType());
- values.put(VOICE_OPERATOR_ALPHA_LONG, state.getVoiceOperatorAlphaLong());
- values.put(VOICE_OPERATOR_ALPHA_SHORT, state.getVoiceOperatorAlphaShort());
- values.put(VOICE_OPERATOR_NUMERIC, state.getVoiceOperatorNumeric());
- values.put(DATA_OPERATOR_ALPHA_LONG, state.getDataOperatorAlphaLong());
- values.put(DATA_OPERATOR_ALPHA_SHORT, state.getDataOperatorAlphaShort());
- values.put(DATA_OPERATOR_NUMERIC, state.getDataOperatorNumeric());
- values.put(IS_MANUAL_NETWORK_SELECTION, state.getIsManualSelection());
- values.put(RIL_VOICE_RADIO_TECHNOLOGY, state.getRilVoiceRadioTechnology());
- values.put(RIL_DATA_RADIO_TECHNOLOGY, state.getRilDataRadioTechnology());
- values.put(CSS_INDICATOR, state.getCssIndicator());
- values.put(NETWORK_ID, state.getCdmaNetworkId());
- values.put(SYSTEM_ID, state.getCdmaSystemId());
- values.put(CDMA_ROAMING_INDICATOR, state.getCdmaRoamingIndicator());
- values.put(CDMA_DEFAULT_ROAMING_INDICATOR, state.getCdmaDefaultRoamingIndicator());
- values.put(CDMA_ERI_ICON_INDEX, state.getCdmaEriIconIndex());
- values.put(CDMA_ERI_ICON_MODE, state.getCdmaEriIconMode());
- values.put(IS_EMERGENCY_ONLY, state.isEmergencyOnly());
- values.put(IS_USING_CARRIER_AGGREGATION, state.isUsingCarrierAggregation());
+ final Parcel p = Parcel.obtain();
+ state.writeToParcel(p, 0);
+ // Turn the parcel to byte array. Safe to do this because the content values were never
+ // written into a persistent storage. ServiceStateProvider keeps values in the memory.
+ values.put(SERVICE_STATE, p.marshall());
return values;
}
/**
+ * The current service state.
+ *
+ * This is the entire {@link ServiceState} object in byte array.
+ *
+ * @hide
+ */
+ public static final String SERVICE_STATE = "service_state";
+
+ /**
* An integer value indicating the current voice service state.
* <p>
* Valid values: {@link ServiceState#STATE_IN_SERVICE},
diff --git a/telephony/java/android/telephony/DataSpecificRegistrationInfo.java b/telephony/java/android/telephony/DataSpecificRegistrationInfo.java
index fbf488e..465c2b1 100644
--- a/telephony/java/android/telephony/DataSpecificRegistrationInfo.java
+++ b/telephony/java/android/telephony/DataSpecificRegistrationInfo.java
@@ -74,16 +74,25 @@
private final LteVopsSupportInfo mLteVopsSupportInfo;
/**
+ * Indicates if it's using carrier aggregation
+ *
+ * @hide
+ */
+ public final boolean isUsingCarrierAggregation;
+
+ /**
* @hide
*/
DataSpecificRegistrationInfo(
int maxDataCalls, boolean isDcNrRestricted, boolean isNrAvailable,
- boolean isEnDcAvailable, LteVopsSupportInfo lteVops) {
+ boolean isEnDcAvailable, LteVopsSupportInfo lteVops,
+ boolean isUsingCarrierAggregation) {
this.maxDataCalls = maxDataCalls;
this.isDcNrRestricted = isDcNrRestricted;
this.isNrAvailable = isNrAvailable;
this.isEnDcAvailable = isEnDcAvailable;
this.mLteVopsSupportInfo = lteVops;
+ this.isUsingCarrierAggregation = isUsingCarrierAggregation;
}
private DataSpecificRegistrationInfo(Parcel source) {
@@ -92,6 +101,7 @@
isNrAvailable = source.readBoolean();
isEnDcAvailable = source.readBoolean();
mLteVopsSupportInfo = LteVopsSupportInfo.CREATOR.createFromParcel(source);
+ isUsingCarrierAggregation = source.readBoolean();
}
@Override
@@ -101,6 +111,7 @@
dest.writeBoolean(isNrAvailable);
dest.writeBoolean(isEnDcAvailable);
mLteVopsSupportInfo.writeToParcel(dest, flags);
+ dest.writeBoolean(isUsingCarrierAggregation);
}
@Override
@@ -116,7 +127,8 @@
.append(" isDcNrRestricted = " + isDcNrRestricted)
.append(" isNrAvailable = " + isNrAvailable)
.append(" isEnDcAvailable = " + isEnDcAvailable)
- .append(mLteVopsSupportInfo.toString())
+ .append(" " + mLteVopsSupportInfo.toString())
+ .append(" isUsingCarrierAggregation = " + isUsingCarrierAggregation)
.append(" }")
.toString();
}
@@ -124,7 +136,7 @@
@Override
public int hashCode() {
return Objects.hash(maxDataCalls, isDcNrRestricted, isNrAvailable, isEnDcAvailable,
- mLteVopsSupportInfo);
+ mLteVopsSupportInfo, isUsingCarrierAggregation);
}
@Override
@@ -138,7 +150,8 @@
&& this.isDcNrRestricted == other.isDcNrRestricted
&& this.isNrAvailable == other.isNrAvailable
&& this.isEnDcAvailable == other.isEnDcAvailable
- && this.mLteVopsSupportInfo.equals(other.mLteVopsSupportInfo);
+ && this.mLteVopsSupportInfo.equals(other.mLteVopsSupportInfo)
+ && this.isUsingCarrierAggregation == other.isUsingCarrierAggregation;
}
public static final @NonNull Parcelable.Creator<DataSpecificRegistrationInfo> CREATOR =
diff --git a/telephony/java/android/telephony/NetworkRegistrationInfo.java b/telephony/java/android/telephony/NetworkRegistrationInfo.java
index 1dc2997..2bb02e7 100644
--- a/telephony/java/android/telephony/NetworkRegistrationInfo.java
+++ b/telephony/java/android/telephony/NetworkRegistrationInfo.java
@@ -251,12 +251,13 @@
@Nullable CellIdentity cellIdentity, int maxDataCalls,
boolean isDcNrRestricted, boolean isNrAvailable,
boolean isEndcAvailable,
- LteVopsSupportInfo lteVopsSupportInfo) {
+ LteVopsSupportInfo lteVopsSupportInfo,
+ boolean isUsingCarrierAggregation) {
this(domain, transportType, registrationState, accessNetworkTechnology, rejectCause,
emergencyOnly, availableServices, cellIdentity);
-
mDataSpecificInfo = new DataSpecificRegistrationInfo(
- maxDataCalls, isDcNrRestricted, isNrAvailable, isEndcAvailable, lteVopsSupportInfo);
+ maxDataCalls, isDcNrRestricted, isNrAvailable, isEndcAvailable, lteVopsSupportInfo,
+ isUsingCarrierAggregation);
updateNrState(mDataSpecificInfo);
}
diff --git a/tests/Internal/Android.bp b/tests/Internal/Android.bp
index 4cb9f8d5..e233fed 100644
--- a/tests/Internal/Android.bp
+++ b/tests/Internal/Android.bp
@@ -10,6 +10,7 @@
"junit",
"androidx.test.rules",
"mockito-target-minus-junit4",
+ "truth-prebuilt",
],
java_resource_dirs: ["res"],
certificate: "platform",
diff --git a/tests/Internal/src/com/android/internal/colorextraction/types/TonalTest.java b/tests/Internal/src/com/android/internal/colorextraction/types/TonalTest.java
index 300182d..768e47c 100644
--- a/tests/Internal/src/com/android/internal/colorextraction/types/TonalTest.java
+++ b/tests/Internal/src/com/android/internal/colorextraction/types/TonalTest.java
@@ -15,6 +15,8 @@
*/
package com.android.internal.colorextraction.types;
+import static com.google.common.truth.Truth.assertThat;
+
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@@ -67,6 +69,36 @@
}
@Test
+ public void extractInto_fromBitmap() {
+ Tonal tonal = new Tonal(InstrumentationRegistry.getContext());
+ GradientColors normal = new GradientColors();
+ GradientColors dark = new GradientColors();
+ GradientColors extraDark = new GradientColors();
+ WallpaperColors wallColors = new WallpaperColors(Color.valueOf(Color.RED), null, null,
+ WallpaperColors.HINT_FROM_BITMAP);
+
+ // WHEN colors are extracted from a wallpaper with only a red primary color.
+ tonal.extractInto(wallColors, normal, dark, extraDark);
+ // THEN the main extracted color is red
+ assertThat(normal.getMainColor()).isEqualTo(Color.RED);
+ }
+
+ @Test
+ public void extractInto_supportsDarkText() {
+ Tonal tonal = new Tonal(InstrumentationRegistry.getContext());
+ GradientColors normal = new GradientColors();
+ GradientColors dark = new GradientColors();
+ GradientColors extraDark = new GradientColors();
+ WallpaperColors wallColors = new WallpaperColors(Color.valueOf(Color.RED), null, null,
+ WallpaperColors.HINT_SUPPORTS_DARK_TEXT);
+
+ // WHEN colors are extracted from a wallpaper with only a red primary color.
+ tonal.extractInto(wallColors, normal, dark, extraDark);
+ // THEN the main extracted color is red
+ assertThat(normal.getMainColor()).isEqualTo(Color.RED);
+ }
+
+ @Test
public void colorRange_containsColor() {
Tonal.ColorRange colorRange = new Tonal.ColorRange(new Range<>(0f, 50f),
new Range<>(0f, 1f), new Range<>(0f, 1f));
diff --git a/wifi/java/android/net/wifi/WifiManager.java b/wifi/java/android/net/wifi/WifiManager.java
index 06a99e2..9b3796f 100644
--- a/wifi/java/android/net/wifi/WifiManager.java
+++ b/wifi/java/android/net/wifi/WifiManager.java
@@ -2424,8 +2424,11 @@
* @throws {@link java.lang.SecurityException} if the caller is missing required permissions.
*
* @deprecated Starting with Build.VERSION_CODES#Q, applications are not allowed to
- * enable/disable Wi-Fi regardless of application's target SDK. This API will have no effect
- * and will always return false.
+ * enable/disable Wi-Fi.
+ * <b>Compatibility Note:</b> For applications targeting
+ * {@link android.os.Build.VERSION_CODES#Q} or above, this API will always return {@code false}
+ * and will have no effect. If apps are targeting an older SDK (
+ * {@link android.os.Build.VERSION_CODES#P} or below), they can continue to use this API.
*/
@Deprecated
public boolean setWifiEnabled(boolean enabled) {