diff options
110 files changed, 3523 insertions, 1331 deletions
diff --git a/Android.bp b/Android.bp index 2f3605946393..f9b60e67e659 100644 --- a/Android.bp +++ b/Android.bp @@ -614,6 +614,7 @@ java_defaults { ":netd_aidl", ":vold_aidl", ":installd_aidl", + ":dumpstate_aidl", "lowpan/java/android/net/lowpan/ILowpanEnergyScanCallback.aidl", "lowpan/java/android/net/lowpan/ILowpanNetScanCallback.aidl", @@ -660,6 +661,7 @@ java_defaults { include_dirs: [ "system/update_engine/binder_bindings", "frameworks/native/aidl/binder", + "frameworks/native/cmds/dumpstate/binder", "frameworks/av/camera/aidl", "frameworks/av/media/libaudioclient/aidl", "frameworks/native/aidl/gui", @@ -833,7 +835,6 @@ java_library_host { "cmds/statsd/src/**/*.proto", "core/proto/**/*.proto", "libs/incident/proto/**/*.proto", - "proto/src/stats_enums.proto", ], proto: { include_dirs: ["external/protobuf/src"], @@ -871,7 +872,6 @@ java_library { srcs: [ "core/proto/**/*.proto", "libs/incident/proto/android/os/**/*.proto", - "proto/src/stats_enums.proto", ], // Protos have lots of MissingOverride and similar. errorprone: { @@ -897,7 +897,6 @@ cc_library { srcs: [ "core/proto/**/*.proto", "libs/incident/**/*.proto", - "proto/src/stats_enums.proto", ], target: { @@ -1094,6 +1093,7 @@ framework_docs_args = "-android -manifest $(location core/res/AndroidManifest.xm "-federationapi SupportLib $(location current/support-api.txt) " framework_docs_only_args = " -android -manifest $(location core/res/AndroidManifest.xml) " + + "-werror -lerror -hide 111 -hide 113 -hide 125 -hide 126 -hide 127 -hide 128 " + "-overview $(location core/java/overview.html) " + // Federate Support Library references against local API file. "-federate SupportLib https://developer.android.com " + @@ -1179,7 +1179,8 @@ stubs_defaults { doc_defaults { name: "framework-docs-default", - libs: framework_docs_only_libs, + libs: framework_docs_only_libs + + ["stub-annotations"], html_dirs: [ "docs/html", ], diff --git a/api/current.txt b/api/current.txt index 0b6af293f667..9269d979104f 100755 --- a/api/current.txt +++ b/api/current.txt @@ -17,6 +17,7 @@ package android { field public static final java.lang.String ACCESS_NOTIFICATION_POLICY = "android.permission.ACCESS_NOTIFICATION_POLICY"; field public static final java.lang.String ACCESS_WIFI_STATE = "android.permission.ACCESS_WIFI_STATE"; field public static final java.lang.String ACCOUNT_MANAGER = "android.permission.ACCOUNT_MANAGER"; + field public static final java.lang.String ACTIVITY_RECOGNITION = "android.permission.ACTIVITY_RECOGNITION"; field public static final java.lang.String ADD_VOICEMAIL = "com.android.voicemail.permission.ADD_VOICEMAIL"; field public static final java.lang.String ANSWER_PHONE_CALLS = "android.permission.ANSWER_PHONE_CALLS"; field public static final java.lang.String BATTERY_STATS = "android.permission.BATTERY_STATS"; @@ -168,6 +169,7 @@ package android { public static final class Manifest.permission_group { ctor public Manifest.permission_group(); + field public static final java.lang.String ACTIVITY_RECOGNITION = "android.permission-group.ACTIVITY_RECOGNITION"; field public static final java.lang.String CALENDAR = "android.permission-group.CALENDAR"; field public static final java.lang.String CALL_LOG = "android.permission-group.CALL_LOG"; field public static final java.lang.String CAMERA = "android.permission-group.CAMERA"; diff --git a/api/system-current.txt b/api/system-current.txt index 6c98753b38e2..92fdca41249d 100644 --- a/api/system-current.txt +++ b/api/system-current.txt @@ -222,7 +222,7 @@ package android { } public static final class R.dimen { - field public static final int config_restricted_icon_size = 17104903; // 0x1050007 + field public static final int config_restrictedIconSize = 17104903; // 0x1050007 } public static final class R.drawable { @@ -235,12 +235,12 @@ package android { } public static final class R.string { - field public static final int config_feedback_intent_extra_key = 17039391; // 0x104001f - field public static final int config_feedback_intent_name_key = 17039392; // 0x1040020 - field public static final int config_help_intent_extra_key = 17039389; // 0x104001d - field public static final int config_help_intent_name_key = 17039390; // 0x104001e - field public static final int config_help_package_name_key = 17039387; // 0x104001b - field public static final int config_help_package_name_value = 17039388; // 0x104001c + field public static final int config_feedbackIntentExtraKey = 17039391; // 0x104001f + field public static final int config_feedbackIntentNameKey = 17039392; // 0x1040020 + field public static final int config_helpIntentExtraKey = 17039389; // 0x104001d + field public static final int config_helpIntentNameKey = 17039390; // 0x104001e + field public static final int config_helpPackageNameKey = 17039387; // 0x104001b + field public static final int config_helpPackageNameValue = 17039388; // 0x104001c } public static final class R.style { @@ -4130,7 +4130,6 @@ package android.os { public class UserManager { method public void clearSeedAccountData(); - method public int[] getProfileIds(int, boolean); method public java.lang.String getSeedAccountName(); method public android.os.PersistableBundle getSeedAccountOptions(); method public java.lang.String getSeedAccountType(); @@ -4195,8 +4194,8 @@ package android.permission { } public static final class PermissionManager.SplitPermissionInfo { - method public java.lang.String[] getNewPermissions(); - method public java.lang.String getRootPermission(); + method public java.util.List<java.lang.String> getNewPermissions(); + method public java.lang.String getSplitPermission(); method public int getTargetSdk(); } @@ -5281,6 +5280,7 @@ package android.telephony { method public int getRejectCause(); method public int getTransportType(); method public boolean isEmergencyEnabled(); + method public boolean isRoaming(); method public void writeToParcel(android.os.Parcel, int); field public static final android.os.Parcelable.Creator<android.telephony.NetworkRegistrationState> CREATOR; field public static final int DOMAIN_CS = 1; // 0x1 @@ -6649,7 +6649,7 @@ package android.util { package android.view { public abstract class Window { - method public void addPrivateFlags(int); + method public void addSystemFlags(int); } public abstract interface WindowManager implements android.view.ViewManager { @@ -6659,7 +6659,10 @@ package android.view { public static class WindowManager.LayoutParams extends android.view.ViewGroup.LayoutParams implements android.os.Parcelable { method public final long getUserActivityTimeout(); method public final void setUserActivityTimeout(long); - field public static final int PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS = 524288; // 0x80000 + field public static final int SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS = 524288; // 0x80000 + } + + public static abstract class WindowManager.LayoutParams.SystemFlags implements java.lang.annotation.Annotation { } } diff --git a/cmds/statsd/src/StatsLogProcessor.h b/cmds/statsd/src/StatsLogProcessor.h index 4091d951ba06..6a9e8a1bf688 100644 --- a/cmds/statsd/src/StatsLogProcessor.h +++ b/cmds/statsd/src/StatsLogProcessor.h @@ -39,7 +39,8 @@ enum DumpReportReason { GET_DATA_CALLED = 4, ADB_DUMP = 5, CONFIG_RESET = 6, - STATSCOMPANION_DIED = 7 + STATSCOMPANION_DIED = 7, + TERMINATION_SIGNAL_RECEIVED = 8 }; class StatsLogProcessor : public ConfigListener { diff --git a/cmds/statsd/src/StatsService.cpp b/cmds/statsd/src/StatsService.cpp index 8da2d447a163..fb6f8c8d4590 100644 --- a/cmds/statsd/src/StatsService.cpp +++ b/cmds/statsd/src/StatsService.cpp @@ -867,6 +867,13 @@ void StatsService::Startup() { mConfigManager->Startup(); } +void StatsService::Terminate() { + ALOGI("StatsService::Terminating"); + if (mProcessor != nullptr) { + mProcessor->WriteDataToDisk(TERMINATION_SIGNAL_RECEIVED); + } +} + void StatsService::OnLogEvent(LogEvent* event) { mProcessor->OnLogEvent(event); if (mShellSubscriber != nullptr) { diff --git a/cmds/statsd/src/StatsService.h b/cmds/statsd/src/StatsService.h index 1f1d782af235..cbf34292c1d4 100644 --- a/cmds/statsd/src/StatsService.h +++ b/cmds/statsd/src/StatsService.h @@ -84,6 +84,11 @@ public: void Startup(); /** + * Called when terminiation signal received. + */ + void Terminate(); + + /** * Called by LogReader when there's a log event to process. */ virtual void OnLogEvent(LogEvent* event); diff --git a/cmds/statsd/src/atom_field_options.proto b/cmds/statsd/src/atom_field_options.proto index a2a03b14c073..453bf7e126cd 100644 --- a/cmds/statsd/src/atom_field_options.proto +++ b/cmds/statsd/src/atom_field_options.proto @@ -36,8 +36,8 @@ enum StateField { // exclusive state field, and any number of primary key fields. // For example, // message UidProcessStateChanged { -// optional int32 uid = 1 [(stateFieldOption).option = PRIMARY]; -// optional android.app.ProcessStateEnum state = 2 [(stateFieldOption).option = EXCLUSIVE]; +// optional int32 uid = 1 [(state_field_option).option = PRIMARY]; +// optional android.app.ProcessStateEnum state = 2 [(state_field_option).option = EXCLUSIVE]; // } // Each of this UidProcessStateChanged atom represents a state change for a specific uid. // A new state automatically overrides the previous state. @@ -46,16 +46,16 @@ enum StateField { // the primary key. // For example: // message ThreadStateChanged { -// optional int32 pid = 1 [(stateFieldOption).option = PRIMARY]; -// optional int32 tid = 2 [(stateFieldOption).option = PRIMARY]; -// optional int32 state = 3 [(stateFieldOption).option = EXCLUSIVE]; +// optional int32 pid = 1 [(state_field_option).option = PRIMARY]; +// optional int32 tid = 2 [(state_field_option).option = PRIMARY]; +// optional int32 state = 3 [(state_field_option).option = EXCLUSIVE]; // } // // Sometimes, there is no primary key field, when the state is GLOBAL. // For example, // // message ScreenStateChanged { -// optional android.view.DisplayStateEnum state = 1 [(stateFieldOption).option = EXCLUSIVE]; +// optional android.view.DisplayStateEnum state = 1 [(state_field_option).option = EXCLUSIVE]; // } // // Only fields of primary types can be annotated. AttributionNode cannot be primary keys (and they @@ -66,7 +66,7 @@ message StateAtomFieldOption { extend google.protobuf.FieldOptions { // Flags to decorate an atom that presents a state change. - optional StateAtomFieldOption stateFieldOption = 50000; + optional StateAtomFieldOption state_field_option = 50000; // Flags to decorate the uid fields in an atom. optional bool is_uid = 50001 [default = false]; diff --git a/cmds/statsd/src/atoms.proto b/cmds/statsd/src/atoms.proto index 8eee9e6af237..501b59388aed 100644 --- a/cmds/statsd/src/atoms.proto +++ b/cmds/statsd/src/atoms.proto @@ -26,12 +26,11 @@ import "frameworks/base/core/proto/android/app/job/enums.proto"; import "frameworks/base/core/proto/android/bluetooth/enums.proto"; import "frameworks/base/core/proto/android/os/enums.proto"; import "frameworks/base/core/proto/android/server/enums.proto"; +import "frameworks/base/core/proto/android/service/procstats_enum.proto"; +import "frameworks/base/core/proto/android/stats/enums.proto"; import "frameworks/base/core/proto/android/telecomm/enums.proto"; import "frameworks/base/core/proto/android/telephony/enums.proto"; import "frameworks/base/core/proto/android/view/enums.proto"; -import "frameworks/base/proto/src/stats_enums.proto"; -import "frameworks/base/core/proto/android/service/procstats.proto"; -import "frameworks/base/core/proto/android/internal/powerprofile.proto"; /** * The master atom class. This message defines all of the available @@ -129,8 +128,6 @@ message Atom { AppCrashOccurred app_crash_occurred = 78; ANROccurred anr_occurred = 79; WTFOccurred wtf_occurred = 80; - PhoneServiceStateChanged phone_service_state_changed = 94; - PhoneStateChanged phone_state_changed = 95; LowMemReported low_mem_reported = 81; GenericAtom generic_atom = 82; KeyValuePairsAtom key_value_pairs_atom = 83; @@ -144,6 +141,8 @@ message Atom { BatteryHealthSnapshot battery_health_snapshot = 91; SlowIo slow_io = 92; BatteryCausedShutdown battery_caused_shutdown = 93; + PhoneServiceStateChanged phone_service_state_changed = 94; + PhoneStateChanged phone_state_changed = 95; } // Pulled events will start at field 10000. @@ -275,7 +274,7 @@ message ThermalThrottlingStateChanged { */ message ScreenStateChanged { // New screen state, from frameworks/base/core/proto/android/view/enums.proto. - optional android.view.DisplayStateEnum state = 1 [(stateFieldOption).option = EXCLUSIVE]; + optional android.view.DisplayStateEnum state = 1 [(state_field_option).option = EXCLUSIVE]; } /** @@ -286,10 +285,10 @@ message ScreenStateChanged { * frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java */ message UidProcessStateChanged { - optional int32 uid = 1 [(stateFieldOption).option = PRIMARY, (is_uid) = true]; + optional int32 uid = 1 [(state_field_option).option = PRIMARY, (is_uid) = true]; // The state, from frameworks/base/core/proto/android/app/enums.proto. - optional android.app.ProcessStateEnum state = 2 [(stateFieldOption).option = EXCLUSIVE]; + optional android.app.ProcessStateEnum state = 2 [(state_field_option).option = EXCLUSIVE]; } /** @@ -321,7 +320,7 @@ message ActivityManagerSleepStateChanged { ASLEEP = 1; AWAKE = 2; } - optional State state = 1 [(stateFieldOption).option = EXCLUSIVE]; + optional State state = 1 [(state_field_option).option = EXCLUSIVE]; } /** @@ -340,7 +339,7 @@ message MemoryFactorStateChanged { CRITICAL = 4; // critical memory. } - optional State factor = 1 [(stateFieldOption).option = EXCLUSIVE]; + optional State factor = 1 [(state_field_option).option = EXCLUSIVE]; } /** @@ -1941,7 +1940,7 @@ message LmkKillOccurred { */ message AppDied { // timestamp(elapsedRealtime) of record creation - optional uint64 timestamp_millis = 1 [(stateFieldOption).option = EXCLUSIVE]; + optional uint64 timestamp_millis = 1 [(state_field_option).option = EXCLUSIVE]; } /** @@ -1952,7 +1951,7 @@ message GenericAtom { optional int32 uid = 1 [(is_uid) = true]; // An event_id indicates the type of event. - optional android.os.statsd.EventType event_id = 2; + optional android.stats.EventType event_id = 2; } /** @@ -2556,8 +2555,7 @@ message LooperStats { // recorded_message_count. // // If recorded_message_count is different than message_count, it means data - // collection has been sampled. All the fields below will be sampled in this - // case. + // collection has been sampled. The fields below will be sampled in this case. optional int64 recorded_message_count = 7; // Total latency of all processed messages. @@ -2573,6 +2571,32 @@ message LooperStats { // True if the screen was interactive PowerManager#isInteractive at the end of the call. optional bool screen_interactive = 10; + + // Max recorded CPU usage of all processed messages. + optional int64 recorded_max_cpu_micros = 11; + + // Max recorded latency of all processed messages. + optional int64 recorded_max_latency_micros = 12; + + // Total number of messages we tracked the dispatching delay for. If we + // collected data for all the messages, message_count will be equal to + // recorded_delay_message_count. + // + // If recorded_delay_message_count is different than message_count, it means data + // collection has been sampled or/and not all messages specified the target dispatch time. + // The fields below will be sampled in this case. + optional int64 recorded_delay_message_count = 13; + + // Total dispatching delay of all processed messages. + // Calculated as a difference between the target dispatching time (Message.when) + // and the actual dispatching time. + // Average can be computed using recorded_total_delay_millis / recorded_delay_message_count. + optional int64 recorded_total_delay_millis = 14; + + // Max dispatching delay of all processed messages. + // Calculated as a difference between the target dispatching time (Message.when) + // and the actual dispatching time. + optional int64 recorded_max_delay_millis = 15; } /** @@ -2691,11 +2715,288 @@ message NumFingerprints { optional int32 num_fingerprints = 2; } +message AggStats { + optional int64 min = 1; + + optional int64 average = 2; + + optional int64 max = 3; +} + +message ProcessStatsStateProto { + optional android.service.procstats.ScreenState screen_state = 1; + + optional android.service.procstats.MemoryState memory_state = 2; + + // this enum list is from frameworks/base/core/java/com/android/internal/app/procstats/ProcessStats.java + // and not frameworks/base/core/java/android/app/ActivityManager.java + optional android.service.procstats.ProcessState process_state = 3; + + // Millisecond uptime duration spent in this state + optional int64 duration_ms = 4; + + // Millisecond elapsed realtime duration spent in this state + optional int64 realtime_duration_ms = 9; + + // # of samples taken + optional int32 sample_size = 5; + + // PSS is memory reserved for this process + optional AggStats pss = 6; + + // USS is memory shared between processes, divided evenly for accounting + optional AggStats uss = 7; + + // RSS is memory resident for this process + optional AggStats rss = 8; +} + +// Next Tag: 7 +message ProcessStatsProto { + // Name of process. + optional string process = 1; + + // Uid of the process. + optional int32 uid = 2; + + // Information about how often kills occurred + message Kill { + // Count of excessive CPU kills + optional int32 cpu = 1; + + // Count of kills when cached + optional int32 cached = 2; + + // PSS stats during cached kill + optional AggStats cached_pss = 3; + } + optional Kill kill = 3; + + // Time and memory spent in various states. + repeated ProcessStatsStateProto states = 5; + + // Total time process has been running... screen_state, memory_state, and process_state + // will not be set. + optional ProcessStatsStateProto total_running_state = 6; +} + +message PackageServiceOperationStatsProto { + // Operate enum: Started, Foreground, Bound, Executing + optional android.service.procstats.ServiceOperationState operation = 1; + + // Number of times the service was in this operation. + optional int32 count = 2; + + // Information about a state the service can be in. + message StateStats { + // Screen state enum. + optional android.service.procstats.ScreenState screen_state = 1; + // Memory state enum. + optional android.service.procstats.MemoryState memory_state = 2; + + // duration in milliseconds. + optional int64 duration_ms = 3; + // Millisecond elapsed realtime duration spent in this state + optional int64 realtime_duration_ms = 4; + } + repeated StateStats state_stats = 3; +} + +message PackageServiceStatsProto { + // Name of service component. + optional string service_name = 1; + + // The operation stats. + // The package_name, package_uid, package_version, service_name will not be set to save space. + repeated PackageServiceOperationStatsProto operation_stats = 2; +} + +message PackageAssociationSourceProcessStatsProto { + // Uid of the process. + optional int32 process_uid = 1; + // Process name. + optional string process_name = 2; + + // Total count of the times this association appeared. + optional int32 total_count = 3; + + // Millisecond uptime total duration this association was around. + optional int64 total_duration_ms = 4; + + // Total count of the times this association became actively impacting its target process. + optional int32 active_count = 5; + + // Information on one source in this association. + message StateStats { + // Process state enum. + optional android.service.procstats.ProcessState process_state = 1; + // Millisecond uptime duration spent in this state + optional int64 duration_ms = 2; + // Millisecond elapsed realtime duration spent in this state + optional int64 realtime_duration_ms = 3; + } + repeated StateStats active_state_stats = 6; +} + +message PackageAssociationProcessStatsProto { + // Name of the target component. + optional string component_name = 1; + // Information on one source in this association. + repeated PackageAssociationSourceProcessStatsProto sources = 2; +} + + +message ProcessStatsPackageProto { + // Name of package. + optional string package = 1; + + // Uid of the package. + optional int32 uid = 2; + + // Version of the package. + optional int64 version = 3; + + // Stats for each process running with the package loaded in to it. + repeated ProcessStatsProto process_stats = 4; + + // Stats for each of the package's services. + repeated PackageServiceStatsProto service_stats = 5; + + // Stats for each association with the package. + repeated PackageAssociationProcessStatsProto association_stats = 6; +} + +message ProcessStatsSectionProto { + // Elapsed realtime at start of report. + optional int64 start_realtime_ms = 1; + + // Elapsed realtime at end of report. + optional int64 end_realtime_ms = 2; + + // CPU uptime at start of report. + optional int64 start_uptime_ms = 3; + + // CPU uptime at end of report. + optional int64 end_uptime_ms = 4; + + // System runtime library. e.g. "libdvm.so", "libart.so". + optional string runtime = 5; + + // whether kernel reports swapped pss. + optional bool has_swapped_pss = 6; + + // Data completeness. e.g. "complete", "partial", shutdown", or "sysprops". + enum Status { + STATUS_UNKNOWN = 0; + STATUS_COMPLETE = 1; + STATUS_PARTIAL = 2; + STATUS_SHUTDOWN = 3; + STATUS_SYSPROPS = 4; + } + repeated Status status = 7; + + // Stats for each process. + repeated ProcessStatsProto process_stats = 8; + + // Stats for each package. + repeated ProcessStatsPackageProto package_stats = 9; +} + /** * Pulled from ProcessStatsService.java */ message ProcStats { - optional android.service.procstats.ProcessStatsSectionProto proc_stats_section = 1; + optional ProcessStatsSectionProto proc_stats_section = 1; +} + +message PowerProfileProto { + optional double cpu_suspend = 1; + + optional double cpu_idle = 2; + + optional double cpu_active = 3; + + message CpuCluster { + optional int32 id = 1; + optional double cluster_power = 2; + optional int32 cores = 3; + repeated int64 speed = 4; + repeated double core_power = 5; + } + + repeated CpuCluster cpu_cluster = 40; + + optional double wifi_scan = 4; + + optional double wifi_on = 5; + + optional double wifi_active = 6; + + optional double wifi_controller_idle = 7; + + optional double wifi_controller_rx = 8; + + optional double wifi_controller_tx = 9; + + repeated double wifi_controller_tx_levels = 10; + + optional double wifi_controller_operating_voltage = 11; + + optional double bluetooth_controller_idle = 12; + + optional double bluetooth_controller_rx = 13; + + optional double bluetooth_controller_tx = 14; + + optional double bluetooth_controller_operating_voltage = 15; + + optional double modem_controller_sleep = 16; + + optional double modem_controller_idle = 17; + + optional double modem_controller_rx = 18; + + repeated double modem_controller_tx = 19; + + optional double modem_controller_operating_voltage = 20; + + optional double gps_on = 21; + + repeated double gps_signal_quality_based = 22; + + optional double gps_operating_voltage = 23; + + optional double bluetooth_on = 24; + + optional double bluetooth_active = 25; + + optional double bluetooth_at_cmd = 26; + + optional double ambient_display = 27; + + optional double screen_on = 28; + + optional double radio_on = 29; + + optional double radio_scanning = 30; + + optional double radio_active = 31; + + optional double screen_full = 32; + + optional double audio = 33; + + optional double video = 34; + + optional double flashlight = 35; + + optional double memory = 36; + + optional double camera = 37; + + optional double wifi_batched_scan = 38; + + optional double battery_capacity = 39; } /** @@ -2703,5 +3004,5 @@ message ProcStats { * Pulled from PowerProfile.java */ message PowerProfile { - optional com.android.internal.os.PowerProfileProto power_profile_proto = 1; -}
\ No newline at end of file + optional PowerProfileProto power_profile = 1; +} diff --git a/cmds/statsd/src/hash.cpp b/cmds/statsd/src/hash.cpp index c501c9f818b9..543a748adedb 100644 --- a/cmds/statsd/src/hash.cpp +++ b/cmds/statsd/src/hash.cpp @@ -16,6 +16,10 @@ #include "hash.h" +#ifndef FALLTHROUGH_INTENDED +#define FALLTHROUGH_INTENDED [[fallthrough]] +#endif + namespace android { namespace os { namespace statsd { @@ -67,8 +71,10 @@ uint32_t Hash32(const char *data, size_t n, uint32_t seed) { switch (n) { case 3: h ^= ByteAs32(data[2]) << 16; + FALLTHROUGH_INTENDED; case 2: h ^= ByteAs32(data[1]) << 8; + FALLTHROUGH_INTENDED; case 1: h ^= ByteAs32(data[0]); h *= m; @@ -104,16 +110,22 @@ uint64_t Hash64(const char* data, size_t n, uint64_t seed) { switch (n) { case 7: h ^= ByteAs64(data[6]) << 48; + FALLTHROUGH_INTENDED; case 6: h ^= ByteAs64(data[5]) << 40; + FALLTHROUGH_INTENDED; case 5: h ^= ByteAs64(data[4]) << 32; + FALLTHROUGH_INTENDED; case 4: h ^= ByteAs64(data[3]) << 24; + FALLTHROUGH_INTENDED; case 3: h ^= ByteAs64(data[2]) << 16; + FALLTHROUGH_INTENDED; case 2: h ^= ByteAs64(data[1]) << 8; + FALLTHROUGH_INTENDED; case 1: h ^= ByteAs64(data[0]); h *= m; diff --git a/cmds/statsd/src/main.cpp b/cmds/statsd/src/main.cpp index a5dac0836238..6b8c12a893e8 100644 --- a/cmds/statsd/src/main.cpp +++ b/cmds/statsd/src/main.cpp @@ -46,6 +46,27 @@ struct log_reader_thread_data { sp<StatsService> service; }; + +sp<StatsService> gStatsService = nullptr; + +void sigHandler(int sig) { + if (gStatsService != nullptr) { + gStatsService->Terminate(); + } +} + +void registerSigHandler() +{ + struct sigaction sa; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + sa.sa_handler = sigHandler; + sigaction(SIGHUP, &sa, nullptr); + sigaction(SIGINT, &sa, nullptr); + sigaction(SIGQUIT, &sa, nullptr); + sigaction(SIGTERM, &sa, nullptr); +} + int main(int /*argc*/, char** /*argv*/) { // Set up the looper sp<Looper> looper(Looper::prepare(0 /* opts */)); @@ -60,23 +81,25 @@ int main(int /*argc*/, char** /*argv*/) { ::android::hardware::configureRpcThreadpool(1 /*threads*/, false /*willJoin*/); // Create the service - sp<StatsService> service = new StatsService(looper); - if (defaultServiceManager()->addService(String16("stats"), service) != 0) { + gStatsService = new StatsService(looper); + if (defaultServiceManager()->addService(String16("stats"), gStatsService) != 0) { ALOGE("Failed to add service as AIDL service"); return -1; } - auto ret = service->registerAsService(); + auto ret = gStatsService->registerAsService(); if (ret != ::android::OK) { ALOGE("Failed to add service as HIDL service"); return 1; // or handle error } - service->sayHiToStatsCompanion(); + registerSigHandler(); + + gStatsService->sayHiToStatsCompanion(); - service->Startup(); + gStatsService->Startup(); - sp<StatsSocketListener> socketListener = new StatsSocketListener(service); + sp<StatsSocketListener> socketListener = new StatsSocketListener(gStatsService); ALOGI("using statsd socket"); // Backlog and /proc/sys/net/unix/max_dgram_qlen set to large value diff --git a/cmds/statsd/src/stats_log.proto b/cmds/statsd/src/stats_log.proto index ab0b23cc009d..10ed7f3ebaa1 100644 --- a/cmds/statsd/src/stats_log.proto +++ b/cmds/statsd/src/stats_log.proto @@ -271,6 +271,7 @@ message ConfigMetricsReport { ADB_DUMP = 5; CONFIG_RESET = 6; STATSCOMPANION_DIED = 7; + TERMINATION_SIGNAL_RECEIVED = 8; } optional DumpReportReason dump_report_reason = 8; diff --git a/core/java/android/app/AppDetailsActivity.java b/core/java/android/app/AppDetailsActivity.java new file mode 100644 index 000000000000..cd36e634f54b --- /dev/null +++ b/core/java/android/app/AppDetailsActivity.java @@ -0,0 +1,36 @@ +/* + * Copyright 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.app; + +import android.content.Intent; +import android.os.Bundle; + +/** + * Helper activity that forwards you to app details page. + * + * @hide + */ +public class AppDetailsActivity extends Activity { + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + Intent intent = new Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS); + intent.setData(android.net.Uri.fromParts("package", getPackageName(), null)); + startActivity(intent); + finish(); + } +} diff --git a/core/java/android/app/backup/BackupAgent.java b/core/java/android/app/backup/BackupAgent.java index df27d583d361..c983d4f68710 100644 --- a/core/java/android/app/backup/BackupAgent.java +++ b/core/java/android/app/backup/BackupAgent.java @@ -29,6 +29,7 @@ import android.os.Looper; import android.os.ParcelFileDescriptor; import android.os.Process; import android.os.RemoteException; +import android.os.UserHandle; import android.system.ErrnoException; import android.system.Os; import android.system.OsConstants; @@ -222,6 +223,18 @@ public abstract class BackupAgent extends ContextWrapper { } /** + * Provided as a convenience for agent implementations that need an opportunity + * to do one-time initialization before the actual backup or restore operation + * is begun with information about the calling user. + * <p> + * + * @hide + */ + public void onCreate(UserHandle user) { + onCreate(); + } + + /** * Provided as a convenience for agent implementations that need to do some * sort of shutdown process after backup or restore is completed. * <p> diff --git a/core/java/android/bluetooth/BluetoothDevice.java b/core/java/android/bluetooth/BluetoothDevice.java index b8e7e3044ca4..0aa053580a6d 100644 --- a/core/java/android/bluetooth/BluetoothDevice.java +++ b/core/java/android/bluetooth/BluetoothDevice.java @@ -107,20 +107,6 @@ public final class BluetoothDevice implements Parcelable { "android.bluetooth.device.action.FOUND"; /** - * Broadcast Action: Remote device disappeared. - * <p>Sent when a remote device that was found in the last discovery is not - * found in the current discovery. - * <p>Always contains the extra field {@link #EXTRA_DEVICE}. - * <p>Requires {@link android.Manifest.permission#BLUETOOTH} to receive. - * - * @hide - */ - @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) - @UnsupportedAppUsage - public static final String ACTION_DISAPPEARED = - "android.bluetooth.device.action.DISAPPEARED"; - - /** * Broadcast Action: Bluetooth class of a remote device has changed. * <p>Always contains the extra fields {@link #EXTRA_DEVICE} and {@link * #EXTRA_CLASS}. diff --git a/core/java/android/content/Intent.java b/core/java/android/content/Intent.java index ca96d5026247..8913748e0c48 100644 --- a/core/java/android/content/Intent.java +++ b/core/java/android/content/Intent.java @@ -3955,6 +3955,12 @@ public class Intent implements Parcelable, Cloneable { public static final String EXTRA_LTE_EARFCN_RSRP_BOOST = "LteEarfcnRsrpBoost"; /** + * An parcelable extra used with {@link #ACTION_SERVICE_STATE} representing the service state. + * @hide + */ + public static final String EXTRA_SERVICE_STATE = "android.intent.extra.SERVICE_STATE"; + + /** * The name of the extra used to define the text to be processed, as a * CharSequence. Note that this may be a styled CharSequence, so you must use * {@link Bundle#getCharSequence(String) Bundle.getCharSequence()} to retrieve it. diff --git a/core/java/android/content/pm/ActivityInfo.java b/core/java/android/content/pm/ActivityInfo.java index 5926af6f9082..0a4f4eb8506c 100644 --- a/core/java/android/content/pm/ActivityInfo.java +++ b/core/java/android/content/pm/ActivityInfo.java @@ -1408,5 +1408,13 @@ public class ActivityInfo extends ComponentInfo implements Parcelable { * @attr ref android.R.styleable#AndroidManifestLayout_minHeight */ public final int minHeight; + + /** + * Returns if this {@link WindowLayout} has specified bounds. + * @hide + */ + public boolean hasSpecifiedSize() { + return width >= 0 || height >= 0 || widthFraction >= 0 || heightFraction >= 0; + } } } diff --git a/core/java/android/content/pm/PackageManagerInternal.java b/core/java/android/content/pm/PackageManagerInternal.java index b5b4432bbdb2..7b4c6fc64a69 100644 --- a/core/java/android/content/pm/PackageManagerInternal.java +++ b/core/java/android/content/pm/PackageManagerInternal.java @@ -19,6 +19,7 @@ package android.content.pm; import android.annotation.IntDef; import android.annotation.NonNull; import android.annotation.Nullable; +import android.annotation.UserIdInt; import android.content.ComponentName; import android.content.Intent; import android.content.pm.PackageManager.ApplicationInfoFlags; @@ -205,6 +206,29 @@ public abstract class PackageManagerInternal { @PackageInfoFlags int flags, int filterCallingUid, int userId); /** + * Return a List of all application packages that are installed on the + * device, for a specific user. If flag GET_UNINSTALLED_PACKAGES has been + * set, a list of all applications including those deleted with + * {@code DONT_DELETE_DATA} (partially installed apps with data directory) + * will be returned. + * + * @param flags Additional option flags to modify the data returned. + * @param userId The user for whom the installed applications are to be + * listed + * @param callingUid The uid of the original caller app + * @return A List of ApplicationInfo objects, one for each installed + * application. In the unlikely case there are no installed + * packages, an empty list is returned. If flag + * {@code MATCH_UNINSTALLED_PACKAGES} is set, the application + * information is retrieved from the list of uninstalled + * applications (which includes installed applications as well as + * applications with data directory i.e. applications which had been + * deleted with {@code DONT_DELETE_DATA} flag set). + */ + public abstract List<ApplicationInfo> getInstalledApplications( + @ApplicationInfoFlags int flags, @UserIdInt int userId, int callingUid); + + /** * Retrieve launcher extras for a suspended package provided to the system in * {@link PackageManager#setPackagesSuspended(String[], boolean, PersistableBundle, * PersistableBundle, String)}. diff --git a/core/java/android/content/pm/PackageParser.java b/core/java/android/content/pm/PackageParser.java index 24675d301f4a..046e9e7108fd 100644 --- a/core/java/android/content/pm/PackageParser.java +++ b/core/java/android/content/pm/PackageParser.java @@ -47,6 +47,7 @@ import android.annotation.Nullable; import android.annotation.TestApi; import android.annotation.UnsupportedAppUsage; import android.app.ActivityTaskManager; +import android.app.AppDetailsActivity; import android.content.ComponentName; import android.content.Intent; import android.content.IntentFilter; @@ -2440,17 +2441,17 @@ public class PackageParser { } - final int NS = PermissionManager.SPLIT_PERMISSIONS.length; + final int NS = PermissionManager.SPLIT_PERMISSIONS.size(); for (int is=0; is<NS; is++) { final PermissionManager.SplitPermissionInfo spi = - PermissionManager.SPLIT_PERMISSIONS[is]; + PermissionManager.SPLIT_PERMISSIONS.get(is); if (pkg.applicationInfo.targetSdkVersion >= spi.getTargetSdk() - || !pkg.requestedPermissions.contains(spi.getRootPermission())) { + || !pkg.requestedPermissions.contains(spi.getSplitPermission())) { continue; } - final String[] newPerms = spi.getNewPermissions(); - for (int in = 0; in < newPerms.length; in++) { - final String perm = newPerms[in]; + final List<String> newPerms = spi.getNewPermissions(); + for (int in = 0; in < newPerms.size(); in++) { + final String perm = newPerms.get(in); if (!pkg.requestedPermissions.contains(perm)) { pkg.requestedPermissions.add(perm); } @@ -3882,6 +3883,11 @@ public class PackageParser { } } + // Add a hidden app detail activity which forwards user to App Details page. + Activity a = generateAppDetailsHiddenActivity(owner, flags, outError, + owner.baseHardwareAccelerated); + owner.activities.add(a); + if (hasActivityOrder) { Collections.sort(owner.activities, (a1, a2) -> Integer.compare(a2.order, a1.order)); } @@ -4121,9 +4127,14 @@ public class PackageParser { return false; } } else { - outInfo.name + String outInfoName = buildClassName(owner.applicationInfo.packageName, name, outError); - if (outInfo.name == null) { + if (AppDetailsActivity.class.getName().equals(outInfoName)) { + outError[0] = tag + " invalid android:name"; + return false; + } + outInfo.name = outInfoName; + if (outInfoName == null) { return false; } } @@ -4162,6 +4173,45 @@ public class PackageParser { return true; } + /** + * Generate activity object that forwards user to App Details page automatically. + * This activity should be invisible to user and user should not know or see it. + */ + private @NonNull PackageParser.Activity generateAppDetailsHiddenActivity( + PackageParser.Package owner, int flags, String[] outError, + boolean hardwareAccelerated) { + + // Build custom App Details activity info instead of parsing it from xml + Activity a = new Activity(owner, AppDetailsActivity.class.getName(), new ActivityInfo()); + a.owner = owner; + a.setPackageName(owner.packageName); + + a.info.theme = 0; + a.info.exported = true; + a.info.name = AppDetailsActivity.class.getName(); + a.info.processName = owner.applicationInfo.processName; + a.info.uiOptions = a.info.applicationInfo.uiOptions; + a.info.taskAffinity = buildTaskAffinityName(owner.packageName, owner.packageName, + ":app_details", outError); + a.info.enabled = true; + a.info.launchMode = ActivityInfo.LAUNCH_MULTIPLE; + a.info.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NONE; + a.info.maxRecents = ActivityTaskManager.getDefaultAppRecentsLimitStatic(); + a.info.configChanges = getActivityConfigChanges(0, 0); + a.info.softInputMode = 0; + a.info.persistableMode = ActivityInfo.PERSIST_NEVER; + a.info.screenOrientation = SCREEN_ORIENTATION_UNSPECIFIED; + a.info.resizeMode = RESIZE_MODE_FORCE_RESIZEABLE; + a.info.lockTaskLaunchMode = 0; + a.info.encryptionAware = a.info.directBootAware = false; + a.info.rotationAnimation = ROTATION_ANIMATION_UNSPECIFIED; + a.info.colorMode = ActivityInfo.COLOR_MODE_DEFAULT; + if (hardwareAccelerated) { + a.info.flags |= ActivityInfo.FLAG_HARDWARE_ACCELERATED; + } + return a; + } + private Activity parseActivity(Package owner, Resources res, XmlResourceParser parser, int flags, String[] outError, CachedComponentArgs cachedArgs, boolean receiver, boolean hardwareAccelerated) @@ -7132,10 +7182,16 @@ public class PackageParser { ComponentName componentName; String componentShortName; - public Component(Package _owner) { - owner = _owner; - intents = null; - className = null; + public Component(Package owner, ArrayList<II> intents, String className) { + this.owner = owner; + this.intents = intents; + this.className = className; + } + + public Component(Package owner) { + this.owner = owner; + this.intents = null; + this.className = null; } public Component(final ParsePackageItemArgs args, final PackageItemInfo outInfo) { @@ -7600,6 +7656,13 @@ public class PackageParser { return mHasMaxAspectRatio; } + // To construct custom activity which does not exist in manifest + Activity(final Package owner, final String className, final ActivityInfo info) { + super(owner, new ArrayList<>(0), className); + this.info = info; + this.info.applicationInfo = owner.applicationInfo; + } + public Activity(final ParseComponentArgs args, final ActivityInfo _info) { super(args, _info); info = _info; diff --git a/core/java/android/hardware/location/ContextHubClient.java b/core/java/android/hardware/location/ContextHubClient.java index 917644db4202..6609b76faac1 100644 --- a/core/java/android/hardware/location/ContextHubClient.java +++ b/core/java/android/hardware/location/ContextHubClient.java @@ -133,6 +133,7 @@ public class ContextHubClient implements Closeable { * * @hide */ + @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public boolean registerIntent(@NonNull PendingIntent intent, long nanoAppId) { // TODO: Implement this return false; @@ -146,6 +147,7 @@ public class ContextHubClient implements Closeable { * * @hide */ + @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) public boolean unregisterIntent(@NonNull PendingIntent intent) { // TODO: Implement this return false; diff --git a/core/java/android/hardware/location/ContextHubManager.java b/core/java/android/hardware/location/ContextHubManager.java index 36f3586aec2a..f94d69b7fa2d 100644 --- a/core/java/android/hardware/location/ContextHubManager.java +++ b/core/java/android/hardware/location/ContextHubManager.java @@ -749,6 +749,7 @@ public final class ContextHubManager { * * @see ContextHubClientCallback */ + @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) @NonNull public ContextHubClient createClient( @NonNull ContextHubInfo hubInfo, @NonNull ContextHubClientCallback callback, @NonNull @CallbackExecutor Executor executor) { @@ -785,6 +786,7 @@ public final class ContextHubManager { * * @see ContextHubClientCallback */ + @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) @NonNull public ContextHubClient createClient( @NonNull ContextHubInfo hubInfo, @NonNull ContextHubClientCallback callback) { return createClient(hubInfo, callback, new HandlerExecutor(Handler.getMain())); @@ -811,6 +813,7 @@ public final class ContextHubManager { * * @hide */ + @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) @NonNull public ContextHubClient createClient( @NonNull PendingIntent intent, @NonNull ContextHubInfo hubInfo, @NonNull ContextHubClientCallback callback, @@ -835,6 +838,7 @@ public final class ContextHubManager { * * @hide */ + @RequiresPermission(android.Manifest.permission.LOCATION_HARDWARE) @NonNull public ContextHubClient createClient( @NonNull PendingIntent intent, @NonNull ContextHubInfo hubInfo, @NonNull ContextHubClientCallback callback) { diff --git a/core/java/android/net/ConnectivityManager.java b/core/java/android/net/ConnectivityManager.java index c496ff4a3bd5..1fbfa40d5d64 100644 --- a/core/java/android/net/ConnectivityManager.java +++ b/core/java/android/net/ConnectivityManager.java @@ -2731,7 +2731,10 @@ public class ConnectivityManager { * * @hide */ - @RequiresPermission(android.Manifest.permission.CONNECTIVITY_INTERNAL) + @RequiresPermission(anyOf = { + android.Manifest.permission.NETWORK_SETTINGS, + android.Manifest.permission.NETWORK_SETUP_WIZARD, + android.Manifest.permission.NETWORK_STACK}) @SystemApi public void setAirplaneMode(boolean enable) { try { diff --git a/core/java/android/os/DumpstateOptions.java b/core/java/android/os/DumpstateOptions.java new file mode 100644 index 000000000000..53037b2499cd --- /dev/null +++ b/core/java/android/os/DumpstateOptions.java @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.os; + +/** + * Options passed to dumpstate service. + * + * @hide + */ +public final class DumpstateOptions implements Parcelable { + // If true the caller can get callbacks with per-section + // progress details. + private final boolean mGetSectionDetails; + // Name of the caller. + private final String mName; + + public DumpstateOptions(Parcel in) { + mGetSectionDetails = in.readBoolean(); + mName = in.readString(); + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel out, int flags) { + out.writeBoolean(mGetSectionDetails); + out.writeString(mName); + } + + public static final Parcelable.Creator<DumpstateOptions> CREATOR = + new Parcelable.Creator<DumpstateOptions>() { + public DumpstateOptions createFromParcel(Parcel in) { + return new DumpstateOptions(in); + } + + public DumpstateOptions[] newArray(int size) { + return new DumpstateOptions[size]; + } + }; +} diff --git a/core/java/android/os/GraphicsEnvironment.java b/core/java/android/os/GraphicsEnvironment.java index df3aae2c901c..5f656207255a 100644 --- a/core/java/android/os/GraphicsEnvironment.java +++ b/core/java/android/os/GraphicsEnvironment.java @@ -55,7 +55,7 @@ public class GraphicsEnvironment { * Set up GraphicsEnvironment */ public void setup(Context context, Bundle coreSettings) { - setupGpuLayers(context, coreSettings); + setupGpuLayers(context); setupAngle(context, coreSettings); chooseDriver(context); } @@ -81,54 +81,27 @@ public class GraphicsEnvironment { } /** - * Return the debug layer app's on-disk and in-APK lib directories - */ - private static String getDebugLayerAppPaths(Context context, String app) { - ApplicationInfo appInfo; - try { - appInfo = context.getPackageManager().getApplicationInfo( - app, PackageManager.MATCH_ALL); - } catch (PackageManager.NameNotFoundException e) { - Log.w(TAG, "Debug layer app '" + app + "' not installed"); - - return null; - } - - String abi = chooseAbi(appInfo); - - StringBuilder sb = new StringBuilder(); - sb.append(appInfo.nativeLibraryDir) - .append(File.pathSeparator); - sb.append(appInfo.sourceDir) - .append("!/lib/") - .append(abi); - String paths = sb.toString(); - - if (DEBUG) Log.v(TAG, "Debug layer app libs: " + paths); - - return paths; - } - - /** * Set up layer search paths for all apps * If debuggable, check for additional debug settings */ - private void setupGpuLayers(Context context, Bundle coreSettings) { + private void setupGpuLayers(Context context) { String layerPaths = ""; // Only enable additional debug functionality if the following conditions are met: - // 1. App is debuggable or device is rooted + // 1. App is debuggable // 2. ENABLE_GPU_DEBUG_LAYERS is true // 3. Package name is equal to GPU_DEBUG_APP - if (isDebuggable(context) || (getCanLoadSystemLibraries() == 1)) { + if (isDebuggable(context)) { - int enable = coreSettings.getInt(Settings.Global.ENABLE_GPU_DEBUG_LAYERS, 0); + int enable = Settings.Global.getInt(context.getContentResolver(), + Settings.Global.ENABLE_GPU_DEBUG_LAYERS, 0); if (enable != 0) { - String gpuDebugApp = coreSettings.getString(Settings.Global.GPU_DEBUG_APP); + String gpuDebugApp = Settings.Global.getString(context.getContentResolver(), + Settings.Global.GPU_DEBUG_APP); String packageName = context.getPackageName(); @@ -142,22 +115,8 @@ public class GraphicsEnvironment { // the layers specified by the app. layerPaths = mDebugLayerPath + ":"; - - // If there is a debug layer app specified, add its path. - String gpuDebugLayerApp = - coreSettings.getString(Settings.Global.GPU_DEBUG_LAYER_APP); - - if (gpuDebugLayerApp != null && !gpuDebugLayerApp.isEmpty()) { - Log.i(TAG, "GPU debug layer app: " + gpuDebugLayerApp); - String paths = getDebugLayerAppPaths(context, gpuDebugLayerApp); - if (paths != null) { - // Append the path so files placed in the app's base directory will - // override the external path - layerPaths += paths + ":"; - } - } - - String layers = coreSettings.getString(Settings.Global.GPU_DEBUG_LAYERS); + String layers = Settings.Global.getString(context.getContentResolver(), + Settings.Global.GPU_DEBUG_LAYERS); Log.i(TAG, "Debug layer list: " + layers); if (layers != null && !layers.isEmpty()) { @@ -331,7 +290,6 @@ public class GraphicsEnvironment { return null; } - private static native int getCanLoadSystemLibraries(); private static native void setLayerPaths(ClassLoader classLoader, String layerPaths); private static native void setDebugLayers(String layers); private static native void setDriverPath(String path); diff --git a/core/java/android/os/UserManager.java b/core/java/android/os/UserManager.java index 8123744281f4..7ea20082e660 100644 --- a/core/java/android/os/UserManager.java +++ b/core/java/android/os/UserManager.java @@ -2363,7 +2363,6 @@ public class UserManager { */ @RequiresPermission(anyOf = {Manifest.permission.MANAGE_USERS, Manifest.permission.CREATE_USERS}, conditional = true) - @SystemApi public @NonNull int[] getProfileIds(@UserIdInt int userId, boolean enabledOnly) { try { return mService.getProfileIds(userId, enabledOnly); diff --git a/core/java/android/permission/PermissionManager.java b/core/java/android/permission/PermissionManager.java index aa44eb7e3a26..7ffb22f189b8 100644 --- a/core/java/android/permission/PermissionManager.java +++ b/core/java/android/permission/PermissionManager.java @@ -25,7 +25,9 @@ import android.content.Context; import com.android.internal.annotations.Immutable; import java.util.Arrays; +import java.util.Collections; import java.util.List; +import java.util.Objects; /** * System level service for accessing the permission capabilities of the platform. @@ -40,26 +42,28 @@ public final class PermissionManager { * * @hide */ - public static final SplitPermissionInfo[] SPLIT_PERMISSIONS = new SplitPermissionInfo[]{ + public static final List<SplitPermissionInfo> SPLIT_PERMISSIONS = Arrays.asList( // READ_EXTERNAL_STORAGE is always required when an app requests // WRITE_EXTERNAL_STORAGE, because we can't have an app that has // write access without read access. The hack here with the target // target SDK version ensures that this grant is always done. new SplitPermissionInfo(android.Manifest.permission.WRITE_EXTERNAL_STORAGE, - new String[]{android.Manifest.permission.READ_EXTERNAL_STORAGE}, + Collections.singletonList(android.Manifest.permission.READ_EXTERNAL_STORAGE), android.os.Build.VERSION_CODES.CUR_DEVELOPMENT + 1), new SplitPermissionInfo(android.Manifest.permission.READ_CONTACTS, - new String[]{android.Manifest.permission.READ_CALL_LOG}, + Collections.singletonList(android.Manifest.permission.READ_CALL_LOG), android.os.Build.VERSION_CODES.JELLY_BEAN), new SplitPermissionInfo(android.Manifest.permission.WRITE_CONTACTS, - new String[]{android.Manifest.permission.WRITE_CALL_LOG}, + Collections.singletonList(android.Manifest.permission.WRITE_CALL_LOG), android.os.Build.VERSION_CODES.JELLY_BEAN), new SplitPermissionInfo(Manifest.permission.ACCESS_FINE_LOCATION, - new String[]{android.Manifest.permission.ACCESS_BACKGROUND_LOCATION}, + Collections.singletonList( + android.Manifest.permission.ACCESS_BACKGROUND_LOCATION), android.os.Build.VERSION_CODES.P0), new SplitPermissionInfo(Manifest.permission.ACCESS_COARSE_LOCATION, - new String[]{android.Manifest.permission.ACCESS_BACKGROUND_LOCATION}, - android.os.Build.VERSION_CODES.P0)}; + Collections.singletonList( + android.Manifest.permission.ACCESS_BACKGROUND_LOCATION), + android.os.Build.VERSION_CODES.P0)); private final @NonNull Context mContext; @@ -74,7 +78,7 @@ public final class PermissionManager { } /** - * Get list of permissions that have been split into more granular or dependent permissions. + * Get set of permissions that have been split into more granular or dependent permissions. * * <p>E.g. before {@link android.os.Build.VERSION_CODES#P0} an app that was granted * {@link Manifest.permission#ACCESS_COARSE_LOCATION} could access he location while it was in @@ -82,7 +86,7 @@ public final class PermissionManager { * the location permission only grants location access while the app is in foreground. This * would break apps that target before {@link android.os.Build.VERSION_CODES#P0}. Hence whenever * such an old app asks for a location permission (i.e. the - * {@link SplitPermissionInfo#getRootPermission()}), then the + * {@link SplitPermissionInfo#getSplitPermission()}), then the * {@link Manifest.permission#ACCESS_BACKGROUND_LOCATION} permission (inside * {@{@link SplitPermissionInfo#getNewPermissions}) is added. * @@ -91,8 +95,9 @@ public final class PermissionManager { * * @return All permissions that are split. */ - public @NonNull List<SplitPermissionInfo> getSplitPermissions() { - return Arrays.asList(SPLIT_PERMISSIONS); + public @NonNull + List<SplitPermissionInfo> getSplitPermissions() { + return SPLIT_PERMISSIONS; } /** @@ -101,21 +106,35 @@ public final class PermissionManager { */ @Immutable public static final class SplitPermissionInfo { - private final @NonNull String mRootPerm; - private final @NonNull String[] mNewPerms; + private final @NonNull String mSplitPerm; + private final @NonNull List<String> mNewPerms; private final int mTargetSdk; + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + SplitPermissionInfo that = (SplitPermissionInfo) o; + return mTargetSdk == that.mTargetSdk + && Objects.equals(mSplitPerm, that.mSplitPerm); + } + + @Override + public int hashCode() { + return Objects.hash(mSplitPerm, mTargetSdk); + } + /** * Get the permission that is split. */ - public @NonNull String getRootPermission() { - return mRootPerm; + public @NonNull String getSplitPermission() { + return mSplitPerm; } /** * Get the permissions that are added. */ - public @NonNull String[] getNewPermissions() { + public @NonNull List<String> getNewPermissions() { return mNewPerms; } @@ -126,9 +145,9 @@ public final class PermissionManager { return mTargetSdk; } - private SplitPermissionInfo(@NonNull String rootPerm, @NonNull String[] newPerms, + private SplitPermissionInfo(@NonNull String rootPerm, @NonNull List<String> newPerms, int targetSdk) { - mRootPerm = rootPerm; + mSplitPerm = rootPerm; mNewPerms = newPerms; mTargetSdk = targetSdk; } diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java index c6e457436025..acb75778e08e 100644 --- a/core/java/android/provider/Settings.java +++ b/core/java/android/provider/Settings.java @@ -11631,12 +11631,6 @@ public final class Settings { public static final String GPU_DEBUG_LAYERS = "gpu_debug_layers"; /** - * Addition app for GPU layer discovery - * @hide - */ - public static final String GPU_DEBUG_LAYER_APP = "gpu_debug_layer_app"; - - /** * Control whether the process CPU usage meter should be shown. * * @deprecated This functionality is no longer available as of diff --git a/core/java/android/service/textclassifier/TextClassifierService.java b/core/java/android/service/textclassifier/TextClassifierService.java index b461c0daaca5..7af9db8ebf32 100644 --- a/core/java/android/service/textclassifier/TextClassifierService.java +++ b/core/java/android/service/textclassifier/TextClassifierService.java @@ -405,8 +405,8 @@ public abstract class TextClassifierService extends Service { PackageManager.MATCH_SYSTEM_ONLY); if ((ri == null) || (ri.serviceInfo == null)) { - Slog.w(LOG_TAG, String.format("Package or service not found in package %s", - packageName)); + Slog.w(LOG_TAG, String.format("Package or service not found in package %s for user %d", + packageName, context.getUserId())); return null; } final ServiceInfo si = ri.serviceInfo; diff --git a/core/java/android/text/style/TextAppearanceSpan.java b/core/java/android/text/style/TextAppearanceSpan.java index 2dc4f6001a06..648bd1bba20c 100644 --- a/core/java/android/text/style/TextAppearanceSpan.java +++ b/core/java/android/text/style/TextAppearanceSpan.java @@ -29,8 +29,33 @@ import android.text.TextPaint; import android.text.TextUtils; /** - * Sets the text color, size, style, and typeface to match a TextAppearance - * resource. + * Sets the text appearance using the given + * {@link android.R.styleable#TextAppearance TextAppearance} attributes. + * By default {@link TextAppearanceSpan} only changes the specified attributes in XML. + * {@link android.R.styleable#TextAppearance_textColorHighlight textColorHighlight}, + * {@link android.R.styleable#TextAppearance_textColorHint textColorHint}, + * {@link android.R.styleable#TextAppearance_textAllCaps textAllCaps} and + * {@link android.R.styleable#TextAppearance_fallbackLineSpacing fallbackLineSpacing} + * are not supported by {@link TextAppearanceSpan}. + * + * {@see android.widget.TextView#setTextAppearance(int)} + * + * @attr ref android.R.styleable#TextAppearance_fontFamily + * @attr ref android.R.styleable#TextAppearance_textColor + * @attr ref android.R.styleable#TextAppearance_textColorLink + * @attr ref android.R.styleable#TextAppearance_textFontWeight + * @attr ref android.R.styleable#TextAppearance_textSize + * @attr ref android.R.styleable#TextAppearance_textStyle + * @attr ref android.R.styleable#TextAppearance_typeface + * @attr ref android.R.styleable#TextAppearance_shadowColor + * @attr ref android.R.styleable#TextAppearance_shadowDx + * @attr ref android.R.styleable#TextAppearance_shadowDy + * @attr ref android.R.styleable#TextAppearance_shadowRadius + * @attr ref android.R.styleable#TextAppearance_elegantTextHeight + * @attr ref android.R.styleable#TextAppearance_letterSpacing + * @attr ref android.R.styleable#TextAppearance_fontFeatureSettings + * @attr ref android.R.styleable#TextAppearance_fontVariationSettings + * */ public class TextAppearanceSpan extends MetricAffectingSpan implements ParcelableSpan { private final String mFamilyName; diff --git a/core/java/android/transition/Visibility.java b/core/java/android/transition/Visibility.java index 319f080bbe63..bd2bef4f11ae 100644 --- a/core/java/android/transition/Visibility.java +++ b/core/java/android/transition/Visibility.java @@ -25,6 +25,7 @@ import android.content.res.TypedArray; import android.util.AttributeSet; import android.view.View; import android.view.ViewGroup; +import android.view.ViewGroupOverlay; import com.android.internal.R; @@ -413,7 +414,6 @@ public abstract class Visibility extends Transition { } } final int finalVisibility = endVisibility; - final ViewGroup finalSceneRoot = sceneRoot; if (overlayView != null) { // TODO: Need to do this for general case of adding to overlay @@ -424,16 +424,32 @@ public abstract class Visibility extends Transition { sceneRoot.getLocationOnScreen(loc); overlayView.offsetLeftAndRight((screenX - loc[0]) - overlayView.getLeft()); overlayView.offsetTopAndBottom((screenY - loc[1]) - overlayView.getTop()); - sceneRoot.getOverlay().add(overlayView); + final ViewGroupOverlay overlay = sceneRoot.getOverlay(); + overlay.add(overlayView); Animator animator = onDisappear(sceneRoot, overlayView, startValues, endValues); if (animator == null) { - sceneRoot.getOverlay().remove(overlayView); + overlay.remove(overlayView); } else { final View finalOverlayView = overlayView; addListener(new TransitionListenerAdapter() { + + @Override + public void onTransitionPause(Transition transition) { + overlay.remove(finalOverlayView); + } + + @Override + public void onTransitionResume(Transition transition) { + if (finalOverlayView.getParent() == null) { + overlay.add(finalOverlayView); + } else { + cancel(); + } + } + @Override public void onTransitionEnd(Transition transition) { - finalSceneRoot.getOverlay().remove(finalOverlayView); + overlay.remove(finalOverlayView); transition.removeListener(this); } }); diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java index c18187b21200..29d3742ba632 100644 --- a/core/java/android/view/View.java +++ b/core/java/android/view/View.java @@ -7315,17 +7315,16 @@ public class View implements Drawable.Callback, KeyEvent.Callback, // Here we check whether we still need the default focus highlight, and switch it on/off. switchDefaultFocusHighlight(); - InputMethodManager imm = getContext().getSystemService(InputMethodManager.class); if (!gainFocus) { if (isPressed()) { setPressed(false); } - if (imm != null && mAttachInfo != null && mAttachInfo.mHasWindowFocus) { - imm.focusOut(this); + if (mAttachInfo != null && mAttachInfo.mHasWindowFocus) { + notifyFocusChangeToInputMethodManager(false /* hasFocus */); } onFocusLost(); - } else if (imm != null && mAttachInfo != null && mAttachInfo.mHasWindowFocus) { - imm.focusIn(this); + } else if (mAttachInfo != null && mAttachInfo.mHasWindowFocus) { + notifyFocusChangeToInputMethodManager(true /* hasFocus */); } invalidate(true); @@ -7341,6 +7340,26 @@ public class View implements Drawable.Callback, KeyEvent.Callback, notifyEnterOrExitForAutoFillIfNeeded(gainFocus); } + /** + * Notify {@link InputMethodManager} about the focus change of the {@link View}. + * + * <p>Does nothing when {@link InputMethodManager} is not available.</p> + * + * @param hasFocus {@code true} when the {@link View} is being focused. + */ + private void notifyFocusChangeToInputMethodManager(boolean hasFocus) { + final InputMethodManager imm = + getContext().getSystemService(InputMethodManager.class); + if (imm == null) { + return; + } + if (hasFocus) { + imm.focusIn(this); + } else { + imm.focusOut(this); + } + } + /** @hide */ public void notifyEnterOrExitForAutoFillIfNeeded(boolean enter) { if (canNotifyAutofillEnterExitEvent()) { @@ -12485,7 +12504,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, mPrivateFlags3 &= ~PFLAG3_TEMPORARY_DETACH; onFinishTemporaryDetach(); if (hasWindowFocus() && hasFocus()) { - getContext().getSystemService(InputMethodManager.class).focusIn(this); + notifyFocusChangeToInputMethodManager(true /* hasFocus */); } notifyEnterOrExitForAutoFillIfNeeded(true); } @@ -12876,20 +12895,19 @@ public class View implements Drawable.Callback, KeyEvent.Callback, * focus, false otherwise. */ public void onWindowFocusChanged(boolean hasWindowFocus) { - InputMethodManager imm = getContext().getSystemService(InputMethodManager.class); if (!hasWindowFocus) { if (isPressed()) { setPressed(false); } mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN; - if (imm != null && (mPrivateFlags & PFLAG_FOCUSED) != 0) { - imm.focusOut(this); + if ((mPrivateFlags & PFLAG_FOCUSED) != 0) { + notifyFocusChangeToInputMethodManager(false /* hasFocus */); } removeLongPressCallback(); removeTapCallback(); onFocusLost(); - } else if (imm != null && (mPrivateFlags & PFLAG_FOCUSED) != 0) { - imm.focusIn(this); + } else if ((mPrivateFlags & PFLAG_FOCUSED) != 0) { + notifyFocusChangeToInputMethodManager(true /* hasFocus */); } refreshDrawableState(); @@ -17981,10 +17999,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, rebuildOutline(); if (isFocused()) { - InputMethodManager imm = getContext().getSystemService(InputMethodManager.class); - if (imm != null) { - imm.focusIn(this); - } + notifyFocusChangeToInputMethodManager(true /* hasFocus */); } } diff --git a/core/java/android/view/Window.java b/core/java/android/view/Window.java index 982737aedc74..c1e94d8ff97e 100644 --- a/core/java/android/view/Window.java +++ b/core/java/android/view/Window.java @@ -1085,6 +1085,19 @@ public abstract class Window { * * <p>Refer to the individual flags for the permissions needed. * + * @param flags The flag bits to add. + * + * @hide + */ + public void addPrivateFlags(int flags) { + setPrivateFlags(flags, flags); + } + + /** + * Add system flag bits. + * + * <p>Refer to the individual flags for the permissions needed. + * * <p>Note: Only for updateable system components (aka. mainline modules) * * @param flags The flag bits to add. @@ -1092,8 +1105,8 @@ public abstract class Window { * @hide */ @SystemApi - public void addPrivateFlags(int flags) { - setPrivateFlags(flags, flags); + public void addSystemFlags(@WindowManager.LayoutParams.SystemFlags int flags) { + addPrivateFlags(flags); } /** diff --git a/core/java/android/view/WindowManager.java b/core/java/android/view/WindowManager.java index 742df5e8a962..2d77cb4f3aca 100644 --- a/core/java/android/view/WindowManager.java +++ b/core/java/android/view/WindowManager.java @@ -1670,7 +1670,7 @@ public interface WindowManager extends ViewManager { */ @SystemApi @RequiresPermission(permission.HIDE_NON_SYSTEM_OVERLAY_WINDOWS) - public static final int PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS = 0x00080000; + public static final int SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS = 0x00080000; /** * Indicates that this window is the rounded corners overlay present on some @@ -1708,6 +1708,18 @@ public interface WindowManager extends ViewManager { public static final int PRIVATE_FLAG_STATUS_FORCE_SHOW_NAVIGATION = 0x00800000; /** + * An internal annotation for flags that can be specified to {@link #softInputMode}. + * + * @hide + */ + @SystemApi + @Retention(RetentionPolicy.SOURCE) + @IntDef(flag = true, prefix = { "SYSTEM_FLAG_" }, value = { + SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS, + }) + public @interface SystemFlags {} + + /** * Control flags that are private to the platform. * @hide */ @@ -1781,8 +1793,8 @@ public interface WindowManager extends ViewManager { equals = PRIVATE_FLAG_SUSTAINED_PERFORMANCE_MODE, name = "SUSTAINED_PERFORMANCE_MODE"), @ViewDebug.FlagToString( - mask = PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS, - equals = PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS, + mask = SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS, + equals = SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS, name = "HIDE_NON_SYSTEM_OVERLAY_WINDOWS"), @ViewDebug.FlagToString( mask = PRIVATE_FLAG_IS_ROUNDED_CORNERS_OVERLAY, diff --git a/core/java/com/android/internal/os/ProcessCpuTracker.java b/core/java/com/android/internal/os/ProcessCpuTracker.java index bf31c7d8ad85..1ee4269d974b 100644 --- a/core/java/com/android/internal/os/ProcessCpuTracker.java +++ b/core/java/com/android/internal/os/ProcessCpuTracker.java @@ -29,7 +29,6 @@ import android.util.Slog; import com.android.internal.util.FastPrintWriter; import libcore.io.IoUtils; -import libcore.io.Libcore; import java.io.File; import java.io.FileInputStream; diff --git a/core/jni/android_os_GraphicsEnvironment.cpp b/core/jni/android_os_GraphicsEnvironment.cpp index 92235ad494a7..b70485d9a0ea 100644 --- a/core/jni/android_os_GraphicsEnvironment.cpp +++ b/core/jni/android_os_GraphicsEnvironment.cpp @@ -23,10 +23,6 @@ namespace { -int getCanLoadSystemLibraries_native() { - return android::GraphicsEnv::getInstance().getCanLoadSystemLibraries(); -} - void setDriverPath(JNIEnv* env, jobject clazz, jstring path) { ScopedUtfChars pathChars(env, path); android::GraphicsEnv::getInstance().setDriverPath(pathChars.c_str()); @@ -55,7 +51,6 @@ void setDebugLayers_native(JNIEnv* env, jobject clazz, jstring layers) { } const JNINativeMethod g_methods[] = { - { "getCanLoadSystemLibraries", "()I", reinterpret_cast<void*>(getCanLoadSystemLibraries_native) }, { "setDriverPath", "(Ljava/lang/String;)V", reinterpret_cast<void*>(setDriverPath) }, { "setAngleInfo", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)V", reinterpret_cast<void*>(setAngleInfo_native) }, { "setLayerPaths", "(Ljava/lang/ClassLoader;Ljava/lang/String;)V", reinterpret_cast<void*>(setLayerPaths_native) }, diff --git a/core/jni/android_util_Binder.cpp b/core/jni/android_util_Binder.cpp index ecad6c027391..d023d22473c8 100644 --- a/core/jni/android_util_Binder.cpp +++ b/core/jni/android_util_Binder.cpp @@ -23,6 +23,7 @@ #include <atomic> #include <fcntl.h> #include <inttypes.h> +#include <mutex> #include <stdio.h> #include <sys/stat.h> #include <sys/types.h> @@ -69,6 +70,7 @@ static struct bindernative_offsets_t // Class state. jclass mClass; jmethodID mExecTransact; + jmethodID mGetInterfaceDescriptor; // Object state. jfieldID mObject; @@ -326,8 +328,32 @@ protected: env->DeleteGlobalRef(mObject); } - virtual status_t onTransact( - uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0) + const String16& getInterfaceDescriptor() const override + { + call_once(mPopulateDescriptor, [this] { + JNIEnv* env = javavm_to_jnienv(mVM); + + ALOGV("getInterfaceDescriptor() on %p calling object %p in env %p vm %p\n", this, mObject, env, mVM); + + jstring descriptor = (jstring)env->CallObjectMethod(mObject, gBinderOffsets.mGetInterfaceDescriptor); + + if (descriptor == nullptr) { + return; + } + + static_assert(sizeof(jchar) == sizeof(char16_t), ""); + const jchar* descriptorChars = env->GetStringChars(descriptor, nullptr); + const char16_t* rawDescriptor = reinterpret_cast<const char16_t*>(descriptorChars); + jsize rawDescriptorLen = env->GetStringLength(descriptor); + mDescriptor = String16(rawDescriptor, rawDescriptorLen); + env->ReleaseStringChars(descriptor, descriptorChars); + }); + + return mDescriptor; + } + + status_t onTransact( + uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0) override { JNIEnv* env = javavm_to_jnienv(mVM); @@ -376,7 +402,7 @@ protected: return res != JNI_FALSE ? NO_ERROR : UNKNOWN_TRANSACTION; } - virtual status_t dump(int fd, const Vector<String16>& args) + status_t dump(int fd, const Vector<String16>& args) override { return 0; } @@ -384,6 +410,9 @@ protected: private: JavaVM* const mVM; jobject const mObject; // GlobalRef to Java Binder + + mutable std::once_flag mPopulateDescriptor; + mutable String16 mDescriptor; }; // ---------------------------------------------------------------------------- @@ -926,6 +955,8 @@ static int int_register_android_os_Binder(JNIEnv* env) gBinderOffsets.mClass = MakeGlobalRefOrDie(env, clazz); gBinderOffsets.mExecTransact = GetMethodIDOrDie(env, clazz, "execTransact", "(IJJI)Z"); + gBinderOffsets.mGetInterfaceDescriptor = GetMethodIDOrDie(env, clazz, "getInterfaceDescriptor", + "()Ljava/lang/String;"); gBinderOffsets.mObject = GetFieldIDOrDie(env, clazz, "mObject", "J"); return RegisterMethodsOrDie( diff --git a/core/proto/android/internal/powerprofile.proto b/core/proto/android/internal/powerprofile.proto index 9dd5e7ee556c..b0c8b5638a72 100644 --- a/core/proto/android/internal/powerprofile.proto +++ b/core/proto/android/internal/powerprofile.proto @@ -35,7 +35,7 @@ message PowerProfileProto { repeated double core_power = 5; } - repeated CpuCluster cpu_cluster = 41; + repeated CpuCluster cpu_cluster = 40; optional double wifi_scan = 4; @@ -85,27 +85,27 @@ message PowerProfileProto { optional double ambient_display = 27; - optional double screen_on = 29; + optional double screen_on = 28; - optional double radio_on = 30; + optional double radio_on = 29; - optional double radio_scanning = 31; + optional double radio_scanning = 30; - optional double radio_active = 32; + optional double radio_active = 31; - optional double screen_full = 33; + optional double screen_full = 32; - optional double audio = 34; + optional double audio = 33; - optional double video = 35; + optional double video = 34; - optional double flashlight = 36; + optional double flashlight = 35; - optional double memory = 37; + optional double memory = 36; - optional double camera = 38; + optional double camera = 37; - optional double wifi_batched_scan = 39; + optional double wifi_batched_scan = 38; - optional double battery_capacity = 40; + optional double battery_capacity = 39; } diff --git a/core/proto/android/providers/settings/global.proto b/core/proto/android/providers/settings/global.proto index 47dbc0716c94..a02602ee5d99 100644 --- a/core/proto/android/providers/settings/global.proto +++ b/core/proto/android/providers/settings/global.proto @@ -397,10 +397,9 @@ message GlobalSettingsProto { // Ordered GPU debug layer list // i.e. <layer1>:<layer2>:...:<layerN> optional SettingProto debug_layers = 2 [ (android.privacy).dest = DEST_AUTOMATIC ]; + // App will load ANGLE instead of native GLES drivers. optional SettingProto angle_enabled_app = 3; - // App that can provide layer libraries. - optional SettingProto debug_layer_app = 4; } optional Gpu gpu = 59; diff --git a/proto/src/stats_enums.proto b/core/proto/android/stats/enums.proto index 6c892cfeae6c..2320a01b324c 100644 --- a/proto/src/stats_enums.proto +++ b/core/proto/android/stats/enums.proto @@ -16,8 +16,7 @@ syntax = "proto2"; -package android.os.statsd; -option java_package = "com.android.os"; +package android.stats; option java_outer_classname = "StatsEnums"; enum EventType { diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml index d2c00f2a9547..1ae5f03a2f04 100644 --- a/core/res/AndroidManifest.xml +++ b/core/res/AndroidManifest.xml @@ -138,7 +138,6 @@ <protected-broadcast android:name="android.bluetooth.device.action.MAS_INSTANCE" /> <protected-broadcast android:name="android.bluetooth.device.action.ALIAS_CHANGED" /> <protected-broadcast android:name="android.bluetooth.device.action.FOUND" /> - <protected-broadcast android:name="android.bluetooth.device.action.DISAPPEARED" /> <protected-broadcast android:name="android.bluetooth.device.action.CLASS_CHANGED" /> <protected-broadcast android:name="android.bluetooth.device.action.ACL_CONNECTED" /> <protected-broadcast android:name="android.bluetooth.device.action.ACL_DISCONNECT_REQUESTED" /> @@ -1151,6 +1150,28 @@ android:protectionLevel="dangerous|instant"/> <!-- ====================================================================== --> + <!-- Permissions for activity recognition --> + <!-- ====================================================================== --> + <eat-comment /> + + <!-- Used for permissions that are associated with activity recognition. + TODO(zezeozue). STOPSHIP: Add icon --> + <permission-group android:name="android.permission-group.ACTIVITY_RECOGNITION" + android:label="@string/permgrouplab_activityRecognition" + android:description="@string/permgroupdesc_activityRecognition" + android:request="@string/permgrouprequest_activityRecognition" + android:priority="1000" /> + + <!-- Allows an application to recognize physical activity. + <p>Protection level: dangerous + --> + <permission android:name="android.permission.ACTIVITY_RECOGNITION" + android:permissionGroup="android.permission-group.ACTIVITY_RECOGNITION" + android:label="@string/permlab_activityRecognition" + android:description="@string/permdesc_activityRecognition" + android:protectionLevel="dangerous|instant" /> + + <!-- ====================================================================== --> <!-- Permissions for accessing the UCE Service --> <!-- ====================================================================== --> @@ -2749,7 +2770,7 @@ android:protectionLevel="signature" /> <!-- @SystemApi Allows an application to use - {@link android.view.WindowManager.LayoutsParams#PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS} + {@link android.view.WindowManager.LayoutsParams#SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS} to hide non-system-overlay windows. <p>Not for use by third-party applications. @hide diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml index aeeba59b694b..cb97a2a7d7cd 100644 --- a/core/res/res/values/config.xml +++ b/core/res/res/values/config.xml @@ -3367,22 +3367,22 @@ <bool name="config_sendPackageName">false</bool> <!-- Name for the set of keys associating package names --> - <string name="config_help_package_name_key" translatable="false"></string> + <string name="config_helpPackageNameKey" translatable="false"></string> <!-- Name for the set of values of package names --> - <string name="config_help_package_name_value" translatable="false"></string> + <string name="config_helpPackageNameValue" translatable="false"></string> <!-- Intent key for the package name keys --> - <string name="config_help_intent_extra_key" translatable="false"></string> + <string name="config_helpIntentExtraKey" translatable="false"></string> <!-- Intent key for package name values --> - <string name="config_help_intent_name_key" translatable="false"></string> + <string name="config_helpIntentNameKey" translatable="false"></string> <!-- Intent key for the package name keys --> - <string name="config_feedback_intent_extra_key" translatable="false"></string> + <string name="config_feedbackIntentExtraKey" translatable="false"></string> <!-- Intent key for package name values --> - <string name="config_feedback_intent_name_key" translatable="false"></string> + <string name="config_feedbackIntentNameKey" translatable="false"></string> <!-- The apps that need to be hidden when they are disabled --> <string-array name="config_hideWhenDisabled_packageNames"></string-array> @@ -3487,7 +3487,7 @@ <string name="config_headlineFontFamilyMedium">@string/font_family_button_material</string> <!-- Size of icon shown beside a preference locked by admin --> - <dimen name="config_restricted_icon_size">@dimen/restricted_icon_size_material</dimen> + <dimen name="config_restrictedIconSize">@dimen/restricted_icon_size_material</dimen> <string translatable="false" name="config_batterySaverDeviceSpecificConfig"></string> diff --git a/core/res/res/values/public.xml b/core/res/res/values/public.xml index 2e42e4ac27f3..95517186fe9e 100644 --- a/core/res/res/values/public.xml +++ b/core/res/res/values/public.xml @@ -2930,17 +2930,17 @@ <public-group type="string" first-id="0x0104001b"> <!-- @hide @SystemApi --> - <public name="config_help_package_name_key" /> + <public name="config_helpPackageNameKey" /> <!-- @hide @SystemApi --> - <public name="config_help_package_name_value" /> + <public name="config_helpPackageNameValue" /> <!-- @hide @SystemApi --> - <public name="config_help_intent_extra_key" /> + <public name="config_helpIntentExtraKey" /> <!-- @hide @SystemApi --> - <public name="config_help_intent_name_key" /> + <public name="config_helpIntentNameKey" /> <!-- @hide @SystemApi --> - <public name="config_feedback_intent_extra_key" /> + <public name="config_feedbackIntentExtraKey" /> <!-- @hide @SystemApi --> - <public name="config_feedback_intent_name_key" /> + <public name="config_feedbackIntentNameKey" /> </public-group> <public-group type="bool" first-id="0x01110000"> @@ -2950,7 +2950,7 @@ <public-group type="dimen" first-id="0x01050007"> <!-- @hide @SystemApi --> - <public name="config_restricted_icon_size" /> + <public name="config_restrictedIconSize" /> </public-group> <!-- =============================================================== diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml index 6bf893d94ce5..fa4406185218 100644 --- a/core/res/res/values/strings.xml +++ b/core/res/res/values/strings.xml @@ -734,6 +734,14 @@ <string name="permgrouprequest_microphone">Allow <b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g></b> to record audio?</string> + <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=40]--> + <string name="permgrouplab_activityRecognition">Activity recognition</string> + <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=40]--> + <string name="permgroupdesc_activityRecognition">recognize activity</string> + <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] --> + <string name="permgrouprequest_activityRecognition">Allow + <b><xliff:g id="app_name" example="Gmail">%1$s</xliff:g></b> to recognize your physical activity?</string> + <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. --> <string name="permgrouplab_camera">Camera</string> <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. --> @@ -1151,6 +1159,11 @@ <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. --> <string name="permdesc_sim_communication">Allows the app to send commands to the SIM. This is very dangerous.</string> + <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=50]--> + <string name="permlab_activityRecognition">recognize physical activity</string> + <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=120]--> + <string name="permdesc_activityRecognition">This app can recognize your physical activity.</string> + <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. --> <string name="permlab_camera">take pictures and videos</string> <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. --> diff --git a/core/res/res/values/symbols.xml b/core/res/res/values/symbols.xml index 2ab3920a99d5..09da4fcd3f4e 100644 --- a/core/res/res/values/symbols.xml +++ b/core/res/res/values/symbols.xml @@ -3272,12 +3272,12 @@ <java-symbol type="integer" name="default_data_warning_level_mb" /> <java-symbol type="bool" name="config_useVideoPauseWorkaround" /> <java-symbol type="bool" name="config_sendPackageName" /> - <java-symbol type="string" name="config_help_package_name_key" /> - <java-symbol type="string" name="config_help_package_name_value" /> - <java-symbol type="string" name="config_help_intent_extra_key" /> - <java-symbol type="string" name="config_help_intent_name_key" /> - <java-symbol type="string" name="config_feedback_intent_extra_key" /> - <java-symbol type="string" name="config_feedback_intent_name_key" /> + <java-symbol type="string" name="config_helpPackageNameKey" /> + <java-symbol type="string" name="config_helpPackageNameValue" /> + <java-symbol type="string" name="config_helpIntentExtraKey" /> + <java-symbol type="string" name="config_helpIntentNameKey" /> + <java-symbol type="string" name="config_feedbackIntentExtraKey" /> + <java-symbol type="string" name="config_feedbackIntentNameKey" /> <java-symbol type="array" name="config_hideWhenDisabled_packageNames" /> diff --git a/core/tests/coretests/src/android/provider/SettingsBackupTest.java b/core/tests/coretests/src/android/provider/SettingsBackupTest.java index 632c37fd54d2..60abd9468179 100644 --- a/core/tests/coretests/src/android/provider/SettingsBackupTest.java +++ b/core/tests/coretests/src/android/provider/SettingsBackupTest.java @@ -450,7 +450,6 @@ public class SettingsBackupTest { Settings.Global.GPU_DEBUG_APP, Settings.Global.GPU_DEBUG_LAYERS, Settings.Global.ANGLE_ENABLED_APP, - Settings.Global.GPU_DEBUG_LAYER_APP, Settings.Global.ENABLE_GNSS_RAW_MEAS_FULL_TRACKING, Settings.Global.INSTALL_CARRIER_APP_NOTIFICATION_PERSISTENT, Settings.Global.INSTALL_CARRIER_APP_NOTIFICATION_SLEEP_MILLIS, diff --git a/graphics/java/android/graphics/pdf/PdfEditor.java b/graphics/java/android/graphics/pdf/PdfEditor.java index 3821bc7ab063..21ce1b8392d2 100644 --- a/graphics/java/android/graphics/pdf/PdfEditor.java +++ b/graphics/java/android/graphics/pdf/PdfEditor.java @@ -27,7 +27,6 @@ import android.system.Os; import android.system.OsConstants; import dalvik.system.CloseGuard; import libcore.io.IoUtils; -import libcore.io.Libcore; import java.io.IOException; diff --git a/packages/CompanionDeviceManager/src/com/android/companiondevicemanager/DeviceDiscoveryService.java b/packages/CompanionDeviceManager/src/com/android/companiondevicemanager/DeviceDiscoveryService.java index cdaabdcda20f..d0ca04bb07c2 100644 --- a/packages/CompanionDeviceManager/src/com/android/companiondevicemanager/DeviceDiscoveryService.java +++ b/packages/CompanionDeviceManager/src/com/android/companiondevicemanager/DeviceDiscoveryService.java @@ -184,7 +184,6 @@ public class DeviceDiscoveryService extends Service { if (shouldScan(mBluetoothFilters)) { final IntentFilter intentFilter = new IntentFilter(); intentFilter.addAction(BluetoothDevice.ACTION_FOUND); - intentFilter.addAction(BluetoothDevice.ACTION_DISAPPEARED); mBluetoothBroadcastReceiver = new BluetoothBroadcastReceiver(); registerReceiver(mBluetoothBroadcastReceiver, intentFilter); diff --git a/packages/EasterEgg/src/com/android/egg/paint/CutoutAvoidingToolbar.kt b/packages/EasterEgg/src/com/android/egg/paint/CutoutAvoidingToolbar.kt index 164fc5a5af3d..9855565c1335 100644 --- a/packages/EasterEgg/src/com/android/egg/paint/CutoutAvoidingToolbar.kt +++ b/packages/EasterEgg/src/com/android/egg/paint/CutoutAvoidingToolbar.kt @@ -26,15 +26,16 @@ class CutoutAvoidingToolbar : LinearLayout { private var _insets: WindowInsets? = null constructor(context: Context) : super(context) { - init(null, 0) } constructor(context: Context, attrs: AttributeSet) : super(context, attrs) { - init(attrs, 0) } - constructor(context: Context, attrs: AttributeSet, defStyle: Int) : super(context, attrs, defStyle) { - init(attrs, defStyle) + constructor( + context: Context, + attrs: AttributeSet, + defStyle: Int + ) : super(context, attrs, defStyle) { } override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) { @@ -81,8 +82,4 @@ class CutoutAvoidingToolbar : LinearLayout { requestLayout() } } - - private fun init(attrs: AttributeSet?, defStyle: Int) { - } - } diff --git a/packages/EasterEgg/src/com/android/egg/paint/Painting.kt b/packages/EasterEgg/src/com/android/egg/paint/Painting.kt index a4a3d3d835e0..fc7e8b008a54 100644 --- a/packages/EasterEgg/src/com/android/egg/paint/Painting.kt +++ b/packages/EasterEgg/src/com/android/egg/paint/Painting.kt @@ -17,7 +17,6 @@ package com.android.egg.paint import android.content.Context -import android.content.res.Resources import android.graphics.* import android.provider.Settings import android.util.AttributeSet @@ -26,7 +25,6 @@ import android.view.MotionEvent import android.view.View import android.view.WindowInsets import java.util.concurrent.TimeUnit -import android.util.Log import android.provider.Settings.System import org.json.JSONObject @@ -86,11 +84,11 @@ public class Painting : View, SpotFilter.Plotter { } var bitmap: Bitmap? = null - var paperColor : Int = 0xFFFFFFFF.toInt() + var paperColor: Int = 0xFFFFFFFF.toInt() private var _paintCanvas: Canvas? = null private val _bitmapLock = Object() - + private var _drawPaint = Paint(Paint.ANTI_ALIAS_FLAG) private var _lastX = 0f private var _lastY = 0f @@ -113,7 +111,9 @@ public class Painting : View, SpotFilter.Plotter { FADE_TO_BLACK_CF synchronized(_bitmapLock) { - c.drawBitmap(bitmap, 0f, 0f, pt) + bitmap?.let { + c.drawBitmap(bitmap!!, 0f, 0f, pt) + } } invalidate() } @@ -122,18 +122,22 @@ public class Painting : View, SpotFilter.Plotter { } constructor(context: Context) : super(context) { - init(null, 0) + init() } constructor(context: Context, attrs: AttributeSet) : super(context, attrs) { - init(attrs, 0) + init() } - constructor(context: Context, attrs: AttributeSet, defStyle: Int) : super(context, attrs, defStyle) { - init(attrs, defStyle) + constructor( + context: Context, + attrs: AttributeSet, + defStyle: Int + ) : super(context, attrs, defStyle) { + init() } - private fun init(attrs: AttributeSet?, defStyle: Int) { + private fun init() { loadDevicePressureData() } @@ -264,7 +268,7 @@ public class Painting : View, SpotFilter.Plotter { super.onDraw(canvas) bitmap?.let { - canvas.drawBitmap(bitmap, 0f, 0f, _drawPaint); + canvas.drawBitmap(bitmap!!, 0f, 0f, _drawPaint) } } @@ -330,8 +334,8 @@ public class Painting : View, SpotFilter.Plotter { } if (bits.width != oldBits.height || bits.height != oldBits.width) { matrix.postScale( - bits.width.toFloat()/oldBits.height, - bits.height.toFloat()/oldBits.width) + bits.width.toFloat() / oldBits.height, + bits.height.toFloat() / oldBits.width) } c.matrix = matrix } @@ -350,9 +354,10 @@ public class Painting : View, SpotFilter.Plotter { val invertPaint = Paint() invertPaint.colorFilter = INVERT_CF synchronized(_bitmapLock) { - _paintCanvas?.drawBitmap(bitmap, 0f, 0f, invertPaint) + bitmap?.let { + _paintCanvas?.drawBitmap(bitmap!!, 0f, 0f, invertPaint) + } } invalidate() } } - diff --git a/packages/EasterEgg/src/com/android/egg/paint/ToolbarView.kt b/packages/EasterEgg/src/com/android/egg/paint/ToolbarView.kt index 86b11e7be81e..460fa3a7241f 100644 --- a/packages/EasterEgg/src/com/android/egg/paint/ToolbarView.kt +++ b/packages/EasterEgg/src/com/android/egg/paint/ToolbarView.kt @@ -17,19 +17,10 @@ package com.android.egg.paint import android.content.Context -import android.graphics.Canvas -import android.graphics.Color -import android.graphics.Paint -import android.graphics.Rect -import android.graphics.drawable.Drawable -import android.text.TextPaint -import android.transition.ChangeBounds import android.transition.Transition import android.transition.TransitionListenerAdapter -import android.transition.TransitionManager import android.util.AttributeSet import android.view.* -import android.view.animation.OvershootInterpolator import android.widget.FrameLayout class ToolbarView : FrameLayout { @@ -44,15 +35,16 @@ class ToolbarView : FrameLayout { } constructor(context: Context) : super(context) { - init(null, 0) } constructor(context: Context, attrs: AttributeSet) : super(context, attrs) { - init(attrs, 0) } - constructor(context: Context, attrs: AttributeSet, defStyle: Int) : super(context, attrs, defStyle) { - init(attrs, defStyle) + constructor( + context: Context, + attrs: AttributeSet, + defStyle: Int + ) : super(context, attrs, defStyle) { } override fun onApplyWindowInsets(insets: WindowInsets?): WindowInsets { @@ -70,8 +62,4 @@ class ToolbarView : FrameLayout { return super.onApplyWindowInsets(insets) } - - private fun init(attrs: AttributeSet?, defStyle: Int) { - } - } diff --git a/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java b/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java index 8c29a2520390..441dbac24928 100644 --- a/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java +++ b/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstallerActivity.java @@ -16,7 +16,7 @@ */ package com.android.packageinstaller; -import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; +import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; import android.Manifest; import android.annotation.NonNull; @@ -281,7 +281,7 @@ public class PackageInstallerActivity extends AlertActivity { @Override protected void onCreate(Bundle icicle) { - getWindow().addPrivateFlags(PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); + getWindow().addSystemFlags(SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); super.onCreate(null); diff --git a/packages/SettingsLib/HelpUtils/src/com/android/settingslib/HelpUtils.java b/packages/SettingsLib/HelpUtils/src/com/android/settingslib/HelpUtils.java index 7306d968a709..e407d7239546 100644 --- a/packages/SettingsLib/HelpUtils/src/com/android/settingslib/HelpUtils.java +++ b/packages/SettingsLib/HelpUtils/src/com/android/settingslib/HelpUtils.java @@ -187,17 +187,17 @@ public class HelpUtils { if (sendPackageName && includePackageName) { String[] packageNameKey = - {resources.getString(android.R.string.config_help_package_name_key)}; + {resources.getString(android.R.string.config_helpPackageNameKey)}; String[] packageNameValue = - {resources.getString(android.R.string.config_help_package_name_value)}; + {resources.getString(android.R.string.config_helpPackageNameValue)}; String helpIntentExtraKey = - resources.getString(android.R.string.config_help_intent_extra_key); + resources.getString(android.R.string.config_helpIntentExtraKey); String helpIntentNameKey = - resources.getString(android.R.string.config_help_intent_name_key); + resources.getString(android.R.string.config_helpIntentNameKey); String feedbackIntentExtraKey = - resources.getString(android.R.string.config_feedback_intent_extra_key); + resources.getString(android.R.string.config_feedbackIntentExtraKey); String feedbackIntentNameKey = - resources.getString(android.R.string.config_feedback_intent_name_key); + resources.getString(android.R.string.config_feedbackIntentNameKey); intent.putExtra(helpIntentExtraKey, packageNameKey); intent.putExtra(helpIntentNameKey, packageNameValue); intent.putExtra(feedbackIntentExtraKey, packageNameKey); diff --git a/packages/SettingsLib/RestrictedLockUtils/res/layout/restricted_icon.xml b/packages/SettingsLib/RestrictedLockUtils/res/layout/restricted_icon.xml index 0f02abd94216..0748192fb1fc 100644 --- a/packages/SettingsLib/RestrictedLockUtils/res/layout/restricted_icon.xml +++ b/packages/SettingsLib/RestrictedLockUtils/res/layout/restricted_icon.xml @@ -15,7 +15,7 @@ --> <ImageView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/restricted_icon" - android:layout_width="@*android:dimen/config_restricted_icon_size" - android:layout_height="@*android:dimen/config_restricted_icon_size" + android:layout_width="@*android:dimen/config_restrictedIconSize" + android:layout_height="@*android:dimen/config_restrictedIconSize" android:tint="?android:attr/colorAccent" android:src="@*android:drawable/ic_info" /> diff --git a/packages/SettingsLib/RestrictedLockUtils/src/com/android/settingslib/RestrictedLockUtils.java b/packages/SettingsLib/RestrictedLockUtils/src/com/android/settingslib/RestrictedLockUtils.java index b87c9e8de1b2..e278c10a2c59 100644 --- a/packages/SettingsLib/RestrictedLockUtils/src/com/android/settingslib/RestrictedLockUtils.java +++ b/packages/SettingsLib/RestrictedLockUtils/src/com/android/settingslib/RestrictedLockUtils.java @@ -91,13 +91,7 @@ public class RestrictedLockUtils { public static boolean isCurrentUserOrProfile(Context context, int userId) { UserManager um = context.getSystemService(UserManager.class); - int[] userIds = um.getProfileIds(UserHandle.myUserId(), true); - for (int i = 0; i < userIds.length; i++) { - if (userIds[i] == userId) { - return true; - } - } - return false; + return um.getUserProfiles().contains(UserHandle.of(userId)); } public static class EnforcedAdmin { diff --git a/packages/SettingsLib/res/layout/restricted_switch_widget.xml b/packages/SettingsLib/res/layout/restricted_switch_widget.xml index e1f6cdf57101..5dbcb7952e88 100644 --- a/packages/SettingsLib/res/layout/restricted_switch_widget.xml +++ b/packages/SettingsLib/res/layout/restricted_switch_widget.xml @@ -16,8 +16,8 @@ <merge xmlns:android="http://schemas.android.com/apk/res/android"> <ImageView xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/restricted_icon" - android:layout_width="@*android:dimen/config_restricted_icon_size" - android:layout_height="@*android:dimen/config_restricted_icon_size" + android:layout_width="@*android:dimen/config_restrictedIconSize" + android:layout_height="@*android:dimen/config_restrictedIconSize" android:tint="?android:attr/colorAccent" android:src="@*android:drawable/ic_info" android:gravity="end|center_vertical" /> diff --git a/packages/SettingsLib/src/com/android/settingslib/RestrictedLockUtilsInternal.java b/packages/SettingsLib/src/com/android/settingslib/RestrictedLockUtilsInternal.java index f57122e6708d..1457fcfadc89 100644 --- a/packages/SettingsLib/src/com/android/settingslib/RestrictedLockUtilsInternal.java +++ b/packages/SettingsLib/src/com/android/settingslib/RestrictedLockUtilsInternal.java @@ -58,7 +58,7 @@ public class RestrictedLockUtilsInternal extends RestrictedLockUtils { public static Drawable getRestrictedPadlock(Context context) { Drawable restrictedPadlock = context.getDrawable(android.R.drawable.ic_info); final int iconSize = context.getResources().getDimensionPixelSize( - android.R.dimen.config_restricted_icon_size); + android.R.dimen.config_restrictedIconSize); TypedArray ta = context.obtainStyledAttributes(new int[]{android.R.attr.colorAccent}); int colorAccent = ta.getColor(0, 0); diff --git a/packages/SettingsLib/src/com/android/settingslib/bluetooth/BluetoothEventManager.java b/packages/SettingsLib/src/com/android/settingslib/bluetooth/BluetoothEventManager.java index 4aca2bb2c54d..7124096e31b8 100644 --- a/packages/SettingsLib/src/com/android/settingslib/bluetooth/BluetoothEventManager.java +++ b/packages/SettingsLib/src/com/android/settingslib/bluetooth/BluetoothEventManager.java @@ -267,8 +267,10 @@ public class BluetoothEventManager { cachedDevice = mDeviceManager.addDevice(device); Log.d(TAG, "DeviceFoundHandler created new CachedBluetoothDevice: " + cachedDevice); - } else if (cachedDevice.getBondState() == BluetoothDevice.BOND_BONDED) { - // Dispatch device add callback to show bonded BT device in discovery mode + } else if (cachedDevice.getBondState() == BluetoothDevice.BOND_BONDED + &&!cachedDevice.getDevice().isConnected()) { + // Dispatch device add callback to show bonded but + // not connected devices in discovery mode dispatchDeviceAdded(cachedDevice); } cachedDevice.setRssi(rssi); diff --git a/packages/SettingsLib/tests/robotests/src/com/android/settingslib/HelpUtilsTest.java b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/HelpUtilsTest.java index 1091e1601b89..36b70dfe2297 100644 --- a/packages/SettingsLib/tests/robotests/src/com/android/settingslib/HelpUtilsTest.java +++ b/packages/SettingsLib/tests/robotests/src/com/android/settingslib/HelpUtilsTest.java @@ -70,17 +70,17 @@ public class HelpUtilsTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); - when(mContext.getResources().getString(R.string.config_help_package_name_key)) + when(mContext.getResources().getString(R.string.config_helpPackageNameKey)) .thenReturn(PACKAGE_NAME_KEY); - when(mContext.getResources().getString(R.string.config_help_package_name_value)) + when(mContext.getResources().getString(R.string.config_helpPackageNameValue)) .thenReturn(PACKAGE_NAME_VALUE); - when(mContext.getResources().getString(R.string.config_help_intent_extra_key)) + when(mContext.getResources().getString(R.string.config_helpIntentExtraKey)) .thenReturn(HELP_INTENT_EXTRA_KEY); - when(mContext.getResources().getString(R.string.config_help_intent_name_key)) + when(mContext.getResources().getString(R.string.config_helpIntentNameKey)) .thenReturn(HELP_INTENT_NAME_KEY); - when(mContext.getResources().getString(R.string.config_feedback_intent_extra_key)) + when(mContext.getResources().getString(R.string.config_feedbackIntentExtraKey)) .thenReturn(FEEDBACK_INTENT_EXTRA_KEY); - when(mContext.getResources().getString(R.string.config_feedback_intent_name_key)) + when(mContext.getResources().getString(R.string.config_feedbackIntentNameKey)) .thenReturn(FEEDBACK_INTENT_NAME_KEY); when(mActivity.getPackageManager()).thenReturn(mPackageManager); diff --git a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java index da1354be63d2..8745a330311a 100644 --- a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java +++ b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java @@ -662,9 +662,6 @@ class SettingsProtoDumpUtil { dumpSetting(s, p, Settings.Global.ANGLE_ENABLED_APP, GlobalSettingsProto.Gpu.ANGLE_ENABLED_APP); - dumpSetting(s, p, - Settings.Global.GPU_DEBUG_LAYER_APP, - GlobalSettingsProto.Gpu.DEBUG_LAYER_APP); p.end(gpuToken); final long hdmiToken = p.start(GlobalSettingsProto.HDMI); diff --git a/packages/SystemUI/res/layout/status_bar.xml b/packages/SystemUI/res/layout/status_bar.xml index f0436dea9207..d033057cdb78 100644 --- a/packages/SystemUI/res/layout/status_bar.xml +++ b/packages/SystemUI/res/layout/status_bar.xml @@ -49,11 +49,6 @@ android:paddingEnd="@dimen/status_bar_padding_end" android:orientation="horizontal" > - <ViewStub - android:id="@+id/operator_name" - android:layout_width="wrap_content" - android:layout_height="match_parent" - android:layout="@layout/operator_name" /> <FrameLayout android:layout_height="match_parent" android:layout_width="0dp" @@ -70,6 +65,12 @@ android:layout_width="match_parent" android:clipChildren="false" > + <ViewStub + android:id="@+id/operator_name" + android:layout_width="wrap_content" + android:layout_height="match_parent" + android:layout="@layout/operator_name" /> + <com.android.systemui.statusbar.policy.Clock android:id="@+id/clock" android:layout_width="wrap_content" diff --git a/packages/SystemUI/res/values/strings.xml b/packages/SystemUI/res/values/strings.xml index e1c71fae7559..42e19aace0c3 100644 --- a/packages/SystemUI/res/values/strings.xml +++ b/packages/SystemUI/res/values/strings.xml @@ -761,6 +761,8 @@ <string name="quick_settings_cast_device_default_description">Ready to cast</string> <!-- QuickSettings: Cast detail panel, text when there are no items [CHAR LIMIT=NONE] --> <string name="quick_settings_cast_detail_empty_text">No devices available</string> + <!-- QuickSettings: Cast unavailable, text when not connected to WiFi [CHAR LIMIT=NONE] --> + <string name="quick_settings_cast_no_wifi">Wi\u2011Fi not connected</string> <!-- QuickSettings: Brightness dialog title [CHAR LIMIT=NONE] --> <string name="quick_settings_brightness_dialog_title">Brightness</string> <!-- QuickSettings: Brightness dialog auto brightness button [CHAR LIMIT=NONE] --> @@ -1999,6 +2001,9 @@ <!-- accessibility label for quick settings items that open a details page [CHAR LIMIT=NONE] --> <string name="accessibility_quick_settings_open_details">Open details.</string> + <!-- accessibility label for quick settings items that are currently disabled. Must have a reason [CHAR LIMIT=NONE] --> + <string name="accessibility_quick_settings_not_available">Unvailable due to <xliff:g name="reason" id="reason" example="Wifi not available">%s</xliff:g></string> + <!-- accessibility label for quick settings items that open a details page [CHAR LIMIT=NONE] --> <string name="accessibility_quick_settings_open_settings">Open <xliff:g name="page" example="Bluetooth">%s</xliff:g> settings.</string> diff --git a/packages/SystemUI/src/com/android/systemui/SlicePermissionActivity.java b/packages/SystemUI/src/com/android/systemui/SlicePermissionActivity.java index 6d790668995e..449ed8c3bcdb 100644 --- a/packages/SystemUI/src/com/android/systemui/SlicePermissionActivity.java +++ b/packages/SystemUI/src/com/android/systemui/SlicePermissionActivity.java @@ -14,7 +14,7 @@ package com.android.systemui; -import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; +import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; import android.app.Activity; import android.app.AlertDialog; @@ -69,7 +69,7 @@ public class SlicePermissionActivity extends Activity implements OnClickListener .setPositiveButton(R.string.slice_permission_allow, this) .setOnDismissListener(this) .create(); - dialog.getWindow().addPrivateFlags(PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); + dialog.getWindow().addSystemFlags(SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); dialog.show(); TextView t1 = dialog.getWindow().getDecorView().findViewById(R.id.text1); t1.setText(getString(R.string.slice_permission_text_1, app2)); diff --git a/packages/SystemUI/src/com/android/systemui/media/MediaProjectionPermissionActivity.java b/packages/SystemUI/src/com/android/systemui/media/MediaProjectionPermissionActivity.java index 4a6786832df0..df763151cdd7 100644 --- a/packages/SystemUI/src/com/android/systemui/media/MediaProjectionPermissionActivity.java +++ b/packages/SystemUI/src/com/android/systemui/media/MediaProjectionPermissionActivity.java @@ -16,7 +16,7 @@ package com.android.systemui.media; -import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; +import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; import android.app.Activity; import android.app.AlertDialog; @@ -151,7 +151,7 @@ public class MediaProjectionPermissionActivity extends Activity ((CheckBox) mDialog.findViewById(R.id.remember)).setOnCheckedChangeListener(this); final Window w = mDialog.getWindow(); w.setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); - w.addPrivateFlags(PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); + w.addSystemFlags(SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); mDialog.show(); } diff --git a/packages/SystemUI/src/com/android/systemui/qs/tiles/CastTile.java b/packages/SystemUI/src/com/android/systemui/qs/tiles/CastTile.java index ed78048c8746..921db6901626 100644 --- a/packages/SystemUI/src/com/android/systemui/qs/tiles/CastTile.java +++ b/packages/SystemUI/src/com/android/systemui/qs/tiles/CastTile.java @@ -46,6 +46,7 @@ import com.android.systemui.statusbar.phone.SystemUIDialog; import com.android.systemui.statusbar.policy.CastController; import com.android.systemui.statusbar.policy.CastController.CastDevice; import com.android.systemui.statusbar.policy.KeyguardMonitor; +import com.android.systemui.statusbar.policy.NetworkController; import java.util.LinkedHashMap; import java.util.Set; @@ -58,16 +59,18 @@ public class CastTile extends QSTileImpl<BooleanState> { private final CastController mController; private final CastDetailAdapter mDetailAdapter; private final KeyguardMonitor mKeyguard; + private final NetworkController mNetworkController; private final Callback mCallback = new Callback(); private final ActivityStarter mActivityStarter; private Dialog mDialog; - private boolean mRegistered; + private boolean mWifiConnected; public CastTile(QSHost host) { super(host); mController = Dependency.get(CastController.class); mDetailAdapter = new CastDetailAdapter(); mKeyguard = Dependency.get(KeyguardMonitor.class); + mNetworkController = Dependency.get(NetworkController.class); mActivityStarter = Dependency.get(ActivityStarter.class); } @@ -87,10 +90,12 @@ public class CastTile extends QSTileImpl<BooleanState> { if (listening) { mController.addCallback(mCallback); mKeyguard.addCallback(mCallback); + mNetworkController.addCallback(mSignalCallback); } else { mController.setDiscovering(false); mController.removeCallback(mCallback); mKeyguard.removeCallback(mCallback); + mNetworkController.removeCallback(mSignalCallback); } } @@ -112,6 +117,9 @@ public class CastTile extends QSTileImpl<BooleanState> { @Override protected void handleClick() { + if (getState().state == Tile.STATE_UNAVAILABLE) { + return; + } if (mKeyguard.isSecure() && !mKeyguard.canSkipBouncer()) { mActivityStarter.postQSRunnableDismissingKeyguard(() -> { showDetail(true); @@ -164,13 +172,22 @@ public class CastTile extends QSTileImpl<BooleanState> { if (!state.value && connecting) { state.label = mContext.getString(R.string.quick_settings_connecting); } - state.state = state.value ? Tile.STATE_ACTIVE : Tile.STATE_INACTIVE; state.icon = ResourceIcon.get(state.value ? R.drawable.ic_qs_cast_on : R.drawable.ic_qs_cast_off); + if (mWifiConnected) { + state.state = state.value ? Tile.STATE_ACTIVE : Tile.STATE_INACTIVE; + state.secondaryLabel = ""; + state.contentDescription = state.contentDescription + "," + + mContext.getString(R.string.accessibility_quick_settings_open_details); + state.expandedAccessibilityClassName = Button.class.getName(); + } else { + state.state = Tile.STATE_UNAVAILABLE; + String noWifi = mContext.getString(R.string.quick_settings_cast_no_wifi); + state.secondaryLabel = noWifi; + state.contentDescription = state.contentDescription + ", " + mContext.getString( + R.string.accessibility_quick_settings_not_available, noWifi); + } mDetailAdapter.updateItems(devices); - state.expandedAccessibilityClassName = Button.class.getName(); - state.contentDescription = state.contentDescription + "," - + mContext.getString(R.string.accessibility_quick_settings_open_details); } @Override @@ -192,6 +209,22 @@ public class CastTile extends QSTileImpl<BooleanState> { : mContext.getString(R.string.quick_settings_cast_device_default_name); } + private final NetworkController.SignalCallback mSignalCallback = + new NetworkController.SignalCallback() { + @Override + public void setWifiIndicators(boolean enabled, + NetworkController.IconState statusIcon, + NetworkController.IconState qsIcon, boolean activityIn, boolean activityOut, + String description, boolean isTransient, String statusLabel) { + // statusIcon.visible has the connected status information + boolean enabledAndConnected = enabled && qsIcon.visible; + if (enabledAndConnected != mWifiConnected) { + mWifiConnected = enabledAndConnected; + refreshState(); + } + } + }; + private final class Callback implements CastController.Callback, KeyguardMonitor.Callback { @Override public void onCastDevicesChanged() { diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShelf.java b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShelf.java index d8f7b6142dd8..7fa042655e53 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShelf.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationShelf.java @@ -436,7 +436,9 @@ public class NotificationShelf extends ActivatableNotificationView implements public boolean onPreDraw() { boolean animatingY = ViewState.isAnimatingY(icon); if (!animatingY) { - observer.removeOnPreDrawListener(this); + if (observer.isAlive()) { + observer.removeOnPreDrawListener(this); + } icon.setTag(TAG_CONTINUOUS_CLIPPING, null); return true; } @@ -453,7 +455,9 @@ public class NotificationShelf extends ActivatableNotificationView implements @Override public void onViewDetachedFromWindow(View v) { if (v == icon) { - observer.removeOnPreDrawListener(predrawListener); + if (observer.isAlive()) { + observer.removeOnPreDrawListener(predrawListener); + } icon.setTag(TAG_CONTINUOUS_CLIPPING, null); } } diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceController.java index 9acaf21c41f5..c66bbb1696ac 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceController.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceController.java @@ -48,6 +48,7 @@ public class HeadsUpAppearanceController implements OnHeadsUpChangedListener, private final NotificationStackScrollLayout mStackScroller; private final HeadsUpStatusBarView mHeadsUpStatusBarView; private final View mClockView; + private final View mOperatorNameView; private final DarkIconDispatcher mDarkIconDispatcher; private final NotificationPanelView mPanelView; private final Consumer<ExpandableNotificationRow> @@ -65,8 +66,10 @@ public class HeadsUpAppearanceController implements OnHeadsUpChangedListener, private final View.OnLayoutChangeListener mStackScrollLayoutChangeListener = (v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom) -> updatePanelTranslation(); + private boolean mAnimationsEnabled = true; Point mPoint; + public HeadsUpAppearanceController( NotificationIconAreaController notificationIconAreaController, HeadsUpManagerPhone headsUpManager, @@ -75,7 +78,8 @@ public class HeadsUpAppearanceController implements OnHeadsUpChangedListener, statusbarView.findViewById(R.id.heads_up_status_bar_view), statusbarView.findViewById(R.id.notification_stack_scroller), statusbarView.findViewById(R.id.notification_panel), - statusbarView.findViewById(R.id.clock)); + statusbarView.findViewById(R.id.clock), + statusbarView.findViewById(R.id.operator_name_frame)); } @VisibleForTesting @@ -85,7 +89,8 @@ public class HeadsUpAppearanceController implements OnHeadsUpChangedListener, HeadsUpStatusBarView headsUpStatusBarView, NotificationStackScrollLayout stackScroller, NotificationPanelView panelView, - View clockView) { + View clockView, + View operatorNameView) { mNotificationIconAreaController = notificationIconAreaController; mHeadsUpManager = headsUpManager; mHeadsUpManager.addListener(this); @@ -101,6 +106,7 @@ public class HeadsUpAppearanceController implements OnHeadsUpChangedListener, mStackScroller.addOnLayoutChangeListener(mStackScrollLayoutChangeListener); mStackScroller.setHeadsUpAppearanceController(this); mClockView = clockView; + mOperatorNameView = operatorNameView; mDarkIconDispatcher = Dependency.get(DarkIconDispatcher.class); mDarkIconDispatcher.addDarkReceiver(this); @@ -230,20 +236,52 @@ public class HeadsUpAppearanceController implements OnHeadsUpChangedListener, mShown = isShown; if (isShown) { mHeadsUpStatusBarView.setVisibility(View.VISIBLE); - CrossFadeHelper.fadeIn(mHeadsUpStatusBarView, CONTENT_FADE_DURATION /* duration */, - CONTENT_FADE_DELAY /* delay */); - CrossFadeHelper.fadeOut(mClockView, CONTENT_FADE_DURATION/* duration */, - 0 /* delay */, () -> mClockView.setVisibility(View.INVISIBLE)); + show(mHeadsUpStatusBarView); + hide(mClockView, View.INVISIBLE); + if (mOperatorNameView != null) { + hide(mOperatorNameView, View.INVISIBLE); + } } else { - CrossFadeHelper.fadeIn(mClockView, CONTENT_FADE_DURATION /* duration */, - CONTENT_FADE_DELAY /* delay */); - CrossFadeHelper.fadeOut(mHeadsUpStatusBarView, CONTENT_FADE_DURATION/* duration */, - 0 /* delay */, () -> mHeadsUpStatusBarView.setVisibility(View.GONE)); - + show(mClockView); + if (mOperatorNameView != null) { + show(mOperatorNameView); + } + hide(mHeadsUpStatusBarView, View.GONE); } } } + /** + * Hides the view and sets the state to endState when finished. + * + * @param view The view to hide. + * @param endState One of {@link View#INVISIBLE} or {@link View#GONE}. + * @see View#setVisibility(int) + * + */ + private void hide(View view, int endState) { + if (mAnimationsEnabled) { + CrossFadeHelper.fadeOut(view, CONTENT_FADE_DURATION /* duration */, + 0 /* delay */, () -> view.setVisibility(endState)); + } else { + view.setVisibility(endState); + } + } + + private void show(View view) { + if (mAnimationsEnabled) { + CrossFadeHelper.fadeIn(view, CONTENT_FADE_DURATION /* duration */, + CONTENT_FADE_DELAY /* delay */); + } else { + view.setVisibility(View.VISIBLE); + } + } + + @VisibleForTesting + void setAnimationsEnabled(boolean enabled) { + mAnimationsEnabled = enabled; + } + @VisibleForTesting public boolean isShown() { return mShown; diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java index 2a4595b980ac..8ac867727e65 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBouncer.java @@ -361,6 +361,8 @@ public class KeyguardBouncer { } else if (fraction == EXPANSION_HIDDEN && oldExpansion != EXPANSION_HIDDEN) { onFullyHidden(); mExpansionCallback.onFullyHidden(); + } else if (fraction != EXPANSION_VISIBLE && oldExpansion == EXPANSION_VISIBLE) { + mExpansionCallback.onStartingToHide(); } } @@ -481,6 +483,7 @@ public class KeyguardBouncer { public interface BouncerExpansionCallback { void onFullyShown(); + void onStartingToHide(); void onFullyHidden(); } } diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java index 3db1456446a0..ac3608bc622a 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarKeyguardViewManager.java @@ -84,6 +84,11 @@ public class StatusBarKeyguardViewManager implements RemoteInputController.Callb } @Override + public void onStartingToHide() { + updateStates(); + } + + @Override public void onFullyHidden() { updateStates(); } diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java index 57c7e285e29f..0d37b550d4e0 100644 --- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java +++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBarWindowController.java @@ -173,9 +173,9 @@ public class StatusBarWindowController implements Callback, Dumpable, Configurat } if (state.dozing) { - mLpChanged.privateFlags |= LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; + mLpChanged.privateFlags |= LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; } else { - mLpChanged.privateFlags &= ~LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; + mLpChanged.privateFlags &= ~LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; } } diff --git a/packages/SystemUI/src/com/android/systemui/tuner/TunablePadding.java b/packages/SystemUI/src/com/android/systemui/tuner/TunablePadding.java index af99236cc393..e85dee841715 100644 --- a/packages/SystemUI/src/com/android/systemui/tuner/TunablePadding.java +++ b/packages/SystemUI/src/com/android/systemui/tuner/TunablePadding.java @@ -51,7 +51,9 @@ public class TunablePadding implements Tunable { public void onTuningChanged(String key, String newValue) { int dimen = mDefaultSize; if (newValue != null) { - dimen = (int) (Integer.parseInt(newValue) * mDensity); + try { + dimen = (int) (Integer.parseInt(newValue) * mDensity); + } catch (NumberFormatException ex) {} } int left = mView.isLayoutRtl() ? FLAG_END : FLAG_START; int right = mView.isLayoutRtl() ? FLAG_START : FLAG_END; diff --git a/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java b/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java index 66d5ee1a276f..4102e63f7330 100644 --- a/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java +++ b/packages/SystemUI/src/com/android/systemui/usb/UsbDebuggingActivity.java @@ -54,7 +54,7 @@ public class UsbDebuggingActivity extends AlertActivity @Override public void onCreate(Bundle icicle) { Window window = getWindow(); - window.addPrivateFlags(WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); + window.addSystemFlags(WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); window.setType(WindowManager.LayoutParams.TYPE_SYSTEM_DIALOG); super.onCreate(icicle); diff --git a/packages/SystemUI/tests/src/com/android/systemui/qs/tiles/CastTileTest.java b/packages/SystemUI/tests/src/com/android/systemui/qs/tiles/CastTileTest.java new file mode 100644 index 000000000000..d9412ecd9a3a --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/qs/tiles/CastTileTest.java @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the + * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the specific language governing + * permissions and limitations under the License. + */ + +package com.android.systemui.qs.tiles; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertTrue; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.service.quicksettings.Tile; +import android.support.test.filters.SmallTest; +import android.testing.AndroidTestingRunner; +import android.testing.TestableLooper; + +import com.android.systemui.Dependency; +import com.android.systemui.SysuiTestCase; +import com.android.systemui.plugins.ActivityStarter; +import com.android.systemui.qs.QSTileHost; +import com.android.systemui.statusbar.policy.CastController; +import com.android.systemui.statusbar.policy.KeyguardMonitor; +import com.android.systemui.statusbar.policy.NetworkController; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.HashSet; +import java.util.Set; + + +@RunWith(AndroidTestingRunner.class) +@TestableLooper.RunWithLooper +@SmallTest +public class CastTileTest extends SysuiTestCase { + + @Mock + private CastController mController; + @Mock + private ActivityStarter mActivityStarter; + @Mock + private KeyguardMonitor mKeyguard; + @Mock + private NetworkController mNetworkController; + @Mock + private QSTileHost mHost; + @Mock + NetworkController.SignalCallback mCallback; + + private TestableLooper mTestableLooper; + private CastTile mCastTile; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + mTestableLooper = TestableLooper.get(this); + + mDependency.injectTestDependency(Dependency.BG_LOOPER, mTestableLooper.getLooper()); + mController = mDependency.injectMockDependency(CastController.class); + mActivityStarter = mDependency.injectMockDependency(ActivityStarter.class); + mKeyguard = mDependency.injectMockDependency(KeyguardMonitor.class); + mNetworkController = mDependency.injectMockDependency(NetworkController.class); + + when(mHost.getContext()).thenReturn(mContext); + + mCastTile = new CastTile(mHost); + + // We are not setting the mocks to listening, so we trigger a first refresh state to + // set the initial state + mCastTile.refreshState(); + + mCastTile.handleSetListening(true); + ArgumentCaptor<NetworkController.SignalCallback> signalCallbackArgumentCaptor = + ArgumentCaptor.forClass(NetworkController.SignalCallback.class); + verify(mNetworkController).addCallback(signalCallbackArgumentCaptor.capture()); + mCallback = signalCallbackArgumentCaptor.getValue(); + + } + + @Test + public void testStateUnavailable_wifiDisabled() { + NetworkController.IconState qsIcon = + new NetworkController.IconState(false, 0, ""); + mCallback.setWifiIndicators(false, mock(NetworkController.IconState.class), + qsIcon, false,false, "", + false, ""); + mTestableLooper.processAllMessages(); + + assertEquals(Tile.STATE_UNAVAILABLE, mCastTile.getState().state); + } + + @Test + public void testStateUnavailable_wifiNotConnected() { + NetworkController.IconState qsIcon = + new NetworkController.IconState(false, 0, ""); + mCallback.setWifiIndicators(true, mock(NetworkController.IconState.class), + qsIcon, false,false, "", + false, ""); + mTestableLooper.processAllMessages(); + + assertEquals(Tile.STATE_UNAVAILABLE, mCastTile.getState().state); + } + + @Test + public void testStateActive_wifiEnabledAndCasting() { + CastController.CastDevice device = mock(CastController.CastDevice.class); + device.state = CastController.CastDevice.STATE_CONNECTED; + Set<CastController.CastDevice> devices = new HashSet<>(); + devices.add(device); + when(mController.getCastDevices()).thenReturn(devices); + + NetworkController.IconState qsIcon = + new NetworkController.IconState(true, 0, ""); + mCallback.setWifiIndicators(true, mock(NetworkController.IconState.class), + qsIcon, false,false, "", + false, ""); + mTestableLooper.processAllMessages(); + + assertEquals(Tile.STATE_ACTIVE, mCastTile.getState().state); + } + + @Test + public void testStateInactive_wifiEnabledNotCasting() { + NetworkController.IconState qsIcon = + new NetworkController.IconState(true, 0, ""); + mCallback.setWifiIndicators(true, mock(NetworkController.IconState.class), + qsIcon, false,false, "", + false, ""); + mTestableLooper.processAllMessages(); + + assertEquals(Tile.STATE_INACTIVE, mCastTile.getState().state); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceControllerTest.java index a4004ae2d7cc..10b0d834b36b 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpAppearanceControllerTest.java @@ -54,6 +54,7 @@ public class HeadsUpAppearanceControllerTest extends SysuiTestCase { private ExpandableNotificationRow mFirst; private HeadsUpStatusBarView mHeadsUpStatusBarView; private HeadsUpManagerPhone mHeadsUpManager; + private View mOperatorNameView; @Before public void setUp() throws Exception { @@ -63,13 +64,15 @@ public class HeadsUpAppearanceControllerTest extends SysuiTestCase { mHeadsUpStatusBarView = new HeadsUpStatusBarView(mContext, mock(View.class), mock(TextView.class)); mHeadsUpManager = mock(HeadsUpManagerPhone.class); + mOperatorNameView = new View(mContext); mHeadsUpAppearanceController = new HeadsUpAppearanceController( mock(NotificationIconAreaController.class), mHeadsUpManager, mHeadsUpStatusBarView, mStackScroller, mPanelView, - new View(mContext)); + new View(mContext), + mOperatorNameView); mHeadsUpAppearanceController.setExpandedHeight(0.0f, 0.0f); } @@ -116,6 +119,22 @@ public class HeadsUpAppearanceControllerTest extends SysuiTestCase { } @Test + public void testOperatorNameViewUpdated() { + mHeadsUpAppearanceController.setAnimationsEnabled(false); + + mFirst.setPinned(true); + when(mHeadsUpManager.hasPinnedHeadsUp()).thenReturn(true); + when(mHeadsUpManager.getTopEntry()).thenReturn(mFirst.getEntry()); + mHeadsUpAppearanceController.onHeadsUpPinned(mFirst); + Assert.assertEquals(View.INVISIBLE, mOperatorNameView.getVisibility()); + + mFirst.setPinned(false); + when(mHeadsUpManager.hasPinnedHeadsUp()).thenReturn(false); + mHeadsUpAppearanceController.onHeadsUpUnPinned(mFirst); + Assert.assertEquals(View.VISIBLE, mOperatorNameView.getVisibility()); + } + + @Test public void testHeaderReadFromOldController() { mHeadsUpAppearanceController.setExpandedHeight(1.0f, 1.0f); @@ -125,6 +144,7 @@ public class HeadsUpAppearanceControllerTest extends SysuiTestCase { mHeadsUpStatusBarView, mStackScroller, mPanelView, + new View(mContext), new View(mContext)); newController.readFrom(mHeadsUpAppearanceController); diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardBouncerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardBouncerTest.java index a7954f2aa199..020682b6b4e8 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardBouncerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/KeyguardBouncerTest.java @@ -170,13 +170,17 @@ public class KeyguardBouncerTest extends SysuiTestCase { mBouncer.ensureView(); mBouncer.setExpansion(0.5f); - mBouncer.setExpansion(1); + mBouncer.setExpansion(KeyguardBouncer.EXPANSION_HIDDEN); verify(mFalsingManager).onBouncerHidden(); verify(mExpansionCallback).onFullyHidden(); - mBouncer.setExpansion(0); + mBouncer.setExpansion(KeyguardBouncer.EXPANSION_VISIBLE); verify(mFalsingManager).onBouncerShown(); verify(mExpansionCallback).onFullyShown(); + + verify(mExpansionCallback, never()).onStartingToHide(); + mBouncer.setExpansion(0.9f); + verify(mExpansionCallback).onStartingToHide(); } @Test diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/StatusBarWindowControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/StatusBarWindowControllerTest.java index f7a7e0430977..de26c709922d 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/StatusBarWindowControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/StatusBarWindowControllerTest.java @@ -74,14 +74,14 @@ public class StatusBarWindowControllerTest extends SysuiTestCase { ArgumentCaptor.forClass(WindowManager.LayoutParams.class); verify(mWindowManager).updateViewLayout(any(), captor.capture()); int flag = captor.getValue().privateFlags - & WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; + & WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; assertThat(flag).isNotEqualTo(0); reset(mWindowManager); mStatusBarWindowController.setDozing(false); verify(mWindowManager).updateViewLayout(any(), captor.capture()); flag = captor.getValue().privateFlags - & WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; + & WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; assertThat(flag).isEqualTo(0); } diff --git a/proto/src/metrics_constants/metrics_constants.proto b/proto/src/metrics_constants/metrics_constants.proto index 5e87707c39e6..d86de5dfd799 100644 --- a/proto/src/metrics_constants/metrics_constants.proto +++ b/proto/src/metrics_constants/metrics_constants.proto @@ -6549,6 +6549,21 @@ message MetricsEvent { // Subtype: The importance of a notification has been changed ADJUSTMENT_KEY_IMPORTANCE = 1580; + // OPEN: Settings > Network & internet > Mobile network > Choose network + // CATEGORY: SETTINGS + // OS: Q + MOBILE_NETWORK_SELECT = 1581; + + // OPEN: Settings > Network & internet > Mobile network > Mobile Data > Dialog + // CATEGORY: SETTINGS + // OS: Q + MOBILE_DATA_DIALOG = 1582; + + // OPEN: Settings > Network & internet > Mobile network > Data roaming > Dialog + // CATEGORY: SETTINGS + // OS: Q + MOBILE_ROAMING_DIALOG = 1583; + // ---- End Q Constants, all Q constants go above this line ---- // Add new aosp constants above this line. diff --git a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java index 6904b3fc6b9c..3a5232a6b97a 100644 --- a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java +++ b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java @@ -708,8 +708,6 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable { } else { throw TaskException.create(); } - } finally { - mBlankStateFile.delete(); } checkAgentResult(packageInfo, agentResult); } @@ -1037,8 +1035,13 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable { private void cleanUpAgent(@StateTransaction int stateTransaction) { applyStateTransaction(stateTransaction); - mBackupDataFile.delete(); + if (mBackupDataFile != null) { + mBackupDataFile.delete(); + } mBlankStateFile.delete(); + mSavedStateFile = null; + mBackupDataFile = null; + mNewStateFile = null; tryCloseFileDescriptor(mSavedState, "old state"); tryCloseFileDescriptor(mBackupData, "backup data"); tryCloseFileDescriptor(mNewState, "new state"); @@ -1059,7 +1062,9 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable { mNewStateFile.renameTo(mSavedStateFile); break; case StateTransaction.DISCARD_NEW: - mNewStateFile.delete(); + if (mNewStateFile != null) { + mNewStateFile.delete(); + } break; case StateTransaction.DISCARD_ALL: mSavedStateFile.delete(); diff --git a/services/core/Android.bp b/services/core/Android.bp index be353458cf44..2fa2941efe7f 100644 --- a/services/core/Android.bp +++ b/services/core/Android.bp @@ -4,6 +4,7 @@ java_library_static { aidl: { include_dirs: [ "frameworks/native/aidl/binder", + "frameworks/native/cmds/dumpstate/binder", "system/core/storaged/binder", "system/netd/server/binder", "system/vold/binder", @@ -11,6 +12,7 @@ java_library_static { }, srcs: [ "java/**/*.java", + ":dumpstate_aidl", ":netd_aidl", ":netd_metrics_aidl", ":installd_aidl", diff --git a/services/core/java/com/android/server/ConnectivityService.java b/services/core/java/com/android/server/ConnectivityService.java index 4b77c69aba2b..bc6254a76327 100644 --- a/services/core/java/com/android/server/ConnectivityService.java +++ b/services/core/java/com/android/server/ConnectivityService.java @@ -1679,6 +1679,16 @@ public class ConnectivityService extends IConnectivityManager.Stub "ConnectivityService"); } + private void enforceAnyPermissionOf(String... permissions) { + for (String permission : permissions) { + if (mContext.checkCallingOrSelfPermission(permission) == PERMISSION_GRANTED) { + return; + } + } + throw new SecurityException( + "Requires one of the following permissions: " + String.join(", ", permissions) + "."); + } + private void enforceInternetPermission() { mContext.enforceCallingOrSelfPermission( android.Manifest.permission.INTERNET, @@ -1723,6 +1733,13 @@ public class ConnectivityService extends IConnectivityManager.Stub "ConnectivityService"); } + private void enforceNetworkStackSettingsOrSetup() { + enforceAnyPermissionOf( + android.Manifest.permission.NETWORK_SETTINGS, + android.Manifest.permission.NETWORK_SETUP_WIZARD, + android.Manifest.permission.NETWORK_STACK); + } + private boolean checkNetworkStackPermission() { return PERMISSION_GRANTED == mContext.checkCallingOrSelfPermission( android.Manifest.permission.NETWORK_STACK); @@ -3984,7 +4001,7 @@ public class ConnectivityService extends IConnectivityManager.Stub @Override public void setAirplaneMode(boolean enable) { - enforceConnectivityInternalPermission(); + enforceNetworkStackSettingsOrSetup(); final long ident = Binder.clearCallingIdentity(); try { final ContentResolver cr = mContext.getContentResolver(); diff --git a/services/core/java/com/android/server/am/ActivityLaunchParamsModifier.java b/services/core/java/com/android/server/am/ActivityLaunchParamsModifier.java deleted file mode 100644 index f44ee7a234ca..000000000000 --- a/services/core/java/com/android/server/am/ActivityLaunchParamsModifier.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (C) 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License - */ - -package com.android.server.am; - -import android.app.ActivityOptions; -import android.content.pm.ActivityInfo; -import android.graphics.Rect; - -import com.android.server.am.LaunchParamsController.LaunchParams; -import com.android.server.am.LaunchParamsController.LaunchParamsModifier; - -/** - * An implementation of {@link LaunchParamsModifier}, which applies the launch bounds specified - * inside {@link ActivityOptions#getLaunchBounds()}. - */ -public class ActivityLaunchParamsModifier implements LaunchParamsModifier { - private final ActivityStackSupervisor mSupervisor; - - ActivityLaunchParamsModifier(ActivityStackSupervisor activityStackSupervisor) { - mSupervisor = activityStackSupervisor; - } - - @Override - public int onCalculate(TaskRecord task, ActivityInfo.WindowLayout layout, - ActivityRecord activity, ActivityRecord source, ActivityOptions options, - LaunchParams currentParams, LaunchParams outParams) { - // We only care about figuring out bounds for activities. - if (activity == null) { - return RESULT_SKIP; - } - - // Activity must be resizeable in the specified task. - if (!(mSupervisor.canUseActivityOptionsLaunchBounds(options) - && (activity.isResizeable() || (task != null && task.isResizeable())))) { - return RESULT_SKIP; - } - - final Rect bounds = options.getLaunchBounds(); - - // Bounds weren't valid. - if (bounds == null || bounds.isEmpty()) { - return RESULT_SKIP; - } - - outParams.mBounds.set(bounds); - - // When this is the most explicit position specification so we should not allow further - // modification of the position. - return RESULT_DONE; - } -} diff --git a/services/core/java/com/android/server/am/ActivityStack.java b/services/core/java/com/android/server/am/ActivityStack.java index db9e59c23858..864bf2d77b59 100644 --- a/services/core/java/com/android/server/am/ActivityStack.java +++ b/services/core/java/com/android/server/am/ActivityStack.java @@ -227,7 +227,7 @@ class ActivityStack<T extends StackWindowController> extends ConfigurationContai } @Override - protected ConfigurationContainer getChildAt(int index) { + protected TaskRecord getChildAt(int index) { return mTaskHistory.get(index); } diff --git a/services/core/java/com/android/server/am/ActivityStarter.java b/services/core/java/com/android/server/am/ActivityStarter.java index 13b16b2fb84c..33f949fccfb0 100644 --- a/services/core/java/com/android/server/am/ActivityStarter.java +++ b/services/core/java/com/android/server/am/ActivityStarter.java @@ -1606,13 +1606,18 @@ class ActivityStarter { mVoiceSession = voiceSession; mVoiceInteractor = voiceInteractor; - mPreferredDisplayId = getPreferedDisplayId(mSourceRecord, mStartActivity, options); - mLaunchParams.reset(); mSupervisor.getLaunchParamsController().calculate(inTask, null /*layout*/, r, sourceRecord, options, mLaunchParams); + if (mLaunchParams.hasPreferredDisplay()) { + mPreferredDisplayId = mLaunchParams.mPreferredDisplayId; + } else { + mPreferredDisplayId = DEFAULT_DISPLAY; + } + ensureValidPreferredDisplayId(r); + mLaunchMode = r.launchMode; mLaunchFlags = adjustLaunchFlagsToDocumentMode( @@ -1704,6 +1709,24 @@ class ActivityStarter { mNoAnimation = (mLaunchFlags & FLAG_ACTIVITY_NO_ANIMATION) != 0; } + /** + * Ensure preferred display ID matches the starting activity. + */ + private void ensureValidPreferredDisplayId(ActivityRecord startingActivity) { + // Check if the Activity is a VR activity. If so, the activity should be launched in + // main display. + if (startingActivity != null && startingActivity.requestedVrComponent != null) { + mPreferredDisplayId = DEFAULT_DISPLAY; + } + + // Get the virtual display ID from ActivityStackManagerService. If that's set we should + // always use that. + final int displayId = mService.mVr2dDisplayId; + if (displayId != INVALID_DISPLAY) { + mPreferredDisplayId = displayId; + } + } + private void sendNewTaskResultRequestIfNeeded() { final ActivityStack sourceStack = mStartActivity.resultTo != null ? mStartActivity.resultTo.getStack() : null; @@ -1883,44 +1906,6 @@ class ActivityStarter { } /** - * Returns the ID of the display to use for a new activity. If the device is in VR mode, - * then return the Vr mode's virtual display ID. If not, if the activity was started with - * a launchDisplayId, use that. Otherwise, if the source activity has a explicit display ID - * set, use that to launch the activity. - */ - private int getPreferedDisplayId( - ActivityRecord sourceRecord, ActivityRecord startingActivity, ActivityOptions options) { - // Check if the Activity is a VR activity. If so, the activity should be launched in - // main display. - if (startingActivity != null && startingActivity.requestedVrComponent != null) { - return DEFAULT_DISPLAY; - } - - // Get the virtual display id from ActivityManagerService. - int displayId = mService.mVr2dDisplayId; - if (displayId != INVALID_DISPLAY) { - if (DEBUG_STACK) { - Slog.d(TAG, "getSourceDisplayId :" + displayId); - } - return displayId; - } - - // If the caller requested a display, prefer that display. - final int launchDisplayId = - (options != null) ? options.getLaunchDisplayId() : INVALID_DISPLAY; - if (launchDisplayId != INVALID_DISPLAY) { - return launchDisplayId; - } - - displayId = sourceRecord != null ? sourceRecord.getDisplayId() : INVALID_DISPLAY; - // If the activity has a displayId set explicitly, launch it on the same displayId. - if (displayId != INVALID_DISPLAY) { - return displayId; - } - return DEFAULT_DISPLAY; - } - - /** * Figure out which task and activity to bring to front when we have found an existing matching * activity record in history. May also clear the task if needed. * @param intentActivity Existing matching activity. diff --git a/services/core/java/com/android/server/am/ActivityTaskManagerService.java b/services/core/java/com/android/server/am/ActivityTaskManagerService.java index 4dd5a998d433..b369b7135b4e 100644 --- a/services/core/java/com/android/server/am/ActivityTaskManagerService.java +++ b/services/core/java/com/android/server/am/ActivityTaskManagerService.java @@ -141,7 +141,6 @@ import android.app.WindowConfiguration; import android.app.admin.DevicePolicyCache; import android.app.assist.AssistContent; import android.app.assist.AssistStructure; -import android.app.servertransaction.ConfigurationChangeItem; import android.app.usage.UsageEvents; import android.content.ActivityNotFoundException; import android.content.ComponentName; @@ -4525,19 +4524,13 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub { mAm.mHandler.sendMessage(msg); } - // TODO: Consider using mPidMap to update configurations for processes. - for (int i = mAm.mLruProcesses.size() - 1; i >= 0; i--) { - ProcessRecord app = mAm.mLruProcesses.get(i); - try { - if (app.thread != null) { - if (DEBUG_CONFIGURATION) Slog.v(TAG_CONFIGURATION, "Sending to proc " - + app.processName + " new config " + configCopy); - getLifecycleManager().scheduleTransaction(app.thread, - ConfigurationChangeItem.obtain(configCopy)); - } - } catch (Exception e) { - Slog.e(TAG_CONFIGURATION, "Failed to schedule configuration change", e); + for (int i = mPidMap.size() - 1; i >= 0; i--) { + WindowProcessController app = mPidMap.get(mPidMap.keyAt(i)); + if (DEBUG_CONFIGURATION) { + Slog.v(TAG_CONFIGURATION, "Update process config of " + + app.mName + " to new config " + configCopy); } + app.onConfigurationChanged(configCopy); } Intent intent = new Intent(Intent.ACTION_CONFIGURATION_CHANGED); diff --git a/services/core/java/com/android/server/am/CoreSettingsObserver.java b/services/core/java/com/android/server/am/CoreSettingsObserver.java index 2ca134465cd6..09c152ef5135 100644 --- a/services/core/java/com/android/server/am/CoreSettingsObserver.java +++ b/services/core/java/com/android/server/am/CoreSettingsObserver.java @@ -56,10 +56,6 @@ final class CoreSettingsObserver extends ContentObserver { sGlobalSettingToTypeMap.put(Settings.Global.DEBUG_VIEW_ATTRIBUTES, int.class); sGlobalSettingToTypeMap.put(Settings.Global.ANGLE_ENABLED_APP, String.class); - sGlobalSettingToTypeMap.put(Settings.Global.ENABLE_GPU_DEBUG_LAYERS, int.class); - sGlobalSettingToTypeMap.put(Settings.Global.GPU_DEBUG_APP, String.class); - sGlobalSettingToTypeMap.put(Settings.Global.GPU_DEBUG_LAYERS, String.class); - sGlobalSettingToTypeMap.put(Settings.Global.GPU_DEBUG_LAYER_APP, String.class); // add other global settings here... } diff --git a/services/core/java/com/android/server/am/LaunchParamsController.java b/services/core/java/com/android/server/am/LaunchParamsController.java index 6415c3ee7f72..218d9080c2c0 100644 --- a/services/core/java/com/android/server/am/LaunchParamsController.java +++ b/services/core/java/com/android/server/am/LaunchParamsController.java @@ -16,6 +16,13 @@ package com.android.server.am; +import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED; +import static android.view.Display.INVALID_DISPLAY; + +import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_CONTINUE; +import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_DONE; +import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP; + import android.annotation.IntDef; import android.app.ActivityOptions; import android.content.pm.ActivityInfo.WindowLayout; @@ -26,13 +33,6 @@ import java.lang.annotation.RetentionPolicy; import java.util.ArrayList; import java.util.List; -import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED; -import static android.view.Display.INVALID_DISPLAY; - -import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_CONTINUE; -import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_DONE; -import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP; - /** * {@link LaunchParamsController} calculates the {@link LaunchParams} by coordinating between * registered {@link LaunchParamsModifier}s. @@ -58,11 +58,7 @@ class LaunchParamsController { */ void registerDefaultModifiers(ActivityStackSupervisor supervisor) { // {@link TaskLaunchParamsModifier} handles window layout preferences. - registerModifier(new TaskLaunchParamsModifier()); - - // {@link ActivityLaunchParamsModifier} is the most specific modifier and thus should be - // registered last (applied first) out of the defaults. - registerModifier(new ActivityLaunchParamsModifier(supervisor)); + registerModifier(new TaskLaunchParamsModifier(supervisor)); } /** @@ -226,27 +222,41 @@ class LaunchParamsController { @IntDef({RESULT_SKIP, RESULT_DONE, RESULT_CONTINUE}) @interface Result {} - // Returned when the modifier does not want to influence the bounds calculation + /** Returned when the modifier does not want to influence the bounds calculation */ int RESULT_SKIP = 0; - // Returned when the modifier has changed the bounds and would like its results to be the - // final bounds applied. + /** + * Returned when the modifier has changed the bounds and would like its results to be the + * final bounds applied. + */ int RESULT_DONE = 1; - // Returned when the modifier has changed the bounds but is okay with other modifiers - // influencing the bounds. + /** + * Returned when the modifier has changed the bounds but is okay with other modifiers + * influencing the bounds. + */ int RESULT_CONTINUE = 2; /** - * Called when asked to calculate {@link LaunchParams}. - * @param task The {@link TaskRecord} currently being positioned. - * @param layout The specified {@link WindowLayout}. - * @param activity The {@link ActivityRecord} currently being positioned. - * @param source The {@link ActivityRecord} activity was started from. - * @param options The {@link ActivityOptions} specified for the activity. - * @param currentParams The current {@link LaunchParams}. This can differ from the initial - * params as it represents the modified params up to this point. - * @param outParams The resulting {@link LaunchParams} after all calculations. - * @return A {@link Result} representing the result of the - * {@link LaunchParams} calculation. + * Returns the launch params that the provided activity launch params should be overridden + * to. {@link LaunchParamsModifier} can use this for various purposes, including: 1) + * Providing default bounds if the launch bounds have not been provided. 2) Repositioning + * the task so it doesn't get placed over an existing task. 3) Resizing the task so that its + * dimensions match the activity's requested orientation. + * + * @param task Can be: 1) the target task in which the source activity wants to + * launch the target activity; 2) a newly created task that Android + * gives a chance to override its launching bounds; 3) {@code null} if + * this is called to override an activity's launching bounds. + * @param layout Desired layout when activity is first launched. + * @param activity Activity that is being started. This can be {@code null} on + * re-parenting an activity to a new task (e.g. for + * Picture-In-Picture). Tasks being created because an activity was + * launched should have this be non-null. + * @param source the Activity that launched a new task. Could be {@code null}. + * @param options {@link ActivityOptions} used to start the activity with. + * @param currentParams launching params after the process of last {@link + * LaunchParamsModifier}. + * @param outParams the result params to be set. + * @return see {@link LaunchParamsModifier.Result} */ @Result int onCalculate(TaskRecord task, WindowLayout layout, ActivityRecord activity, diff --git a/services/core/java/com/android/server/am/ProcessList.java b/services/core/java/com/android/server/am/ProcessList.java index 3ac7885eba37..9e7ce3204444 100644 --- a/services/core/java/com/android/server/am/ProcessList.java +++ b/services/core/java/com/android/server/am/ProcessList.java @@ -162,9 +162,11 @@ public final class ProcessList { // LMK_TARGET <minfree> <minkillprio> ... (up to 6 pairs) // LMK_PROCPRIO <pid> <uid> <prio> // LMK_PROCREMOVE <pid> + // LMK_PROCPURGE static final byte LMK_TARGET = 0; static final byte LMK_PROCPRIO = 1; static final byte LMK_PROCREMOVE = 2; + static final byte LMK_PROCPURGE = 3; // These are the various interesting memory levels that we will give to // the OOM killer. Note that the OOM killer only supports 6 slots, so we @@ -813,31 +815,46 @@ public final class ProcessList { return true; } + // Never call directly, use writeLmkd() instead + private static boolean writeLmkdCommand(ByteBuffer buf) { + try { + sLmkdOutputStream.write(buf.array(), 0, buf.position()); + } catch (IOException ex) { + Slog.w(TAG, "Error writing to lowmemorykiller socket"); + + try { + sLmkdSocket.close(); + } catch (IOException ex2) { + } + + sLmkdSocket = null; + return false; + } + return true; + } + private static void writeLmkd(ByteBuffer buf) { for (int i = 0; i < 3; i++) { if (sLmkdSocket == null) { - if (openLmkdSocket() == false) { - try { - Thread.sleep(1000); - } catch (InterruptedException ie) { - } - continue; + if (openLmkdSocket() == false) { + try { + Thread.sleep(1000); + } catch (InterruptedException ie) { } - } - - try { - sLmkdOutputStream.write(buf.array(), 0, buf.position()); - return; - } catch (IOException ex) { - Slog.w(TAG, "Error writing to lowmemorykiller socket"); - - try { - sLmkdSocket.close(); - } catch (IOException ex2) { + continue; } - sLmkdSocket = null; + // Purge any previously registered pids + ByteBuffer purge_buf = ByteBuffer.allocate(4); + purge_buf.putInt(LMK_PROCPURGE); + if (writeLmkdCommand(purge_buf) == false) { + // Write failed, skip the rest and retry + continue; + } + } + if (writeLmkdCommand(buf)) { + return; } } } diff --git a/services/core/java/com/android/server/am/TaskLaunchParamsModifier.java b/services/core/java/com/android/server/am/TaskLaunchParamsModifier.java index 92f1cc34be92..fd34d180ebc0 100644 --- a/services/core/java/com/android/server/am/TaskLaunchParamsModifier.java +++ b/services/core/java/com/android/server/am/TaskLaunchParamsModifier.java @@ -16,304 +16,770 @@ package com.android.server.am; +import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM; +import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN; +import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED; +import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LOCKED; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_NOSENSOR; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT; +import static android.util.DisplayMetrics.DENSITY_DEFAULT; +import static android.view.Display.DEFAULT_DISPLAY; +import static android.view.Display.INVALID_DISPLAY; + import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM; import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME; +import android.annotation.NonNull; +import android.annotation.Nullable; import android.app.ActivityOptions; +import android.app.WindowConfiguration; import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; import android.graphics.Rect; +import android.os.Build; import android.util.Slog; import android.view.Gravity; -import com.android.internal.annotations.VisibleForTesting; + import com.android.server.am.LaunchParamsController.LaunchParams; import com.android.server.am.LaunchParamsController.LaunchParamsModifier; import java.util.ArrayList; +import java.util.List; /** - * Determines where a launching task should be positioned and sized on the display. - * - * The modifier is fairly simple. For the new task it tries default position based on the gravity - * and compares corners of the task with corners of existing tasks. If some two pairs of corners are - * sufficiently close enough, it shifts the bounds of the new task and tries again. When it exhausts - * all possible shifts, it gives up and puts the task in the original position. - * - * Note that the only gravities of concern are the corners and the center. + * The class that defines the default launch params for tasks. */ class TaskLaunchParamsModifier implements LaunchParamsModifier { private static final String TAG = TAG_WITH_CLASS_NAME ? "TaskLaunchParamsModifier" : TAG_AM; + private static final boolean DEBUG = false; - // Determines how close window frames/corners have to be to call them colliding. - private static final int BOUNDS_CONFLICT_MIN_DISTANCE = 4; + // A mask for SUPPORTS_SCREEN that indicates the activity supports resize. + private static final int SUPPORTS_SCREEN_RESIZEABLE_MASK = + ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES + | ApplicationInfo.FLAG_SUPPORTS_LARGE_SCREENS + | ApplicationInfo.FLAG_SUPPORTS_SMALL_SCREENS + | ApplicationInfo.FLAG_RESIZEABLE_FOR_SCREENS + | ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES + | ApplicationInfo.FLAG_SUPPORTS_XLARGE_SCREENS; - // Task will receive dimensions based on available dimensions divided by this. - private static final int WINDOW_SIZE_DENOMINATOR = 2; + // Screen size of Nexus 5x + private static final int DEFAULT_PORTRAIT_PHONE_WIDTH_DP = 412; + private static final int DEFAULT_PORTRAIT_PHONE_HEIGHT_DP = 732; - // Task will receive margins based on available dimensions divided by this. - private static final int MARGIN_SIZE_DENOMINATOR = 4; + // Allowance of size matching. + private static final int EPSILON = 2; - // If task bounds collide with some other, we will step and try again until we find a good - // position. The step will be determined by using dimensions and dividing it by this. + // Cascade window offset. + private static final int CASCADING_OFFSET_DP = 75; + + // Threshold how close window corners have to be to call them colliding. + private static final int BOUNDS_CONFLICT_THRESHOLD = 4; + + // Divide display size by this number to get each step to adjust bounds to avoid conflict. private static final int STEP_DENOMINATOR = 16; // We always want to step by at least this. private static final int MINIMAL_STEP = 1; - // Used to indicate if positioning algorithm is allowed to restart from the beginning, when it - // reaches the end of stack bounds. - private static final boolean ALLOW_RESTART = true; + private final ActivityStackSupervisor mSupervisor; + private final Rect mTmpBounds = new Rect(); + private final int[] mTmpDirections = new int[2]; - private static final int SHIFT_POLICY_DIAGONAL_DOWN = 1; - private static final int SHIFT_POLICY_HORIZONTAL_RIGHT = 2; - private static final int SHIFT_POLICY_HORIZONTAL_LEFT = 3; + private StringBuilder mLogBuilder; - private final Rect mAvailableRect = new Rect(); - private final Rect mTmpProposal = new Rect(); - private final Rect mTmpOriginal = new Rect(); + TaskLaunchParamsModifier(ActivityStackSupervisor supervisor) { + mSupervisor = supervisor; + } - /** - * Tries to set task's bound in a way that it won't collide with any other task. By colliding - * we mean that two tasks have left-top corner very close to each other, so one might get - * obfuscated by the other one. - */ @Override public int onCalculate(TaskRecord task, ActivityInfo.WindowLayout layout, ActivityRecord activity, ActivityRecord source, ActivityOptions options, LaunchParams currentParams, LaunchParams outParams) { - // We can only apply positioning if we're in a freeform stack. - if (task == null || task.getStack() == null || !task.inFreeformWindowingMode()) { - return RESULT_SKIP; - } + initLogBuilder(task, activity); + final int result = calculate(task, layout, activity, source, options, currentParams, + outParams); + outputLog(); + return result; + } - final ArrayList<TaskRecord> tasks = task.getStack().getAllTasks(); + private int calculate(TaskRecord task, ActivityInfo.WindowLayout layout, + ActivityRecord activity, ActivityRecord source, ActivityOptions options, + LaunchParams currentParams, LaunchParams outParams) { + // STEP 1: Determine the display to launch the activity/task. + final int displayId = getPreferredLaunchDisplay(options, source, currentParams); + outParams.mPreferredDisplayId = displayId; + ActivityDisplay display = mSupervisor.getActivityDisplay(displayId); + if (DEBUG) { + appendLog("display-id=" + outParams.mPreferredDisplayId + " display-windowing-mode=" + + display.getWindowingMode()); + } - mAvailableRect.set(task.getParent().getBounds()); + final ActivityRecord root; + if (task != null) { + root = (task.getRootActivity() == null ? activity : task.getRootActivity()); + } else { + root = activity; + } + // STEP 2: Resolve launch windowing mode. + // STEP 2.1: Determine if any parameter has specified initial bounds. That might be the + // launch bounds from activity options, or size/gravity passed in layout. It also treat the + // launch windowing mode in options as a suggestion for future resolution. + int launchMode = options != null ? options.getLaunchWindowingMode() + : WINDOWING_MODE_UNDEFINED; + // hasInitialBounds is set if either activity options or layout has specified bounds. If + // that's set we'll skip some adjustments later to avoid overriding the initial bounds. + boolean hasInitialBounds = false; + final boolean canApplyFreeformPolicy = + canApplyFreeformWindowPolicy(display, root, launchMode); + if (mSupervisor.canUseActivityOptionsLaunchBounds(options) && canApplyFreeformPolicy) { + hasInitialBounds = true; + launchMode = launchMode == WINDOWING_MODE_UNDEFINED + ? WINDOWING_MODE_FREEFORM + : launchMode; + outParams.mBounds.set(options.getLaunchBounds()); + if (DEBUG) appendLog("activity-options-bounds=" + outParams.mBounds); + } else if (launchMode == WINDOWING_MODE_PINNED) { + // System controls PIP window's bounds, so don't apply launch bounds. + if (DEBUG) appendLog("empty-window-layout-for-pip"); + } else if (launchMode == WINDOWING_MODE_FULLSCREEN) { + if (DEBUG) appendLog("activity-options-fullscreen=" + outParams.mBounds); + } else if (layout != null && canApplyFreeformPolicy) { + getLayoutBounds(display, root, layout, mTmpBounds); + if (!mTmpBounds.isEmpty()) { + launchMode = WINDOWING_MODE_FREEFORM; + outParams.mBounds.set(mTmpBounds); + hasInitialBounds = true; + if (DEBUG) appendLog("bounds-from-layout=" + outParams.mBounds); + } else { + if (DEBUG) appendLog("empty-window-layout"); + } + } - final Rect resultBounds = outParams.mBounds; + // STEP 2.2: Check if previous modifier or the controller (referred as "callers" below) has + // some opinions on launch mode and launch bounds. If they have opinions and there is no + // initial bounds set in parameters. Note the check on display ID is also input param + // related because we always defer to callers' suggestion if there is no specific display ID + // in options or from source activity. + // + // If opinions from callers don't need any further resolution, we try to honor that as is as + // much as possible later. + + // Flag to indicate if current param needs no further resolution. It's true it current + // param isn't freeform mode, or it already has launch bounds. + boolean fullyResolvedCurrentParam = false; + // We inherit launch params from previous modifiers or LaunchParamsController if options, + // layout and display conditions are not contradictory to their suggestions. It's important + // to carry over their values because LaunchParamsController doesn't automatically do that. + if (!currentParams.isEmpty() && !hasInitialBounds + && (!currentParams.hasPreferredDisplay() + || displayId == currentParams.mPreferredDisplayId)) { + if (currentParams.hasWindowingMode()) { + launchMode = currentParams.mWindowingMode; + fullyResolvedCurrentParam = (launchMode != WINDOWING_MODE_FREEFORM); + if (DEBUG) { + appendLog("inherit-" + WindowConfiguration.windowingModeToString(launchMode)); + } + } - if (layout == null) { - positionCenter(tasks, mAvailableRect, getFreeformWidth(mAvailableRect), - getFreeformHeight(mAvailableRect), resultBounds); - return RESULT_CONTINUE; + if (!currentParams.mBounds.isEmpty()) { + outParams.mBounds.set(currentParams.mBounds); + fullyResolvedCurrentParam = true; + if (DEBUG) appendLog("inherit-bounds=" + outParams.mBounds); + } } - int width = getFinalWidth(layout, mAvailableRect); - int height = getFinalHeight(layout, mAvailableRect); - int verticalGravity = layout.gravity & Gravity.VERTICAL_GRAVITY_MASK; - int horizontalGravity = layout.gravity & Gravity.HORIZONTAL_GRAVITY_MASK; - if (verticalGravity == Gravity.TOP) { - if (horizontalGravity == Gravity.RIGHT) { - positionTopRight(tasks, mAvailableRect, width, height, resultBounds); - } else { - positionTopLeft(tasks, mAvailableRect, width, height, resultBounds); - } - } else if (verticalGravity == Gravity.BOTTOM) { - if (horizontalGravity == Gravity.RIGHT) { - positionBottomRight(tasks, mAvailableRect, width, height, resultBounds); - } else { - positionBottomLeft(tasks, mAvailableRect, width, height, resultBounds); + // STEP 2.3: Adjust launch parameters as needed for freeform display. We enforce the policy + // that legacy (pre-D) apps and those apps that can't handle multiple screen density well + // are forced to be maximized. The rest of this step is to define the default policy when + // there is no initial bounds or a fully resolved current params from callers. Right now we + // launch all possible tasks/activities that can handle freeform into freeform mode. + if (display.inFreeformWindowingMode()) { + if (launchMode == WINDOWING_MODE_PINNED) { + if (DEBUG) appendLog("picture-in-picture"); + } else if (isTaskForcedMaximized(root)) { + // We're launching an activity that probably can't handle resizing nicely, so force + // it to be maximized even someone suggests launching it in freeform using launch + // options. + launchMode = WINDOWING_MODE_FULLSCREEN; + outParams.mBounds.setEmpty(); + if (DEBUG) appendLog("forced-maximize"); + } else if (fullyResolvedCurrentParam) { + // Don't adjust launch mode if that's inherited, except when we're launching an + // activity that should be forced to maximize. + if (DEBUG) appendLog("skip-adjustment-fully-resolved-params"); + } else if (launchMode != WINDOWING_MODE_FREEFORM + && (isNOrGreater(root) || isPreNResizeable(root))) { + // We're launching a pre-N and post-D activity that supports resizing, or a post-N + // activity. They can handle freeform nicely so launch them in freeform. + // Use undefined because we know we're in a freeform display. + launchMode = WINDOWING_MODE_UNDEFINED; + if (DEBUG) appendLog("should-be-freeform"); } } else { - // Some fancy gravity setting that we don't support yet. We just put the activity in the - // center. - Slog.w(TAG, "Received unsupported gravity: " + layout.gravity - + ", positioning in the center instead."); - positionCenter(tasks, mAvailableRect, width, height, resultBounds); + if (DEBUG) appendLog("non-freeform-display"); + } + // If launch mode matches display windowing mode, let it inherit from display. + outParams.mWindowingMode = launchMode == display.getWindowingMode() + ? WINDOWING_MODE_UNDEFINED : launchMode; + + // STEP 3: Determine final launch bounds based on resolved windowing mode and activity + // requested orientation. We set bounds to empty for fullscreen mode and keep bounds as is + // for all other windowing modes that's not freeform mode. One can read comments in + // relevant methods to further understand this step. + // + // We skip making adjustments if the params are fully resolved from previous results and + // trust that they are valid. + if (!fullyResolvedCurrentParam) { + final int resolvedMode = (launchMode != WINDOWING_MODE_UNDEFINED) ? launchMode + : display.getWindowingMode(); + if (source != null && source.inFreeformWindowingMode() + && resolvedMode == WINDOWING_MODE_FREEFORM + && outParams.mBounds.isEmpty() + && source.getDisplayId() == display.mDisplayId) { + // Set bounds to be not very far from source activity. + cascadeBounds(source.getBounds(), display, outParams.mBounds); + } + getTaskBounds(root, display, layout, resolvedMode, hasInitialBounds, outParams.mBounds); } return RESULT_CONTINUE; } - @VisibleForTesting - static int getFreeformStartLeft(Rect bounds) { - return bounds.left + bounds.width() / MARGIN_SIZE_DENOMINATOR; + private int getPreferredLaunchDisplay(@Nullable ActivityOptions options, + ActivityRecord source, LaunchParams currentParams) { + int displayId = INVALID_DISPLAY; + final int optionLaunchId = options != null ? options.getLaunchDisplayId() : INVALID_DISPLAY; + if (optionLaunchId != INVALID_DISPLAY) { + if (DEBUG) appendLog("display-from-option=" + optionLaunchId); + displayId = optionLaunchId; + } + + if (displayId == INVALID_DISPLAY && source != null) { + final int sourceDisplayId = source.getDisplayId(); + if (DEBUG) appendLog("display-from-source=" + sourceDisplayId); + displayId = sourceDisplayId; + } + + if (displayId != INVALID_DISPLAY && mSupervisor.getActivityDisplay(displayId) == null) { + displayId = INVALID_DISPLAY; + } + displayId = (displayId == INVALID_DISPLAY) ? currentParams.mPreferredDisplayId : displayId; + + displayId = (displayId == INVALID_DISPLAY) ? DEFAULT_DISPLAY : displayId; + + return displayId; + } + + private boolean canApplyFreeformWindowPolicy(@NonNull ActivityDisplay display, + @NonNull ActivityRecord root, int launchMode) { + return display.inFreeformWindowingMode() || launchMode == WINDOWING_MODE_FREEFORM + || root.isResizeable(); } - @VisibleForTesting - static int getFreeformStartTop(Rect bounds) { - return bounds.top + bounds.height() / MARGIN_SIZE_DENOMINATOR; + private void getLayoutBounds(@NonNull ActivityDisplay display, @NonNull ActivityRecord root, + @NonNull ActivityInfo.WindowLayout windowLayout, @NonNull Rect outBounds) { + final int verticalGravity = windowLayout.gravity & Gravity.VERTICAL_GRAVITY_MASK; + final int horizontalGravity = windowLayout.gravity & Gravity.HORIZONTAL_GRAVITY_MASK; + if (!windowLayout.hasSpecifiedSize() && verticalGravity == 0 && horizontalGravity == 0) { + outBounds.setEmpty(); + return; + } + + final Rect bounds = display.getBounds(); + final int defaultWidth = bounds.width(); + final int defaultHeight = bounds.height(); + + int width; + int height; + if (!windowLayout.hasSpecifiedSize()) { + outBounds.setEmpty(); + getTaskBounds(root, display, windowLayout, WINDOWING_MODE_FREEFORM, + /* hasInitialBounds */ false, outBounds); + width = outBounds.width(); + height = outBounds.height(); + } else { + width = defaultWidth; + if (windowLayout.width > 0 && windowLayout.width < defaultWidth) { + width = windowLayout.width; + } else if (windowLayout.widthFraction > 0 && windowLayout.widthFraction < 1.0f) { + width = (int) (width * windowLayout.widthFraction); + } + + height = defaultHeight; + if (windowLayout.height > 0 && windowLayout.height < defaultHeight) { + height = windowLayout.height; + } else if (windowLayout.heightFraction > 0 && windowLayout.heightFraction < 1.0f) { + height = (int) (height * windowLayout.heightFraction); + } + } + + final float fractionOfHorizontalOffset; + switch (horizontalGravity) { + case Gravity.LEFT: + fractionOfHorizontalOffset = 0f; + break; + case Gravity.RIGHT: + fractionOfHorizontalOffset = 1f; + break; + default: + fractionOfHorizontalOffset = 0.5f; + } + + final float fractionOfVerticalOffset; + switch (verticalGravity) { + case Gravity.TOP: + fractionOfVerticalOffset = 0f; + break; + case Gravity.BOTTOM: + fractionOfVerticalOffset = 1f; + break; + default: + fractionOfVerticalOffset = 0.5f; + } + + outBounds.set(0, 0, width, height); + final int xOffset = (int) (fractionOfHorizontalOffset * (defaultWidth - width)); + final int yOffset = (int) (fractionOfVerticalOffset * (defaultHeight - height)); + outBounds.offset(xOffset, yOffset); } - @VisibleForTesting - static int getFreeformWidth(Rect bounds) { - return bounds.width() / WINDOW_SIZE_DENOMINATOR; + /** + * Returns if task is forced to maximize. + * + * There are several cases where we force a task to maximize: + * 1) Root activity is targeting pre-Donut, which by default can't handle multiple screen + * densities, so resizing will likely cause issues; + * 2) Root activity doesn't declare any flag that it supports any screen density, so resizing + * may also cause issues; + * 3) Root activity is not resizeable, for which we shouldn't allow user resize it. + * + * @param root the root activity to check against. + * @return {@code true} if it should be forced to maximize; {@code false} otherwise. + */ + private boolean isTaskForcedMaximized(@NonNull ActivityRecord root) { + if (root.appInfo.targetSdkVersion < Build.VERSION_CODES.DONUT + || (root.appInfo.flags & SUPPORTS_SCREEN_RESIZEABLE_MASK) == 0) { + return true; + } + + return !root.isResizeable(); } - @VisibleForTesting - static int getFreeformHeight(Rect bounds) { - return bounds.height() / WINDOW_SIZE_DENOMINATOR; + private boolean isNOrGreater(@NonNull ActivityRecord root) { + return root.appInfo.targetSdkVersion >= Build.VERSION_CODES.N; + } + + /** + * Resolves activity requested orientation to 4 categories: + * 1) {@link ActivityInfo#SCREEN_ORIENTATION_LOCKED} indicating app wants to lock down + * orientation; + * 2) {@link ActivityInfo#SCREEN_ORIENTATION_LANDSCAPE} indicating app wants to be in landscape; + * 3) {@link ActivityInfo#SCREEN_ORIENTATION_PORTRAIT} indicating app wants to be in portrait; + * 4) {@link ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED} indicating app can handle any + * orientation. + * + * @param activity the activity to check + * @return corresponding resolved orientation value. + */ + private int resolveOrientation(@NonNull ActivityRecord activity) { + int orientation = activity.info.screenOrientation; + switch (orientation) { + case SCREEN_ORIENTATION_NOSENSOR: + case SCREEN_ORIENTATION_LOCKED: + orientation = SCREEN_ORIENTATION_LOCKED; + break; + case SCREEN_ORIENTATION_SENSOR_LANDSCAPE: + case SCREEN_ORIENTATION_REVERSE_LANDSCAPE: + case SCREEN_ORIENTATION_USER_LANDSCAPE: + case SCREEN_ORIENTATION_LANDSCAPE: + if (DEBUG) appendLog("activity-requested-landscape"); + orientation = SCREEN_ORIENTATION_LANDSCAPE; + break; + case SCREEN_ORIENTATION_SENSOR_PORTRAIT: + case SCREEN_ORIENTATION_REVERSE_PORTRAIT: + case SCREEN_ORIENTATION_USER_PORTRAIT: + case SCREEN_ORIENTATION_PORTRAIT: + if (DEBUG) appendLog("activity-requested-portrait"); + orientation = SCREEN_ORIENTATION_PORTRAIT; + break; + default: + orientation = SCREEN_ORIENTATION_UNSPECIFIED; + } + + return orientation; } - @VisibleForTesting - static int getHorizontalStep(Rect bounds) { - return Math.max(bounds.width() / STEP_DENOMINATOR, MINIMAL_STEP); + private boolean isPreNResizeable(ActivityRecord root) { + return root.appInfo.targetSdkVersion < Build.VERSION_CODES.N && root.isResizeable(); } - @VisibleForTesting - static int getVerticalStep(Rect bounds) { - return Math.max(bounds.height() / STEP_DENOMINATOR, MINIMAL_STEP); + private void cascadeBounds(@NonNull Rect srcBounds, @NonNull ActivityDisplay display, + @NonNull Rect outBounds) { + outBounds.set(srcBounds); + float density = (float) display.getConfiguration().densityDpi / DENSITY_DEFAULT; + final int defaultOffset = (int) (CASCADING_OFFSET_DP * density + 0.5f); + + display.getBounds(mTmpBounds); + final int dx = Math.min(defaultOffset, Math.max(0, mTmpBounds.right - srcBounds.right)); + final int dy = Math.min(defaultOffset, Math.max(0, mTmpBounds.bottom - srcBounds.bottom)); + outBounds.offset(dx, dy); } + private void getTaskBounds(@NonNull ActivityRecord root, @NonNull ActivityDisplay display, + @NonNull ActivityInfo.WindowLayout layout, int resolvedMode, boolean hasInitialBounds, + @NonNull Rect inOutBounds) { + if (resolvedMode == WINDOWING_MODE_FULLSCREEN) { + // We don't handle letterboxing here. Letterboxing will be handled by valid checks + // later. + inOutBounds.setEmpty(); + if (DEBUG) appendLog("maximized-bounds"); + return; + } + if (resolvedMode != WINDOWING_MODE_FREEFORM) { + // We don't apply freeform bounds adjustment to other windowing modes. + if (DEBUG) { + appendLog("skip-bounds-" + WindowConfiguration.windowingModeToString(resolvedMode)); + } + return; + } - private int getFinalWidth(ActivityInfo.WindowLayout windowLayout, Rect availableRect) { - int width = getFreeformWidth(availableRect); - if (windowLayout.width > 0) { - width = windowLayout.width; + final int orientation = resolveOrientation(root, display, inOutBounds); + if (orientation != SCREEN_ORIENTATION_PORTRAIT + && orientation != SCREEN_ORIENTATION_LANDSCAPE) { + throw new IllegalStateException( + "Orientation must be one of portrait or landscape, but it's " + + ActivityInfo.screenOrientationToString(orientation)); } - if (windowLayout.widthFraction > 0) { - width = (int) (availableRect.width() * windowLayout.widthFraction); + + // First we get the default size we want. + getDefaultFreeformSize(display, layout, orientation, mTmpBounds); + if (hasInitialBounds || sizeMatches(inOutBounds, mTmpBounds)) { + // We're here because either input parameters specified initial bounds, or the suggested + // bounds have the same size of the default freeform size. We should use the suggested + // bounds if possible -- so if app can handle the orientation we just use it, and if not + // we transpose the suggested bounds in-place. + if (orientation == orientationFromBounds(inOutBounds)) { + if (DEBUG) appendLog("freeform-size-orientation-match=" + inOutBounds); + } else { + // Meh, orientation doesn't match. Let's rotate inOutBounds in-place. + centerBounds(display, inOutBounds.height(), inOutBounds.width(), inOutBounds); + if (DEBUG) appendLog("freeform-orientation-mismatch=" + inOutBounds); + } + } else { + // We are here either because there is no suggested bounds, or the suggested bounds is + // a cascade from source activity. We should use the default freeform size and center it + // to the center of suggested bounds (or the display if no suggested bounds). The + // default size might be too big to center to source activity bounds in display, so we + // may need to move it back to the display. + centerBounds(display, mTmpBounds.width(), mTmpBounds.height(), inOutBounds); + adjustBoundsToFitInDisplay(display, inOutBounds); + if (DEBUG) appendLog("freeform-size-mismatch=" + inOutBounds); } - return width; + + // Lastly we adjust bounds to avoid conflicts with other tasks as much as possible. + adjustBoundsToAvoidConflict(display, inOutBounds); } - private int getFinalHeight(ActivityInfo.WindowLayout windowLayout, Rect availableRect) { - int height = getFreeformHeight(availableRect); - if (windowLayout.height > 0) { - height = windowLayout.height; + private int resolveOrientation(@NonNull ActivityRecord root, @NonNull ActivityDisplay display, + @NonNull Rect bounds) { + int orientation = resolveOrientation(root); + + if (orientation == SCREEN_ORIENTATION_LOCKED) { + orientation = bounds.isEmpty() ? display.getConfiguration().orientation + : orientationFromBounds(bounds); + if (DEBUG) { + appendLog(bounds.isEmpty() ? "locked-orientation-from-display=" + orientation + : "locked-orientation-from-bounds=" + bounds); + } } - if (windowLayout.heightFraction > 0) { - height = (int) (availableRect.height() * windowLayout.heightFraction); + + if (orientation == SCREEN_ORIENTATION_UNSPECIFIED) { + orientation = bounds.isEmpty() ? SCREEN_ORIENTATION_PORTRAIT + : orientationFromBounds(bounds); + if (DEBUG) { + appendLog(bounds.isEmpty() ? "default-portrait" + : "orientation-from-bounds=" + bounds); + } } - return height; - } - private void positionBottomLeft(ArrayList<TaskRecord> tasks, Rect availableRect, int width, - int height, Rect result) { - mTmpProposal.set(availableRect.left, availableRect.bottom - height, - availableRect.left + width, availableRect.bottom); - position(tasks, availableRect, mTmpProposal, !ALLOW_RESTART, SHIFT_POLICY_HORIZONTAL_RIGHT, - result); + return orientation; } - private void positionBottomRight(ArrayList<TaskRecord> tasks, Rect availableRect, int width, - int height, Rect result) { - mTmpProposal.set(availableRect.right - width, availableRect.bottom - height, - availableRect.right, availableRect.bottom); - position(tasks, availableRect, mTmpProposal, !ALLOW_RESTART, SHIFT_POLICY_HORIZONTAL_LEFT, - result); + private void getDefaultFreeformSize(@NonNull ActivityDisplay display, + @NonNull ActivityInfo.WindowLayout layout, int orientation, @NonNull Rect bounds) { + // Default size, which is letterboxing/pillarboxing in display. That's to say the large + // dimension of default size is the small dimension of display size, and the small dimension + // of default size is calculated to keep the same aspect ratio as the display's. + Rect displayBounds = display.getBounds(); + final int portraitHeight = Math.min(displayBounds.width(), displayBounds.height()); + final int otherDimension = Math.max(displayBounds.width(), displayBounds.height()); + final int portraitWidth = (portraitHeight * portraitHeight) / otherDimension; + final int defaultWidth = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? portraitHeight + : portraitWidth; + final int defaultHeight = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? portraitWidth + : portraitHeight; + + // Get window size based on Nexus 5x screen, we assume that this is enough to show content + // of activities. + final float density = (float) display.getConfiguration().densityDpi / DENSITY_DEFAULT; + final int phonePortraitWidth = (int) (DEFAULT_PORTRAIT_PHONE_WIDTH_DP * density + 0.5f); + final int phonePortraitHeight = (int) (DEFAULT_PORTRAIT_PHONE_HEIGHT_DP * density + 0.5f); + final int phoneWidth = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? phonePortraitHeight + : phonePortraitWidth; + final int phoneHeight = (orientation == SCREEN_ORIENTATION_LANDSCAPE) ? phonePortraitWidth + : phonePortraitHeight; + + // Minimum layout requirements. + final int layoutMinWidth = (layout == null) ? -1 : layout.minWidth; + final int layoutMinHeight = (layout == null) ? -1 : layout.minHeight; + + // Final result. + final int width = Math.min(defaultWidth, Math.max(phoneWidth, layoutMinWidth)); + final int height = Math.min(defaultHeight, Math.max(phoneHeight, layoutMinHeight)); + + bounds.set(0, 0, width, height); } - private void positionTopLeft(ArrayList<TaskRecord> tasks, Rect availableRect, int width, - int height, Rect result) { - mTmpProposal.set(availableRect.left, availableRect.top, - availableRect.left + width, availableRect.top + height); - position(tasks, availableRect, mTmpProposal, !ALLOW_RESTART, SHIFT_POLICY_HORIZONTAL_RIGHT, - result); + /** + * Gets centered bounds of width x height. If inOutBounds is not empty, the result bounds + * centers at its center or display's center if inOutBounds is empty. + */ + private void centerBounds(@NonNull ActivityDisplay display, int width, int height, + @NonNull Rect inOutBounds) { + if (inOutBounds.isEmpty()) { + display.getBounds(inOutBounds); + } + final int left = inOutBounds.centerX() - width / 2; + final int top = inOutBounds.centerY() - height / 2; + inOutBounds.set(left, top, left + width, top + height); } - private void positionTopRight(ArrayList<TaskRecord> tasks, Rect availableRect, int width, - int height, Rect result) { - mTmpProposal.set(availableRect.right - width, availableRect.top, - availableRect.right, availableRect.top + height); - position(tasks, availableRect, mTmpProposal, !ALLOW_RESTART, SHIFT_POLICY_HORIZONTAL_LEFT, - result); - } + private void adjustBoundsToFitInDisplay(@NonNull ActivityDisplay display, + @NonNull Rect inOutBounds) { + final Rect displayBounds = display.getBounds(); + + if (displayBounds.width() < inOutBounds.width() + || displayBounds.height() < inOutBounds.height()) { + // There is no way for us to fit the bounds in the display without changing width + // or height. Don't even try it. + return; + } + + final int dx; + if (inOutBounds.right > displayBounds.right) { + // Right edge is out of display. + dx = displayBounds.right - inOutBounds.right; + } else if (inOutBounds.left < displayBounds.left) { + // Left edge is out of display. + dx = displayBounds.left - inOutBounds.left; + } else { + // Vertical edges are all in display. + dx = 0; + } - private void positionCenter(ArrayList<TaskRecord> tasks, Rect availableRect, int width, - int height, Rect result) { - final int defaultFreeformLeft = getFreeformStartLeft(availableRect); - final int defaultFreeformTop = getFreeformStartTop(availableRect); - mTmpProposal.set(defaultFreeformLeft, defaultFreeformTop, - defaultFreeformLeft + width, defaultFreeformTop + height); - position(tasks, availableRect, mTmpProposal, ALLOW_RESTART, SHIFT_POLICY_DIAGONAL_DOWN, - result); + final int dy; + if (inOutBounds.top < displayBounds.top) { + // Top edge is out of display. + dy = displayBounds.top - inOutBounds.top; + } else if (inOutBounds.bottom > displayBounds.bottom) { + // Bottom edge is out of display. + dy = displayBounds.bottom - inOutBounds.bottom; + } else { + // Horizontal edges are all in display. + dy = 0; + } + inOutBounds.offset(dx, dy); } - private void position(ArrayList<TaskRecord> tasks, Rect availableRect, - Rect proposal, boolean allowRestart, int shiftPolicy, Rect result) { - mTmpOriginal.set(proposal); - boolean restarted = false; - while (boundsConflict(proposal, tasks)) { - // Unfortunately there is already a task at that spot, so we need to look for some - // other place. - shiftStartingPoint(proposal, availableRect, shiftPolicy); - if (shiftedTooFar(proposal, availableRect, shiftPolicy)) { - // We don't want the task to go outside of the stack, because it won't look - // nice. Depending on the starting point we either restart, or immediately give up. - if (!allowRestart) { - proposal.set(mTmpOriginal); - break; - } - // We must have started not from the top. Let's restart from there because there - // might be some space there. - proposal.set(availableRect.left, availableRect.top, - availableRect.left + proposal.width(), - availableRect.top + proposal.height()); - restarted = true; + /** + * Adjusts input bounds to avoid conflict with existing tasks in the display. + * + * If the input bounds conflict with existing tasks, this method scans the bounds in a series of + * directions to find a location where the we can put the bounds in display without conflict + * with any other tasks. + * + * It doesn't try to adjust bounds that's not fully in the given display. + * + * @param display the display which tasks are to check + * @param inOutBounds the bounds used to input initial bounds and output result bounds + */ + private void adjustBoundsToAvoidConflict(@NonNull ActivityDisplay display, + @NonNull Rect inOutBounds) { + final Rect displayBounds = display.getBounds(); + if (!displayBounds.contains(inOutBounds)) { + // The initial bounds are already out of display. The scanning algorithm below doesn't + // work so well with them. + return; + } + + final List<TaskRecord> tasksToCheck = new ArrayList<>(); + for (int i = 0; i < display.getChildCount(); ++i) { + ActivityStack<?> stack = display.getChildAt(i); + if (!stack.inFreeformWindowingMode()) { + continue; } - if (restarted && (proposal.left > getFreeformStartLeft(availableRect) - || proposal.top > getFreeformStartTop(availableRect))) { - // If we restarted and crossed the initial position, let's not struggle anymore. - // The user already must have ton of tasks visible, we can just smack the new - // one in the center. - proposal.set(mTmpOriginal); + + for (int j = 0; j < stack.getChildCount(); ++j) { + tasksToCheck.add(stack.getChildAt(j)); + } + } + + if (!boundsConflict(tasksToCheck, inOutBounds)) { + // Current proposal doesn't conflict with any task. Early return to avoid unnecessary + // calculation. + return; + } + + calculateCandidateShiftDirections(displayBounds, inOutBounds); + for (int direction : mTmpDirections) { + if (direction == Gravity.NO_GRAVITY) { + // We exhausted candidate directions, give up. break; } + + mTmpBounds.set(inOutBounds); + while (boundsConflict(tasksToCheck, mTmpBounds) && displayBounds.contains(mTmpBounds)) { + shiftBounds(direction, displayBounds, mTmpBounds); + } + + if (!boundsConflict(tasksToCheck, mTmpBounds) && displayBounds.contains(mTmpBounds)) { + // Found a candidate. Just use this. + inOutBounds.set(mTmpBounds); + if (DEBUG) appendLog("avoid-bounds-conflict=" + inOutBounds); + return; + } + + // Didn't find a conflict free bounds here. Try the next candidate direction. } - result.set(proposal); + + // We failed to find a conflict free location. Just keep the original result. } - private boolean shiftedTooFar(Rect start, Rect availableRect, int shiftPolicy) { - switch (shiftPolicy) { - case SHIFT_POLICY_HORIZONTAL_LEFT: - return start.left < availableRect.left; - case SHIFT_POLICY_HORIZONTAL_RIGHT: - return start.right > availableRect.right; - default: // SHIFT_POLICY_DIAGONAL_DOWN - return start.right > availableRect.right || start.bottom > availableRect.bottom; + /** + * Determines scanning directions and their priorities to avoid bounds conflict. + * + * @param availableBounds bounds that the result must be in + * @param initialBounds initial bounds when start scanning + */ + private void calculateCandidateShiftDirections(@NonNull Rect availableBounds, + @NonNull Rect initialBounds) { + for (int i = 0; i < mTmpDirections.length; ++i) { + mTmpDirections[i] = Gravity.NO_GRAVITY; + } + + final int oneThirdWidth = (2 * availableBounds.left + availableBounds.right) / 3; + final int twoThirdWidth = (availableBounds.left + 2 * availableBounds.right) / 3; + final int centerX = initialBounds.centerX(); + if (centerX < oneThirdWidth) { + // Too close to left, just scan to the right. + mTmpDirections[0] = Gravity.RIGHT; + return; + } else if (centerX > twoThirdWidth) { + // Too close to right, just scan to the left. + mTmpDirections[0] = Gravity.LEFT; + return; } + + final int oneThirdHeight = (2 * availableBounds.top + availableBounds.bottom) / 3; + final int twoThirdHeight = (availableBounds.top + 2 * availableBounds.bottom) / 3; + final int centerY = initialBounds.centerY(); + if (centerY < oneThirdHeight || centerY > twoThirdHeight) { + // Too close to top or bottom boundary and we're in the middle horizontally, scan + // horizontally in both directions. + mTmpDirections[0] = Gravity.RIGHT; + mTmpDirections[1] = Gravity.LEFT; + return; + } + + // We're in the center region both horizontally and vertically. Scan in both directions of + // primary diagonal. + mTmpDirections[0] = Gravity.BOTTOM | Gravity.RIGHT; + mTmpDirections[1] = Gravity.TOP | Gravity.LEFT; } - private void shiftStartingPoint(Rect posposal, Rect availableRect, int shiftPolicy) { - final int defaultFreeformStepHorizontal = getHorizontalStep(availableRect); - final int defaultFreeformStepVertical = getVerticalStep(availableRect); + private boolean boundsConflict(@NonNull List<TaskRecord> tasks, @NonNull Rect bounds) { + for (TaskRecord task : tasks) { + final Rect taskBounds = task.getBounds(); + final boolean leftClose = Math.abs(taskBounds.left - bounds.left) + < BOUNDS_CONFLICT_THRESHOLD; + final boolean topClose = Math.abs(taskBounds.top - bounds.top) + < BOUNDS_CONFLICT_THRESHOLD; + final boolean rightClose = Math.abs(taskBounds.right - bounds.right) + < BOUNDS_CONFLICT_THRESHOLD; + final boolean bottomClose = Math.abs(taskBounds.bottom - bounds.bottom) + < BOUNDS_CONFLICT_THRESHOLD; + + if ((leftClose && topClose) || (leftClose && bottomClose) || (rightClose && topClose) + || (rightClose && bottomClose)) { + return true; + } + } + + return false; + } - switch (shiftPolicy) { - case SHIFT_POLICY_HORIZONTAL_LEFT: - posposal.offset(-defaultFreeformStepHorizontal, 0); + private void shiftBounds(int direction, @NonNull Rect availableRect, + @NonNull Rect inOutBounds) { + final int horizontalOffset; + switch (direction & Gravity.HORIZONTAL_GRAVITY_MASK) { + case Gravity.LEFT: + horizontalOffset = -Math.max(MINIMAL_STEP, + availableRect.width() / STEP_DENOMINATOR); break; - case SHIFT_POLICY_HORIZONTAL_RIGHT: - posposal.offset(defaultFreeformStepHorizontal, 0); + case Gravity.RIGHT: + horizontalOffset = Math.max(MINIMAL_STEP, availableRect.width() / STEP_DENOMINATOR); break; - default: // SHIFT_POLICY_DIAGONAL_DOWN: - posposal.offset(defaultFreeformStepHorizontal, defaultFreeformStepVertical); + default: + horizontalOffset = 0; + } + + final int verticalOffset; + switch (direction & Gravity.VERTICAL_GRAVITY_MASK) { + case Gravity.TOP: + verticalOffset = -Math.max(MINIMAL_STEP, availableRect.height() / STEP_DENOMINATOR); break; + case Gravity.BOTTOM: + verticalOffset = Math.max(MINIMAL_STEP, availableRect.height() / STEP_DENOMINATOR); + break; + default: + verticalOffset = 0; } + + inOutBounds.offset(horizontalOffset, verticalOffset); } - private static boolean boundsConflict(Rect proposal, ArrayList<TaskRecord> tasks) { - for (int i = tasks.size() - 1; i >= 0; i--) { - final TaskRecord task = tasks.get(i); - if (!task.mActivities.isEmpty() && !task.matchParentBounds()) { - final Rect bounds = task.getOverrideBounds(); - if (closeLeftTopCorner(proposal, bounds) || closeRightTopCorner(proposal, bounds) - || closeLeftBottomCorner(proposal, bounds) - || closeRightBottomCorner(proposal, bounds)) { - return true; - } - } + private void initLogBuilder(TaskRecord task, ActivityRecord activity) { + if (DEBUG) { + mLogBuilder = new StringBuilder("TaskLaunchParamsModifier:task=" + task + + " activity=" + activity); } - return false; } - private static final boolean closeLeftTopCorner(Rect first, Rect second) { - return Math.abs(first.left - second.left) < BOUNDS_CONFLICT_MIN_DISTANCE - && Math.abs(first.top - second.top) < BOUNDS_CONFLICT_MIN_DISTANCE; + private void appendLog(String log) { + if (DEBUG) mLogBuilder.append(" ").append(log); } - private static final boolean closeRightTopCorner(Rect first, Rect second) { - return Math.abs(first.right - second.right) < BOUNDS_CONFLICT_MIN_DISTANCE - && Math.abs(first.top - second.top) < BOUNDS_CONFLICT_MIN_DISTANCE; + private void outputLog() { + if (DEBUG) Slog.d(TAG, mLogBuilder.toString()); } - private static final boolean closeLeftBottomCorner(Rect first, Rect second) { - return Math.abs(first.left - second.left) < BOUNDS_CONFLICT_MIN_DISTANCE - && Math.abs(first.bottom - second.bottom) < BOUNDS_CONFLICT_MIN_DISTANCE; + private static int orientationFromBounds(Rect bounds) { + return bounds.width() > bounds.height() ? SCREEN_ORIENTATION_LANDSCAPE + : SCREEN_ORIENTATION_PORTRAIT; } - private static final boolean closeRightBottomCorner(Rect first, Rect second) { - return Math.abs(first.right - second.right) < BOUNDS_CONFLICT_MIN_DISTANCE - && Math.abs(first.bottom - second.bottom) < BOUNDS_CONFLICT_MIN_DISTANCE; + private static boolean sizeMatches(Rect left, Rect right) { + return (Math.abs(right.width() - left.width()) < EPSILON) + && (Math.abs(right.height() - left.height()) < EPSILON); } } diff --git a/services/core/java/com/android/server/pm/LauncherAppsService.java b/services/core/java/com/android/server/pm/LauncherAppsService.java index 93230401eb20..a08c189cb125 100644 --- a/services/core/java/com/android/server/pm/LauncherAppsService.java +++ b/services/core/java/com/android/server/pm/LauncherAppsService.java @@ -20,6 +20,7 @@ import android.annotation.NonNull; import android.annotation.UserIdInt; import android.app.ActivityManager; import android.app.ActivityManagerInternal; +import android.app.AppDetailsActivity; import android.app.AppGlobals; import android.app.IApplicationThread; import android.app.PendingIntent; @@ -65,7 +66,9 @@ import com.android.server.LocalServices; import com.android.server.SystemService; import com.android.server.wm.ActivityTaskManagerInternal; +import java.util.ArrayList; import java.util.Collections; +import java.util.HashSet; import java.util.List; /** @@ -74,6 +77,7 @@ import java.util.List; */ public class LauncherAppsService extends SystemService { + private static final boolean SHOW_HIDDEN_APP_ENABLED = false; private final LauncherAppsImpl mLauncherAppsImpl; public LauncherAppsService(Context context) { @@ -281,15 +285,84 @@ public class LauncherAppsService extends SystemService { } } + private ResolveInfo getHiddenAppActivityInfo(String packageName, int callingUid, + UserHandle user) { + Intent intent = new Intent(); + intent.setComponent(new ComponentName(packageName, AppDetailsActivity.class.getName())); + final PackageManagerInternal pmInt = + LocalServices.getService(PackageManagerInternal.class); + List<ResolveInfo> apps = pmInt.queryIntentActivities(intent, + PackageManager.MATCH_DIRECT_BOOT_AWARE + | PackageManager.MATCH_DIRECT_BOOT_UNAWARE, + callingUid, user.getIdentifier()); + if (apps.size() > 0) { + return apps.get(0); + } + return null; + } + @Override public ParceledListSlice<ResolveInfo> getLauncherActivities(String callingPackage, - String packageName, UserHandle user) - throws RemoteException { - return queryActivitiesForUser(callingPackage, + String packageName, UserHandle user) throws RemoteException { + ParceledListSlice<ResolveInfo> launcherActivities = queryActivitiesForUser( + callingPackage, new Intent(Intent.ACTION_MAIN) .addCategory(Intent.CATEGORY_LAUNCHER) .setPackage(packageName), user); + if (!SHOW_HIDDEN_APP_ENABLED) { + return launcherActivities; + } + + final int callingUid = injectBinderCallingUid(); + final ArrayList<ResolveInfo> result = new ArrayList<>(launcherActivities.getList()); + if (packageName != null) { + // If target package has launcher activities, then return those launcher + // activities. Otherwise, return hidden activity that forwards user to app + // details page. + if (result.size() > 0) { + return launcherActivities; + } + ResolveInfo info = getHiddenAppActivityInfo(packageName, callingUid, user); + if (info != null) { + result.add(info); + } + return new ParceledListSlice<>(result); + } + + long ident = injectClearCallingIdentity(); + try { + final HashSet<String> visiblePackages = new HashSet<>(); + for (ResolveInfo info : result) { + visiblePackages.add(info.activityInfo.packageName); + } + final PackageManagerInternal pmInt = + LocalServices.getService(PackageManagerInternal.class); + List<ApplicationInfo> installedPackages = pmInt.getInstalledApplications(0, + user.getIdentifier(), callingUid); + for (ApplicationInfo applicationInfo : installedPackages) { + if (!visiblePackages.contains(applicationInfo.packageName)) { + if (!shouldShowHiddenApp(applicationInfo)) { + continue; + } + ResolveInfo info = getHiddenAppActivityInfo(applicationInfo.packageName, + callingUid, user); + if (info != null) { + result.add(info); + } + } + } + return new ParceledListSlice<>(result); + } finally { + injectRestoreCallingIdentity(ident); + } + } + + private static boolean shouldShowHiddenApp(ApplicationInfo appInfo) { + if (appInfo.isSystemApp() || appInfo.isUpdatedSystemApp()) { + return false; + } + return true; } @Override diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java index 13f084e67494..3528b86b05f4 100644 --- a/services/core/java/com/android/server/pm/PackageManagerService.java +++ b/services/core/java/com/android/server/pm/PackageManagerService.java @@ -121,6 +121,7 @@ import android.annotation.Nullable; import android.annotation.UserIdInt; import android.app.ActivityManager; import android.app.ActivityManagerInternal; +import android.app.AppDetailsActivity; import android.app.AppOpsManager; import android.app.IActivityManager; import android.app.ResourcesManager; @@ -2920,7 +2921,7 @@ public class PackageManagerService extends IPackageManager.Stub for (int splitPermNum = 0; splitPermNum < numSplitPerms; splitPermNum++) { final PermissionManager.SplitPermissionInfo splitPerm = splitPermissions.get(splitPermNum); - final String rootPerm = splitPerm.getRootPermission(); + final String rootPerm = splitPerm.getSplitPermission(); if (preUpgradeSdkVersion >= splitPerm.getTargetSdk()) { continue; @@ -2942,11 +2943,11 @@ public class PackageManagerService extends IPackageManager.Stub continue; } - final String[] newPerms = splitPerm.getNewPermissions(); + final List<String> newPerms = splitPerm.getNewPermissions(); - final int numNewPerms = newPerms.length; + final int numNewPerms = newPerms.size(); for (int newPermNum = 0; newPermNum < numNewPerms; newPermNum++) { - final String newPerm = newPerms[newPermNum]; + final String newPerm = newPerms.get(newPermNum); if (checkPermission(newPerm, pkgName, userId) == PERMISSION_GRANTED) { continue; } @@ -7869,10 +7870,16 @@ public class PackageManagerService extends IPackageManager.Stub @Override public ParceledListSlice<ApplicationInfo> getInstalledApplications(int flags, int userId) { final int callingUid = Binder.getCallingUid(); + return new ParceledListSlice<>( + getInstalledApplicationsListInternal(flags, userId, callingUid)); + } + + private List<ApplicationInfo> getInstalledApplicationsListInternal(int flags, int userId, + int callingUid) { if (getInstantAppPackageName(callingUid) != null) { - return ParceledListSlice.emptyList(); + return Collections.emptyList(); } - if (!sUserManager.exists(userId)) return ParceledListSlice.emptyList(); + if (!sUserManager.exists(userId)) return Collections.emptyList(); flags = updateFlagsForApplication(flags, userId, null); final boolean listUninstalled = (flags & MATCH_KNOWN_PACKAGES) != 0; @@ -7937,7 +7944,7 @@ public class PackageManagerService extends IPackageManager.Stub } } - return new ParceledListSlice<>(list); + return list; } } @@ -12150,7 +12157,9 @@ public class PackageManagerService extends IPackageManager.Stub if (mPackageListObservers.size() == 0) { return; } - observers = (PackageListObserver[]) mPackageListObservers.toArray(); + final PackageListObserver[] observerArray = + new PackageListObserver[mPackageListObservers.size()]; + observers = mPackageListObservers.toArray(observerArray); } for (int i = observers.length - 1; i >= 0; --i) { observers[i].onPackageAdded(packageName); @@ -12170,7 +12179,9 @@ public class PackageManagerService extends IPackageManager.Stub if (mPackageListObservers.size() == 0) { return; } - observers = (PackageListObserver[]) mPackageListObservers.toArray(); + final PackageListObserver[] observerArray = + new PackageListObserver[mPackageListObservers.size()]; + observers = mPackageListObservers.toArray(observerArray); } for (int i = observers.length - 1; i >= 0; --i) { observers[i].onPackageRemoved(packageName); @@ -19388,6 +19399,16 @@ public class PackageManagerService extends IPackageManager.Stub throw new SecurityException("Cannot disable a protected package: " + packageName); } } + // Only allow apps with CHANGE_COMPONENT_ENABLED_STATE permission to change hidden + // app details activity + if (AppDetailsActivity.class.getName().equals(className)) { + if (mContext.checkCallingOrSelfPermission( + android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE) + != PackageManager.PERMISSION_GRANTED) { + Slog.e(TAG, "Cannot disable a protected component: " + packageName); + return; + } + } synchronized (mPackages) { if (callingUid == Process.SHELL_UID @@ -22283,6 +22304,14 @@ public class PackageManagerService extends IPackageManager.Stub } @Override + public List<ApplicationInfo> getInstalledApplications(int flags, int userId, + int callingUid) { + return PackageManagerService.this.getInstalledApplicationsListInternal(flags, userId, + callingUid); + } + + + @Override public boolean isPlatformSigned(String packageName) { PackageSetting packageSetting = mSettings.mPackages.get(packageName); if (packageSetting == null) { diff --git a/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java b/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java index 6f644dd70339..0a93653ede56 100644 --- a/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java +++ b/services/core/java/com/android/server/pm/permission/DefaultPermissionGrantPolicy.java @@ -1033,8 +1033,8 @@ public final class DefaultPermissionGrantPolicy { if (applicationInfo != null && applicationInfo.targetSdkVersion < splitPerm.getTargetSdk() - && permissionsWithoutSplits.contains(splitPerm.getRootPermission())) { - Collections.addAll(permissions, splitPerm.getNewPermissions()); + && permissionsWithoutSplits.contains(splitPerm.getSplitPermission())) { + permissions.addAll(splitPerm.getNewPermissions()); } } diff --git a/services/core/java/com/android/server/policy/PhoneWindowManager.java b/services/core/java/com/android/server/policy/PhoneWindowManager.java index 21bf488f828c..06ee935818b3 100644 --- a/services/core/java/com/android/server/policy/PhoneWindowManager.java +++ b/services/core/java/com/android/server/policy/PhoneWindowManager.java @@ -6046,6 +6046,19 @@ public class PhoneWindowManager implements WindowManagerPolicy { } } + // Intercept the Accessibility keychord (CTRL + ALT + Z) for keyboard users. + if (mAccessibilityShortcutController.isAccessibilityShortcutAvailable(isKeyguardLocked())) { + switch (keyCode) { + case KeyEvent.KEYCODE_Z: { + if (down && event.isCtrlPressed() && event.isAltPressed()) { + mHandler.sendMessage(mHandler.obtainMessage(MSG_ACCESSIBILITY_SHORTCUT)); + result &= ~ACTION_PASS_TO_USER; + } + break; + } + } + } + if (useHapticFeedback) { performHapticFeedbackLw(null, HapticFeedbackConstants.VIRTUAL_KEY, false, "Virtual Key - Press"); diff --git a/services/core/java/com/android/server/stats/StatsCompanionService.java b/services/core/java/com/android/server/stats/StatsCompanionService.java index 1abaaf2412bf..6ca4f2e49d0a 100644 --- a/services/core/java/com/android/server/stats/StatsCompanionService.java +++ b/services/core/java/com/android/server/stats/StatsCompanionService.java @@ -1056,6 +1056,11 @@ public class StatsCompanionService extends IStatsCompanionService.Stub { e.writeLong(entry.totalLatencyMicros); e.writeLong(entry.cpuUsageMicros); e.writeBoolean(entry.isInteractive); + e.writeLong(entry.maxCpuUsageMicros); + e.writeLong(entry.maxLatencyMicros); + e.writeLong(entry.recordedDelayMessageCount); + e.writeLong(entry.delayMillis); + e.writeLong(entry.maxDelayMillis); pulledData.add(e); } } diff --git a/services/core/java/com/android/server/textclassifier/TextClassificationManagerService.java b/services/core/java/com/android/server/textclassifier/TextClassificationManagerService.java index d36ab3f09399..5ce8145fa00e 100644 --- a/services/core/java/com/android/server/textclassifier/TextClassificationManagerService.java +++ b/services/core/java/com/android/server/textclassifier/TextClassificationManagerService.java @@ -28,7 +28,6 @@ import android.os.Binder; import android.os.IBinder; import android.os.RemoteException; import android.os.UserHandle; -import android.provider.Settings; import android.service.textclassifier.ITextClassificationCallback; import android.service.textclassifier.ITextClassifierService; import android.service.textclassifier.ITextLinksCallback; @@ -41,7 +40,6 @@ import android.view.textclassifier.TextClassification; import android.view.textclassifier.TextClassificationContext; import android.view.textclassifier.TextClassificationManager; import android.view.textclassifier.TextClassificationSessionId; -import android.view.textclassifier.TextClassifier; import android.view.textclassifier.TextLinks; import android.view.textclassifier.TextSelection; @@ -275,6 +273,20 @@ public final class TextClassificationManagerService extends ITextClassifierServi IndentingPrintWriter pw = new IndentingPrintWriter(fout, " "); TextClassificationManager tcm = mContext.getSystemService(TextClassificationManager.class); tcm.dump(pw); + + pw.printPair("context", mContext); pw.println(); + synchronized (mLock) { + int size = mUserStates.size(); + pw.print("Number user states: "); pw.println(size); + if (size > 0) { + for (int i = 0; i < size; i++) { + pw.increaseIndent(); + UserState userState = mUserStates.valueAt(i); + pw.print(i); pw.print(":"); userState.dump(pw); pw.println(); + pw.decreaseIndent(); + } + } + } } private static final class PendingRequest implements IBinder.DeathRecipient { @@ -431,6 +443,15 @@ public final class TextClassificationManagerService extends ITextClassifierServi return willBind; } + private void dump(IndentingPrintWriter pw) { + pw.printPair("context", mContext); + pw.printPair("userId", mUserId); + synchronized (mLock) { + pw.printPair("binding", mBinding); + pw.printPair("numberRequests", mPendingRequests.size()); + } + } + private final class TextClassifierServiceConnection implements ServiceConnection { @Override public void onServiceConnected(ComponentName name, IBinder service) { diff --git a/services/core/java/com/android/server/wm/AppWindowToken.java b/services/core/java/com/android/server/wm/AppWindowToken.java index e57fea31f1a8..e38e22909957 100644 --- a/services/core/java/com/android/server/wm/AppWindowToken.java +++ b/services/core/java/com/android/server/wm/AppWindowToken.java @@ -102,6 +102,7 @@ import android.view.WindowManager.LayoutParams; import android.view.animation.Animation; import com.android.internal.R; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.util.ToBooleanFunction; import com.android.server.input.InputApplicationHandle; import com.android.server.policy.WindowManagerPolicy.StartingSurface; @@ -1741,6 +1742,30 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree return boundsLayer; } + /** Get position and crop region of animation. */ + @VisibleForTesting + void getAnimationBounds(Point outPosition, Rect outBounds) { + outPosition.set(0, 0); + outBounds.setEmpty(); + + final TaskStack stack = getStack(); + final Task task = getTask(); + if (task != null && task.inFreeformWindowingMode()) { + task.getRelativePosition(outPosition); + } else if (stack != null) { + stack.getRelativePosition(outPosition); + } + + // Always use stack bounds in order to have the ability to animate outside the task region. + // It also needs to be consistent when {@link #mNeedsAnimationBoundsLayer} is set that crops + // according to the bounds. + if (stack != null) { + stack.getBounds(outBounds); + } + // We have the relative position so the local position can be removed from bounds. + outBounds.offsetTo(0, 0); + } + boolean applyAnimationLocked(WindowManager.LayoutParams lp, int transit, boolean enter, boolean isVoiceInteraction) { @@ -1759,14 +1784,7 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "AWT#applyAnimationLocked"); if (okToAnimate()) { final AnimationAdapter adapter; - final TaskStack stack = getStack(); - mTmpPoint.set(0, 0); - mTmpRect.setEmpty(); - if (stack != null) { - stack.getRelativePosition(mTmpPoint); - stack.getBounds(mTmpRect); - mTmpRect.offsetTo(0, 0); - } + getAnimationBounds(mTmpPoint, mTmpRect); // Delaying animation start isn't compatible with remote animations at all. if (mService.mAppTransition.getRemoteAnimationController() != null diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java index 10ba63e0a9f7..14ea04073c66 100644 --- a/services/core/java/com/android/server/wm/WindowManagerService.java +++ b/services/core/java/com/android/server/wm/WindowManagerService.java @@ -45,8 +45,8 @@ import static android.view.WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHA import static android.view.WindowManager.LayoutParams.LAST_APPLICATION_WINDOW; import static android.view.WindowManager.LayoutParams.LAST_SUB_WINDOW; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW; -import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_IS_ROUNDED_CORNERS_OVERLAY; +import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; import static android.view.WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY; import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING; import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER; @@ -1928,7 +1928,7 @@ public class WindowManagerService extends IWindowManager.Stub mAccessibilityController.onSomeWindowResizedOrMovedLocked(); } - if ((flagChanges & PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS) != 0) { + if ((flagChanges & SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS) != 0) { updateNonSystemOverlayWindowsVisibilityIfNeeded( win, win.mWinAnimator.getShown()); } diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java index 8276952d8a6c..eacbda198aba 100644 --- a/services/core/java/com/android/server/wm/WindowState.java +++ b/services/core/java/com/android/server/wm/WindowState.java @@ -46,12 +46,12 @@ import static android.view.WindowManager.LayoutParams.LAST_SUB_WINDOW; import static android.view.WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS; import static android.view.WindowManager.LayoutParams.MATCH_PARENT; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW; -import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_LAYOUT_CHILD_WINDOW_IN_PARENT_FRAME; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_NO_MOVE_ANIMATION; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_WILL_NOT_REPLACE_ON_RELAUNCH; import static android.view.WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE; import static android.view.WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST; +import static android.view.WindowManager.LayoutParams.SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS; import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION; import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA; import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY; @@ -3470,7 +3470,7 @@ class WindowState extends WindowContainer<WindowState> implements WindowManagerP * this window is visible. */ boolean hideNonSystemOverlayWindowsWhenVisible() { - return (mAttrs.privateFlags & PRIVATE_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS) != 0 + return (mAttrs.privateFlags & SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS) != 0 && mSession.mCanHideNonSystemOverlayWindows; } diff --git a/services/net/java/android/net/ip/IpNeighborMonitor.java b/services/net/java/android/net/ip/IpNeighborMonitor.java index fc07aa1ecd17..9512f1be66ef 100644 --- a/services/net/java/android/net/ip/IpNeighborMonitor.java +++ b/services/net/java/android/net/ip/IpNeighborMonitor.java @@ -40,7 +40,6 @@ import android.util.Log; import com.android.internal.util.BitUtils; import libcore.io.IoUtils; -import libcore.io.Libcore; import java.io.FileDescriptor; import java.net.InetAddress; diff --git a/services/net/java/android/net/netlink/NetlinkSocket.java b/services/net/java/android/net/netlink/NetlinkSocket.java index cfcba3a84f51..40098c1532b1 100644 --- a/services/net/java/android/net/netlink/NetlinkSocket.java +++ b/services/net/java/android/net/netlink/NetlinkSocket.java @@ -32,7 +32,6 @@ import android.system.Os; import android.system.StructTimeval; import android.util.Log; import libcore.io.IoUtils; -import libcore.io.Libcore; import java.io.FileDescriptor; import java.io.InterruptedIOException; diff --git a/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java b/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java index fb57d68082a2..7a847f3284d2 100644 --- a/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java +++ b/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java @@ -726,6 +726,39 @@ public class KeyValueBackupTaskTest { } @Test + public void testRunTask_whenSecondAgentUnavailable_commitsFirstAgentState() throws Exception { + TransportMock transportMock = setUpInitializedTransport(mTransport); + AgentMock agentMock = setUpAgent(PACKAGE_1); + setUpAgent(PACKAGE_2.unavailable()); + agentOnBackupDo( + agentMock, + (oldState, dataOutput, newState) -> { + writeData(dataOutput, "key", "data".getBytes()); + writeState(newState, "newState".getBytes()); + }); + KeyValueBackupTask task = createKeyValueBackupTask(transportMock, PACKAGE_1, PACKAGE_2); + + runTask(task); + + assertThat(Files.readAllBytes(getStateFile(mTransport, PACKAGE_1))).isEqualTo( + "newState".getBytes()); + } + + @Test + public void testRunTask_whenNonIncrementalAndAgentUnavailable() throws Exception { + TransportMock transportMock = setUpInitializedTransport(mTransport); + setUpAgent(PACKAGE_1.unavailable()); + KeyValueBackupTask task = createKeyValueBackupTask(transportMock, true, PACKAGE_1); + + runTask(task); + + verify(mBackupManagerService).setWorkSource(null); + verify(mObserver).onResult(PACKAGE_1.packageName, ERROR_AGENT_FAILURE); + verify(mObserver).backupFinished(BackupManager.SUCCESS); + assertBackupPendingFor(PACKAGE_1); + } + + @Test public void testRunTask_whenBindToAgentThrowsSecurityException() throws Exception { TransportMock transportMock = setUpInitializedTransport(mTransport); setUpAgent(PACKAGE_1); @@ -743,6 +776,23 @@ public class KeyValueBackupTaskTest { } @Test + public void testRunTask_whenNonIncrementalAndBindToAgentThrowsSecurityException() throws Exception { + TransportMock transportMock = setUpInitializedTransport(mTransport); + setUpAgent(PACKAGE_1); + doThrow(SecurityException.class) + .when(mBackupManagerService) + .bindToAgentSynchronous(argThat(applicationInfo(PACKAGE_1)), anyInt()); + KeyValueBackupTask task = createKeyValueBackupTask(transportMock, true, PACKAGE_1); + + runTask(task); + + verify(mBackupManagerService).setWorkSource(null); + verify(mObserver).onResult(PACKAGE_1.packageName, ERROR_AGENT_FAILURE); + verify(mObserver).backupFinished(BackupManager.SUCCESS); + assertBackupPendingFor(PACKAGE_1); + } + + @Test public void testRunTask_whenTransportGetBackupQuotaThrows_notifiesCorrectly() throws Exception { TransportMock transportMock = setUpInitializedTransport(mTransport); when(transportMock.transport.getBackupQuota(PACKAGE_1.packageName, false)) diff --git a/services/tests/servicestests/src/com/android/server/am/ActivityLaunchParamsModifierTests.java b/services/tests/servicestests/src/com/android/server/am/ActivityLaunchParamsModifierTests.java deleted file mode 100644 index 9de64f2cf211..000000000000 --- a/services/tests/servicestests/src/com/android/server/am/ActivityLaunchParamsModifierTests.java +++ /dev/null @@ -1,144 +0,0 @@ -/* - * Copyright (C) 2017 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License - */ - -package com.android.server.am; - -import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD; -import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN; - -import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_DONE; -import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_SKIP; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -import android.app.ActivityOptions; -import android.content.pm.ActivityInfo; -import android.graphics.Rect; -import android.platform.test.annotations.Presubmit; - -import androidx.test.filters.MediumTest; -import androidx.test.runner.AndroidJUnit4; - -import com.android.server.am.LaunchParamsController.LaunchParams; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; - -/** - * Tests for exercising resizing bounds due to activity options. - * - * Build/Install/Run: - * atest FrameworksServicesTests:ActivityLaunchParamsModifierTests - */ -@MediumTest -@Presubmit -@RunWith(AndroidJUnit4.class) -public class ActivityLaunchParamsModifierTests extends ActivityTestsBase { - private ActivityLaunchParamsModifier mModifier; - private ActivityTaskManagerService mService; - private ActivityStack mStack; - private TaskRecord mTask; - private ActivityRecord mActivity; - - private LaunchParams mCurrent; - private LaunchParams mResult; - - @Before - @Override - public void setUp() throws Exception { - super.setUp(); - mService = createActivityTaskManagerService(); - mModifier = new ActivityLaunchParamsModifier(mService.mStackSupervisor); - mCurrent = new LaunchParams(); - mResult = new LaunchParams(); - - - mStack = mService.mStackSupervisor.getDefaultDisplay().createStack( - WINDOWING_MODE_FULLSCREEN, ACTIVITY_TYPE_STANDARD, true /* onTop */); - mTask = new TaskBuilder(mService.mStackSupervisor).setStack(mStack).build(); - mActivity = new ActivityBuilder(mService).setTask(mTask).build(); - } - - - @Test - public void testSkippedInvocations() throws Exception { - // No specified activity should be ignored - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - null /*activity*/, null /*source*/, null /*options*/, mCurrent, mResult)); - - // No specified activity options should be ignored - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, null /*options*/, mCurrent, mResult)); - - // launch bounds specified should be ignored. - final ActivityOptions options = ActivityOptions.makeBasic(); - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - - // Non-resizeable records should be ignored - mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_UNRESIZEABLE; - assertFalse(mActivity.isResizeable()); - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - - // make record resizeable - mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_RESIZEABLE; - assertTrue(mActivity.isResizeable()); - - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - - // Does not support freeform - mService.mSupportsFreeformWindowManagement = false; - assertFalse(mService.mStackSupervisor.canUseActivityOptionsLaunchBounds(options)); - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - - mService.mSupportsFreeformWindowManagement = true; - options.setLaunchBounds(new Rect()); - assertTrue(mService.mStackSupervisor.canUseActivityOptionsLaunchBounds(options)); - - // Invalid bounds - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - options.setLaunchBounds(new Rect(0, 0, -1, -1)); - assertEquals(RESULT_SKIP, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - - // Valid bounds should cause the positioner to be applied. - options.setLaunchBounds(new Rect(0, 0, 100, 100)); - assertEquals(RESULT_DONE, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - } - - @Test - public void testBoundsExtraction() throws Exception { - // Make activity resizeable and enable freeform mode. - mActivity.info.resizeMode = ActivityInfo.RESIZE_MODE_RESIZEABLE; - mService.mSupportsFreeformWindowManagement = true; - - ActivityOptions options = ActivityOptions.makeBasic(); - final Rect proposedBounds = new Rect(20, 30, 45, 40); - options.setLaunchBounds(proposedBounds); - - assertEquals(RESULT_DONE, mModifier.onCalculate(null /*task*/, null /*layout*/, - mActivity, null /*source*/, options /*options*/, mCurrent, mResult)); - assertEquals(mResult.mBounds, proposedBounds); - } -} diff --git a/services/tests/servicestests/src/com/android/server/am/TaskLaunchParamsModifierTests.java b/services/tests/servicestests/src/com/android/server/am/TaskLaunchParamsModifierTests.java index f5b8f78cfd53..0d1302f78316 100644 --- a/services/tests/servicestests/src/com/android/server/am/TaskLaunchParamsModifierTests.java +++ b/services/tests/servicestests/src/com/android/server/am/TaskLaunchParamsModifierTests.java @@ -11,239 +11,1098 @@ * 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 + * limitations under the License. */ package com.android.server.am; import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD; import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM; +import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN; +import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED; +import static android.app.WindowConfiguration.WINDOWING_MODE_UNDEFINED; +import static android.content.pm.ActivityInfo.RESIZE_MODE_UNRESIZEABLE; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LOCKED; +import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; +import static android.util.DisplayMetrics.DENSITY_DEFAULT; +import static android.view.Display.DEFAULT_DISPLAY; import static com.android.server.am.LaunchParamsController.LaunchParamsModifier.RESULT_CONTINUE; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.when; -import android.content.pm.ActivityInfo.WindowLayout; +import android.app.ActivityOptions; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.res.Configuration; import android.graphics.Rect; +import android.os.Build; import android.platform.test.annotations.Presubmit; import android.view.Gravity; -import androidx.test.filters.MediumTest; +import androidx.test.filters.SmallTest; +import androidx.test.filters.FlakyTest; import androidx.test.runner.AndroidJUnit4; +import com.android.server.am.LaunchParamsController.LaunchParams; + import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import java.util.Locale; + /** - * Tests for exercising resizing task bounds. + * Tests for default task bounds. * * Build/Install/Run: * atest FrameworksServicesTests:TaskLaunchParamsModifierTests */ -@MediumTest +@SmallTest @Presubmit @RunWith(AndroidJUnit4.class) +@FlakyTest(detail = "Confirm stable in post-submit before removing") public class TaskLaunchParamsModifierTests extends ActivityTestsBase { - private final static int STACK_WIDTH = 100; - private final static int STACK_HEIGHT = 200; - - private final static Rect STACK_BOUNDS = new Rect(0, 0, STACK_WIDTH, STACK_HEIGHT); - private ActivityTaskManagerService mService; - private ActivityStack mStack; - private TaskRecord mTask; + private ActivityRecord mActivity; - private TaskLaunchParamsModifier mPositioner; + private TaskLaunchParamsModifier mTarget; - private LaunchParamsController.LaunchParams mCurrent; - private LaunchParamsController.LaunchParams mResult; + private LaunchParams mCurrent; + private LaunchParams mResult; @Before @Override public void setUp() throws Exception { super.setUp(); - mService = createActivityTaskManagerService(); - mStack = mService.mStackSupervisor.getDefaultDisplay().createStack( - WINDOWING_MODE_FREEFORM, ACTIVITY_TYPE_STANDARD, true /* onTop */); - mStack.requestResize(STACK_BOUNDS); + setupActivityTaskManagerService(); + mService.mSupportsFreeformWindowManagement = true; + when(mSupervisor.canUseActivityOptionsLaunchBounds(any())).thenCallRealMethod(); + + mActivity = new ActivityBuilder(mService).build(); + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.N_MR1; + mActivity.info.applicationInfo.flags |= ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES; + + mTarget = new TaskLaunchParamsModifier(mSupervisor); + + mCurrent = new LaunchParams(); + mCurrent.reset(); + mResult = new LaunchParams(); + mResult.reset(); + } - // We must create the task after resizing to make sure it does not inherit the stack - // dimensions on resize. - mTask = new TaskBuilder(mService.mStackSupervisor).setStack(mStack).build(); + // ============================= + // Display ID Related Tests + // ============================= + @Test + public void testDefaultToPrimaryDisplay() { + createNewActivityDisplay(WINDOWING_MODE_FREEFORM); - mPositioner = new TaskLaunchParamsModifier(); + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); - mResult = new LaunchParamsController.LaunchParams(); - mCurrent = new LaunchParamsController.LaunchParams(); + assertEquals(DEFAULT_DISPLAY, mResult.mPreferredDisplayId); } - /** - * Ensures that the setup bounds are set as expected with the stack bounds set and the task - * bounds still {@code null}. - * @throws Exception - */ @Test - public void testInitialBounds() throws Exception { - assertEquals(mStack.getOverrideBounds(), STACK_BOUNDS); - assertEquals(mTask.getOverrideBounds(), new Rect()); + public void testUsesPreviousDisplayIdIfSet() { + createNewActivityDisplay(WINDOWING_MODE_FREEFORM); + final TestActivityDisplay display = createNewActivityDisplay(WINDOWING_MODE_FULLSCREEN); + + mCurrent.mPreferredDisplayId = display.mDisplayId; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(display.mDisplayId, mResult.mPreferredDisplayId); } - /** - * Ensures that a task positioned with no {@link WindowLayout} receives the default launch - * position. - * @throws Exception - */ @Test - public void testLaunchNoWindowLayout() throws Exception { - assertEquals(RESULT_CONTINUE, mPositioner.onCalculate(mTask, null /*layout*/, - null /*record*/, null /*source*/, null /*options*/, mCurrent, mResult)); - assertEquals(getDefaultBounds(Gravity.NO_GRAVITY), mResult.mBounds); + public void testUsesSourcesDisplayIdIfSet() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + final TestActivityDisplay fullscreenDisplay = createNewActivityDisplay( + WINDOWING_MODE_FULLSCREEN); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + ActivityRecord source = createSourceActivity(fullscreenDisplay); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, source, /* options */ null, mCurrent, mResult)); + + assertEquals(fullscreenDisplay.mDisplayId, mResult.mPreferredDisplayId); } - /** - * Ensures that a task positioned with an empty {@link WindowLayout} receives the default launch - * position. - * @throws Exception - */ @Test - public void testlaunchEmptyWindowLayout() throws Exception { - assertEquals(RESULT_CONTINUE, mPositioner.onCalculate(mTask, - new WindowLayout(0, 0, 0, 0, Gravity.NO_GRAVITY, 0, 0), null /*activity*/, - null /*source*/, null /*options*/, mCurrent, mResult)); - assertEquals(mResult.mBounds, getDefaultBounds(Gravity.NO_GRAVITY)); + public void testUsesOptionsDisplayIdIfSet() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + final TestActivityDisplay fullscreenDisplay = createNewActivityDisplay( + WINDOWING_MODE_FULLSCREEN); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + ActivityRecord source = createSourceActivity(freeformDisplay); + + ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(fullscreenDisplay.mDisplayId); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, source, options, mCurrent, mResult)); + + assertEquals(fullscreenDisplay.mDisplayId, mResult.mPreferredDisplayId); } - /** - * Ensures that a task positioned with a {@link WindowLayout} gravity specified is positioned - * according to specification. - * @throws Exception - */ + // ===================================== + // Launch Windowing Mode Related Tests + // ===================================== @Test - public void testlaunchWindowLayoutGravity() throws Exception { - // Unspecified gravity should be ignored - testGravity(Gravity.NO_GRAVITY); + public void testBoundsInOptionsInfersFreeformOnFreeformDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchBounds(new Rect(0, 0, 100, 100)); - // Unsupported gravity should be ignored - testGravity(Gravity.LEFT); - testGravity(Gravity.RIGHT); + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; - // Test defaults for vertical gravities - testGravity(Gravity.TOP); - testGravity(Gravity.BOTTOM); + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); - // Test corners - testGravity(Gravity.TOP | Gravity.LEFT); - testGravity(Gravity.TOP | Gravity.RIGHT); - testGravity(Gravity.BOTTOM | Gravity.LEFT); - testGravity(Gravity.BOTTOM | Gravity.RIGHT); + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); } - private void testGravity(int gravity) { - try { - assertEquals(RESULT_CONTINUE, mPositioner.onCalculate(mTask, - new WindowLayout(0, 0, 0, 0, gravity, 0, 0), null /*activity*/, - null /*source*/, null /*options*/, mCurrent, mResult)); - assertEquals(mResult.mBounds, getDefaultBounds(gravity)); - } finally { - mCurrent.reset(); - mResult.reset(); - } + @Test + public void testBoundsInOptionsInfersFreeformWithResizeableActivity() { + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchBounds(new Rect(0, 0, 100, 100)); + + mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FULLSCREEN); + } + + @Test + public void testKeepsPictureInPictureLaunchModeInOptions() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_PINNED); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_PINNED, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testKeepsPictureInPictureLaunchModeWithBoundsInOptions() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_PINNED); + options.setLaunchBounds(new Rect(0, 0, 100, 100)); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_PINNED, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testKeepsFullscreenLaunchModeInOptionsOnNonFreeformDisplay() { + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_FULLSCREEN); + + mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode, + WINDOWING_MODE_FULLSCREEN); + } + + @Test + public void testNonEmptyLayoutInfersFreeformOnFreeformDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testNonEmptyLayoutInfersFreeformWithEmptySize() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setGravity(Gravity.LEFT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testNonEmptyLayoutInfersFreeformWithResizeableActivity() { + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).build(); + + mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FULLSCREEN); + } + + @Test + public void testRespectsFullyResolvedCurrentParam_Fullscreen() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mWindowingMode = WINDOWING_MODE_FULLSCREEN; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testRespectsModeFromFullyResolvedCurrentParam_NonEmptyBounds() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; + mCurrent.mBounds.set(0, 0, 200, 100); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testForceMaximizesPreDApp() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM); + options.setLaunchBounds(new Rect(0, 0, 200, 100)); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; + mCurrent.mBounds.set(0, 0, 200, 100); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.CUPCAKE; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testForceMaximizesAppWithoutMultipleDensitySupport() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM); + options.setLaunchBounds(new Rect(0, 0, 200, 100)); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; + mCurrent.mBounds.set(0, 0, 200, 100); + + mActivity.appInfo.flags = 0; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testForceMaximizesUnresizeableApp() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM); + options.setLaunchBounds(new Rect(0, 0, 200, 100)); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; + mCurrent.mBounds.set(0, 0, 200, 100); + + mActivity.info.resizeMode = RESIZE_MODE_UNRESIZEABLE; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testSkipsForceMaximizingAppsOnNonFreeformDisplay() { + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_FREEFORM); + options.setLaunchBounds(new Rect(0, 0, 200, 100)); + + mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; + mCurrent.mBounds.set(0, 0, 200, 100); + + mActivity.info.resizeMode = RESIZE_MODE_UNRESIZEABLE; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FULLSCREEN); + } + + @Test + public void testUsesFullscreenOnNonFreeformDisplay() { + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(DEFAULT_DISPLAY); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode, + WINDOWING_MODE_FULLSCREEN); + } + + @Test + public void testUsesFreeformByDefaultForPostNApp() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testUsesFreeformByDefaultForPreNResizeableAppWithoutOrientationRequest() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FREEFORM, mResult.mWindowingMode, + WINDOWING_MODE_FREEFORM); + } + + @Test + public void testSkipsFreeformForPreNResizeableAppOnNonFullscreenDisplay() { + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(DEFAULT_DISPLAY); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquivalentWindowingMode(WINDOWING_MODE_FULLSCREEN, mResult.mWindowingMode, + WINDOWING_MODE_FULLSCREEN); + } + + // ================================ + // Launching Bounds Related Tests + // =============================== + @Test + public void testKeepsBoundsWithPictureInPictureLaunchModeInOptions() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchWindowingMode(WINDOWING_MODE_PINNED); + + final Rect expected = new Rect(0, 0, 100, 100); + options.setLaunchBounds(expected); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(expected, mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsRespectsGravityWithEmptySize_LeftGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setGravity(Gravity.LEFT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(0, mResult.mBounds.left); + } + + @Test + public void testNonEmptyLayoutBoundsRespectsGravityWithEmptySize_TopGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setGravity(Gravity.TOP).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(0, mResult.mBounds.top); + } + + @Test + public void testNonEmptyLayoutBoundsRespectsGravityWithEmptySize_TopLeftGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setGravity(Gravity.TOP | Gravity.LEFT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(0, mResult.mBounds.left); + assertEquals(0, mResult.mBounds.top); + } + + @Test + public void testNonEmptyLayoutBoundsRespectsGravityWithEmptySize_RightGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setGravity(Gravity.RIGHT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(1920, mResult.mBounds.right); + } + + @Test + public void testNonEmptyLayoutBoundsRespectsGravityWithEmptySize_BottomGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setGravity(Gravity.BOTTOM).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(1080, mResult.mBounds.bottom); + } + + @Test + public void testNonEmptyLayoutBoundsRespectsGravityWithEmptySize_BottomRightGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setGravity(Gravity.BOTTOM | Gravity.RIGHT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(1920, mResult.mBounds.right); + assertEquals(1080, mResult.mBounds.bottom); + } + + @Test + public void testNonEmptyLayoutBoundsOnFreeformDisplay_CenterToDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(900, 500, 1020, 580), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsOnFreeformDisplay_LeftGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).setGravity(Gravity.LEFT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(0, 500, 120, 580), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsOnFreeformDisplay_TopGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).setGravity(Gravity.TOP).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(900, 0, 1020, 80), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsOnFreeformDisplay_TopLeftGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).setGravity(Gravity.TOP | Gravity.LEFT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(0, 0, 120, 80), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsOnFreeformDisplay_RightGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).setGravity(Gravity.RIGHT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(1800, 500, 1920, 580), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsOnFreeformDisplay_BottomGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).setGravity(Gravity.BOTTOM).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(900, 1000, 1020, 1080), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsOnFreeformDisplay_RightBottomGravity() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).setGravity(Gravity.BOTTOM | Gravity.RIGHT).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(1800, 1000, 1920, 1080), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutFractionBoundsOnFreeformDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidthFraction(0.0625f).setHeightFraction(0.1f).build(); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(900, 486, 1020, 594), mResult.mBounds); + } + + @Test + public void testNonEmptyLayoutBoundsWithResizeableActivity() { + final ActivityDisplay display = mSupervisor.getActivityDisplay(DEFAULT_DISPLAY); + display.setBounds(new Rect(0, 0, 1920, 1080)); + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setWidth(120).setHeight(80).build(); + + mCurrent.mPreferredDisplayId = DEFAULT_DISPLAY; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(900, 500, 1020, 580), mResult.mBounds); + } + + @Test + public void testRespectBoundsFromFullyResolvedCurrentParam_NonEmptyBounds() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + mCurrent.mPreferredDisplayId = freeformDisplay.mDisplayId; + mCurrent.mWindowingMode = WINDOWING_MODE_FREEFORM; + mCurrent.mBounds.set(0, 0, 200, 100); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, /* options */ null, mCurrent, mResult)); + + assertEquals(new Rect(0, 0, 200, 100), mResult.mBounds); + } + + @Test + public void testDefaultSizeSmallerThanBigScreen() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + final int resultWidth = mResult.mBounds.width(); + final int displayWidth = freeformDisplay.getBounds().width(); + assertTrue("Result width " + resultWidth + " is not smaller than " + displayWidth, + resultWidth < displayWidth); + + final int resultHeight = mResult.mBounds.height(); + final int displayHeight = freeformDisplay.getBounds().height(); + assertTrue("Result width " + resultHeight + " is not smaller than " + + displayHeight, resultHeight < displayHeight); + } + + @Test + public void testDefaultFreeformSizeCenteredToDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + final Rect displayBounds = freeformDisplay.getBounds(); + assertEquals("Distance to left and right should be equal.", + mResult.mBounds.left - displayBounds.left, + displayBounds.right - mResult.mBounds.right); + assertEquals("Distance to top and bottom should be equal.", + mResult.mBounds.top - displayBounds.top, + displayBounds.bottom - mResult.mBounds.bottom); + } + + @Test + public void testCascadesToSourceSizeForFreeform() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + final ActivityRecord source = createSourceActivity(freeformDisplay); + source.setBounds(0, 0, 412, 732); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, source, options, mCurrent, mResult)); + + final Rect displayBounds = freeformDisplay.getBounds(); + assertTrue("Left bounds should be larger than 0.", mResult.mBounds.left > 0); + assertTrue("Top bounds should be larger than 0.", mResult.mBounds.top > 0); + assertTrue("Bounds should be centered at somewhere in the left half, but it's " + + "centerX is " + mResult.mBounds.centerX(), + mResult.mBounds.centerX() < displayBounds.centerX()); + assertTrue("Bounds should be centered at somewhere in the top half, but it's " + + "centerY is " + mResult.mBounds.centerY(), + mResult.mBounds.centerY() < displayBounds.centerY()); + } + + @Test + public void testAdjustBoundsToFitDisplay_TopLeftOutOfDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + final ActivityRecord source = createSourceActivity(freeformDisplay); + source.setBounds(0, 0, 200, 400); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, source, options, mCurrent, mResult)); + + final Rect displayBounds = freeformDisplay.getBounds(); + assertTrue("display bounds doesn't contain result. display bounds: " + + displayBounds + " result: " + mResult.mBounds, + displayBounds.contains(mResult.mBounds)); + } + + @Test + public void testAdjustBoundsToFitDisplay_BottomRightOutOfDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + final ActivityRecord source = createSourceActivity(freeformDisplay); + source.setBounds(1720, 680, 1920, 1080); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, source, options, mCurrent, mResult)); + + final Rect displayBounds = freeformDisplay.getBounds(); + assertTrue("display bounds doesn't contain result. display bounds: " + + displayBounds + " result: " + mResult.mBounds, + displayBounds.contains(mResult.mBounds)); + } + + @Test + public void testAdjustBoundsToFitDisplay_LargerThanDisplay() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + Configuration overrideConfig = new Configuration(); + overrideConfig.setTo(mSupervisor.getOverrideConfiguration()); + overrideConfig.setLayoutDirection(new Locale("ar")); + mSupervisor.onConfigurationChanged(overrideConfig); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + final ActivityRecord source = createSourceActivity(freeformDisplay); + source.setBounds(1720, 680, 1920, 1080); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, source, options, mCurrent, mResult)); + + final Rect displayBounds = freeformDisplay.getBounds(); + assertTrue("display bounds doesn't contain result. display bounds: " + + displayBounds + " result: " + mResult.mBounds, + displayBounds.contains(mResult.mBounds)); } - /** - * Ensures that a task which causes a conflict with another task when positioned is adjusted as - * expected. - * @throws Exception - */ - @Test - public void testLaunchWindowCenterConflict() throws Exception { - testConflict(Gravity.NO_GRAVITY); - testConflict(Gravity.TOP); - testConflict(Gravity.BOTTOM); - testConflict(Gravity.TOP | Gravity.LEFT); - testConflict(Gravity.TOP | Gravity.RIGHT); - testConflict(Gravity.BOTTOM | Gravity.LEFT); - testConflict(Gravity.BOTTOM | Gravity.RIGHT); - } - - private void testConflict(int gravity) { - final WindowLayout layout = new WindowLayout(0, 0, 0, 0, gravity, 0, 0); - - // layout first task - mService.mStackSupervisor.getLaunchParamsController().layoutTask(mTask, layout); - - // Second task will be laid out on top of the first so starting bounds is the same. - final Rect expectedBounds = new Rect(mTask.getOverrideBounds()); - - ActivityRecord activity = null; - TaskRecord secondTask = null; - - // wrap with try/finally to ensure cleanup of activity/stack. - try { - // empty tasks are ignored in conflicts - activity = new ActivityBuilder(mService).setTask(mTask).build(); - - // Create secondary task - secondTask = new TaskBuilder(mService.mStackSupervisor).setStack(mStack).build(); - - // layout second task - assertEquals(RESULT_CONTINUE, - mPositioner.onCalculate(secondTask, layout, null /*activity*/, - null /*source*/, null /*options*/, mCurrent, mResult)); - - if ((gravity & (Gravity.TOP | Gravity.RIGHT)) == (Gravity.TOP | Gravity.RIGHT) - || (gravity & (Gravity.BOTTOM | Gravity.RIGHT)) - == (Gravity.BOTTOM | Gravity.RIGHT)) { - expectedBounds.offset(-TaskLaunchParamsModifier.getHorizontalStep( - mStack.getOverrideBounds()), 0); - } else if ((gravity & Gravity.TOP) == Gravity.TOP - || (gravity & Gravity.BOTTOM) == Gravity.BOTTOM) { - expectedBounds.offset( - TaskLaunchParamsModifier.getHorizontalStep(mStack.getOverrideBounds()), 0); - } else { - expectedBounds.offset( - TaskLaunchParamsModifier.getHorizontalStep(mStack.getOverrideBounds()), - TaskLaunchParamsModifier.getVerticalStep(mStack.getOverrideBounds())); - } - - assertEquals(mResult.mBounds, expectedBounds); - } finally { - // Remove task and activity to prevent influencing future tests - if (activity != null) { - mTask.removeActivity(activity); - } - - if (secondTask != null) { - mStack.removeTask(secondTask, "cleanup", ActivityStack.REMOVE_TASK_MODE_DESTROYING); - } + @Test + public void testRespectsLayoutMinDimensions() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + + final ActivityInfo.WindowLayout layout = new WindowLayoutBuilder() + .setMinWidth(500).setMinHeight(800).build(); + + mActivity.appInfo.targetSdkVersion = Build.VERSION_CODES.LOLLIPOP; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, layout, mActivity, + /* source */ null, options, mCurrent, mResult)); + + assertEquals(500, mResult.mBounds.width()); + assertEquals(800, mResult.mBounds.height()); + } + + @Test + public void testRotatesInPlaceInitialBoundsMismatchOrientation() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + options.setLaunchBounds(new Rect(100, 100, 500, 300)); + + mActivity.info.screenOrientation = SCREEN_ORIENTATION_PORTRAIT; + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(new Rect(200, 0, 400, 400), mResult.mBounds); + } + + @Test + public void testShiftsToRightForCloseToLeftBoundsWhenConflict() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + addFreeformTaskTo(freeformDisplay, new Rect(50, 50, 100, 150)); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + options.setLaunchBounds(new Rect(50, 50, 500, 300)); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(new Rect(170, 50, 620, 300), mResult.mBounds); + } + + @Test + public void testShiftsToLeftForCloseToRightBoundsWhenConflict() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + addFreeformTaskTo(freeformDisplay, new Rect(1720, 50, 1830, 150)); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + options.setLaunchBounds(new Rect(1720, 50, 1850, 300)); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(new Rect(1600, 50, 1730, 300), mResult.mBounds); + } + + @Test + public void testShiftsToRightFirstForHorizontallyCenteredAndCloseToTopWhenConflict() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + addFreeformTaskTo(freeformDisplay, new Rect(0, 0, 100, 300)); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + options.setLaunchBounds(new Rect(0, 0, 1800, 200)); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(new Rect(120, 0, 1920, 200), mResult.mBounds); + } + + @Test + public void testShiftsToLeftNoSpaceOnRightForHorizontallyCenteredAndCloseToTopWhenConflict() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + addFreeformTaskTo(freeformDisplay, new Rect(120, 0, 240, 300)); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + options.setLaunchBounds(new Rect(120, 0, 1860, 200)); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(new Rect(0, 0, 1740, 200), mResult.mBounds); + } + + @Test + public void testShiftsToBottomRightFirstForCenteredBoundsWhenConflict() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + addFreeformTaskTo(freeformDisplay, new Rect(120, 0, 240, 100)); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + options.setLaunchBounds(new Rect(120, 0, 1800, 1013)); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(new Rect(240, 67, 1920, 1080), mResult.mBounds); + } + + @Test + public void testShiftsToTopLeftIfNoSpaceOnBottomRightForCenteredBoundsWhenConflict() { + final TestActivityDisplay freeformDisplay = createNewActivityDisplay( + WINDOWING_MODE_FREEFORM); + + addFreeformTaskTo(freeformDisplay, new Rect(120, 67, 240, 100)); + + final ActivityOptions options = ActivityOptions.makeBasic(); + options.setLaunchDisplayId(freeformDisplay.mDisplayId); + options.setLaunchBounds(new Rect(120, 67, 1800, 1020)); + + assertEquals(RESULT_CONTINUE, mTarget.onCalculate(/* task */ null, /* layout */ null, + mActivity, /* source */ null, options, mCurrent, mResult)); + + assertEquals(new Rect(0, 0, 1680, + 953), mResult.mBounds); + } + + private TestActivityDisplay createNewActivityDisplay(int windowingMode) { + final TestActivityDisplay display = addNewActivityDisplayAt(ActivityDisplay.POSITION_TOP); + display.setWindowingMode(windowingMode); + display.setBounds(/* left */ 0, /* top */ 0, /* right */ 1920, /* bottom */ 1080); + display.getConfiguration().densityDpi = DENSITY_DEFAULT; + return display; + } + + private ActivityRecord createSourceActivity(TestActivityDisplay display) { + final TestActivityStack stack = display.createStack(display.getWindowingMode(), + ACTIVITY_TYPE_STANDARD, true); + return new ActivityBuilder(mService).setStack(stack).setCreateTask(true).build(); + } + + private void addFreeformTaskTo(TestActivityDisplay display, Rect bounds) { + final TestActivityStack stack = display.createStack(display.getWindowingMode(), + ACTIVITY_TYPE_STANDARD, true); + stack.setWindowingMode(WINDOWING_MODE_FREEFORM); + final TaskRecord task = new TaskBuilder(mSupervisor).setStack(stack).build(); + task.setBounds(bounds); + } + + private void assertEquivalentWindowingMode(int expected, int actual, int parentWindowingMode) { + if (expected != parentWindowingMode) { + assertEquals(expected, actual); + } else { + assertEquals(WINDOWING_MODE_UNDEFINED, actual); } } - private Rect getDefaultBounds(int gravity) { - final Rect bounds = new Rect(); - bounds.set(mStack.getOverrideBounds()); + private static class WindowLayoutBuilder { + private int mWidth = -1; + private int mHeight = -1; + private float mWidthFraction = -1f; + private float mHeightFraction = -1f; + private int mGravity = Gravity.NO_GRAVITY; + private int mMinWidth = -1; + private int mMinHeight = -1; - final int verticalInset = - TaskLaunchParamsModifier.getFreeformStartTop(mStack.getOverrideBounds()); - final int horizontalInset = - TaskLaunchParamsModifier.getFreeformStartLeft(mStack.getOverrideBounds()); + private WindowLayoutBuilder setWidth(int width) { + mWidth = width; + return this; + } + + private WindowLayoutBuilder setHeight(int height) { + mHeight = height; + return this; + } - bounds.inset(horizontalInset, verticalInset); + private WindowLayoutBuilder setWidthFraction(float widthFraction) { + mWidthFraction = widthFraction; + return this; + } + + private WindowLayoutBuilder setHeightFraction(float heightFraction) { + mHeightFraction = heightFraction; + return this; + } - if ((gravity & (Gravity.TOP | Gravity.RIGHT)) == (Gravity.TOP | Gravity.RIGHT)) { - bounds.offsetTo(horizontalInset * 2, 0); - } else if ((gravity & Gravity.TOP) == Gravity.TOP) { - bounds.offsetTo(0, 0); - } else if ((gravity & (Gravity.BOTTOM | Gravity.RIGHT)) - == (Gravity.BOTTOM | Gravity.RIGHT)) { - bounds.offsetTo(horizontalInset * 2, verticalInset * 2); - } else if ((gravity & Gravity.BOTTOM) == Gravity.BOTTOM) { - bounds.offsetTo(0, verticalInset * 2); + private WindowLayoutBuilder setGravity(int gravity) { + mGravity = gravity; + return this; } - return bounds; + private WindowLayoutBuilder setMinWidth(int minWidth) { + mMinWidth = minWidth; + return this; + } + + private WindowLayoutBuilder setMinHeight(int minHeight) { + mMinHeight = minHeight; + return this; + } + + private ActivityInfo.WindowLayout build() { + return new ActivityInfo.WindowLayout(mWidth, mWidthFraction, mHeight, mHeightFraction, + mGravity, mMinWidth, mMinHeight); + } } } diff --git a/services/tests/servicestests/src/com/android/server/wm/AppWindowTokenTests.java b/services/tests/servicestests/src/com/android/server/wm/AppWindowTokenTests.java index 6d31dfbb8186..7935ec168142 100644 --- a/services/tests/servicestests/src/com/android/server/wm/AppWindowTokenTests.java +++ b/services/tests/servicestests/src/com/android/server/wm/AppWindowTokenTests.java @@ -16,6 +16,8 @@ package com.android.server.wm; +import static android.app.WindowConfiguration.WINDOWING_MODE_FREEFORM; +import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY; import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_BEHIND; import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE; import static android.content.pm.ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE; @@ -33,10 +35,12 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.anyInt; +import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; +import android.graphics.Point; +import android.graphics.Rect; import android.platform.test.annotations.Presubmit; import android.view.Surface; import android.view.WindowManager; @@ -255,4 +259,30 @@ public class AppWindowTokenTests extends WindowTestsBase { closingWindow.removeIfPossible(); assertTrue(closingWindow.mRemoved); } + + @Test + public void testTransitionAnimationPositionAndBounds() { + final Rect stackBounds = new Rect( + 0/* left */, 0 /* top */, 1000 /* right */, 1000 /* bottom */); + final Rect taskBounds = new Rect( + 100/* left */, 200 /* top */, 600 /* right */, 600 /* bottom */); + mStack.setBounds(stackBounds); + mTask.setBounds(taskBounds); + + mTask.setWindowingMode(WINDOWING_MODE_FREEFORM); + assertTransitionAnimationPositionAndBounds(taskBounds.left, taskBounds.top, stackBounds); + + mTask.setWindowingMode(WINDOWING_MODE_SPLIT_SCREEN_SECONDARY); + assertTransitionAnimationPositionAndBounds(stackBounds.left, stackBounds.top, stackBounds); + } + + private void assertTransitionAnimationPositionAndBounds(int expectedX, int expectedY, + Rect expectedBounds) { + final Point outPosition = new Point(); + final Rect outBounds = new Rect(); + mToken.getAnimationBounds(outPosition, outBounds); + assertEquals(expectedX, outPosition.x); + assertEquals(expectedY, outPosition.y); + assertEquals(expectedBounds, outBounds); + } } diff --git a/telephony/java/android/provider/Telephony.java b/telephony/java/android/provider/Telephony.java index 4846092286ba..8454d12ac317 100644 --- a/telephony/java/android/provider/Telephony.java +++ b/telephony/java/android/provider/Telephony.java @@ -3289,7 +3289,6 @@ public final class Telephony { 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_DATA_ROAMING_FROM_REGISTRATION, state.getDataRoamingFromRegistration()); values.put(IS_USING_CARRIER_AGGREGATION, state.isUsingCarrierAggregation()); return values; } diff --git a/telephony/java/android/telephony/NetworkRegistrationState.java b/telephony/java/android/telephony/NetworkRegistrationState.java index c3931557feb3..b312f8478413 100644 --- a/telephony/java/android/telephony/NetworkRegistrationState.java +++ b/telephony/java/android/telephony/NetworkRegistrationState.java @@ -95,6 +95,13 @@ public class NetworkRegistrationState implements Parcelable { @RegState private final int mRegState; + /** + * Save the {@link ServiceState.RoamingType roaming type}. it can be overridden roaming type + * from resource overlay or carrier config. + */ + @ServiceState.RoamingType + private int mRoamingType; + private final int mAccessNetworkTechnology; private final int mRejectCause; @@ -140,6 +147,8 @@ public class NetworkRegistrationState implements Parcelable { mDomain = domain; mTransportType = transportType; mRegState = regState; + mRoamingType = (regState == REG_STATE_ROAMING) + ? ServiceState.ROAMING_TYPE_UNKNOWN : ServiceState.ROAMING_TYPE_NOT_ROAMING; mAccessNetworkTechnology = accessNetworkTechnology; mRejectCause = rejectCause; mAvailableServices = availableServices; @@ -182,6 +191,7 @@ public class NetworkRegistrationState implements Parcelable { mDomain = source.readInt(); mTransportType = source.readInt(); mRegState = source.readInt(); + mRoamingType = source.readInt(); mAccessNetworkTechnology = source.readInt(); mRejectCause = source.readInt(); mEmergencyOnly = source.readBoolean(); @@ -211,6 +221,31 @@ public class NetworkRegistrationState implements Parcelable { } /** + * @return {@code true} if registered on roaming network, {@code false} otherwise. + */ + public boolean isRoaming() { + return mRoamingType != ServiceState.ROAMING_TYPE_NOT_ROAMING; + } + + /** + * Set {@link ServiceState.RoamingType roaming type}. This could override + * roaming type based on resource overlay or carrier config. + * @hide + */ + public void setRoamingType(@ServiceState.RoamingType int roamingType) { + mRoamingType = roamingType; + } + + /** + * @return {@link ServiceState.RoamingType roaming type}. This could return + * overridden roaming type based on resource overlay or carrier config. + * @hide + */ + public @ServiceState.RoamingType int getRoamingType() { + return mRoamingType; + } + + /** * @return Whether emergency is enabled. */ public boolean isEmergencyEnabled() { return mEmergencyOnly; } @@ -280,6 +315,7 @@ public class NetworkRegistrationState implements Parcelable { .append(" domain=").append((mDomain == DOMAIN_CS) ? "CS" : "PS") .append("transportType=").append(mTransportType) .append(" regState=").append(regStateToString(mRegState)) + .append(" roamingType=").append(mRoamingType) .append(" accessNetworkTechnology=") .append(TelephonyManager.getNetworkTypeName(mAccessNetworkTechnology)) .append(" rejectCause=").append(mRejectCause) @@ -293,9 +329,9 @@ public class NetworkRegistrationState implements Parcelable { @Override public int hashCode() { - return Objects.hash(mDomain, mTransportType, mRegState, mAccessNetworkTechnology, - mRejectCause, mEmergencyOnly, mAvailableServices, mCellIdentity, - mVoiceSpecificStates, mDataSpecificStates); + return Objects.hash(mDomain, mTransportType, mRegState, mRoamingType, + mAccessNetworkTechnology, mRejectCause, mEmergencyOnly, mAvailableServices, + mCellIdentity, mVoiceSpecificStates, mDataSpecificStates); } @Override @@ -310,6 +346,7 @@ public class NetworkRegistrationState implements Parcelable { return mDomain == other.mDomain && mTransportType == other.mTransportType && mRegState == other.mRegState + && mRoamingType == other.mRoamingType && mAccessNetworkTechnology == other.mAccessNetworkTechnology && mRejectCause == other.mRejectCause && mEmergencyOnly == other.mEmergencyOnly @@ -325,6 +362,7 @@ public class NetworkRegistrationState implements Parcelable { dest.writeInt(mDomain); dest.writeInt(mTransportType); dest.writeInt(mRegState); + dest.writeInt(mRoamingType); dest.writeInt(mAccessNetworkTechnology); dest.writeInt(mRejectCause); dest.writeBoolean(mEmergencyOnly); diff --git a/telephony/java/android/telephony/ServiceState.java b/telephony/java/android/telephony/ServiceState.java index 60e103aa62e0..e0ec2c50ab5b 100644 --- a/telephony/java/android/telephony/ServiceState.java +++ b/telephony/java/android/telephony/ServiceState.java @@ -20,6 +20,7 @@ import android.annotation.IntDef; import android.annotation.SystemApi; import android.annotation.TestApi; import android.annotation.UnsupportedAppUsage; +import android.content.Intent; import android.os.Bundle; import android.os.Parcel; import android.os.Parcelable; @@ -200,6 +201,15 @@ public class ServiceState implements Parcelable { private int mVoiceRegState = STATE_OUT_OF_SERVICE; private int mDataRegState = STATE_OUT_OF_SERVICE; + /** @hide */ + @Retention(RetentionPolicy.SOURCE) + @IntDef(prefix = { "ROAMING_TYPE_" }, value = { + ROAMING_TYPE_NOT_ROAMING, + ROAMING_TYPE_UNKNOWN, + ROAMING_TYPE_DOMESTIC, + ROAMING_TYPE_INTERNATIONAL + }) + public @interface RoamingType {} /** * Roaming type * HOME : in home network @@ -230,8 +240,6 @@ public class ServiceState implements Parcelable { */ public static final int UNKNOWN_ID = -1; - private int mVoiceRoamingType; - private int mDataRoamingType; private String mVoiceOperatorAlphaLong; private String mVoiceOperatorAlphaShort; private String mVoiceOperatorNumeric; @@ -261,8 +269,6 @@ public class ServiceState implements Parcelable { @UnsupportedAppUsage private int mCdmaEriIconMode; - private boolean mIsDataRoamingFromRegistration; - @UnsupportedAppUsage private boolean mIsUsingCarrierAggregation; @@ -334,8 +340,6 @@ public class ServiceState implements Parcelable { protected void copyFrom(ServiceState s) { mVoiceRegState = s.mVoiceRegState; mDataRegState = s.mDataRegState; - mVoiceRoamingType = s.mVoiceRoamingType; - mDataRoamingType = s.mDataRoamingType; mVoiceOperatorAlphaLong = s.mVoiceOperatorAlphaLong; mVoiceOperatorAlphaShort = s.mVoiceOperatorAlphaShort; mVoiceOperatorNumeric = s.mVoiceOperatorNumeric; @@ -353,7 +357,6 @@ public class ServiceState implements Parcelable { mCdmaEriIconIndex = s.mCdmaEriIconIndex; mCdmaEriIconMode = s.mCdmaEriIconMode; mIsEmergencyOnly = s.mIsEmergencyOnly; - mIsDataRoamingFromRegistration = s.mIsDataRoamingFromRegistration; mIsUsingCarrierAggregation = s.mIsUsingCarrierAggregation; mChannelNumber = s.mChannelNumber; mCellBandwidths = s.mCellBandwidths == null ? null : @@ -369,8 +372,6 @@ public class ServiceState implements Parcelable { public ServiceState(Parcel in) { mVoiceRegState = in.readInt(); mDataRegState = in.readInt(); - mVoiceRoamingType = in.readInt(); - mDataRoamingType = in.readInt(); mVoiceOperatorAlphaLong = in.readString(); mVoiceOperatorAlphaShort = in.readString(); mVoiceOperatorNumeric = in.readString(); @@ -388,7 +389,6 @@ public class ServiceState implements Parcelable { mCdmaEriIconIndex = in.readInt(); mCdmaEriIconMode = in.readInt(); mIsEmergencyOnly = in.readInt() != 0; - mIsDataRoamingFromRegistration = in.readInt() != 0; mIsUsingCarrierAggregation = in.readInt() != 0; mLteEarfcnRsrpBoost = in.readInt(); mNetworkRegistrationStates = new ArrayList<>(); @@ -400,8 +400,6 @@ public class ServiceState implements Parcelable { public void writeToParcel(Parcel out, int flags) { out.writeInt(mVoiceRegState); out.writeInt(mDataRegState); - out.writeInt(mVoiceRoamingType); - out.writeInt(mDataRoamingType); out.writeString(mVoiceOperatorAlphaLong); out.writeString(mVoiceOperatorAlphaShort); out.writeString(mVoiceOperatorNumeric); @@ -419,7 +417,6 @@ public class ServiceState implements Parcelable { out.writeInt(mCdmaEriIconIndex); out.writeInt(mCdmaEriIconMode); out.writeInt(mIsEmergencyOnly ? 1 : 0); - out.writeInt(mIsDataRoamingFromRegistration ? 1 : 0); out.writeInt(mIsUsingCarrierAggregation ? 1 : 0); out.writeInt(mLteEarfcnRsrpBoost); out.writeList(mNetworkRegistrationStates); @@ -537,17 +534,21 @@ public class ServiceState implements Parcelable { */ @UnsupportedAppUsage public boolean getVoiceRoaming() { - return mVoiceRoamingType != ROAMING_TYPE_NOT_ROAMING; + return getVoiceRoamingType() != ROAMING_TYPE_NOT_ROAMING; } - /** * Get current voice network roaming type * @return roaming type * @hide */ @UnsupportedAppUsage - public int getVoiceRoamingType() { - return mVoiceRoamingType; + public @RoamingType int getVoiceRoamingType() { + final NetworkRegistrationState regState = getNetworkRegistrationState( + NetworkRegistrationState.DOMAIN_CS, AccessNetworkConstants.TransportType.WWAN); + if (regState != null) { + return regState.getRoamingType(); + } + return ROAMING_TYPE_NOT_ROAMING; } /** @@ -557,19 +558,7 @@ public class ServiceState implements Parcelable { */ @UnsupportedAppUsage public boolean getDataRoaming() { - return mDataRoamingType != ROAMING_TYPE_NOT_ROAMING; - } - - /** - * Set whether data network registration state is roaming - * - * This should only be set to the roaming value received - * once the data registration phase has completed. - * @hide - */ - @UnsupportedAppUsage - public void setDataRoamingFromRegistration(boolean dataRoaming) { - mIsDataRoamingFromRegistration = dataRoaming; + return getDataRoamingType() != ROAMING_TYPE_NOT_ROAMING; } /** @@ -578,7 +567,12 @@ public class ServiceState implements Parcelable { * @hide */ public boolean getDataRoamingFromRegistration() { - return mIsDataRoamingFromRegistration; + final NetworkRegistrationState regState = getNetworkRegistrationState( + NetworkRegistrationState.DOMAIN_PS, AccessNetworkConstants.TransportType.WWAN); + if (regState != null) { + return (regState.getRegState() == NetworkRegistrationState.REG_STATE_ROAMING); + } + return false; } /** @@ -587,8 +581,13 @@ public class ServiceState implements Parcelable { * @hide */ @UnsupportedAppUsage - public int getDataRoamingType() { - return mDataRoamingType; + public @RoamingType int getDataRoamingType() { + final NetworkRegistrationState regState = getNetworkRegistrationState( + NetworkRegistrationState.DOMAIN_PS, AccessNetworkConstants.TransportType.WWAN); + if (regState != null) { + return regState.getRoamingType(); + } + return ROAMING_TYPE_NOT_ROAMING; } /** @@ -761,8 +760,6 @@ public class ServiceState implements Parcelable { return Objects.hash( mVoiceRegState, mDataRegState, - mVoiceRoamingType, - mDataRoamingType, mChannelNumber, mCellBandwidths, mVoiceOperatorAlphaLong, @@ -782,7 +779,6 @@ public class ServiceState implements Parcelable { mCdmaEriIconIndex, mCdmaEriIconMode, mIsEmergencyOnly, - mIsDataRoamingFromRegistration, mIsUsingCarrierAggregation, mLteEarfcnRsrpBoost, mNetworkRegistrationStates); @@ -796,8 +792,6 @@ public class ServiceState implements Parcelable { return (mVoiceRegState == s.mVoiceRegState && mDataRegState == s.mDataRegState && mIsManualNetworkSelection == s.mIsManualNetworkSelection - && mVoiceRoamingType == s.mVoiceRoamingType - && mDataRoamingType == s.mDataRoamingType && mChannelNumber == s.mChannelNumber && Arrays.equals(mCellBandwidths, s.mCellBandwidths) && equalsHandlesNulls(mVoiceOperatorAlphaLong, s.mVoiceOperatorAlphaLong) @@ -815,7 +809,6 @@ public class ServiceState implements Parcelable { && equalsHandlesNulls(mCdmaDefaultRoamingIndicator, s.mCdmaDefaultRoamingIndicator) && mIsEmergencyOnly == s.mIsEmergencyOnly - && mIsDataRoamingFromRegistration == s.mIsDataRoamingFromRegistration && mIsUsingCarrierAggregation == s.mIsUsingCarrierAggregation) && (mNetworkRegistrationStates == null ? s.mNetworkRegistrationStates == null : s.mNetworkRegistrationStates != null && @@ -935,8 +928,6 @@ public class ServiceState implements Parcelable { .append(", mChannelNumber=").append(mChannelNumber) .append(", duplexMode()=").append(getDuplexMode()) .append(", mCellBandwidths=").append(Arrays.toString(mCellBandwidths)) - .append(", mVoiceRoamingType=").append(getRoamingLogString(mVoiceRoamingType)) - .append(", mDataRoamingType=").append(getRoamingLogString(mDataRoamingType)) .append(", mVoiceOperatorAlphaLong=").append(mVoiceOperatorAlphaLong) .append(", mVoiceOperatorAlphaShort=").append(mVoiceOperatorAlphaShort) .append(", mDataOperatorAlphaLong=").append(mDataOperatorAlphaLong) @@ -953,7 +944,6 @@ public class ServiceState implements Parcelable { .append(", mCdmaRoamingIndicator=").append(mCdmaRoamingIndicator) .append(", mCdmaDefaultRoamingIndicator=").append(mCdmaDefaultRoamingIndicator) .append(", mIsEmergencyOnly=").append(mIsEmergencyOnly) - .append(", mIsDataRoamingFromRegistration=").append(mIsDataRoamingFromRegistration) .append(", mIsUsingCarrierAggregation=").append(mIsUsingCarrierAggregation) .append(", mLteEarfcnRsrpBoost=").append(mLteEarfcnRsrpBoost) .append(", mNetworkRegistrationStates=").append(mNetworkRegistrationStates) @@ -964,8 +954,6 @@ public class ServiceState implements Parcelable { if (DBG) Rlog.d(LOG_TAG, "[ServiceState] setNullState=" + state); mVoiceRegState = state; mDataRegState = state; - mVoiceRoamingType = ROAMING_TYPE_NOT_ROAMING; - mDataRoamingType = ROAMING_TYPE_NOT_ROAMING; mChannelNumber = -1; mCellBandwidths = new int[0]; mVoiceOperatorAlphaLong = null; @@ -985,7 +973,6 @@ public class ServiceState implements Parcelable { mCdmaEriIconIndex = -1; mCdmaEriIconMode = -1; mIsEmergencyOnly = false; - mIsDataRoamingFromRegistration = false; mIsUsingCarrierAggregation = false; mLteEarfcnRsrpBoost = 0; mNetworkRegistrationStates = new ArrayList<>(); @@ -1031,32 +1018,50 @@ public class ServiceState implements Parcelable { } public void setRoaming(boolean roaming) { - mVoiceRoamingType = (roaming ? ROAMING_TYPE_UNKNOWN : ROAMING_TYPE_NOT_ROAMING); - mDataRoamingType = mVoiceRoamingType; + setVoiceRoaming(roaming); + setDataRoaming(roaming); } /** @hide */ @UnsupportedAppUsage public void setVoiceRoaming(boolean roaming) { - mVoiceRoamingType = (roaming ? ROAMING_TYPE_UNKNOWN : ROAMING_TYPE_NOT_ROAMING); + setVoiceRoamingType(roaming ? ROAMING_TYPE_UNKNOWN : ROAMING_TYPE_NOT_ROAMING); } /** @hide */ @UnsupportedAppUsage - public void setVoiceRoamingType(int type) { - mVoiceRoamingType = type; + public void setVoiceRoamingType(@RoamingType int type) { + NetworkRegistrationState regState = getNetworkRegistrationState( + NetworkRegistrationState.DOMAIN_CS, AccessNetworkConstants.TransportType.WWAN); + if (regState == null) { + regState = new NetworkRegistrationState( + NetworkRegistrationState.DOMAIN_CS, AccessNetworkConstants.TransportType.WWAN, + ServiceState.ROAMING_TYPE_NOT_ROAMING, TelephonyManager.NETWORK_TYPE_UNKNOWN, 0, + false, null, null); + addNetworkRegistrationState(regState); + } + regState.setRoamingType(type); } /** @hide */ @UnsupportedAppUsage public void setDataRoaming(boolean dataRoaming) { - mDataRoamingType = (dataRoaming ? ROAMING_TYPE_UNKNOWN : ROAMING_TYPE_NOT_ROAMING); + setDataRoamingType(dataRoaming ? ROAMING_TYPE_UNKNOWN : ROAMING_TYPE_NOT_ROAMING); } /** @hide */ @UnsupportedAppUsage - public void setDataRoamingType(int type) { - mDataRoamingType = type; + public void setDataRoamingType(@RoamingType int type) { + NetworkRegistrationState regState = getNetworkRegistrationState( + NetworkRegistrationState.DOMAIN_PS, AccessNetworkConstants.TransportType.WWAN); + if (regState == null) { + regState = new NetworkRegistrationState( + NetworkRegistrationState.DOMAIN_PS, AccessNetworkConstants.TransportType.WWAN, + ServiceState.ROAMING_TYPE_NOT_ROAMING, TelephonyManager.NETWORK_TYPE_UNKNOWN, 0, + false, null, null); + addNetworkRegistrationState(regState); + } + regState.setRoamingType(type); } /** @@ -1168,30 +1173,10 @@ public class ServiceState implements Parcelable { */ @UnsupportedAppUsage private void setFromNotifierBundle(Bundle m) { - mVoiceRegState = m.getInt("voiceRegState"); - mDataRegState = m.getInt("dataRegState"); - mVoiceRoamingType = m.getInt("voiceRoamingType"); - mDataRoamingType = m.getInt("dataRoamingType"); - mVoiceOperatorAlphaLong = m.getString("operator-alpha-long"); - mVoiceOperatorAlphaShort = m.getString("operator-alpha-short"); - mVoiceOperatorNumeric = m.getString("operator-numeric"); - mDataOperatorAlphaLong = m.getString("data-operator-alpha-long"); - mDataOperatorAlphaShort = m.getString("data-operator-alpha-short"); - mDataOperatorNumeric = m.getString("data-operator-numeric"); - mIsManualNetworkSelection = m.getBoolean("manual"); - mRilVoiceRadioTechnology = m.getInt("radioTechnology"); - mRilDataRadioTechnology = m.getInt("dataRadioTechnology"); - mCssIndicator = m.getBoolean("cssIndicator"); - mNetworkId = m.getInt("networkId"); - mSystemId = m.getInt("systemId"); - mCdmaRoamingIndicator = m.getInt("cdmaRoamingIndicator"); - mCdmaDefaultRoamingIndicator = m.getInt("cdmaDefaultRoamingIndicator"); - mIsEmergencyOnly = m.getBoolean("emergencyOnly"); - mIsDataRoamingFromRegistration = m.getBoolean("isDataRoamingFromRegistration"); - mIsUsingCarrierAggregation = m.getBoolean("isUsingCarrierAggregation"); - mLteEarfcnRsrpBoost = m.getInt("LteEarfcnRsrpBoost"); - mChannelNumber = m.getInt("ChannelNumber"); - mCellBandwidths = m.getIntArray("CellBandwidths"); + ServiceState ssFromBundle = m.getParcelable(Intent.EXTRA_SERVICE_STATE); + if (ssFromBundle != null) { + copyFrom(ssFromBundle); + } } /** @@ -1202,10 +1187,13 @@ public class ServiceState implements Parcelable { */ @UnsupportedAppUsage public void fillInNotifierBundle(Bundle m) { + m.putParcelable(Intent.EXTRA_SERVICE_STATE, this); + // serviceState already consists of below entries. + // for backward compatibility, we continue fill in below entries. m.putInt("voiceRegState", mVoiceRegState); m.putInt("dataRegState", mDataRegState); - m.putInt("voiceRoamingType", mVoiceRoamingType); - m.putInt("dataRoamingType", mDataRoamingType); + m.putInt("dataRoamingType", getDataRoamingType()); + m.putInt("voiceRoamingType", getVoiceRoamingType()); m.putString("operator-alpha-long", mVoiceOperatorAlphaLong); m.putString("operator-alpha-short", mVoiceOperatorAlphaShort); m.putString("operator-numeric", mVoiceOperatorNumeric); @@ -1221,7 +1209,7 @@ public class ServiceState implements Parcelable { m.putInt("cdmaRoamingIndicator", mCdmaRoamingIndicator); m.putInt("cdmaDefaultRoamingIndicator", mCdmaDefaultRoamingIndicator); m.putBoolean("emergencyOnly", mIsEmergencyOnly); - m.putBoolean("isDataRoamingFromRegistration", mIsDataRoamingFromRegistration); + m.putBoolean("isDataRoamingFromRegistration", getDataRoamingFromRegistration()); m.putBoolean("isUsingCarrierAggregation", mIsUsingCarrierAggregation); m.putInt("LteEarfcnRsrpBoost", mLteEarfcnRsrpBoost); m.putInt("ChannelNumber", mChannelNumber); diff --git a/telephony/java/com/android/internal/telephony/RILConstants.java b/telephony/java/com/android/internal/telephony/RILConstants.java index 3a263504a2ec..cb8269efe443 100644 --- a/telephony/java/com/android/internal/telephony/RILConstants.java +++ b/telephony/java/com/android/internal/telephony/RILConstants.java @@ -420,6 +420,7 @@ public interface RILConstants { int RIL_REQUEST_SET_LOGICAL_TO_PHYSICAL_SLOT_MAPPING = 201; int RIL_REQUEST_SET_SIGNAL_STRENGTH_REPORTING_CRITERIA = 202; int RIL_REQUEST_SET_LINK_CAPACITY_REPORTING_CRITERIA = 203; + int RIL_REQUEST_SET_PREFERRED_DATA_MODEM = 204; /* Responses begin */ int RIL_RESPONSE_ACKNOWLEDGEMENT = 800; diff --git a/telephony/java/com/android/internal/telephony/TelephonyPermissions.java b/telephony/java/com/android/internal/telephony/TelephonyPermissions.java index dac7e04be07a..9730ebc57fcf 100644 --- a/telephony/java/com/android/internal/telephony/TelephonyPermissions.java +++ b/telephony/java/com/android/internal/telephony/TelephonyPermissions.java @@ -32,6 +32,7 @@ import android.os.UserHandle; import android.telephony.Rlog; import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; +import android.util.Log; import com.android.internal.annotations.VisibleForTesting; @@ -43,6 +44,10 @@ public final class TelephonyPermissions { private static final boolean DBG = false; + // When set to true this flag will treat all apps that fail the device identifier check as + // though they are targeting pre-Q and return dummy data instead of throwing a SecurityException + private static final boolean RELAX_DEVICE_IDENTIFIER_CHECK = true; + private static final Supplier<ITelephony> TELEPHONY_SUPPLIER = () -> ITelephony.Stub.asInterface(ServiceManager.getService(Context.TELEPHONY_SERVICE)); @@ -275,31 +280,41 @@ public final class TelephonyPermissions { */ private static boolean reportAccessDeniedToReadIdentifiers(Context context, int subId, int pid, int uid, String callingPackage, String message) { - if (callingPackage != null) { - try { - // if the target SDK is pre-Q then check if the calling package would have - // previously had access to device identifiers. - ApplicationInfo callingPackageInfo = context.getPackageManager().getApplicationInfo( - callingPackage, 0); - if (callingPackageInfo != null - && callingPackageInfo.targetSdkVersion < Build.VERSION_CODES.Q) { - if (context.checkPermission(android.Manifest.permission.READ_PHONE_STATE, pid, - uid) == PackageManager.PERMISSION_GRANTED) { - return false; - } - if (SubscriptionManager.isValidSubscriptionId(subId) - && getCarrierPrivilegeStatus(TELEPHONY_SUPPLIER, subId, uid) - == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) { - return false; + // if the device identifier check is relaxed then just return false to return dummy data to + // the caller instead of throwing a SecurityException for apps targeting Q+. + if (RELAX_DEVICE_IDENTIFIER_CHECK) { + Log.wtf(LOG_TAG, + "reportAccessDeniedToReadIdentifiers:" + callingPackage + ":" + message); + return false; + } else { + if (callingPackage != null) { + try { + // if the target SDK is pre-Q then check if the calling package would have + // previously had access to device identifiers. + ApplicationInfo callingPackageInfo = + context.getPackageManager().getApplicationInfo( + callingPackage, 0); + if (callingPackageInfo != null + && callingPackageInfo.targetSdkVersion < Build.VERSION_CODES.Q) { + if (context.checkPermission(android.Manifest.permission.READ_PHONE_STATE, + pid, + uid) == PackageManager.PERMISSION_GRANTED) { + return false; + } + if (SubscriptionManager.isValidSubscriptionId(subId) + && getCarrierPrivilegeStatus(TELEPHONY_SUPPLIER, subId, uid) + == TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS) { + return false; + } } + } catch (PackageManager.NameNotFoundException e) { + // If the application info for the calling package could not be found then + // default to throwing the SecurityException. } - } catch (PackageManager.NameNotFoundException e) { - // If the application info for the calling package could not be found then default - // to throwing the SecurityException. } + throw new SecurityException(message + ": The user " + uid + " does not have the " + + "READ_PRIVILEGED_PHONE_STATE permission to access the device identifiers"); } - throw new SecurityException(message + ": The user " + uid + " does not have the " - + "READ_PRIVILEGED_PHONE_STATE permission to access the device identifiers"); } /** diff --git a/tools/stats_log_api_gen/Collation.cpp b/tools/stats_log_api_gen/Collation.cpp index 4245700ed90d..d1f42f8b398e 100644 --- a/tools/stats_log_api_gen/Collation.cpp +++ b/tools/stats_log_api_gen/Collation.cpp @@ -251,7 +251,7 @@ int collate_atom(const Descriptor *atom, AtomDecl *atomDecl, } atomDecl->fields.push_back(atField); - if (field->options().GetExtension(os::statsd::stateFieldOption).option() == + if (field->options().GetExtension(os::statsd::state_field_option).option() == os::statsd::StateField::PRIMARY) { if (javaType == JAVA_TYPE_UNKNOWN || javaType == JAVA_TYPE_ATTRIBUTION_CHAIN || @@ -261,7 +261,7 @@ int collate_atom(const Descriptor *atom, AtomDecl *atomDecl, atomDecl->primaryFields.push_back(it->first); } - if (field->options().GetExtension(os::statsd::stateFieldOption).option() == + if (field->options().GetExtension(os::statsd::state_field_option).option() == os::statsd::StateField::EXCLUSIVE) { if (javaType == JAVA_TYPE_UNKNOWN || javaType == JAVA_TYPE_ATTRIBUTION_CHAIN || diff --git a/tools/stats_log_api_gen/test.proto b/tools/stats_log_api_gen/test.proto index 264a865e3b39..f6359748a27e 100644 --- a/tools/stats_log_api_gen/test.proto +++ b/tools/stats_log_api_gen/test.proto @@ -127,33 +127,33 @@ message GoodStateAtoms { // The atom has only primary field but no exclusive state field. message BadStateAtom1 { optional int32 uid = 1 - [(android.os.statsd.stateFieldOption).option = PRIMARY]; + [(android.os.statsd.state_field_option).option = PRIMARY]; } // Only primative types can be annotated. message BadStateAtom2 { repeated android.os.statsd.AttributionNode attribution = 1 - [(android.os.statsd.stateFieldOption).option = PRIMARY]; + [(android.os.statsd.state_field_option).option = PRIMARY]; optional int32 state = 2 - [(android.os.statsd.stateFieldOption).option = EXCLUSIVE]; + [(android.os.statsd.state_field_option).option = EXCLUSIVE]; } // Having 2 exclusive state field in the atom means the atom is badly designed. // E.g., putting bluetooth state and wifi state in the same atom. message BadStateAtom3 { optional int32 uid = 1 - [(android.os.statsd.stateFieldOption).option = PRIMARY]; + [(android.os.statsd.state_field_option).option = PRIMARY]; optional int32 state = 2 - [(android.os.statsd.stateFieldOption).option = EXCLUSIVE]; + [(android.os.statsd.state_field_option).option = EXCLUSIVE]; optional int32 state2 = 3 - [(android.os.statsd.stateFieldOption).option = EXCLUSIVE]; + [(android.os.statsd.state_field_option).option = EXCLUSIVE]; } message GoodStateAtom1 { optional int32 uid = 1 - [(android.os.statsd.stateFieldOption).option = PRIMARY]; + [(android.os.statsd.state_field_option).option = PRIMARY]; optional int32 state = 2 - [(android.os.statsd.stateFieldOption).option = EXCLUSIVE]; + [(android.os.statsd.state_field_option).option = EXCLUSIVE]; } // Atoms can have exclusive state field, but no primary field. That means @@ -161,16 +161,16 @@ message GoodStateAtom1 { message GoodStateAtom2 { optional int32 uid = 1; optional int32 state = 2 - [(android.os.statsd.stateFieldOption).option = EXCLUSIVE]; + [(android.os.statsd.state_field_option).option = EXCLUSIVE]; } // We can have more than one primary fields. That means their combination is a // primary key. message GoodStateAtom3 { optional int32 uid = 1 - [(android.os.statsd.stateFieldOption).option = PRIMARY]; + [(android.os.statsd.state_field_option).option = PRIMARY]; optional int32 tid = 2 - [(android.os.statsd.stateFieldOption).option = PRIMARY]; + [(android.os.statsd.state_field_option).option = PRIMARY]; optional int32 state = 3 - [(android.os.statsd.stateFieldOption).option = EXCLUSIVE]; + [(android.os.statsd.state_field_option).option = EXCLUSIVE]; }
\ No newline at end of file diff --git a/wifi/java/android/net/wifi/WifiWakeReasonAndCounts.java b/wifi/java/android/net/wifi/WifiWakeReasonAndCounts.java deleted file mode 100644 index f5cad139bd23..000000000000 --- a/wifi/java/android/net/wifi/WifiWakeReasonAndCounts.java +++ /dev/null @@ -1,163 +0,0 @@ -/* - * Copyright (C) 2015 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.net.wifi; - -import android.os.Parcel; -import android.os.Parcelable; - -/** - * A class representing wifi wake reason accounting. - */ - -/** @hide */ -public class WifiWakeReasonAndCounts implements Parcelable { - private static final String TAG = "WifiWakeReasonAndCounts"; - /** - * Wlan can wake host, only when it is cmd/event, local driver-fw - * functions(non-data, non cmd/event) and rx data.The first packet - * from wlan that woke up a sleep host is what is accounted here. - * Total wlan wake to application processor would be: - * [cmdEventWake + driverFwLocalWake + totalRxDataWake] - * A further classification is provided for identifying the reasons - * for wakeup. - */ - public int totalCmdEventWake; - public int totalDriverFwLocalWake; - public int totalRxDataWake; - - public int rxUnicast; - public int rxMulticast; - public int rxBroadcast; - - public int icmp; - public int icmp6; - public int icmp6Ra; - public int icmp6Na; - public int icmp6Ns; - - public int ipv4RxMulticast; - public int ipv6Multicast; - public int otherRxMulticast; - public int[] cmdEventWakeCntArray; - public int[] driverFWLocalWakeCntArray; - - /* {@hide} */ - public WifiWakeReasonAndCounts () { - } - - @Override - /* {@hide} */ - public String toString() { - StringBuffer sb = new StringBuffer(); - sb.append(" totalCmdEventWake ").append(totalCmdEventWake); - sb.append(" totalDriverFwLocalWake ").append(totalDriverFwLocalWake); - sb.append(" totalRxDataWake ").append(totalRxDataWake); - - sb.append(" rxUnicast ").append(rxUnicast); - sb.append(" rxMulticast ").append(rxMulticast); - sb.append(" rxBroadcast ").append(rxBroadcast); - - sb.append(" icmp ").append(icmp); - sb.append(" icmp6 ").append(icmp6); - sb.append(" icmp6Ra ").append(icmp6Ra); - sb.append(" icmp6Na ").append(icmp6Na); - sb.append(" icmp6Ns ").append(icmp6Ns); - - sb.append(" ipv4RxMulticast ").append(ipv4RxMulticast); - sb.append(" ipv6Multicast ").append(ipv6Multicast); - sb.append(" otherRxMulticast ").append(otherRxMulticast); - for (int i = 0; i < cmdEventWakeCntArray.length; i++) { - sb.append(" cmdEventWakeCntArray[" + i + "] " + cmdEventWakeCntArray[i]); - } - for (int i = 0; i < driverFWLocalWakeCntArray.length; i++) { - sb.append(" driverFWLocalWakeCntArray[" + i + "] " + driverFWLocalWakeCntArray[i]); - } - - return sb.toString(); - } - - /* Implement the Parcelable interface - * {@hide} - */ - @Override - public int describeContents() { - return 0; - } - - /* Implement the Parcelable interface - * {@hide} - */ - @Override - public void writeToParcel(Parcel dest, int flags) { - dest.writeInt(totalCmdEventWake); - dest.writeInt(totalDriverFwLocalWake); - dest.writeInt(totalRxDataWake); - - dest.writeInt(rxUnicast); - dest.writeInt(rxMulticast); - dest.writeInt(rxBroadcast); - - dest.writeInt(icmp); - dest.writeInt(icmp6); - dest.writeInt(icmp6Ra); - dest.writeInt(icmp6Na); - dest.writeInt(icmp6Ns); - - dest.writeInt(ipv4RxMulticast); - dest.writeInt(ipv6Multicast); - dest.writeInt(otherRxMulticast); - dest.writeIntArray(cmdEventWakeCntArray); - dest.writeIntArray(driverFWLocalWakeCntArray); - } - - /* Implement the Parcelable interface - * {@hide} - */ - public static final Creator<WifiWakeReasonAndCounts> CREATOR = - new Creator<WifiWakeReasonAndCounts>() { - public WifiWakeReasonAndCounts createFromParcel(Parcel in) { - WifiWakeReasonAndCounts counts = new WifiWakeReasonAndCounts(); - counts.totalCmdEventWake = in.readInt(); - counts.totalDriverFwLocalWake = in.readInt(); - counts.totalRxDataWake = in.readInt(); - - counts.rxUnicast = in.readInt(); - counts.rxMulticast = in.readInt(); - counts.rxBroadcast = in.readInt(); - - counts.icmp = in.readInt(); - counts.icmp6 = in.readInt(); - counts.icmp6Ra = in.readInt(); - counts.icmp6Na = in.readInt(); - counts.icmp6Ns = in.readInt(); - - counts.ipv4RxMulticast = in.readInt(); - counts.ipv6Multicast = in.readInt(); - counts.otherRxMulticast = in.readInt(); - in.readIntArray(counts.cmdEventWakeCntArray); - in.readIntArray(counts.driverFWLocalWakeCntArray); - return counts; - } - /* Implement the Parcelable interface - * {@hide} - */ - @Override - public WifiWakeReasonAndCounts[] newArray(int size) { - return new WifiWakeReasonAndCounts[size]; - } - }; -} diff --git a/wifi/java/android/net/wifi/hotspot2/ProvisioningCallback.java b/wifi/java/android/net/wifi/hotspot2/ProvisioningCallback.java index b4dfac6c01c7..6076175ce9d1 100644 --- a/wifi/java/android/net/wifi/hotspot2/ProvisioningCallback.java +++ b/wifi/java/android/net/wifi/hotspot2/ProvisioningCallback.java @@ -102,6 +102,12 @@ public abstract class ProvisioningCallback { public static final int OSU_FAILURE_NO_OSU_ACTIVITY_FOUND = 14; /** + * The reason code for provisioning failure when the status of a SOAP message is not the + * expected message status. + */ + public static final int OSU_FAILURE_UNEXPECTED_SOAP_MESSAGE_STATUS = 15; + + /** * The status code for provisioning flow to indicate connecting to OSU AP */ public static final int OSU_STATUS_AP_CONNECTING = 1; @@ -147,6 +153,11 @@ public abstract class ProvisioningCallback { public static final int OSU_STATUS_SECOND_SOAP_EXCHANGE = 9; /** + * The status code for provisioning flow to indicate starting the third SOAP exchange. + */ + public static final int OSU_STATUS_THIRD_SOAP_EXCHANGE = 10; + + /** * Provisioning status for OSU failure * * @param status indicates error condition |