Merge "Revert "Move signing data into SigningDetails container""
diff --git a/Android.bp b/Android.bp
index 69ee848..03a79f6 100644
--- a/Android.bp
+++ b/Android.bp
@@ -730,10 +730,18 @@
"core/proto/android/os/procrank.proto",
"core/proto/android/os/ps.proto",
"core/proto/android/os/system_properties.proto",
+ "core/proto/android/util/event_log_tags.proto",
],
// Append protoc-gen-cppstream tool's PATH otherwise aprotoc can't find the plugin tool
- cmd: "PATH=$$PATH:$$(dirname $(location protoc-gen-cppstream)) $(location aprotoc) --plugin=protoc-gen-cpp-stream=$(location protoc-gen-cppstream) --dependency_out=$(depfile) --cppstream_out=$(genDir)/ -Iexternal/protobuf/src -I . $(in)",
+ cmd: "mkdir -p $(genDir) " +
+ "&& $(location aprotoc) " +
+ " --plugin=$(location protoc-gen-cppstream) " +
+ " --dependency_out=$(depfile) " +
+ " --cppstream_out=$(genDir) " +
+ " -Iexternal/protobuf/src " +
+ " -I . " +
+ " $(in)",
output_extension = "proto.h",
}
diff --git a/api/current.txt b/api/current.txt
index d8deef3..009c56d 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -579,6 +579,7 @@
field public static final int fadingEdge = 16842975; // 0x10100df
field public static final int fadingEdgeLength = 16842976; // 0x10100e0
field public static final int fadingMode = 16843745; // 0x10103e1
+ field public static final int fallbackLineSpacing = 16844155; // 0x101057b
field public static final int fastScrollAlwaysVisible = 16843573; // 0x1010335
field public static final int fastScrollEnabled = 16843302; // 0x1010226
field public static final int fastScrollOverlayPosition = 16843578; // 0x101033a
@@ -20180,6 +20181,13 @@
ctor public ICUUncheckedIOException(java.lang.String, java.lang.Throwable);
}
+ public class IllformedLocaleException extends java.lang.RuntimeException {
+ ctor public IllformedLocaleException();
+ ctor public IllformedLocaleException(java.lang.String);
+ ctor public IllformedLocaleException(java.lang.String, int);
+ method public int getErrorIndex();
+ }
+
public class IndianCalendar extends android.icu.util.Calendar {
ctor public IndianCalendar();
ctor public IndianCalendar(android.icu.util.TimeZone);
@@ -52310,6 +52318,7 @@
method public boolean isAllCaps();
method public boolean isCursorVisible();
method public boolean isElegantTextHeight();
+ method public boolean isFallbackLineSpacing();
method public boolean isInputMethodTarget();
method public boolean isSuggestionsEnabled();
method public boolean isTextSelectable();
@@ -52353,6 +52362,7 @@
method public void setError(java.lang.CharSequence);
method public void setError(java.lang.CharSequence, android.graphics.drawable.Drawable);
method public void setExtractedText(android.view.inputmethod.ExtractedText);
+ method public void setFallbackLineSpacing(boolean);
method public void setFilters(android.text.InputFilter[]);
method public void setFontFeatureSettings(java.lang.String);
method public boolean setFontVariationSettings(java.lang.String);
diff --git a/api/system-current.txt b/api/system-current.txt
index ba1d383..7c047ab 100644
--- a/api/system-current.txt
+++ b/api/system-current.txt
@@ -137,6 +137,7 @@
field public static final java.lang.String RECEIVE_EMERGENCY_BROADCAST = "android.permission.RECEIVE_EMERGENCY_BROADCAST";
field public static final java.lang.String RECEIVE_WIFI_CREDENTIAL_CHANGE = "android.permission.RECEIVE_WIFI_CREDENTIAL_CHANGE";
field public static final java.lang.String RECOVERY = "android.permission.RECOVERY";
+ field public static final java.lang.String RECOVER_KEYSTORE = "android.permission.RECOVER_KEYSTORE";
field public static final java.lang.String REGISTER_CALL_PROVIDER = "android.permission.REGISTER_CALL_PROVIDER";
field public static final java.lang.String REGISTER_CONNECTION_MANAGER = "android.permission.REGISTER_CONNECTION_MANAGER";
field public static final java.lang.String REGISTER_SIM_SUBSCRIPTION = "android.permission.REGISTER_SIM_SUBSCRIPTION";
@@ -1448,7 +1449,7 @@
method public abstract void onMessageReceipt(int, int, android.hardware.location.ContextHubMessage);
}
- public class ContextHubMessage {
+ public deprecated class ContextHubMessage {
ctor public ContextHubMessage(int, int, byte[]);
method public int describeContents();
method public byte[] getData();
@@ -1579,7 +1580,7 @@
field public static final android.os.Parcelable.Creator<android.hardware.location.MemoryRegion> CREATOR;
}
- public class NanoApp {
+ public deprecated class NanoApp {
ctor public NanoApp();
ctor public deprecated NanoApp(int, byte[]);
ctor public NanoApp(long, byte[]);
@@ -1627,7 +1628,7 @@
field public static final android.os.Parcelable.Creator<android.hardware.location.NanoAppBinary> CREATOR;
}
- public class NanoAppFilter {
+ public deprecated class NanoAppFilter {
ctor public NanoAppFilter(long, int, int, long);
method public int describeContents();
method public boolean testMatch(android.hardware.location.NanoAppInstanceInfo);
@@ -1642,7 +1643,7 @@
field public static final int VENDOR_ANY = -1; // 0xffffffff
}
- public class NanoAppInstanceInfo {
+ public deprecated class NanoAppInstanceInfo {
ctor public NanoAppInstanceInfo();
method public int describeContents();
method public long getAppId();
diff --git a/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java b/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java
index b61cdec..e87a78e 100644
--- a/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java
+++ b/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java
@@ -23,8 +23,8 @@
import android.app.backup.IBackupObserver;
import android.app.backup.IRestoreObserver;
import android.app.backup.IRestoreSession;
-import android.app.backup.RestoreSet;
import android.app.backup.ISelectBackupTransportCallback;
+import android.app.backup.RestoreSet;
import android.content.ComponentName;
import android.content.pm.IPackageManager;
import android.content.pm.PackageInfo;
@@ -37,6 +37,7 @@
import com.android.internal.annotations.GuardedBy;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.CountDownLatch;
@@ -339,18 +340,16 @@
System.err.println(PM_NOT_RUNNING_ERR);
}
if (installedPackages != null) {
- List<String> packages = new ArrayList<>();
- for (PackageInfo pi : installedPackages) {
- try {
- if (mBmgr.isAppEligibleForBackup(pi.packageName)) {
- packages.add(pi.packageName);
- }
- } catch (RemoteException e) {
- System.err.println(e.toString());
- System.err.println(BMGR_NOT_RUNNING_ERR);
- }
+ String[] packages =
+ installedPackages.stream().map(p -> p.packageName).toArray(String[]::new);
+ String[] filteredPackages = {};
+ try {
+ filteredPackages = mBmgr.filterAppsEligibleForBackup(packages);
+ } catch (RemoteException e) {
+ System.err.println(e.toString());
+ System.err.println(BMGR_NOT_RUNNING_ERR);
}
- backupNowPackages(packages, nonIncrementalBackup);
+ backupNowPackages(Arrays.asList(filteredPackages), nonIncrementalBackup);
}
}
diff --git a/cmds/incident_helper/src/ih_util.cpp b/cmds/incident_helper/src/ih_util.cpp
index e23e80a..847b26a 100644
--- a/cmds/incident_helper/src/ih_util.cpp
+++ b/cmds/incident_helper/src/ih_util.cpp
@@ -208,6 +208,19 @@
return true;
}
+std::string behead(std::string* line, const char cut) {
+ auto found = line->find_first_of(cut);
+ if (found == std::string::npos) {
+ std::string head = line->substr(0);
+ line->assign("");
+ return head;
+ }
+ std::string head = line->substr(0, found);
+ while(line->at(found) == cut) found++; // trim more cut of the rest
+ line->assign(line->substr(found));
+ return head;
+}
+
int toInt(const std::string& s) {
return atoi(s.c_str());
}
diff --git a/cmds/incident_helper/src/ih_util.h b/cmds/incident_helper/src/ih_util.h
index b063b2f..53f4438 100644
--- a/cmds/incident_helper/src/ih_util.h
+++ b/cmds/incident_helper/src/ih_util.h
@@ -34,6 +34,8 @@
const std::string DEFAULT_NEWLINE = "\r\n";
const std::string TAB_DELIMITER = "\t";
const std::string COMMA_DELIMITER = ",";
+const std::string PIPE_DELIMITER = "|";
+const std::string PARENTHESES_DELIMITER = "()";
// returns true if c is a-zA-Z0-9 or underscore
bool isValidChar(char c);
@@ -89,6 +91,11 @@
bool stripSuffix(std::string* line, const char* key, bool endAtDelimiter = false);
/**
+ * behead the given line by the cut, return the head and reassign the line to be the rest.
+ */
+std::string behead(std::string* line, const char cut);
+
+/**
* Converts string to the desired type
*/
int toInt(const std::string& s);
diff --git a/cmds/incident_helper/src/main.cpp b/cmds/incident_helper/src/main.cpp
index 8c6cd78..418dc3f 100644
--- a/cmds/incident_helper/src/main.cpp
+++ b/cmds/incident_helper/src/main.cpp
@@ -19,6 +19,7 @@
#include "parsers/BatteryTypeParser.h"
#include "parsers/CpuFreqParser.h"
#include "parsers/CpuInfoParser.h"
+#include "parsers/EventLogTagsParser.h"
#include "parsers/KernelWakesParser.h"
#include "parsers/PageTypeInfoParser.h"
#include "parsers/ProcrankParser.h"
@@ -55,6 +56,8 @@
// IDs larger than 1 are section ids reserved in incident.proto
case 1000:
return new SystemPropertiesParser();
+ case 1100:
+ return new EventLogTagsParser();
case 2000:
return new ProcrankParser();
case 2001:
diff --git a/cmds/incident_helper/src/parsers/EventLogTagsParser.cpp b/cmds/incident_helper/src/parsers/EventLogTagsParser.cpp
new file mode 100644
index 0000000..73e37bd
--- /dev/null
+++ b/cmds/incident_helper/src/parsers/EventLogTagsParser.cpp
@@ -0,0 +1,84 @@
+/*
+ * 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.
+ */
+#define LOG_TAG "incident_helper"
+
+#include <android/util/ProtoOutputStream.h>
+
+#include "frameworks/base/core/proto/android/util/event_log_tags.proto.h"
+#include "ih_util.h"
+#include "EventLogTagsParser.h"
+
+status_t
+EventLogTagsParser::Parse(const int in, const int out) const
+{
+ Reader reader(in);
+ string line;
+
+ ProtoOutputStream proto;
+
+ // parse line by line
+ while (reader.readLine(&line)) {
+ if (line.empty()) continue;
+ string debug = line;
+ string tagNumber = behead(&line, ' ');
+ string tagName = behead(&line, ' ');
+ if (tagNumber == "" || tagName == "") {
+ fprintf(stderr, "Bad line, expect at least two parts: %s[%s, %s]\n",
+ debug.c_str(), tagNumber.c_str(), tagName.c_str());
+ continue;
+ }
+
+ long long token = proto.start(EventLogTagMapProto::EVENT_LOG_TAGS);
+ proto.write(EventLogTag::TAG_NUMBER, toInt(tagNumber));
+ proto.write(EventLogTag::TAG_NAME, tagName);
+
+ record_t valueDescriptors = parseRecord(line, PARENTHESES_DELIMITER);
+ for (size_t i = 0; i < valueDescriptors.size(); i++) {
+ record_t valueDescriptor = parseRecord(valueDescriptors[i], PIPE_DELIMITER);
+ if (valueDescriptor.size() != 2 && valueDescriptor.size() != 3) {
+ // If the parts doesn't contains pipe, then skips it.
+ continue;
+ }
+ long long descriptorToken = proto.start(EventLogTag::VALUE_DESCRIPTORS);
+ proto.write(EventLogTag::ValueDescriptor::NAME, valueDescriptor[0]);
+ proto.write(EventLogTag::ValueDescriptor::TYPE, toInt(valueDescriptor[1]));
+ if (valueDescriptor.size() == 3) {
+ char c = valueDescriptor[2][0];
+ int unit = 0;
+ if (c < '0' || c > '9') {
+ unit = (int) c;
+ } else {
+ unit = toInt(valueDescriptor[2]);
+ }
+ proto.write(EventLogTag::ValueDescriptor::UNIT, unit);
+ }
+ proto.end(descriptorToken);
+ }
+ proto.end(token);
+ }
+
+ if (!reader.ok(&line)) {
+ fprintf(stderr, "Bad read from fd %d: %s\n", in, line.c_str());
+ return -1;
+ }
+
+ if (!proto.flush(out)) {
+ fprintf(stderr, "[%s]Error writing proto back\n", this->name.string());
+ return -1;
+ }
+ fprintf(stderr, "[%s]Proto size: %zu bytes\n", this->name.string(), proto.size());
+ return NO_ERROR;
+}
diff --git a/cmds/incident_helper/src/parsers/EventLogTagsParser.h b/cmds/incident_helper/src/parsers/EventLogTagsParser.h
new file mode 100644
index 0000000..79057ce
--- /dev/null
+++ b/cmds/incident_helper/src/parsers/EventLogTagsParser.h
@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+#ifndef EVENT_LOG_TAGS_PARSER_H
+#define EVENT_LOG_TAGS_PARSER_H
+
+#include "TextParserBase.h"
+
+using namespace android;
+
+/**
+ * event.logtags parser, parse file in /system/etc/event-log-tags
+ */
+class EventLogTagsParser : public TextParserBase {
+public:
+ EventLogTagsParser() : TextParserBase(String8("EventLogTagsParser")) {};
+ ~EventLogTagsParser() {};
+
+ virtual status_t Parse(const int in, const int out) const;
+};
+
+#endif // EVENT_LOG_TAGS_PARSER_H
diff --git a/cmds/incident_helper/testdata/event-log-tags.txt b/cmds/incident_helper/testdata/event-log-tags.txt
new file mode 100644
index 0000000..35396bf
--- /dev/null
+++ b/cmds/incident_helper/testdata/event-log-tags.txt
@@ -0,0 +1,6 @@
+42 answer (to life the universe etc|3)
+314 pi
+1004 chatty (dropped|3)
+1005 tag_def (tag|1),(name|3),(format|3)
+2747 contacts_aggregation (aggregation time|2|3), (count|1|1)
+1397638484 snet_event_log (subtag|3) (uid|1) (message|3|s)
\ No newline at end of file
diff --git a/cmds/incident_helper/tests/EventLogTagsParser_test.cpp b/cmds/incident_helper/tests/EventLogTagsParser_test.cpp
new file mode 100644
index 0000000..d0d1f1e
--- /dev/null
+++ b/cmds/incident_helper/tests/EventLogTagsParser_test.cpp
@@ -0,0 +1,125 @@
+/*
+ * 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.
+ */
+
+#include "EventLogTagsParser.h"
+
+#include "frameworks/base/core/proto/android/util/event_log_tags.pb.h"
+
+#include <android-base/file.h>
+#include <android-base/test_utils.h>
+#include <gmock/gmock.h>
+#include <google/protobuf/message_lite.h>
+#include <gtest/gtest.h>
+#include <string.h>
+#include <fcntl.h>
+
+using namespace android::base;
+using namespace android::util;
+using namespace std;
+using ::testing::StrEq;
+using ::testing::Test;
+using ::testing::internal::CaptureStderr;
+using ::testing::internal::CaptureStdout;
+using ::testing::internal::GetCapturedStderr;
+using ::testing::internal::GetCapturedStdout;
+
+class EventLogTagsParserTest : public Test {
+public:
+ virtual void SetUp() override {
+ ASSERT_TRUE(tf.fd != -1);
+ }
+
+protected:
+ TemporaryFile tf;
+
+ const string kTestPath = GetExecutableDirectory();
+ const string kTestDataPath = kTestPath + "/testdata/";
+};
+
+TEST_F(EventLogTagsParserTest, Success) {
+ const string testFile = kTestDataPath + "event-log-tags.txt";
+
+ EventLogTagsParser parser;
+ EventLogTagMapProto expected;
+
+ EventLogTag* eventLogTag;
+ EventLogTag::ValueDescriptor* desp;
+
+ eventLogTag = expected.add_event_log_tags();
+ eventLogTag->set_tag_number(42);
+ eventLogTag->set_tag_name("answer");
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("to life the universe etc");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_STRING);
+
+ eventLogTag = expected.add_event_log_tags();
+ eventLogTag->set_tag_number(314);
+ eventLogTag->set_tag_name("pi");
+
+ eventLogTag = expected.add_event_log_tags();
+ eventLogTag->set_tag_number(1004);
+ eventLogTag->set_tag_name("chatty");
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("dropped");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_STRING);
+
+ eventLogTag = expected.add_event_log_tags();
+ eventLogTag->set_tag_number(1005);
+ eventLogTag->set_tag_name("tag_def");
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("tag");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_INT);
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("name");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_STRING);
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("format");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_STRING);
+
+ eventLogTag = expected.add_event_log_tags();
+ eventLogTag->set_tag_number(2747);
+ eventLogTag->set_tag_name("contacts_aggregation");
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("aggregation time");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_LONG);
+ desp->set_unit(EventLogTag_ValueDescriptor_DataUnit_MILLISECONDS);
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("count");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_INT);
+ desp->set_unit(EventLogTag_ValueDescriptor_DataUnit_OBJECTS);
+
+ eventLogTag = expected.add_event_log_tags();
+ eventLogTag->set_tag_number(1397638484);
+ eventLogTag->set_tag_name("snet_event_log");
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("subtag");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_STRING);
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("uid");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_INT);
+ desp = eventLogTag->add_value_descriptors();
+ desp->set_name("message");
+ desp->set_type(EventLogTag_ValueDescriptor_DataType_STRING);
+ desp->set_unit(EventLogTag_ValueDescriptor_DataUnit_SECONDS);
+
+ int fd = open(testFile.c_str(), O_RDONLY);
+ ASSERT_TRUE(fd != -1);
+
+ CaptureStdout();
+ ASSERT_EQ(NO_ERROR, parser.Parse(fd, STDOUT_FILENO));
+ EXPECT_EQ(GetCapturedStdout(), expected.SerializeAsString());
+ close(fd);
+}
diff --git a/cmds/incident_helper/tests/ih_util_test.cpp b/cmds/incident_helper/tests/ih_util_test.cpp
index 7b8cf52..efe714d 100644
--- a/cmds/incident_helper/tests/ih_util_test.cpp
+++ b/cmds/incident_helper/tests/ih_util_test.cpp
@@ -60,6 +60,9 @@
result = parseRecord("123,456,78_9", ",");
expected = { "123", "456", "78_9" };
EXPECT_EQ(expected, result);
+
+ result = parseRecord("", " ");
+ EXPECT_TRUE(result.empty());
}
TEST(IhUtilTest, ParseRecordByColumns) {
@@ -133,6 +136,22 @@
EXPECT_THAT(data4, StrEq(" 243%abc"));
}
+TEST(IhUtilTest, behead) {
+ string testcase1 = "81002 dropbox_file_copy (a)(b)";
+ EXPECT_THAT(behead(&testcase1, ' '), StrEq("81002"));
+ EXPECT_THAT(behead(&testcase1, ' '), StrEq("dropbox_file_copy"));
+ EXPECT_THAT(testcase1, "(a)(b)");
+
+ string testcase2 = "adbce,erwqr";
+ EXPECT_THAT(behead(&testcase2, ' '), StrEq("adbce,erwqr"));
+ EXPECT_THAT(testcase2, "");
+
+ string testcase3 = "first second";
+ EXPECT_THAT(behead(&testcase3, ' '), StrEq("first"));
+ EXPECT_THAT(behead(&testcase3, ' '), StrEq("second"));
+ EXPECT_THAT(testcase3, "");
+}
+
TEST(IhUtilTest, Reader) {
TemporaryFile tf;
ASSERT_NE(tf.fd, -1);
diff --git a/cmds/incidentd/Android.mk b/cmds/incidentd/Android.mk
index 11d3e49..8420bc8 100644
--- a/cmds/incidentd/Android.mk
+++ b/cmds/incidentd/Android.mk
@@ -14,6 +14,9 @@
LOCAL_PATH:= $(call my-dir)
+# proto files used in incidentd to generate cppstream proto headers.
+PROTO_FILES:= frameworks/base/core/proto/android/util/log.proto
+
# ========= #
# incidentd #
# ========= #
@@ -59,20 +62,38 @@
libutils
LOCAL_MODULE_CLASS := EXECUTABLES
+
gen_src_dir := $(local-generated-sources-dir)
-GEN := $(gen_src_dir)/src/section_list.cpp
-$(GEN): $(HOST_OUT_EXECUTABLES)/incident-section-gen
-$(GEN): PRIVATE_CUSTOM_TOOL = \
+# generate section_list.cpp
+GEN_LIST := $(gen_src_dir)/src/section_list.cpp
+$(GEN_LIST): $(HOST_OUT_EXECUTABLES)/incident-section-gen
+$(GEN_LIST): PRIVATE_CUSTOM_TOOL = \
$(HOST_OUT_EXECUTABLES)/incident-section-gen incidentd > $@
-$(GEN): $(HOST_OUT_EXECUTABLES)/incident-section-gen
+$(GEN_LIST): $(HOST_OUT_EXECUTABLES)/incident-section-gen
$(transform-generated-source)
-LOCAL_GENERATED_SOURCES += $(GEN)
+LOCAL_GENERATED_SOURCES += $(GEN_LIST)
+GEN_LIST:=
+
+# generate cppstream proto, add proto files to PROTO_FILES
+GEN_PROTO := $(gen_src_dir)/proto.timestamp
+$(GEN_PROTO): $(HOST_OUT_EXECUTABLES)/aprotoc $(HOST_OUT_EXECUTABLES)/protoc-gen-cppstream $(PROTO_FILES)
+$(GEN_PROTO): PRIVATE_GEN_SRC_DIR := $(gen_src_dir)
+$(GEN_PROTO): PRIVATE_CUSTOM_TOOL = \
+ $(HOST_OUT_EXECUTABLES)/aprotoc --plugin=protoc-gen-cppstream=$(HOST_OUT_EXECUTABLES)/protoc-gen-cppstream \
+ --cppstream_out=$(PRIVATE_GEN_SRC_DIR) -Iexternal/protobuf/src -I . \
+ $(PROTO_FILES) \
+ && touch $@
+$(GEN_PROTO): $(HOST_OUT_EXECUTABLES)/aprotoc
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN_PROTO)
+GEN_PROTO:=
gen_src_dir:=
-GEN:=
+ifeq ($(BUILD_WITH_INCIDENTD_RC), true)
LOCAL_INIT_RC := incidentd.rc
+endif
include $(BUILD_EXECUTABLE)
@@ -120,4 +141,22 @@
LOCAL_TEST_DATA := $(call find-test-data-in-subdirs, $(LOCAL_PATH), *, testdata)
+LOCAL_MODULE_CLASS := NATIVE_TESTS
+gen_src_dir := $(local-generated-sources-dir)
+# generate cppstream proto for testing
+GEN_PROTO := $(gen_src_dir)/log.proto.timestamp
+$(GEN_PROTO): $(HOST_OUT_EXECUTABLES)/aprotoc $(HOST_OUT_EXECUTABLES)/protoc-gen-cppstream $(PROTO_FILES)
+$(GEN_PROTO): PRIVATE_GEN_SRC_DIR := $(gen_src_dir)
+$(GEN_PROTO): PRIVATE_CUSTOM_TOOL = \
+ $(HOST_OUT_EXECUTABLES)/aprotoc --plugin=protoc-gen-cppstream=$(HOST_OUT_EXECUTABLES)/protoc-gen-cppstream \
+ --cppstream_out=$(PRIVATE_GEN_SRC_DIR) -Iexternal/protobuf/src -I . \
+ $(PROTO_FILES) \
+ && touch $@
+$(GEN_PROTO): $(HOST_OUT_EXECUTABLES)/aprotoc
+ $(transform-generated-source)
+LOCAL_GENERATED_SOURCES += $(GEN_PROTO)
+GEN_PROTO:=
+
+gen_src_dir:=
+
include $(BUILD_NATIVE_TEST)
diff --git a/cmds/incidentd/src/Section.cpp b/cmds/incidentd/src/Section.cpp
index 22053ef..61d16f8 100644
--- a/cmds/incidentd/src/Section.cpp
+++ b/cmds/incidentd/src/Section.cpp
@@ -16,21 +16,29 @@
#define LOG_TAG "incidentd"
-#include "FdBuffer.h"
-#include "Privacy.h"
-#include "PrivacyBuffer.h"
#include "Section.h"
-#include "io_util.h"
-#include "section_list.h"
+#include <errno.h>
+#include <unistd.h>
+#include <wait.h>
+
+#include <memory>
+#include <mutex>
#include <android/util/protobuf.h>
-#include <private/android_filesystem_config.h>
#include <binder/IServiceManager.h>
-#include <map>
-#include <mutex>
-#include <wait.h>
-#include <unistd.h>
+#include <log/log_event_list.h>
+#include <log/logprint.h>
+#include <log/log_read.h>
+#include <private/android_filesystem_config.h> // for AID_NOBODY
+#include <private/android_logger.h>
+
+#include "FdBuffer.h"
+#include "frameworks/base/core/proto/android/util/log.proto.h"
+#include "io_util.h"
+#include "Privacy.h"
+#include "PrivacyBuffer.h"
+#include "section_list.h"
using namespace android::util;
using namespace std;
@@ -41,7 +49,7 @@
// incident section parameters
const int WAIT_MAX = 5;
const struct timespec WAIT_INTERVAL_NS = {0, 200 * 1000 * 1000};
-const char* INCIDENT_HELPER = "/system/bin/incident_helper";
+const char INCIDENT_HELPER[] = "/system/bin/incident_helper";
static pid_t
fork_execute_incident_helper(const int id, const char* name, Fpipe& p2cPipe, Fpipe& c2pPipe)
@@ -609,3 +617,160 @@
return NO_ERROR;
}
+
+// ================================================================================
+// initialization only once in Section.cpp.
+map<log_id_t, log_time> LogSection::gLastLogsRetrieved;
+
+LogSection::LogSection(int id, log_id_t logID)
+ :WorkerThreadSection(id),
+ mLogID(logID)
+{
+ name += "logcat ";
+ name += android_log_id_to_name(logID);
+ switch (logID) {
+ case LOG_ID_EVENTS:
+ case LOG_ID_STATS:
+ case LOG_ID_SECURITY:
+ mBinary = true;
+ break;
+ default:
+ mBinary = false;
+ }
+}
+
+LogSection::~LogSection()
+{
+}
+
+static size_t
+trimTail(char const* buf, size_t len)
+{
+ while (len > 0) {
+ char c = buf[len - 1];
+ if (c == '\0' || c == ' ' || c == '\n' || c == '\r' || c == ':') {
+ len--;
+ } else {
+ break;
+ }
+ }
+ return len;
+}
+
+static inline int32_t get4LE(uint8_t const* src) {
+ return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
+}
+
+status_t
+LogSection::BlockingCall(int pipeWriteFd) const
+{
+ status_t err = NO_ERROR;
+ // Open log buffer and getting logs since last retrieved time if any.
+ unique_ptr<logger_list, void (*)(logger_list*)> loggers(
+ gLastLogsRetrieved.find(mLogID) == gLastLogsRetrieved.end() ?
+ android_logger_list_alloc(ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 0, 0) :
+ android_logger_list_alloc_time(ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK,
+ gLastLogsRetrieved[mLogID], 0),
+ android_logger_list_free);
+
+ if (android_logger_open(loggers.get(), mLogID) == NULL) {
+ ALOGW("LogSection %s: Can't get logger.", this->name.string());
+ return err;
+ }
+
+ log_msg msg;
+ log_time lastTimestamp(0);
+
+ ProtoOutputStream proto;
+ while (true) { // keeps reading until logd buffer is fully read.
+ status_t err = android_logger_list_read(loggers.get(), &msg);
+ // err = 0 - no content, unexpected connection drop or EOF.
+ // err = +ive number - size of retrieved data from logger
+ // err = -ive number, OS supplied error _except_ for -EAGAIN
+ // err = -EAGAIN, graceful indication for ANDRODI_LOG_NONBLOCK that this is the end of data.
+ if (err <= 0) {
+ if (err != -EAGAIN) {
+ ALOGE("LogSection %s: fails to read a log_msg.\n", this->name.string());
+ }
+ break;
+ }
+ if (mBinary) {
+ // remove the first uint32 which is tag's index in event log tags
+ android_log_context context = create_android_log_parser(msg.msg() + sizeof(uint32_t),
+ msg.len() - sizeof(uint32_t));;
+ android_log_list_element elem;
+
+ lastTimestamp.tv_sec = msg.entry_v1.sec;
+ lastTimestamp.tv_nsec = msg.entry_v1.nsec;
+
+ // format a BinaryLogEntry
+ long long token = proto.start(LogProto::BINARY_LOGS);
+ proto.write(BinaryLogEntry::SEC, msg.entry_v1.sec);
+ proto.write(BinaryLogEntry::NANOSEC, msg.entry_v1.nsec);
+ proto.write(BinaryLogEntry::UID, (int) msg.entry_v4.uid);
+ proto.write(BinaryLogEntry::PID, msg.entry_v1.pid);
+ proto.write(BinaryLogEntry::TID, msg.entry_v1.tid);
+ proto.write(BinaryLogEntry::TAG_INDEX, get4LE(reinterpret_cast<uint8_t const*>(msg.msg())));
+ do {
+ elem = android_log_read_next(context);
+ long long elemToken = proto.start(BinaryLogEntry::ELEMS);
+ switch (elem.type) {
+ case EVENT_TYPE_INT:
+ proto.write(BinaryLogEntry::Elem::TYPE, BinaryLogEntry::Elem::EVENT_TYPE_INT);
+ proto.write(BinaryLogEntry::Elem::VAL_INT32, (int) elem.data.int32);
+ break;
+ case EVENT_TYPE_LONG:
+ proto.write(BinaryLogEntry::Elem::TYPE, BinaryLogEntry::Elem::EVENT_TYPE_LONG);
+ proto.write(BinaryLogEntry::Elem::VAL_INT64, (long long) elem.data.int64);
+ break;
+ case EVENT_TYPE_STRING:
+ proto.write(BinaryLogEntry::Elem::TYPE, BinaryLogEntry::Elem::EVENT_TYPE_STRING);
+ proto.write(BinaryLogEntry::Elem::VAL_STRING, elem.data.string, elem.len);
+ break;
+ case EVENT_TYPE_FLOAT:
+ proto.write(BinaryLogEntry::Elem::TYPE, BinaryLogEntry::Elem::EVENT_TYPE_FLOAT);
+ proto.write(BinaryLogEntry::Elem::VAL_FLOAT, elem.data.float32);
+ break;
+ case EVENT_TYPE_LIST:
+ proto.write(BinaryLogEntry::Elem::TYPE, BinaryLogEntry::Elem::EVENT_TYPE_LIST);
+ break;
+ case EVENT_TYPE_LIST_STOP:
+ proto.write(BinaryLogEntry::Elem::TYPE, BinaryLogEntry::Elem::EVENT_TYPE_LIST_STOP);
+ break;
+ case EVENT_TYPE_UNKNOWN:
+ proto.write(BinaryLogEntry::Elem::TYPE, BinaryLogEntry::Elem::EVENT_TYPE_UNKNOWN);
+ break;
+ }
+ proto.end(elemToken);
+ } while ((elem.type != EVENT_TYPE_UNKNOWN) && !elem.complete);
+ proto.end(token);
+ if (context) {
+ android_log_destroy(&context);
+ }
+ } else {
+ AndroidLogEntry entry;
+ err = android_log_processLogBuffer(&msg.entry_v1, &entry);
+ if (err != NO_ERROR) {
+ ALOGE("LogSection %s: fails to process to an entry.\n", this->name.string());
+ break;
+ }
+ lastTimestamp.tv_sec = entry.tv_sec;
+ lastTimestamp.tv_nsec = entry.tv_nsec;
+
+ // format a TextLogEntry
+ long long token = proto.start(LogProto::TEXT_LOGS);
+ proto.write(TextLogEntry::SEC, (long long)entry.tv_sec);
+ proto.write(TextLogEntry::NANOSEC, (long long)entry.tv_nsec);
+ proto.write(TextLogEntry::PRIORITY, (int)entry.priority);
+ proto.write(TextLogEntry::UID, entry.uid);
+ proto.write(TextLogEntry::PID, entry.pid);
+ proto.write(TextLogEntry::TID, entry.tid);
+ proto.write(TextLogEntry::TAG, entry.tag, trimTail(entry.tag, entry.tagLen));
+ proto.write(TextLogEntry::LOG, entry.message, trimTail(entry.message, entry.messageLen));
+ proto.end(token);
+ }
+ }
+ gLastLogsRetrieved[mLogID] = lastTimestamp;
+ proto.flush(pipeWriteFd);
+ return err;
+}
diff --git a/cmds/incidentd/src/Section.h b/cmds/incidentd/src/Section.h
index 64558a6..d440ee9 100644
--- a/cmds/incidentd/src/Section.h
+++ b/cmds/incidentd/src/Section.h
@@ -19,7 +19,9 @@
#include "Reporter.h"
+#include <map>
#include <stdarg.h>
+
#include <utils/String8.h>
#include <utils/String16.h>
#include <utils/Vector.h>
@@ -122,5 +124,24 @@
Vector<String16> mArgs;
};
+/**
+ * Section that reads from logd.
+ */
+class LogSection : public WorkerThreadSection
+{
+ // global last log retrieved timestamp for each log_id_t.
+ static map<log_id_t, log_time> gLastLogsRetrieved;
+
+public:
+ LogSection(int id, log_id_t logID);
+ virtual ~LogSection();
+
+ virtual status_t BlockingCall(int pipeWriteFd) const;
+
+private:
+ log_id_t mLogID;
+ bool mBinary;
+};
+
#endif // SECTIONS_H
diff --git a/cmds/incidentd/src/section_list.h b/cmds/incidentd/src/section_list.h
index dfd2312..ddc0505 100644
--- a/cmds/incidentd/src/section_list.h
+++ b/cmds/incidentd/src/section_list.h
@@ -17,6 +17,8 @@
#ifndef SECTION_LIST_H
#define SECTION_LIST_H
+#include <log/log_event_list.h> // include log_id_t enums.
+
#include "Privacy.h"
#include "Section.h"
diff --git a/cmds/incidentd/tests/Section_test.cpp b/cmds/incidentd/tests/Section_test.cpp
index 0c7876c..cbfb896 100644
--- a/cmds/incidentd/tests/Section_test.cpp
+++ b/cmds/incidentd/tests/Section_test.cpp
@@ -155,7 +155,7 @@
}
TEST(SectionTest, CommandSectionBadCommand) {
- CommandSection cs(NOOP_PARSER, "echo", "about", NULL);
+ CommandSection cs(NOOP_PARSER, "echoo", "about", NULL);
ReportRequestSet requests;
ASSERT_EQ(NAME_NOT_FOUND, cs.Execute(&requests));
}
@@ -167,6 +167,26 @@
ASSERT_EQ(NO_ERROR, cs.Execute(&requests));
}
+TEST(SectionTest, LogSectionBinary) {
+ LogSection ls(1, LOG_ID_EVENTS);
+ ReportRequestSet requests;
+ requests.setMainFd(STDOUT_FILENO);
+ CaptureStdout();
+ ASSERT_EQ(NO_ERROR, ls.Execute(&requests));
+ string results = GetCapturedStdout();
+ EXPECT_FALSE(results.empty());
+}
+
+TEST(SectionTest, LogSectionSystem) {
+ LogSection ls(1, LOG_ID_SYSTEM);
+ ReportRequestSet requests;
+ requests.setMainFd(STDOUT_FILENO);
+ CaptureStdout();
+ ASSERT_EQ(NO_ERROR, ls.Execute(&requests));
+ string results = GetCapturedStdout();
+ EXPECT_FALSE(results.empty());
+}
+
TEST(SectionTest, TestFilterPiiTaggedFields) {
TemporaryFile tf;
FileSection fs(NOOP_PARSER, tf.path);
diff --git a/cmds/statsd/Android.mk b/cmds/statsd/Android.mk
index d829243..735efe3 100644
--- a/cmds/statsd/Android.mk
+++ b/cmds/statsd/Android.mk
@@ -34,6 +34,7 @@
src/config/ConfigKey.cpp \
src/config/ConfigListener.cpp \
src/config/ConfigManager.cpp \
+ src/external/StatsPuller.cpp \
src/external/StatsCompanionServicePuller.cpp \
src/external/ResourcePowerManagerPuller.cpp \
src/external/CpuTimePerUidPuller.cpp \
diff --git a/cmds/statsd/src/StatsLogProcessor.cpp b/cmds/statsd/src/StatsLogProcessor.cpp
index 991badc..a9e0f23 100644
--- a/cmds/statsd/src/StatsLogProcessor.cpp
+++ b/cmds/statsd/src/StatsLogProcessor.cpp
@@ -82,9 +82,7 @@
void StatsLogProcessor::onAnomalyAlarmFired(
const uint64_t timestampNs,
unordered_set<sp<const AnomalyAlarm>, SpHash<AnomalyAlarm>> anomalySet) {
- // TODO: This is a thread-safety issue. mMetricsManagers could change under our feet.
- // TODO: Solution? Lock everything! :(
- // TODO: Question: Can we replace the other lock (broadcast), or do we need to supplement it?
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
for (const auto& itr : mMetricsManagers) {
itr.second->onAnomalyAlarmFired(timestampNs, anomalySet);
}
@@ -92,11 +90,13 @@
// TODO: what if statsd service restarts? How do we know what logs are already processed before?
void StatsLogProcessor::OnLogEvent(const LogEvent& msg) {
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
+
StatsdStats::getInstance().noteAtomLogged(msg.GetTagId(), msg.GetTimestampNs() / NS_PER_SEC);
// pass the event to metrics managers.
for (auto& pair : mMetricsManagers) {
pair.second->onLogEvent(msg);
- flushIfNecessary(msg.GetTimestampNs(), pair.first, *(pair.second));
+ flushIfNecessaryLocked(msg.GetTimestampNs(), pair.first, *(pair.second));
}
// Hard-coded logic to update the isolated uid's in the uid-map.
// The field numbers need to be currently updated by hand with atoms.proto
@@ -116,6 +116,7 @@
}
void StatsLogProcessor::OnConfigUpdated(const ConfigKey& key, const StatsdConfig& config) {
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
ALOGD("Updated configuration for key %s", key.ToString().c_str());
sp<MetricsManager> newMetricsManager = new MetricsManager(key, config, mTimeBaseSec, mUidMap);
auto it = mMetricsManagers.find(key);
@@ -142,6 +143,7 @@
}
size_t StatsLogProcessor::GetMetricsSize(const ConfigKey& key) const {
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
auto it = mMetricsManagers.find(key);
if (it == mMetricsManagers.end()) {
ALOGW("Config source %s does not exist", key.ToString().c_str());
@@ -152,6 +154,7 @@
void StatsLogProcessor::onDumpReport(const ConfigKey& key, const uint64_t& dumpTimeStampNs,
ConfigMetricsReportList* report) {
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
auto it = mMetricsManagers.find(key);
if (it == mMetricsManagers.end()) {
ALOGW("Config source %s does not exist", key.ToString().c_str());
@@ -165,6 +168,7 @@
}
void StatsLogProcessor::onDumpReport(const ConfigKey& key, vector<uint8_t>* outData) {
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
auto it = mMetricsManagers.find(key);
if (it == mMetricsManagers.end()) {
ALOGW("Config source %s does not exist", key.ToString().c_str());
@@ -173,9 +177,7 @@
// This allows another broadcast to be sent within the rate-limit period if we get close to
// filling the buffer again soon.
- mBroadcastTimesMutex.lock();
mLastBroadcastTimes.erase(key);
- mBroadcastTimesMutex.unlock();
ProtoOutputStream proto;
@@ -224,6 +226,7 @@
}
void StatsLogProcessor::OnConfigRemoved(const ConfigKey& key) {
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
auto it = mMetricsManagers.find(key);
if (it != mMetricsManagers.end()) {
mMetricsManagers.erase(it);
@@ -231,14 +234,11 @@
}
StatsdStats::getInstance().noteConfigRemoved(key);
- std::lock_guard<std::mutex> lock(mBroadcastTimesMutex);
mLastBroadcastTimes.erase(key);
}
-void StatsLogProcessor::flushIfNecessary(uint64_t timestampNs, const ConfigKey& key,
- MetricsManager& metricsManager) {
- std::lock_guard<std::mutex> lock(mBroadcastTimesMutex);
-
+void StatsLogProcessor::flushIfNecessaryLocked(
+ uint64_t timestampNs, const ConfigKey& key, MetricsManager& metricsManager) {
auto lastCheckTime = mLastByteSizeTimes.find(key);
if (lastCheckTime != mLastByteSizeTimes.end()) {
if (timestampNs - lastCheckTime->second < StatsdStats::kMinByteSizeCheckPeriodNs) {
@@ -274,6 +274,7 @@
void StatsLogProcessor::WriteDataToDisk() {
mkdir(STATS_DATA_DIR, S_IRWXU);
+ std::lock_guard<std::mutex> lock(mMetricsMutex);
for (auto& pair : mMetricsManagers) {
const ConfigKey& key = pair.first;
vector<uint8_t> data;
diff --git a/cmds/statsd/src/StatsLogProcessor.h b/cmds/statsd/src/StatsLogProcessor.h
index f62fc4e..b527e27 100644
--- a/cmds/statsd/src/StatsLogProcessor.h
+++ b/cmds/statsd/src/StatsLogProcessor.h
@@ -57,7 +57,7 @@
void WriteDataToDisk();
private:
- mutable mutex mBroadcastTimesMutex;
+ mutable mutex mMetricsMutex;
std::unordered_map<ConfigKey, sp<MetricsManager>> mMetricsManagers;
@@ -72,8 +72,8 @@
/* Check if we should send a broadcast if approaching memory limits and if we're over, we
* actually delete the data. */
- void flushIfNecessary(uint64_t timestampNs, const ConfigKey& key,
- MetricsManager& metricsManager);
+ void flushIfNecessaryLocked(uint64_t timestampNs, const ConfigKey& key,
+ MetricsManager& metricsManager);
// Function used to send a broadcast so that receiver for the config key can call getData
// to retrieve the stored data.
diff --git a/cmds/statsd/src/atoms.proto b/cmds/statsd/src/atoms.proto
index 221a554..7f77ef7 100644
--- a/cmds/statsd/src/atoms.proto
+++ b/cmds/statsd/src/atoms.proto
@@ -81,25 +81,28 @@
DropboxErrorChanged dropbox_error_changed = 45;
AnomalyDetected anomaly_detected = 46;
AppHook app_hook = 47;
+ AppStartChanged app_start_changed = 48;
+ AppStartCancelChanged app_start_cancel_changed = 49;
+ AppStartFullyDrawnChanged app_start_fully_drawn_changed = 50;
// TODO: Reorder the numbering so that the most frequent occur events occur in the first 15.
}
- // Pulled events will start at field 1000.
+ // Pulled events will start at field 10000.
oneof pulled {
- WifiBytesTransfer wifi_bytes_transfer = 1000;
- WifiBytesTransferByFgBg wifi_bytes_transfer_by_fg_bg = 1001;
- MobileBytesTransfer mobile_bytes_transfer = 1002;
- MobileBytesTransferByFgBg mobile_bytes_transfer_by_fg_bg = 1003;
- KernelWakelock kernel_wakelock = 1004;
- PlatformSleepState platform_sleep_state = 1005;
- SleepStateVoter sleep_state_voter = 1006;
- SubsystemSleepState subsystem_sleep_state = 1007;
- CpuTimePerFreq cpu_time_per_freq = 1008;
- CpuTimePerUid cpu_time_per_uid = 1009;
- CpuTimePerUidFreq cpu_time_per_uid_freq = 1010;
- WifiActivityEnergyInfo wifi_activity_energy_info = 1011;
- ModemActivityInfo modem_activity_info = 1012;
- AttributionChainDummyAtom attribution_chain_dummy_atom = 10000;
+ WifiBytesTransfer wifi_bytes_transfer = 10000;
+ WifiBytesTransferByFgBg wifi_bytes_transfer_by_fg_bg = 10001;
+ MobileBytesTransfer mobile_bytes_transfer = 10002;
+ MobileBytesTransferByFgBg mobile_bytes_transfer_by_fg_bg = 10003;
+ KernelWakelock kernel_wakelock = 10004;
+ PlatformSleepState platform_sleep_state = 10005;
+ SleepStateVoter sleep_state_voter = 10006;
+ SubsystemSleepState subsystem_sleep_state = 10007;
+ CpuTimePerFreq cpu_time_per_freq = 10008;
+ CpuTimePerUid cpu_time_per_uid = 10009;
+ CpuTimePerUidFreq cpu_time_per_uid_freq = 10010;
+ WifiActivityEnergyInfo wifi_activity_energy_info = 10011;
+ ModemActivityInfo modem_activity_info = 10012;
+ AttributionChainDummyAtom attribution_chain_dummy_atom = 100000;
}
}
@@ -800,16 +803,19 @@
optional string process_name = 3;
// The pid if available. -1 means not available.
- optional int32 pid = 4;
+ optional sint32 pid = 4;
// 1 indicates is instant app. -1 indicates Not applicable.
- optional int32 is_instant_app = 5;
+ optional sint32 is_instant_app = 5;
// The activity name if available.
optional string activity_name = 6;
+ // The package name if available.
+ optional string package_name = 7;
+
// 1 indicates in foreground. -1 indicates not available.
- optional int32 is_foreground = 7;
+ optional sint32 is_foreground = 8;
}
/*
@@ -852,6 +858,100 @@
optional int64 alert_id = 3;
}
+message AppStartChanged {
+ // The uid if available. -1 means not available.
+ optional int32 uid = 1;
+
+ // The app package name.
+ optional string pkg_name = 2;
+
+ enum TransitionType {
+ APP_START_TRANSITION_TYPE_UNKNOWN = 0;
+ WARM = 1;
+ HOT = 2;
+ COLD = 3;
+ }
+ // The transition type.
+ optional TransitionType type = 3;
+
+ // The activity name.
+ optional string activity_name = 4;
+
+ // The name of the calling app. Empty if not set.
+ optional string calling_pkg_name = 5;
+
+ // Whether the app is an instant app.
+ optional bool is_instant_app = 6;
+
+ // Device uptime when activity started.
+ optional int64 activity_start_msec = 7;
+
+ // TODO: Update android/app/ActivityManagerInternal.java constants to depend on our proto enum.
+ enum TransitionReason {
+ APP_START_TRANSITION_REASON_UNKNOWN = 0;
+ SPLASH_SCREEN = 1;
+ WINDOWS_DRAWN = 2;
+ TIMEOUT = 3;
+ SNAPSHOT = 4;
+ }
+ optional TransitionReason reason = 8;
+
+ optional int32 transition_delay_msec = 9;
+ // -1 if not set.
+ optional int32 starting_window_delay_msec = 10;
+ // -1 if not set.
+ optional int32 bind_application_delay_msec = 11;
+ optional int32 windows_drawn_delay_msec = 12;
+
+ // Empty if not set.
+ optional string launch_token = 13;
+
+}
+
+message AppStartCancelChanged {
+ // The uid if available. -1 means not available.
+ optional int32 uid = 1;
+
+ // The app package name.
+ optional string pkg_name = 2;
+
+ enum TransitionType {
+ APP_START_TRANSITION_TYPE_UNKNOWN = 0;
+ WARM = 1;
+ HOT = 2;
+ COLD = 3;
+ }
+ // The transition type.
+ optional TransitionType type = 3;
+
+ // The activity name.
+ optional string activity_name = 4;
+}
+
+message AppStartFullyDrawnChanged {
+ // The uid if available. -1 means not available.
+ optional int32 uid = 1;
+
+ // The app package name.
+ optional string pkg_name = 2;
+
+ enum TransitionType {
+ APP_START_TRANSITION_TYPE_UNKNOWN = 0;
+ WITH_BUNDLE = 1;
+ WITHOUT_BUNDLE = 2;
+ }
+ // The transition type.
+ optional TransitionType type = 3;
+
+ // The activity name.
+ optional string activity_name = 4;
+
+ optional bool transition_process_running = 5;
+
+ // App startup time (until call to Activity#reportFullyDrawn()).
+ optional int64 app_startup_time_ms = 6;
+}
+
/**
* Pulls bytes transferred via wifi (Sum of foreground and background usage).
*
diff --git a/cmds/statsd/src/external/CpuTimePerUidFreqPuller.cpp b/cmds/statsd/src/external/CpuTimePerUidFreqPuller.cpp
index 9738760..a61afb4 100644
--- a/cmds/statsd/src/external/CpuTimePerUidFreqPuller.cpp
+++ b/cmds/statsd/src/external/CpuTimePerUidFreqPuller.cpp
@@ -20,6 +20,9 @@
#include <fstream>
#include "external/CpuTimePerUidFreqPuller.h"
+#include "../guardrail/StatsdStats.h"
+#include "CpuTimePerUidFreqPuller.h"
+#include "guardrail/StatsdStats.h"
#include "logd/LogEvent.h"
#include "statslog.h"
@@ -45,43 +48,47 @@
* This provides the times a UID's processes spent executing at each different cpu frequency.
* The file contains a monotonically increasing count of time for a single boot.
*/
-bool CpuTimePerUidFreqPuller::Pull(const int tagId, vector<shared_ptr<LogEvent>>* data) {
- data->clear();
+CpuTimePerUidFreqPuller::CpuTimePerUidFreqPuller()
+ : StatsPuller(android::util::CPU_TIME_PER_UID_FREQ) {
+}
- ifstream fin;
- fin.open(sProcFile);
- if (!fin.good()) {
- VLOG("Failed to read pseudo file %s", sProcFile.c_str());
- return false;
- }
+bool CpuTimePerUidFreqPuller::PullInternal(vector<shared_ptr<LogEvent>>* data) {
+ data->clear();
- uint64_t timestamp = time(nullptr) * NS_PER_SEC;
- char buf[kLineBufferSize];
- // first line prints the format and frequencies
- fin.getline(buf, kLineBufferSize);
- char * pch;
- while(!fin.eof()){
+ ifstream fin;
+ fin.open(sProcFile);
+ if (!fin.good()) {
+ VLOG("Failed to read pseudo file %s", sProcFile.c_str());
+ return false;
+ }
+
+ uint64_t timestamp = time(nullptr) * NS_PER_SEC;
+ char buf[kLineBufferSize];
+ // first line prints the format and frequencies
fin.getline(buf, kLineBufferSize);
- pch = strtok (buf, " :");
- if (pch == NULL) break;
- uint64_t uid = std::stoull(pch);
- pch = strtok(NULL, " ");
- uint64_t timeMs;
- int idx = 0;
- do {
- timeMs = std::stoull(pch);
- auto ptr = make_shared<LogEvent>(android::util::CPU_TIME_PER_UID_FREQ, timestamp);
- ptr->write(uid);
- ptr->write(idx);
- ptr->write(timeMs);
- ptr->init();
- data->push_back(ptr);
- VLOG("uid %lld, freq idx %d, sys time %lld", (long long)uid, idx, (long long)timeMs);
- idx ++;
- pch = strtok(NULL, " ");
- } while (pch != NULL);
- }
- return true;
+ char* pch;
+ while (!fin.eof()) {
+ fin.getline(buf, kLineBufferSize);
+ pch = strtok(buf, " :");
+ if (pch == NULL) break;
+ uint64_t uid = std::stoull(pch);
+ pch = strtok(NULL, " ");
+ uint64_t timeMs;
+ int idx = 0;
+ do {
+ timeMs = std::stoull(pch);
+ auto ptr = make_shared<LogEvent>(android::util::CPU_TIME_PER_UID_FREQ, timestamp);
+ ptr->write(uid);
+ ptr->write(idx);
+ ptr->write(timeMs);
+ ptr->init();
+ data->push_back(ptr);
+ VLOG("uid %lld, freq idx %d, sys time %lld", (long long)uid, idx, (long long)timeMs);
+ idx++;
+ pch = strtok(NULL, " ");
+ } while (pch != NULL);
+ }
+ return true;
}
} // namespace statsd
diff --git a/cmds/statsd/src/external/CpuTimePerUidFreqPuller.h b/cmds/statsd/src/external/CpuTimePerUidFreqPuller.h
index 839e5aa..6f6c669 100644
--- a/cmds/statsd/src/external/CpuTimePerUidFreqPuller.h
+++ b/cmds/statsd/src/external/CpuTimePerUidFreqPuller.h
@@ -33,7 +33,8 @@
*/
class CpuTimePerUidFreqPuller : public StatsPuller {
public:
- bool Pull(const int tagId, vector<std::shared_ptr<LogEvent>>* data) override;
+ CpuTimePerUidFreqPuller();
+ bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override;
};
} // namespace statsd
diff --git a/cmds/statsd/src/external/CpuTimePerUidPuller.cpp b/cmds/statsd/src/external/CpuTimePerUidPuller.cpp
index f69b9b5..e7ea4b9 100644
--- a/cmds/statsd/src/external/CpuTimePerUidPuller.cpp
+++ b/cmds/statsd/src/external/CpuTimePerUidPuller.cpp
@@ -20,6 +20,8 @@
#include <fstream>
#include "external/CpuTimePerUidPuller.h"
+#include "CpuTimePerUidPuller.h"
+#include "guardrail/StatsdStats.h"
#include "logd/LogEvent.h"
#include "statslog.h"
@@ -42,38 +44,42 @@
* This provides the time a UID's processes spent executing in user-space and kernel-space.
* The file contains a monotonically increasing count of time for a single boot.
*/
-bool CpuTimePerUidPuller::Pull(const int tagId, vector<shared_ptr<LogEvent>>* data) {
- data->clear();
+CpuTimePerUidPuller::CpuTimePerUidPuller() : StatsPuller(android::util::CPU_TIME_PER_UID) {
+}
- ifstream fin;
- fin.open(sProcFile);
- if (!fin.good()) {
- VLOG("Failed to read pseudo file %s", sProcFile.c_str());
- return false;
- }
+bool CpuTimePerUidPuller::PullInternal(vector<shared_ptr<LogEvent>>* data) {
+ data->clear();
- uint64_t timestamp = time(nullptr) * NS_PER_SEC;
- char buf[kLineBufferSize];
- char * pch;
- while(!fin.eof()){
- fin.getline(buf, kLineBufferSize);
- pch = strtok(buf, " :");
- if (pch == NULL) break;
- uint64_t uid = std::stoull(pch);
- pch = strtok(buf, " ");
- uint64_t userTimeMs = std::stoull(pch);
- pch = strtok(buf, " ");
- uint64_t sysTimeMs = std::stoull(pch);
+ ifstream fin;
+ fin.open(sProcFile);
+ if (!fin.good()) {
+ VLOG("Failed to read pseudo file %s", sProcFile.c_str());
+ return false;
+ }
- auto ptr = make_shared<LogEvent>(android::util::CPU_TIME_PER_UID, timestamp);
- ptr->write(uid);
- ptr->write(userTimeMs);
- ptr->write(sysTimeMs);
- ptr->init();
- data->push_back(ptr);
- VLOG("uid %lld, user time %lld, sys time %lld", (long long)uid, (long long)userTimeMs, (long long)sysTimeMs);
- }
- return true;
+ uint64_t timestamp = time(nullptr) * NS_PER_SEC;
+ char buf[kLineBufferSize];
+ char* pch;
+ while (!fin.eof()) {
+ fin.getline(buf, kLineBufferSize);
+ pch = strtok(buf, " :");
+ if (pch == NULL) break;
+ uint64_t uid = std::stoull(pch);
+ pch = strtok(buf, " ");
+ uint64_t userTimeMs = std::stoull(pch);
+ pch = strtok(buf, " ");
+ uint64_t sysTimeMs = std::stoull(pch);
+
+ auto ptr = make_shared<LogEvent>(android::util::CPU_TIME_PER_UID, timestamp);
+ ptr->write(uid);
+ ptr->write(userTimeMs);
+ ptr->write(sysTimeMs);
+ ptr->init();
+ data->push_back(ptr);
+ VLOG("uid %lld, user time %lld, sys time %lld", (long long)uid, (long long)userTimeMs,
+ (long long)sysTimeMs);
+ }
+ return true;
}
} // namespace statsd
diff --git a/cmds/statsd/src/external/CpuTimePerUidPuller.h b/cmds/statsd/src/external/CpuTimePerUidPuller.h
index 9bb8946..d0d39d0 100644
--- a/cmds/statsd/src/external/CpuTimePerUidPuller.h
+++ b/cmds/statsd/src/external/CpuTimePerUidPuller.h
@@ -33,7 +33,8 @@
*/
class CpuTimePerUidPuller : public StatsPuller {
public:
- bool Pull(const int tagId, vector<std::shared_ptr<LogEvent>>* data) override;
+ CpuTimePerUidPuller();
+ bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override;
};
} // namespace statsd
diff --git a/cmds/statsd/src/external/ResourcePowerManagerPuller.cpp b/cmds/statsd/src/external/ResourcePowerManagerPuller.cpp
index cb9f1cc..2e29fb0 100644
--- a/cmds/statsd/src/external/ResourcePowerManagerPuller.cpp
+++ b/cmds/statsd/src/external/ResourcePowerManagerPuller.cpp
@@ -33,6 +33,7 @@
#include "external/ResourcePowerManagerPuller.h"
#include "external/StatsPuller.h"
+#include "ResourcePowerManagerPuller.h"
#include "logd/LogEvent.h"
#include "statslog.h"
@@ -72,7 +73,10 @@
return gPowerHalV1_0 != nullptr;
}
-bool ResourcePowerManagerPuller::Pull(const int tagId, vector<shared_ptr<LogEvent>>* data) {
+ResourcePowerManagerPuller::ResourcePowerManagerPuller(int tagId) : StatsPuller(tagId) {
+}
+
+bool ResourcePowerManagerPuller::PullInternal(vector<shared_ptr<LogEvent>>* data) {
std::lock_guard<std::mutex> lock(gPowerHalMutex);
if (!getPowerHal()) {
@@ -83,79 +87,87 @@
uint64_t timestamp = time(nullptr) * NS_PER_SEC;
data->clear();
- Return<void> ret = gPowerHalV1_0->getPlatformLowPowerStats(
- [&data, timestamp](hidl_vec<PowerStatePlatformSleepState> states, Status status) {
- if (status != Status::SUCCESS) return;
-
- for (size_t i = 0; i < states.size(); i++) {
- const PowerStatePlatformSleepState& state = states[i];
-
- auto statePtr = make_shared<LogEvent>(
- android::util::PLATFORM_SLEEP_STATE, timestamp);
- statePtr->write(state.name);
- statePtr->write(state.residencyInMsecSinceBoot);
- statePtr->write(state.totalTransitions);
- statePtr->write(state.supportedOnlyInSuspend);
- statePtr->init();
- data->push_back(statePtr);
- VLOG("powerstate: %s, %lld, %lld, %d", state.name.c_str(),
- (long long)state.residencyInMsecSinceBoot,
- (long long)state.totalTransitions, state.supportedOnlyInSuspend ? 1 : 0);
- for (auto voter : state.voters) {
- auto voterPtr =
- make_shared<LogEvent>(android::util::SLEEP_STATE_VOTER, timestamp);
- voterPtr->write(state.name);
- voterPtr->write(voter.name);
- voterPtr->write(voter.totalTimeInMsecVotedForSinceBoot);
- voterPtr->write(voter.totalNumberOfTimesVotedSinceBoot);
- voterPtr->init();
- data->push_back(voterPtr);
- VLOG("powerstatevoter: %s, %s, %lld, %lld", state.name.c_str(),
- voter.name.c_str(), (long long)voter.totalTimeInMsecVotedForSinceBoot,
- (long long)voter.totalNumberOfTimesVotedSinceBoot);
- }
- }
- });
- if (!ret.isOk()) {
- ALOGE("getLowPowerStats() failed: power HAL service not available");
- gPowerHalV1_0 = nullptr;
- return false;
- }
-
- // Trying to cast to IPower 1.1, this will succeed only for devices supporting 1.1
- sp<android::hardware::power::V1_1::IPower> gPowerHal_1_1 =
- android::hardware::power::V1_1::IPower::castFrom(gPowerHalV1_0);
- if (gPowerHal_1_1 != nullptr) {
- ret = gPowerHal_1_1->getSubsystemLowPowerStats(
- [&data, timestamp](hidl_vec<PowerStateSubsystem> subsystems, Status status) {
-
+ Return<void> ret;
+ if (mTagId == android::util::PLATFORM_SLEEP_STATE ||
+ mTagId == android::util::SLEEP_STATE_VOTER) {
+ ret = gPowerHalV1_0->getPlatformLowPowerStats(
+ [&data, timestamp](hidl_vec<PowerStatePlatformSleepState> states, Status status) {
if (status != Status::SUCCESS) return;
- if (subsystems.size() > 0) {
- for (size_t i = 0; i < subsystems.size(); i++) {
- const PowerStateSubsystem& subsystem = subsystems[i];
- for (size_t j = 0; j < subsystem.states.size(); j++) {
- const PowerStateSubsystemSleepState& state = subsystem.states[j];
- auto subsystemStatePtr = make_shared<LogEvent>(
- android::util::SUBSYSTEM_SLEEP_STATE, timestamp);
- subsystemStatePtr->write(subsystem.name);
- subsystemStatePtr->write(state.name);
- subsystemStatePtr->write(state.residencyInMsecSinceBoot);
- subsystemStatePtr->write(state.totalTransitions);
- subsystemStatePtr->write(state.lastEntryTimestampMs);
- subsystemStatePtr->write(state.supportedOnlyInSuspend);
- subsystemStatePtr->init();
- data->push_back(subsystemStatePtr);
- VLOG("subsystemstate: %s, %s, %lld, %lld, %lld",
- subsystem.name.c_str(), state.name.c_str(),
- (long long)state.residencyInMsecSinceBoot,
- (long long)state.totalTransitions,
- (long long)state.lastEntryTimestampMs);
- }
+ for (size_t i = 0; i < states.size(); i++) {
+ const PowerStatePlatformSleepState& state = states[i];
+
+ auto statePtr = make_shared<LogEvent>(android::util::PLATFORM_SLEEP_STATE,
+ timestamp);
+ statePtr->write(state.name);
+ statePtr->write(state.residencyInMsecSinceBoot);
+ statePtr->write(state.totalTransitions);
+ statePtr->write(state.supportedOnlyInSuspend);
+ statePtr->init();
+ data->push_back(statePtr);
+ VLOG("powerstate: %s, %lld, %lld, %d", state.name.c_str(),
+ (long long)state.residencyInMsecSinceBoot,
+ (long long)state.totalTransitions,
+ state.supportedOnlyInSuspend ? 1 : 0);
+ for (auto voter : state.voters) {
+ auto voterPtr = make_shared<LogEvent>(android::util::SLEEP_STATE_VOTER,
+ timestamp);
+ voterPtr->write(state.name);
+ voterPtr->write(voter.name);
+ voterPtr->write(voter.totalTimeInMsecVotedForSinceBoot);
+ voterPtr->write(voter.totalNumberOfTimesVotedSinceBoot);
+ voterPtr->init();
+ data->push_back(voterPtr);
+ VLOG("powerstatevoter: %s, %s, %lld, %lld", state.name.c_str(),
+ voter.name.c_str(),
+ (long long)voter.totalTimeInMsecVotedForSinceBoot,
+ (long long)voter.totalNumberOfTimesVotedSinceBoot);
}
}
});
+ if (!ret.isOk()) {
+ ALOGE("getLowPowerStats() failed: power HAL service not available");
+ gPowerHalV1_0 = nullptr;
+ return false;
+ }
+ }
+
+ if (mTagId == android::util::SUBSYSTEM_SLEEP_STATE) {
+ // Trying to cast to IPower 1.1, this will succeed only for devices supporting 1.1
+ sp<android::hardware::power::V1_1::IPower> gPowerHal_1_1 =
+ android::hardware::power::V1_1::IPower::castFrom(gPowerHalV1_0);
+ if (gPowerHal_1_1 != nullptr) {
+ ret = gPowerHal_1_1->getSubsystemLowPowerStats(
+ [&data, timestamp](hidl_vec<PowerStateSubsystem> subsystems, Status status) {
+ if (status != Status::SUCCESS) return;
+
+ if (subsystems.size() > 0) {
+ for (size_t i = 0; i < subsystems.size(); i++) {
+ const PowerStateSubsystem& subsystem = subsystems[i];
+ for (size_t j = 0; j < subsystem.states.size(); j++) {
+ const PowerStateSubsystemSleepState& state =
+ subsystem.states[j];
+ auto subsystemStatePtr = make_shared<LogEvent>(
+ android::util::SUBSYSTEM_SLEEP_STATE, timestamp);
+ subsystemStatePtr->write(subsystem.name);
+ subsystemStatePtr->write(state.name);
+ subsystemStatePtr->write(state.residencyInMsecSinceBoot);
+ subsystemStatePtr->write(state.totalTransitions);
+ subsystemStatePtr->write(state.lastEntryTimestampMs);
+ subsystemStatePtr->write(state.supportedOnlyInSuspend);
+ subsystemStatePtr->init();
+ data->push_back(subsystemStatePtr);
+ VLOG("subsystemstate: %s, %s, %lld, %lld, %lld",
+ subsystem.name.c_str(), state.name.c_str(),
+ (long long)state.residencyInMsecSinceBoot,
+ (long long)state.totalTransitions,
+ (long long)state.lastEntryTimestampMs);
+ }
+ }
+ }
+ });
+ }
}
return true;
}
diff --git a/cmds/statsd/src/external/ResourcePowerManagerPuller.h b/cmds/statsd/src/external/ResourcePowerManagerPuller.h
index c396c12..3399408 100644
--- a/cmds/statsd/src/external/ResourcePowerManagerPuller.h
+++ b/cmds/statsd/src/external/ResourcePowerManagerPuller.h
@@ -28,7 +28,8 @@
*/
class ResourcePowerManagerPuller : public StatsPuller {
public:
- bool Pull(const int tagId, vector<std::shared_ptr<LogEvent>>* data) override;
+ ResourcePowerManagerPuller(int tagId);
+ bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override;
};
} // namespace statsd
diff --git a/cmds/statsd/src/external/StatsCompanionServicePuller.cpp b/cmds/statsd/src/external/StatsCompanionServicePuller.cpp
index ffe1be9..b955f1c 100644
--- a/cmds/statsd/src/external/StatsCompanionServicePuller.cpp
+++ b/cmds/statsd/src/external/StatsCompanionServicePuller.cpp
@@ -22,6 +22,7 @@
#include <private/android_filesystem_config.h>
#include "StatsCompanionServicePuller.h"
#include "StatsService.h"
+#include "guardrail/StatsdStats.h"
using namespace android;
using namespace android::base;
@@ -39,13 +40,16 @@
// The reading and parsing are implemented in Java. It is not difficult to port over. But for now
// let StatsCompanionService handle that and send the data back.
-bool StatsCompanionServicePuller::Pull(const int tagId, vector<shared_ptr<LogEvent> >* data) {
+StatsCompanionServicePuller::StatsCompanionServicePuller(int tagId) : StatsPuller(tagId) {
+}
+
+bool StatsCompanionServicePuller::PullInternal(vector<shared_ptr<LogEvent> >* data) {
sp<IStatsCompanionService> statsCompanion = StatsService::getStatsCompanionService();
vector<StatsLogEventWrapper> returned_value;
if (statsCompanion != NULL) {
- Status status = statsCompanion->pullData(tagId, &returned_value);
+ Status status = statsCompanion->pullData(mTagId, &returned_value);
if (!status.isOk()) {
- ALOGW("error pulling for %d", tagId);
+ ALOGW("error pulling for %d", mTagId);
return false;
}
data->clear();
@@ -60,7 +64,7 @@
std::copy(it.bytes.begin(), it.bytes.end(), tmp.buf + kLogMsgHeaderSize);
data->push_back(make_shared<LogEvent>(tmp));
}
- ALOGD("StatsCompanionServicePuller::pull succeeded for %d", tagId);
+ ALOGD("StatsCompanionServicePuller::pull succeeded for %d", mTagId);
return true;
} else {
ALOGW("statsCompanion not found!");
diff --git a/cmds/statsd/src/external/StatsCompanionServicePuller.h b/cmds/statsd/src/external/StatsCompanionServicePuller.h
index 3ff2274..4c91f31 100644
--- a/cmds/statsd/src/external/StatsCompanionServicePuller.h
+++ b/cmds/statsd/src/external/StatsCompanionServicePuller.h
@@ -25,7 +25,8 @@
class StatsCompanionServicePuller : public StatsPuller {
public:
- bool Pull(const int tagId, vector<std::shared_ptr<LogEvent> >* data) override;
+ StatsCompanionServicePuller(int tagId);
+ bool PullInternal(vector<std::shared_ptr<LogEvent> >* data) override;
};
} // namespace statsd
diff --git a/cmds/statsd/src/external/StatsPuller.cpp b/cmds/statsd/src/external/StatsPuller.cpp
new file mode 100644
index 0000000..cadc535
--- /dev/null
+++ b/cmds/statsd/src/external/StatsPuller.cpp
@@ -0,0 +1,64 @@
+/*
+ * 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.
+ */
+
+#define DEBUG false // STOPSHIP if true
+#include "Log.h"
+
+#include "StatsPuller.h"
+#include "guardrail/StatsdStats.h"
+
+namespace android {
+namespace os {
+namespace statsd {
+
+using std::lock_guard;
+
+// ValueMetric has a minimum bucket size of 10min so that we don't pull too frequently
+StatsPuller::StatsPuller(const int tagId)
+ : mTagId(tagId) {
+ if (StatsdStats::kPullerCooldownMap.find(tagId) == StatsdStats::kPullerCooldownMap.end()) {
+ mCoolDownSec = StatsdStats::kDefaultPullerCooldown;
+ } else {
+ mCoolDownSec = StatsdStats::kPullerCooldownMap[tagId];
+ }
+ VLOG("Puller for tag %d created. Cooldown set to %ld", mTagId, mCoolDownSec);
+}
+
+bool StatsPuller::Pull(std::vector<std::shared_ptr<LogEvent>>* data) {
+ lock_guard<std::mutex> lock(mLock);
+ StatsdStats::getInstance().notePull(mTagId);
+ long curTime = time(nullptr);
+ if (curTime - mLastPullTimeSec < mCoolDownSec) {
+ (*data) = mCachedData;
+ StatsdStats::getInstance().notePullFromCache(mTagId);
+ return true;
+ }
+ if (mMinPullIntervalSec > curTime - mLastPullTimeSec) {
+ mMinPullIntervalSec = curTime - mLastPullTimeSec;
+ StatsdStats::getInstance().updateMinPullIntervalSec(mTagId, mMinPullIntervalSec);
+ }
+ mCachedData.clear();
+ mLastPullTimeSec = curTime;
+ bool ret = PullInternal(&mCachedData);
+ if (ret) {
+ (*data) = mCachedData;
+ }
+ return ret;
+}
+
+} // namespace statsd
+} // namespace os
+} // namespace android
diff --git a/cmds/statsd/src/external/StatsPuller.h b/cmds/statsd/src/external/StatsPuller.h
index 940ad9c..47cc9f0 100644
--- a/cmds/statsd/src/external/StatsPuller.h
+++ b/cmds/statsd/src/external/StatsPuller.h
@@ -18,11 +18,13 @@
#include <android/os/StatsLogEventWrapper.h>
#include <utils/String16.h>
+#include <mutex>
#include <vector>
+
#include "logd/LogEvent.h"
+#include "guardrail/StatsdStats.h"
using android::os::StatsLogEventWrapper;
-using std::vector;
namespace android {
namespace os {
@@ -30,9 +32,33 @@
class StatsPuller {
public:
- virtual ~StatsPuller(){};
+ StatsPuller(const int tagId);
- virtual bool Pull(const int tagId, vector<std::shared_ptr<LogEvent>>* data) = 0;
+ virtual ~StatsPuller() {}
+
+ bool Pull(std::vector<std::shared_ptr<LogEvent>>* data);
+
+protected:
+ // The atom tag id this puller pulls
+ const int mTagId;
+
+private:
+ mutable std::mutex mLock;
+ // Minimum time before this puller does actual pull again.
+ // If a pull request comes before cooldown, a cached version from purevious pull
+ // will be returned.
+ // The actual value should be determined by individual pullers.
+ long mCoolDownSec;
+ // For puller stats
+ long mMinPullIntervalSec = LONG_MAX;
+
+ virtual bool PullInternal(std::vector<std::shared_ptr<LogEvent>>* data) = 0;
+
+ // Cache of data from last pull. If next request comes before cool down finishes,
+ // cached data will be returned.
+ std::vector<std::shared_ptr<LogEvent>> mCachedData;
+
+ long mLastPullTimeSec;
};
} // namespace statsd
diff --git a/cmds/statsd/src/external/StatsPullerManagerImpl.cpp b/cmds/statsd/src/external/StatsPullerManagerImpl.cpp
index d707f85..58c7b12 100644
--- a/cmds/statsd/src/external/StatsPullerManagerImpl.cpp
+++ b/cmds/statsd/src/external/StatsPullerManagerImpl.cpp
@@ -45,29 +45,29 @@
StatsPullerManagerImpl::StatsPullerManagerImpl()
: mCurrentPullingInterval(LONG_MAX) {
- shared_ptr<StatsPuller> statsCompanionServicePuller = make_shared<StatsCompanionServicePuller>();
- shared_ptr<StatsPuller> resourcePowerManagerPuller = make_shared<ResourcePowerManagerPuller>();
- shared_ptr<StatsPuller> cpuTimePerUidPuller = make_shared<CpuTimePerUidPuller>();
- shared_ptr<StatsPuller> cpuTimePerUidFreqPuller = make_shared<CpuTimePerUidFreqPuller>();
-
mPullers.insert({android::util::KERNEL_WAKELOCK,
- statsCompanionServicePuller});
+ make_shared<StatsCompanionServicePuller>(android::util::KERNEL_WAKELOCK)});
mPullers.insert({android::util::WIFI_BYTES_TRANSFER,
- statsCompanionServicePuller});
- mPullers.insert({android::util::MOBILE_BYTES_TRANSFER,
- statsCompanionServicePuller});
+ make_shared<StatsCompanionServicePuller>(android::util::WIFI_BYTES_TRANSFER)});
+ mPullers.insert(
+ {android::util::MOBILE_BYTES_TRANSFER,
+ make_shared<StatsCompanionServicePuller>(android::util::MOBILE_BYTES_TRANSFER)});
mPullers.insert({android::util::WIFI_BYTES_TRANSFER_BY_FG_BG,
- statsCompanionServicePuller});
+ make_shared<StatsCompanionServicePuller>(
+ android::util::WIFI_BYTES_TRANSFER_BY_FG_BG)});
mPullers.insert({android::util::MOBILE_BYTES_TRANSFER_BY_FG_BG,
- statsCompanionServicePuller});
+ make_shared<StatsCompanionServicePuller>(
+ android::util::MOBILE_BYTES_TRANSFER_BY_FG_BG)});
mPullers.insert({android::util::PLATFORM_SLEEP_STATE,
- resourcePowerManagerPuller});
+ make_shared<ResourcePowerManagerPuller>(android::util::PLATFORM_SLEEP_STATE)});
mPullers.insert({android::util::SLEEP_STATE_VOTER,
- resourcePowerManagerPuller});
- mPullers.insert({android::util::SUBSYSTEM_SLEEP_STATE,
- resourcePowerManagerPuller});
- mPullers.insert({android::util::CPU_TIME_PER_UID, cpuTimePerUidPuller});
- mPullers.insert({android::util::CPU_TIME_PER_UID_FREQ, cpuTimePerUidFreqPuller});
+ make_shared<ResourcePowerManagerPuller>(android::util::SLEEP_STATE_VOTER)});
+ mPullers.insert(
+ {android::util::SUBSYSTEM_SLEEP_STATE,
+ make_shared<ResourcePowerManagerPuller>(android::util::SUBSYSTEM_SLEEP_STATE)});
+ mPullers.insert({android::util::CPU_TIME_PER_FREQ, make_shared<StatsCompanionServicePuller>(android::util::CPU_TIME_PER_FREQ)});
+ mPullers.insert({android::util::CPU_TIME_PER_UID, make_shared<CpuTimePerUidPuller>()});
+ mPullers.insert({android::util::CPU_TIME_PER_UID_FREQ, make_shared<CpuTimePerUidFreqPuller>()});
mStatsCompanionService = StatsService::getStatsCompanionService();
}
@@ -76,7 +76,7 @@
if (DEBUG) ALOGD("Initiating pulling %d", tagId);
if (mPullers.find(tagId) != mPullers.end()) {
- bool ret = mPullers.find(tagId)->second->Pull(tagId, data);
+ bool ret = mPullers.find(tagId)->second->Pull(data);
ALOGD("pulled %d items", (int)data->size());
return ret;
} else {
diff --git a/cmds/statsd/src/guardrail/StatsdStats.cpp b/cmds/statsd/src/guardrail/StatsdStats.cpp
index 33927aa..36dd616 100644
--- a/cmds/statsd/src/guardrail/StatsdStats.cpp
+++ b/cmds/statsd/src/guardrail/StatsdStats.cpp
@@ -19,6 +19,7 @@
#include "StatsdStats.h"
#include <android/util/ProtoOutputStream.h>
+#include "../stats_log_util.h"
#include "statslog.h"
namespace android {
@@ -59,6 +60,20 @@
const int FIELD_ID_ANOMALY_ALARMS_REGISTERED = 1;
+std::map<int, long> StatsdStats::kPullerCooldownMap = {
+ {android::util::KERNEL_WAKELOCK, 1},
+ {android::util::WIFI_BYTES_TRANSFER, 1},
+ {android::util::MOBILE_BYTES_TRANSFER, 1},
+ {android::util::WIFI_BYTES_TRANSFER_BY_FG_BG, 1},
+ {android::util::MOBILE_BYTES_TRANSFER_BY_FG_BG, 1},
+ {android::util::PLATFORM_SLEEP_STATE, 1},
+ {android::util::SLEEP_STATE_VOTER, 1},
+ {android::util::SUBSYSTEM_SLEEP_STATE, 1},
+ {android::util::CPU_TIME_PER_FREQ, 1},
+ {android::util::CPU_TIME_PER_UID, 1},
+ {android::util::CPU_TIME_PER_UID_FREQ, 1},
+};
+
// TODO: add stats for pulled atoms.
StatsdStats::StatsdStats() {
mPushedAtomStats.resize(android::util::kMaxPushedAtomId + 1);
@@ -70,6 +85,14 @@
return statsInstance;
}
+void StatsdStats::addToIceBoxLocked(const StatsdStatsReport_ConfigStats& stats) {
+ // The size of mIceBox grows strictly by one at a time. It won't be > kMaxIceBoxSize.
+ if (mIceBox.size() == kMaxIceBoxSize) {
+ mIceBox.pop_front();
+ }
+ mIceBox.push_back(stats);
+}
+
void StatsdStats::noteConfigReceived(const ConfigKey& key, int metricsCount, int conditionsCount,
int matchersCount, int alertsCount, bool isValid) {
lock_guard<std::mutex> lock(mLock);
@@ -92,7 +115,7 @@
mConfigStats[key] = configStats;
} else {
configStats.set_deletion_time_sec(nowTimeSec);
- mIceBox.push_back(configStats);
+ addToIceBoxLocked(configStats);
}
}
@@ -108,7 +131,7 @@
mMetricsStats.erase(key);
mAlertStats.erase(key);
mConditionStats.erase(key);
- mIceBox.push_back(it->second);
+ addToIceBoxLocked(it->second);
mConfigStats.erase(it);
}
}
@@ -231,6 +254,21 @@
mAnomalyAlarmRegisteredStats++;
}
+void StatsdStats::updateMinPullIntervalSec(int pullAtomId, long intervalSec) {
+ lock_guard<std::mutex> lock(mLock);
+ mPulledAtomStats[pullAtomId].minPullIntervalSec = intervalSec;
+}
+
+void StatsdStats::notePull(int pullAtomId) {
+ lock_guard<std::mutex> lock(mLock);
+ mPulledAtomStats[pullAtomId].totalPull++;
+}
+
+void StatsdStats::notePullFromCache(int pullAtomId) {
+ lock_guard<std::mutex> lock(mLock);
+ mPulledAtomStats[pullAtomId].totalPullFromCache++;
+}
+
void StatsdStats::noteAtomLogged(int atomId, int32_t timeSec) {
lock_guard<std::mutex> lock(mLock);
@@ -401,7 +439,7 @@
configStats.clear_alert_stats();
}
- VLOG("********Atom stats***********");
+ VLOG("********Pushed Atom stats***********");
const size_t atomCounts = mPushedAtomStats.size();
for (size_t i = 2; i < atomCounts; i++) {
if (mPushedAtomStats[i] > 0) {
@@ -415,6 +453,12 @@
}
}
+ VLOG("********Pulled Atom stats***********");
+ for (const auto& pair : mPulledAtomStats) {
+ android::os::statsd::writePullerStatsToStream(pair, &proto);
+ VLOG("Atom %d->%ld, %ld, %ld\n", (int) pair.first, (long) pair.second.totalPull, (long) pair.second.totalPullFromCache, (long) pair.second.minPullIntervalSec);
+ }
+
if (mAnomalyAlarmRegisteredStats > 0) {
VLOG("********AnomalyAlarmStats stats***********");
long long token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ANOMALY_ALARM_STATS);
diff --git a/cmds/statsd/src/guardrail/StatsdStats.h b/cmds/statsd/src/guardrail/StatsdStats.h
index 45aa192..52ab253 100644
--- a/cmds/statsd/src/guardrail/StatsdStats.h
+++ b/cmds/statsd/src/guardrail/StatsdStats.h
@@ -17,9 +17,11 @@
#include "config/ConfigKey.h"
#include "frameworks/base/cmds/statsd/src/stats_log.pb.h"
+#include "statslog.h"
#include <gtest/gtest_prod.h>
#include <log/log_time.h>
+#include <list>
#include <mutex>
#include <string>
#include <vector>
@@ -44,6 +46,9 @@
const static int kMaxMetricCountPerConfig = 300;
const static int kMaxMatcherCountPerConfig = 500;
+ // The max number of old config stats we keep.
+ const static int kMaxIceBoxSize = 20;
+
const static int kMaxTimestampCount = 20;
const static int kMaxLogSourceCount = 50;
@@ -62,6 +67,13 @@
/* Min period between two checks of byte size per config key in nanoseconds. */
static const unsigned long long kMinByteSizeCheckPeriodNs = 10 * NS_PER_SEC;
+ // Default minimum interval between pulls for an atom. Pullers can return cached values if
+ // another pull request happens within this interval.
+ static std::map<int, long> kPullerCooldownMap;
+
+ // Default cooldown time for a puller
+ static const long kDefaultPullerCooldown = 1;
+
/**
* Report a new config has been received and report the static stats about the config.
*
@@ -154,6 +166,15 @@
void setUidMapChanges(int changes);
void setCurrentUidMapMemory(int bytes);
+ // Update minimum interval between pulls for an pulled atom
+ void updateMinPullIntervalSec(int pullAtomId, long intervalSec);
+
+ // Notify pull request for an atom
+ void notePull(int pullAtomId);
+
+ // Notify pull request for an atom served from cached data
+ void notePullFromCache(int pullAtomId);
+
/**
* Reset the historical stats. Including all stats in icebox, and the tracked stats about
* metrics, matchers, and atoms. The active configs will be kept and StatsdStats will continue
@@ -168,6 +189,12 @@
*/
void dumpStats(std::vector<uint8_t>* buffer, bool reset);
+ typedef struct {
+ long totalPull;
+ long totalPullFromCache;
+ long minPullIntervalSec;
+ } PulledAtomStats;
+
private:
StatsdStats();
@@ -179,19 +206,21 @@
StatsdStatsReport_UidMapStats mUidMapStats;
// The stats about the configs that are still in use.
+ // The map size is capped by kMaxConfigCount.
std::map<const ConfigKey, StatsdStatsReport_ConfigStats> mConfigStats;
// Stores the stats for the configs that are no longer in use.
- std::vector<const StatsdStatsReport_ConfigStats> mIceBox;
+ // The size of the vector is capped by kMaxIceBoxSize.
+ std::list<const StatsdStatsReport_ConfigStats> mIceBox;
// Stores the number of output tuple of condition trackers when it's bigger than
// kDimensionKeySizeSoftLimit. When you see the number is kDimensionKeySizeHardLimit +1,
- // it means some data has been dropped.
+ // it means some data has been dropped. The map size is capped by kMaxConfigCount.
std::map<const ConfigKey, std::map<const int64_t, int>> mConditionStats;
// Stores the number of output tuple of metric producers when it's bigger than
// kDimensionKeySizeSoftLimit. When you see the number is kDimensionKeySizeHardLimit +1,
- // it means some data has been dropped.
+ // it means some data has been dropped. The map size is capped by kMaxConfigCount.
std::map<const ConfigKey, std::map<const int64_t, int>> mMetricsStats;
// Stores the number of times a pushed atom is logged.
@@ -200,15 +229,18 @@
// This is a vector, not a map because it will be accessed A LOT -- for each stats log.
std::vector<int> mPushedAtomStats;
+ // Maps PullAtomId to its stats. The size is capped by the puller atom counts.
+ std::map<int, PulledAtomStats> mPulledAtomStats;
+
// Stores the number of times statsd modified the anomaly alarm registered with
// StatsCompanionService.
int mAnomalyAlarmRegisteredStats = 0;
// Stores the number of times an anomaly detection alert has been declared
- // (per config, per alert name).
+ // (per config, per alert name). The map size is capped by kMaxConfigCount.
std::map<const ConfigKey, std::map<const int64_t, int>> mAlertStats;
- // Stores how many times a matcher have been matched.
+ // Stores how many times a matcher have been matched. The map size is capped by kMaxConfigCount.
std::map<const ConfigKey, std::map<const int64_t, int>> mMatcherStats;
void noteConfigRemovedInternalLocked(const ConfigKey& key);
@@ -224,6 +256,8 @@
void noteBroadcastSent(const ConfigKey& key, int32_t timeSec);
+ void addToIceBoxLocked(const StatsdStatsReport_ConfigStats& stats);
+
FRIEND_TEST(StatsdStatsTest, TestValidConfigAdd);
FRIEND_TEST(StatsdStatsTest, TestInvalidConfigAdd);
FRIEND_TEST(StatsdStatsTest, TestConfigRemove);
@@ -235,4 +269,4 @@
} // namespace statsd
} // namespace os
-} // namespace android
\ No newline at end of file
+} // namespace android
diff --git a/cmds/statsd/src/metrics/DurationMetricProducer.cpp b/cmds/statsd/src/metrics/DurationMetricProducer.cpp
index 3f8a8ff..b546297 100644
--- a/cmds/statsd/src/metrics/DurationMetricProducer.cpp
+++ b/cmds/statsd/src/metrics/DurationMetricProducer.cpp
@@ -117,11 +117,11 @@
case DurationMetric_AggregationType_SUM:
return make_unique<OringDurationTracker>(
mConfigKey, mMetricId, eventKey, mWizard, mConditionTrackerIndex, mNested,
- mCurrentBucketStartTimeNs, mBucketSizeNs, mAnomalyTrackers);
+ mCurrentBucketStartTimeNs, mBucketSizeNs, mConditionSliced, mAnomalyTrackers);
case DurationMetric_AggregationType_MAX_SPARSE:
return make_unique<MaxDurationTracker>(
mConfigKey, mMetricId, eventKey, mWizard, mConditionTrackerIndex, mNested,
- mCurrentBucketStartTimeNs, mBucketSizeNs, mAnomalyTrackers);
+ mCurrentBucketStartTimeNs, mBucketSizeNs, mConditionSliced, mAnomalyTrackers);
}
}
diff --git a/cmds/statsd/src/metrics/GaugeMetricProducer.cpp b/cmds/statsd/src/metrics/GaugeMetricProducer.cpp
index e6f311b..1a4888c 100644
--- a/cmds/statsd/src/metrics/GaugeMetricProducer.cpp
+++ b/cmds/statsd/src/metrics/GaugeMetricProducer.cpp
@@ -326,6 +326,7 @@
}
}
+ mCurrentSlicedBucketForAnomaly = std::make_shared<DimToValMap>();
mCurrentSlicedBucket = std::make_shared<DimToGaugeFieldsMap>();
// Adjusts the bucket start time
diff --git a/cmds/statsd/src/metrics/duration_helper/DurationTracker.h b/cmds/statsd/src/metrics/duration_helper/DurationTracker.h
index 842581e..023c25e 100644
--- a/cmds/statsd/src/metrics/duration_helper/DurationTracker.h
+++ b/cmds/statsd/src/metrics/duration_helper/DurationTracker.h
@@ -62,7 +62,7 @@
public:
DurationTracker(const ConfigKey& key, const int64_t& id, const HashableDimensionKey& eventKey,
sp<ConditionWizard> wizard, int conditionIndex, bool nesting,
- uint64_t currentBucketStartNs, uint64_t bucketSizeNs,
+ uint64_t currentBucketStartNs, uint64_t bucketSizeNs, bool conditionSliced,
const std::vector<sp<DurationAnomalyTracker>>& anomalyTrackers)
: mConfigKey(key),
mTrackerId(id),
@@ -74,6 +74,7 @@
mCurrentBucketStartTimeNs(currentBucketStartNs),
mDuration(0),
mCurrentBucketNum(0),
+ mConditionSliced(conditionSliced),
mAnomalyTrackers(anomalyTrackers){};
virtual ~DurationTracker(){};
@@ -163,6 +164,8 @@
uint64_t mCurrentBucketNum;
+ const bool mConditionSliced;
+
std::vector<sp<DurationAnomalyTracker>> mAnomalyTrackers;
FRIEND_TEST(OringDurationTrackerTest, TestPredictAnomalyTimestamp);
diff --git a/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.cpp b/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.cpp
index 94f98ad..0c99391 100644
--- a/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.cpp
+++ b/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.cpp
@@ -28,9 +28,10 @@
const HashableDimensionKey& eventKey,
sp<ConditionWizard> wizard, int conditionIndex, bool nesting,
uint64_t currentBucketStartNs, uint64_t bucketSizeNs,
+ bool conditionSliced,
const vector<sp<DurationAnomalyTracker>>& anomalyTrackers)
: DurationTracker(key, id, eventKey, wizard, conditionIndex, nesting, currentBucketStartNs,
- bucketSizeNs, anomalyTrackers) {
+ bucketSizeNs, conditionSliced, anomalyTrackers) {
}
bool MaxDurationTracker::hitGuardRail(const HashableDimensionKey& newKey) {
@@ -63,7 +64,9 @@
}
DurationInfo& duration = mInfos[key];
- duration.conditionKeys = conditionKey;
+ if (mConditionSliced) {
+ duration.conditionKeys = conditionKey;
+ }
VLOG("MaxDuration: key %s start condition %d", key.c_str(), condition);
switch (duration.state) {
diff --git a/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.h b/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.h
index 68c48cb1..5d3c158 100644
--- a/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.h
+++ b/cmds/statsd/src/metrics/duration_helper/MaxDurationTracker.h
@@ -31,7 +31,7 @@
MaxDurationTracker(const ConfigKey& key, const int64_t& id,
const HashableDimensionKey& eventKey, sp<ConditionWizard> wizard,
int conditionIndex, bool nesting, uint64_t currentBucketStartNs,
- uint64_t bucketSizeNs,
+ uint64_t bucketSizeNs, bool conditionSliced,
const std::vector<sp<DurationAnomalyTracker>>& anomalyTrackers);
void noteStart(const HashableDimensionKey& key, bool condition, const uint64_t eventTime,
const ConditionKey& conditionKey) override;
diff --git a/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.cpp b/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.cpp
index c77d0b7..6bf4228 100644
--- a/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.cpp
+++ b/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.cpp
@@ -27,10 +27,10 @@
OringDurationTracker::OringDurationTracker(
const ConfigKey& key, const int64_t& id, const HashableDimensionKey& eventKey,
sp<ConditionWizard> wizard, int conditionIndex, bool nesting, uint64_t currentBucketStartNs,
- uint64_t bucketSizeNs, const vector<sp<DurationAnomalyTracker>>& anomalyTrackers)
-
+ uint64_t bucketSizeNs, bool conditionSliced,
+ const vector<sp<DurationAnomalyTracker>>& anomalyTrackers)
: DurationTracker(key, id, eventKey, wizard, conditionIndex, nesting, currentBucketStartNs,
- bucketSizeNs, anomalyTrackers),
+ bucketSizeNs, conditionSliced, anomalyTrackers),
mStarted(),
mPaused() {
mLastStartTime = 0;
@@ -73,7 +73,7 @@
mPaused[key]++;
}
- if (mConditionKeyMap.find(key) == mConditionKeyMap.end()) {
+ if (mConditionSliced && mConditionKeyMap.find(key) == mConditionKeyMap.end()) {
mConditionKeyMap[key] = conditionKey;
}
diff --git a/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.h b/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.h
index 7fe649c..293726c 100644
--- a/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.h
+++ b/cmds/statsd/src/metrics/duration_helper/OringDurationTracker.h
@@ -30,7 +30,7 @@
OringDurationTracker(const ConfigKey& key, const int64_t& id,
const HashableDimensionKey& eventKey, sp<ConditionWizard> wizard,
int conditionIndex, bool nesting, uint64_t currentBucketStartNs,
- uint64_t bucketSizeNs,
+ uint64_t bucketSizeNs, bool conditionSliced,
const std::vector<sp<DurationAnomalyTracker>>& anomalyTrackers);
void noteStart(const HashableDimensionKey& key, bool condition, const uint64_t eventTime,
diff --git a/cmds/statsd/src/stats_log.proto b/cmds/statsd/src/stats_log.proto
index ae69a50..2596a5f 100644
--- a/cmds/statsd/src/stats_log.proto
+++ b/cmds/statsd/src/stats_log.proto
@@ -246,4 +246,12 @@
optional int32 alarms_registered = 1;
}
optional AnomalyAlarmStats anomaly_alarm_stats = 9;
+
+ message PulledAtomStats {
+ optional int32 atom_id = 1;
+ optional int64 total_pull = 2;
+ optional int64 total_pull_from_cache = 3;
+ optional int64 min_pull_interval_sec = 4;
+ }
+ repeated PulledAtomStats pulled_atom_stats = 10;
}
\ No newline at end of file
diff --git a/cmds/statsd/src/stats_log_util.cpp b/cmds/statsd/src/stats_log_util.cpp
index b335b58..a41f30c 100644
--- a/cmds/statsd/src/stats_log_util.cpp
+++ b/cmds/statsd/src/stats_log_util.cpp
@@ -45,6 +45,13 @@
// for MessageValue Proto
const int FIELD_ID_FIELD_VALUE_IN_MESSAGE_VALUE_PROTO = 1;
+// for PulledAtomStats proto
+const int FIELD_ID_PULLED_ATOM_STATS = 10;
+const int FIELD_ID_PULL_ATOM_ID = 1;
+const int FIELD_ID_TOTAL_PULL = 2;
+const int FIELD_ID_TOTAL_PULL_FROM_CACHE = 3;
+const int FIELD_ID_MIN_PULL_INTERVAL_SEC = 4;
+
void writeDimensionsValueProtoToStream(const DimensionsValue& dimensionsValue,
ProtoOutputStream* protoOutput) {
protoOutput->write(FIELD_TYPE_INT32 | DIMENSIONS_VALUE_FIELD, dimensionsValue.field());
@@ -248,6 +255,19 @@
}
}
+void writePullerStatsToStream(const std::pair<int, StatsdStats::PulledAtomStats>& pair,
+ util::ProtoOutputStream* protoOutput) {
+ long long token = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_ID_PULLED_ATOM_STATS |
+ FIELD_COUNT_REPEATED);
+ protoOutput->write(FIELD_TYPE_INT32 | FIELD_ID_PULL_ATOM_ID, (int32_t)pair.first);
+ protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_TOTAL_PULL, (long long)pair.second.totalPull);
+ protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_TOTAL_PULL_FROM_CACHE,
+ (long long)pair.second.totalPullFromCache);
+ protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_MIN_PULL_INTERVAL_SEC,
+ (long long)pair.second.minPullIntervalSec);
+ protoOutput->end(token);
+}
+
} // namespace statsd
} // namespace os
} // namespace android
\ No newline at end of file
diff --git a/cmds/statsd/src/stats_log_util.h b/cmds/statsd/src/stats_log_util.h
index 33303dc..09a43f5 100644
--- a/cmds/statsd/src/stats_log_util.h
+++ b/cmds/statsd/src/stats_log_util.h
@@ -17,29 +17,32 @@
#pragma once
#include <android/util/ProtoOutputStream.h>
-#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
-#include "frameworks/base/cmds/statsd/src/stats_log.pb.h"
#include "field_util.h"
+#include "frameworks/base/cmds/statsd/src/stats_log.pb.h"
+#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
+#include "guardrail/StatsdStats.h"
namespace android {
namespace os {
namespace statsd {
// Helper function to write DimensionsValue proto to ProtoOutputStream.
-void writeDimensionsValueProtoToStream(
- const DimensionsValue& fieldValue, util::ProtoOutputStream* protoOutput);
+void writeDimensionsValueProtoToStream(const DimensionsValue& fieldValue,
+ util::ProtoOutputStream* protoOutput);
// Helper function to write Field proto to ProtoOutputStream.
-void writeFieldProtoToStream(
- const Field& field, util::ProtoOutputStream* protoOutput);
+void writeFieldProtoToStream(const Field& field, util::ProtoOutputStream* protoOutput);
// Helper function to construct the field value tree and write to ProtoOutputStream
-void writeFieldValueTreeToStream(const FieldValueMap &fieldValueMap,
- util::ProtoOutputStream* protoOutput);
+void writeFieldValueTreeToStream(const FieldValueMap& fieldValueMap,
+ util::ProtoOutputStream* protoOutput);
// Convert the TimeUnit enum to the bucket size in millis.
int64_t TimeUnitToBucketSizeInMillis(TimeUnit unit);
+// Helper function to write PulledAtomStats to ProtoOutputStream
+void writePullerStatsToStream(const std::pair<int, StatsdStats::PulledAtomStats>& pair,
+ util::ProtoOutputStream* protoOutput);
} // namespace statsd
} // namespace os
} // namespace android
\ No newline at end of file
diff --git a/cmds/statsd/tests/StatsLogProcessor_test.cpp b/cmds/statsd/tests/StatsLogProcessor_test.cpp
index 5d053e2..aab5bed 100644
--- a/cmds/statsd/tests/StatsLogProcessor_test.cpp
+++ b/cmds/statsd/tests/StatsLogProcessor_test.cpp
@@ -60,9 +60,9 @@
// Expect only the first flush to trigger a check for byte size since the last two are
// rate-limited.
EXPECT_CALL(mockMetricsManager, byteSize()).Times(1);
- p.flushIfNecessary(99, key, mockMetricsManager);
- p.flushIfNecessary(100, key, mockMetricsManager);
- p.flushIfNecessary(101, key, mockMetricsManager);
+ p.flushIfNecessaryLocked(99, key, mockMetricsManager);
+ p.flushIfNecessaryLocked(100, key, mockMetricsManager);
+ p.flushIfNecessaryLocked(101, key, mockMetricsManager);
}
TEST(StatsLogProcessorTest, TestRateLimitBroadcast) {
@@ -80,12 +80,12 @@
.WillRepeatedly(Return(int(StatsdStats::kMaxMetricsBytesPerConfig * .95)));
// Expect only one broadcast despite always returning a size that should trigger broadcast.
- p.flushIfNecessary(1, key, mockMetricsManager);
+ p.flushIfNecessaryLocked(1, key, mockMetricsManager);
EXPECT_EQ(1, broadcastCount);
// This next call to flush should not trigger a broadcast.
p.mLastByteSizeTimes.clear(); // Force another check for byte size.
- p.flushIfNecessary(2, key, mockMetricsManager);
+ p.flushIfNecessaryLocked(2, key, mockMetricsManager);
EXPECT_EQ(1, broadcastCount);
}
@@ -106,7 +106,7 @@
EXPECT_CALL(mockMetricsManager, onDumpReport(_)).Times(1);
// Expect to call the onDumpReport and skip the broadcast.
- p.flushIfNecessary(1, key, mockMetricsManager);
+ p.flushIfNecessaryLocked(1, key, mockMetricsManager);
EXPECT_EQ(0, broadcastCount);
}
diff --git a/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp b/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp
index 704a466..f98be1b 100644
--- a/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp
+++ b/cmds/statsd/tests/metrics/MaxDurationTracker_test.cpp
@@ -50,24 +50,22 @@
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
- ConditionKey conditionKey1;
- conditionKey1[StringToId("condition")] = conditionKey;
uint64_t bucketStartTimeNs = 10000000000;
uint64_t bucketSizeNs = 30 * 1000 * 1000 * 1000LL;
int64_t metricId = 1;
MaxDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, -1, false, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, false, {});
- tracker.noteStart(key1, true, bucketStartTimeNs, conditionKey1);
+ tracker.noteStart(key1, true, bucketStartTimeNs, ConditionKey());
// Event starts again. This would not change anything as it already starts.
- tracker.noteStart(key1, true, bucketStartTimeNs + 3, conditionKey1);
+ tracker.noteStart(key1, true, bucketStartTimeNs + 3, ConditionKey());
// Stopped.
tracker.noteStop(key1, bucketStartTimeNs + 10, false);
// Another event starts in this bucket.
- tracker.noteStart(key2, true, bucketStartTimeNs + 20, conditionKey1);
+ tracker.noteStart(key2, true, bucketStartTimeNs + 20, ConditionKey());
tracker.noteStop(key2, bucketStartTimeNs + 40, false /*stop all*/);
tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 1, &buckets);
@@ -80,20 +78,18 @@
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
- ConditionKey conditionKey1;
- conditionKey1[StringToId("condition")] = conditionKey;
uint64_t bucketStartTimeNs = 10000000000;
uint64_t bucketSizeNs = 30 * 1000 * 1000 * 1000LL;
int64_t metricId = 1;
MaxDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, -1, false, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, false, {});
- tracker.noteStart(key1, true, bucketStartTimeNs + 1, conditionKey1);
+ tracker.noteStart(key1, true, bucketStartTimeNs + 1, ConditionKey());
// Another event starts in this bucket.
- tracker.noteStart(key2, true, bucketStartTimeNs + 20, conditionKey1);
+ tracker.noteStart(key2, true, bucketStartTimeNs + 20, ConditionKey());
tracker.flushIfNeeded(bucketStartTimeNs + bucketSizeNs + 40, &buckets);
tracker.noteStopAll(bucketStartTimeNs + bucketSizeNs + 40);
EXPECT_TRUE(tracker.mInfos.empty());
@@ -112,22 +108,20 @@
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
- ConditionKey conditionKey1;
- conditionKey1[StringToId("condition")] = conditionKey;
uint64_t bucketStartTimeNs = 10000000000;
uint64_t bucketSizeNs = 30 * 1000 * 1000 * 1000LL;
int64_t metricId = 1;
MaxDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, -1, false, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, false, {});
// The event starts.
- tracker.noteStart(DEFAULT_DIMENSION_KEY, true, bucketStartTimeNs + 1, conditionKey1);
+ tracker.noteStart(DEFAULT_DIMENSION_KEY, true, bucketStartTimeNs + 1, ConditionKey());
// Starts again. Does not change anything.
tracker.noteStart(DEFAULT_DIMENSION_KEY, true, bucketStartTimeNs + bucketSizeNs + 1,
- conditionKey1);
+ ConditionKey());
// The event stops at early 4th bucket.
tracker.flushIfNeeded(bucketStartTimeNs + (3 * bucketSizeNs) + 20, &buckets);
@@ -144,19 +138,17 @@
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
- ConditionKey conditionKey1;
- conditionKey1[StringToId("condition")] = conditionKey;
uint64_t bucketStartTimeNs = 10000000000;
uint64_t bucketSizeNs = 30 * 1000 * 1000 * 1000LL;
int64_t metricId = 1;
MaxDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, -1, true, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, false, {});
// 2 starts
- tracker.noteStart(DEFAULT_DIMENSION_KEY, true, bucketStartTimeNs + 1, conditionKey1);
- tracker.noteStart(DEFAULT_DIMENSION_KEY, true, bucketStartTimeNs + 10, conditionKey1);
+ tracker.noteStart(DEFAULT_DIMENSION_KEY, true, bucketStartTimeNs + 1, ConditionKey());
+ tracker.noteStart(DEFAULT_DIMENSION_KEY, true, bucketStartTimeNs + 10, ConditionKey());
// one stop
tracker.noteStop(DEFAULT_DIMENSION_KEY, bucketStartTimeNs + 20, false /*stop all*/);
@@ -196,7 +188,7 @@
int64_t metricId = 1;
MaxDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, false, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, true, {});
EXPECT_TRUE(tracker.mAnomalyTrackers.empty());
tracker.noteStart(key1, true, eventStartTimeNs, conditionKey1);
@@ -222,22 +214,21 @@
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
- ConditionKey conditionKey1;
- conditionKey1[StringToId("APP_BACKGROUND")] = conditionKey;
+
uint64_t bucketStartTimeNs = 10 * NS_PER_SEC;
uint64_t eventStartTimeNs = bucketStartTimeNs + NS_PER_SEC + 1;
uint64_t bucketSizeNs = 30 * NS_PER_SEC;
sp<DurationAnomalyTracker> anomalyTracker = new DurationAnomalyTracker(alert, kConfigKey);
MaxDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, -1, true, bucketStartTimeNs,
- bucketSizeNs, {anomalyTracker});
+ bucketSizeNs, false, {anomalyTracker});
- tracker.noteStart(key1, true, eventStartTimeNs, conditionKey1);
+ tracker.noteStart(key1, true, eventStartTimeNs, ConditionKey());
tracker.noteStop(key1, eventStartTimeNs + 10, false);
EXPECT_EQ(anomalyTracker->mLastAnomalyTimestampNs, -1);
EXPECT_EQ(10LL, tracker.mDuration);
- tracker.noteStart(key2, true, eventStartTimeNs + 20, conditionKey1);
+ tracker.noteStart(key2, true, eventStartTimeNs + 20, ConditionKey());
tracker.flushIfNeeded(eventStartTimeNs + 2 * bucketSizeNs + 3 * NS_PER_SEC, &buckets);
tracker.noteStop(key2, eventStartTimeNs + 2 * bucketSizeNs + 3 * NS_PER_SEC, false);
EXPECT_EQ((long long)(4 * NS_PER_SEC + 1LL), tracker.mDuration);
diff --git a/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp b/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp
index 36cdaae..89c6abe 100644
--- a/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp
+++ b/cmds/statsd/tests/metrics/OringDurationTracker_test.cpp
@@ -47,9 +47,6 @@
TEST(OringDurationTrackerTest, TestDurationOverlap) {
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
- ConditionKey key1;
- key1[StringToId("APP_BACKGROUND")] = kConditionKey1;
-
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
uint64_t bucketStartTimeNs = 10000000000;
@@ -58,11 +55,11 @@
uint64_t durationTimeNs = 2 * 1000;
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, false,
- bucketStartTimeNs, bucketSizeNs, {});
+ bucketStartTimeNs, bucketSizeNs, false, {});
- tracker.noteStart(kEventKey1, true, eventStartTimeNs, key1);
+ tracker.noteStart(kEventKey1, true, eventStartTimeNs, ConditionKey());
EXPECT_EQ((long long)eventStartTimeNs, tracker.mLastStartTime);
- tracker.noteStart(kEventKey1, true, eventStartTimeNs + 10, key1); // overlapping wl
+ tracker.noteStart(kEventKey1, true, eventStartTimeNs + 10, ConditionKey()); // overlapping wl
EXPECT_EQ((long long)eventStartTimeNs, tracker.mLastStartTime);
tracker.noteStop(kEventKey1, eventStartTimeNs + durationTimeNs, false);
@@ -76,9 +73,6 @@
TEST(OringDurationTrackerTest, TestDurationNested) {
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
- ConditionKey key1;
- key1[StringToId("APP_BACKGROUND")] = kConditionKey1;
-
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
uint64_t bucketStartTimeNs = 10000000000;
@@ -86,10 +80,10 @@
uint64_t bucketSizeNs = 30 * 1000 * 1000 * 1000LL;
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, true, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, false, {});
- tracker.noteStart(kEventKey1, true, eventStartTimeNs, key1);
- tracker.noteStart(kEventKey1, true, eventStartTimeNs + 10, key1); // overlapping wl
+ tracker.noteStart(kEventKey1, true, eventStartTimeNs, ConditionKey());
+ tracker.noteStart(kEventKey1, true, eventStartTimeNs + 10, ConditionKey()); // overlapping wl
tracker.noteStop(kEventKey1, eventStartTimeNs + 2000, false);
tracker.noteStop(kEventKey1, eventStartTimeNs + 2003, false);
@@ -103,9 +97,6 @@
TEST(OringDurationTrackerTest, TestStopAll) {
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
- ConditionKey key1;
- key1[StringToId("APP_BACKGROUND")] = kConditionKey1;
-
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
uint64_t bucketStartTimeNs = 10000000000;
@@ -113,10 +104,10 @@
uint64_t bucketSizeNs = 30 * 1000 * 1000 * 1000LL;
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, true, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, false, {});
- tracker.noteStart(kEventKey1, true, eventStartTimeNs, key1);
- tracker.noteStart(kEventKey2, true, eventStartTimeNs + 10, key1); // overlapping wl
+ tracker.noteStart(kEventKey1, true, eventStartTimeNs, ConditionKey());
+ tracker.noteStart(kEventKey2, true, eventStartTimeNs + 10, ConditionKey()); // overlapping wl
tracker.noteStopAll(eventStartTimeNs + 2003);
@@ -129,9 +120,6 @@
TEST(OringDurationTrackerTest, TestCrossBucketBoundary) {
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
- ConditionKey key1;
- key1[StringToId("APP_BACKGROUND")] = kConditionKey1;
-
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
uint64_t bucketStartTimeNs = 10000000000;
@@ -140,12 +128,12 @@
uint64_t durationTimeNs = 2 * 1000;
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, true, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, false, {});
- tracker.noteStart(kEventKey1, true, eventStartTimeNs, key1);
+ tracker.noteStart(kEventKey1, true, eventStartTimeNs, ConditionKey());
EXPECT_EQ((long long)eventStartTimeNs, tracker.mLastStartTime);
tracker.flushIfNeeded(eventStartTimeNs + 2 * bucketSizeNs, &buckets);
- tracker.noteStart(kEventKey1, true, eventStartTimeNs + 2 * bucketSizeNs, key1);
+ tracker.noteStart(kEventKey1, true, eventStartTimeNs + 2 * bucketSizeNs, ConditionKey());
EXPECT_EQ((long long)(bucketStartTimeNs + 2 * bucketSizeNs), tracker.mLastStartTime);
EXPECT_EQ(2u, buckets[eventKey].size());
@@ -178,7 +166,7 @@
uint64_t durationTimeNs = 2 * 1000;
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, false,
- bucketStartTimeNs, bucketSizeNs, {});
+ bucketStartTimeNs, bucketSizeNs, true, {});
tracker.noteStart(kEventKey1, true, eventStartTimeNs, key1);
@@ -211,7 +199,7 @@
uint64_t durationTimeNs = 2 * 1000;
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, false,
- bucketStartTimeNs, bucketSizeNs, {});
+ bucketStartTimeNs, bucketSizeNs, true, {});
tracker.noteStart(kEventKey1, true, eventStartTimeNs, key1);
// condition to false; record duration 5n
@@ -243,7 +231,7 @@
uint64_t bucketSizeNs = 30 * 1000 * 1000 * 1000LL;
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, true, bucketStartTimeNs,
- bucketSizeNs, {});
+ bucketSizeNs, true, {});
tracker.noteStart(kEventKey1, true, eventStartTimeNs, key1);
tracker.noteStart(kEventKey1, true, eventStartTimeNs + 2, key1);
@@ -270,18 +258,17 @@
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
- ConditionKey key1;
- key1[StringToId("APP_BACKGROUND")] = kConditionKey1;
+
uint64_t bucketStartTimeNs = 10 * NS_PER_SEC;
uint64_t eventStartTimeNs = bucketStartTimeNs + NS_PER_SEC + 1;
uint64_t bucketSizeNs = 30 * NS_PER_SEC;
sp<DurationAnomalyTracker> anomalyTracker = new DurationAnomalyTracker(alert, kConfigKey);
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, true, bucketStartTimeNs,
- bucketSizeNs, {anomalyTracker});
+ bucketSizeNs, true, {anomalyTracker});
// Nothing in the past bucket.
- tracker.noteStart(DEFAULT_DIMENSION_KEY, true, eventStartTimeNs, key1);
+ tracker.noteStart(DEFAULT_DIMENSION_KEY, true, eventStartTimeNs, ConditionKey());
EXPECT_EQ((long long)(alert.trigger_if_sum_gt() + eventStartTimeNs),
tracker.predictAnomalyTimestampNs(*anomalyTracker, eventStartTimeNs));
@@ -289,7 +276,7 @@
EXPECT_EQ(0u, buckets[eventKey].size());
uint64_t event1StartTimeNs = eventStartTimeNs + 10;
- tracker.noteStart(kEventKey1, true, event1StartTimeNs, key1);
+ tracker.noteStart(kEventKey1, true, event1StartTimeNs, ConditionKey());
// No past buckets. The anomaly will happen in bucket #0.
EXPECT_EQ((long long)(event1StartTimeNs + alert.trigger_if_sum_gt() - 3),
tracker.predictAnomalyTimestampNs(*anomalyTracker, event1StartTimeNs));
@@ -308,7 +295,7 @@
// One past buckets. The anomaly will happen in bucket #1.
uint64_t event2StartTimeNs = eventStartTimeNs + bucketSizeNs + 15;
- tracker.noteStart(kEventKey1, true, event2StartTimeNs, key1);
+ tracker.noteStart(kEventKey1, true, event2StartTimeNs, ConditionKey());
EXPECT_EQ((long long)(event2StartTimeNs + alert.trigger_if_sum_gt() - bucket0Duration -
bucket1Duration),
tracker.predictAnomalyTimestampNs(*anomalyTracker, event2StartTimeNs));
@@ -317,7 +304,7 @@
// Only one past buckets is applicable. Bucket +0 should be trashed. The anomaly will happen in
// bucket #2.
uint64_t event3StartTimeNs = bucketStartTimeNs + 2 * bucketSizeNs - 9 * NS_PER_SEC;
- tracker.noteStart(kEventKey1, true, event3StartTimeNs, key1);
+ tracker.noteStart(kEventKey1, true, event3StartTimeNs, ConditionKey());
EXPECT_EQ((long long)(event3StartTimeNs + alert.trigger_if_sum_gt() - bucket1Duration - 1LL),
tracker.predictAnomalyTimestampNs(*anomalyTracker, event3StartTimeNs));
}
@@ -332,17 +319,16 @@
unordered_map<HashableDimensionKey, vector<DurationBucket>> buckets;
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
- ConditionKey key1;
- key1[StringToId("APP_BACKGROUND")] = kConditionKey1;
+
uint64_t bucketStartTimeNs = 10 * NS_PER_SEC;
uint64_t eventStartTimeNs = bucketStartTimeNs + NS_PER_SEC + 1;
uint64_t bucketSizeNs = 30 * NS_PER_SEC;
sp<DurationAnomalyTracker> anomalyTracker = new DurationAnomalyTracker(alert, kConfigKey);
OringDurationTracker tracker(kConfigKey, metricId, eventKey, wizard, 1, true /*nesting*/,
- bucketStartTimeNs, bucketSizeNs, {anomalyTracker});
+ bucketStartTimeNs, bucketSizeNs, false, {anomalyTracker});
- tracker.noteStart(DEFAULT_DIMENSION_KEY, true, eventStartTimeNs, key1);
+ tracker.noteStart(DEFAULT_DIMENSION_KEY, true, eventStartTimeNs, ConditionKey());
tracker.noteStop(DEFAULT_DIMENSION_KEY, eventStartTimeNs + 10, false);
EXPECT_EQ(anomalyTracker->mLastAnomalyTimestampNs, -1);
EXPECT_TRUE(tracker.mStarted.empty());
@@ -350,7 +336,7 @@
EXPECT_EQ(0u, tracker.mStarted.size());
- tracker.noteStart(DEFAULT_DIMENSION_KEY, true, eventStartTimeNs + 20, key1);
+ tracker.noteStart(DEFAULT_DIMENSION_KEY, true, eventStartTimeNs + 20, ConditionKey());
EXPECT_EQ(1u, anomalyTracker->mAlarms.size());
EXPECT_EQ((long long)(51ULL * NS_PER_SEC),
(long long)(anomalyTracker->mAlarms.begin()->second->timestampSec * NS_PER_SEC));
diff --git a/cmds/statsd/tools/loadtest/res/layout/activity_loadtest.xml b/cmds/statsd/tools/loadtest/res/layout/activity_loadtest.xml
index f10b69d..857853e 100644
--- a/cmds/statsd/tools/loadtest/res/layout/activity_loadtest.xml
+++ b/cmds/statsd/tools/loadtest/res/layout/activity_loadtest.xml
@@ -64,15 +64,11 @@
android:layout_height="wrap_content"
android:layout_width="wrap_content"
android:text="@string/bucket_label" />
- <EditText
- android:id="@+id/bucket"
- android:inputType="number"
- android:layout_weight="1"
- android:layout_width="match_parent"
- android:layout_height="wrap_content"
- android:maxLength="3"
- android:text="@integer/bucket_default"
- android:textSize="30dp"/>
+ <Spinner
+ android:id="@+id/bucket_spinner"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:prompt="@string/bucket_label"/>
</LinearLayout>
<LinearLayout
@@ -145,6 +141,7 @@
android:checked="false" />
<LinearLayout
+ android:gravity="center"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="horizontal">
@@ -166,11 +163,6 @@
android:layout_height="wrap_content"
android:text="@string/event"
android:checked="true"/>
- </LinearLayout>
- <LinearLayout
- android:layout_width="match_parent"
- android:layout_height="wrap_content"
- android:orientation="horizontal">
<CheckBox
android:id="@+id/include_value"
android:layout_width="wrap_content"
diff --git a/cmds/statsd/tools/loadtest/res/layout/spinner_item.xml b/cmds/statsd/tools/loadtest/res/layout/spinner_item.xml
new file mode 100644
index 0000000..b03da06
--- /dev/null
+++ b/cmds/statsd/tools/loadtest/res/layout/spinner_item.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<TextView
+ xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:textSize="30dp"
+ android:gravity="left"
+ android:padding="5dip"
+ />
diff --git a/cmds/statsd/tools/loadtest/res/raw/loadtest_config b/cmds/statsd/tools/loadtest/res/raw/loadtest_config
index fbce0e8..2422190 100755
--- a/cmds/statsd/tools/loadtest/res/raw/loadtest_config
+++ b/cmds/statsd/tools/loadtest/res/raw/loadtest_config
Binary files differ
diff --git a/cmds/statsd/tools/loadtest/res/values/integers.xml b/cmds/statsd/tools/loadtest/res/values/integers.xml
index 76b5692..c2407d3 100644
--- a/cmds/statsd/tools/loadtest/res/values/integers.xml
+++ b/cmds/statsd/tools/loadtest/res/values/integers.xml
@@ -17,7 +17,6 @@
*/
-->
<resources>
- <integer name="bucket_default">10</integer>
<integer name="burst_default">1</integer>
<integer name="period_default">2</integer>
<integer name="replication_default">1</integer>
diff --git a/cmds/statsd/tools/loadtest/res/values/strings.xml b/cmds/statsd/tools/loadtest/res/values/strings.xml
index d0f77c6..e8ae3f8 100644
--- a/cmds/statsd/tools/loadtest/res/values/strings.xml
+++ b/cmds/statsd/tools/loadtest/res/values/strings.xml
@@ -20,6 +20,7 @@
<string name="app_name">Statsd Loadtest</string>
<string name="bucket_label">bucket size (mins): </string>
<string name="burst_label">burst: </string>
+ <string name="bucket_default">FIVE_MINUTES</string>
<string name="placebo">placebo</string>
<string name="period_label">logging period (secs): </string>
<string name="replication_label">metric replication: </string>
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/BatteryDataRecorder.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/BatteryDataRecorder.java
index 709b28b29..bab0c1e 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/BatteryDataRecorder.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/BatteryDataRecorder.java
@@ -28,8 +28,10 @@
private static final String DUMP_FILENAME = TAG + "_dump.tmp";
public BatteryDataRecorder(boolean placebo, int replication, TimeUnit bucket, long periodSecs,
- int burst) {
- super(placebo, replication, bucket, periodSecs, burst);
+ int burst, boolean includeCountMetric, boolean includeDurationMetric,
+ boolean includeEventMetric, boolean includeValueMetric, boolean includeGaugeMetric) {
+ super(placebo, replication, bucket, periodSecs, burst, includeCountMetric,
+ includeDurationMetric, includeEventMetric, includeValueMetric, includeGaugeMetric);
}
@Override
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ConfigFactory.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ConfigFactory.java
index b492ea9..843b1e5 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ConfigFactory.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ConfigFactory.java
@@ -42,6 +42,16 @@
* Creates StatsdConfig protos for loadtesting.
*/
public class ConfigFactory {
+ public static class ConfigMetadata {
+ public final byte[] bytes;
+ public final int numMetrics;
+
+ public ConfigMetadata(byte[] bytes, int numMetrics) {
+ this.bytes = bytes;
+ this.numMetrics = numMetrics;
+ }
+ }
+
public static final long CONFIG_ID = 123456789;
private static final String TAG = "loadtest.ConfigFactory";
@@ -81,11 +91,11 @@
* ones
* @param bucketMillis The bucket size, in milliseconds, for aggregate metrics
* @param placebo If true, only return an empty config
- * @return The serialized config
+ * @return The serialized config and the number of metrics.
*/
- public byte[] getConfig(int replication, TimeUnit bucket, boolean placebo, boolean includeCount,
- boolean includeDuration, boolean includeEvent, boolean includeValue,
- boolean includeGauge) {
+ public ConfigMetadata getConfig(int replication, TimeUnit bucket, boolean placebo,
+ boolean includeCount, boolean includeDuration, boolean includeEvent,
+ boolean includeValue, boolean includeGauge) {
StatsdConfig.Builder config = StatsdConfig.newBuilder()
.setId(CONFIG_ID);
if (placebo) {
@@ -137,7 +147,7 @@
Log.d(TAG, "Loadtest config is : " + config.build());
Log.d(TAG, "Generated config has " + numMetrics + " metrics");
- return config.build().toByteArray();
+ return new ConfigMetadata(config.build().toByteArray(), numMetrics);
}
/**
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/LoadtestActivity.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/LoadtestActivity.java
index 056ac0c..c81ac07 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/LoadtestActivity.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/LoadtestActivity.java
@@ -39,16 +39,22 @@
import android.view.inputmethod.InputMethodManager;
import android.view.MotionEvent;
import android.view.View.OnFocusChangeListener;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
+import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;
import com.android.os.StatsLog.ConfigMetricsReport;
import com.android.os.StatsLog.ConfigMetricsReportList;
import com.android.os.StatsLog.StatsdStatsReport;
import com.android.internal.os.StatsdConfigProto.TimeUnit;
+import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
/**
* Runs a load test for statsd.
@@ -68,7 +74,7 @@
* <li> The 'burst' parameter controls how many atoms are pushed at the same time (per period).
* </ul>
*/
-public class LoadtestActivity extends Activity {
+public class LoadtestActivity extends Activity implements AdapterView.OnItemSelectedListener {
private static final String TAG = "StatsdLoadtest";
public static final String TYPE = "type";
@@ -76,6 +82,8 @@
public static final String PERF_ALARM = "perf_alarm";
private static final String START = "start";
private static final String STOP = "stop";
+ private static final Map<String, TimeUnit> TIME_UNIT_MAP = initializeTimeUnitMap();
+ private static final List<String> TIME_UNIT_LABELS = initializeTimeUnitLabels();
public final static class PusherAlarmReceiver extends BroadcastReceiver {
@Override
@@ -95,6 +103,35 @@
}
}
+ private static Map<String, TimeUnit> initializeTimeUnitMap() {
+ Map<String, TimeUnit> labels = new HashMap();
+ labels.put("1m", TimeUnit.ONE_MINUTE);
+ labels.put("5m", TimeUnit.FIVE_MINUTES);
+ labels.put("10m", TimeUnit.TEN_MINUTES);
+ labels.put("30m", TimeUnit.THIRTY_MINUTES);
+ labels.put("1h", TimeUnit.ONE_HOUR);
+ labels.put("3h", TimeUnit.THREE_HOURS);
+ labels.put("6h", TimeUnit.SIX_HOURS);
+ labels.put("12h", TimeUnit.TWELVE_HOURS);
+ labels.put("1d", TimeUnit.ONE_DAY);
+ labels.put("1s", TimeUnit.CTS);
+ return labels;
+ }
+ private static List<String> initializeTimeUnitLabels() {
+ List<String> labels = new ArrayList();
+ labels.add("1s");
+ labels.add("1m");
+ labels.add("5m");
+ labels.add("10m");
+ labels.add("30m");
+ labels.add("1h");
+ labels.add("3h");
+ labels.add("6h");
+ labels.add("12h");
+ labels.add("1d");
+ return labels;
+ }
+
private AlarmManager mAlarmMgr;
/** Used to periodically log atoms to logd. */
@@ -105,7 +142,7 @@
private Button mStartStop;
private EditText mReplicationText;
- private EditText mBucketText;
+ private Spinner mBucketSpinner;
private EditText mPeriodText;
private EditText mBurstText;
private EditText mDurationText;
@@ -187,6 +224,9 @@
/** For intra-minute periods. */
private final Handler mHandler = new Handler();
+ /** Number of metrics in the current config. */
+ private int mNumMetrics;
+
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
@@ -311,6 +351,18 @@
return null;
}
+ @Override
+ public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
+ String item = parent.getItemAtPosition(position).toString();
+
+ mBucket = TIME_UNIT_MAP.get(item);
+ }
+
+ @Override
+ public void onNothingSelected(AdapterView<?> parent) {
+ // Another interface callback
+ }
+
private void onPerfAlarm() {
if (mPerfData != null) {
mPerfData.onAlarm(this);
@@ -318,7 +370,9 @@
// Piggy-back on that alarm to show the elapsed time.
long elapsedTimeMins = (long) Math.floor(
(SystemClock.elapsedRealtime() - mStartedTimeMillis) / 60 / 1000);
- mReportText.setText("Loadtest in progress. Elapsed time = " + elapsedTimeMins + " min(s)");
+ mReportText.setText("Loadtest in progress.\n"
+ + "num metrics =" + mNumMetrics
+ + "\nElapsed time = " + elapsedTimeMins + " min(s)");
}
private void onAlarm() {
@@ -378,10 +432,12 @@
scheduleNext();
// Start tracking performance.
- mPerfData = new PerfData(this, mPlacebo, mReplication, mBucket, mPeriodSecs, mBurst);
+ mPerfData = new PerfData(this, mPlacebo, mReplication, mBucket, mPeriodSecs, mBurst,
+ mIncludeCountMetric, mIncludeDurationMetric, mIncludeEventMetric, mIncludeValueMetric,
+ mIncludeGaugeMetric);
mPerfData.startRecording(this);
- mReportText.setText("Loadtest in progress.");
+ mReportText.setText("Loadtest in progress.\nnum metrics =" + mNumMetrics);
mStartedTimeMillis = SystemClock.elapsedRealtime();
updateStarted(true);
@@ -427,9 +483,16 @@
mBurstText.setEnabled(!mPlacebo && !mStarted);
mReplicationText.setEnabled(!mPlacebo && !mStarted);
mPeriodText.setEnabled(!mStarted);
- mBucketText.setEnabled(!mPlacebo && !mStarted);
+ mBucketSpinner.setEnabled(!mPlacebo && !mStarted);
mDurationText.setEnabled(!mStarted);
mPlaceboCheckBox.setEnabled(!mStarted);
+
+ boolean enabled = !mStarted && !mPlaceboCheckBox.isChecked();
+ mCountMetricCheckBox.setEnabled(enabled);
+ mDurationMetricCheckBox.setEnabled(enabled);
+ mEventMetricCheckBox.setEnabled(enabled);
+ mValueMetricCheckBox.setEnabled(enabled);
+ mGaugeMetricCheckBox.setEnabled(enabled);
}
private boolean statsdRunning() {
@@ -463,10 +526,11 @@
}
}
- private boolean setConfig(byte[] config) {
+ private boolean setConfig(ConfigFactory.ConfigMetadata configData) {
if (mStatsManager != null) {
if (mStatsManager.addConfiguration(ConfigFactory.CONFIG_ID,
- config, getPackageName(), LoadtestActivity.this.getClass().getName())) {
+ configData.bytes, getPackageName(), LoadtestActivity.this.getClass().getName())) {
+ mNumMetrics = configData.numMetrics;
Log.d(TAG, "Config pushed to statsd");
return true;
} else {
@@ -484,10 +548,6 @@
mPeriodSecs = periodSecs;
}
- private synchronized void setBucket(TimeUnit bucket) {
- mBucket = bucket;
- }
-
private synchronized void setBurst(int burst) {
mBurst = burst;
}
@@ -496,12 +556,9 @@
mDurationMins = durationMins;
}
- private synchronized void setPlacebo(boolean placebo) {
- mPlacebo = placebo;
- updateControlsEnabled();
- }
private void handleFocus(EditText editText) {
+ /*
editText.setOnFocusChangeListener(new OnFocusChangeListener() {
@Override
public void onFocusChange(View v, boolean hasFocus) {
@@ -510,6 +567,7 @@
}
}
});
+ */
}
private void initBurst() {
@@ -537,15 +595,23 @@
}
private void initBucket() {
- mBucket = TimeUnit.valueOf(getResources().getInteger(R.integer.bucket_default));
- mBucketText = (EditText) findViewById(R.id.bucket);
- mBucketText.addTextChangedListener(new NumericalWatcher(mBucketText, 1, 9) {
- @Override
- public void onNewValue(int newValue) {
- setBucket(TimeUnit.valueOf(newValue));
+ String defaultValue = getResources().getString(R.string.bucket_default);
+ mBucket = TimeUnit.valueOf(defaultValue);
+ mBucketSpinner = (Spinner) findViewById(R.id.bucket_spinner);
+
+ ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>(
+ this, R.layout.spinner_item, TIME_UNIT_LABELS);
+
+ mBucketSpinner.setAdapter(dataAdapter);
+ mBucketSpinner.setOnItemSelectedListener(this);
+
+ for (String label : TIME_UNIT_MAP.keySet()) {
+ Log.d(TAG, "EVALUATE " + label + " VS " + defaultValue);
+ if (defaultValue.equals(TIME_UNIT_MAP.get(label).toString())) {
+ Log.d(TAG, " FOUND IT");
+ mBucketSpinner.setSelection(dataAdapter.getPosition(label));
}
- });
- handleFocus(mBucketText);
+ }
}
private void initPeriod() {
@@ -578,7 +644,8 @@
mPlaceboCheckBox.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
- setPlacebo(((CheckBox) view).isChecked());
+ mPlacebo = mPlaceboCheckBox.isChecked();
+ updateControlsEnabled();
}
});
}
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/MemoryDataRecorder.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/MemoryDataRecorder.java
index 66bcbff..af7bd4d 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/MemoryDataRecorder.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/MemoryDataRecorder.java
@@ -28,8 +28,10 @@
private StringBuilder mSb;
public MemoryDataRecorder(boolean placebo, int replication, TimeUnit bucket, long periodSecs,
- int burst) {
- super(placebo, replication, bucket, periodSecs, burst);
+ int burst, boolean includeCountMetric, boolean includeDurationMetric,
+ boolean includeEventMetric, boolean includeValueMetric, boolean includeGaugeMetric) {
+ super(placebo, replication, bucket, periodSecs, burst, includeCountMetric,
+ includeDurationMetric, includeEventMetric, includeValueMetric, includeGaugeMetric);
}
@Override
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfData.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfData.java
index 4b4e368..7a01ade 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfData.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfData.java
@@ -54,15 +54,24 @@
private final Set<PerfDataRecorder> mRecorders;
public PerfData(LoadtestActivity loadtestActivity, boolean placebo, int replication,
- TimeUnit bucket, long periodSecs, int burst) {
- super(placebo, replication, bucket, periodSecs, burst);
+ TimeUnit bucket, long periodSecs, int burst, boolean includeCountMetric,
+ boolean includeDurationMetric, boolean includeEventMetric, boolean includeValueMetric,
+ boolean includeGaugeMetric) {
+ super(placebo, replication, bucket, periodSecs, burst, includeCountMetric,
+ includeDurationMetric, includeEventMetric, includeValueMetric, includeGaugeMetric);
mRecorders = new HashSet();
- mRecorders.add(new BatteryDataRecorder(placebo, replication, bucket, periodSecs, burst));
- mRecorders.add(new MemoryDataRecorder(placebo, replication, bucket, periodSecs, burst));
+ mRecorders.add(new BatteryDataRecorder(placebo, replication, bucket, periodSecs, burst,
+ includeCountMetric, includeDurationMetric, includeEventMetric, includeValueMetric,
+ includeGaugeMetric));
+ mRecorders.add(new MemoryDataRecorder(placebo, replication, bucket, periodSecs, burst,
+ includeCountMetric, includeDurationMetric, includeEventMetric, includeValueMetric,
+ includeGaugeMetric));
mRecorders.add(new StatsdStatsRecorder(loadtestActivity, placebo, replication, bucket,
- periodSecs, burst));
+ periodSecs, burst, includeCountMetric, includeDurationMetric, includeEventMetric,
+ includeValueMetric, includeGaugeMetric));
mRecorders.add(new ValidationRecorder(loadtestActivity, placebo, replication, bucket,
- periodSecs, burst));
+ periodSecs, burst, includeCountMetric, includeDurationMetric, includeEventMetric,
+ includeValueMetric, includeGaugeMetric));
mAlarmMgr = (AlarmManager) loadtestActivity.getSystemService(Context.ALARM_SERVICE);
}
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfDataRecorder.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfDataRecorder.java
index fd182ad..8613ac1 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfDataRecorder.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/PerfDataRecorder.java
@@ -40,9 +40,12 @@
protected final String mColumnSuffix;
protected PerfDataRecorder(boolean placebo, int replication, TimeUnit bucket, long periodSecs,
- int burst) {
+ int burst, boolean includeCountMetric, boolean includeDurationMetric,
+ boolean includeEventMetric, boolean includeValueMetric, boolean includeGaugeMetric) {
mTimeAsString = new SimpleDateFormat("YYYY_MM_dd_HH_mm_ss").format(new Date());
- mColumnSuffix = getColumnSuffix(placebo, replication, bucket, periodSecs, burst);
+ mColumnSuffix = getColumnSuffix(placebo, replication, bucket, periodSecs, burst,
+ includeCountMetric, includeDurationMetric, includeEventMetric, includeValueMetric,
+ includeGaugeMetric);
}
/** Starts recording performance data. */
@@ -122,14 +125,35 @@
/** Gets the suffix to use in the column name for perf data. */
private String getColumnSuffix(boolean placebo, int replication, TimeUnit bucket,
- long periodSecs, int burst) {
+ long periodSecs, int burst, boolean includeCountMetric, boolean includeDurationMetric,
+ boolean includeEventMetric, boolean includeValueMetric, boolean includeGaugeMetric) {
if (placebo) {
return "_placebo_p=" + periodSecs;
}
- return "_r=" + replication + "_bkt=" + bucket + "_p=" + periodSecs + "_bst=" + burst;
+ StringBuilder sb = new StringBuilder()
+ .append("_r=" + replication)
+ .append("_bkt=" + bucket)
+ .append("_p=" + periodSecs)
+ .append("_bst=" + burst)
+ .append("_m=");
+ if (includeCountMetric) {
+ sb.append("c");
+ }
+ if (includeEventMetric) {
+ sb.append("e");
+ }
+ if (includeDurationMetric) {
+ sb.append("d");
+ }
+ if (includeGaugeMetric) {
+ sb.append("g");
+ }
+ if (includeValueMetric) {
+ sb.append("v");
+ }
+ return sb.toString();
}
-
private File getStorageDir() {
File file = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_DOCUMENTS), "loadtest/" + mTimeAsString);
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/StatsdStatsRecorder.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/StatsdStatsRecorder.java
index 1e30fdf..e63150f 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/StatsdStatsRecorder.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/StatsdStatsRecorder.java
@@ -28,8 +28,11 @@
private final LoadtestActivity mLoadtestActivity;
public StatsdStatsRecorder(LoadtestActivity loadtestActivity, boolean placebo, int replication,
- TimeUnit bucket, long periodSecs, int burst) {
- super(placebo, replication, bucket, periodSecs, burst);
+ TimeUnit bucket, long periodSecs, int burst, boolean includeCountMetric,
+ boolean includeDurationMetric, boolean includeEventMetric, boolean includeValueMetric,
+ boolean includeGaugeMetric) {
+ super(placebo, replication, bucket, periodSecs, burst, includeCountMetric,
+ includeDurationMetric, includeEventMetric, includeValueMetric, includeGaugeMetric);
mLoadtestActivity = loadtestActivity;
}
@@ -56,7 +59,7 @@
.append(configStats.getConditionCount() + "\n")
.append("matcher_count,")
.append(configStats.getMatcherCount() + "\n");
- writeData(context, "statsdstats_", "", sb);
+ writeData(context, "statsdstats_", "stat,value", sb);
}
}
}
diff --git a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ValidationRecorder.java b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ValidationRecorder.java
index 5d26be3..d9f0ca9 100644
--- a/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ValidationRecorder.java
+++ b/cmds/statsd/tools/loadtest/src/com/android/statsd/loadtest/ValidationRecorder.java
@@ -34,8 +34,11 @@
private final LoadtestActivity mLoadtestActivity;
public ValidationRecorder(LoadtestActivity loadtestActivity, boolean placebo, int replication,
- TimeUnit bucket, long periodSecs, int burst) {
- super(placebo, replication, bucket, periodSecs, burst);
+ TimeUnit bucket, long periodSecs, int burst, boolean includeCountMetric,
+ boolean includeDurationMetric, boolean includeEventMetric, boolean includeValueMetric,
+ boolean includeGaugeMetric) {
+ super(placebo, replication, bucket, periodSecs, burst, includeCountMetric,
+ includeDurationMetric, includeEventMetric, includeValueMetric, includeGaugeMetric);
mLoadtestActivity = loadtestActivity;
}
@@ -55,6 +58,9 @@
}
private void validateData() {
+ // The code below is commented out because it calls getData, which has the side-effect
+ // of clearing statsd's data buffer.
+ /*
List<ConfigMetricsReport> reports = mLoadtestActivity.getData();
if (reports != null) {
Log.d(TAG, "GOT DATA");
@@ -66,6 +72,7 @@
}
}
}
+ */
}
private void validateEventBatteryLevelChanges(StatsLogReport logReport) {
diff --git a/core/java/android/annotation/SystemApi.java b/core/java/android/annotation/SystemApi.java
index 55028eb..e96ff01 100644
--- a/core/java/android/annotation/SystemApi.java
+++ b/core/java/android/annotation/SystemApi.java
@@ -39,6 +39,6 @@
* @hide
*/
@Target({TYPE, FIELD, METHOD, CONSTRUCTOR, ANNOTATION_TYPE, PACKAGE})
-@Retention(RetentionPolicy.SOURCE)
+@Retention(RetentionPolicy.RUNTIME)
public @interface SystemApi {
}
diff --git a/core/java/android/app/Notification.java b/core/java/android/app/Notification.java
index 85c3be8..046a128 100644
--- a/core/java/android/app/Notification.java
+++ b/core/java/android/app/Notification.java
@@ -5994,8 +5994,15 @@
/**
* Sets the title to be displayed on this conversation. May be set to {@code null}.
*
- * @param conversationTitle A name for the conversation, or {@code null}
- * @return this object for method chaining.
+ * <p>This API's behavior was changed in SDK version {@link Build.VERSION_CODES#P}. If your
+ * application's target version is less than {@link Build.VERSION_CODES#P}, setting a
+ * conversation title to a non-null value will make {@link #isGroupConversation()} return
+ * {@code true} and passing {@code null} will make it return {@code false}. In
+ * {@link Build.VERSION_CODES#P} and beyond, use {@link #setGroupConversation(boolean)}
+ * to set group conversation status.
+ *
+ * @param conversationTitle Title displayed for this conversation
+ * @return this object for method chaining
*/
public MessagingStyle setConversationTitle(@Nullable CharSequence conversationTitle) {
mConversationTitle = conversationTitle;
@@ -6083,6 +6090,7 @@
/**
* Sets whether this conversation notification represents a group.
+ *
* @param isGroupConversation {@code true} if the conversation represents a group,
* {@code false} otherwise.
* @return this object for method chaining
@@ -6093,9 +6101,27 @@
}
/**
- * Returns {@code true} if this notification represents a group conversation.
+ * Returns {@code true} if this notification represents a group conversation, otherwise
+ * {@code false}.
+ *
+ * <p> If the application that generated this {@link MessagingStyle} targets an SDK version
+ * less than {@link Build.VERSION_CODES#P}, this method becomes dependent on whether or
+ * not the conversation title is set; returning {@code true} if the conversation title is
+ * a non-null value, or {@code false} otherwise. From {@link Build.VERSION_CODES#P} forward,
+ * this method returns what's set by {@link #setGroupConversation(boolean)} allowing for
+ * named, non-group conversations.
+ *
+ * @see #setConversationTitle(CharSequence)
*/
public boolean isGroupConversation() {
+ // When target SDK version is < P, a non-null conversation title dictates if this is
+ // as group conversation.
+ if (mBuilder != null
+ && mBuilder.mContext.getApplicationInfo().targetSdkVersion
+ < Build.VERSION_CODES.P) {
+ return mConversationTitle != null;
+ }
+
return mIsGroupConversation;
}
diff --git a/core/java/android/app/backup/BackupManager.java b/core/java/android/app/backup/BackupManager.java
index 6512b98..3a6a5b2 100644
--- a/core/java/android/app/backup/BackupManager.java
+++ b/core/java/android/app/backup/BackupManager.java
@@ -707,7 +707,6 @@
* redirects them into main-thread actions. This serializes the backup
* progress callbacks nicely within the usual main-thread lifecycle pattern.
*/
- @SystemApi
private class BackupObserverWrapper extends IBackupObserver.Stub {
final Handler mHandler;
final BackupObserver mObserver;
diff --git a/core/java/android/app/backup/IBackupManager.aidl b/core/java/android/app/backup/IBackupManager.aidl
index c42a898..792cb5f 100644
--- a/core/java/android/app/backup/IBackupManager.aidl
+++ b/core/java/android/app/backup/IBackupManager.aidl
@@ -402,6 +402,9 @@
/**
* Ask the framework whether this app is eligible for backup.
*
+ * <p>If you are calling this method multiple times, you should instead use
+ * {@link #filterAppsEligibleForBackup(String[])} to save resources.
+ *
* <p>Callers must hold the android.permission.BACKUP permission to use this method.
*
* @param packageName The name of the package.
@@ -410,6 +413,16 @@
boolean isAppEligibleForBackup(String packageName);
/**
+ * Filter the packages that are eligible for backup and return the result.
+ *
+ * <p>Callers must hold the android.permission.BACKUP permission to use this method.
+ *
+ * @param packages The list of packages to filter.
+ * @return The packages eligible for backup.
+ */
+ String[] filterAppsEligibleForBackup(in String[] packages);
+
+ /**
* Request an immediate backup, providing an observer to which results of the backup operation
* will be published. The Android backup system will decide for each package whether it will
* be full app data backup or key/value-pair-based backup.
diff --git a/core/java/android/bluetooth/BluetoothA2dp.java b/core/java/android/bluetooth/BluetoothA2dp.java
index 7841b83..35a21a4 100644
--- a/core/java/android/bluetooth/BluetoothA2dp.java
+++ b/core/java/android/bluetooth/BluetoothA2dp.java
@@ -17,6 +17,7 @@
package android.bluetooth;
import android.Manifest;
+import android.annotation.Nullable;
import android.annotation.RequiresPermission;
import android.annotation.SdkConstant;
import android.annotation.SdkConstant.SdkConstantType;
@@ -103,6 +104,24 @@
"android.bluetooth.a2dp.profile.action.AVRCP_CONNECTION_STATE_CHANGED";
/**
+ * Intent used to broadcast the selection of a connected device as active.
+ *
+ * <p>This intent will have one extra:
+ * <ul>
+ * <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device. It can
+ * be null if no device is active. </li>
+ * </ul>
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission to
+ * receive.
+ *
+ * @hide
+ */
+ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
+ public static final String ACTION_ACTIVE_DEVICE_CHANGED =
+ "android.bluetooth.a2dp.profile.action.ACTIVE_DEVICE_CHANGED";
+
+ /**
* Intent used to broadcast the change in the Audio Codec state of the
* A2DP Source profile.
*
@@ -425,6 +444,75 @@
}
/**
+ * Select a connected device as active.
+ *
+ * The active device selection is per profile. An active device's
+ * purpose is profile-specific. For example, A2DP audio streaming
+ * is to the active A2DP Sink device. If a remote device is not
+ * connected, it cannot be selected as active.
+ *
+ * <p> This API returns false in scenarios like the profile on the
+ * device is not connected or Bluetooth is not turned on.
+ * When this API returns true, it is guaranteed that the
+ * {@link #ACTION_ACTIVE_DEVICE_CHANGED} intent will be broadcasted
+ * with the active device.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN}
+ * permission.
+ *
+ * @param device the remote Bluetooth device. Could be null to clear
+ * the active device and stop streaming audio to a Bluetooth device.
+ * @return false on immediate error, true otherwise
+ * @hide
+ */
+ public boolean setActiveDevice(@Nullable BluetoothDevice device) {
+ if (DBG) log("setActiveDevice(" + device + ")");
+ try {
+ mServiceLock.readLock().lock();
+ if (mService != null && isEnabled()
+ && ((device == null) || isValidDevice(device))) {
+ return mService.setActiveDevice(device);
+ }
+ if (mService == null) Log.w(TAG, "Proxy not attached to service");
+ return false;
+ } catch (RemoteException e) {
+ Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
+ return false;
+ } finally {
+ mServiceLock.readLock().unlock();
+ }
+ }
+
+ /**
+ * Get the connected device that is active.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH}
+ * permission.
+ *
+ * @return the connected device that is active or null if no device
+ * is active
+ * @hide
+ */
+ @RequiresPermission(Manifest.permission.BLUETOOTH)
+ @Nullable
+ public BluetoothDevice getActiveDevice() {
+ if (VDBG) log("getActiveDevice()");
+ try {
+ mServiceLock.readLock().lock();
+ if (mService != null && isEnabled()) {
+ return mService.getActiveDevice();
+ }
+ if (mService == null) Log.w(TAG, "Proxy not attached to service");
+ return null;
+ } catch (RemoteException e) {
+ Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));
+ return null;
+ } finally {
+ mServiceLock.readLock().unlock();
+ }
+ }
+
+ /**
* Set priority of the profile
*
* <p> The device should already be paired.
diff --git a/core/java/android/bluetooth/BluetoothHeadset.java b/core/java/android/bluetooth/BluetoothHeadset.java
index 838d315..55a6b4c 100644
--- a/core/java/android/bluetooth/BluetoothHeadset.java
+++ b/core/java/android/bluetooth/BluetoothHeadset.java
@@ -16,6 +16,7 @@
package android.bluetooth;
+import android.annotation.Nullable;
import android.annotation.RequiresPermission;
import android.annotation.SdkConstant;
import android.annotation.SdkConstant.SdkConstantType;
@@ -93,6 +94,23 @@
public static final String ACTION_AUDIO_STATE_CHANGED =
"android.bluetooth.headset.profile.action.AUDIO_STATE_CHANGED";
+ /**
+ * Intent used to broadcast the selection of a connected device as active.
+ *
+ * <p>This intent will have one extra:
+ * <ul>
+ * <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote device. It can
+ * be null if no device is active. </li>
+ * </ul>
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission to
+ * receive.
+ *
+ * @hide
+ */
+ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
+ public static final String ACTION_ACTIVE_DEVICE_CHANGED =
+ "android.bluetooth.headset.profile.action.ACTIVE_DEVICE_CHANGED";
/**
* Intent used to broadcast that the headset has posted a
@@ -983,6 +1001,76 @@
}
/**
+ * Select a connected device as active.
+ *
+ * The active device selection is per profile. An active device's
+ * purpose is profile-specific. For example, in HFP and HSP profiles,
+ * it is the device used for phone call audio. If a remote device is not
+ * connected, it cannot be selected as active.
+ *
+ * <p> This API returns false in scenarios like the profile on the
+ * device is not connected or Bluetooth is not turned on.
+ * When this API returns true, it is guaranteed that the
+ * {@link #ACTION_ACTIVE_DEVICE_CHANGED} intent will be broadcasted
+ * with the active device.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH_ADMIN}
+ * permission.
+ *
+ * @param device Remote Bluetooth Device, could be null if phone call audio should not be
+ * streamed to a headset
+ * @return false on immediate error, true otherwise
+ * @hide
+ */
+ @RequiresPermission(android.Manifest.permission.BLUETOOTH_ADMIN)
+ public boolean setActiveDevice(@Nullable BluetoothDevice device) {
+ if (DBG) {
+ Log.d(TAG, "setActiveDevice: " + device);
+ }
+ final IBluetoothHeadset service = mService;
+ if (service != null && isEnabled() && (device == null || isValidDevice(device))) {
+ try {
+ return service.setActiveDevice(device);
+ } catch (RemoteException e) {
+ Log.e(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ }
+ if (service == null) {
+ Log.w(TAG, "Proxy not attached to service");
+ }
+ return false;
+ }
+
+ /**
+ * Get the connected device that is active.
+ *
+ * <p>Requires {@link android.Manifest.permission#BLUETOOTH}
+ * permission.
+ *
+ * @return the connected device that is active or null if no device
+ * is active.
+ * @hide
+ */
+ @RequiresPermission(android.Manifest.permission.BLUETOOTH)
+ public BluetoothDevice getActiveDevice() {
+ if (VDBG) {
+ Log.d(TAG, "getActiveDevice");
+ }
+ final IBluetoothHeadset service = mService;
+ if (service != null && isEnabled()) {
+ try {
+ return service.getActiveDevice();
+ } catch (RemoteException e) {
+ Log.e(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ }
+ if (service == null) {
+ Log.w(TAG, "Proxy not attached to service");
+ }
+ return null;
+ }
+
+ /**
* check if in-band ringing is supported for this platform.
*
* @return true if in-band ringing is supported false if in-band ringing is not supported
diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java
index 4cedeaa..c5c6aa2 100644
--- a/core/java/android/content/Context.java
+++ b/core/java/android/content/Context.java
@@ -3532,7 +3532,7 @@
* @see android.net.wifi.rtt.WifiRttManager
* @hide
*/
- public static final String WIFI_RTT_RANGING_SERVICE = "rttmanager2";
+ public static final String WIFI_RTT_RANGING_SERVICE = "wifirtt";
/**
* Use with {@link #getSystemService} to retrieve a {@link
diff --git a/core/java/android/content/pm/PackageBackwardCompatibility.java b/core/java/android/content/pm/PackageBackwardCompatibility.java
index cee2599..8014c94 100644
--- a/core/java/android/content/pm/PackageBackwardCompatibility.java
+++ b/core/java/android/content/pm/PackageBackwardCompatibility.java
@@ -16,6 +16,8 @@
package android.content.pm;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
import android.content.pm.PackageParser.Package;
import android.os.Build;
@@ -56,7 +58,7 @@
boolean apacheHttpLegacyPresent = isLibraryPresent(
usesLibraries, usesOptionalLibraries, APACHE_HTTP_LEGACY);
if (!apacheHttpLegacyPresent) {
- usesLibraries = ArrayUtils.add(usesLibraries, APACHE_HTTP_LEGACY);
+ usesLibraries = prefix(usesLibraries, APACHE_HTTP_LEGACY);
}
}
@@ -86,4 +88,12 @@
return ArrayUtils.contains(usesLibraries, apacheHttpLegacy)
|| ArrayUtils.contains(usesOptionalLibraries, apacheHttpLegacy);
}
+
+ private static @NonNull <T> ArrayList<T> prefix(@Nullable ArrayList<T> cur, T val) {
+ if (cur == null) {
+ cur = new ArrayList<>();
+ }
+ cur.add(0, val);
+ return cur;
+ }
}
diff --git a/core/java/android/hardware/hdmi/HdmiTimerRecordSources.java b/core/java/android/hardware/hdmi/HdmiTimerRecordSources.java
index 6fe13ca..d7c2e1b 100644
--- a/core/java/android/hardware/hdmi/HdmiTimerRecordSources.java
+++ b/core/java/android/hardware/hdmi/HdmiTimerRecordSources.java
@@ -187,7 +187,6 @@
* Base class for time-related information.
* @hide
*/
- @SystemApi
/* package */ static class TimeUnit {
/* package */ final int mHour;
/* package */ final int mMinute;
diff --git a/core/java/android/hardware/location/ContextHubMessage.java b/core/java/android/hardware/location/ContextHubMessage.java
index bca2ae6..2a4ad00 100644
--- a/core/java/android/hardware/location/ContextHubMessage.java
+++ b/core/java/android/hardware/location/ContextHubMessage.java
@@ -19,14 +19,20 @@
import android.annotation.SystemApi;
import android.os.Parcel;
import android.os.Parcelable;
-import android.util.Log;
import java.util.Arrays;
/**
+ * @deprecated Use {@link android.hardware.location.NanoAppMessage} instead to send messages with
+ * {@link android.hardware.location.ContextHubClient#sendMessageToNanoApp(
+ * NanoAppMessage)} and receive messages with
+ * {@link android.hardware.location.ContextHubClientCallback#onMessageFromNanoApp(
+ * ContextHubClient, NanoAppMessage)}.
+ *
* @hide
*/
@SystemApi
+@Deprecated
public class ContextHubMessage {
private int mType;
private int mVersion;
@@ -34,7 +40,6 @@
private static final String TAG = "ContextHubMessage";
-
/**
* Get the message type
*
diff --git a/core/java/android/hardware/location/NanoApp.java b/core/java/android/hardware/location/NanoApp.java
index 0465def..b5c01ec 100644
--- a/core/java/android/hardware/location/NanoApp.java
+++ b/core/java/android/hardware/location/NanoApp.java
@@ -28,9 +28,14 @@
* Nano apps are expected to be used only by bundled apps only
* at this time.
*
+ * @deprecated Use {@link android.hardware.location.NanoAppBinary} instead to load a nanoapp with
+ * {@link android.hardware.location.ContextHubManager#loadNanoApp(
+ * ContextHubInfo, NanoAppBinary)}.
+ *
* @hide
*/
@SystemApi
+@Deprecated
public class NanoApp {
private final String TAG = "NanoApp";
diff --git a/core/java/android/hardware/location/NanoAppFilter.java b/core/java/android/hardware/location/NanoAppFilter.java
index 5ccf546..75a96ee 100644
--- a/core/java/android/hardware/location/NanoAppFilter.java
+++ b/core/java/android/hardware/location/NanoAppFilter.java
@@ -16,15 +16,18 @@
package android.hardware.location;
-
import android.annotation.SystemApi;
import android.os.Parcel;
import android.os.Parcelable;
/**
+ * @deprecated Use {@link android.hardware.location.ContextHubManager#queryNanoApps(ContextHubInfo)}
+ * to find loaded nanoapps, which doesn't require using this class as a parameter.
+ *
* @hide
*/
@SystemApi
+@Deprecated
public class NanoAppFilter {
private static final String TAG = "NanoAppFilter";
diff --git a/core/java/android/hardware/location/NanoAppInstanceInfo.java b/core/java/android/hardware/location/NanoAppInstanceInfo.java
index c00819b..f1926eaa 100644
--- a/core/java/android/hardware/location/NanoAppInstanceInfo.java
+++ b/core/java/android/hardware/location/NanoAppInstanceInfo.java
@@ -28,9 +28,12 @@
*
* TODO(b/69270990) Remove this class once the old API is deprecated.
*
+ * @deprecated Use {@link android.hardware.location.NanoAppState} instead.
+ *
* @hide
*/
@SystemApi
+@Deprecated
public class NanoAppInstanceInfo {
private String mPublisher = "Unknown";
private String mName = "Unknown";
diff --git a/core/java/android/hardware/radio/RadioManager.java b/core/java/android/hardware/radio/RadioManager.java
index 9b6515c..6e383ae 100644
--- a/core/java/android/hardware/radio/RadioManager.java
+++ b/core/java/android/hardware/radio/RadioManager.java
@@ -1654,8 +1654,8 @@
TunerCallbackAdapter halCallback = new TunerCallbackAdapter(callback, handler);
try {
tuner = mService.openTuner(moduleId, config, withAudio, halCallback);
- } catch (RemoteException e) {
- Log.e(TAG, "Failed to open tuner", e);
+ } catch (RemoteException | IllegalArgumentException ex) {
+ Log.e(TAG, "Failed to open tuner", ex);
return null;
}
if (tuner == null) {
diff --git a/core/java/android/hardware/radio/TunerAdapter.java b/core/java/android/hardware/radio/TunerAdapter.java
index 864d17c..a8a896a 100644
--- a/core/java/android/hardware/radio/TunerAdapter.java
+++ b/core/java/android/hardware/radio/TunerAdapter.java
@@ -63,6 +63,7 @@
@Override
public int setConfiguration(RadioManager.BandConfig config) {
+ if (config == null) return RadioManager.STATUS_BAD_VALUE;
try {
mTuner.setConfiguration(config);
mBand = config.getType();
diff --git a/core/java/android/net/IpSecConfig.java b/core/java/android/net/IpSecConfig.java
index e6cd3fc..f54ceb5 100644
--- a/core/java/android/net/IpSecConfig.java
+++ b/core/java/android/net/IpSecConfig.java
@@ -102,17 +102,11 @@
/** Set the local IP address for Tunnel mode */
public void setLocalAddress(String localAddress) {
- if (localAddress == null) {
- throw new IllegalArgumentException("localAddress may not be null!");
- }
mLocalAddress = localAddress;
}
/** Set the remote IP address for this IPsec transform */
public void setRemoteAddress(String remoteAddress) {
- if (remoteAddress == null) {
- throw new IllegalArgumentException("remoteAddress may not be null!");
- }
mRemoteAddress = remoteAddress;
}
diff --git a/core/java/android/net/IpSecManager.java b/core/java/android/net/IpSecManager.java
index 6a4b891..34cfa9b 100644
--- a/core/java/android/net/IpSecManager.java
+++ b/core/java/android/net/IpSecManager.java
@@ -69,7 +69,7 @@
}
/** @hide */
- public static final int INVALID_RESOURCE_ID = 0;
+ public static final int INVALID_RESOURCE_ID = -1;
/**
* Thrown to indicate that a requested SPI is in use.
@@ -128,7 +128,7 @@
private final InetAddress mRemoteAddress;
private final CloseGuard mCloseGuard = CloseGuard.get();
private int mSpi = INVALID_SECURITY_PARAMETER_INDEX;
- private int mResourceId;
+ private int mResourceId = INVALID_RESOURCE_ID;
/** Get the underlying SPI held by this object. */
public int getSpi() {
@@ -146,6 +146,7 @@
public void close() {
try {
mService.releaseSecurityParameterIndex(mResourceId);
+ mResourceId = INVALID_RESOURCE_ID;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
@@ -501,7 +502,7 @@
public static final class UdpEncapsulationSocket implements AutoCloseable {
private final ParcelFileDescriptor mPfd;
private final IIpSecService mService;
- private final int mResourceId;
+ private int mResourceId = INVALID_RESOURCE_ID;
private final int mPort;
private final CloseGuard mCloseGuard = CloseGuard.get();
@@ -554,6 +555,7 @@
public void close() throws IOException {
try {
mService.closeUdpEncapsulationSocket(mResourceId);
+ mResourceId = INVALID_RESOURCE_ID;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
diff --git a/core/java/android/net/IpSecTransform.java b/core/java/android/net/IpSecTransform.java
index 7cd742b..102ba6d 100644
--- a/core/java/android/net/IpSecTransform.java
+++ b/core/java/android/net/IpSecTransform.java
@@ -347,6 +347,9 @@
*/
public IpSecTransform.Builder setSpi(
@TransformDirection int direction, IpSecManager.SecurityParameterIndex spi) {
+ if (spi.getResourceId() == INVALID_RESOURCE_ID) {
+ throw new IllegalArgumentException("Invalid SecurityParameterIndex");
+ }
mConfig.setSpiResourceId(direction, spi.getResourceId());
return this;
}
@@ -381,6 +384,9 @@
public IpSecTransform.Builder setIpv4Encapsulation(
IpSecManager.UdpEncapsulationSocket localSocket, int remotePort) {
mConfig.setEncapType(ENCAP_ESPINUDP);
+ if (localSocket.getResourceId() == INVALID_RESOURCE_ID) {
+ throw new IllegalArgumentException("Invalid UdpEncapsulationSocket");
+ }
mConfig.setEncapSocketResourceId(localSocket.getResourceId());
mConfig.setEncapRemotePort(remotePort);
return this;
@@ -426,6 +432,9 @@
public IpSecTransform buildTransportModeTransform(InetAddress remoteAddress)
throws IpSecManager.ResourceUnavailableException,
IpSecManager.SpiUnavailableException, IOException {
+ if (remoteAddress == null) {
+ throw new IllegalArgumentException("Remote address may not be null or empty!");
+ }
mConfig.setMode(MODE_TRANSPORT);
mConfig.setRemoteAddress(remoteAddress.getHostAddress());
// FIXME: modifying a builder after calling build can change the built transform.
@@ -447,8 +456,12 @@
*/
public IpSecTransform buildTunnelModeTransform(
InetAddress localAddress, InetAddress remoteAddress) {
- // FIXME: argument validation here
- // throw new IllegalArgumentException("Natt Keepalive requires UDP Encapsulation");
+ if (localAddress == null) {
+ throw new IllegalArgumentException("Local address may not be null or empty!");
+ }
+ if (remoteAddress == null) {
+ throw new IllegalArgumentException("Remote address may not be null or empty!");
+ }
mConfig.setLocalAddress(localAddress.getHostAddress());
mConfig.setRemoteAddress(remoteAddress.getHostAddress());
mConfig.setMode(MODE_TUNNEL);
diff --git a/core/java/android/net/TrafficStats.java b/core/java/android/net/TrafficStats.java
index 196a3bc..bda720bb 100644
--- a/core/java/android/net/TrafficStats.java
+++ b/core/java/android/net/TrafficStats.java
@@ -27,6 +27,7 @@
import android.media.MediaPlayer;
import android.os.RemoteException;
import android.os.ServiceManager;
+import android.util.DataUnit;
import com.android.server.NetworkManagementSocketTagger;
@@ -56,15 +57,20 @@
*/
public final static int UNSUPPORTED = -1;
- /** @hide */
+ /** @hide @deprecated use {@link DataUnit} instead to clarify SI-vs-IEC */
+ @Deprecated
public static final long KB_IN_BYTES = 1024;
- /** @hide */
+ /** @hide @deprecated use {@link DataUnit} instead to clarify SI-vs-IEC */
+ @Deprecated
public static final long MB_IN_BYTES = KB_IN_BYTES * 1024;
- /** @hide */
+ /** @hide @deprecated use {@link DataUnit} instead to clarify SI-vs-IEC */
+ @Deprecated
public static final long GB_IN_BYTES = MB_IN_BYTES * 1024;
- /** @hide */
+ /** @hide @deprecated use {@link DataUnit} instead to clarify SI-vs-IEC */
+ @Deprecated
public static final long TB_IN_BYTES = GB_IN_BYTES * 1024;
- /** @hide */
+ /** @hide @deprecated use {@link DataUnit} instead to clarify SI-vs-IEC */
+ @Deprecated
public static final long PB_IN_BYTES = TB_IN_BYTES * 1024;
/**
diff --git a/core/java/android/os/HidlSupport.java b/core/java/android/os/HidlSupport.java
index a080c8d..4d7d931 100644
--- a/core/java/android/os/HidlSupport.java
+++ b/core/java/android/os/HidlSupport.java
@@ -86,6 +86,25 @@
}
/**
+ * Class which can be used to fetch an object out of a lambda. Fetching an object
+ * out of a local scope with HIDL is a common operation (although usually it can
+ * and should be avoided).
+ *
+ * @param <E> Inner object type.
+ */
+ public static final class Mutable<E> {
+ public E value;
+
+ public Mutable() {
+ value = null;
+ }
+
+ public Mutable(E value) {
+ this.value = value;
+ }
+ }
+
+ /**
* Similar to Arrays.deepHashCode, but also take care of lists.
*/
public static int deepHashCode(Object o) {
diff --git a/core/java/android/os/WorkSource.java b/core/java/android/os/WorkSource.java
index 401b4a3..bb043b0 100644
--- a/core/java/android/os/WorkSource.java
+++ b/core/java/android/os/WorkSource.java
@@ -407,11 +407,11 @@
}
public boolean remove(WorkSource other) {
- if (mNum <= 0 || other.mNum <= 0) {
+ if (isEmpty() || other.isEmpty()) {
return false;
}
- boolean uidRemoved = false;
+ boolean uidRemoved;
if (mNames == null && other.mNames == null) {
uidRemoved = removeUids(other);
} else {
@@ -427,13 +427,8 @@
}
boolean chainRemoved = false;
- if (other.mChains != null) {
- if (mChains != null) {
- chainRemoved = mChains.removeAll(other.mChains);
- }
- } else if (mChains != null) {
- mChains.clear();
- chainRemoved = true;
+ if (other.mChains != null && mChains != null) {
+ chainRemoved = mChains.removeAll(other.mChains);
}
return uidRemoved || chainRemoved;
diff --git a/core/java/android/os/storage/StorageManager.java b/core/java/android/os/storage/StorageManager.java
index 68c242d..f4deeed 100644
--- a/core/java/android/os/storage/StorageManager.java
+++ b/core/java/android/os/storage/StorageManager.java
@@ -16,9 +16,6 @@
package android.os.storage;
-import static android.net.TrafficStats.GB_IN_BYTES;
-import static android.net.TrafficStats.MB_IN_BYTES;
-
import android.annotation.BytesLong;
import android.annotation.IntDef;
import android.annotation.NonNull;
@@ -59,6 +56,7 @@
import android.system.Os;
import android.system.OsConstants;
import android.text.TextUtils;
+import android.util.DataUnit;
import android.util.Log;
import android.util.Pair;
import android.util.Slog;
@@ -116,6 +114,8 @@
/** {@hide} */
public static final String PROP_HAS_ADOPTABLE = "vold.has_adoptable";
/** {@hide} */
+ public static final String PROP_HAS_RESERVED = "vold.has_reserved";
+ /** {@hide} */
public static final String PROP_FORCE_ADOPTABLE = "persist.fw.force_adoptable";
/** {@hide} */
public static final String PROP_EMULATE_FBE = "persist.sys.emulate_fbe";
@@ -1197,12 +1197,12 @@
}
private static final int DEFAULT_THRESHOLD_PERCENTAGE = 5;
- private static final long DEFAULT_THRESHOLD_MAX_BYTES = 500 * MB_IN_BYTES;
+ private static final long DEFAULT_THRESHOLD_MAX_BYTES = DataUnit.MEBIBYTES.toBytes(500);
private static final int DEFAULT_CACHE_PERCENTAGE = 10;
- private static final long DEFAULT_CACHE_MAX_BYTES = 5 * GB_IN_BYTES;
+ private static final long DEFAULT_CACHE_MAX_BYTES = DataUnit.GIBIBYTES.toBytes(5);
- private static final long DEFAULT_FULL_THRESHOLD_BYTES = MB_IN_BYTES;
+ private static final long DEFAULT_FULL_THRESHOLD_BYTES = DataUnit.MEBIBYTES.toBytes(1);
/**
* Return the number of available bytes until the given path is considered
diff --git a/core/java/android/provider/DocumentsContract.java b/core/java/android/provider/DocumentsContract.java
index 99fcdad..e7fd59e 100644
--- a/core/java/android/provider/DocumentsContract.java
+++ b/core/java/android/provider/DocumentsContract.java
@@ -16,7 +16,6 @@
package android.provider;
-import static android.net.TrafficStats.KB_IN_BYTES;
import static android.system.OsConstants.SEEK_SET;
import static com.android.internal.util.Preconditions.checkArgument;
@@ -51,6 +50,7 @@
import android.os.storage.StorageVolume;
import android.system.ErrnoException;
import android.system.Os;
+import android.util.DataUnit;
import android.util.Log;
import libcore.io.IoUtils;
@@ -173,7 +173,7 @@
/**
* Buffer is large enough to rewind past any EXIF headers.
*/
- private static final int THUMBNAIL_BUFFER_SIZE = (int) (128 * KB_IN_BYTES);
+ private static final int THUMBNAIL_BUFFER_SIZE = (int) DataUnit.KIBIBYTES.toBytes(128);
/** {@hide} */
public static final String EXTERNAL_STORAGE_PROVIDER_AUTHORITY =
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 009fc39..5f424a7 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -7191,13 +7191,6 @@
public static final String QS_TILES = "sysui_qs_tiles";
/**
- * Whether preloaded APKs have been installed for the user.
- * @hide
- */
- public static final String DEMO_USER_SETUP_COMPLETE
- = "demo_user_setup_complete";
-
- /**
* Specifies whether the web action API is enabled.
*
* @hide
@@ -9782,6 +9775,22 @@
public static final String TEXT_CLASSIFIER_CONSTANTS = "text_classifier_constants";
/**
+ * BatteryStats specific settings.
+ * This is encoded as a key=value list, separated by commas. Ex: "foo=1,bar=true"
+ *
+ * The following keys are supported:
+ * <pre>
+ * track_cpu_times_by_proc_state (boolean)
+ * </pre>
+ *
+ * <p>
+ * Type: string
+ * @hide
+ * see also com.android.internal.os.BatteryStatsImpl.Constants
+ */
+ public static final String BATTERY_STATS_CONSTANTS = "battery_stats_constants";
+
+ /**
* Whether or not App Standby feature is enabled. This controls throttling of apps
* based on usage patterns and predictions.
* Type: int (0 for false, 1 for true)
@@ -9791,6 +9800,14 @@
public static final java.lang.String APP_STANDBY_ENABLED = "app_standby_enabled";
/**
+ * Whether or not Network Watchlist feature is enabled.
+ * Type: int (0 for false, 1 for true)
+ * Default: 0
+ * @hide
+ */
+ public static final String NETWORK_WATCHLIST_ENABLED = "network_watchlist_enabled";
+
+ /**
* Get the key that retrieves a bluetooth headset's priority.
* @hide
*/
diff --git a/core/java/android/security/recoverablekeystore/RecoverableKeyStoreLoader.java b/core/java/android/security/recoverablekeystore/RecoverableKeyStoreLoader.java
index 0412326..b5ec795 100644
--- a/core/java/android/security/recoverablekeystore/RecoverableKeyStoreLoader.java
+++ b/core/java/android/security/recoverablekeystore/RecoverableKeyStoreLoader.java
@@ -43,18 +43,61 @@
public static final int NO_ERROR = KeyStore.NO_ERROR;
public static final int SYSTEM_ERROR = KeyStore.SYSTEM_ERROR;
+
+ /**
+ * Failed because the loader has not been initialized with a recovery public key yet.
+ */
public static final int ERROR_UNINITIALIZED_RECOVERY_PUBLIC_KEY = 20;
+
+ /**
+ * Failed because no snapshot is yet pending to be synced for the user.
+ */
public static final int ERROR_NO_SNAPSHOT_PENDING = 21;
+
+ /**
+ * Failed due to an error internal to AndroidKeyStore.
+ */
public static final int ERROR_KEYSTORE_INTERNAL_ERROR = 22;
+
+ /**
+ * Failed because the user does not have a lock screen set.
+ */
public static final int ERROR_INSECURE_USER = 24;
/**
+ * Failed because of an internal database error.
+ */
+ public static final int ERROR_DATABASE_ERROR = 25;
+
+ /**
+ * Failed because the provided certificate was not a valid X509 certificate.
+ */
+ public static final int ERROR_BAD_X509_CERTIFICATE = 26;
+
+ /**
+ * Should never be thrown - some algorithm that all AOSP implementations must support is
+ * not available.
+ */
+ public static final int ERROR_UNEXPECTED_MISSING_ALGORITHM = 27;
+
+ /**
+ * The caller is attempting to perform an operation that is not yet fully supported in the API.
+ */
+ public static final int ERROR_NOT_YET_SUPPORTED = 28;
+
+ /**
+ * Error thrown if decryption failed. This might be because the tag is wrong, the key is wrong,
+ * the data has become corrupted, the data has been tampered with, etc.
+ */
+ public static final int ERROR_DECRYPTION_FAILED = 29;
+
+ /**
* Rate limit is enforced to prevent using too many trusted remote devices, since each device
* can have its own number of user secret guesses allowed.
*
* @hide
*/
- public static final int RATE_LIMIT_EXCEEDED = 21;
+ public static final int ERROR_RATE_LIMIT_EXCEEDED = 30;
/** Key has been successfully synced. */
public static final int RECOVERY_STATUS_SYNCED = 0;
@@ -89,12 +132,13 @@
/**
* Creates new {@link #RecoverableKeyStoreLoaderException} instance from the error code.
*
- * @param errorCode
+ * @param errorCode An error code, as listed at the top of this file.
+ * @param message The associated error message.
* @hide
*/
- public static RecoverableKeyStoreLoaderException fromErrorCode(int errorCode) {
- return new RecoverableKeyStoreLoaderException(
- errorCode, getMessageFromErrorCode(errorCode));
+ public static RecoverableKeyStoreLoaderException fromErrorCode(
+ int errorCode, String message) {
+ return new RecoverableKeyStoreLoaderException(errorCode, message);
}
/**
@@ -106,33 +150,18 @@
*/
static RecoverableKeyStoreLoaderException fromServiceSpecificException(
ServiceSpecificException e) throws RecoverableKeyStoreLoaderException {
- throw RecoverableKeyStoreLoaderException.fromErrorCode(e.errorCode);
+ throw RecoverableKeyStoreLoaderException.fromErrorCode(e.errorCode, e.getMessage());
}
private RecoverableKeyStoreLoaderException(int errorCode, String message) {
super(message);
+ mErrorCode = errorCode;
}
/** Returns errorCode. */
public int getErrorCode() {
return mErrorCode;
}
-
- /** @hide */
- private static String getMessageFromErrorCode(int errorCode) {
- switch (errorCode) {
- case NO_ERROR:
- return "OK";
- case SYSTEM_ERROR:
- return "System error";
- case ERROR_UNINITIALIZED_RECOVERY_PUBLIC_KEY:
- return "Recovery service is not initialized";
- case RATE_LIMIT_EXCEEDED:
- return "Rate limit exceeded";
- default:
- return String.valueOf("Unknown error code " + errorCode);
- }
- }
}
/**
diff --git a/core/java/android/text/DynamicLayout.java b/core/java/android/text/DynamicLayout.java
index 6bca37a..18431ca 100644
--- a/core/java/android/text/DynamicLayout.java
+++ b/core/java/android/text/DynamicLayout.java
@@ -1096,6 +1096,11 @@
public void onSpanChanged(Spannable s, Object o, int start, int end, int nstart, int nend) {
if (o instanceof UpdateLayout) {
+ if (start > end) {
+ // Bug: 67926915 start cannot be determined, fallback to reflow from start
+ // instead of causing an exception
+ start = 0;
+ }
reflow(s, start, end - start, end - start);
reflow(s, nstart, nend - nstart, nend - nstart);
}
diff --git a/core/java/android/util/DataUnit.java b/core/java/android/util/DataUnit.java
new file mode 100644
index 0000000..3cc1bd8
--- /dev/null
+++ b/core/java/android/util/DataUnit.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2007 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.util;
+
+import java.time.temporal.ChronoUnit;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Constants for common byte-related units. Note that both SI and IEC units are
+ * supported, and you'll need to pick the correct one for your use-case.
+ * <p>
+ * This design is mirrored after {@link TimeUnit} and {@link ChronoUnit}.
+ *
+ * @hide
+ */
+public enum DataUnit {
+ KILOBYTES { @Override public long toBytes(long v) { return v * 1_000; } },
+ MEGABYTES { @Override public long toBytes(long v) { return v * 1_000_000; } },
+ GIGABYTES { @Override public long toBytes(long v) { return v * 1_000_000_000; } },
+ KIBIBYTES { @Override public long toBytes(long v) { return v * 1_024; } },
+ MEBIBYTES { @Override public long toBytes(long v) { return v * 1_048_576; } },
+ GIBIBYTES { @Override public long toBytes(long v) { return v * 1_073_741_824; } };
+
+ public long toBytes(long v) {
+ throw new AbstractMethodError();
+ }
+}
diff --git a/core/java/android/util/FeatureFlagUtils.java b/core/java/android/util/FeatureFlagUtils.java
index d31bc1f..1d5392e 100644
--- a/core/java/android/util/FeatureFlagUtils.java
+++ b/core/java/android/util/FeatureFlagUtils.java
@@ -43,7 +43,7 @@
DEFAULT_FLAGS.put("settings_connected_device_v2", "true");
DEFAULT_FLAGS.put("settings_battery_v2", "false");
DEFAULT_FLAGS.put("settings_battery_display_app_list", "false");
- DEFAULT_FLAGS.put("settings_security_settings_v2", "false");
+ DEFAULT_FLAGS.put("settings_security_settings_v2", "true");
}
/**
diff --git a/core/java/android/util/KeyValueListParser.java b/core/java/android/util/KeyValueListParser.java
index 0a00794..7eef63e 100644
--- a/core/java/android/util/KeyValueListParser.java
+++ b/core/java/android/util/KeyValueListParser.java
@@ -17,6 +17,9 @@
import android.text.TextUtils;
+import java.time.Duration;
+import java.time.format.DateTimeParseException;
+
/**
* Parses a list of key=value pairs, separated by some delimiter, and puts the results in
* an internal Map. Values can be then queried by key, or if not found, a default value
@@ -189,4 +192,24 @@
public String keyAt(int index) {
return mValues.keyAt(index);
}
+
+ /**
+ * {@hide}
+ * Parse a duration in millis based on java.time.Duration or just a number (millis)
+ */
+ public long getDurationMillis(String key, long def) {
+ String value = mValues.get(key);
+ if (value != null) {
+ try {
+ if (value.startsWith("P") || value.startsWith("p")) {
+ return Duration.parse(value).toMillis();
+ } else {
+ return Long.parseLong(value);
+ }
+ } catch (NumberFormatException | DateTimeParseException e) {
+ // fallthrough
+ }
+ }
+ return def;
+ }
}
diff --git a/core/java/android/view/WindowManagerPolicyConstants.java b/core/java/android/view/WindowManagerPolicyConstants.java
index 21943bd..9c1c9e3 100644
--- a/core/java/android/view/WindowManagerPolicyConstants.java
+++ b/core/java/android/view/WindowManagerPolicyConstants.java
@@ -18,8 +18,6 @@
import static android.view.Display.DEFAULT_DISPLAY;
-import android.annotation.SystemApi;
-
/**
* Constants for interfacing with WindowManagerService and WindowManagerPolicyInternal.
* @hide
@@ -62,7 +60,6 @@
* Set to {@code true} when intent was invoked from pressing the home key.
* @hide
*/
- @SystemApi
String EXTRA_FROM_HOME_KEY = "android.intent.extra.FROM_HOME_KEY";
// TODO: move this to a more appropriate place.
diff --git a/core/java/android/webkit/FindAddress.java b/core/java/android/webkit/FindAddress.java
new file mode 100644
index 0000000..31b2427
--- /dev/null
+++ b/core/java/android/webkit/FindAddress.java
@@ -0,0 +1,478 @@
+/*
+ * 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.webkit;
+
+import java.util.Locale;
+import java.util.regex.MatchResult;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Java implementation of legacy WebView.findAddress algorithm.
+ *
+ * @hide
+ */
+class FindAddress {
+ static class ZipRange {
+ int mLow;
+ int mHigh;
+ int mException1;
+ int mException2;
+ ZipRange(int low, int high, int exception1, int exception2) {
+ mLow = low;
+ mHigh = high;
+ mException1 = exception1;
+ mException2 = exception1;
+ }
+ boolean matches(String zipCode) {
+ int prefix = Integer.parseInt(zipCode.substring(0, 2));
+ return (mLow <= prefix && prefix <= mHigh) || prefix == mException1
+ || prefix == mException2;
+ }
+ }
+
+ // Addresses consist of at least this many words, not including state and zip code.
+ private static final int MIN_ADDRESS_WORDS = 4;
+
+ // Adddresses consist of at most this many words, not including state and zip code.
+ private static final int MAX_ADDRESS_WORDS = 14;
+
+ // Addresses consist of at most this many lines.
+ private static final int MAX_ADDRESS_LINES = 5;
+
+ // No words in an address are longer than this many characters.
+ private static final int kMaxAddressNameWordLength = 25;
+
+ // Location name should be in the first MAX_LOCATION_NAME_DISTANCE words
+ private static final int MAX_LOCATION_NAME_DISTANCE = 5;
+
+ private static final ZipRange[] sStateZipCodeRanges = {
+ new ZipRange(99, 99, -1, -1), // AK Alaska.
+ new ZipRange(35, 36, -1, -1), // AL Alabama.
+ new ZipRange(71, 72, -1, -1), // AR Arkansas.
+ new ZipRange(96, 96, -1, -1), // AS American Samoa.
+ new ZipRange(85, 86, -1, -1), // AZ Arizona.
+ new ZipRange(90, 96, -1, -1), // CA California.
+ new ZipRange(80, 81, -1, -1), // CO Colorado.
+ new ZipRange(6, 6, -1, -1), // CT Connecticut.
+ new ZipRange(20, 20, -1, -1), // DC District of Columbia.
+ new ZipRange(19, 19, -1, -1), // DE Delaware.
+ new ZipRange(32, 34, -1, -1), // FL Florida.
+ new ZipRange(96, 96, -1, -1), // FM Federated States of Micronesia.
+ new ZipRange(30, 31, -1, -1), // GA Georgia.
+ new ZipRange(96, 96, -1, -1), // GU Guam.
+ new ZipRange(96, 96, -1, -1), // HI Hawaii.
+ new ZipRange(50, 52, -1, -1), // IA Iowa.
+ new ZipRange(83, 83, -1, -1), // ID Idaho.
+ new ZipRange(60, 62, -1, -1), // IL Illinois.
+ new ZipRange(46, 47, -1, -1), // IN Indiana.
+ new ZipRange(66, 67, 73, -1), // KS Kansas.
+ new ZipRange(40, 42, -1, -1), // KY Kentucky.
+ new ZipRange(70, 71, -1, -1), // LA Louisiana.
+ new ZipRange(1, 2, -1, -1), // MA Massachusetts.
+ new ZipRange(20, 21, -1, -1), // MD Maryland.
+ new ZipRange(3, 4, -1, -1), // ME Maine.
+ new ZipRange(96, 96, -1, -1), // MH Marshall Islands.
+ new ZipRange(48, 49, -1, -1), // MI Michigan.
+ new ZipRange(55, 56, -1, -1), // MN Minnesota.
+ new ZipRange(63, 65, -1, -1), // MO Missouri.
+ new ZipRange(96, 96, -1, -1), // MP Northern Mariana Islands.
+ new ZipRange(38, 39, -1, -1), // MS Mississippi.
+ new ZipRange(55, 56, -1, -1), // MT Montana.
+ new ZipRange(27, 28, -1, -1), // NC North Carolina.
+ new ZipRange(58, 58, -1, -1), // ND North Dakota.
+ new ZipRange(68, 69, -1, -1), // NE Nebraska.
+ new ZipRange(3, 4, -1, -1), // NH New Hampshire.
+ new ZipRange(7, 8, -1, -1), // NJ New Jersey.
+ new ZipRange(87, 88, 86, -1), // NM New Mexico.
+ new ZipRange(88, 89, 96, -1), // NV Nevada.
+ new ZipRange(10, 14, 0, 6), // NY New York.
+ new ZipRange(43, 45, -1, -1), // OH Ohio.
+ new ZipRange(73, 74, -1, -1), // OK Oklahoma.
+ new ZipRange(97, 97, -1, -1), // OR Oregon.
+ new ZipRange(15, 19, -1, -1), // PA Pennsylvania.
+ new ZipRange(6, 6, 0, 9), // PR Puerto Rico.
+ new ZipRange(96, 96, -1, -1), // PW Palau.
+ new ZipRange(2, 2, -1, -1), // RI Rhode Island.
+ new ZipRange(29, 29, -1, -1), // SC South Carolina.
+ new ZipRange(57, 57, -1, -1), // SD South Dakota.
+ new ZipRange(37, 38, -1, -1), // TN Tennessee.
+ new ZipRange(75, 79, 87, 88), // TX Texas.
+ new ZipRange(84, 84, -1, -1), // UT Utah.
+ new ZipRange(22, 24, 20, -1), // VA Virginia.
+ new ZipRange(6, 9, -1, -1), // VI Virgin Islands.
+ new ZipRange(5, 5, -1, -1), // VT Vermont.
+ new ZipRange(98, 99, -1, -1), // WA Washington.
+ new ZipRange(53, 54, -1, -1), // WI Wisconsin.
+ new ZipRange(24, 26, -1, -1), // WV West Virginia.
+ new ZipRange(82, 83, -1, -1) // WY Wyoming.
+ };
+
+ // Newlines
+ private static final String NL = "\n\u000B\u000C\r\u0085\u2028\u2029";
+
+ // Space characters
+ private static final String SP = "\u0009\u0020\u00A0\u1680\u2000\u2001"
+ + "\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F"
+ + "\u205F\u3000";
+
+ // Whitespace
+ private static final String WS = SP + NL;
+
+ // Characters that are considered word delimiters.
+ private static final String WORD_DELIM = ",*\u2022" + WS;
+
+ // Lookahead for word end.
+ private static final String WORD_END = "(?=[" + WORD_DELIM + "]|$)";
+
+ // Address words are a sequence of non-delimiter characters.
+ private static final Pattern sWordRe =
+ Pattern.compile("[^" + WORD_DELIM + "]+" + WORD_END, Pattern.CASE_INSENSITIVE);
+
+ // Characters that are considered suffix delimiters for house numbers.
+ private static final String HOUSE_POST_DELIM = ",\"'" + WS;
+
+ // Lookahead for house end.
+ private static final String HOUSE_END = "(?=[" + HOUSE_POST_DELIM + "]|$)";
+
+ // Characters that are considered prefix delimiters for house numbers.
+ private static final String HOUSE_PRE_DELIM = ":" + HOUSE_POST_DELIM;
+
+ // A house number component is "one" or a number, optionally
+ // followed by a single alphabetic character, or
+ private static final String HOUSE_COMPONENT = "(?:one|\\d+([a-z](?=[^a-z]|$)|st|nd|rd|th)?)";
+
+ // House numbers are a repetition of |HOUSE_COMPONENT|, separated by -, and followed by
+ // a delimiter character.
+ private static final Pattern sHouseNumberRe =
+ Pattern.compile(HOUSE_COMPONENT + "(?:-" + HOUSE_COMPONENT + ")*" + HOUSE_END,
+ Pattern.CASE_INSENSITIVE);
+
+ // XXX: do we want to accept whitespace other than 0x20 in state names?
+ private static final Pattern sStateRe = Pattern.compile("(?:"
+ + "(ak|alaska)|"
+ + "(al|alabama)|"
+ + "(ar|arkansas)|"
+ + "(as|american[" + SP + "]+samoa)|"
+ + "(az|arizona)|"
+ + "(ca|california)|"
+ + "(co|colorado)|"
+ + "(ct|connecticut)|"
+ + "(dc|district[" + SP + "]+of[" + SP + "]+columbia)|"
+ + "(de|delaware)|"
+ + "(fl|florida)|"
+ + "(fm|federated[" + SP + "]+states[" + SP + "]+of[" + SP + "]+micronesia)|"
+ + "(ga|georgia)|"
+ + "(gu|guam)|"
+ + "(hi|hawaii)|"
+ + "(ia|iowa)|"
+ + "(id|idaho)|"
+ + "(il|illinois)|"
+ + "(in|indiana)|"
+ + "(ks|kansas)|"
+ + "(ky|kentucky)|"
+ + "(la|louisiana)|"
+ + "(ma|massachusetts)|"
+ + "(md|maryland)|"
+ + "(me|maine)|"
+ + "(mh|marshall[" + SP + "]+islands)|"
+ + "(mi|michigan)|"
+ + "(mn|minnesota)|"
+ + "(mo|missouri)|"
+ + "(mp|northern[" + SP + "]+mariana[" + SP + "]+islands)|"
+ + "(ms|mississippi)|"
+ + "(mt|montana)|"
+ + "(nc|north[" + SP + "]+carolina)|"
+ + "(nd|north[" + SP + "]+dakota)|"
+ + "(ne|nebraska)|"
+ + "(nh|new[" + SP + "]+hampshire)|"
+ + "(nj|new[" + SP + "]+jersey)|"
+ + "(nm|new[" + SP + "]+mexico)|"
+ + "(nv|nevada)|"
+ + "(ny|new[" + SP + "]+york)|"
+ + "(oh|ohio)|"
+ + "(ok|oklahoma)|"
+ + "(or|oregon)|"
+ + "(pa|pennsylvania)|"
+ + "(pr|puerto[" + SP + "]+rico)|"
+ + "(pw|palau)|"
+ + "(ri|rhode[" + SP + "]+island)|"
+ + "(sc|south[" + SP + "]+carolina)|"
+ + "(sd|south[" + SP + "]+dakota)|"
+ + "(tn|tennessee)|"
+ + "(tx|texas)|"
+ + "(ut|utah)|"
+ + "(va|virginia)|"
+ + "(vi|virgin[" + SP + "]+islands)|"
+ + "(vt|vermont)|"
+ + "(wa|washington)|"
+ + "(wi|wisconsin)|"
+ + "(wv|west[" + SP + "]+virginia)|"
+ + "(wy|wyoming)"
+ + ")" + WORD_END,
+ Pattern.CASE_INSENSITIVE);
+
+ private static final Pattern sLocationNameRe = Pattern.compile("(?:"
+ + "alley|annex|arcade|ave[.]?|avenue|alameda|bayou|"
+ + "beach|bend|bluffs?|bottom|boulevard|branch|bridge|"
+ + "brooks?|burgs?|bypass|broadway|camino|camp|canyon|"
+ + "cape|causeway|centers?|circles?|cliffs?|club|common|"
+ + "corners?|course|courts?|coves?|creek|crescent|crest|"
+ + "crossing|crossroad|curve|circulo|dale|dam|divide|"
+ + "drives?|estates?|expressway|extensions?|falls?|ferry|"
+ + "fields?|flats?|fords?|forest|forges?|forks?|fort|"
+ + "freeway|gardens?|gateway|glens?|greens?|groves?|"
+ + "harbors?|haven|heights|highway|hills?|hollow|inlet|"
+ + "islands?|isle|junctions?|keys?|knolls?|lakes?|land|"
+ + "landing|lane|lights?|loaf|locks?|lodge|loop|mall|"
+ + "manors?|meadows?|mews|mills?|mission|motorway|mount|"
+ + "mountains?|neck|orchard|oval|overpass|parks?|"
+ + "parkways?|pass|passage|path|pike|pines?|plains?|"
+ + "plaza|points?|ports?|prairie|privada|radial|ramp|"
+ + "ranch|rapids?|rd[.]?|rest|ridges?|river|roads?|route|"
+ + "row|rue|run|shoals?|shores?|skyway|springs?|spurs?|"
+ + "squares?|station|stravenue|stream|st[.]?|streets?|"
+ + "summit|speedway|terrace|throughway|trace|track|"
+ + "trafficway|trail|tunnel|turnpike|underpass|unions?|"
+ + "valleys?|viaduct|views?|villages?|ville|vista|walks?|"
+ + "wall|ways?|wells?|xing|xrd)" + WORD_END,
+ Pattern.CASE_INSENSITIVE);
+
+ private static final Pattern sSuffixedNumberRe =
+ Pattern.compile("(\\d+)(st|nd|rd|th)", Pattern.CASE_INSENSITIVE);
+
+ private static final Pattern sZipCodeRe =
+ Pattern.compile("(?:\\d{5}(?:-\\d{4})?)" + WORD_END, Pattern.CASE_INSENSITIVE);
+
+ private static boolean checkHouseNumber(String houseNumber) {
+ // Make sure that there are at most 5 digits.
+ int digitCount = 0;
+ for (int i = 0; i < houseNumber.length(); ++i) {
+ if (Character.isDigit(houseNumber.charAt(i))) ++digitCount;
+ }
+ if (digitCount > 5) return false;
+
+ // Make sure that any ordinals are valid.
+ Matcher suffixMatcher = sSuffixedNumberRe.matcher(houseNumber);
+ while (suffixMatcher.find()) {
+ int num = Integer.parseInt(suffixMatcher.group(1));
+ if (num == 0) {
+ return false; // 0th is invalid.
+ }
+ String suffix = suffixMatcher.group(2).toLowerCase(Locale.getDefault());
+ switch (num % 10) {
+ case 1:
+ return suffix.equals(num % 100 == 11 ? "th" : "st");
+ case 2:
+ return suffix.equals(num % 100 == 12 ? "th" : "nd");
+ case 3:
+ return suffix.equals(num % 100 == 13 ? "th" : "rd");
+ default:
+ return suffix.equals("th");
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Attempt to match a house number beginnning at position offset
+ * in content. The house number must be followed by a word
+ * delimiter or the end of the string, and if offset is non-zero,
+ * then it must also be preceded by a word delimiter.
+ *
+ * @return a MatchResult if a valid house number was found.
+ */
+ private static MatchResult matchHouseNumber(String content, int offset) {
+ if (offset > 0 && HOUSE_PRE_DELIM.indexOf(content.charAt(offset - 1)) == -1) return null;
+ Matcher matcher = sHouseNumberRe.matcher(content).region(offset, content.length());
+ if (matcher.lookingAt()) {
+ MatchResult matchResult = matcher.toMatchResult();
+ if (checkHouseNumber(matchResult.group(0))) return matchResult;
+ }
+ return null;
+ }
+
+ /**
+ * Attempt to match a US state beginnning at position offset in
+ * content. The matching state must be followed by a word
+ * delimiter or the end of the string, and if offset is non-zero,
+ * then it must also be preceded by a word delimiter.
+ *
+ * @return a MatchResult if a valid US state (or two letter code)
+ * was found.
+ */
+ private static MatchResult matchState(String content, int offset) {
+ if (offset > 0 && WORD_DELIM.indexOf(content.charAt(offset - 1)) == -1) return null;
+ Matcher stateMatcher = sStateRe.matcher(content).region(offset, content.length());
+ return stateMatcher.lookingAt() ? stateMatcher.toMatchResult() : null;
+ }
+
+ /**
+ * Test whether zipCode matches the U.S. zip code format (ddddd or
+ * ddddd-dddd) and is within the expected range, given that
+ * stateMatch is a match of sStateRe.
+ *
+ * @return true if zipCode is a valid zip code, is legal for the
+ * matched state, and is followed by a word delimiter or the end
+ * of the string.
+ */
+ private static boolean isValidZipCode(String zipCode, MatchResult stateMatch) {
+ if (stateMatch == null) return false;
+ // Work out the index of the state, based on which group matched.
+ int stateIndex = stateMatch.groupCount();
+ while (stateIndex > 0) {
+ if (stateMatch.group(stateIndex--) != null) break;
+ }
+ return sZipCodeRe.matcher(zipCode).matches()
+ && sStateZipCodeRanges[stateIndex].matches(zipCode);
+ }
+
+ /**
+ * Test whether location is one of the valid locations.
+ *
+ * @return true if location starts with a valid location name
+ * followed by a word delimiter or the end of the string.
+ */
+ private static boolean isValidLocationName(String location) {
+ return sLocationNameRe.matcher(location).matches();
+ }
+
+ /**
+ * Attempt to match a complete address in content, starting with
+ * houseNumberMatch.
+ *
+ * @param content The string to search.
+ * @param houseNumberMatch A matching house number to start extending.
+ * @return +ve: the end of the match
+ * +ve: the position to restart searching for house numbers, negated.
+ */
+ private static int attemptMatch(String content, MatchResult houseNumberMatch) {
+ int restartPos = -1;
+ int nonZipMatch = -1;
+ int it = houseNumberMatch.end();
+ int numLines = 1;
+ boolean consecutiveHouseNumbers = true;
+ boolean foundLocationName = false;
+ int wordCount = 1;
+ String lastWord = "";
+
+ Matcher matcher = sWordRe.matcher(content);
+
+ for (; it < content.length(); lastWord = matcher.group(0), it = matcher.end()) {
+ if (!matcher.find(it)) {
+ // No more words in the input sequence.
+ return -content.length();
+ }
+ if (matcher.end() - matcher.start() > kMaxAddressNameWordLength) {
+ // Word is too long to be part of an address. Fail.
+ return -matcher.end();
+ }
+
+ // Count the number of newlines we just consumed.
+ while (it < matcher.start()) {
+ if (NL.indexOf(content.charAt(it++)) != -1) ++numLines;
+ }
+
+ // Consumed too many lines. Fail.
+ if (numLines > MAX_ADDRESS_LINES) break;
+
+ // Consumed too many words. Fail.
+ if (++wordCount > MAX_ADDRESS_WORDS) break;
+
+ if (matchHouseNumber(content, it) != null) {
+ if (consecutiveHouseNumbers && numLines > 1) {
+ // Last line ended with a number, and this this line starts with one.
+ // Restart at this number.
+ return -it;
+ }
+ // Remember the position of this match as the restart position.
+ if (restartPos == -1) restartPos = it;
+ continue;
+ }
+
+ consecutiveHouseNumbers = false;
+
+ if (isValidLocationName(matcher.group(0))) {
+ foundLocationName = true;
+ continue;
+ }
+
+ if (wordCount == MAX_LOCATION_NAME_DISTANCE && !foundLocationName) {
+ // Didn't find a location name in time. Fail.
+ it = matcher.end();
+ break;
+ }
+
+ if (foundLocationName && wordCount > MIN_ADDRESS_WORDS) {
+ // We can now attempt to match a state.
+ MatchResult stateMatch = matchState(content, it);
+ if (stateMatch != null) {
+ if (lastWord.equals("et") && stateMatch.group(0).equals("al")) {
+ // Reject "et al" as a false postitive.
+ it = stateMatch.end();
+ break;
+ }
+
+ // At this point we've matched a state; try to match a zip code after it.
+ Matcher zipMatcher = sWordRe.matcher(content);
+ if (zipMatcher.find(stateMatch.end())
+ && isValidZipCode(zipMatcher.group(0), stateMatch)) {
+ return zipMatcher.end();
+ }
+ // The content ends with a state but no zip
+ // code. This is a legal match according to the
+ // documentation. N.B. This differs from the
+ // original c++ implementation, which only allowed
+ // the zip code to be optional at the end of the
+ // string, which presumably is a bug. Now we
+ // prefer to find a match with a zip code, but
+ // remember non-zip matches and return them if
+ // necessary.
+ nonZipMatch = stateMatch.end();
+ }
+ }
+ }
+
+ if (nonZipMatch > 0) return nonZipMatch;
+
+ return -(restartPos > 0 ? restartPos : it);
+ }
+
+ /**
+ * Return the first matching address in content.
+ *
+ * @param content The string to search.
+ * @return The first valid address, or null if no address was matched.
+ */
+ static String findAddress(String content) {
+ Matcher houseNumberMatcher = sHouseNumberRe.matcher(content);
+ int start = 0;
+ while (houseNumberMatcher.find(start)) {
+ if (checkHouseNumber(houseNumberMatcher.group(0))) {
+ start = houseNumberMatcher.start();
+ int end = attemptMatch(content, houseNumberMatcher);
+ if (end > 0) {
+ return content.substring(start, end);
+ }
+ start = -end;
+ } else {
+ start = houseNumberMatcher.end();
+ }
+ }
+ return null;
+ }
+}
diff --git a/core/java/android/webkit/WebView.java b/core/java/android/webkit/WebView.java
index de5a822..deb94e81 100644
--- a/core/java/android/webkit/WebView.java
+++ b/core/java/android/webkit/WebView.java
@@ -129,8 +129,10 @@
* String summary = "<html><body>You scored <b>192</b> points.</body></html>";
* webview.loadData(summary, "text/html", null);
* // ... although note that there are restrictions on what this HTML can do.
- * // See the JavaDocs for {@link #loadData(String,String,String) loadData()} and {@link
- * #loadDataWithBaseURL(String,String,String,String,String) loadDataWithBaseURL()} for more info.
+ * // See {@link #loadData(String,String,String)} and {@link
+ * #loadDataWithBaseURL(String,String,String,String,String)} for more info.
+ * // Also see {@link #loadData(String,String,String)} for information on encoding special
+ * // characters.
* </pre>
*
* <p>A WebView has several customization points where you can add your
@@ -989,13 +991,21 @@
* #loadDataWithBaseURL(String,String,String,String,String)
* loadDataWithBaseURL()} with an appropriate base URL.
* <p>
- * The encoding parameter specifies whether the data is base64 or URL
+ * The {@code encoding} parameter specifies whether the data is base64 or URL
* encoded. If the data is base64 encoded, the value of the encoding
- * parameter must be 'base64'. For all other values of the parameter,
- * including {@code null}, it is assumed that the data uses ASCII encoding for
- * octets inside the range of safe URL characters and use the standard %xx
- * hex encoding of URLs for octets outside that range. For example, '#',
- * '%', '\', '?' should be replaced by %23, %25, %27, %3f respectively.
+ * parameter must be 'base64'. HTML can be encoded with {@link
+ * android.util.Base64#encodeToString(byte[],int)} like so:
+ * <pre>
+ * String unencodedHtml =
+ * "<html><body>'%28' is the code for '('</body></html>";
+ * String encodedHtml = Base64.encodeToString(unencodedHtml.getBytes(), Base64.NO_PADDING);
+ * webView.loadData(encodedHtml, "text/html", "base64");
+ * </pre>
+ * <p>
+ * For all other values of {@code encoding} (including {@code null}) it is assumed that the
+ * data uses ASCII encoding for octets inside the range of safe URL characters and use the
+ * standard %xx hex encoding of URLs for octets outside that range. See <a
+ * href="https://tools.ietf.org/html/rfc3986#section-2.2">RFC 3986</a> for more information.
* <p>
* The {@code mimeType} parameter specifies the format of the data.
* If WebView can't handle the specified MIME type, it will download the data.
@@ -1821,9 +1831,10 @@
*/
@Nullable
public static String findAddress(String addr) {
- // TODO: Rewrite this in Java so it is not needed to start up chromium
- // Could also be deprecated
- return getFactory().getStatics().findAddress(addr);
+ if (addr == null) {
+ throw new NullPointerException("addr is null");
+ }
+ return FindAddress.findAddress(addr);
}
/**
diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java
index 1618d62..ff374fa 100644
--- a/core/java/android/widget/TextView.java
+++ b/core/java/android/widget/TextView.java
@@ -296,6 +296,7 @@
* @attr ref android.R.styleable#TextView_imeActionId
* @attr ref android.R.styleable#TextView_editorExtras
* @attr ref android.R.styleable#TextView_elegantTextHeight
+ * @attr ref android.R.styleable#TextView_fallbackLineSpacing
* @attr ref android.R.styleable#TextView_letterSpacing
* @attr ref android.R.styleable#TextView_fontFeatureSettings
* @attr ref android.R.styleable#TextView_breakStrategy
@@ -310,7 +311,6 @@
public class TextView extends View implements ViewTreeObserver.OnPreDrawListener {
static final String LOG_TAG = "TextView";
static final boolean DEBUG_EXTRACT = false;
- static final boolean DEBUG_AUTOFILL = false;
private static final float[] TEMP_POSITION = new float[2];
// Enum for the "typeface" XML parameter.
@@ -655,7 +655,7 @@
// True if internationalized input should be used for numbers and date and time.
private final boolean mUseInternationalizedInput;
// True if fallback fonts that end up getting used should be allowed to affect line spacing.
- /* package */ final boolean mUseFallbackLineSpacing;
+ /* package */ boolean mUseFallbackLineSpacing;
@ViewDebug.ExportedProperty(category = "text")
private int mGravity = Gravity.TOP | Gravity.START;
@@ -788,7 +788,7 @@
// Indicates whether the text was set statically or dynamically, so it can be used to
// sanitize autofill requests.
- private boolean mSetFromXmlOrResourceId = false;
+ private boolean mTextSetFromXmlOrResourceId = false;
// Resource id used to set the text - used for autofill purposes.
private @StringRes int mTextId = ResourceId.ID_NULL;
@@ -930,7 +930,7 @@
int n = a.getIndexCount();
// Must set id in a temporary variable because it will be reset by setText()
- boolean setFromXml = false;
+ boolean textIsSetFromXml = false;
for (int i = 0; i < n; i++) {
int attr = a.getIndex(i);
@@ -1072,7 +1072,7 @@
break;
case com.android.internal.R.styleable.TextView_text:
- setFromXml = true;
+ textIsSetFromXml = true;
mTextId = a.getResourceId(attr, ResourceId.ID_NULL);
text = a.getText(attr);
break;
@@ -1465,8 +1465,8 @@
}
setText(text, bufferType);
- if (setFromXml) {
- mSetFromXmlOrResourceId = true;
+ if (textIsSetFromXml) {
+ mTextSetFromXmlOrResourceId = true;
}
if (hint != null) setHint(hint);
@@ -3255,6 +3255,8 @@
float mShadowDx = 0, mShadowDy = 0, mShadowRadius = 0;
boolean mHasElegant = false;
boolean mElegant = false;
+ boolean mHasFallbackLineSpacing = false;
+ boolean mFallbackLineSpacing = false;
boolean mHasLetterSpacing = false;
float mLetterSpacing = 0;
String mFontFeatureSettings = null;
@@ -3279,6 +3281,8 @@
+ " mShadowRadius:" + mShadowRadius + "\n"
+ " mHasElegant:" + mHasElegant + "\n"
+ " mElegant:" + mElegant + "\n"
+ + " mHasFallbackLineSpacing:" + mHasFallbackLineSpacing + "\n"
+ + " mFallbackLineSpacing:" + mFallbackLineSpacing + "\n"
+ " mHasLetterSpacing:" + mHasLetterSpacing + "\n"
+ " mLetterSpacing:" + mLetterSpacing + "\n"
+ " mFontFeatureSettings:" + mFontFeatureSettings + "\n"
@@ -3317,6 +3321,8 @@
com.android.internal.R.styleable.TextAppearance_shadowRadius);
sAppearanceValues.put(com.android.internal.R.styleable.TextView_elegantTextHeight,
com.android.internal.R.styleable.TextAppearance_elegantTextHeight);
+ sAppearanceValues.put(com.android.internal.R.styleable.TextView_fallbackLineSpacing,
+ com.android.internal.R.styleable.TextAppearance_fallbackLineSpacing);
sAppearanceValues.put(com.android.internal.R.styleable.TextView_letterSpacing,
com.android.internal.R.styleable.TextAppearance_letterSpacing);
sAppearanceValues.put(com.android.internal.R.styleable.TextView_fontFeatureSettings,
@@ -3407,6 +3413,11 @@
attributes.mHasElegant = true;
attributes.mElegant = appearance.getBoolean(attr, attributes.mElegant);
break;
+ case com.android.internal.R.styleable.TextAppearance_fallbackLineSpacing:
+ attributes.mHasFallbackLineSpacing = true;
+ attributes.mFallbackLineSpacing = appearance.getBoolean(attr,
+ attributes.mFallbackLineSpacing);
+ break;
case com.android.internal.R.styleable.TextAppearance_letterSpacing:
attributes.mHasLetterSpacing = true;
attributes.mLetterSpacing =
@@ -3460,6 +3471,10 @@
setElegantTextHeight(attributes.mElegant);
}
+ if (attributes.mHasFallbackLineSpacing) {
+ setFallbackLineSpacing(attributes.mFallbackLineSpacing);
+ }
+
if (attributes.mHasLetterSpacing) {
setLetterSpacing(attributes.mLetterSpacing);
}
@@ -3741,7 +3756,7 @@
*
* @param elegant set the paint's elegant metrics flag.
*
- * @see Paint#isElegantTextHeight(boolean)
+ * @see Paint#isElegantTextHeight()
*
* @attr ref android.R.styleable#TextView_elegantTextHeight
*/
@@ -3757,6 +3772,43 @@
}
/**
+ * Set whether to respect the ascent and descent of the fallback fonts that are used in
+ * displaying the text (which is needed to avoid text from consecutive lines running into
+ * each other). If set, fallback fonts that end up getting used can increase the ascent
+ * and descent of the lines that they are used on.
+ * <p/>
+ * It is required to be true if text could be in languages like Burmese or Tibetan where text
+ * is typically much taller or deeper than Latin text.
+ *
+ * @param enabled whether to expand linespacing based on fallback fonts, {@code true} by default
+ *
+ * @see StaticLayout.Builder#setUseLineSpacingFromFallbacks(boolean)
+ *
+ * @attr ref android.R.styleable#TextView_fallbackLineSpacing
+ */
+ public void setFallbackLineSpacing(boolean enabled) {
+ if (mUseFallbackLineSpacing != enabled) {
+ mUseFallbackLineSpacing = enabled;
+ if (mLayout != null) {
+ nullLayouts();
+ requestLayout();
+ invalidate();
+ }
+ }
+ }
+
+ /**
+ * @return whether fallback line spacing is enabled, {@code true} by default
+ *
+ * @see #setFallbackLineSpacing(boolean)
+ *
+ * @attr ref android.R.styleable#TextView_fallbackLineSpacing
+ */
+ public boolean isFallbackLineSpacing() {
+ return mUseFallbackLineSpacing;
+ }
+
+ /**
* Get the value of the TextView's elegant height metrics flag. This setting selects font
* variants that have not been compacted to fit Latin-based vertical
* metrics, and also increases top and bottom bounds to provide more space.
@@ -5283,7 +5335,7 @@
private void setText(CharSequence text, BufferType type,
boolean notifyBefore, int oldlen) {
- mSetFromXmlOrResourceId = false;
+ mTextSetFromXmlOrResourceId = false;
if (text == null) {
text = "";
}
@@ -5521,7 +5573,7 @@
@android.view.RemotableViewMethod
public final void setText(@StringRes int resid) {
setText(getContext().getResources().getText(resid));
- mSetFromXmlOrResourceId = true;
+ mTextSetFromXmlOrResourceId = true;
mTextId = resid;
}
@@ -5549,7 +5601,7 @@
*/
public final void setText(@StringRes int resid, BufferType type) {
setText(getContext().getResources().getText(resid), type);
- mSetFromXmlOrResourceId = true;
+ mTextSetFromXmlOrResourceId = true;
mTextId = resid;
}
@@ -9463,7 +9515,7 @@
}
final AutofillManager afm = mContext.getSystemService(AutofillManager.class);
if (afm != null) {
- if (DEBUG_AUTOFILL) {
+ if (android.view.autofill.Helper.sVerbose) {
Log.v(LOG_TAG, "sendAfterTextChanged(): notify AFM for text=" + mText);
}
afm.notifyValueChanged(TextView.this);
@@ -10241,9 +10293,16 @@
final boolean isPassword = hasPasswordTransformationMethod()
|| isPasswordInputType(getInputType());
if (forAutofill) {
- structure.setDataIsSensitive(!mSetFromXmlOrResourceId);
+ structure.setDataIsSensitive(!mTextSetFromXmlOrResourceId);
if (mTextId != ResourceId.ID_NULL) {
- structure.setTextIdEntry(getResources().getResourceEntryName(mTextId));
+ try {
+ structure.setTextIdEntry(getResources().getResourceEntryName(mTextId));
+ } catch (Resources.NotFoundException e) {
+ if (android.view.autofill.Helper.sVerbose) {
+ Log.v(LOG_TAG, "onProvideAutofillStructure(): cannot set name for text id "
+ + mTextId + ": " + e.getMessage());
+ }
+ }
}
}
diff --git a/core/java/com/android/internal/app/IBatteryStats.aidl b/core/java/com/android/internal/app/IBatteryStats.aidl
index ab118ba..5d4bccc 100644
--- a/core/java/com/android/internal/app/IBatteryStats.aidl
+++ b/core/java/com/android/internal/app/IBatteryStats.aidl
@@ -81,7 +81,11 @@
void noteStopWakelockFromSource(in WorkSource ws, int pid, String name, String historyName,
int type);
void noteLongPartialWakelockStart(String name, String historyName, int uid);
+ void noteLongPartialWakelockStartFromSource(String name, String historyName,
+ in WorkSource workSource);
void noteLongPartialWakelockFinish(String name, String historyName, int uid);
+ void noteLongPartialWakelockFinishFromSource(String name, String historyName,
+ in WorkSource workSource);
void noteVibratorOn(int uid, long durationMillis);
void noteVibratorOff(int uid);
diff --git a/core/java/com/android/internal/app/procstats/ProcessState.java b/core/java/com/android/internal/app/procstats/ProcessState.java
index efc9c02..79f4c1b 100644
--- a/core/java/com/android/internal/app/procstats/ProcessState.java
+++ b/core/java/com/android/internal/app/procstats/ProcessState.java
@@ -153,7 +153,6 @@
private int mNumActiveServices;
private int mNumStartedServices;
- private int mNumExcessiveWake;
private int mNumExcessiveCpu;
private int mNumCachedKill;
@@ -470,9 +469,23 @@
}
}
- public void addPss(long pss, long uss, boolean always,
+ public void addPss(long pss, long uss, boolean always, int type, long duration,
ArrayMap<String, ProcessStateHolder> pkgList) {
ensureNotDead();
+ switch (type) {
+ case ProcessStats.ADD_PSS_INTERNAL:
+ mStats.mInternalPssCount++;
+ mStats.mInternalPssTime += duration;
+ break;
+ case ProcessStats.ADD_PSS_EXTERNAL:
+ mStats.mExternalPssCount++;
+ mStats.mExternalPssTime += duration;
+ break;
+ case ProcessStats.ADD_PSS_EXTERNAL_SLOW:
+ mStats.mExternalSlowPssCount++;
+ mStats.mExternalSlowPssTime += duration;
+ break;
+ }
if (!always) {
if (mLastPssState == mCurState && SystemClock.uptimeMillis()
< (mLastPssTime+(30*1000))) {
diff --git a/core/java/com/android/internal/app/procstats/ProcessStats.java b/core/java/com/android/internal/app/procstats/ProcessStats.java
index 96ba2b0..35b2dd2 100644
--- a/core/java/com/android/internal/app/procstats/ProcessStats.java
+++ b/core/java/com/android/internal/app/procstats/ProcessStats.java
@@ -134,6 +134,10 @@
public static final int FLAG_SHUTDOWN = 1<<1;
public static final int FLAG_SYSPROPS = 1<<2;
+ public static final int ADD_PSS_INTERNAL = 0;
+ public static final int ADD_PSS_EXTERNAL = 1;
+ public static final int ADD_PSS_EXTERNAL_SLOW = 2;
+
public static final int[] ALL_MEM_ADJ = new int[] { ADJ_MEM_FACTOR_NORMAL,
ADJ_MEM_FACTOR_MODERATE, ADJ_MEM_FACTOR_LOW, ADJ_MEM_FACTOR_CRITICAL };
@@ -158,7 +162,7 @@
};
// Current version of the parcel format.
- private static final int PARCEL_VERSION = 23;
+ private static final int PARCEL_VERSION = 24;
// In-memory Parcel magic number, used to detect attempts to unmarshall bad data
private static final int MAGIC = 0x50535454;
@@ -183,6 +187,18 @@
boolean mHasSwappedOutPss;
+ // Count and total time expended doing "quick" pss computations for internal use.
+ public long mInternalPssCount;
+ public long mInternalPssTime;
+
+ // Count and total time expended doing "quick" pss computations due to external requests.
+ public long mExternalPssCount;
+ public long mExternalPssTime;
+
+ // Count and total time expended doing full/slow pss computations due to external requests.
+ public long mExternalSlowPssCount;
+ public long mExternalSlowPssTime;
+
public final SparseMappingTable mTableData = new SparseMappingTable();
public final long[] mSysMemUsageArgs = new long[SYS_MEM_USAGE_COUNT];
@@ -302,6 +318,13 @@
mTimePeriodEndRealtime += other.mTimePeriodEndRealtime - other.mTimePeriodStartRealtime;
mTimePeriodEndUptime += other.mTimePeriodEndUptime - other.mTimePeriodStartUptime;
+ mInternalPssCount += other.mInternalPssCount;
+ mInternalPssTime += other.mInternalPssTime;
+ mExternalPssCount += other.mExternalPssCount;
+ mExternalPssTime += other.mExternalPssTime;
+ mExternalSlowPssCount += other.mExternalSlowPssCount;
+ mExternalSlowPssTime += other.mExternalSlowPssTime;
+
mHasSwappedOutPss |= other.mHasSwappedOutPss;
}
@@ -500,6 +523,12 @@
buildTimePeriodStartClockStr();
mTimePeriodStartRealtime = mTimePeriodEndRealtime = SystemClock.elapsedRealtime();
mTimePeriodStartUptime = mTimePeriodEndUptime = SystemClock.uptimeMillis();
+ mInternalPssCount = 0;
+ mInternalPssTime = 0;
+ mExternalPssCount = 0;
+ mExternalPssTime = 0;
+ mExternalSlowPssCount = 0;
+ mExternalSlowPssTime = 0;
mTableData.reset();
Arrays.fill(mMemFactorDurations, 0);
mSysMemUsage.resetTable();
@@ -760,6 +789,12 @@
out.writeLong(mTimePeriodEndRealtime);
out.writeLong(mTimePeriodStartUptime);
out.writeLong(mTimePeriodEndUptime);
+ out.writeLong(mInternalPssCount);
+ out.writeLong(mInternalPssTime);
+ out.writeLong(mExternalPssCount);
+ out.writeLong(mExternalPssTime);
+ out.writeLong(mExternalSlowPssCount);
+ out.writeLong(mExternalSlowPssTime);
out.writeString(mRuntime);
out.writeInt(mHasSwappedOutPss ? 1 : 0);
out.writeInt(mFlags);
@@ -928,6 +963,12 @@
mTimePeriodEndRealtime = in.readLong();
mTimePeriodStartUptime = in.readLong();
mTimePeriodEndUptime = in.readLong();
+ mInternalPssCount = in.readLong();
+ mInternalPssTime = in.readLong();
+ mExternalPssCount = in.readLong();
+ mExternalPssTime = in.readLong();
+ mExternalSlowPssCount = in.readLong();
+ mExternalSlowPssTime = in.readLong();
mRuntime = in.readString();
mHasSwappedOutPss = in.readInt() != 0;
mFlags = in.readInt();
@@ -1484,9 +1525,31 @@
totalMem.processStateWeight[STATE_SERVICE_RESTARTING], totalMem.totalTime, totalPss,
totalMem.processStateSamples[STATE_SERVICE_RESTARTING]);
pw.println();
+ pw.println("PSS collection stats:");
+ pw.print(" Internal: ");
+ pw.print(mInternalPssCount);
+ pw.print("x over ");
+ TimeUtils.formatDuration(mInternalPssTime, pw);
+ pw.println();
+ pw.print(" External: ");
+ pw.print(mExternalPssCount);
+ pw.print("x over ");
+ TimeUtils.formatDuration(mExternalPssTime, pw);
+ pw.println();
+ pw.print(" External Slow: ");
+ pw.print(mExternalSlowPssCount);
+ pw.print("x over ");
+ TimeUtils.formatDuration(mExternalSlowPssTime, pw);
+ pw.println();
+ pw.println();
pw.print(" Start time: ");
pw.print(DateFormat.format("yyyy-MM-dd HH:mm:ss", mTimePeriodStartClock));
pw.println();
+ pw.print(" Total uptime: ");
+ TimeUtils.formatDuration(
+ (mRunning ? SystemClock.uptimeMillis() : mTimePeriodEndUptime)
+ - mTimePeriodStartUptime, pw);
+ pw.println();
pw.print(" Total elapsed time: ");
TimeUtils.formatDuration(
(mRunning ? SystemClock.elapsedRealtime() : mTimePeriodEndRealtime)
diff --git a/core/java/com/android/internal/colorextraction/types/Tonal.java b/core/java/com/android/internal/colorextraction/types/Tonal.java
index 71baaf1..9b7383f 100644
--- a/core/java/com/android/internal/colorextraction/types/Tonal.java
+++ b/core/java/com/android/internal/colorextraction/types/Tonal.java
@@ -53,10 +53,8 @@
public static final int THRESHOLD_COLOR_LIGHT = 0xffe0e0e0;
public static final int MAIN_COLOR_LIGHT = 0xffe0e0e0;
- public static final int SECONDARY_COLOR_LIGHT = 0xff9e9e9e;
public static final int THRESHOLD_COLOR_DARK = 0xff212121;
public static final int MAIN_COLOR_DARK = 0xff000000;
- public static final int SECONDARY_COLOR_DARK = 0xff000000;
private final TonalPalette mGreyPalette;
private final ArrayList<TonalPalette> mTonalPalettes;
@@ -211,10 +209,8 @@
}
// Normal colors:
- // best fit + a 2 colors offset
outColorsNormal.setMainColor(mainColor);
- int secondaryIndex = primaryIndex + (primaryIndex >= 2 ? -2 : 2);
- outColorsNormal.setSecondaryColor(getColorInt(secondaryIndex, h, s, l));
+ outColorsNormal.setSecondaryColor(mainColor);
// Dark colors:
// Stops at 4th color, only lighter if dark text is supported
@@ -225,9 +221,9 @@
} else {
primaryIndex = Math.min(fitIndex, 3);
}
- secondaryIndex = primaryIndex + (primaryIndex >= 2 ? -2 : 2);
- outColorsDark.setMainColor(getColorInt(primaryIndex, h, s, l));
- outColorsDark.setSecondaryColor(getColorInt(secondaryIndex, h, s, l));
+ mainColor = getColorInt(primaryIndex, h, s, l);
+ outColorsDark.setMainColor(mainColor);
+ outColorsDark.setSecondaryColor(mainColor);
// Extra Dark:
// Stay close to dark colors until dark text is supported
@@ -238,9 +234,9 @@
} else {
primaryIndex = 2;
}
- secondaryIndex = primaryIndex + (primaryIndex >= 2 ? -2 : 2);
- outColorsExtraDark.setMainColor(getColorInt(primaryIndex, h, s, l));
- outColorsExtraDark.setSecondaryColor(getColorInt(secondaryIndex, h, s, l));
+ mainColor = getColorInt(primaryIndex, h, s, l);
+ outColorsExtraDark.setMainColor(mainColor);
+ outColorsExtraDark.setSecondaryColor(mainColor);
outColorsNormal.setSupportsDarkText(supportsDarkText);
outColorsDark.setSupportsDarkText(supportsDarkText);
@@ -273,11 +269,10 @@
boolean light = inWallpaperColors != null
&& (inWallpaperColors.getColorHints() & WallpaperColors.HINT_SUPPORTS_DARK_TEXT)
!= 0;
- int innerColor = light ? MAIN_COLOR_LIGHT : MAIN_COLOR_DARK;
- int outerColor = light ? SECONDARY_COLOR_LIGHT : SECONDARY_COLOR_DARK;
+ final int color = light ? MAIN_COLOR_LIGHT : MAIN_COLOR_DARK;
- outGradientColors.setMainColor(innerColor);
- outGradientColors.setSecondaryColor(outerColor);
+ outGradientColors.setMainColor(color);
+ outGradientColors.setSecondaryColor(color);
outGradientColors.setSupportsDarkText(light);
}
diff --git a/core/java/com/android/internal/os/BatteryStatsImpl.java b/core/java/com/android/internal/os/BatteryStatsImpl.java
index db8fcf6..b8ff9e4 100644
--- a/core/java/com/android/internal/os/BatteryStatsImpl.java
+++ b/core/java/com/android/internal/os/BatteryStatsImpl.java
@@ -21,10 +21,13 @@
import android.app.ActivityManager;
import android.bluetooth.BluetoothActivityEnergyInfo;
import android.bluetooth.UidTraffic;
+import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
+import android.database.ContentObserver;
import android.net.ConnectivityManager;
import android.net.NetworkStats;
+import android.net.Uri;
import android.net.wifi.WifiActivityEnergyInfo;
import android.net.wifi.WifiManager;
import android.os.BatteryManager;
@@ -46,6 +49,7 @@
import android.os.UserHandle;
import android.os.WorkSource;
import android.os.WorkSource.WorkChain;
+import android.provider.Settings;
import android.telephony.DataConnectionRealTimeInfo;
import android.telephony.ModemActivityInfo;
import android.telephony.ServiceState;
@@ -54,6 +58,7 @@
import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.IntArray;
+import android.util.KeyValueListParser;
import android.util.Log;
import android.util.LogWriter;
import android.util.LongSparseArray;
@@ -124,7 +129,7 @@
private static final int MAGIC = 0xBA757475; // 'BATSTATS'
// Current on-disk Parcel version
- private static final int VERSION = 172 + (USE_OLD_HISTORY ? 1000 : 0);
+ private static final int VERSION = 173 + (USE_OLD_HISTORY ? 1000 : 0);
// Maximum number of items we will record in the history.
private static final int MAX_HISTORY_ITEMS;
@@ -289,12 +294,21 @@
/**
* Update per-freq cpu times for all the uids in {@link #mPendingUids}.
*/
- public void updateProcStateCpuTimes() {
+ public void updateProcStateCpuTimes(boolean onBattery, boolean onBatteryScreenOff) {
final SparseIntArray uidStates;
synchronized (BatteryStatsImpl.this) {
+ if (!mConstants.TRACK_CPU_TIMES_BY_PROC_STATE) {
+ return;
+ }
if(!initKernelSingleUidTimeReaderLocked()) {
return;
}
+ // If the KernelSingleUidTimeReader has stale cpu times, then we shouldn't try to
+ // compute deltas since it might result in mis-attributing cpu times to wrong states.
+ if (mKernelSingleUidTimeReader.hasStaleData()) {
+ mPendingUids.clear();
+ return;
+ }
if (mPendingUids.size() == 0) {
return;
@@ -307,7 +321,6 @@
final int procState = uidStates.valueAt(i);
final int[] isolatedUids;
final Uid u;
- final boolean onBattery;
synchronized (BatteryStatsImpl.this) {
// It's possible that uid no longer exists and any internal references have
// already been deleted, so using {@link #getAvailableUidStatsLocked} to avoid
@@ -324,7 +337,6 @@
isolatedUids[j] = u.mChildUids.get(j);
}
}
- onBattery = mOnBatteryInternal;
}
long[] cpuTimesMs = mKernelSingleUidTimeReader.readDeltaMs(uid);
if (isolatedUids != null) {
@@ -335,27 +347,45 @@
}
if (onBattery && cpuTimesMs != null) {
synchronized (BatteryStatsImpl.this) {
- u.addProcStateTimesMs(procState, cpuTimesMs);
- u.addProcStateScreenOffTimesMs(procState, cpuTimesMs);
+ u.addProcStateTimesMs(procState, cpuTimesMs, onBattery);
+ u.addProcStateScreenOffTimesMs(procState, cpuTimesMs, onBatteryScreenOff);
}
}
}
}
+ public void copyFromAllUidsCpuTimes() {
+ synchronized (BatteryStatsImpl.this) {
+ copyFromAllUidsCpuTimes(
+ mOnBatteryTimeBase.isRunning(), mOnBatteryScreenOffTimeBase.isRunning());
+ }
+ }
+
/**
* When the battery/screen state changes, we don't attribute the cpu times to any process
* but we still need to snapshots of all uids to get correct deltas later on. Since we
* already read this data for updating per-freq cpu times, we can use the same data for
* per-procstate cpu times.
*/
- public void copyFromAllUidsCpuTimes() {
+ public void copyFromAllUidsCpuTimes(boolean onBattery, boolean onBatteryScreenOff) {
synchronized (BatteryStatsImpl.this) {
+ if (!mConstants.TRACK_CPU_TIMES_BY_PROC_STATE) {
+ return;
+ }
if(!initKernelSingleUidTimeReaderLocked()) {
return;
}
final SparseArray<long[]> allUidCpuFreqTimesMs =
mKernelUidCpuFreqTimeReader.getAllUidCpuFreqTimeMs();
+ // If the KernelSingleUidTimeReader has stale cpu times, then we shouldn't try to
+ // compute deltas since it might result in mis-attributing cpu times to wrong states.
+ if (mKernelSingleUidTimeReader.hasStaleData()) {
+ mKernelSingleUidTimeReader.setAllUidsCpuTimesMs(allUidCpuFreqTimesMs);
+ mKernelSingleUidTimeReader.markDataAsStale(false);
+ mPendingUids.clear();
+ return;
+ }
for (int i = allUidCpuFreqTimesMs.size() - 1; i >= 0; --i) {
final int uid = allUidCpuFreqTimesMs.keyAt(i);
final Uid u = getAvailableUidStatsLocked(mapUid(uid));
@@ -368,7 +398,7 @@
}
final long[] deltaTimesMs = mKernelSingleUidTimeReader.computeDelta(
uid, cpuTimesMs.clone());
- if (mOnBatteryInternal && deltaTimesMs != null) {
+ if (onBattery && deltaTimesMs != null) {
final int procState;
final int idx = mPendingUids.indexOfKey(uid);
if (idx >= 0) {
@@ -378,8 +408,8 @@
procState = u.mProcessState;
}
if (procState >= 0 && procState < Uid.NUM_PROCESS_STATE) {
- u.addProcStateTimesMs(procState, deltaTimesMs);
- u.addProcStateScreenOffTimesMs(procState, deltaTimesMs);
+ u.addProcStateTimesMs(procState, deltaTimesMs, onBattery);
+ u.addProcStateScreenOffTimesMs(procState, deltaTimesMs, onBatteryScreenOff);
}
}
}
@@ -443,8 +473,9 @@
Future<?> scheduleSync(String reason, int flags);
Future<?> scheduleCpuSyncDueToRemovedUid(int uid);
- Future<?> scheduleReadProcStateCpuTimes();
- Future<?> scheduleCopyFromAllUidsCpuTimes();
+ Future<?> scheduleReadProcStateCpuTimes(boolean onBattery, boolean onBatteryScreenOff);
+ Future<?> scheduleCopyFromAllUidsCpuTimes(boolean onBattery, boolean onBatteryScreenOff);
+ Future<?> scheduleCpuSyncDueToSettingChange();
}
public Handler mHandler;
@@ -807,6 +838,9 @@
@VisibleForTesting
protected PowerProfile mPowerProfile;
+ @GuardedBy("this")
+ private final Constants mConstants;
+
/*
* Holds a SamplingTimer associated with each Resource Power Manager state and voter,
* recording their times when on-battery (regardless of screen state).
@@ -895,6 +929,7 @@
mHandler = null;
mPlatformIdleStateCallback = null;
mUserInfoProvider = null;
+ mConstants = new Constants(mHandler);
clearHistoryLocked();
}
@@ -1231,12 +1266,10 @@
public long[] mCounts;
public long[] mLoadedCounts;
public long[] mUnpluggedCounts;
- public long[] mPluggedCounts;
private LongSamplingCounterArray(TimeBase timeBase, Parcel in) {
mTimeBase = timeBase;
- mPluggedCounts = in.createLongArray();
- mCounts = copyArray(mPluggedCounts, mCounts);
+ mCounts = in.createLongArray();
mLoadedCounts = in.createLongArray();
mUnpluggedCounts = in.createLongArray();
timeBase.add(this);
@@ -1255,17 +1288,16 @@
@Override
public void onTimeStarted(long elapsedRealTime, long baseUptime, long baseRealtime) {
- mUnpluggedCounts = copyArray(mPluggedCounts, mUnpluggedCounts);
+ mUnpluggedCounts = copyArray(mCounts, mUnpluggedCounts);
}
@Override
public void onTimeStopped(long elapsedRealtime, long baseUptime, long baseRealtime) {
- mPluggedCounts = copyArray(mCounts, mPluggedCounts);
}
@Override
public long[] getCountsLocked(int which) {
- long[] val = copyArray(mTimeBase.isRunning() ? mCounts : mPluggedCounts, null);
+ long[] val = copyArray(mCounts, null);
if (which == STATS_SINCE_UNPLUGGED) {
subtract(val, mUnpluggedCounts);
} else if (which != STATS_SINCE_CHARGED) {
@@ -1278,15 +1310,18 @@
public void logState(Printer pw, String prefix) {
pw.println(prefix + "mCounts=" + Arrays.toString(mCounts)
+ " mLoadedCounts=" + Arrays.toString(mLoadedCounts)
- + " mUnpluggedCounts=" + Arrays.toString(mUnpluggedCounts)
- + " mPluggedCounts=" + Arrays.toString(mPluggedCounts));
+ + " mUnpluggedCounts=" + Arrays.toString(mUnpluggedCounts));
}
public void addCountLocked(long[] counts) {
+ addCountLocked(counts, mTimeBase.isRunning());
+ }
+
+ public void addCountLocked(long[] counts, boolean isRunning) {
if (counts == null) {
return;
}
- if (mTimeBase.isRunning()) {
+ if (isRunning) {
if (mCounts == null) {
mCounts = new long[counts.length];
}
@@ -1306,7 +1341,6 @@
public void reset(boolean detachIfReset) {
fillArray(mCounts, 0);
fillArray(mLoadedCounts, 0);
- fillArray(mPluggedCounts, 0);
fillArray(mUnpluggedCounts, 0);
if (detachIfReset) {
detach();
@@ -1325,7 +1359,6 @@
mCounts = in.createLongArray();
mLoadedCounts = copyArray(mCounts, mLoadedCounts);
mUnpluggedCounts = copyArray(mCounts, mUnpluggedCounts);
- mPluggedCounts = copyArray(mCounts, mPluggedCounts);
}
public static void writeToParcel(Parcel out, LongSamplingCounterArray counterArray) {
@@ -3783,7 +3816,8 @@
+ " and battery is " + (unplugged ? "on" : "off"));
}
updateCpuTimeLocked();
- mExternalSync.scheduleCopyFromAllUidsCpuTimes();
+ mExternalSync.scheduleCopyFromAllUidsCpuTimes(mOnBatteryTimeBase.isRunning(),
+ mOnBatteryScreenOffTimeBase.isRunning());
mOnBatteryTimeBase.setRunning(unplugged, uptime, realtime);
if (updateOnBatteryTimeBase) {
@@ -4028,18 +4062,17 @@
public void noteWakupAlarmLocked(String packageName, int uid, WorkSource workSource,
String tag) {
- if (!isOnBattery()) {
- return;
- }
if (workSource != null) {
for (int i = 0; i < workSource.size(); ++i) {
uid = workSource.get(i);
final String workSourceName = workSource.getName(i);
- BatteryStatsImpl.Uid.Pkg pkg = getPackageStatsLocked(uid,
- workSourceName != null ? workSourceName : packageName);
- pkg.noteWakeupAlarmLocked(tag);
+ if (isOnBattery()) {
+ BatteryStatsImpl.Uid.Pkg pkg = getPackageStatsLocked(uid,
+ workSourceName != null ? workSourceName : packageName);
+ pkg.noteWakeupAlarmLocked(tag);
+ }
StatsLog.write(StatsLog.WAKEUP_ALARM_OCCURRED, uid, tag);
}
@@ -4050,16 +4083,20 @@
final WorkChain wc = workChains.get(i);
uid = wc.getAttributionUid();
- BatteryStatsImpl.Uid.Pkg pkg = getPackageStatsLocked(uid, packageName);
- pkg.noteWakeupAlarmLocked(tag);
+ if (isOnBattery()) {
+ BatteryStatsImpl.Uid.Pkg pkg = getPackageStatsLocked(uid, packageName);
+ pkg.noteWakeupAlarmLocked(tag);
+ }
// TODO(statsd): Log the full attribution chain here once it's available
StatsLog.write(StatsLog.WAKEUP_ALARM_OCCURRED, uid, tag);
}
}
} else {
- BatteryStatsImpl.Uid.Pkg pkg = getPackageStatsLocked(uid, packageName);
- pkg.noteWakeupAlarmLocked(tag);
+ if (isOnBattery()) {
+ BatteryStatsImpl.Uid.Pkg pkg = getPackageStatsLocked(uid, packageName);
+ pkg.noteWakeupAlarmLocked(tag);
+ }
StatsLog.write(StatsLog.WAKEUP_ALARM_OCCURRED, uid, tag);
}
}
@@ -4318,6 +4355,34 @@
public void noteLongPartialWakelockStart(String name, String historyName, int uid) {
uid = mapUid(uid);
+ noteLongPartialWakeLockStartInternal(name, historyName, uid);
+ StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName, 1);
+ }
+
+ public void noteLongPartialWakelockStartFromSource(String name, String historyName,
+ WorkSource workSource) {
+ final int N = workSource.size();
+ for (int i = 0; i < N; ++i) {
+ final int uid = mapUid(workSource.get(i));
+ noteLongPartialWakeLockStartInternal(name, historyName, uid);
+ StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName, 1);
+ }
+
+ final ArrayList<WorkChain> workChains = workSource.getWorkChains();
+ if (workChains != null) {
+ for (int i = 0; i < workChains.size(); ++i) {
+ final WorkChain workChain = workChains.get(i);
+ final int uid = workChain.getAttributionUid();
+ noteLongPartialWakeLockStartInternal(name, historyName, uid);
+
+ // TODO(statsd): the Log WorkChain to statds, and not just the uid.
+ StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName,
+ 1);
+ }
+ }
+ }
+
+ private void noteLongPartialWakeLockStartInternal(String name, String historyName, int uid) {
final long elapsedRealtime = mClocks.elapsedRealtime();
final long uptime = mClocks.uptimeMillis();
if (historyName == null) {
@@ -4329,11 +4394,39 @@
}
addHistoryEventLocked(elapsedRealtime, uptime, HistoryItem.EVENT_LONG_WAKE_LOCK_START,
historyName, uid);
- StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName, 1);
}
public void noteLongPartialWakelockFinish(String name, String historyName, int uid) {
uid = mapUid(uid);
+ noteLongPartialWakeLockFinishInternal(name, historyName, uid);
+ StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName, 0);
+ }
+
+ public void noteLongPartialWakelockFinishFromSource(String name, String historyName,
+ WorkSource workSource) {
+ final int N = workSource.size();
+ for (int i = 0; i < N; ++i) {
+ final int uid = mapUid(workSource.get(i));
+ noteLongPartialWakeLockFinishInternal(name, historyName, uid);
+ StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName, 0);
+ }
+
+ final ArrayList<WorkChain> workChains = workSource.getWorkChains();
+ if (workChains != null) {
+ for (int i = 0; i < workChains.size(); ++i) {
+ final WorkChain workChain = workChains.get(i);
+ final int uid = workChain.getAttributionUid();
+
+ noteLongPartialWakeLockFinishInternal(name, historyName, uid);
+
+ // TODO(statsd): the Log WorkChain to statds, and not just the uid.
+ StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName,
+ 0);
+ }
+ }
+ }
+
+ private void noteLongPartialWakeLockFinishInternal(String name, String historyName, int uid) {
final long elapsedRealtime = mClocks.elapsedRealtime();
final long uptime = mClocks.uptimeMillis();
if (historyName == null) {
@@ -4345,7 +4438,6 @@
}
addHistoryEventLocked(elapsedRealtime, uptime, HistoryItem.EVENT_LONG_WAKE_LOCK_FINISH,
historyName, uid);
- StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, uid, name, historyName, 0);
}
void aggregateLastWakeupUptimeLocked(long uptimeMs) {
@@ -6590,7 +6682,7 @@
return null;
}
- private void addProcStateTimesMs(int procState, long[] cpuTimesMs) {
+ private void addProcStateTimesMs(int procState, long[] cpuTimesMs, boolean onBattery) {
if (mProcStateTimeMs == null) {
mProcStateTimeMs = new LongSamplingCounterArray[NUM_PROCESS_STATE];
}
@@ -6599,10 +6691,11 @@
mProcStateTimeMs[procState] = new LongSamplingCounterArray(
mBsi.mOnBatteryTimeBase);
}
- mProcStateTimeMs[procState].addCountLocked(cpuTimesMs);
+ mProcStateTimeMs[procState].addCountLocked(cpuTimesMs, onBattery);
}
- private void addProcStateScreenOffTimesMs(int procState, long[] cpuTimesMs) {
+ private void addProcStateScreenOffTimesMs(int procState, long[] cpuTimesMs,
+ boolean onBatteryScreenOff) {
if (mProcStateScreenOffTimeMs == null) {
mProcStateScreenOffTimeMs = new LongSamplingCounterArray[NUM_PROCESS_STATE];
}
@@ -6611,7 +6704,7 @@
mProcStateScreenOffTimeMs[procState] = new LongSamplingCounterArray(
mBsi.mOnBatteryScreenOffTimeBase);
}
- mProcStateScreenOffTimeMs[procState].addCountLocked(cpuTimesMs);
+ mProcStateScreenOffTimeMs[procState].addCountLocked(cpuTimesMs, onBatteryScreenOff);
}
@Override
@@ -9348,9 +9441,11 @@
if (mProcessState != ActivityManager.PROCESS_STATE_NONEXISTENT) {
mProcessStateTimer[mProcessState].stopRunningLocked(elapsedRealtimeMs);
- if (mBsi.mPerProcStateCpuTimesAvailable) {
+ if (mBsi.trackPerProcStateCpuTimes()) {
if (mBsi.mPendingUids.size() == 0) {
- mBsi.mExternalSync.scheduleReadProcStateCpuTimes();
+ mBsi.mExternalSync.scheduleReadProcStateCpuTimes(
+ mBsi.mOnBatteryTimeBase.isRunning(),
+ mBsi.mOnBatteryScreenOffTimeBase.isRunning());
}
if (mBsi.mPendingUids.indexOfKey(mUid) < 0
|| ArrayUtils.contains(CRITICAL_PROC_STATES, mProcessState)) {
@@ -9700,6 +9795,7 @@
mCheckinFile = new AtomicFile(new File(systemDir, "batterystats-checkin.bin"));
mDailyFile = new AtomicFile(new File(systemDir, "batterystats-daily.xml"));
mHandler = new MyHandler(handler.getLooper());
+ mConstants = new Constants(mHandler);
mStartCount++;
mScreenOnTimer = new StopwatchTimer(mClocks, null, -1, null, mOnBatteryTimeBase);
mScreenDozeTimer = new StopwatchTimer(mClocks, null, -1, null, mOnBatteryTimeBase);
@@ -9795,6 +9891,7 @@
mDailyFile = null;
mHandler = null;
mExternalSync = null;
+ mConstants = new Constants(mHandler);
clearHistoryLocked();
readFromParcel(p);
mPlatformIdleStateCallback = null;
@@ -12548,6 +12645,78 @@
mShuttingDown = true;
}
+ public boolean trackPerProcStateCpuTimes() {
+ return mConstants.TRACK_CPU_TIMES_BY_PROC_STATE && mPerProcStateCpuTimesAvailable;
+ }
+
+ public void systemServicesReady(Context context) {
+ mConstants.startObserving(context.getContentResolver());
+ }
+
+ @VisibleForTesting
+ public final class Constants extends ContentObserver {
+ public static final String KEY_TRACK_CPU_TIMES_BY_PROC_STATE
+ = "track_cpu_times_by_proc_state";
+
+ private static final boolean DEFAULT_TRACK_CPU_TIMES_BY_PROC_STATE = true;
+
+ public boolean TRACK_CPU_TIMES_BY_PROC_STATE = DEFAULT_TRACK_CPU_TIMES_BY_PROC_STATE;
+
+ private ContentResolver mResolver;
+ private final KeyValueListParser mParser = new KeyValueListParser(',');
+
+ public Constants(Handler handler) {
+ super(handler);
+ }
+
+ public void startObserving(ContentResolver resolver) {
+ mResolver = resolver;
+ mResolver.registerContentObserver(
+ Settings.Global.getUriFor(Settings.Global.BATTERY_STATS_CONSTANTS),
+ false /* notifyForDescendants */, this);
+ updateConstants();
+ }
+
+ @Override
+ public void onChange(boolean selfChange, Uri uri) {
+ updateConstants();
+ }
+
+ private void updateConstants() {
+ synchronized (BatteryStatsImpl.this) {
+ try {
+ mParser.setString(Settings.Global.getString(mResolver,
+ Settings.Global.BATTERY_STATS_CONSTANTS));
+ } catch (IllegalArgumentException e) {
+ // Failed to parse the settings string, log this and move on
+ // with defaults.
+ Slog.e(TAG, "Bad batterystats settings", e);
+ }
+
+ updateTrackCpuTimesByProcStateLocked(TRACK_CPU_TIMES_BY_PROC_STATE,
+ mParser.getBoolean(KEY_TRACK_CPU_TIMES_BY_PROC_STATE,
+ DEFAULT_TRACK_CPU_TIMES_BY_PROC_STATE));
+ }
+ }
+
+ private void updateTrackCpuTimesByProcStateLocked(boolean wasEnabled, boolean isEnabled) {
+ TRACK_CPU_TIMES_BY_PROC_STATE = isEnabled;
+ if (isEnabled && !wasEnabled) {
+ mKernelSingleUidTimeReader.markDataAsStale(true);
+ mExternalSync.scheduleCpuSyncDueToSettingChange();
+ }
+ }
+
+ public void dumpLocked(PrintWriter pw) {
+ pw.print(KEY_TRACK_CPU_TIMES_BY_PROC_STATE); pw.print("=");
+ pw.println(TRACK_CPU_TIMES_BY_PROC_STATE);
+ }
+ }
+
+ public void dumpConstantsLocked(PrintWriter pw) {
+ mConstants.dumpLocked(pw);
+ }
+
Parcel mPendingWrite = null;
final ReentrantLock mWriteLock = new ReentrantLock();
diff --git a/core/java/com/android/internal/os/KernelSingleUidTimeReader.java b/core/java/com/android/internal/os/KernelSingleUidTimeReader.java
index ca635a4..ebeb24c4 100644
--- a/core/java/com/android/internal/os/KernelSingleUidTimeReader.java
+++ b/core/java/com/android/internal/os/KernelSingleUidTimeReader.java
@@ -46,12 +46,14 @@
private final int mCpuFreqsCount;
@GuardedBy("this")
- private final SparseArray<long[]> mLastUidCpuTimeMs = new SparseArray<>();
+ private SparseArray<long[]> mLastUidCpuTimeMs = new SparseArray<>();
@GuardedBy("this")
private int mReadErrorCounter;
@GuardedBy("this")
private boolean mSingleUidCpuTimesAvailable = true;
+ @GuardedBy("this")
+ private boolean mHasStaleData;
private final Injector mInjector;
@@ -166,6 +168,30 @@
return deltaTimesMs;
}
+ public void markDataAsStale(boolean hasStaleData) {
+ synchronized (this) {
+ mHasStaleData = hasStaleData;
+ }
+ }
+
+ public boolean hasStaleData() {
+ synchronized (this) {
+ return mHasStaleData;
+ }
+ }
+
+ public void setAllUidsCpuTimesMs(SparseArray<long[]> allUidsCpuTimesMs) {
+ synchronized (this) {
+ mLastUidCpuTimeMs.clear();
+ for (int i = allUidsCpuTimesMs.size() - 1; i >= 0; --i) {
+ final long[] cpuTimesMs = allUidsCpuTimesMs.valueAt(i);
+ if (cpuTimesMs != null) {
+ mLastUidCpuTimeMs.put(allUidsCpuTimesMs.keyAt(i), cpuTimesMs.clone());
+ }
+ }
+ }
+ }
+
public void removeUid(int uid) {
synchronized (this) {
mLastUidCpuTimeMs.delete(uid);
diff --git a/core/java/com/android/internal/widget/ILockSettings.aidl b/core/java/com/android/internal/widget/ILockSettings.aidl
index 862288b..4e7df28 100644
--- a/core/java/com/android/internal/widget/ILockSettings.aidl
+++ b/core/java/com/android/internal/widget/ILockSettings.aidl
@@ -66,6 +66,7 @@
void initRecoveryService(in String rootCertificateAlias, in byte[] signedPublicKeyList);
KeyStoreRecoveryData getRecoveryData(in byte[] account);
byte[] generateAndStoreKey(String alias);
+ void removeKey(String alias);
void setSnapshotCreatedPendingIntent(in PendingIntent intent);
Map getRecoverySnapshotVersions();
void setServerParameters(long serverParameters);
diff --git a/core/java/com/android/internal/widget/RecyclerView.java b/core/java/com/android/internal/widget/RecyclerView.java
index 7abc76a..408a4e9 100644
--- a/core/java/com/android/internal/widget/RecyclerView.java
+++ b/core/java/com/android/internal/widget/RecyclerView.java
@@ -9556,7 +9556,7 @@
if (vScroll == 0 && hScroll == 0) {
return false;
}
- mRecyclerView.scrollBy(hScroll, vScroll);
+ mRecyclerView.smoothScrollBy(hScroll, vScroll);
return true;
}
diff --git a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
index de2b7c3..4257c98 100644
--- a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
+++ b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
@@ -12,21 +12,62 @@
static jmethodID gInputStream_readMethodID;
static jmethodID gInputStream_skipMethodID;
+// FIXME: Share with ByteBufferStreamAdaptor.cpp?
+static JNIEnv* get_env_or_die(JavaVM* jvm) {
+ JNIEnv* env;
+ if (jvm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+ LOG_ALWAYS_FATAL("Failed to get JNIEnv for JavaVM: %p", jvm);
+ }
+ return env;
+}
+
/**
* Wrapper for a Java InputStream.
*/
class JavaInputStreamAdaptor : public SkStream {
+ JavaInputStreamAdaptor(JavaVM* jvm, jobject js, jbyteArray ar, jint capacity,
+ bool swallowExceptions)
+ : fJvm(jvm)
+ , fJavaInputStream(js)
+ , fJavaByteArray(ar)
+ , fCapacity(capacity)
+ , fBytesRead(0)
+ , fIsAtEnd(false)
+ , fSwallowExceptions(swallowExceptions) {}
+
public:
- JavaInputStreamAdaptor(JNIEnv* env, jobject js, jbyteArray ar)
- : fEnv(env), fJavaInputStream(js), fJavaByteArray(ar) {
- SkASSERT(ar);
- fCapacity = env->GetArrayLength(ar);
- SkASSERT(fCapacity > 0);
- fBytesRead = 0;
- fIsAtEnd = false;
+ static JavaInputStreamAdaptor* Create(JNIEnv* env, jobject js, jbyteArray ar,
+ bool swallowExceptions) {
+ JavaVM* jvm;
+ LOG_ALWAYS_FATAL_IF(env->GetJavaVM(&jvm) != JNI_OK);
+
+ js = env->NewGlobalRef(js);
+ if (!js) {
+ return nullptr;
+ }
+
+ ar = (jbyteArray) env->NewGlobalRef(ar);
+ if (!ar) {
+ env->DeleteGlobalRef(js);
+ return nullptr;
+ }
+
+ jint capacity = env->GetArrayLength(ar);
+ return new JavaInputStreamAdaptor(jvm, js, ar, capacity, swallowExceptions);
}
- virtual size_t read(void* buffer, size_t size) {
+ ~JavaInputStreamAdaptor() override {
+ auto* env = get_env_or_die(fJvm);
+ env->DeleteGlobalRef(fJavaInputStream);
+ env->DeleteGlobalRef(fJavaByteArray);
+ }
+
+ size_t read(void* buffer, size_t size) override {
+ auto* env = get_env_or_die(fJvm);
+ if (!fSwallowExceptions && checkException(env)) {
+ // Just in case the caller did not clear from a previous exception.
+ return 0;
+ }
if (NULL == buffer) {
if (0 == size) {
return 0;
@@ -37,10 +78,10 @@
*/
size_t amountSkipped = 0;
do {
- size_t amount = this->doSkip(size - amountSkipped);
+ size_t amount = this->doSkip(size - amountSkipped, env);
if (0 == amount) {
char tmp;
- amount = this->doRead(&tmp, 1);
+ amount = this->doRead(&tmp, 1, env);
if (0 == amount) {
// if read returned 0, we're at EOF
fIsAtEnd = true;
@@ -52,16 +93,13 @@
return amountSkipped;
}
}
- return this->doRead(buffer, size);
+ return this->doRead(buffer, size, env);
}
- virtual bool isAtEnd() const {
- return fIsAtEnd;
- }
+ bool isAtEnd() const override { return fIsAtEnd; }
private:
- size_t doRead(void* buffer, size_t size) {
- JNIEnv* env = fEnv;
+ size_t doRead(void* buffer, size_t size, JNIEnv* env) {
size_t bytesRead = 0;
// read the bytes
do {
@@ -76,13 +114,9 @@
jint n = env->CallIntMethod(fJavaInputStream,
gInputStream_readMethodID, fJavaByteArray, 0, requested);
- if (env->ExceptionCheck()) {
- env->ExceptionDescribe();
- env->ExceptionClear();
+ if (checkException(env)) {
SkDebugf("---- read threw an exception\n");
- // Consider the stream to be at the end, since there was an error.
- fIsAtEnd = true;
- return 0;
+ return bytesRead;
}
if (n < 0) { // n == 0 should not be possible, see InputStream read() specifications.
@@ -92,14 +126,9 @@
env->GetByteArrayRegion(fJavaByteArray, 0, n,
reinterpret_cast<jbyte*>(buffer));
- if (env->ExceptionCheck()) {
- env->ExceptionDescribe();
- env->ExceptionClear();
+ if (checkException(env)) {
SkDebugf("---- read:GetByteArrayRegion threw an exception\n");
- // The error was not with the stream itself, but consider it to be at the
- // end, since we do not have a way to recover.
- fIsAtEnd = true;
- return 0;
+ return bytesRead;
}
buffer = (void*)((char*)buffer + n);
@@ -111,14 +140,10 @@
return bytesRead;
}
- size_t doSkip(size_t size) {
- JNIEnv* env = fEnv;
-
+ size_t doSkip(size_t size, JNIEnv* env) {
jlong skipped = env->CallLongMethod(fJavaInputStream,
gInputStream_skipMethodID, (jlong)size);
- if (env->ExceptionCheck()) {
- env->ExceptionDescribe();
- env->ExceptionClear();
+ if (checkException(env)) {
SkDebugf("------- skip threw an exception\n");
return 0;
}
@@ -129,20 +154,37 @@
return (size_t)skipped;
}
- JNIEnv* fEnv;
- jobject fJavaInputStream; // the caller owns this object
- jbyteArray fJavaByteArray; // the caller owns this object
- jint fCapacity;
+ bool checkException(JNIEnv* env) {
+ if (!env->ExceptionCheck()) {
+ return false;
+ }
+
+ env->ExceptionDescribe();
+ if (fSwallowExceptions) {
+ env->ExceptionClear();
+ }
+
+ // There is no way to recover from the error, so consider the stream
+ // to be at the end.
+ fIsAtEnd = true;
+
+ return true;
+ }
+
+ JavaVM* fJvm;
+ jobject fJavaInputStream;
+ jbyteArray fJavaByteArray;
+ const jint fCapacity;
size_t fBytesRead;
bool fIsAtEnd;
+ const bool fSwallowExceptions;
};
-SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream,
- jbyteArray storage) {
- return new JavaInputStreamAdaptor(env, stream, storage);
+SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream, jbyteArray storage,
+ bool swallowExceptions) {
+ return JavaInputStreamAdaptor::Create(env, stream, storage, swallowExceptions);
}
-
static SkMemoryStream* adaptor_to_mem_stream(SkStream* stream) {
SkASSERT(stream != NULL);
size_t bufferSize = 4096;
diff --git a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h
index 56cba51..fccd471 100644
--- a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h
+++ b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h
@@ -16,13 +16,16 @@
* @param stream Pointer to Java InputStream.
* @param storage Java byte array for retrieving data from the
* Java InputStream.
+ * @param swallowExceptions Whether to call ExceptionClear() after
+ * an Exception is thrown. If false, it is up to the client to
+ * clear or propagate the exception.
* @return SkStream Simple subclass of SkStream which supports its
* basic methods like reading. Only valid until the calling
* function returns, since the Java InputStream is not managed
* by the SkStream.
*/
-SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream,
- jbyteArray storage);
+SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream, jbyteArray storage,
+ bool swallowExceptions = true);
/**
* Copy a Java InputStream. The result will be rewindable.
@@ -33,10 +36,8 @@
* @return SkStreamRewindable The data in stream will be copied
* to a new SkStreamRewindable.
*/
-SkStreamRewindable* CopyJavaInputStream(JNIEnv* env, jobject stream,
- jbyteArray storage);
+SkStreamRewindable* CopyJavaInputStream(JNIEnv* env, jobject stream, jbyteArray storage);
-SkWStream* CreateJavaOutputStreamAdaptor(JNIEnv* env, jobject stream,
- jbyteArray storage);
+SkWStream* CreateJavaOutputStreamAdaptor(JNIEnv* env, jobject stream, jbyteArray storage);
#endif // _ANDROID_GRAPHICS_CREATE_JAVA_OUTPUT_STREAM_ADAPTOR_H_
diff --git a/core/jni/android/graphics/ImageDecoder.cpp b/core/jni/android/graphics/ImageDecoder.cpp
index bacab2a..5bdad08 100644
--- a/core/jni/android/graphics/ImageDecoder.cpp
+++ b/core/jni/android/graphics/ImageDecoder.cpp
@@ -16,6 +16,7 @@
#include "Bitmap.h"
#include "ByteBufferStreamAdaptor.h"
+#include "CreateJavaOutputStreamAdaptor.h"
#include "GraphicsJNI.h"
#include "NinePatchPeeker.h"
#include "Utils.h"
@@ -26,10 +27,12 @@
#include <SkAndroidCodec.h>
#include <SkEncodedImageFormat.h>
+#include <SkFrontBufferedStream.h>
#include <SkStream.h>
#include <androidfw/Asset.h>
#include <jni.h>
+#include <sys/stat.h>
using namespace android;
@@ -69,15 +72,15 @@
static jobject native_create(JNIEnv* env, std::unique_ptr<SkStream> stream) {
if (!stream.get()) {
- return nullObjectReturn("Failed to create a stream");
+ doThrowIOE(env, "Failed to create a stream");
+ return nullptr;
}
std::unique_ptr<ImageDecoder> decoder(new ImageDecoder);
decoder->mCodec = SkAndroidCodec::MakeFromStream(std::move(stream), &decoder->mPeeker);
if (!decoder->mCodec.get()) {
- // FIXME: Add an error code to SkAndroidCodec::MakeFromStream, like
- // SkCodec? Then this can print a more informative error message.
- // (Or we can print one from within SkCodec.)
- ALOGE("Failed to create an SkCodec");
+ // FIXME: (b/71578461) Use the error message from
+ // SkCodec::MakeFromStream to report a more informative error message.
+ doThrowIOE(env, "Failed to create an SkCodec");
return nullptr;
}
@@ -88,7 +91,52 @@
reinterpret_cast<jlong>(decoder.release()), width, height);
}
-static jobject ImageDecoder_nCreate(JNIEnv* env, jobject /*clazz*/, jlong assetPtr) {
+static jobject ImageDecoder_nCreateFd(JNIEnv* env, jobject /*clazz*/,
+ jobject fileDescriptor) {
+ int descriptor = jniGetFDFromFileDescriptor(env, fileDescriptor);
+
+ struct stat fdStat;
+ if (fstat(descriptor, &fdStat) == -1) {
+ doThrowIOE(env, "broken file descriptor; fstat returned -1");
+ return nullptr;
+ }
+
+ int dupDescriptor = dup(descriptor);
+ FILE* file = fdopen(dupDescriptor, "r");
+ if (file == NULL) {
+ close(dupDescriptor);
+ doThrowIOE(env, "Could not open file");
+ return nullptr;
+ }
+ std::unique_ptr<SkFILEStream> fileStream(new SkFILEStream(file));
+
+ if (::lseek(descriptor, 0, SEEK_CUR) == 0) {
+ return native_create(env, std::move(fileStream));
+ }
+
+ // FIXME: This allows us to pretend the current location is the beginning,
+ // but it would be better if SkFILEStream allowed treating its starting
+ // point as the beginning.
+ std::unique_ptr<SkStream> stream(SkFrontBufferedStream::Make(std::move(fileStream),
+ SkCodec::MinBufferedBytesNeeded()));
+ return native_create(env, std::move(stream));
+}
+
+static jobject ImageDecoder_nCreateInputStream(JNIEnv* env, jobject /*clazz*/,
+ jobject is, jbyteArray storage) {
+ std::unique_ptr<SkStream> stream(CreateJavaInputStreamAdaptor(env, is, storage, false));
+
+ if (!stream.get()) {
+ doThrowIOE(env, "Failed to create stream!");
+ return nullptr;
+ }
+ std::unique_ptr<SkStream> bufferedStream(
+ SkFrontBufferedStream::Make(std::move(stream),
+ SkCodec::MinBufferedBytesNeeded()));
+ return native_create(env, std::move(bufferedStream));
+}
+
+static jobject ImageDecoder_nCreateAsset(JNIEnv* env, jobject /*clazz*/, jlong assetPtr) {
Asset* asset = reinterpret_cast<Asset*>(assetPtr);
std::unique_ptr<SkStream> stream(new AssetStreamAdaptor(asset));
return native_create(env, std::move(stream));
@@ -99,6 +147,7 @@
std::unique_ptr<SkStream> stream = CreateByteBufferStreamAdaptor(env, jbyteBuffer,
initialPosition, limit);
if (!stream) {
+ doThrowIOE(env, "Failed to read ByteBuffer");
return nullptr;
}
return native_create(env, std::move(stream));
@@ -114,6 +163,7 @@
return codec->getEncodedFormat() == SkEncodedImageFormat::kWEBP;
}
+// This method should never return null. Instead, it should throw an exception.
static jobject ImageDecoder_nDecodeBitmap(JNIEnv* env, jobject /*clazz*/, jlong nativePtr,
jobject jcallback, jobject jpostProcess,
jint desiredWidth, jint desiredHeight, jobject jsubset,
@@ -165,7 +215,8 @@
case kOpaque_SkAlphaType:
break;
case kUnknown_SkAlphaType:
- return nullObjectReturn("Unknown alpha type");
+ doThrowIOE(env, "Unknown alpha type");
+ return nullptr;
}
SkColorType colorType = kN32_SkColorType;
@@ -200,7 +251,8 @@
bitmapInfo = bitmapInfo.makeColorType(kAlpha_8_SkColorType);
}
if (!bm.setInfo(bitmapInfo)) {
- return nullObjectReturn("Failed to setInfo properly");
+ doThrowIOE(env, "Failed to setInfo properly");
+ return nullptr;
}
sk_sp<Bitmap> nativeBitmap;
@@ -213,35 +265,44 @@
nativeBitmap = Bitmap::allocateHeapBitmap(&bm);
}
if (!nativeBitmap) {
- ALOGE("OOM allocating Bitmap with dimensions %i x %i",
- decodeInfo.width(), decodeInfo.height());
- doThrowOOME(env);
+ SkString msg;
+ msg.printf("OOM allocating Bitmap with dimensions %i x %i",
+ decodeInfo.width(), decodeInfo.height());
+ doThrowOOME(env, msg.c_str());
return nullptr;
}
- jobject jexception = nullptr;
SkAndroidCodec::AndroidOptions options;
options.fSampleSize = sampleSize;
auto result = codec->getAndroidPixels(decodeInfo, bm.getPixels(), bm.rowBytes(), &options);
+ jobject jexception = env->ExceptionOccurred();
+ if (jexception) {
+ env->ExceptionClear();
+ }
switch (result) {
case SkCodec::kSuccess:
+ // Ignore the exception, since the decode was successful anyway.
+ jexception = nullptr;
break;
case SkCodec::kIncompleteInput:
- if (jcallback) {
+ if (jcallback && !jexception) {
jexception = env->NewObject(gIncomplete_class, gIncomplete_constructorMethodID);
}
break;
case SkCodec::kErrorInInput:
- if (jcallback) {
+ if (jcallback && !jexception) {
jexception = env->NewObject(gCorrupt_class, gCorrupt_constructorMethodID);
}
break;
default:
- ALOGE("getPixels failed with error %i", result);
+ SkString msg;
+ msg.printf("getPixels failed with error %i", result);
+ doThrowIOE(env, msg.c_str());
return nullptr;
}
if (jexception) {
+ // FIXME: Do not provide a way for the client to force the method to return null.
if (!env->CallBooleanMethod(jcallback, gCallback_onExceptionMethodID, jexception) ||
env->ExceptionCheck()) {
return nullptr;
@@ -268,7 +329,8 @@
size_t ninePatchArraySize = decoder->mPeeker.mPatch->serializedSize();
ninePatchChunk = env->NewByteArray(ninePatchArraySize);
if (ninePatchChunk == nullptr) {
- return nullObjectReturn("ninePatchChunk == null");
+ doThrowOOME(env, "Failed to allocate nine patch chunk.");
+ return nullptr;
}
env->SetByteArrayRegion(ninePatchChunk, 0, decoder->mPeeker.mPatchSize,
@@ -278,7 +340,8 @@
if (decoder->mPeeker.mHasInsets) {
ninePatchInsets = decoder->mPeeker.createNinePatchInsets(env, 1.0f);
if (ninePatchInsets == nullptr) {
- return nullObjectReturn("nine patch insets == null");
+ doThrowOOME(env, "Failed to allocate nine patch insets.");
+ return nullptr;
}
}
}
@@ -303,7 +366,8 @@
SkImageInfo scaledInfo = bitmapInfo.makeWH(desiredWidth, desiredHeight);
SkBitmap scaledBm;
if (!scaledBm.setInfo(scaledInfo)) {
- nullObjectReturn("Failed scaled setInfo");
+ doThrowIOE(env, "Failed scaled setInfo");
+ return nullptr;
}
sk_sp<Bitmap> scaledPixelRef;
@@ -313,9 +377,10 @@
scaledPixelRef = Bitmap::allocateHeapBitmap(&scaledBm);
}
if (!scaledPixelRef) {
- ALOGE("OOM allocating scaled Bitmap with dimensions %i x %i",
- desiredWidth, desiredHeight);
- doThrowOOME(env);
+ SkString msg;
+ msg.printf("OOM allocating scaled Bitmap with dimensions %i x %i",
+ desiredWidth, desiredHeight);
+ doThrowOOME(env, msg.c_str());
return nullptr;
}
@@ -334,13 +399,11 @@
if (jpostProcess) {
std::unique_ptr<Canvas> canvas(Canvas::create_canvas(bm));
- if (!canvas) {
- return nullObjectReturn("Failed to create Canvas for PostProcess!");
- }
jobject jcanvas = env->NewObject(gCanvas_class, gCanvas_constructorMethodID,
reinterpret_cast<jlong>(canvas.get()));
if (!jcanvas) {
- return nullObjectReturn("Failed to create Java Canvas for PostProcess!");
+ doThrowOOME(env, "Failed to create Java Canvas for PostProcess!");
+ return nullptr;
}
// jcanvas will now own canvas.
canvas.release();
@@ -368,15 +431,17 @@
newAlphaType = kOpaque_SkAlphaType;
break;
default:
- ALOGE("invalid return from postProcess: %i", pixelFormat);
- doThrowIAE(env);
+ SkString msg;
+ msg.printf("invalid return from postProcess: %i", pixelFormat);
+ doThrowIAE(env, msg.c_str());
return nullptr;
}
if (newAlphaType != bm.alphaType()) {
if (!bm.setAlphaType(newAlphaType)) {
- ALOGE("incompatible return from postProcess: %i", pixelFormat);
- doThrowIAE(env);
+ SkString msg;
+ msg.printf("incompatible return from postProcess: %i", pixelFormat);
+ doThrowIAE(env, msg.c_str());
return nullptr;
}
nativeBitmap->setAlphaType(newAlphaType);
@@ -405,7 +470,8 @@
ninePatchChunk, ninePatchInsets);
}
if (allocator == ImageDecoder::kHardware_Allocator) {
- return nullObjectReturn("failed to allocate hardware Bitmap!");
+ doThrowOOME(env, "failed to allocate hardware Bitmap!");
+ return nullptr;
}
// If we failed to create a hardware bitmap, go ahead and create a
// software one.
@@ -430,19 +496,21 @@
decoder->mPeeker.getPadding(env, outPadding);
}
-static void ImageDecoder_nRecycle(JNIEnv* /*env*/, jobject /*clazz*/, jlong nativePtr) {
+static void ImageDecoder_nClose(JNIEnv* /*env*/, jobject /*clazz*/, jlong nativePtr) {
delete reinterpret_cast<ImageDecoder*>(nativePtr);
}
static const JNINativeMethod gImageDecoderMethods[] = {
- { "nCreate", "(J)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreate },
+ { "nCreate", "(J)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateAsset },
{ "nCreate", "(Ljava/nio/ByteBuffer;II)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateByteBuffer },
{ "nCreate", "([BII)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateByteArray },
+ { "nCreate", "(Ljava/io/InputStream;[B)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateInputStream },
+ { "nCreate", "(Ljava/io/FileDescriptor;)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateFd },
{ "nDecodeBitmap", "(JLandroid/graphics/ImageDecoder$OnExceptionListener;Landroid/graphics/PostProcess;IILandroid/graphics/Rect;ZIZZZ)Landroid/graphics/Bitmap;",
(void*) ImageDecoder_nDecodeBitmap },
{ "nGetSampledSize","(JI)Landroid/graphics/Point;", (void*) ImageDecoder_nGetSampledSize },
{ "nGetPadding", "(JLandroid/graphics/Rect;)V", (void*) ImageDecoder_nGetPadding },
- { "nRecycle", "(J)V", (void*) ImageDecoder_nRecycle},
+ { "nClose", "(J)V", (void*) ImageDecoder_nClose},
};
int register_android_graphics_ImageDecoder(JNIEnv* env) {
@@ -459,7 +527,7 @@
gCorrupt_constructorMethodID = GetMethodIDOrDie(env, gCorrupt_class, "<init>", "()V");
jclass callback_class = FindClassOrDie(env, "android/graphics/ImageDecoder$OnExceptionListener");
- gCallback_onExceptionMethodID = GetMethodIDOrDie(env, callback_class, "onException", "(Ljava/lang/Exception;)Z");
+ gCallback_onExceptionMethodID = GetMethodIDOrDie(env, callback_class, "onException", "(Ljava/io/IOException;)Z");
jclass postProcess_class = FindClassOrDie(env, "android/graphics/PostProcess");
gPostProcess_postProcessMethodID = GetMethodIDOrDie(env, postProcess_class, "postProcess", "(Landroid/graphics/Canvas;II)I");
diff --git a/core/proto/android/app/activitymanager.proto b/core/proto/android/app/activitymanager.proto
index 7385050..3412a32 100644
--- a/core/proto/android/app/activitymanager.proto
+++ b/core/proto/android/app/activitymanager.proto
@@ -38,29 +38,29 @@
PROCESS_STATE_BOUND_FOREGROUND_SERVICE = 300;
// Process is hosting a foreground service.
PROCESS_STATE_FOREGROUND_SERVICE = 400;
- // Same as PROCESS_STATE_TOP but while device is sleeping.
- PROCESS_STATE_TOP_SLEEPING = 500;
// Process is important to the user, and something they are aware of.
- PROCESS_STATE_IMPORTANT_FOREGROUND = 600;
+ PROCESS_STATE_IMPORTANT_FOREGROUND = 500;
// Process is important to the user, but not something they are aware of.
- PROCESS_STATE_IMPORTANT_BACKGROUND = 700;
+ PROCESS_STATE_IMPORTANT_BACKGROUND = 600;
// Process is in the background transient so we will try to keep running.
- PROCESS_STATE_TRANSIENT_BACKGROUND = 800;
+ PROCESS_STATE_TRANSIENT_BACKGROUND = 700;
// Process is in the background running a backup/restore operation.
- PROCESS_STATE_BACKUP = 900;
- // Process is in the background, but it can't restore its state so we want
- // to try to avoid killing it.
- PROCESS_STATE_HEAVY_WEIGHT = 1000;
+ PROCESS_STATE_BACKUP = 800;
// Process is in the background running a service. Unlike oom_adj, this
// level is used for both the normal running in background state and the
// executing operations state.
- PROCESS_STATE_SERVICE = 1100;
+ PROCESS_STATE_SERVICE = 900;
// Process is in the background running a receiver. Note that from the
// perspective of oom_adj, receivers run at a higher foreground level, but
// for our prioritization here that is not necessary and putting them
// below services means many fewer changes in some process states as they
// receive broadcasts.
- PROCESS_STATE_RECEIVER = 1200;
+ PROCESS_STATE_RECEIVER = 1000;
+ // Same as PROCESS_STATE_TOP but while device is sleeping.
+ PROCESS_STATE_TOP_SLEEPING = 1100;
+ // Process is in the background, but it can't restore its state so we want
+ // to try to avoid killing it.
+ PROCESS_STATE_HEAVY_WEIGHT = 1200;
// Process is in the background but hosts the home activity.
PROCESS_STATE_HOME = 1300;
// Process is in the background but hosts the last shown activity.
@@ -70,9 +70,12 @@
// Process is being cached for later use and is a client of another cached
// process that contains activities.
PROCESS_STATE_CACHED_ACTIVITY_CLIENT = 1600;
+ // Process is being cached for later use and has an activity that corresponds
+ // to an existing recent task.
+ PROCESS_STATE_CACHED_RECENT = 1700;
// Process is being cached for later use and is empty.
- PROCESS_STATE_CACHED_EMPTY = 1700;
+ PROCESS_STATE_CACHED_EMPTY = 1800;
// Process does not exist.
- PROCESS_STATE_NONEXISTENT = 1800;
+ PROCESS_STATE_NONEXISTENT = 1900;
}
diff --git a/core/proto/android/os/incident.proto b/core/proto/android/os/incident.proto
index a6db31f..2f856ab 100644
--- a/core/proto/android/os/incident.proto
+++ b/core/proto/android/os/incident.proto
@@ -43,6 +43,8 @@
import "frameworks/base/core/proto/android/service/package.proto";
import "frameworks/base/core/proto/android/service/print.proto";
import "frameworks/base/core/proto/android/service/procstats.proto";
+import "frameworks/base/core/proto/android/util/event_log_tags.proto";
+import "frameworks/base/core/proto/android/util/log.proto";
import "frameworks/base/libs/incident/proto/android/privacy.proto";
import "frameworks/base/libs/incident/proto/android/section.proto";
@@ -59,6 +61,8 @@
// the sections are able to be controlled and configured by section ids.
// Instead privacy field options need to be configured in each section proto message.
message IncidentProto {
+ reserved 1001;
+
// Incident header from callers
repeated IncidentHeaderProto header = 1;
// Internal metadata of incidentd
@@ -70,6 +74,52 @@
(section).args = "getprop"
];
+ // Device Logs
+ optional android.util.EventLogTagMapProto event_log_tag_map = 1100 [
+ (section).type = SECTION_FILE,
+ (section).args = "/system/etc/event-log-tags"
+ ];
+
+ optional android.util.LogProto main_logs = 1101 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_MAIN"
+ ];
+
+ optional android.util.LogProto radio_logs = 1102 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_RADIO"
+ ];
+
+ optional android.util.LogProto events_logs = 1103 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_EVENTS"
+ ];
+
+ optional android.util.LogProto system_logs = 1104 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_SYSTEM"
+ ];
+
+ optional android.util.LogProto crash_logs = 1105 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_CRASH"
+ ];
+
+ optional android.util.LogProto stats_logs = 1106 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_STATS"
+ ];
+
+ optional android.util.LogProto security_logs = 1107 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_SECURITY"
+ ];
+
+ optional android.util.LogProto kernel_logs = 1108 [
+ (section).type = SECTION_LOG,
+ (section).args = "LOG_ID_KERNEL"
+ ];
+
// Linux services
optional Procrank procrank = 2000 [
(section).type = SECTION_COMMAND,
@@ -196,4 +246,5 @@
(section).type = SECTION_DUMPSYS,
(section).args = "graphicsstats --proto"
];
+
}
diff --git a/core/proto/android/providers/settings.proto b/core/proto/android/providers/settings.proto
index fb0ebed..f5d098c 100644
--- a/core/proto/android/providers/settings.proto
+++ b/core/proto/android/providers/settings.proto
@@ -582,7 +582,7 @@
optional SettingProto downloads_backup_charging_only = 162;
optional SettingProto automatic_storage_manager_downloads_days_to_retain = 163;
optional SettingProto qs_tiles = 164;
- optional SettingProto demo_user_setup_complete = 165;
+ reserved 165; // Removed demo_user_setup_complete
optional SettingProto instant_apps_enabled = 166;
optional SettingProto device_paired = 167;
optional SettingProto package_verifier_state = 191;
diff --git a/core/proto/android/util/event_log_tags.proto b/core/proto/android/util/event_log_tags.proto
new file mode 100644
index 0000000..cb039be
--- /dev/null
+++ b/core/proto/android/util/event_log_tags.proto
@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+syntax = "proto2";
+package android.util;
+
+option java_multiple_files = true;
+
+// Proto representation of event.logtags.
+// Usually sit in /system/etc/event-log-tags.
+message EventLogTagMapProto {
+ repeated EventLogTag event_log_tags = 1;
+}
+
+message EventLogTag {
+ optional uint32 tag_number = 1; // keyed by tag number.
+ optional string tag_name = 2;
+
+ message ValueDescriptor {
+ optional string name = 1;
+
+ enum DataType {
+ UNKNOWN = 0;
+ INT = 1;
+ LONG = 2;
+ STRING = 3;
+ LIST = 4;
+ FLOAT = 5;
+ }
+ optional DataType type = 2;
+
+ enum DataUnit {
+ UNSET = 0; // this field is optional, so default is unset
+ OBJECTS = 1; // Number of objects
+ BYTES = 2; // Number of bytes (default for type of int/long)
+ MILLISECONDS = 3; // Number of milliseconds
+ ALLOCATIONS = 4; // Number of allocations
+ ID = 5; // Id
+ PERCENT = 6; // Percent
+ SECONDS = 115; // 's', Number of seconds (monotonic time)
+ }
+ optional DataUnit unit = 3;
+ }
+ repeated ValueDescriptor value_descriptors = 3;
+}
\ No newline at end of file
diff --git a/core/proto/android/util/log.proto b/core/proto/android/util/log.proto
new file mode 100644
index 0000000..30ff412
--- /dev/null
+++ b/core/proto/android/util/log.proto
@@ -0,0 +1,88 @@
+/*
+ * 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.
+ */
+
+syntax = "proto2";
+package android.util;
+
+option java_multiple_files = true;
+
+// Represents a Text Log in logd
+// Next Tag: 9
+message TextLogEntry {
+ optional uint64 sec = 1;
+ optional uint64 nanosec = 2;
+
+ enum LogPriority {
+ LOG_UNKNOWN = 0;
+ LOG_DEFAULT = 1;
+ LOG_VERBOSE = 2;
+ LOG_DEBUG = 3;
+ LOG_INFO = 4;
+ LOG_WARN = 5;
+ LOG_ERROR = 6;
+ LOG_FATAL = 7;
+ LOG_SILENT = 8;
+ }
+ optional LogPriority priority = 3;
+ optional int32 uid = 4;
+ optional int32 pid = 5;
+ optional int32 tid = 6;
+ optional string tag = 7;
+ optional string log = 8;
+}
+
+// Represents a Binary Log in logd, need to look event-log-tags for more info.
+// Next Tag: 8
+message BinaryLogEntry {
+ optional uint64 sec = 1;
+ optional uint64 nanosec = 2;
+ optional int32 uid = 3;
+ optional int32 pid = 4;
+ optional int32 tid = 5;
+
+ // Index of the event tag, can look up in event-log-tags file
+ optional uint32 tag_index = 6;
+
+ message Elem {
+ // must be sync with liblog log/log.h
+ enum Type {
+ EVENT_TYPE_LIST_STOP = 10; // '\n'
+ EVENT_TYPE_UNKNOWN = 63; // '?'
+
+ EVENT_TYPE_INT = 0;
+ EVENT_TYPE_LONG = 1;
+ EVENT_TYPE_STRING = 2;
+ EVENT_TYPE_LIST = 3;
+ EVENT_TYPE_FLOAT = 4;
+ }
+ optional Type type = 1 [default=EVENT_TYPE_UNKNOWN];
+
+ oneof value {
+ int32 val_int32 = 2;
+ int64 val_int64 = 3;
+ string val_string = 4;
+ float val_float = 5;
+ }
+ }
+ repeated Elem elems = 7;
+}
+
+message LogProto {
+ repeated TextLogEntry text_logs = 1;
+
+ repeated BinaryLogEntry binary_logs = 2;
+}
+
diff --git a/core/res/AndroidManifest.xml b/core/res/AndroidManifest.xml
index 52bfcde..3a6b2de 100644
--- a/core/res/AndroidManifest.xml
+++ b/core/res/AndroidManifest.xml
@@ -159,6 +159,8 @@
<protected-broadcast
android:name="android.bluetooth.headset.action.HF_INDICATORS_VALUE_CHANGED" />
<protected-broadcast
+ android:name="android.bluetooth.headset.profile.action.ACTIVE_DEVICE_CHANGED" />
+ <protected-broadcast
android:name="android.bluetooth.headsetclient.profile.action.CONNECTION_STATE_CHANGED" />
<protected-broadcast
android:name="android.bluetooth.headsetclient.profile.action.AUDIO_STATE_CHANGED" />
@@ -173,6 +175,8 @@
<protected-broadcast
android:name="android.bluetooth.a2dp.profile.action.CONNECTION_STATE_CHANGED" />
<protected-broadcast
+ android:name="android.bluetooth.a2dp.profile.action.ACTIVE_DEVICE_CHANGED" />
+ <protected-broadcast
android:name="android.bluetooth.a2dp.profile.action.PLAYING_STATE_CHANGED" />
<protected-broadcast
android:name="android.bluetooth.a2dp.profile.action.CODEC_CONFIG_CHANGED" />
@@ -3125,6 +3129,12 @@
<permission android:name="android.permission.BACKUP"
android:protectionLevel="signature|privileged" />
+ <!-- @SystemApi Allows application to manage RecoverableKeyStoreLoader.
+ <p>Not for use by third-party applications.
+ @hide -->
+ <permission android:name="android.permission.RECOVER_KEYSTORE"
+ android:protectionLevel="signature|privileged" />
+
<!-- Allows a package to launch the secure full-backup confirmation UI.
ONLY the system process may hold this permission.
@hide -->
@@ -3918,6 +3928,14 @@
</intent-filter>
</receiver>
+ <receiver android:name="com.android.server.updates.CarrierIdInstallReceiver"
+ android:permission="android.permission.UPDATE_CONFIG">
+ <intent-filter>
+ <action android:name="com.android.internal.intent.action.UPDATE_CARRIER_ID_DB" />
+ <data android:scheme="content" android:host="*" android:mimeType="*/*" />
+ </intent-filter>
+ </receiver>
+
<receiver android:name="com.android.server.MasterClearReceiver"
android:permission="android.permission.MASTER_CLEAR">
<intent-filter
diff --git a/core/res/res/values/attrs.xml b/core/res/res/values/attrs.xml
index 1b3d6ce..ee7c795 100644
--- a/core/res/res/values/attrs.xml
+++ b/core/res/res/values/attrs.xml
@@ -4470,6 +4470,10 @@
<attr name="shadowRadius" format="float" />
<!-- Elegant text height, especially for less compacted complex script text. -->
<attr name="elegantTextHeight" format="boolean" />
+ <!-- Whether to respect the ascent and descent of the fallback fonts that are used in
+ displaying the text. When true, fallback fonts that end up getting used can increase
+ the ascent and descent of the lines that they are used on. -->
+ <attr name="fallbackLineSpacing" format="boolean"/>
<!-- Text letter-spacing. -->
<attr name="letterSpacing" format="float" />
<!-- Font feature settings. -->
@@ -4803,6 +4807,10 @@
<attr name="textAllCaps" />
<!-- Elegant text height, especially for less compacted complex script text. -->
<attr name="elegantTextHeight" />
+ <!-- Whether to respect the ascent and descent of the fallback fonts that are used in
+ displaying the text. When true, fallback fonts that end up getting used can increase
+ the ascent and descent of the lines that they are used on. -->
+ <attr name="fallbackLineSpacing" format="boolean"/>
<!-- Text letter-spacing. -->
<attr name="letterSpacing" />
<!-- Font feature settings. -->
diff --git a/core/res/res/values/config.xml b/core/res/res/values/config.xml
index fd05bb4..d2685cf 100644
--- a/core/res/res/values/config.xml
+++ b/core/res/res/values/config.xml
@@ -2784,7 +2784,7 @@
<bool name="config_eap_sim_based_auth_supported">true</bool>
<!-- How long history of previous vibrations should be kept for the dumpsys. -->
- <integer name="config_previousVibrationsDumpLimit">20</integer>
+ <integer name="config_previousVibrationsDumpLimit">50</integer>
<!-- The default vibration strength, must be between 1 and 255 inclusive. -->
<integer name="config_defaultVibrationAmplitude">255</integer>
diff --git a/core/res/res/values/disallowed_apps_managed_device.xml b/core/res/res/values/disallowed_apps_managed_device.xml
index 8940b15..3fb9ba4 100644
--- a/core/res/res/values/disallowed_apps_managed_device.xml
+++ b/core/res/res/values/disallowed_apps_managed_device.xml
@@ -18,6 +18,6 @@
-->
<resources>
<!-- A list of apps to be removed from the managed device. -->
- <string-array name="disallowed_apps_managed_device">
+ <string-array translatable="false" name="disallowed_apps_managed_device">
</string-array>
</resources>
diff --git a/core/res/res/values/disallowed_apps_managed_profile.xml b/core/res/res/values/disallowed_apps_managed_profile.xml
index e3a513f..c3ea8ec 100644
--- a/core/res/res/values/disallowed_apps_managed_profile.xml
+++ b/core/res/res/values/disallowed_apps_managed_profile.xml
@@ -18,6 +18,6 @@
-->
<resources>
<!-- A list of apps to be removed from the managed profile. -->
- <string-array name="disallowed_apps_managed_profile">
+ <string-array translatable="false" name="disallowed_apps_managed_profile">
</string-array>
</resources>
diff --git a/core/res/res/values/disallowed_apps_managed_user.xml b/core/res/res/values/disallowed_apps_managed_user.xml
index b7b645d..e5b29afe 100644
--- a/core/res/res/values/disallowed_apps_managed_user.xml
+++ b/core/res/res/values/disallowed_apps_managed_user.xml
@@ -18,6 +18,6 @@
-->
<resources>
<!-- A list of apps to be removed from the managed user. -->
- <string-array name="disallowed_apps_managed_user">
+ <string-array translatable="false" name="disallowed_apps_managed_user">
</string-array>
</resources>
diff --git a/core/res/res/values/public.xml b/core/res/res/values/public.xml
index 8540ff1..6ec88dc 100644
--- a/core/res/res/values/public.xml
+++ b/core/res/res/values/public.xml
@@ -2860,6 +2860,7 @@
<public name="isVrOnly"/>
<public name="widgetFeatures" />
<public name="appComponentFactory" />
+ <public name="fallbackLineSpacing" />
</public-group>
<public-group type="style" first-id="0x010302e0">
diff --git a/core/res/res/values/required_apps_managed_device.xml b/core/res/res/values/required_apps_managed_device.xml
index 0ac706f..40db9df 100644
--- a/core/res/res/values/required_apps_managed_device.xml
+++ b/core/res/res/values/required_apps_managed_device.xml
@@ -19,7 +19,7 @@
<resources>
<!-- A list of apps to be retained on the managed device.
Takes precedence over the disallowed apps lists. -->
- <string-array name="required_apps_managed_device">
+ <string-array translatable="false" name="required_apps_managed_device">
<item>com.android.settings</item>
<item>com.android.contacts</item>
<item>com.android.dialer</item>
diff --git a/core/res/res/values/required_apps_managed_profile.xml b/core/res/res/values/required_apps_managed_profile.xml
index a0b8492..c6b37e8 100644
--- a/core/res/res/values/required_apps_managed_profile.xml
+++ b/core/res/res/values/required_apps_managed_profile.xml
@@ -19,7 +19,7 @@
<resources>
<!-- A list of apps to be retained in the managed profile.
Takes precedence over the disallowed apps lists. -->
- <string-array name="required_apps_managed_profile">
+ <string-array translatable="false" name="required_apps_managed_profile">
<item>com.android.contacts</item>
<item>com.android.settings</item>
<item>com.android.providers.downloads</item>
diff --git a/core/res/res/values/required_apps_managed_user.xml b/core/res/res/values/required_apps_managed_user.xml
index e8fdb21..8800e535 100644
--- a/core/res/res/values/required_apps_managed_user.xml
+++ b/core/res/res/values/required_apps_managed_user.xml
@@ -19,7 +19,7 @@
<resources>
<!-- A list of apps to be retained on the managed user.
Takes precedence over the disallowed apps lists. -->
- <string-array name="required_apps_managed_user">
+ <string-array translatable="false" name="required_apps_managed_user">
<item>com.android.settings</item>
<item>com.android.contacts</item>
<item>com.android.dialer</item>
diff --git a/core/res/res/values/vendor_disallowed_apps_managed_device.xml b/core/res/res/values/vendor_disallowed_apps_managed_device.xml
index c826d27..493cd60 100644
--- a/core/res/res/values/vendor_disallowed_apps_managed_device.xml
+++ b/core/res/res/values/vendor_disallowed_apps_managed_device.xml
@@ -18,6 +18,6 @@
-->
<resources>
<!-- A list of apps to be removed from the managed device by a particular vendor. -->
- <string-array name="vendor_disallowed_apps_managed_device">
+ <string-array translatable="false" name="vendor_disallowed_apps_managed_device">
</string-array>
</resources>
diff --git a/core/res/res/values/vendor_disallowed_apps_managed_profile.xml b/core/res/res/values/vendor_disallowed_apps_managed_profile.xml
index 5fcb2778..84cab5f 100644
--- a/core/res/res/values/vendor_disallowed_apps_managed_profile.xml
+++ b/core/res/res/values/vendor_disallowed_apps_managed_profile.xml
@@ -18,6 +18,6 @@
-->
<resources>
<!-- A list of apps to be removed from the managed profile by a particular vendor. -->
- <string-array name="vendor_disallowed_apps_managed_profile">
+ <string-array translatable="false" name="vendor_disallowed_apps_managed_profile">
</string-array>
</resources>
diff --git a/core/res/res/values/vendor_disallowed_apps_managed_user.xml b/core/res/res/values/vendor_disallowed_apps_managed_user.xml
index 3355d77..975bb5d 100644
--- a/core/res/res/values/vendor_disallowed_apps_managed_user.xml
+++ b/core/res/res/values/vendor_disallowed_apps_managed_user.xml
@@ -18,6 +18,6 @@
-->
<resources>
<!-- A list of apps to be removed from the managed user by a particular vendor. -->
- <string-array name="vendor_disallowed_apps_managed_user">
+ <string-array translatable="false" name="vendor_disallowed_apps_managed_user">
</string-array>
</resources>
diff --git a/core/res/res/values/vendor_required_apps_managed_device.xml b/core/res/res/values/vendor_required_apps_managed_device.xml
index e684e22..1ef48db 100644
--- a/core/res/res/values/vendor_required_apps_managed_device.xml
+++ b/core/res/res/values/vendor_required_apps_managed_device.xml
@@ -19,6 +19,6 @@
<resources>
<!-- A list of apps to be retained on the managed device by a particular vendor.
Takes precedence over the disallowed apps lists. -->
- <string-array name="vendor_required_apps_managed_device">
+ <string-array translatable="false" name="vendor_required_apps_managed_device">
</string-array>
</resources>
diff --git a/core/res/res/values/vendor_required_apps_managed_profile.xml b/core/res/res/values/vendor_required_apps_managed_profile.xml
index 4a3edf8..49cfa8b 100644
--- a/core/res/res/values/vendor_required_apps_managed_profile.xml
+++ b/core/res/res/values/vendor_required_apps_managed_profile.xml
@@ -19,6 +19,6 @@
<resources>
<!-- A list of apps to be retained in the managed profile by a particular vendor.
Takes precedence over the disallowed apps lists. -->
- <string-array name="vendor_required_apps_managed_profile">
+ <string-array translatable="false" name="vendor_required_apps_managed_profile">
</string-array>
</resources>
diff --git a/core/res/res/values/vendor_required_apps_managed_user.xml b/core/res/res/values/vendor_required_apps_managed_user.xml
index 71dbd62..bad7803 100644
--- a/core/res/res/values/vendor_required_apps_managed_user.xml
+++ b/core/res/res/values/vendor_required_apps_managed_user.xml
@@ -19,6 +19,6 @@
<resources>
<!-- A list of apps to be retained on the managed user by a particular vendor.
Takes precedence over the disallowed apps lists. -->
- <string-array name="vendor_required_apps_managed_user">
+ <string-array translatable="false" name="vendor_required_apps_managed_user">
</string-array>
</resources>
diff --git a/core/tests/BroadcastRadioTests/src/android/hardware/radio/tests/functional/RadioTunerTest.java b/core/tests/BroadcastRadioTests/src/android/hardware/radio/tests/functional/RadioTunerTest.java
index a8d5164..896fd15 100644
--- a/core/tests/BroadcastRadioTests/src/android/hardware/radio/tests/functional/RadioTunerTest.java
+++ b/core/tests/BroadcastRadioTests/src/android/hardware/radio/tests/functional/RadioTunerTest.java
@@ -149,6 +149,10 @@
mRadioTuner = mRadioManager.openTuner(mModule.getId(),
mFmBandConfig, withAudio, mCallback, null);
+ if (!withAudio) {
+ // non-audio sessions might not be supported - if so, then skip the test
+ assumeNotNull(mRadioTuner);
+ }
assertNotNull(mRadioTuner);
verify(mCallback, timeout(kConfigCallbackTimeoutMs)).onConfigurationChanged(any());
resetCallback();
@@ -207,20 +211,8 @@
public void testSetBadConfiguration() throws Throwable {
openTuner();
- // set bad config
- Constructor<RadioManager.AmBandConfig> configConstr =
- RadioManager.AmBandConfig.class.getDeclaredConstructor(
- int.class, int.class, int.class, int.class, int.class, boolean.class);
- configConstr.setAccessible(true);
- RadioManager.AmBandConfig badConfig = configConstr.newInstance(
- 0 /*region*/, RadioManager.BAND_AM /*type*/,
- 10000 /*lowerLimit*/, 1 /*upperLimit*/, 100 /*spacing*/, false /*stereo*/);
- int ret = mRadioTuner.setConfiguration(badConfig);
- assertEquals(RadioManager.STATUS_BAD_VALUE, ret);
- verify(mCallback, never()).onConfigurationChanged(any());
-
// set null config
- ret = mRadioTuner.setConfiguration(null);
+ int ret = mRadioTuner.setConfiguration(null);
assertEquals(RadioManager.STATUS_BAD_VALUE, ret);
verify(mCallback, never()).onConfigurationChanged(any());
diff --git a/core/tests/coretests/src/android/app/NotificationTest.java b/core/tests/coretests/src/android/app/NotificationTest.java
index 7183934..b51c677 100644
--- a/core/tests/coretests/src/android/app/NotificationTest.java
+++ b/core/tests/coretests/src/android/app/NotificationTest.java
@@ -28,6 +28,7 @@
import android.graphics.BitmapFactory;
import android.graphics.drawable.Icon;
import android.media.session.MediaSession;
+import android.os.Build;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.test.InstrumentationRegistry;
@@ -215,9 +216,11 @@
}
@Test
- public void testMessagingStyle_isGroupConversation() {
+ public void messagingStyle_isGroupConversation() {
+ mContext.getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.P;
Notification.MessagingStyle messagingStyle = new Notification.MessagingStyle("self name")
- .setGroupConversation(true);
+ .setGroupConversation(true)
+ .setConversationTitle("test conversation title");
Notification notification = new Notification.Builder(mContext, "test id")
.setSmallIcon(1)
.setContentTitle("test title")
@@ -228,6 +231,56 @@
assertTrue(notification.extras.getBoolean(Notification.EXTRA_IS_GROUP_CONVERSATION));
}
+ @Test
+ public void messagingStyle_isGroupConversation_noConversationTitle() {
+ mContext.getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.P;
+ Notification.MessagingStyle messagingStyle = new Notification.MessagingStyle("self name")
+ .setGroupConversation(true)
+ .setConversationTitle(null);
+ Notification notification = new Notification.Builder(mContext, "test id")
+ .setSmallIcon(1)
+ .setContentTitle("test title")
+ .setStyle(messagingStyle)
+ .build();
+
+ assertTrue(messagingStyle.isGroupConversation());
+ assertTrue(notification.extras.getBoolean(Notification.EXTRA_IS_GROUP_CONVERSATION));
+ }
+
+ @Test
+ public void messagingStyle_isGroupConversation_withConversationTitle_legacy() {
+ // In legacy (version < P), isGroupConversation is controlled by conversationTitle.
+ mContext.getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.O;
+ Notification.MessagingStyle messagingStyle = new Notification.MessagingStyle("self name")
+ .setGroupConversation(false)
+ .setConversationTitle("test conversation title");
+ Notification notification = new Notification.Builder(mContext, "test id")
+ .setSmallIcon(1)
+ .setContentTitle("test title")
+ .setStyle(messagingStyle)
+ .build();
+
+ assertTrue(messagingStyle.isGroupConversation());
+ assertFalse(notification.extras.getBoolean(Notification.EXTRA_IS_GROUP_CONVERSATION));
+ }
+
+ @Test
+ public void messagingStyle_isGroupConversation_withoutConversationTitle_legacy() {
+ // In legacy (version < P), isGroupConversation is controlled by conversationTitle.
+ mContext.getApplicationInfo().targetSdkVersion = Build.VERSION_CODES.O;
+ Notification.MessagingStyle messagingStyle = new Notification.MessagingStyle("self name")
+ .setGroupConversation(true)
+ .setConversationTitle(null);
+ Notification notification = new Notification.Builder(mContext, "test id")
+ .setSmallIcon(1)
+ .setContentTitle("test title")
+ .setStyle(messagingStyle)
+ .build();
+
+ assertFalse(messagingStyle.isGroupConversation());
+ assertTrue(notification.extras.getBoolean(Notification.EXTRA_IS_GROUP_CONVERSATION));
+ }
+
private Notification.Builder getMediaNotification() {
MediaSession session = new MediaSession(mContext, "test");
return new Notification.Builder(mContext, "color")
diff --git a/core/tests/coretests/src/android/content/pm/PackageBackwardCompatibilityTest.java b/core/tests/coretests/src/android/content/pm/PackageBackwardCompatibilityTest.java
index 1a54bd6..63a5e4c 100644
--- a/core/tests/coretests/src/android/content/pm/PackageBackwardCompatibilityTest.java
+++ b/core/tests/coretests/src/android/content/pm/PackageBackwardCompatibilityTest.java
@@ -41,6 +41,8 @@
private static final String ANDROID_TEST_MOCK = "android.test.mock";
+ private static final String OTHER_LIBRARY = "other.library";
+
private Package mPackage;
private static ArrayList<String> arrayList(String... strings) {
@@ -78,6 +80,18 @@
}
@Test
+ public void targeted_at_O_not_empty_usesLibraries() {
+ mPackage.applicationInfo.targetSdkVersion = Build.VERSION_CODES.O;
+ mPackage.usesLibraries = arrayList(OTHER_LIBRARY);
+ PackageBackwardCompatibility.modifySharedLibraries(mPackage);
+ // The org.apache.http.legacy jar should be added at the start of the list.
+ assertEquals("usesLibraries not updated correctly",
+ arrayList(ORG_APACHE_HTTP_LEGACY, OTHER_LIBRARY),
+ mPackage.usesLibraries);
+ assertNull("usesOptionalLibraries not updated correctly", mPackage.usesOptionalLibraries);
+ }
+
+ @Test
public void targeted_at_O_org_apache_http_legacy_in_usesLibraries() {
mPackage.applicationInfo.targetSdkVersion = Build.VERSION_CODES.O;
mPackage.usesLibraries = arrayList(ORG_APACHE_HTTP_LEGACY);
diff --git a/core/tests/coretests/src/android/os/WorkSourceTest.java b/core/tests/coretests/src/android/os/WorkSourceTest.java
index 90b4575..566ac4d 100644
--- a/core/tests/coretests/src/android/os/WorkSourceTest.java
+++ b/core/tests/coretests/src/android/os/WorkSourceTest.java
@@ -331,4 +331,24 @@
wc.addNode(200, "tag2");
assertEquals(100, wc.getAttributionUid());
}
+
+ public void testRemove_fromChainedWorkSource() {
+ WorkSource ws1 = new WorkSource();
+ ws1.createWorkChain().addNode(50, "foo");
+ ws1.createWorkChain().addNode(75, "bar");
+ ws1.add(100);
+
+ WorkSource ws2 = new WorkSource();
+ ws2.add(100);
+
+ assertTrue(ws1.remove(ws2));
+ assertEquals(2, ws1.getWorkChains().size());
+ assertEquals(50, ws1.getWorkChains().get(0).getAttributionUid());
+ assertEquals(75, ws1.getWorkChains().get(1).getAttributionUid());
+
+ ws2.createWorkChain().addNode(50, "foo");
+ assertTrue(ws1.remove(ws2));
+ assertEquals(1, ws1.getWorkChains().size());
+ assertEquals(75, ws1.getWorkChains().get(0).getAttributionUid());
+ }
}
diff --git a/core/tests/coretests/src/android/provider/SettingsBackupTest.java b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
index fc86500..7cfedc8 100644
--- a/core/tests/coretests/src/android/provider/SettingsBackupTest.java
+++ b/core/tests/coretests/src/android/provider/SettingsBackupTest.java
@@ -112,6 +112,7 @@
Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD,
Settings.Global.BATTERY_DISCHARGE_THRESHOLD,
Settings.Global.BATTERY_SAVER_DEVICE_SPECIFIC_CONSTANTS,
+ Settings.Global.BATTERY_STATS_CONSTANTS,
Settings.Global.BLE_SCAN_ALWAYS_AVAILABLE,
Settings.Global.BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX,
Settings.Global.BLUETOOTH_A2DP_SRC_PRIORITY_PREFIX,
@@ -281,6 +282,7 @@
Settings.Global.NETWORK_SCORING_UI_ENABLED,
Settings.Global.NETWORK_SWITCH_NOTIFICATION_DAILY_LIMIT,
Settings.Global.NETWORK_SWITCH_NOTIFICATION_RATE_LIMIT_MILLIS,
+ Settings.Global.NETWORK_WATCHLIST_ENABLED,
Settings.Global.NEW_CONTACT_AGGREGATOR,
Settings.Global.NITZ_UPDATE_DIFF,
Settings.Global.NITZ_UPDATE_SPACING,
@@ -452,7 +454,6 @@
Settings.Secure.COMPLETED_CATEGORY_PREFIX,
Settings.Secure.CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS,
Settings.Secure.DEFAULT_INPUT_METHOD,
- Settings.Secure.DEMO_USER_SETUP_COMPLETE,
Settings.Secure.DEVICE_PAIRED,
Settings.Secure.DIALER_DEFAULT_APPLICATION,
Settings.Secure.DISABLED_PRINT_SERVICES,
diff --git a/core/tests/coretests/src/android/util/DataUnitTest.java b/core/tests/coretests/src/android/util/DataUnitTest.java
new file mode 100644
index 0000000..4eae8b4
--- /dev/null
+++ b/core/tests/coretests/src/android/util/DataUnitTest.java
@@ -0,0 +1,36 @@
+/*
+ * 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.util;
+
+import android.support.test.filters.SmallTest;
+
+import junit.framework.TestCase;
+
+@SmallTest
+public class DataUnitTest extends TestCase {
+ public void testSi() throws Exception {
+ assertEquals(12_000L, DataUnit.KILOBYTES.toBytes(12));
+ assertEquals(12_000_000L, DataUnit.MEGABYTES.toBytes(12));
+ assertEquals(12_000_000_000L, DataUnit.GIGABYTES.toBytes(12));
+ }
+
+ public void testIec() throws Exception {
+ assertEquals(12_288L, DataUnit.KIBIBYTES.toBytes(12));
+ assertEquals(12_582_912L, DataUnit.MEBIBYTES.toBytes(12));
+ assertEquals(12_884_901_888L, DataUnit.GIBIBYTES.toBytes(12));
+ }
+}
diff --git a/core/tests/coretests/src/android/widget/TextViewFallbackLineSpacingTest.java b/core/tests/coretests/src/android/widget/TextViewFallbackLineSpacingTest.java
new file mode 100644
index 0000000..e9d1d3e
--- /dev/null
+++ b/core/tests/coretests/src/android/widget/TextViewFallbackLineSpacingTest.java
@@ -0,0 +1,138 @@
+/*
+ * 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.widget;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import android.app.Activity;
+import android.support.test.filters.MediumTest;
+import android.support.test.rule.ActivityTestRule;
+import android.text.DynamicLayout;
+import android.text.FontFallbackSetup;
+import android.text.Layout;
+import android.text.StaticLayout;
+import android.util.TypedValue;
+import android.view.View;
+import android.widget.TextView.BufferType;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Parametrized test for TextView#setFallbackLineSpacing.
+ */
+@MediumTest
+@RunWith(Parameterized.class)
+public class TextViewFallbackLineSpacingTest {
+
+ @Parameterized.Parameters(name = "{0}")
+ public static Collection layouts() {
+ return Arrays.asList(new Object[][] {
+ // name, enabled, BufferType
+ { "Enabled - StaticLayout", true, BufferType.NORMAL},
+ { "Disabled - StaticLayout", false, BufferType.NORMAL},
+ { "Enabled - DynamicLayout", true, BufferType.EDITABLE},
+ { "Disabled - DynamicLayout", false, BufferType.EDITABLE},
+ });
+ }
+
+ @Rule
+ public ActivityTestRule<TextViewActivity> mActivityRule = new ActivityTestRule<>(
+ TextViewActivity.class);
+
+ private final boolean mEnabled;
+ private final BufferType mBufferType;
+
+ public TextViewFallbackLineSpacingTest(String testName, boolean enabled,
+ BufferType bufferType) {
+ mEnabled = enabled;
+ mBufferType = bufferType;
+ }
+
+ @Test
+ public void testFallbackLineSpacing() {
+ // All glyphs in the fonts are 1em wide.
+ final String[] testFontFiles = {
+ // ascent == 1em, descent == 2em, only supports 'a' and space
+ "ascent1em-descent2em.ttf",
+ // ascent == 3em, descent == 4em, only supports 'b'
+ "ascent3em-descent4em.ttf"
+ };
+ final String xml = "<?xml version='1.0' encoding='UTF-8'?>"
+ + "<familyset>"
+ + " <family name='sans-serif'>"
+ + " <font weight='400' style='normal'>ascent1em-descent2em.ttf</font>"
+ + " </family>"
+ + " <family>"
+ + " <font weight='400' style='normal'>ascent3em-descent4em.ttf</font>"
+ + " </family>"
+ + "</familyset>";
+
+ try (FontFallbackSetup setup =
+ new FontFallbackSetup("DynamicLayout", testFontFiles, xml)) {
+ final Activity activity = mActivityRule.getActivity();
+ final TextView textView = new TextView(activity);
+ textView.setTypeface(setup.getTypefaceFor("sans-serif"));
+ textView.setTextSize(TypedValue.COMPLEX_UNIT_PX, 100);
+ // This should result in three lines.
+ textView.setText("aaaaa aabaa aaaaa", mBufferType);
+ textView.setPadding(0, 0, 0, 0);
+ textView.setIncludeFontPadding(false);
+ textView.setFallbackLineSpacing(mEnabled);
+
+ final int em = (int) Math.ceil(textView.getPaint().measureText("a"));
+ final int width = 5 * em;
+ final int height = 30 * em; // tall enough to not affect our other measurements
+ textView.measure(
+ View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+ View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY));
+ textView.layout(0, 0, width, height);
+
+ final Layout layout = textView.getLayout();
+ assertNotNull(layout);
+ if (mBufferType == BufferType.NORMAL) {
+ assertTrue(layout instanceof StaticLayout);
+ } else {
+ assertTrue(layout instanceof DynamicLayout);
+ }
+ assertEquals(3, layout.getLineCount());
+
+ assertEquals(-em, layout.getLineAscent(0));
+ assertEquals(2 * em, layout.getLineDescent(0));
+
+ if (mEnabled) {
+ // The second line has a 'b', so it needs more ascent and descent.
+ assertEquals(-3 * em, layout.getLineAscent(1));
+ assertEquals(4 * em, layout.getLineDescent(1));
+ } else {
+ // old behavior
+ assertEquals(-em, layout.getLineAscent(1));
+ assertEquals(2 * em, layout.getLineDescent(1));
+ }
+
+ assertEquals(-em, layout.getLineAscent(2));
+ assertEquals(2 * em, layout.getLineDescent(2));
+ }
+ }
+}
diff --git a/core/tests/coretests/src/android/widget/TextViewTest.java b/core/tests/coretests/src/android/widget/TextViewTest.java
index 5dec42e..2b5b27b 100644
--- a/core/tests/coretests/src/android/widget/TextViewTest.java
+++ b/core/tests/coretests/src/android/widget/TextViewTest.java
@@ -30,12 +30,10 @@
import android.support.test.filters.MediumTest;
import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
-import android.text.FontFallbackSetup;
import android.text.GetChars;
import android.text.Layout;
import android.text.Selection;
import android.text.Spannable;
-import android.util.TypedValue;
import android.view.View;
import org.junit.Before;
@@ -251,56 +249,4 @@
}
return builder.toString();
}
-
- @Test
- public void testFallbackLineSpacing() {
- // All glyphs in the fonts are 1em wide.
- final String[] testFontFiles = {
- // ascent == 1em, descent == 2em, only supports 'a' and space
- "ascent1em-descent2em.ttf",
- // ascent == 3em, descent == 4em, only supports 'b'
- "ascent3em-descent4em.ttf"
- };
- final String xml = "<?xml version='1.0' encoding='UTF-8'?>"
- + "<familyset>"
- + " <family name='sans-serif'>"
- + " <font weight='400' style='normal'>ascent1em-descent2em.ttf</font>"
- + " </family>"
- + " <family>"
- + " <font weight='400' style='normal'>ascent3em-descent4em.ttf</font>"
- + " </family>"
- + "</familyset>";
-
- try (FontFallbackSetup setup =
- new FontFallbackSetup("DynamicLayout", testFontFiles, xml)) {
- mTextView = new TextView(mActivity);
- mTextView.setTypeface(setup.getTypefaceFor("sans-serif"));
- mTextView.setTextSize(TypedValue.COMPLEX_UNIT_PX, 100);
- mTextView.setText("aaaaa aabaa aaaaa"); // This should result in three lines.
- mTextView.setPadding(0, 0, 0, 0);
- mTextView.setIncludeFontPadding(false);
-
- final int em = (int) Math.ceil(mTextView.getPaint().measureText("a"));
- final int width = 5 * em;
- final int height = 30 * em; // tall enough to not affect our other measurements
- mTextView.measure(
- View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
- View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY));
- mTextView.layout(0, 0, width, height);
-
- final Layout layout = mTextView.getLayout();
- assertNotNull(layout);
- assertEquals(3, layout.getLineCount());
-
- assertEquals(-em, layout.getLineAscent(0));
- assertEquals(2 * em, layout.getLineDescent(0));
-
- // The second line has a 'b', so it needs more ascent and descent.
- assertEquals(-3 * em, layout.getLineAscent(1));
- assertEquals(4 * em, layout.getLineDescent(1));
-
- assertEquals(-em, layout.getLineAscent(2));
- assertEquals(2 * em, layout.getLineDescent(2));
- }
- }
}
diff --git a/core/tests/coretests/src/com/android/internal/os/BatteryStatsImplTest.java b/core/tests/coretests/src/com/android/internal/os/BatteryStatsImplTest.java
index 3794b5f..a8094ea 100644
--- a/core/tests/coretests/src/com/android/internal/os/BatteryStatsImplTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/BatteryStatsImplTest.java
@@ -71,7 +71,7 @@
@Test
public void testUpdateProcStateCpuTimes() {
mBatteryStatsImpl.setOnBatteryInternal(true);
- mBatteryStatsImpl.updateTimeBasesLocked(true, Display.STATE_ON, 0, 0);
+ mBatteryStatsImpl.updateTimeBasesLocked(false, Display.STATE_ON, 0, 0);
final int[] testUids = {10032, 10048, 10145, 10139};
final int[] testProcStates = {
@@ -98,7 +98,7 @@
}
}
- mBatteryStatsImpl.updateProcStateCpuTimes();
+ mBatteryStatsImpl.updateProcStateCpuTimes(true, false);
verifyNoPendingUids();
for (int i = 0; i < testUids.length; ++i) {
@@ -125,7 +125,7 @@
}
addPendingUids(testUids, testProcStates);
- mBatteryStatsImpl.updateProcStateCpuTimes();
+ mBatteryStatsImpl.updateProcStateCpuTimes(true, false);
verifyNoPendingUids();
for (int i = 0; i < testUids.length; ++i) {
@@ -157,7 +157,7 @@
}
addPendingUids(testUids, testProcStates);
- mBatteryStatsImpl.updateProcStateCpuTimes();
+ mBatteryStatsImpl.updateProcStateCpuTimes(true, true);
verifyNoPendingUids();
for (int i = 0; i < testUids.length; ++i) {
@@ -196,7 +196,7 @@
final long[] isolatedUidCpuTimes = {495784, 398473, 4895, 4905, 30984093};
when(mKernelSingleUidTimeReader.readDeltaMs(childUid)).thenReturn(isolatedUidCpuTimes);
- mBatteryStatsImpl.updateProcStateCpuTimes();
+ mBatteryStatsImpl.updateProcStateCpuTimes(true, true);
verifyNoPendingUids();
for (int i = 0; i < testUids.length; ++i) {
@@ -227,8 +227,8 @@
@Test
public void testCopyFromAllUidsCpuTimes() {
- mBatteryStatsImpl.setOnBatteryInternal(true);
- mBatteryStatsImpl.updateTimeBasesLocked(true, Display.STATE_ON, 0, 0);
+ mBatteryStatsImpl.setOnBatteryInternal(false);
+ mBatteryStatsImpl.updateTimeBasesLocked(false, Display.STATE_ON, 0, 0);
final int[] testUids = {10032, 10048, 10145, 10139};
final int[] testProcStates = {
@@ -264,7 +264,7 @@
.thenReturn(expectedCpuTimes[i]);
}
- mBatteryStatsImpl.copyFromAllUidsCpuTimes();
+ mBatteryStatsImpl.copyFromAllUidsCpuTimes(true, false);
verifyNoPendingUids();
for (int i = 0; i < testUids.length; ++i) {
diff --git a/core/tests/coretests/src/com/android/internal/os/BstatsCpuTimesValidationTest.java b/core/tests/coretests/src/com/android/internal/os/BstatsCpuTimesValidationTest.java
index e54fe7d..4d34721 100644
--- a/core/tests/coretests/src/com/android/internal/os/BstatsCpuTimesValidationTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/BstatsCpuTimesValidationTest.java
@@ -25,6 +25,8 @@
import static android.os.BatteryStats.Uid.PROCESS_STATE_TOP_SLEEPING;
import static android.os.BatteryStats.Uid.UID_PROCESS_TYPES;
+import static com.android.internal.os.BatteryStatsImpl.Constants.KEY_TRACK_CPU_TIMES_BY_PROC_STATE;
+
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import static junit.framework.Assert.assertTrue;
@@ -48,15 +50,19 @@
import android.os.PowerManager;
import android.os.Process;
import android.os.SystemClock;
+import android.provider.Settings;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.LargeTest;
import android.support.test.runner.AndroidJUnit4;
import android.support.test.uiautomator.UiDevice;
+import android.text.TextUtils;
import android.util.DebugUtils;
import android.util.Log;
import org.junit.BeforeClass;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TestName;
import org.junit.runner.RunWith;
import java.util.Arrays;
@@ -86,6 +92,9 @@
private static final int START_SERVICE_TIMEOUT_MS = 2000;
private static final int START_ISOLATED_SERVICE_TIMEOUT_MS = 2000;
+ private static final int SETTING_UPDATE_TIMEOUT_MS = 2000;
+ private static final int SETTING_UPDATE_CHECK_INTERVAL_MS = 200;
+
private static final int GENERAL_TIMEOUT_MS = 4000;
private static final int GENERAL_INTERVAL_MS = 200;
@@ -97,6 +106,8 @@
private static boolean sCpuFreqTimesAvailable;
private static boolean sPerProcStateTimesAvailable;
+ @Rule public TestName testName = new TestName();
+
@BeforeClass
public static void setupOnce() throws Exception {
sContext = InstrumentationRegistry.getContext();
@@ -123,6 +134,9 @@
@Test
public void testCpuFreqTimes() throws Exception {
if (!sCpuFreqTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -148,6 +162,9 @@
@Test
public void testCpuFreqTimes_screenOff() throws Exception {
if (!sCpuFreqTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -179,6 +196,9 @@
@Test
public void testCpuFreqTimes_isolatedProcess() throws Exception {
if (!sCpuFreqTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -204,6 +224,9 @@
@Test
public void testCpuFreqTimes_stateTop() throws Exception {
if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -234,6 +257,9 @@
@Test
public void testIsolatedCpuFreqTimes_stateService() throws Exception {
if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -272,6 +298,9 @@
@Test
public void testCpuFreqTimes_stateTopSleeping() throws Exception {
if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -302,6 +331,9 @@
@Test
public void testCpuFreqTimes_stateFgService() throws Exception {
if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -332,6 +364,9 @@
@Test
public void testCpuFreqTimes_stateFg() throws Exception {
if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -362,6 +397,9 @@
@Test
public void testCpuFreqTimes_stateBg() throws Exception {
if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -392,6 +430,9 @@
@Test
public void testCpuFreqTimes_stateCached() throws Exception {
if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
return;
}
@@ -419,6 +460,124 @@
batteryOffScreenOn();
}
+ @Test
+ public void testCpuFreqTimes_trackingDisabled() throws Exception {
+ if (!sCpuFreqTimesAvailable || !sPerProcStateTimesAvailable) {
+ Log.w(TAG, "Skipping " + testName.getMethodName()
+ + "; freqTimesAvailable=" + sCpuFreqTimesAvailable
+ + ", procStateTimesAvailable=" + sPerProcStateTimesAvailable);
+ return;
+ }
+
+ final String bstatsConstants = Settings.Global.getString(sContext.getContentResolver(),
+ Settings.Global.BATTERY_STATS_CONSTANTS);
+ try {
+ batteryOnScreenOn();
+ forceStop();
+ resetBatteryStats();
+ final long[] initialSnapshot = getAllCpuFreqTimes(sTestPkgUid);
+ assertNull("Initial snapshot should be null, initial="
+ + Arrays.toString(initialSnapshot), initialSnapshot);
+ assertNull("Initial top state snapshot should be null",
+ getAllCpuFreqTimes(sTestPkgUid, PROCESS_STATE_TOP));
+
+ doSomeWork(PROCESS_STATE_TOP);
+ forceStop();
+
+ final long[] cpuTimesMs = getAllCpuFreqTimes(sTestPkgUid, PROCESS_STATE_TOP);
+ final String msgCpuTimes = getAllCpuTimesMsg();
+ assertCpuTimesValid(cpuTimesMs);
+ long actualCpuTimeMs = 0;
+ for (int i = 0; i < cpuTimesMs.length / 2; ++i) {
+ actualCpuTimeMs += cpuTimesMs[i];
+ }
+ assertApproximateValue("Incorrect total cpu time, " + msgCpuTimes,
+ WORK_DURATION_MS, actualCpuTimeMs);
+
+ updateTrackPerProcStateCpuTimesSetting(bstatsConstants, false);
+
+ doSomeWork(PROCESS_STATE_TOP);
+ forceStop();
+
+ final long[] cpuTimesMs2 = getAllCpuFreqTimes(sTestPkgUid, PROCESS_STATE_TOP);
+ assertCpuTimesValid(cpuTimesMs2);
+ assertCpuTimesEqual(cpuTimesMs2, cpuTimesMs, 20,
+ "Unexpected cpu times with tracking off");
+
+ updateTrackPerProcStateCpuTimesSetting(bstatsConstants, true);
+
+ final long[] cpuTimesMs3 = getAllCpuFreqTimes(sTestPkgUid, PROCESS_STATE_TOP);
+ assertCpuTimesValid(cpuTimesMs3);
+ assertCpuTimesEqual(cpuTimesMs3, cpuTimesMs, 20,
+ "Unexpected cpu times after turning on tracking");
+
+ doSomeWork(PROCESS_STATE_TOP);
+ forceStop();
+
+ final long[] cpuTimesMs4 = getAllCpuFreqTimes(sTestPkgUid, PROCESS_STATE_TOP);
+ assertCpuTimesValid(cpuTimesMs4);
+ actualCpuTimeMs = 0;
+ for (int i = 0; i < cpuTimesMs.length / 2; ++i) {
+ actualCpuTimeMs += cpuTimesMs[i];
+ }
+ assertApproximateValue("Incorrect total cpu time, " + msgCpuTimes,
+ 2 * WORK_DURATION_MS, actualCpuTimeMs);
+
+ batteryOffScreenOn();
+ } finally {
+ Settings.Global.putString(sContext.getContentResolver(),
+ Settings.Global.BATTERY_STATS_CONSTANTS, bstatsConstants);
+ }
+ }
+
+ private void assertCpuTimesEqual(long[] actual, long[] expected, long delta, String errMsg) {
+ for (int i = actual.length - 1; i >= 0; --i) {
+ if (actual[i] > expected[i] + delta || actual[i] < expected[i]) {
+ fail(errMsg + ", actual=" + actual + ", expected=" + expected + ", delta=" + delta);
+ }
+ }
+ }
+
+ private void updateTrackPerProcStateCpuTimesSetting(String originalConstants, boolean enabled)
+ throws Exception {
+ final String newConstants;
+ final String setting = KEY_TRACK_CPU_TIMES_BY_PROC_STATE + "=" + enabled;
+ if (originalConstants == null || "null".equals(originalConstants)) {
+ newConstants = setting;
+ } else if (originalConstants.contains(KEY_TRACK_CPU_TIMES_BY_PROC_STATE)) {
+ newConstants = originalConstants.replaceAll(
+ KEY_TRACK_CPU_TIMES_BY_PROC_STATE + "=(true|false)", setting);
+ } else {
+ newConstants = originalConstants + "," + setting;
+ }
+ Settings.Global.putString(sContext.getContentResolver(),
+ Settings.Global.BATTERY_STATS_CONSTANTS, newConstants);
+ assertTrackPerProcStateCpuTimesSetting(enabled);
+ }
+
+ private void assertTrackPerProcStateCpuTimesSetting(boolean enabled) throws Exception {
+ final String expectedValue = Boolean.toString(enabled);
+ assertDelayedCondition("Unexpected value for " + KEY_TRACK_CPU_TIMES_BY_PROC_STATE, () -> {
+ final String actualValue = getSettingValueFromDump(KEY_TRACK_CPU_TIMES_BY_PROC_STATE);
+ return expectedValue.equals(actualValue)
+ ? null : "expected=" + expectedValue + ", actual=" + actualValue;
+ }, SETTING_UPDATE_TIMEOUT_MS, SETTING_UPDATE_CHECK_INTERVAL_MS);
+ }
+
+ private String getSettingValueFromDump(String key) throws Exception {
+ final String settingsDump = executeCmdSilent("dumpsys batterystats --settings");
+ final TextUtils.SimpleStringSplitter splitter = new TextUtils.SimpleStringSplitter('\n');
+ splitter.setString(settingsDump);
+ String next;
+ while (splitter.hasNext()) {
+ next = splitter.next();
+ if (next.startsWith(key)) {
+ return next.split("=")[1];
+ }
+ }
+ return null;
+ }
+
private void assertCpuTimesValid(long[] cpuTimes) {
assertNotNull(cpuTimes);
for (int i = 0; i < cpuTimes.length; ++i) {
@@ -750,13 +909,18 @@
}
private void assertDelayedCondition(String errMsgPrefix, ExpectedCondition condition)
- throws Exception {
- final long endTime = SystemClock.uptimeMillis() + GENERAL_TIMEOUT_MS;
+ throws Exception {
+ assertDelayedCondition(errMsgPrefix, condition, GENERAL_TIMEOUT_MS, GENERAL_INTERVAL_MS);
+ }
+
+ private void assertDelayedCondition(String errMsgPrefix, ExpectedCondition condition,
+ long timeoutMs, long checkIntervalMs) throws Exception {
+ final long endTime = SystemClock.uptimeMillis() + timeoutMs;
while (SystemClock.uptimeMillis() <= endTime) {
if (condition.getErrIfNotTrue() == null) {
return;
}
- SystemClock.sleep(GENERAL_INTERVAL_MS);
+ SystemClock.sleep(checkIntervalMs);
}
final String errMsg = condition.getErrIfNotTrue();
if (errMsg != null) {
diff --git a/core/tests/coretests/src/com/android/internal/os/LongSamplingCounterArrayTest.java b/core/tests/coretests/src/com/android/internal/os/LongSamplingCounterArrayTest.java
index 27aec56..37b4e41a 100644
--- a/core/tests/coretests/src/com/android/internal/os/LongSamplingCounterArrayTest.java
+++ b/core/tests/coretests/src/com/android/internal/os/LongSamplingCounterArrayTest.java
@@ -16,7 +16,9 @@
package com.android.internal.os;
+import static android.os.BatteryStats.STATS_CURRENT;
import static android.os.BatteryStats.STATS_SINCE_CHARGED;
+import static android.os.BatteryStats.STATS_SINCE_UNPLUGGED;
import static com.android.internal.os.BatteryStatsImpl.LongSamplingCounterArray;
import static com.android.internal.os.BatteryStatsImpl.TimeBase;
@@ -61,7 +63,6 @@
private static final long[] COUNTS = {1111, 2222, 3333, 4444};
private static final long[] LOADED_COUNTS = {5555, 6666, 7777, 8888};
- private static final long[] PLUGGED_COUNTS = {9999, 11111, 22222, 33333};
private static final long[] UNPLUGGED_COUNTS = {44444, 55555, 66666, 77777};
private static final long[] ZEROES = {0, 0, 0, 0};
@@ -83,11 +84,10 @@
parcel.setDataPosition(0);
// Now clear counterArray and verify values are read from parcel correctly.
- updateCounts(null, null, null, null);
+ updateCounts(null, null, null);
mCounterArray = LongSamplingCounterArray.readFromParcel(parcel, mTimeBase);
assertArrayEquals(COUNTS, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(LOADED_COUNTS, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(COUNTS, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
assertArrayEquals(UNPLUGGED_COUNTS, mCounterArray.mUnpluggedCounts,
"Unexpected unpluggedCounts");
parcel.recycle();
@@ -101,11 +101,10 @@
parcel.setDataPosition(0);
// Now clear counterArray and verify values are read from parcel correctly.
- updateCounts(null, null, null, null);
+ updateCounts(null, null, null);
mCounterArray = LongSamplingCounterArray.readSummaryFromParcelLocked(parcel, mTimeBase);
assertArrayEquals(COUNTS, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(COUNTS, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(COUNTS, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
assertArrayEquals(COUNTS, mCounterArray.mUnpluggedCounts, "Unexpected unpluggedCounts");
parcel.recycle();
}
@@ -116,8 +115,7 @@
mCounterArray.onTimeStarted(0, 0, 0);
assertArrayEquals(COUNTS, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(LOADED_COUNTS, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(PLUGGED_COUNTS, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
- assertArrayEquals(PLUGGED_COUNTS, mCounterArray.mUnpluggedCounts,
+ assertArrayEquals(COUNTS, mCounterArray.mUnpluggedCounts,
"Unexpected unpluggedCounts");
}
@@ -127,7 +125,6 @@
mCounterArray.onTimeStopped(0, 0, 0);
assertArrayEquals(COUNTS, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(LOADED_COUNTS, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(COUNTS, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
assertArrayEquals(UNPLUGGED_COUNTS, mCounterArray.mUnpluggedCounts,
"Unexpected unpluggedCounts");
}
@@ -137,24 +134,50 @@
initializeCounterArrayWithDefaultValues();
when(mTimeBase.isRunning()).thenReturn(false);
- long[] actualVal = mCounterArray.getCountsLocked(STATS_SINCE_CHARGED);
- long[] expectedVal = PLUGGED_COUNTS;
- assertArrayEquals(expectedVal, actualVal, "Unexpected values");
+ assertArrayEquals(COUNTS, mCounterArray.getCountsLocked(STATS_SINCE_CHARGED),
+ "Unexpected values");
+ assertArrayEquals(subtract(COUNTS, LOADED_COUNTS),
+ mCounterArray.getCountsLocked(STATS_CURRENT), "Unexpected values");
+ assertArrayEquals(subtract(COUNTS, UNPLUGGED_COUNTS),
+ mCounterArray.getCountsLocked(STATS_SINCE_UNPLUGGED), "Unexpected values");
when(mTimeBase.isRunning()).thenReturn(true);
- actualVal = mCounterArray.getCountsLocked(STATS_SINCE_CHARGED);
- expectedVal = COUNTS;
- assertArrayEquals(expectedVal, actualVal, "Unexpected values");
+ assertArrayEquals(COUNTS, mCounterArray.getCountsLocked(STATS_SINCE_CHARGED),
+ "Unexpected values");
+ assertArrayEquals(subtract(COUNTS, LOADED_COUNTS),
+ mCounterArray.getCountsLocked(STATS_CURRENT), "Unexpected values");
+ assertArrayEquals(subtract(COUNTS, UNPLUGGED_COUNTS),
+ mCounterArray.getCountsLocked(STATS_SINCE_UNPLUGGED), "Unexpected values");
+ }
+
+ private long[] subtract(long[] val, long[] toSubtract) {
+ final long[] result = val.clone();
+ if (toSubtract != null) {
+ for (int i = val.length - 1; i >= 0; --i) {
+ result[i] -= toSubtract[i];
+ }
+ }
+ return result;
}
@Test
public void testAddCountLocked() {
+ updateCounts(null, null, null);
final long[] deltas = {123, 234, 345, 456};
when(mTimeBase.isRunning()).thenReturn(true);
mCounterArray.addCountLocked(deltas);
assertArrayEquals(deltas, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(null, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(null, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
+ assertArrayEquals(null, mCounterArray.mUnpluggedCounts, "Unexpected unpluggedCounts");
+
+ updateCounts(null, null, null);
+ mCounterArray.addCountLocked(deltas, false);
+ assertArrayEquals(null, mCounterArray.mCounts, "Unexpected counts");
+ assertArrayEquals(null, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
+ assertArrayEquals(null, mCounterArray.mUnpluggedCounts, "Unexpected unpluggedCounts");
+ mCounterArray.addCountLocked(deltas, true);
+ assertArrayEquals(deltas, mCounterArray.mCounts, "Unexpected counts");
+ assertArrayEquals(null, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
assertArrayEquals(null, mCounterArray.mUnpluggedCounts, "Unexpected unpluggedCounts");
initializeCounterArrayWithDefaultValues();
@@ -165,7 +188,18 @@
mCounterArray.addCountLocked(deltas);
assertArrayEquals(newCounts, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(LOADED_COUNTS, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(PLUGGED_COUNTS, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
+ assertArrayEquals(UNPLUGGED_COUNTS, mCounterArray.mUnpluggedCounts,
+ "Unexpected unpluggedCounts");
+
+ initializeCounterArrayWithDefaultValues();
+ mCounterArray.addCountLocked(deltas, false);
+ assertArrayEquals(COUNTS, mCounterArray.mCounts, "Unexpected counts");
+ assertArrayEquals(LOADED_COUNTS, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
+ assertArrayEquals(UNPLUGGED_COUNTS, mCounterArray.mUnpluggedCounts,
+ "Unexpected unpluggedCounts");
+ mCounterArray.addCountLocked(deltas, true);
+ assertArrayEquals(newCounts, mCounterArray.mCounts, "Unexpected counts");
+ assertArrayEquals(LOADED_COUNTS, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
assertArrayEquals(UNPLUGGED_COUNTS, mCounterArray.mUnpluggedCounts,
"Unexpected unpluggedCounts");
}
@@ -177,7 +211,6 @@
mCounterArray.reset(false /* detachIfReset */);
assertArrayEquals(ZEROES, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(ZEROES, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(ZEROES, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
assertArrayEquals(ZEROES, mCounterArray.mUnpluggedCounts, "Unexpected unpluggedCounts");
verifyZeroInteractions(mTimeBase);
@@ -186,7 +219,6 @@
mCounterArray.reset(true /* detachIfReset */);
assertArrayEquals(ZEROES, mCounterArray.mCounts, "Unexpected counts");
assertArrayEquals(ZEROES, mCounterArray.mLoadedCounts, "Unexpected loadedCounts");
- assertArrayEquals(ZEROES, mCounterArray.mPluggedCounts, "Unexpected pluggedCounts");
assertArrayEquals(ZEROES, mCounterArray.mUnpluggedCounts, "Unexpected unpluggedCounts");
verify(mTimeBase).remove(mCounterArray);
verifyNoMoreInteractions(mTimeBase);
@@ -200,7 +232,7 @@
}
private void initializeCounterArrayWithDefaultValues() {
- updateCounts(COUNTS, LOADED_COUNTS, PLUGGED_COUNTS, UNPLUGGED_COUNTS);
+ updateCounts(COUNTS, LOADED_COUNTS, UNPLUGGED_COUNTS);
}
private void assertArrayEquals(long[] expected, long[] actual, String msg) {
@@ -208,11 +240,9 @@
+ ", actual: " + Arrays.toString(actual), Arrays.equals(expected, actual));
}
- private void updateCounts(long[] counts, long[] loadedCounts,
- long[] pluggedCounts, long[] unpluggedCounts) {
- mCounterArray.mCounts = counts;
- mCounterArray.mLoadedCounts = loadedCounts;
- mCounterArray.mPluggedCounts = pluggedCounts;
- mCounterArray.mUnpluggedCounts = unpluggedCounts;
+ private void updateCounts(long[] counts, long[] loadedCounts, long[] unpluggedCounts) {
+ mCounterArray.mCounts = counts == null ? null : counts.clone();
+ mCounterArray.mLoadedCounts = loadedCounts == null ? null : loadedCounts.clone();
+ mCounterArray.mUnpluggedCounts = unpluggedCounts == null ? null : unpluggedCounts.clone();
}
}
diff --git a/core/tests/coretests/src/com/android/internal/os/MockBatteryStatsImpl.java b/core/tests/coretests/src/com/android/internal/os/MockBatteryStatsImpl.java
index f19ff67..6c5a2aa 100644
--- a/core/tests/coretests/src/com/android/internal/os/MockBatteryStatsImpl.java
+++ b/core/tests/coretests/src/com/android/internal/os/MockBatteryStatsImpl.java
@@ -139,12 +139,19 @@
}
@Override
- public Future<?> scheduleReadProcStateCpuTimes() {
+ public Future<?> scheduleCpuSyncDueToSettingChange() {
return null;
}
@Override
- public Future<?> scheduleCopyFromAllUidsCpuTimes() {
+ public Future<?> scheduleReadProcStateCpuTimes(
+ boolean onBattery, boolean onBatteryScreenOff) {
+ return null;
+ }
+
+ @Override
+ public Future<?> scheduleCopyFromAllUidsCpuTimes(
+ boolean onBattery, boolean onBatteryScreenOff) {
return null;
}
diff --git a/core/tests/privacytests/Android.mk b/core/tests/privacytests/Android.mk
index 7b11225..7bba417 100644
--- a/core/tests/privacytests/Android.mk
+++ b/core/tests/privacytests/Android.mk
@@ -13,4 +13,7 @@
LOCAL_JAVA_LIBRARIES := android.test.runner
LOCAL_PACKAGE_NAME := FrameworksPrivacyLibraryTests
+LOCAL_CERTIFICATE := platform
+LOCAL_COMPATIBILITY_SUITE := device-tests
+
include $(BUILD_PACKAGE)
diff --git a/core/tests/privacytests/AndroidTest.xml b/core/tests/privacytests/AndroidTest.xml
new file mode 100644
index 0000000..a43f48e
--- /dev/null
+++ b/core/tests/privacytests/AndroidTest.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<configuration description="Runs Privacy Tests.">
+ <target_preparer class="com.android.tradefed.targetprep.TestAppInstallSetup">
+ <option name="test-file-name" value="FrameworksPrivacyLibraryTests.apk" />
+ </target_preparer>
+
+ <test class="com.android.tradefed.testtype.AndroidJUnitTest" >
+ <option name="package" value="com.android.frameworks.coretests.privacy" />
+ <option name="runner" value="android.support.test.runner.AndroidJUnitRunner" />
+ </test>
+</configuration>
\ No newline at end of file
diff --git a/graphics/java/android/graphics/ImageDecoder.java b/graphics/java/android/graphics/ImageDecoder.java
index 60416a7..97ce886 100644
--- a/graphics/java/android/graphics/ImageDecoder.java
+++ b/graphics/java/android/graphics/ImageDecoder.java
@@ -16,29 +16,44 @@
package android.graphics;
+import static android.system.OsConstants.SEEK_SET;
+
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.RawRes;
+import android.content.ContentResolver;
+import android.content.res.AssetFileDescriptor;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.NinePatchDrawable;
+import android.net.Uri;
+import android.system.ErrnoException;
+import android.system.Os;
+
+import libcore.io.IoUtils;
+import dalvik.system.CloseGuard;
import java.nio.ByteBuffer;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ArrayIndexOutOfBoundsException;
+import java.lang.AutoCloseable;
import java.lang.NullPointerException;
import java.lang.RuntimeException;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.SOURCE;
+import java.util.concurrent.atomic.AtomicBoolean;
/**
* Class for decoding images as {@link Bitmap}s or {@link Drawable}s.
* @hide
*/
-public final class ImageDecoder {
+public final class ImageDecoder implements AutoCloseable {
/**
* Source of the encoded image data.
*/
@@ -47,10 +62,7 @@
Resources getResources() { return null; }
/* @hide */
- void close() {}
-
- /* @hide */
- abstract ImageDecoder createImageDecoder();
+ abstract ImageDecoder createImageDecoder() throws IOException;
};
private static class ByteArraySource extends Source {
@@ -64,7 +76,7 @@
private final int mLength;
@Override
- public ImageDecoder createImageDecoder() {
+ public ImageDecoder createImageDecoder() throws IOException {
return nCreate(mData, mOffset, mLength);
}
}
@@ -76,7 +88,7 @@
private final ByteBuffer mBuffer;
@Override
- public ImageDecoder createImageDecoder() {
+ public ImageDecoder createImageDecoder() throws IOException {
if (!mBuffer.isDirect() && mBuffer.hasArray()) {
int offset = mBuffer.arrayOffset() + mBuffer.position();
int length = mBuffer.limit() - mBuffer.position();
@@ -86,61 +98,110 @@
}
}
- private static class ResourceSource extends Source {
- ResourceSource(Resources res, int resId)
- throws Resources.NotFoundException {
- // Test that the resource can be found.
- InputStream is = null;
+ private static class ContentResolverSource extends Source {
+ ContentResolverSource(ContentResolver resolver, Uri uri) {
+ mResolver = resolver;
+ mUri = uri;
+ }
+
+ private final ContentResolver mResolver;
+ private final Uri mUri;
+
+ @Override
+ public ImageDecoder createImageDecoder() throws IOException {
+ AssetFileDescriptor assetFd = null;
try {
- is = res.openRawResource(resId);
- } finally {
- if (is != null) {
- try {
- is.close();
- } catch (IOException e) {
- }
+ if (mUri.getScheme() == ContentResolver.SCHEME_CONTENT) {
+ assetFd = mResolver.openTypedAssetFileDescriptor(mUri,
+ "image/*", null);
+ } else {
+ assetFd = mResolver.openAssetFileDescriptor(mUri, "r");
}
+ } catch (FileNotFoundException e) {
+ // Some images cannot be opened as AssetFileDescriptors (e.g.
+ // bmp, ico). Open them as InputStreams.
+ InputStream is = mResolver.openInputStream(mUri);
+ if (is == null) {
+ throw new FileNotFoundException(mUri.toString());
+ }
+
+ return createFromStream(is);
}
+ final FileDescriptor fd = assetFd.getFileDescriptor();
+ final long offset = assetFd.getStartOffset();
+
+ ImageDecoder decoder = null;
+ try {
+ try {
+ Os.lseek(fd, offset, SEEK_SET);
+ decoder = nCreate(fd);
+ } catch (ErrnoException e) {
+ decoder = createFromStream(new FileInputStream(fd));
+ }
+ } finally {
+ if (decoder == null) {
+ IoUtils.closeQuietly(assetFd);
+ } else {
+ decoder.mAssetFd = assetFd;
+ }
+ }
+ return decoder;
+ }
+ }
+
+ private static ImageDecoder createFromStream(InputStream is) throws IOException {
+ // Arbitrary size matches BitmapFactory.
+ byte[] storage = new byte[16 * 1024];
+ ImageDecoder decoder = null;
+ try {
+ decoder = nCreate(is, storage);
+ } finally {
+ if (decoder == null) {
+ IoUtils.closeQuietly(is);
+ } else {
+ decoder.mInputStream = is;
+ decoder.mTempStorage = storage;
+ }
+ }
+
+ return decoder;
+ }
+
+ private static class ResourceSource extends Source {
+ ResourceSource(Resources res, int resId) {
mResources = res;
mResId = resId;
}
final Resources mResources;
final int mResId;
- // This is just stored here in order to keep the underlying Asset
- // alive. FIXME: Can I access the Asset (and keep it alive) without
- // this object?
- InputStream mInputStream;
@Override
public Resources getResources() { return mResources; }
@Override
- public ImageDecoder createImageDecoder() {
- // FIXME: Can I bypass creating the stream?
+ public ImageDecoder createImageDecoder() throws IOException {
+ // This is just used in order to access the underlying Asset and
+ // keep it alive. FIXME: Can we skip creating this object?
+ InputStream is = null;
+ ImageDecoder decoder = null;
try {
- mInputStream = mResources.openRawResource(mResId);
- } catch (Resources.NotFoundException e) {
- // This should never happen, since we already tested in the
- // constructor.
- }
- if (!(mInputStream instanceof AssetManager.AssetInputStream)) {
- // This should never happen.
- throw new RuntimeException("Resource is not an asset?");
- }
- long asset = ((AssetManager.AssetInputStream) mInputStream).getNativeAsset();
- return nCreate(asset);
- }
-
- @Override
- public void close() {
- try {
- mInputStream.close();
- } catch (IOException e) {
+ is = mResources.openRawResource(mResId);
+ if (!(is instanceof AssetManager.AssetInputStream)) {
+ // This should never happen.
+ throw new RuntimeException("Resource is not an asset?");
+ }
+ long asset = ((AssetManager.AssetInputStream) is).getNativeAsset();
+ decoder = nCreate(asset);
} finally {
- mInputStream = null;
+ if (decoder == null) {
+ IoUtils.closeQuietly(is);
+ } else {
+ decoder.mInputStream = is;
+ }
}
+ return decoder;
}
}
@@ -159,18 +220,23 @@
};
/**
- * Used if the provided data is incomplete.
+ * Supplied to onException if the provided data is incomplete.
+ *
+ * Will never be thrown by ImageDecoder.
*
* There may be a partial image to display.
*/
- public class IncompleteException extends Exception {};
+ public static class IncompleteException extends IOException {};
/**
* Used if the provided data is corrupt.
*
- * There may be a partial image to display.
+ * May be thrown if there is nothing to display.
+ *
+ * If supplied to onException, there may be a correct partial image to
+ * display.
*/
- public class CorruptException extends Exception {};
+ public static class CorruptException extends IOException {};
/**
* Optional listener supplied to {@link #decodeDrawable} or
@@ -193,15 +259,14 @@
public static interface OnExceptionListener {
/**
* Called when there is a problem in the stream or in the data.
- * FIXME: Or do not allow streams?
* FIXME: Report how much of the image has been decoded?
*
- * @param e Exception containing information about the error.
+ * @param e IOException containing information about the error.
* @return True to create and return a {@link Drawable}/
* {@link Bitmap} with partial data. False to return
* {@code null}. True is the default.
*/
- public boolean onException(Exception e);
+ public boolean onException(IOException e);
};
// Fields
@@ -221,9 +286,15 @@
private PostProcess mPostProcess;
private OnExceptionListener mOnExceptionListener;
+ // Objects for interacting with the input.
+ private InputStream mInputStream;
+ private byte[] mTempStorage;
+ private AssetFileDescriptor mAssetFd;
+ private final AtomicBoolean mClosed = new AtomicBoolean();
+ private final CloseGuard mCloseGuard = CloseGuard.get();
/**
- * Private constructor called by JNI. {@link #recycle} must be
+ * Private constructor called by JNI. {@link #close} must be
* called after decoding to delete native resources.
*/
@SuppressWarnings("unused")
@@ -233,6 +304,20 @@
mHeight = height;
mDesiredWidth = width;
mDesiredHeight = height;
+ mCloseGuard.open("close");
+ }
+
+ @Override
+ protected void finalize() throws Throwable {
+ try {
+ if (mCloseGuard != null) {
+ mCloseGuard.warnIfOpen();
+ }
+
+ close();
+ } finally {
+ super.finalize();
+ }
}
/**
@@ -243,14 +328,28 @@
* // FIXME: Can be an @DrawableRes?
* @return a new Source object, which can be passed to
* {@link #decodeDrawable} or {@link #decodeBitmap}.
- * @throws Resources.NotFoundException if the asset does not exist.
*/
+ @NonNull
public static Source createSource(@NonNull Resources res, @RawRes int resId)
- throws Resources.NotFoundException {
+ {
return new ResourceSource(res, resId);
}
/**
+ * Create a new {@link Source} from a {@link android.net.Uri}.
+ *
+ * @param cr to retrieve from.
+ * @param uri of the image file.
+ * @return a new Source object, which can be passed to
+ * {@link #decodeDrawable} or {@link #decodeBitmap}.
+ */
+ @NonNull
+ public static Source createSource(@NonNull ContentResolver cr,
+ @NonNull Uri uri) {
+ return new ContentResolverSource(cr, uri);
+ }
+
+ /**
* Create a new {@link Source} from a byte array.
* @param data byte array of compressed image data.
* @param offset offset into data for where the decoder should begin
@@ -307,7 +406,7 @@
+ "provided " + sampleSize);
}
if (mNativePtr == 0) {
- throw new IllegalStateException("ImageDecoder is recycled!");
+ throw new IllegalStateException("ImageDecoder is closed!");
}
return nGetSampledSize(mNativePtr, sampleSize);
@@ -500,24 +599,26 @@
mAsAlphaMask = true;
}
- /**
- * Clean up resources.
- *
- * ImageDecoder has a private constructor, and will always be recycled
- * by decodeDrawable or decodeBitmap which creates it, so there is no
- * need for a finalizer.
- */
- private void recycle() {
- if (mNativePtr == 0) {
+ @Override
+ public void close() {
+ mCloseGuard.close();
+ if (!mClosed.compareAndSet(false, true)) {
return;
}
- nRecycle(mNativePtr);
+ nClose(mNativePtr);
mNativePtr = 0;
+
+ IoUtils.closeQuietly(mInputStream);
+ IoUtils.closeQuietly(mAssetFd);
+
+ mInputStream = null;
+ mAssetFd = null;
+ mTempStorage = null;
}
private void checkState() {
if (mNativePtr == 0) {
- throw new IllegalStateException("Cannot reuse ImageDecoder.Source!");
+ throw new IllegalStateException("Cannot use closed ImageDecoder!");
}
checkSubset(mDesiredWidth, mDesiredHeight, mCropRect);
@@ -548,44 +649,47 @@
/**
* Create a {@link Drawable}.
+ * @throws IOException if {@code src} is not found, is an unsupported
+ * format, or cannot be decoded for any reason.
*/
- public static Drawable decodeDrawable(Source src, OnHeaderDecodedListener listener) {
- ImageDecoder decoder = src.createImageDecoder();
- if (decoder == null) {
- return null;
- }
+ @NonNull
+ public static Drawable decodeDrawable(Source src, OnHeaderDecodedListener listener)
+ throws IOException {
+ try (ImageDecoder decoder = src.createImageDecoder()) {
+ if (listener != null) {
+ ImageInfo info = new ImageInfo(decoder.mWidth, decoder.mHeight);
+ listener.onHeaderDecoded(info, decoder);
+ }
- if (listener != null) {
- ImageInfo info = new ImageInfo(decoder.mWidth, decoder.mHeight);
- listener.onHeaderDecoded(info, decoder);
- }
+ decoder.checkState();
- decoder.checkState();
+ if (decoder.mRequireUnpremultiplied) {
+ // Though this could be supported (ignored) for opaque images,
+ // it seems better to always report this error.
+ throw new IllegalStateException("Cannot decode a Drawable " +
+ "with unpremultiplied pixels!");
+ }
- if (decoder.mRequireUnpremultiplied) {
- // Though this could be supported (ignored) for opaque images, it
- // seems better to always report this error.
- throw new IllegalStateException("Cannot decode a Drawable with" +
- " unpremultiplied pixels!");
- }
+ if (decoder.mMutable) {
+ throw new IllegalStateException("Cannot decode a mutable " +
+ "Drawable!");
+ }
- if (decoder.mMutable) {
- throw new IllegalStateException("Cannot decode a mutable Drawable!");
- }
-
- try {
Bitmap bm = nDecodeBitmap(decoder.mNativePtr,
decoder.mOnExceptionListener,
decoder.mPostProcess,
- decoder.mDesiredWidth, decoder.mDesiredHeight,
+ decoder.mDesiredWidth,
+ decoder.mDesiredHeight,
decoder.mCropRect,
- false, // decoder.mMutable
+ false, // mMutable
decoder.mAllocator,
- false, // decoder.mRequireUnpremultiplied
+ false, // mRequireUnpremultiplied
decoder.mPreferRamOverQuality,
- decoder.mAsAlphaMask
- );
+ decoder.mAsAlphaMask);
if (bm == null) {
+ // FIXME: bm should never be null. Currently a return value
+ // of false from onException will result in bm being null. What
+ // is the right API to choose to discard partial Bitmaps?
return null;
}
@@ -606,60 +710,58 @@
// TODO: Handle animation.
return new BitmapDrawable(res, bm);
- } finally {
- decoder.recycle();
- src.close();
}
}
/**
- * Create a {@link Bitmap}.
+ * Create a {@link Bitmap}.
+ * @throws IOException if {@code src} is not found, is an unsupported
+ * format, or cannot be decoded for any reason.
*/
- public static Bitmap decodeBitmap(Source src, OnHeaderDecodedListener listener) {
- ImageDecoder decoder = src.createImageDecoder();
- if (decoder == null) {
- return null;
- }
+ @NonNull
+ public static Bitmap decodeBitmap(Source src, OnHeaderDecodedListener listener)
+ throws IOException {
+ try (ImageDecoder decoder = src.createImageDecoder()) {
+ if (listener != null) {
+ ImageInfo info = new ImageInfo(decoder.mWidth, decoder.mHeight);
+ listener.onHeaderDecoded(info, decoder);
+ }
- if (listener != null) {
- ImageInfo info = new ImageInfo(decoder.mWidth, decoder.mHeight);
- listener.onHeaderDecoded(info, decoder);
- }
+ decoder.checkState();
- decoder.checkState();
-
- try {
return nDecodeBitmap(decoder.mNativePtr,
decoder.mOnExceptionListener,
decoder.mPostProcess,
- decoder.mDesiredWidth, decoder.mDesiredHeight,
+ decoder.mDesiredWidth,
+ decoder.mDesiredHeight,
decoder.mCropRect,
decoder.mMutable,
decoder.mAllocator,
decoder.mRequireUnpremultiplied,
decoder.mPreferRamOverQuality,
decoder.mAsAlphaMask);
- } finally {
- decoder.recycle();
- src.close();
}
}
- private static native ImageDecoder nCreate(long asset);
+ private static native ImageDecoder nCreate(long asset) throws IOException;
private static native ImageDecoder nCreate(ByteBuffer buffer,
int position,
- int limit);
+ int limit) throws IOException;
private static native ImageDecoder nCreate(byte[] data, int offset,
- int length);
+ int length) throws IOException;
+ private static native ImageDecoder nCreate(InputStream is, byte[] storage);
+ private static native ImageDecoder nCreate(FileDescriptor fd) throws IOException;
+ @NonNull
private static native Bitmap nDecodeBitmap(long nativePtr,
OnExceptionListener listener,
PostProcess postProcess,
int width, int height,
Rect cropRect, boolean mutable,
int allocator, boolean requireUnpremul,
- boolean preferRamOverQuality, boolean asAlphaMask);
+ boolean preferRamOverQuality, boolean asAlphaMask)
+ throws IOException;
private static native Point nGetSampledSize(long nativePtr,
int sampleSize);
private static native void nGetPadding(long nativePtr, Rect outRect);
- private static native void nRecycle(long nativePtr);
+ private static native void nClose(long nativePtr);
}
diff --git a/libs/incident/proto/android/section.proto b/libs/incident/proto/android/section.proto
index d268cf4..49bfe1e 100644
--- a/libs/incident/proto/android/section.proto
+++ b/libs/incident/proto/android/section.proto
@@ -37,6 +37,9 @@
// incidentd calls dumpsys for annotated field
SECTION_DUMPSYS = 3;
+
+ // incidentd calls logs for annotated field
+ SECTION_LOG = 4;
}
message SectionFlags {
diff --git a/location/java/android/location/ILocationManager.aidl b/location/java/android/location/ILocationManager.aidl
index f9075cfd..0990dcc 100644
--- a/location/java/android/location/ILocationManager.aidl
+++ b/location/java/android/location/ILocationManager.aidl
@@ -79,6 +79,7 @@
boolean startGnssBatch(long periodNanos, boolean wakeOnFifoFull, String packageName);
void flushGnssBatch(String packageName);
boolean stopGnssBatch();
+ boolean injectLocation(in Location location);
// --- deprecated ---
List<String> getAllProviders();
diff --git a/location/java/android/location/LocationManager.java b/location/java/android/location/LocationManager.java
index 4802b23..f0b2774 100644
--- a/location/java/android/location/LocationManager.java
+++ b/location/java/android/location/LocationManager.java
@@ -42,6 +42,7 @@
import static android.Manifest.permission.ACCESS_COARSE_LOCATION;
import static android.Manifest.permission.ACCESS_FINE_LOCATION;
+import static android.Manifest.permission.LOCATION_HARDWARE;
/**
* This class provides access to the system location services. These
@@ -882,6 +883,34 @@
requestLocationUpdates(request, null, null, intent);
}
+ /**
+ * Set the last known location with a new location.
+ *
+ * <p>A privileged client can inject a {@link Location} if it has a better estimate of what
+ * the recent location is. This is especially useful when the device boots up and the GPS
+ * chipset is in the process of getting the first fix. If the client has cached the location,
+ * it can inject the {@link Location}, so if an app requests for a {@link Location} from {@link
+ * #getLastKnownLocation(String)}, the location information is still useful before getting
+ * the first fix.</p>
+ *
+ * <p> Useful in products like Auto.
+ *
+ * @param newLocation newly available {@link Location} object
+ * @return true if update was successful, false if not
+ *
+ * @throws SecurityException if no suitable permission is present
+ *
+ * @hide
+ */
+ @RequiresPermission(allOf = {LOCATION_HARDWARE, ACCESS_FINE_LOCATION})
+ public boolean injectLocation(Location newLocation) {
+ try {
+ return mService.injectLocation(newLocation);
+ } catch (RemoteException e) {
+ throw e.rethrowFromSystemServer();
+ }
+ }
+
private ListenerTransport wrapListener(LocationListener listener, Looper looper) {
if (listener == null) return null;
synchronized (mListeners) {
diff --git a/packages/PrintSpooler/Android.mk b/packages/PrintSpooler/Android.mk
index 19e44e3..6feb8a6 100644
--- a/packages/PrintSpooler/Android.mk
+++ b/packages/PrintSpooler/Android.mk
@@ -18,17 +18,26 @@
LOCAL_MODULE_TAGS := optional
-LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res frameworks/support/v7/recyclerview/res
-LOCAL_AAPT_FLAGS := --auto-add-overlay --extra-packages android.support.v7.recyclerview
+LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res
+LOCAL_USE_AAPT2 := true
LOCAL_SRC_FILES := $(call all-java-files-under, src)
LOCAL_SRC_FILES += \
- src/com/android/printspooler/renderer/IPdfRenderer.aidl \
- src/com/android/printspooler/renderer/IPdfEditor.aidl
+ src/com/android/printspooler/renderer/IPdfRenderer.aidl \
+ src/com/android/printspooler/renderer/IPdfEditor.aidl
LOCAL_PACKAGE_NAME := PrintSpooler
LOCAL_JNI_SHARED_LIBRARIES := libprintspooler_jni
-LOCAL_STATIC_JAVA_LIBRARIES := android-support-v4 android-support-v7-recyclerview
+LOCAL_STATIC_ANDROID_LIBRARIES := \
+ android-support-v7-recyclerview \
+ android-support-compat \
+ android-support-media-compat \
+ android-support-core-utils \
+ android-support-core-ui \
+ android-support-fragment
+
+LOCAL_STATIC_JAVA_LIBRARIES := \
+ android-support-annotations
include $(BUILD_PACKAGE)
diff --git a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java
index 1d3f26ee..48de1c9 100644
--- a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java
+++ b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProtoDumpUtil.java
@@ -1720,9 +1720,6 @@
Settings.Secure.QS_TILES,
SecureSettingsProto.QS_TILES);
dumpSetting(s, p,
- Settings.Secure.DEMO_USER_SETUP_COMPLETE,
- SecureSettingsProto.DEMO_USER_SETUP_COMPLETE);
- dumpSetting(s, p,
Settings.Secure.INSTANT_APPS_ENABLED,
SecureSettingsProto.INSTANT_APPS_ENABLED);
dumpSetting(s, p,
diff --git a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java
index bef2bcb..1167d69 100644
--- a/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java
+++ b/packages/SettingsProvider/src/com/android/providers/settings/SettingsProvider.java
@@ -2592,7 +2592,9 @@
public void onUidRemovedLocked(int uid) {
final SettingsState ssaidSettings = getSettingsLocked(SETTINGS_TYPE_SSAID,
UserHandle.getUserId(uid));
- ssaidSettings.deleteSettingLocked(Integer.toString(uid));
+ if (ssaidSettings != null) {
+ ssaidSettings.deleteSettingLocked(Integer.toString(uid));
+ }
}
@Nullable
diff --git a/packages/SystemUI/res-keyguard/layout/keyguard_status_area.xml b/packages/SystemUI/res-keyguard/layout/keyguard_status_area.xml
index b154d46..5e09e75 100644
--- a/packages/SystemUI/res-keyguard/layout/keyguard_status_area.xml
+++ b/packages/SystemUI/res-keyguard/layout/keyguard_status_area.xml
@@ -32,6 +32,8 @@
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginBottom="@dimen/widget_vertical_padding"
+ android:paddingStart="64dp"
+ android:paddingEnd="64dp"
android:theme="@style/TextAppearance.Keyguard"
/>
<LinearLayout android:id="@+id/row"
diff --git a/packages/SystemUI/res-keyguard/values/dimens.xml b/packages/SystemUI/res-keyguard/values/dimens.xml
index 463af61..04cf6b0 100644
--- a/packages/SystemUI/res-keyguard/values/dimens.xml
+++ b/packages/SystemUI/res-keyguard/values/dimens.xml
@@ -57,7 +57,7 @@
<dimen name="widget_separator_thickness">2dp</dimen>
<dimen name="widget_horizontal_padding">8dp</dimen>
<dimen name="widget_icon_size">16dp</dimen>
- <dimen name="widget_icon_padding">4dp</dimen>
+ <dimen name="widget_icon_padding">8dp</dimen>
<!-- The y translation to apply at the start in appear animations. -->
<dimen name="appear_y_translation_start">32dp</dimen>
diff --git a/packages/SystemUI/res-keyguard/values/styles.xml b/packages/SystemUI/res-keyguard/values/styles.xml
index d50bab5..5f52e2a 100644
--- a/packages/SystemUI/res-keyguard/values/styles.xml
+++ b/packages/SystemUI/res-keyguard/values/styles.xml
@@ -83,13 +83,13 @@
<item name="android:gravity">center</item>
<item name="android:ellipsize">end</item>
<item name="android:maxLines">2</item>
+ <item name="android:fontFamily">@*android:string/config_headlineFontFamilyLight</item>
</style>
<style name="TextAppearance.Keyguard.Secondary">
<item name="android:layout_width">wrap_content</item>
<item name="android:layout_height">wrap_content</item>
<item name="android:textSize">@dimen/widget_label_font_size</item>
- <item name="android:singleLine">true</item>
</style>
</resources>
diff --git a/packages/SystemUI/res/values/config.xml b/packages/SystemUI/res/values/config.xml
index e313e86..b33f857 100644
--- a/packages/SystemUI/res/values/config.xml
+++ b/packages/SystemUI/res/values/config.xml
@@ -76,8 +76,11 @@
<!-- Vibration duration for GlowPadView used in SearchPanelView -->
<integer translatable="false" name="config_search_panel_view_vibration_duration">20</integer>
+ <!-- Show mic or phone affordance on Keyguard -->
+ <bool name="config_keyguardShowLeftAffordance">false</bool>
+
<!-- Show camera affordance on Keyguard -->
- <bool name="config_keyguardShowCameraAffordance">true</bool>
+ <bool name="config_keyguardShowCameraAffordance">false</bool>
<!-- Whether we should use SRC drawing mode when drawing the scrim behind. If this flag is set,
we change the canvas opacity so libhwui doesn't call glClear on our surface, and then we
@@ -95,6 +98,12 @@
<bool name="config_dead_zone_flash">false</bool>
+ <!-- Whether to enable dimming navigation buttons when wallpaper is not visible, should be
+ enabled for OLED devices to reduce/prevent burn in on the navigation bar (because of the
+ black background and static button placements) and disabled for all other devices to
+ prevent wasting cpu cycles on the dimming animation -->
+ <bool name="config_navigation_bar_enable_auto_dim_no_visible_wallpaper">true</bool>
+
<!-- Whether QuickSettings is in a phone landscape -->
<bool name="quick_settings_wide">false</bool>
diff --git a/packages/SystemUI/src/com/android/keyguard/CarrierText.java b/packages/SystemUI/src/com/android/keyguard/CarrierText.java
index 13c48d0..45d1aad8 100644
--- a/packages/SystemUI/src/com/android/keyguard/CarrierText.java
+++ b/packages/SystemUI/src/com/android/keyguard/CarrierText.java
@@ -268,6 +268,18 @@
}
}
+ @Override
+ protected void onVisibilityChanged(View changedView, int visibility) {
+ super.onVisibilityChanged(changedView, visibility);
+
+ // Only show marquee when visible
+ if (visibility == VISIBLE) {
+ setEllipsize(TextUtils.TruncateAt.MARQUEE);
+ } else {
+ setEllipsize(TextUtils.TruncateAt.END);
+ }
+ }
+
/**
* Top-level function for creating carrier text. Makes text based on simState, PLMN
* and SPN as well as device capabilities, such as being emergency call capable.
diff --git a/packages/SystemUI/src/com/android/keyguard/KeyguardSliceView.java b/packages/SystemUI/src/com/android/keyguard/KeyguardSliceView.java
index b8adb6a..8135c61 100644
--- a/packages/SystemUI/src/com/android/keyguard/KeyguardSliceView.java
+++ b/packages/SystemUI/src/com/android/keyguard/KeyguardSliceView.java
@@ -26,6 +26,9 @@
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.provider.Settings;
+import android.text.Layout;
+import android.text.TextUtils;
+import android.text.TextUtils.TruncateAt;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
@@ -40,6 +43,7 @@
import com.android.systemui.keyguard.KeyguardSliceProvider;
import com.android.systemui.tuner.TunerService;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.function.Consumer;
@@ -129,7 +133,20 @@
android.app.slice.SliceItem.FORMAT_TEXT,
new String[]{android.app.slice.Slice.HINT_TITLE},
null /* nonHints */);
- mTitle.setText(mainTitle.getText());
+ CharSequence title = mainTitle.getText();
+ mTitle.setText(title);
+
+ // Check if we're already ellipsizing the text.
+ // We're going to figure out the best possible line break if not.
+ Layout layout = mTitle.getLayout();
+ if (layout != null){
+ final int lineCount = layout.getLineCount();
+ if (lineCount > 0) {
+ if (layout.getEllipsisCount(lineCount - 1) == 0) {
+ mTitle.setText(findBestLineBreak(title));
+ }
+ }
+ }
}
mClickActions.clear();
@@ -195,6 +212,46 @@
mListener.accept(mHasHeader);
}
+ /**
+ * Breaks a string in 2 lines where both have similar character count
+ * but first line is always longer.
+ *
+ * @param charSequence Original text.
+ * @return Optimal string.
+ */
+ private CharSequence findBestLineBreak(CharSequence charSequence) {
+ if (TextUtils.isEmpty(charSequence)) {
+ return charSequence;
+ }
+
+ String source = charSequence.toString();
+ // Ignore if there is only 1 word,
+ // or if line breaks were manually set.
+ if (source.contains("\n") || !source.contains(" ")) {
+ return source;
+ }
+
+ final String[] words = source.split(" ");
+ final StringBuilder optimalString = new StringBuilder(source.length());
+ int current = 0;
+ while (optimalString.length() < source.length() - optimalString.length()) {
+ optimalString.append(words[current]);
+ if (current < words.length - 1) {
+ optimalString.append(" ");
+ }
+ current++;
+ }
+ optimalString.append("\n");
+ for (int i = current; i < words.length; i++) {
+ optimalString.append(words[i]);
+ if (current < words.length - 1) {
+ optimalString.append(" ");
+ }
+ }
+
+ return optimalString.toString();
+ }
+
public void setDark(float darkAmount) {
mDarkAmount = darkAmount;
updateTextColors();
@@ -287,6 +344,9 @@
setPadding(horizontalPadding, 0, horizontalPadding, 0);
setCompoundDrawablePadding((int) context.getResources()
.getDimension(R.dimen.widget_icon_padding));
+ setMaxWidth(KeyguardSliceView.this.getWidth() / 2);
+ setMaxLines(1);
+ setEllipsize(TruncateAt.END);
}
public void setHasDivider(boolean hasDivider) {
diff --git a/packages/SystemUI/src/com/android/systemui/OverviewProxyService.java b/packages/SystemUI/src/com/android/systemui/OverviewProxyService.java
index 22922e7..a7d1f0d 100644
--- a/packages/SystemUI/src/com/android/systemui/OverviewProxyService.java
+++ b/packages/SystemUI/src/com/android/systemui/OverviewProxyService.java
@@ -146,6 +146,7 @@
filter.addDataScheme("package");
filter.addDataSchemeSpecificPart(mLauncherComponentName.getPackageName(),
PatternMatcher.PATTERN_LITERAL);
+ filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
mContext.registerReceiver(mLauncherAddedReceiver, filter);
}
diff --git a/packages/SystemUI/src/com/android/systemui/doze/DozeUi.java b/packages/SystemUI/src/com/android/systemui/doze/DozeUi.java
index b352ec9..75f1b50 100644
--- a/packages/SystemUI/src/com/android/systemui/doze/DozeUi.java
+++ b/packages/SystemUI/src/com/android/systemui/doze/DozeUi.java
@@ -16,6 +16,8 @@
package com.android.systemui.doze;
+import static com.android.systemui.doze.DozeMachine.State.DOZE_AOD_PAUSED;
+
import android.app.AlarmManager;
import android.content.Context;
import android.os.Handler;
@@ -79,6 +81,11 @@
public void transitionTo(DozeMachine.State oldState, DozeMachine.State newState) {
switch (newState) {
case DOZE_AOD:
+ if (oldState == DOZE_AOD_PAUSED) {
+ mHost.dozeTimeTick();
+ }
+ scheduleTimeTick();
+ break;
case DOZE_AOD_PAUSING:
scheduleTimeTick();
break;
diff --git a/packages/SystemUI/src/com/android/systemui/qs/tiles/LocationTile.java b/packages/SystemUI/src/com/android/systemui/qs/tiles/LocationTile.java
index c35f591..8bdbf28 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/tiles/LocationTile.java
+++ b/packages/SystemUI/src/com/android/systemui/qs/tiles/LocationTile.java
@@ -101,6 +101,9 @@
// state.visible = !(mKeyguard.isSecure() && mKeyguard.isShowing());
state.value = locationEnabled;
checkIfRestrictionEnforcedByAdminOnly(state, UserManager.DISALLOW_SHARE_LOCATION);
+ if (state.disabledByPolicy == false) {
+ checkIfRestrictionEnforcedByAdminOnly(state, UserManager.DISALLOW_CONFIG_LOCATION_MODE);
+ }
state.icon = mIcon;
state.slash.isSlashed = !state.value;
if (locationEnabled) {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardAffordanceHelper.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardAffordanceHelper.java
index df1ffda..46d9827 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardAffordanceHelper.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardAffordanceHelper.java
@@ -529,6 +529,13 @@
KeyguardAffordanceView targetView = left ? mLeftIcon : mRightIcon;
KeyguardAffordanceView otherView = left ? mRightIcon : mLeftIcon;
startSwiping(targetView);
+
+ // Do not animate the circle expanding if the affordance isn't visible,
+ // otherwise the circle will be meaningless.
+ if (targetView.getVisibility() != View.VISIBLE) {
+ animate = false;
+ }
+
if (animate) {
fling(0, false, !left);
updateIcon(otherView, 0.0f, 0, true, false, true, false);
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
index f058862..01b3b44 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/KeyguardBottomAreaView.java
@@ -822,8 +822,10 @@
@Override
public IconState getIcon() {
mLeftIsVoiceAssist = canLaunchVoiceAssist();
+ final boolean showAffordance =
+ getResources().getBoolean(R.bool.config_keyguardShowLeftAffordance);
if (mLeftIsVoiceAssist) {
- mIconState.isVisible = mUserSetupComplete;
+ mIconState.isVisible = mUserSetupComplete && showAffordance;
if (mLeftAssistIcon == null) {
mIconState.drawable = mContext.getDrawable(R.drawable.ic_mic_26dp);
} else {
@@ -832,7 +834,7 @@
mIconState.contentDescription = mContext.getString(
R.string.accessibility_voice_assist_button);
} else {
- mIconState.isVisible = mUserSetupComplete && isPhoneVisible();
+ mIconState.isVisible = mUserSetupComplete && showAffordance && isPhoneVisible();
mIconState.drawable = mContext.getDrawable(R.drawable.ic_phone_24dp);
mIconState.contentDescription = mContext.getString(
R.string.accessibility_phone_button);
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarTransitions.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarTransitions.java
index b81a3b0..bd6421c 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarTransitions.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarTransitions.java
@@ -26,7 +26,6 @@
import android.view.IWindowManager;
import android.view.MotionEvent;
import android.view.View;
-import android.view.WindowManagerGlobal;
import com.android.internal.statusbar.IStatusBarService;
import com.android.systemui.Dependency;
@@ -37,6 +36,7 @@
private final NavigationBarView mView;
private final IStatusBarService mBarService;
private final LightBarTransitionsController mLightTransitionsController;
+ private final boolean mAllowAutoDimWallpaperNotVisible;
private boolean mWallpaperVisible;
private boolean mLightsOut;
@@ -49,6 +49,8 @@
ServiceManager.getService(Context.STATUS_BAR_SERVICE));
mLightTransitionsController = new LightBarTransitionsController(view.getContext(),
this::applyDarkIntensity);
+ mAllowAutoDimWallpaperNotVisible = view.getContext().getResources()
+ .getBoolean(R.bool.config_navigation_bar_enable_auto_dim_no_visible_wallpaper);
IWindowManager windowManagerService = Dependency.get(IWindowManager.class);
Handler handler = Handler.getMain();
@@ -80,8 +82,8 @@
@Override
protected boolean isLightsOut(int mode) {
- return super.isLightsOut(mode) || (mAutoDim && !mWallpaperVisible
- && mode != MODE_WARNING);
+ return super.isLightsOut(mode) || (mAllowAutoDimWallpaperNotVisible && mAutoDim
+ && !mWallpaperVisible && mode != MODE_WARNING);
}
public LightBarTransitionsController getLightTransitionsController() {
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java
index 2796f0f..392581d 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/NavigationBarView.java
@@ -199,8 +199,10 @@
}
}
- private final OverviewProxyListener mOverviewProxyListener =
- isConnected -> setSlippery(!isConnected);
+ private final OverviewProxyListener mOverviewProxyListener = isConnected -> {
+ setSlippery(!isConnected);
+ setDisabledFlags(mDisabledFlags, true);
+ };
public NavigationBarView(Context context, AttributeSet attrs) {
super(context, attrs);
diff --git a/packages/SystemUI/src/com/android/systemui/usb/UsbConfirmActivity.java b/packages/SystemUI/src/com/android/systemui/usb/UsbConfirmActivity.java
index e117969..0a3e34e 100644
--- a/packages/SystemUI/src/com/android/systemui/usb/UsbConfirmActivity.java
+++ b/packages/SystemUI/src/com/android/systemui/usb/UsbConfirmActivity.java
@@ -68,7 +68,6 @@
String appName = mResolveInfo.loadLabel(packageManager).toString();
final AlertController.AlertParams ap = mAlertParams;
- ap.mIcon = mResolveInfo.loadIcon(packageManager);
ap.mTitle = appName;
if (mDevice == null) {
ap.mMessage = getString(R.string.usb_accessory_confirm_prompt, appName,
diff --git a/packages/SystemUI/src/com/android/systemui/usb/UsbPermissionActivity.java b/packages/SystemUI/src/com/android/systemui/usb/UsbPermissionActivity.java
index 4606aee..238407a 100644
--- a/packages/SystemUI/src/com/android/systemui/usb/UsbPermissionActivity.java
+++ b/packages/SystemUI/src/com/android/systemui/usb/UsbPermissionActivity.java
@@ -90,7 +90,6 @@
String appName = aInfo.loadLabel(packageManager).toString();
final AlertController.AlertParams ap = mAlertParams;
- ap.mIcon = aInfo.loadIcon(packageManager);
ap.mTitle = appName;
if (mDevice == null) {
ap.mMessage = getString(R.string.usb_accessory_permission_prompt, appName,
diff --git a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeHostFake.java b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeHostFake.java
index 3e6bd7e..2398fd3 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/doze/DozeHostFake.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/doze/DozeHostFake.java
@@ -61,7 +61,7 @@
@Override
public void dozeTimeTick() {
- throw new RuntimeException("not implemented");
+ // Nothing to do in here. Real host would just update the UI.
}
@Override
diff --git a/services/backup/java/com/android/server/backup/BackupManagerConstants.java b/services/backup/java/com/android/server/backup/BackupManagerConstants.java
index b17f794..1a54e95 100644
--- a/services/backup/java/com/android/server/backup/BackupManagerConstants.java
+++ b/services/backup/java/com/android/server/backup/BackupManagerConstants.java
@@ -85,9 +85,6 @@
super(handler);
mResolver = resolver;
updateSettings();
- }
-
- public void start() {
mResolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.BACKUP_MANAGER_CONSTANTS), false, this);
}
diff --git a/services/backup/java/com/android/server/backup/BackupManagerServiceInterface.java b/services/backup/java/com/android/server/backup/BackupManagerServiceInterface.java
index 86462d8..7b021c6 100644
--- a/services/backup/java/com/android/server/backup/BackupManagerServiceInterface.java
+++ b/services/backup/java/com/android/server/backup/BackupManagerServiceInterface.java
@@ -186,6 +186,8 @@
boolean isAppEligibleForBackup(String packageName);
+ String[] filterAppsEligibleForBackup(String[] packages);
+
void dump(FileDescriptor fd, PrintWriter pw, String[] args);
IBackupManager getBackupManagerBinder();
diff --git a/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java b/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java
index 2d2993d..3cf374f 100644
--- a/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java
+++ b/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java
@@ -70,12 +70,28 @@
private static final String DEFAULT_HOME_KEY = "@home@";
// Sentinel: start of state file, followed by a version number
+ // Note that STATE_FILE_VERSION=2 is tied to UNDEFINED_ANCESTRAL_RECORD_VERSION=-1 *as well as*
+ // ANCESTRAL_RECORD_VERSION=1 (introduced Android P).
+ // Should the ANCESTRAL_RECORD_VERSION be bumped up in the future, STATE_FILE_VERSION will also
+ // need bumping up, assuming more data needs saving to the state file.
private static final String STATE_FILE_HEADER = "=state=";
private static final int STATE_FILE_VERSION = 2;
- // Current version of the saved ancestral-dataset file format
+ // key under which we store the saved ancestral-dataset format (starting from Android P)
+ // IMPORTANT: this key needs to come first in the restore data stream (to find out
+ // whether this version of Android knows how to restore the incoming data set), so it needs
+ // to be always the first one in alphabetical order of all the keys
+ private static final String ANCESTRAL_RECORD_KEY = "@ancestral_record@";
+
+ // Current version of the saved ancestral-dataset format
+ // Note that this constant was not used until Android P, and started being used
+ // to version @pm@ data for forwards-compatibility.
private static final int ANCESTRAL_RECORD_VERSION = 1;
+ // Undefined version of the saved ancestral-dataset file format means that the restore data
+ // is coming from pre-Android P device.
+ private static final int UNDEFINED_ANCESTRAL_RECORD_VERSION = -1;
+
private List<PackageInfo> mAllPackages;
private PackageManager mPackageManager;
// version & signature info of each app in a restore set
@@ -175,9 +191,8 @@
// additional involvement by the transport to obtain.
return mRestoredSignatures.keySet();
}
-
- // The backed up data is the signature block for each app, keyed by
- // the package name.
+
+ // The backed up data is the signature block for each app, keyed by the package name.
public void onBackup(ParcelFileDescriptor oldState, BackupDataOutput data,
ParcelFileDescriptor newState) {
if (DEBUG) Slog.v(TAG, "onBackup()");
@@ -196,6 +211,22 @@
mExisting.clear();
}
+ /*
+ * Ancestral record version:
+ *
+ * int ancestralRecordVersion -- the version of the format in which this backup set is
+ * produced
+ */
+ try {
+ if (DEBUG) Slog.v(TAG, "Storing ancestral record version key");
+ outputBufferStream.writeInt(ANCESTRAL_RECORD_VERSION);
+ writeEntity(data, ANCESTRAL_RECORD_KEY, outputBuffer.toByteArray());
+ } catch (IOException e) {
+ // Real error writing data
+ Slog.e(TAG, "Unable to write package backup data file!");
+ return;
+ }
+
long homeVersion = 0;
ArrayList<byte[]> homeSigHashes = null;
PackageInfo homeInfo = null;
@@ -230,6 +261,7 @@
Slog.i(TAG, "Home preference changed; backing up new state " + home);
}
if (home != null) {
+ outputBuffer.reset();
outputBufferStream.writeUTF(home.flattenToString());
outputBufferStream.writeLong(homeVersion);
outputBufferStream.writeUTF(homeInstaller != null ? homeInstaller : "" );
@@ -244,8 +276,8 @@
* Global metadata:
*
* int SDKversion -- the SDK version of the OS itself on the device
- * that produced this backup set. Used to reject
- * backups from later OSes onto earlier ones.
+ * that produced this backup set. Before Android P it was used to
+ * reject backups from later OSes onto earlier ones.
* String incremental -- the incremental release name of the OS stored in
* the backup set.
*/
@@ -354,7 +386,7 @@
// Finally, write the new state blob -- just the list of all apps we handled
writeStateFile(mAllPackages, home, homeVersion, homeSigHashes, newState);
}
-
+
private static void writeEntity(BackupDataOutput data, String key, byte[] bytes)
throws IOException {
data.writeEntityHeader(key, bytes.length);
@@ -366,83 +398,57 @@
// image. We'll use those later to determine what we can legitimately restore.
public void onRestore(BackupDataInput data, int appVersionCode, ParcelFileDescriptor newState)
throws IOException {
- List<ApplicationInfo> restoredApps = new ArrayList<ApplicationInfo>();
- HashMap<String, Metadata> sigMap = new HashMap<String, Metadata>();
if (DEBUG) Slog.v(TAG, "onRestore()");
- int storedSystemVersion = -1;
- while (data.readNextHeader()) {
+ // we expect the ANCESTRAL_RECORD_KEY ("@ancestral_record@") to always come first in the
+ // restore set - based on that value we use different mechanisms to consume the data;
+ // if the ANCESTRAL_RECORD_KEY is missing in the restore set, it means that the data is
+ // is coming from a pre-Android P device, and we consume the header data in the legacy way
+ // TODO: add a CTS test to verify that backups of PMBA generated on Android P+ always
+ // contain the ANCESTRAL_RECORD_KEY, and it's always the first key
+ int ancestralRecordVersion = getAncestralRecordVersionValue(data);
+
+ RestoreDataConsumer consumer = getRestoreDataConsumer(ancestralRecordVersion);
+ if (consumer == null) {
+ Slog.w(TAG, "Ancestral restore set version is unknown"
+ + " to this Android version; not restoring");
+ return;
+ } else {
+ consumer.consumeRestoreData(data);
+ }
+ }
+
+ private int getAncestralRecordVersionValue(BackupDataInput data) throws IOException {
+ int ancestralRecordVersionValue = UNDEFINED_ANCESTRAL_RECORD_VERSION;
+ if (data.readNextHeader()) {
String key = data.getKey();
int dataSize = data.getDataSize();
if (DEBUG) Slog.v(TAG, " got key=" + key + " dataSize=" + dataSize);
- // generic setup to parse any entity data
- byte[] inputBytes = new byte[dataSize];
- data.readEntityData(inputBytes, 0, dataSize);
- ByteArrayInputStream inputBuffer = new ByteArrayInputStream(inputBytes);
- DataInputStream inputBufferStream = new DataInputStream(inputBuffer);
+ if (ANCESTRAL_RECORD_KEY.equals(key)) {
+ // generic setup to parse any entity data
+ byte[] inputBytes = new byte[dataSize];
+ data.readEntityData(inputBytes, 0, dataSize);
+ ByteArrayInputStream inputBuffer = new ByteArrayInputStream(inputBytes);
+ DataInputStream inputBufferStream = new DataInputStream(inputBuffer);
- if (key.equals(GLOBAL_METADATA_KEY)) {
- int storedSdkVersion = inputBufferStream.readInt();
- if (DEBUG) Slog.v(TAG, " storedSystemVersion = " + storedSystemVersion);
- if (storedSystemVersion > Build.VERSION.SDK_INT) {
- // returning before setting the sig map means we rejected the restore set
- Slog.w(TAG, "Restore set was from a later version of Android; not restoring");
- return;
- }
- mStoredSdkVersion = storedSdkVersion;
- mStoredIncrementalVersion = inputBufferStream.readUTF();
- mHasMetadata = true;
- if (DEBUG) {
- Slog.i(TAG, "Restore set version " + storedSystemVersion
- + " is compatible with OS version " + Build.VERSION.SDK_INT
- + " (" + mStoredIncrementalVersion + " vs "
- + Build.VERSION.INCREMENTAL + ")");
- }
- } else if (key.equals(DEFAULT_HOME_KEY)) {
- String cn = inputBufferStream.readUTF();
- mRestoredHome = ComponentName.unflattenFromString(cn);
- mRestoredHomeVersion = inputBufferStream.readLong();
- mRestoredHomeInstaller = inputBufferStream.readUTF();
- mRestoredHomeSigHashes = readSignatureHashArray(inputBufferStream);
- if (DEBUG) {
- Slog.i(TAG, " read preferred home app " + mRestoredHome
- + " version=" + mRestoredHomeVersion
- + " installer=" + mRestoredHomeInstaller
- + " sig=" + mRestoredHomeSigHashes);
- }
- } else {
- // it's a file metadata record
- int versionCodeInt = inputBufferStream.readInt();
- long versionCode;
- if (versionCodeInt == Integer.MIN_VALUE) {
- versionCode = inputBufferStream.readLong();
- } else {
- versionCode = versionCodeInt;
- }
- ArrayList<byte[]> sigs = readSignatureHashArray(inputBufferStream);
- if (DEBUG) {
- Slog.i(TAG, " read metadata for " + key
- + " dataSize=" + dataSize
- + " versionCode=" + versionCode + " sigs=" + sigs);
- }
-
- if (sigs == null || sigs.size() == 0) {
- Slog.w(TAG, "Not restoring package " + key
- + " since it appears to have no signatures.");
- continue;
- }
-
- ApplicationInfo app = new ApplicationInfo();
- app.packageName = key;
- restoredApps.add(app);
- sigMap.put(key, new Metadata(versionCode, sigs));
+ ancestralRecordVersionValue = inputBufferStream.readInt();
}
}
+ return ancestralRecordVersionValue;
+ }
- // On successful completion, cache the signature map for the Backup Manager to use
- mRestoredSignatures = sigMap;
+ private RestoreDataConsumer getRestoreDataConsumer(int ancestralRecordVersion) {
+ switch (ancestralRecordVersion) {
+ case UNDEFINED_ANCESTRAL_RECORD_VERSION:
+ return new LegacyRestoreDataConsumer();
+ case 1:
+ return new AncestralVersion1RestoreDataConsumer();
+ default:
+ Slog.e(TAG, "Unrecognized ANCESTRAL_RECORD_VERSION: " + ancestralRecordVersion);
+ return null;
+ }
}
private static void writeSignatureHashArray(DataOutputStream out, ArrayList<byte[]> hashes)
@@ -639,4 +645,173 @@
Slog.e(TAG, "Unable to write package manager state file!");
}
}
+
+ interface RestoreDataConsumer {
+ void consumeRestoreData(BackupDataInput data) throws IOException;
+ }
+
+ private class LegacyRestoreDataConsumer implements RestoreDataConsumer {
+
+ public void consumeRestoreData(BackupDataInput data) throws IOException {
+ List<ApplicationInfo> restoredApps = new ArrayList<ApplicationInfo>();
+ HashMap<String, Metadata> sigMap = new HashMap<String, Metadata>();
+ int storedSystemVersion = -1;
+
+ if (DEBUG) Slog.i(TAG, "Using LegacyRestoreDataConsumer");
+ // we already have the first header read and "cached", since ANCESTRAL_RECORD_KEY
+ // was missing
+ while (true) {
+ String key = data.getKey();
+ int dataSize = data.getDataSize();
+
+ if (DEBUG) Slog.v(TAG, " got key=" + key + " dataSize=" + dataSize);
+
+ // generic setup to parse any entity data
+ byte[] inputBytes = new byte[dataSize];
+ data.readEntityData(inputBytes, 0, dataSize);
+ ByteArrayInputStream inputBuffer = new ByteArrayInputStream(inputBytes);
+ DataInputStream inputBufferStream = new DataInputStream(inputBuffer);
+
+ if (key.equals(GLOBAL_METADATA_KEY)) {
+ int storedSdkVersion = inputBufferStream.readInt();
+ if (DEBUG) Slog.v(TAG, " storedSystemVersion = " + storedSystemVersion);
+ mStoredSdkVersion = storedSdkVersion;
+ mStoredIncrementalVersion = inputBufferStream.readUTF();
+ mHasMetadata = true;
+ if (DEBUG) {
+ Slog.i(TAG, "Restore set version " + storedSystemVersion
+ + " is compatible with OS version " + Build.VERSION.SDK_INT
+ + " (" + mStoredIncrementalVersion + " vs "
+ + Build.VERSION.INCREMENTAL + ")");
+ }
+ } else if (key.equals(DEFAULT_HOME_KEY)) {
+ String cn = inputBufferStream.readUTF();
+ mRestoredHome = ComponentName.unflattenFromString(cn);
+ mRestoredHomeVersion = inputBufferStream.readLong();
+ mRestoredHomeInstaller = inputBufferStream.readUTF();
+ mRestoredHomeSigHashes = readSignatureHashArray(inputBufferStream);
+ if (DEBUG) {
+ Slog.i(TAG, " read preferred home app " + mRestoredHome
+ + " version=" + mRestoredHomeVersion
+ + " installer=" + mRestoredHomeInstaller
+ + " sig=" + mRestoredHomeSigHashes);
+ }
+ } else {
+ // it's a file metadata record
+ int versionCodeInt = inputBufferStream.readInt();
+ long versionCode;
+ if (versionCodeInt == Integer.MIN_VALUE) {
+ versionCode = inputBufferStream.readLong();
+ } else {
+ versionCode = versionCodeInt;
+ }
+ ArrayList<byte[]> sigs = readSignatureHashArray(inputBufferStream);
+ if (DEBUG) {
+ Slog.i(TAG, " read metadata for " + key
+ + " dataSize=" + dataSize
+ + " versionCode=" + versionCode + " sigs=" + sigs);
+ }
+
+ if (sigs == null || sigs.size() == 0) {
+ Slog.w(TAG, "Not restoring package " + key
+ + " since it appears to have no signatures.");
+ continue;
+ }
+
+ ApplicationInfo app = new ApplicationInfo();
+ app.packageName = key;
+ restoredApps.add(app);
+ sigMap.put(key, new Metadata(versionCode, sigs));
+ }
+
+ boolean readNextHeader = data.readNextHeader();
+ if (!readNextHeader) {
+ if (DEBUG) Slog.v(TAG, "LegacyRestoreDataConsumer:"
+ + " we're done reading all the headers");
+ break;
+ }
+ }
+
+ // On successful completion, cache the signature map for the Backup Manager to use
+ mRestoredSignatures = sigMap;
+ }
+ }
+
+ private class AncestralVersion1RestoreDataConsumer implements RestoreDataConsumer {
+
+ public void consumeRestoreData(BackupDataInput data) throws IOException {
+ List<ApplicationInfo> restoredApps = new ArrayList<ApplicationInfo>();
+ HashMap<String, Metadata> sigMap = new HashMap<String, Metadata>();
+ int storedSystemVersion = -1;
+
+ if (DEBUG) Slog.i(TAG, "Using AncestralVersion1RestoreDataConsumer");
+ while (data.readNextHeader()) {
+ String key = data.getKey();
+ int dataSize = data.getDataSize();
+
+ if (DEBUG) Slog.v(TAG, " got key=" + key + " dataSize=" + dataSize);
+
+ // generic setup to parse any entity data
+ byte[] inputBytes = new byte[dataSize];
+ data.readEntityData(inputBytes, 0, dataSize);
+ ByteArrayInputStream inputBuffer = new ByteArrayInputStream(inputBytes);
+ DataInputStream inputBufferStream = new DataInputStream(inputBuffer);
+
+ if (key.equals(GLOBAL_METADATA_KEY)) {
+ int storedSdkVersion = inputBufferStream.readInt();
+ if (DEBUG) Slog.v(TAG, " storedSystemVersion = " + storedSystemVersion);
+ mStoredSdkVersion = storedSdkVersion;
+ mStoredIncrementalVersion = inputBufferStream.readUTF();
+ mHasMetadata = true;
+ if (DEBUG) {
+ Slog.i(TAG, "Restore set version " + storedSystemVersion
+ + " is compatible with OS version " + Build.VERSION.SDK_INT
+ + " (" + mStoredIncrementalVersion + " vs "
+ + Build.VERSION.INCREMENTAL + ")");
+ }
+ } else if (key.equals(DEFAULT_HOME_KEY)) {
+ String cn = inputBufferStream.readUTF();
+ mRestoredHome = ComponentName.unflattenFromString(cn);
+ mRestoredHomeVersion = inputBufferStream.readLong();
+ mRestoredHomeInstaller = inputBufferStream.readUTF();
+ mRestoredHomeSigHashes = readSignatureHashArray(inputBufferStream);
+ if (DEBUG) {
+ Slog.i(TAG, " read preferred home app " + mRestoredHome
+ + " version=" + mRestoredHomeVersion
+ + " installer=" + mRestoredHomeInstaller
+ + " sig=" + mRestoredHomeSigHashes);
+ }
+ } else {
+ // it's a file metadata record
+ int versionCodeInt = inputBufferStream.readInt();
+ long versionCode;
+ if (versionCodeInt == Integer.MIN_VALUE) {
+ versionCode = inputBufferStream.readLong();
+ } else {
+ versionCode = versionCodeInt;
+ }
+ ArrayList<byte[]> sigs = readSignatureHashArray(inputBufferStream);
+ if (DEBUG) {
+ Slog.i(TAG, " read metadata for " + key
+ + " dataSize=" + dataSize
+ + " versionCode=" + versionCode + " sigs=" + sigs);
+ }
+
+ if (sigs == null || sigs.size() == 0) {
+ Slog.w(TAG, "Not restoring package " + key
+ + " since it appears to have no signatures.");
+ continue;
+ }
+
+ ApplicationInfo app = new ApplicationInfo();
+ app.packageName = key;
+ restoredApps.add(app);
+ sigMap.put(key, new Metadata(versionCode, sigs));
+ }
+ }
+
+ // On successful completion, cache the signature map for the Backup Manager to use
+ mRestoredSignatures = sigMap;
+ }
+ }
}
diff --git a/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java b/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java
index 51c44e1..b99d341 100644
--- a/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java
+++ b/services/backup/java/com/android/server/backup/RefactoredBackupManagerService.java
@@ -148,6 +148,7 @@
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;
@@ -1605,9 +1606,15 @@
return BackupManager.ERROR_BACKUP_NOT_ALLOWED;
}
- TransportClient transportClient =
- mTransportManager.getCurrentTransportClient("BMS.requestBackup()");
- if (transportClient == null) {
+ final TransportClient transportClient;
+ final String transportDirName;
+ try {
+ transportDirName =
+ mTransportManager.getTransportDirName(
+ mTransportManager.getCurrentTransportName());
+ transportClient =
+ mTransportManager.getCurrentTransportClientOrThrow("BMS.requestBackup()");
+ } catch (TransportNotRegisteredException e) {
BackupObserverUtils.sendBackupFinished(observer, BackupManager.ERROR_TRANSPORT_ABORTED);
monitor = BackupManagerMonitorUtils.monitorEvent(monitor,
BackupManagerMonitor.LOG_EVENT_ID_TRANSPORT_IS_NULL,
@@ -1652,12 +1659,11 @@
+ " k/v backups");
}
- String dirName = transportClient.getTransportDirName();
boolean nonIncrementalBackup = (flags & BackupManager.FLAG_NON_INCREMENTAL_BACKUP) != 0;
Message msg = mBackupHandler.obtainMessage(MSG_REQUEST_BACKUP);
- msg.obj = new BackupParams(transportClient, dirName, kvBackupList, fullBackupList, observer,
- monitor, listener, true, nonIncrementalBackup);
+ msg.obj = new BackupParams(transportClient, transportDirName, kvBackupList, fullBackupList,
+ observer, monitor, listener, true, nonIncrementalBackup);
mBackupHandler.sendMessage(msg);
return BackupManager.SUCCESS;
}
@@ -3095,29 +3101,30 @@
}
}
- // Supply the configuration summary string for the given transport. If the name is
- // not one of the available transports, or if the transport does not supply any
- // summary / destination string, the method can return null.
- //
- // This string is used VERBATIM as the summary text of the relevant Settings item!
+ /**
+ * Supply the current destination string for the given transport. If the name is not one of the
+ * registered transports the method will return null.
+ *
+ * <p>This string is used VERBATIM as the summary text of the relevant Settings item.
+ *
+ * @param transportName The name of the registered transport.
+ * @return The current destination string or null if the transport is not registered.
+ */
@Override
public String getDestinationString(String transportName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "getDestinationString");
+ mContext.enforceCallingOrSelfPermission(
+ android.Manifest.permission.BACKUP, "getDestinationString");
- final IBackupTransport transport = mTransportManager.getTransportBinder(transportName);
- if (transport != null) {
- try {
- final String text = transport.currentDestinationString();
- if (MORE_DEBUG) Slog.d(TAG, "getDestinationString() returning " + text);
- return text;
- } catch (Exception e) {
- /* fall through to return null */
- Slog.e(TAG, "Unable to get string from transport: " + e.getMessage());
+ try {
+ String string = mTransportManager.getTransportCurrentDestinationString(transportName);
+ if (MORE_DEBUG) {
+ Slog.d(TAG, "getDestinationString() returning " + string);
}
+ return string;
+ } catch (TransportNotRegisteredException e) {
+ Slog.e(TAG, "Unable to get destination string from transport: " + e.getMessage());
+ return null;
}
-
- return null;
}
// Supply the manage-data intent for the given transport.
@@ -3387,31 +3394,41 @@
@Override
public boolean isAppEligibleForBackup(String packageName) {
- mContext.enforceCallingOrSelfPermission(android.Manifest.permission.BACKUP,
- "isAppEligibleForBackup");
- try {
- PackageInfo packageInfo = mPackageManager.getPackageInfo(packageName,
- PackageManager.GET_SIGNATURES);
- if (!AppBackupUtils.appIsEligibleForBackup(packageInfo.applicationInfo,
- mPackageManager) ||
- AppBackupUtils.appIsStopped(packageInfo.applicationInfo) ||
- AppBackupUtils.appIsDisabled(packageInfo.applicationInfo, mPackageManager)) {
- return false;
- }
- IBackupTransport transport = mTransportManager.getCurrentTransportBinder();
- if (transport != null) {
- try {
- return transport.isAppEligibleForBackup(packageInfo,
- AppBackupUtils.appGetsFullBackup(packageInfo));
- } catch (Exception e) {
- Slog.e(TAG, "Unable to ask about eligibility: " + e.getMessage());
- }
- }
- // If transport is not present we couldn't tell that the package is not eligible.
- return true;
- } catch (NameNotFoundException e) {
- return false;
+ mContext.enforceCallingOrSelfPermission(
+ android.Manifest.permission.BACKUP, "isAppEligibleForBackup");
+
+ String callerLogString = "BMS.isAppEligibleForBackup";
+ TransportClient transportClient =
+ mTransportManager.getCurrentTransportClient(callerLogString);
+ boolean eligible =
+ AppBackupUtils.appIsRunningAndEligibleForBackupWithTransport(
+ transportClient, packageName, mPackageManager);
+ if (transportClient != null) {
+ mTransportManager.disposeOfTransportClient(transportClient, callerLogString);
}
+ return eligible;
+ }
+
+ @Override
+ public String[] filterAppsEligibleForBackup(String[] packages) {
+ mContext.enforceCallingOrSelfPermission(
+ android.Manifest.permission.BACKUP, "filterAppsEligibleForBackup");
+
+ String callerLogString = "BMS.filterAppsEligibleForBackup";
+ TransportClient transportClient =
+ mTransportManager.getCurrentTransportClient(callerLogString);
+ List<String> eligibleApps = new LinkedList<>();
+ for (String packageName : packages) {
+ if (AppBackupUtils
+ .appIsRunningAndEligibleForBackupWithTransport(
+ transportClient, packageName, mPackageManager)) {
+ eligibleApps.add(packageName);
+ }
+ }
+ if (transportClient != null) {
+ mTransportManager.disposeOfTransportClient(transportClient, callerLogString);
+ }
+ return eligibleApps.toArray(new String[eligibleApps.size()]);
}
@Override
@@ -3475,10 +3492,10 @@
pw.println((t.equals(mTransportManager.getCurrentTransportName()) ? " * "
: " ") + t);
try {
- IBackupTransport transport = mTransportManager.getTransportBinder(t);
File dir = new File(mBaseStateDir,
mTransportManager.getTransportDirName(t));
- pw.println(" destination: " + transport.currentDestinationString());
+ pw.println(" destination: "
+ + mTransportManager.getTransportCurrentDestinationString(t));
pw.println(" intent: "
+ mTransportManager.getTransportConfigurationIntent(t));
for (File f : dir.listFiles()) {
diff --git a/services/backup/java/com/android/server/backup/Trampoline.java b/services/backup/java/com/android/server/backup/Trampoline.java
index 94a26275..a628c9d 100644
--- a/services/backup/java/com/android/server/backup/Trampoline.java
+++ b/services/backup/java/com/android/server/backup/Trampoline.java
@@ -452,6 +452,12 @@
}
@Override
+ public String[] filterAppsEligibleForBackup(String[] packages) {
+ BackupManagerServiceInterface svc = mService;
+ return (svc != null) ? svc.filterAppsEligibleForBackup(packages) : null;
+ }
+
+ @Override
public int requestBackup(String[] packages, IBackupObserver observer,
IBackupManagerMonitor monitor, int flags) throws RemoteException {
BackupManagerServiceInterface svc = mService;
diff --git a/services/backup/java/com/android/server/backup/TransportManager.java b/services/backup/java/com/android/server/backup/TransportManager.java
index fbdb183..72a3a32 100644
--- a/services/backup/java/com/android/server/backup/TransportManager.java
+++ b/services/backup/java/com/android/server/backup/TransportManager.java
@@ -49,6 +49,7 @@
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.transport.TransportClientManager;
import com.android.server.backup.transport.TransportConnectionListener;
+import com.android.server.backup.transport.TransportNotAvailableException;
import com.android.server.backup.transport.TransportNotRegisteredException;
import java.util.ArrayList;
@@ -265,6 +266,18 @@
}
/**
+ * Retrieve the current destination string of {@code transportName}.
+ * @throws TransportNotRegisteredException if the transport is not registered.
+ */
+ public String getTransportCurrentDestinationString(String transportName)
+ throws TransportNotRegisteredException {
+ synchronized (mTransportLock) {
+ return getRegisteredTransportDescriptionOrThrowLocked(transportName)
+ .currentDestinationString;
+ }
+ }
+
+ /**
* Retrieve the data management label of {@code transportName}.
* @throws TransportNotRegisteredException if the transport is not registered.
*/
@@ -290,6 +303,18 @@
}
/**
+ * Retrieve the transport dir name of {@code transportComponent}.
+ * @throws TransportNotRegisteredException if the transport is not registered.
+ */
+ public String getTransportDirName(ComponentName transportComponent)
+ throws TransportNotRegisteredException {
+ synchronized (mTransportLock) {
+ return getRegisteredTransportDescriptionOrThrowLocked(transportComponent)
+ .transportDirName;
+ }
+ }
+
+ /**
* Execute {@code transportConsumer} for each registered transport passing the transport name.
* This is called with an internal lock held, ensuring that the transport will remain registered
* while {@code transportConsumer} is being executed. Don't do heavy operations in
@@ -358,7 +383,6 @@
return description;
}
-
@GuardedBy("mTransportLock")
@Nullable
private Map.Entry<ComponentName, TransportDescription> getRegisteredTransportEntryLocked(
@@ -373,17 +397,35 @@
return null;
}
+ @GuardedBy("mTransportLock")
+ private TransportDescription getRegisteredTransportDescriptionOrThrowLocked(
+ ComponentName transportComponent) throws TransportNotRegisteredException {
+ TransportDescription description =
+ mRegisteredTransportsDescriptionMap.get(transportComponent);
+ if (description == null) {
+ throw new TransportNotRegisteredException(transportComponent);
+ }
+ return description;
+ }
+
@Nullable
public TransportClient getTransportClient(String transportName, String caller) {
+ try {
+ return getTransportClientOrThrow(transportName, caller);
+ } catch (TransportNotRegisteredException e) {
+ Slog.w(TAG, "Transport " + transportName + " not registered");
+ return null;
+ }
+ }
+
+ public TransportClient getTransportClientOrThrow(String transportName, String caller)
+ throws TransportNotRegisteredException {
synchronized (mTransportLock) {
ComponentName component = getRegisteredTransportComponentLocked(transportName);
if (component == null) {
- Slog.w(TAG, "Transport " + transportName + " not registered");
- return null;
+ throw new TransportNotRegisteredException(transportName);
}
- TransportDescription description = mRegisteredTransportsDescriptionMap.get(component);
- return mTransportClientManager.getTransportClient(
- component, description.transportDirName, caller);
+ return mTransportClientManager.getTransportClient(component, caller);
}
}
@@ -403,7 +445,25 @@
*/
@Nullable
public TransportClient getCurrentTransportClient(String caller) {
- return getTransportClient(mCurrentTransportName, caller);
+ synchronized (mTransportLock) {
+ return getTransportClient(mCurrentTransportName, caller);
+ }
+ }
+
+ /**
+ * Returns a {@link TransportClient} for the current transport or throws if not registered.
+ *
+ * @param caller A {@link String} identifying the caller for logging/debugging purposes. Check
+ * {@link TransportClient#connectAsync(TransportConnectionListener, String)} for more
+ * details.
+ * @return A {@link TransportClient}.
+ * @throws TransportNotRegisteredException if the transport is not registered.
+ */
+ public TransportClient getCurrentTransportClientOrThrow(String caller)
+ throws TransportNotRegisteredException {
+ synchronized (mTransportLock) {
+ return getTransportClientOrThrow(mCurrentTransportName, caller);
+ }
}
/**
diff --git a/services/backup/java/com/android/server/backup/internal/PerformClearTask.java b/services/backup/java/com/android/server/backup/internal/PerformClearTask.java
index 84ca59b..140d7286 100644
--- a/services/backup/java/com/android/server/backup/internal/PerformClearTask.java
+++ b/services/backup/java/com/android/server/backup/internal/PerformClearTask.java
@@ -23,12 +23,14 @@
import com.android.internal.backup.IBackupTransport;
import com.android.server.backup.RefactoredBackupManagerService;
+import com.android.server.backup.TransportManager;
import com.android.server.backup.transport.TransportClient;
import java.io.File;
public class PerformClearTask implements Runnable {
private final RefactoredBackupManagerService mBackupManagerService;
+ private final TransportManager mTransportManager;
private final TransportClient mTransportClient;
private final PackageInfo mPackage;
private final OnTaskFinishedListener mListener;
@@ -37,6 +39,7 @@
TransportClient transportClient, PackageInfo packageInfo,
OnTaskFinishedListener listener) {
mBackupManagerService = backupManagerService;
+ mTransportManager = backupManagerService.getTransportManager();
mTransportClient = transportClient;
mPackage = packageInfo;
mListener = listener;
@@ -47,8 +50,9 @@
IBackupTransport transport = null;
try {
// Clear the on-device backup state to ensure a full backup next time
- File stateDir = new File(mBackupManagerService.getBaseStateDir(),
- mTransportClient.getTransportDirName());
+ String transportDirName =
+ mTransportManager.getTransportDirName(mTransportClient.getTransportComponent());
+ File stateDir = new File(mBackupManagerService.getBaseStateDir(), transportDirName);
File stateFile = new File(stateDir, mPackage.packageName);
stateFile.delete();
diff --git a/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java b/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java
index c624698..2f2af98 100644
--- a/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java
+++ b/services/backup/java/com/android/server/backup/internal/PerformInitializeTask.java
@@ -122,7 +122,9 @@
transportClientsToDisposeOf.add(transportClient);
Slog.i(TAG, "Initializing (wiping) backup transport storage: " + transportName);
- String transportDirName = transportClient.getTransportDirName();
+ String transportDirName =
+ mTransportManager.getTransportDirName(
+ transportClient.getTransportComponent());
EventLog.writeEvent(EventLogTags.BACKUP_START, transportDirName);
long startRealtime = SystemClock.elapsedRealtime();
diff --git a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
index 86866dc..88f9ead 100644
--- a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
+++ b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java
@@ -61,6 +61,7 @@
import com.android.server.backup.PackageManagerBackupAgent;
import com.android.server.backup.PackageManagerBackupAgent.Metadata;
import com.android.server.backup.RefactoredBackupManagerService;
+import com.android.server.backup.TransportManager;
import com.android.server.backup.internal.OnTaskFinishedListener;
import com.android.server.backup.transport.TransportClient;
import com.android.server.backup.utils.AppBackupUtils;
@@ -78,6 +79,7 @@
public class PerformUnifiedRestoreTask implements BackupRestoreTask {
private RefactoredBackupManagerService backupManagerService;
+ private final TransportManager mTransportManager;
// Transport client we're working with to do the restore
private final TransportClient mTransportClient;
@@ -164,6 +166,7 @@
int pmToken, boolean isFullSystemRestore, String[] filterSet,
OnTaskFinishedListener listener) {
this.backupManagerService = backupManagerService;
+ mTransportManager = backupManagerService.getTransportManager();
mEphemeralOpToken = backupManagerService.generateRandomIntegerToken();
mState = UnifiedRestoreState.INITIAL;
mStartRealtime = SystemClock.elapsedRealtime();
@@ -349,8 +352,9 @@
}
try {
- String transportDir = mTransportClient.getTransportDirName();
- mStateDir = new File(backupManagerService.getBaseStateDir(), transportDir);
+ String transportDirName =
+ mTransportManager.getTransportDirName(mTransportClient.getTransportComponent());
+ mStateDir = new File(backupManagerService.getBaseStateDir(), transportDirName);
// Fetch the current metadata from the dataset first
PackageInfo pmPackage = new PackageInfo();
diff --git a/services/backup/java/com/android/server/backup/transport/TransportClient.java b/services/backup/java/com/android/server/backup/transport/TransportClient.java
index 2c7a0eb..7bd9111 100644
--- a/services/backup/java/com/android/server/backup/transport/TransportClient.java
+++ b/services/backup/java/com/android/server/backup/transport/TransportClient.java
@@ -68,7 +68,6 @@
private final Intent mBindIntent;
private final String mIdentifier;
private final ComponentName mTransportComponent;
- private final String mTransportDirName;
private final Handler mListenerHandler;
private final String mPrefixForLog;
private final Object mStateLock = new Object();
@@ -87,13 +86,11 @@
Context context,
Intent bindIntent,
ComponentName transportComponent,
- String transportDirName,
String identifier) {
this(
context,
bindIntent,
transportComponent,
- transportDirName,
identifier,
new Handler(Looper.getMainLooper()));
}
@@ -103,12 +100,10 @@
Context context,
Intent bindIntent,
ComponentName transportComponent,
- String transportDirName,
String identifier,
Handler listenerHandler) {
mContext = context;
mTransportComponent = transportComponent;
- mTransportDirName = transportDirName;
mBindIntent = bindIntent;
mIdentifier = identifier;
mListenerHandler = listenerHandler;
@@ -122,10 +117,6 @@
return mTransportComponent;
}
- public String getTransportDirName() {
- return mTransportDirName;
- }
-
// Calls to onServiceDisconnected() or onBindingDied() turn TransportClient UNUSABLE. After one
// of these calls, if a binding happen again the new service can be a different instance. Since
// transports are stateful, we don't want a new instance responding for an old instance's state.
diff --git a/services/backup/java/com/android/server/backup/transport/TransportClientManager.java b/services/backup/java/com/android/server/backup/transport/TransportClientManager.java
index bb550f6..1cbe7471 100644
--- a/services/backup/java/com/android/server/backup/transport/TransportClientManager.java
+++ b/services/backup/java/com/android/server/backup/transport/TransportClientManager.java
@@ -23,7 +23,6 @@
import android.content.Intent;
import android.util.Log;
-import com.android.internal.backup.IBackupTransport;
import com.android.server.backup.TransportManager;
/**
@@ -48,17 +47,12 @@
* transportComponent}.
*
* @param transportComponent The {@link ComponentName} of the transport.
- * @param transportDirName The {@link String} returned by
- * {@link IBackupTransport#transportDirName()} at registration.
* @param caller A {@link String} identifying the caller for logging/debugging purposes. Check
* {@link TransportClient#connectAsync(TransportConnectionListener, String)} for more
* details.
* @return A {@link TransportClient}.
*/
- public TransportClient getTransportClient(
- ComponentName transportComponent,
- String transportDirName,
- String caller) {
+ public TransportClient getTransportClient(ComponentName transportComponent, String caller) {
Intent bindIntent =
new Intent(SERVICE_ACTION_TRANSPORT_HOST).setComponent(transportComponent);
synchronized (mTransportClientsLock) {
@@ -67,7 +61,6 @@
mContext,
bindIntent,
transportComponent,
- transportDirName,
Integer.toString(mTransportClientsCreated));
mTransportClientsCreated++;
TransportUtils.log(Log.DEBUG, TAG, caller, "Retrieving " + transportClient);
diff --git a/services/backup/java/com/android/server/backup/transport/TransportNotRegisteredException.java b/services/backup/java/com/android/server/backup/transport/TransportNotRegisteredException.java
index 26bf92c..02766de 100644
--- a/services/backup/java/com/android/server/backup/transport/TransportNotRegisteredException.java
+++ b/services/backup/java/com/android/server/backup/transport/TransportNotRegisteredException.java
@@ -16,6 +16,7 @@
package com.android.server.backup.transport;
+import android.content.ComponentName;
import android.util.AndroidException;
import com.android.server.backup.TransportManager;
@@ -32,4 +33,8 @@
public TransportNotRegisteredException(String transportName) {
super("Transport " + transportName + " not registered");
}
+
+ public TransportNotRegisteredException(ComponentName transportComponent) {
+ super("Transport for host " + transportComponent + " not registered");
+ }
}
diff --git a/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java b/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java
index d7cac77..dbf1a826 100644
--- a/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java
+++ b/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java
@@ -20,6 +20,8 @@
import static com.android.server.backup.RefactoredBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE;
import static com.android.server.backup.RefactoredBackupManagerService.TAG;
+import android.annotation.Nullable;
+import android.app.backup.BackupTransport;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
@@ -27,7 +29,9 @@
import android.os.Process;
import android.util.Slog;
+import com.android.internal.backup.IBackupTransport;
import com.android.internal.util.ArrayUtils;
+import com.android.server.backup.transport.TransportClient;
/**
* Utility methods wrapping operations on ApplicationInfo and PackageInfo.
@@ -71,6 +75,44 @@
return !appIsDisabled(app, pm);
}
+ /**
+ * Returns whether an app is eligible for backup at runtime. That is, the app has to:
+ * <ol>
+ * <li>Return true for {@link #appIsEligibleForBackup(ApplicationInfo, PackageManager)}
+ * <li>Return false for {@link #appIsStopped(ApplicationInfo)}
+ * <li>Return false for {@link #appIsDisabled(ApplicationInfo, PackageManager)}
+ * <li>Be eligible for the transport via
+ * {@link BackupTransport#isAppEligibleForBackup(PackageInfo, boolean)}
+ * </ol>
+ */
+ public static boolean appIsRunningAndEligibleForBackupWithTransport(
+ @Nullable TransportClient transportClient, String packageName, PackageManager pm) {
+ try {
+ PackageInfo packageInfo = pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
+ ApplicationInfo applicationInfo = packageInfo.applicationInfo;
+ if (!appIsEligibleForBackup(applicationInfo, pm)
+ || appIsStopped(applicationInfo)
+ || appIsDisabled(applicationInfo, pm)) {
+ return false;
+ }
+ if (transportClient != null) {
+ try {
+ IBackupTransport transport =
+ transportClient.connectOrThrow(
+ "AppBackupUtils.appIsEligibleForBackupAtRuntime");
+ return transport.isAppEligibleForBackup(
+ packageInfo, AppBackupUtils.appGetsFullBackup(packageInfo));
+ } catch (Exception e) {
+ Slog.e(TAG, "Unable to ask about eligibility: " + e.getMessage());
+ }
+ }
+ // If transport is not present we couldn't tell that the package is not eligible.
+ return true;
+ } catch (PackageManager.NameNotFoundException e) {
+ return false;
+ }
+ }
+
/** Avoid backups of 'disabled' apps. */
public static boolean appIsDisabled(ApplicationInfo app, PackageManager pm) {
switch (pm.getApplicationEnabledSetting(app.packageName)) {
diff --git a/services/core/java/com/android/server/AlarmManagerService.java b/services/core/java/com/android/server/AlarmManagerService.java
index 472723d..a024d5a 100644
--- a/services/core/java/com/android/server/AlarmManagerService.java
+++ b/services/core/java/com/android/server/AlarmManagerService.java
@@ -149,6 +149,9 @@
private long mNextNonWakeup;
private long mLastWakeupSet;
private long mLastWakeup;
+ private long mLastTickSet;
+ private long mLastTickIssued; // elapsed
+ private long mLastTickReceived;
int mBroadcastRefCount = 0;
PowerManager.WakeLock mWakeLock;
boolean mLastWakeLockUnimportantForLogging;
@@ -1596,6 +1599,7 @@
pw.println();
mForceAppStandbyTracker.dump(pw, " ");
+ pw.println();
final long nowRTC = System.currentTimeMillis();
final long nowELAPSED = SystemClock.elapsedRealtime();
@@ -1607,8 +1611,12 @@
pw.println();
pw.print(" mLastTimeChangeClockTime="); pw.print(mLastTimeChangeClockTime);
pw.print("="); pw.println(sdf.format(new Date(mLastTimeChangeClockTime)));
- pw.print(" mLastTimeChangeRealtime=");
- TimeUtils.formatDuration(mLastTimeChangeRealtime, pw);
+ pw.print(" mLastTimeChangeRealtime="); pw.println(mLastTimeChangeRealtime);
+ pw.print(" mLastTickIssued=");
+ TimeUtils.formatDuration(mLastTickIssued - nowELAPSED, pw);
+ pw.println();
+ pw.print(" mLastTickReceived="); pw.println(sdf.format(new Date(mLastTickReceived)));
+ pw.print(" mLastTickSet="); pw.println(sdf.format(new Date(mLastTickSet)));
pw.println();
if (!mInteractive) {
pw.print(" Time since non-interactive: ");
@@ -3284,6 +3292,9 @@
if (DEBUG_BATCH) {
Slog.v(TAG, "Received TIME_TICK alarm; rescheduling");
}
+ synchronized (mLock) {
+ mLastTickReceived = System.currentTimeMillis();
+ }
scheduleTimeTickEvent();
} else if (intent.getAction().equals(Intent.ACTION_DATE_CHANGED)) {
// Since the kernel does not keep track of DST, we need to
@@ -3309,6 +3320,11 @@
setImpl(ELAPSED_REALTIME, SystemClock.elapsedRealtime() + tickEventDelay, 0,
0, mTimeTickSender, null, null, AlarmManager.FLAG_STANDALONE, workSource,
null, Process.myUid(), "android");
+
+ // Finally, remember when we set the tick alarm
+ synchronized (mLock) {
+ mLastTickSet = currentTime;
+ }
}
public void scheduleDateChangedEvent() {
@@ -3660,6 +3676,11 @@
if (alarm.operation != null) {
// PendingIntent alarm
mSendCount++;
+
+ if (alarm.priorityClass.priority == PRIO_TICK) {
+ mLastTickIssued = nowELAPSED;
+ }
+
try {
alarm.operation.send(getContext(), 0,
mBackgroundIntent.putExtra(
diff --git a/services/core/java/com/android/server/DeviceIdleController.java b/services/core/java/com/android/server/DeviceIdleController.java
index 6f697c4..985f16d 100644
--- a/services/core/java/com/android/server/DeviceIdleController.java
+++ b/services/core/java/com/android/server/DeviceIdleController.java
@@ -795,64 +795,65 @@
Slog.e(TAG, "Bad device idle settings", e);
}
- LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getLong(
+ LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getDurationMillis(
KEY_LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT,
!COMPRESS_TIME ? 5 * 60 * 1000L : 15 * 1000L);
- LIGHT_PRE_IDLE_TIMEOUT = mParser.getLong(KEY_LIGHT_PRE_IDLE_TIMEOUT,
+ LIGHT_PRE_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_PRE_IDLE_TIMEOUT,
!COMPRESS_TIME ? 10 * 60 * 1000L : 30 * 1000L);
- LIGHT_IDLE_TIMEOUT = mParser.getLong(KEY_LIGHT_IDLE_TIMEOUT,
+ LIGHT_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_IDLE_TIMEOUT,
!COMPRESS_TIME ? 5 * 60 * 1000L : 15 * 1000L);
LIGHT_IDLE_FACTOR = mParser.getFloat(KEY_LIGHT_IDLE_FACTOR,
2f);
- LIGHT_MAX_IDLE_TIMEOUT = mParser.getLong(KEY_LIGHT_MAX_IDLE_TIMEOUT,
+ LIGHT_MAX_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_MAX_IDLE_TIMEOUT,
!COMPRESS_TIME ? 15 * 60 * 1000L : 60 * 1000L);
- LIGHT_IDLE_MAINTENANCE_MIN_BUDGET = mParser.getLong(
+ LIGHT_IDLE_MAINTENANCE_MIN_BUDGET = mParser.getDurationMillis(
KEY_LIGHT_IDLE_MAINTENANCE_MIN_BUDGET,
!COMPRESS_TIME ? 1 * 60 * 1000L : 15 * 1000L);
- LIGHT_IDLE_MAINTENANCE_MAX_BUDGET = mParser.getLong(
+ LIGHT_IDLE_MAINTENANCE_MAX_BUDGET = mParser.getDurationMillis(
KEY_LIGHT_IDLE_MAINTENANCE_MAX_BUDGET,
!COMPRESS_TIME ? 5 * 60 * 1000L : 30 * 1000L);
- MIN_LIGHT_MAINTENANCE_TIME = mParser.getLong(
+ MIN_LIGHT_MAINTENANCE_TIME = mParser.getDurationMillis(
KEY_MIN_LIGHT_MAINTENANCE_TIME,
!COMPRESS_TIME ? 5 * 1000L : 1 * 1000L);
- MIN_DEEP_MAINTENANCE_TIME = mParser.getLong(
+ MIN_DEEP_MAINTENANCE_TIME = mParser.getDurationMillis(
KEY_MIN_DEEP_MAINTENANCE_TIME,
!COMPRESS_TIME ? 30 * 1000L : 5 * 1000L);
long inactiveTimeoutDefault = (mSmallBatteryDevice ? 15 : 30) * 60 * 1000L;
- INACTIVE_TIMEOUT = mParser.getLong(KEY_INACTIVE_TIMEOUT,
+ INACTIVE_TIMEOUT = mParser.getDurationMillis(KEY_INACTIVE_TIMEOUT,
!COMPRESS_TIME ? inactiveTimeoutDefault : (inactiveTimeoutDefault / 10));
- SENSING_TIMEOUT = mParser.getLong(KEY_SENSING_TIMEOUT,
+ SENSING_TIMEOUT = mParser.getDurationMillis(KEY_SENSING_TIMEOUT,
!DEBUG ? 4 * 60 * 1000L : 60 * 1000L);
- LOCATING_TIMEOUT = mParser.getLong(KEY_LOCATING_TIMEOUT,
+ LOCATING_TIMEOUT = mParser.getDurationMillis(KEY_LOCATING_TIMEOUT,
!DEBUG ? 30 * 1000L : 15 * 1000L);
LOCATION_ACCURACY = mParser.getFloat(KEY_LOCATION_ACCURACY, 20);
- MOTION_INACTIVE_TIMEOUT = mParser.getLong(KEY_MOTION_INACTIVE_TIMEOUT,
+ MOTION_INACTIVE_TIMEOUT = mParser.getDurationMillis(KEY_MOTION_INACTIVE_TIMEOUT,
!COMPRESS_TIME ? 10 * 60 * 1000L : 60 * 1000L);
long idleAfterInactiveTimeout = (mSmallBatteryDevice ? 15 : 30) * 60 * 1000L;
- IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getLong(KEY_IDLE_AFTER_INACTIVE_TIMEOUT,
+ IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getDurationMillis(
+ KEY_IDLE_AFTER_INACTIVE_TIMEOUT,
!COMPRESS_TIME ? idleAfterInactiveTimeout
: (idleAfterInactiveTimeout / 10));
- IDLE_PENDING_TIMEOUT = mParser.getLong(KEY_IDLE_PENDING_TIMEOUT,
+ IDLE_PENDING_TIMEOUT = mParser.getDurationMillis(KEY_IDLE_PENDING_TIMEOUT,
!COMPRESS_TIME ? 5 * 60 * 1000L : 30 * 1000L);
- MAX_IDLE_PENDING_TIMEOUT = mParser.getLong(KEY_MAX_IDLE_PENDING_TIMEOUT,
+ MAX_IDLE_PENDING_TIMEOUT = mParser.getDurationMillis(KEY_MAX_IDLE_PENDING_TIMEOUT,
!COMPRESS_TIME ? 10 * 60 * 1000L : 60 * 1000L);
IDLE_PENDING_FACTOR = mParser.getFloat(KEY_IDLE_PENDING_FACTOR,
2f);
- IDLE_TIMEOUT = mParser.getLong(KEY_IDLE_TIMEOUT,
+ IDLE_TIMEOUT = mParser.getDurationMillis(KEY_IDLE_TIMEOUT,
!COMPRESS_TIME ? 60 * 60 * 1000L : 6 * 60 * 1000L);
- MAX_IDLE_TIMEOUT = mParser.getLong(KEY_MAX_IDLE_TIMEOUT,
+ MAX_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_MAX_IDLE_TIMEOUT,
!COMPRESS_TIME ? 6 * 60 * 60 * 1000L : 30 * 60 * 1000L);
IDLE_FACTOR = mParser.getFloat(KEY_IDLE_FACTOR,
2f);
- MIN_TIME_TO_ALARM = mParser.getLong(KEY_MIN_TIME_TO_ALARM,
+ MIN_TIME_TO_ALARM = mParser.getDurationMillis(KEY_MIN_TIME_TO_ALARM,
!COMPRESS_TIME ? 60 * 60 * 1000L : 6 * 60 * 1000L);
- MAX_TEMP_APP_WHITELIST_DURATION = mParser.getLong(
+ MAX_TEMP_APP_WHITELIST_DURATION = mParser.getDurationMillis(
KEY_MAX_TEMP_APP_WHITELIST_DURATION, 5 * 60 * 1000L);
- MMS_TEMP_APP_WHITELIST_DURATION = mParser.getLong(
+ MMS_TEMP_APP_WHITELIST_DURATION = mParser.getDurationMillis(
KEY_MMS_TEMP_APP_WHITELIST_DURATION, 60 * 1000L);
- SMS_TEMP_APP_WHITELIST_DURATION = mParser.getLong(
+ SMS_TEMP_APP_WHITELIST_DURATION = mParser.getDurationMillis(
KEY_SMS_TEMP_APP_WHITELIST_DURATION, 20 * 1000L);
- NOTIFICATION_WHITELIST_DURATION = mParser.getLong(
+ NOTIFICATION_WHITELIST_DURATION = mParser.getDurationMillis(
KEY_NOTIFICATION_WHITELIST_DURATION, 30 * 1000L);
}
}
diff --git a/services/core/java/com/android/server/EventLogTags.logtags b/services/core/java/com/android/server/EventLogTags.logtags
index 6174aec..8361132 100644
--- a/services/core/java/com/android/server/EventLogTags.logtags
+++ b/services/core/java/com/android/server/EventLogTags.logtags
@@ -261,6 +261,10 @@
2756 fstrim_finish (time|2|3)
# ---------------------------
+# Job scheduler
+# ---------------------------
+8000 job_deferred_execution (time|2|3)
+
# AudioService.java
# ---------------------------
40000 volume_changed (stream|1), (prev_level|1), (level|1), (max_level|1), (caller|3)
diff --git a/services/core/java/com/android/server/IpSecService.java b/services/core/java/com/android/server/IpSecService.java
index 989cb88..5c098e3 100644
--- a/services/core/java/com/android/server/IpSecService.java
+++ b/services/core/java/com/android/server/IpSecService.java
@@ -102,8 +102,14 @@
/* Binder context for this service */
private final Context mContext;
- /** Should be a never-repeating global ID for resources */
- private static AtomicInteger mNextResourceId = new AtomicInteger(0x00FADED0);
+ /**
+ * The next non-repeating global ID for tracking resources between users, this service,
+ * and kernel data structures. Accessing this variable is not thread safe, so it is
+ * only read or modified within blocks synchronized on IpSecService.this. We want to
+ * avoid -1 (INVALID_RESOURCE_ID) and 0 (we probably forgot to initialize it).
+ */
+ @GuardedBy("IpSecService.this")
+ private int mNextResourceId = 1;
interface IpSecServiceConfiguration {
INetd getNetdInstance() throws RemoteException;
@@ -856,7 +862,7 @@
checkNotNull(binder, "Null Binder passed to allocateSecurityParameterIndex");
UserRecord userRecord = mUserResourceTracker.getUserRecord(Binder.getCallingUid());
- int resourceId = mNextResourceId.getAndIncrement();
+ final int resourceId = mNextResourceId++;
int spi = IpSecManager.INVALID_SECURITY_PARAMETER_INDEX;
String localAddress = "";
@@ -979,7 +985,7 @@
int callingUid = Binder.getCallingUid();
UserRecord userRecord = mUserResourceTracker.getUserRecord(callingUid);
- int resourceId = mNextResourceId.getAndIncrement();
+ final int resourceId = mNextResourceId++;
FileDescriptor sockFd = null;
try {
if (!userRecord.mSocketQuotaTracker.isAvailable()) {
@@ -1102,7 +1108,7 @@
IpSecConfig c, IBinder binder) throws RemoteException {
checkIpSecConfig(c);
checkNotNull(binder, "Null Binder passed to createTransportModeTransform");
- int resourceId = mNextResourceId.getAndIncrement();
+ final int resourceId = mNextResourceId++;
UserRecord userRecord = mUserResourceTracker.getUserRecord(Binder.getCallingUid());
diff --git a/services/core/java/com/android/server/LocationManagerService.java b/services/core/java/com/android/server/LocationManagerService.java
index 57c992f..ea748db 100644
--- a/services/core/java/com/android/server/LocationManagerService.java
+++ b/services/core/java/com/android/server/LocationManagerService.java
@@ -2254,6 +2254,64 @@
}
}
+ /**
+ * Provides an interface to inject and set the last location if location is not available
+ * currently.
+ *
+ * This helps in cases where the product (Cars for example) has saved the last known location
+ * before powering off. This interface lets the client inject the saved location while the GPS
+ * chipset is getting its first fix, there by improving user experience.
+ *
+ * @param location - Location object to inject
+ * @return true if update was successful, false if not
+ */
+ @Override
+ public boolean injectLocation(Location location) {
+ mContext.enforceCallingPermission(android.Manifest.permission.LOCATION_HARDWARE,
+ "Location Hardware permission not granted to inject location");
+ mContext.enforceCallingPermission(android.Manifest.permission.ACCESS_FINE_LOCATION,
+ "Access Fine Location permission not granted to inject Location");
+
+ if (location == null) {
+ if (D) {
+ Log.d(TAG, "injectLocation(): called with null location");
+ }
+ return false;
+ }
+ LocationProviderInterface p = null;
+ String provider = location.getProvider();
+ if (provider != null) {
+ p = mProvidersByName.get(provider);
+ }
+ if (p == null) {
+ if (D) {
+ Log.d(TAG, "injectLocation(): unknown provider");
+ }
+ return false;
+ }
+ synchronized (mLock) {
+ if (!isAllowedByCurrentUserSettingsLocked(provider)) {
+ if (D) {
+ Log.d(TAG, "Location disabled in Settings for current user:" + mCurrentUserId);
+ }
+ return false;
+ } else {
+ // NOTE: If last location is already available, location is not injected. If
+ // provider's normal source (like a GPS chipset) have already provided an output,
+ // there is no need to inject this location.
+ if (mLastLocation.get(provider) == null) {
+ updateLastLocationLocked(location, provider);
+ } else {
+ if (D) {
+ Log.d(TAG, "injectLocation(): Location exists. Not updating");
+ }
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
@Override
public void requestGeofence(LocationRequest request, Geofence geofence, PendingIntent intent,
String packageName) {
@@ -2614,30 +2672,18 @@
private void handleLocationChangedLocked(Location location, boolean passive) {
if (D) Log.d(TAG, "incoming location: " + location);
-
long now = SystemClock.elapsedRealtime();
String provider = (passive ? LocationManager.PASSIVE_PROVIDER : location.getProvider());
-
// Skip if the provider is unknown.
LocationProviderInterface p = mProvidersByName.get(provider);
if (p == null) return;
-
- // Update last known locations
- Location noGPSLocation = location.getExtraLocation(Location.EXTRA_NO_GPS_LOCATION);
- Location lastNoGPSLocation;
+ updateLastLocationLocked(location, provider);
+ // mLastLocation should have been updated from the updateLastLocationLocked call above.
Location lastLocation = mLastLocation.get(provider);
if (lastLocation == null) {
- lastLocation = new Location(provider);
- mLastLocation.put(provider, lastLocation);
- } else {
- lastNoGPSLocation = lastLocation.getExtraLocation(Location.EXTRA_NO_GPS_LOCATION);
- if (noGPSLocation == null && lastNoGPSLocation != null) {
- // New location has no no-GPS location: adopt last no-GPS location. This is set
- // directly into location because we do not want to notify COARSE clients.
- location.setExtraLocation(Location.EXTRA_NO_GPS_LOCATION, lastNoGPSLocation);
- }
+ Log.e(TAG, "handleLocationChangedLocked() updateLastLocation failed");
+ return;
}
- lastLocation.set(location);
// Update last known coarse interval location if enough time has passed.
Location lastLocationCoarseInterval = mLastLocationCoarseInterval.get(provider);
@@ -2653,7 +2699,7 @@
// Don't ever return a coarse location that is more recent than the allowed update
// interval (i.e. don't allow an app to keep registering and unregistering for
// location updates to overcome the minimum interval).
- noGPSLocation =
+ Location noGPSLocation =
lastLocationCoarseInterval.getExtraLocation(Location.EXTRA_NO_GPS_LOCATION);
// Skip if there are no UpdateRecords for this provider.
@@ -2778,6 +2824,30 @@
}
}
+ /**
+ * Updates last location with the given location
+ *
+ * @param location new location to update
+ * @param provider Location provider to update for
+ */
+ private void updateLastLocationLocked(Location location, String provider) {
+ Location noGPSLocation = location.getExtraLocation(Location.EXTRA_NO_GPS_LOCATION);
+ Location lastNoGPSLocation;
+ Location lastLocation = mLastLocation.get(provider);
+ if (lastLocation == null) {
+ lastLocation = new Location(provider);
+ mLastLocation.put(provider, lastLocation);
+ } else {
+ lastNoGPSLocation = lastLocation.getExtraLocation(Location.EXTRA_NO_GPS_LOCATION);
+ if (noGPSLocation == null && lastNoGPSLocation != null) {
+ // New location has no no-GPS location: adopt last no-GPS location. This is set
+ // directly into location because we do not want to notify COARSE clients.
+ location.setExtraLocation(Location.EXTRA_NO_GPS_LOCATION, lastNoGPSLocation);
+ }
+ }
+ lastLocation.set(location);
+ }
+
private class LocationWorkerHandler extends Handler {
public LocationWorkerHandler(Looper looper) {
super(looper, null, true);
diff --git a/services/core/java/com/android/server/StorageManagerService.java b/services/core/java/com/android/server/StorageManagerService.java
index 90822d1..dc2f2a5 100644
--- a/services/core/java/com/android/server/StorageManagerService.java
+++ b/services/core/java/com/android/server/StorageManagerService.java
@@ -96,6 +96,7 @@
import android.text.format.DateUtils;
import android.util.ArrayMap;
import android.util.AtomicFile;
+import android.util.DataUnit;
import android.util.Log;
import android.util.Pair;
import android.util.Slog;
@@ -2190,7 +2191,7 @@
}
try {
- mVold.fdeEnable(type, password, IVold.ENCRYPTION_FLAG_IN_PLACE);
+ mVold.fdeEnable(type, password, 0);
} catch (Exception e) {
Slog.wtf(TAG, e);
return -1;
@@ -3508,8 +3509,8 @@
pw.print(") total size: ");
pw.print(pair.second);
pw.print(" (");
- pw.print((float) pair.second / TrafficStats.GB_IN_BYTES);
- pw.println(" GB)");
+ pw.print(DataUnit.MEBIBYTES.toBytes(pair.second));
+ pw.println(" MiB)");
}
pw.println("Force adoptable: " + mForceAdoptable);
pw.println();
diff --git a/services/core/java/com/android/server/VibratorService.java b/services/core/java/com/android/server/VibratorService.java
index 0e51fda..c1cda98 100644
--- a/services/core/java/com/android/server/VibratorService.java
+++ b/services/core/java/com/android/server/VibratorService.java
@@ -26,6 +26,7 @@
import android.database.ContentObserver;
import android.hardware.input.InputManager;
import android.hardware.vibrator.V1_0.Constants.EffectStrength;
+import android.icu.text.DateFormat;
import android.media.AudioManager;
import android.os.PowerManager.ServiceType;
import android.os.PowerSaveState;
@@ -62,6 +63,7 @@
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.LinkedList;
+import java.util.Date;
public class VibratorService extends IVibratorService.Stub
implements InputManager.InputDeviceListener {
@@ -69,6 +71,8 @@
private static final boolean DEBUG = false;
private static final String SYSTEM_UI_PACKAGE = "com.android.systemui";
+ private static final long[] DOUBLE_CLICK_EFFECT_FALLBACK_TIMINGS = { 0, 30, 100, 30 };
+
private final LinkedList<VibrationInfo> mPreviousVibrations;
private final int mPreviousVibrationsLimit;
private final boolean mAllowPriorityVibrationsInLowPowerMode;
@@ -110,7 +114,12 @@
private class Vibration implements IBinder.DeathRecipient {
private final IBinder mToken;
private final VibrationEffect mEffect;
+ // Start time in CLOCK_BOOTTIME base.
private final long mStartTime;
+ // Start time in unix epoch time. Only to be used for debugging purposes and to correlate
+ // with other system events, any duration calculations should be done use mStartTime so as
+ // not to be affected by discontinuities created by RTC adjustments.
+ private final long mStartTimeDebug;
private final int mUsageHint;
private final int mUid;
private final String mOpPkg;
@@ -119,7 +128,8 @@
int usageHint, int uid, String opPkg) {
mToken = token;
mEffect = effect;
- mStartTime = SystemClock.uptimeMillis();
+ mStartTime = SystemClock.elapsedRealtime();
+ mStartTimeDebug = System.currentTimeMillis();
mUsageHint = usageHint;
mUid = uid;
mOpPkg = opPkg;
@@ -153,18 +163,22 @@
return (mUid == Process.SYSTEM_UID || mUid == 0 || SYSTEM_UI_PACKAGE.equals(mOpPkg))
&& !repeating;
}
+
+ public VibrationInfo toInfo() {
+ return new VibrationInfo(mStartTimeDebug, mEffect, mUsageHint, mUid, mOpPkg);
+ }
}
private static class VibrationInfo {
- private final long mStartTime;
+ private final long mStartTimeDebug;
private final VibrationEffect mEffect;
private final int mUsageHint;
private final int mUid;
private final String mOpPkg;
- public VibrationInfo(long startTime, VibrationEffect effect,
+ public VibrationInfo(long startTimeDebug, VibrationEffect effect,
int usageHint, int uid, String opPkg) {
- mStartTime = startTime;
+ mStartTimeDebug = startTimeDebug;
mEffect = effect;
mUsageHint = usageHint;
mUid = uid;
@@ -174,8 +188,8 @@
@Override
public String toString() {
return new StringBuilder()
- .append(", startTime: ")
- .append(mStartTime)
+ .append("startTime: ")
+ .append(DateFormat.getDateTimeInstance().format(new Date(mStartTimeDebug)))
.append(", effect: ")
.append(mEffect)
.append(", usageHint: ")
@@ -225,7 +239,7 @@
com.android.internal.R.array.config_virtualKeyVibePattern);
VibrationEffect clickEffect = createEffect(clickEffectTimings);
VibrationEffect doubleClickEffect = VibrationEffect.createWaveform(
- new long[] {0, 30, 100, 30} /*timings*/, -1);
+ DOUBLE_CLICK_EFFECT_FALLBACK_TIMINGS, -1 /*repeatIndex*/);
long[] tickEffectTimings = getLongIntArray(context.getResources(),
com.android.internal.R.array.config_clockTickVibePattern);
VibrationEffect tickEffect = createEffect(tickEffectTimings);
@@ -392,17 +406,7 @@
}
Vibration vib = new Vibration(token, effect, usageHint, uid, opPkg);
-
- // Only link against waveforms since they potentially don't have a finish if
- // they're repeating. Let other effects just play out until they're done.
- if (effect instanceof VibrationEffect.Waveform) {
- try {
- token.linkToDeath(vib, 0);
- } catch (RemoteException e) {
- return;
- }
- }
-
+ linkVibration(vib);
long ident = Binder.clearCallingIdentity();
try {
@@ -430,8 +434,7 @@
if (mPreviousVibrations.size() > mPreviousVibrationsLimit) {
mPreviousVibrations.removeFirst();
}
- mPreviousVibrations.addLast(new VibrationInfo(
- vib.mStartTime, vib.mEffect, vib.mUsageHint, vib.mUid, vib.mOpPkg));
+ mPreviousVibrations.addLast(vib.toInfo());
}
@Override // Binder call
@@ -589,10 +592,23 @@
AppOpsManager.OP_VIBRATE, mCurrentVibration.mUid,
mCurrentVibration.mOpPkg);
} catch (RemoteException e) { }
+ unlinkVibration(mCurrentVibration);
mCurrentVibration = null;
}
}
+ private void linkVibration(Vibration vib) {
+ // Only link against waveforms since they potentially don't have a finish if
+ // they're repeating. Let other effects just play out until they're done.
+ if (vib.mEffect instanceof VibrationEffect.Waveform) {
+ try {
+ vib.mToken.linkToDeath(vib, 0);
+ } catch (RemoteException e) {
+ return;
+ }
+ }
+ }
+
private void unlinkVibration(Vibration vib) {
if (vib.mEffect instanceof VibrationEffect.Waveform) {
vib.mToken.unlinkToDeath(vib, 0);
@@ -742,8 +758,7 @@
synchronized (mInputDeviceVibrators) {
VibrationEffect.Prebaked prebaked = (VibrationEffect.Prebaked) vib.mEffect;
// Input devices don't support prebaked effect, so skip trying it with them.
- final int vibratorCount = mInputDeviceVibrators.size();
- if (vibratorCount == 0) {
+ if (mInputDeviceVibrators.isEmpty()) {
long timeout = vibratorPerformEffect(prebaked.getId(), EffectStrength.MEDIUM);
if (timeout > 0) {
noteVibratorOnLocked(vib.mUid, timeout);
@@ -753,12 +768,11 @@
if (!prebaked.shouldFallback()) {
return 0;
}
- final int id = prebaked.getId();
- if (id < 0 || id >= mFallbackEffects.length || mFallbackEffects[id] == null) {
+ VibrationEffect effect = getFallbackEffect(prebaked.getId());
+ if (effect == null) {
Slog.w(TAG, "Failed to play prebaked effect, no fallback");
return 0;
}
- VibrationEffect effect = mFallbackEffects[id];
Vibration fallbackVib =
new Vibration(vib.mToken, effect, vib.mUsageHint, vib.mUid, vib.mOpPkg);
startVibrationInnerLocked(fallbackVib);
@@ -766,6 +780,13 @@
return 0;
}
+ private VibrationEffect getFallbackEffect(int effectId) {
+ if (effectId < 0 || effectId >= mFallbackEffects.length) {
+ return null;
+ }
+ return mFallbackEffects[effectId];
+ }
+
private void noteVibratorOnLocked(int uid, long millis) {
try {
mBatteryStatsService.noteVibratorOn(uid, millis);
diff --git a/services/core/java/com/android/server/am/ActivityDisplay.java b/services/core/java/com/android/server/am/ActivityDisplay.java
index af5cf1e..e38148c 100644
--- a/services/core/java/com/android/server/am/ActivityDisplay.java
+++ b/services/core/java/com/android/server/am/ActivityDisplay.java
@@ -556,10 +556,10 @@
return stack == getTopStack();
}
- boolean isTopFullscreenStack(ActivityStack stack) {
+ boolean isTopNotPinnedStack(ActivityStack stack) {
for (int i = mStacks.size() - 1; i >= 0; --i) {
final ActivityStack current = mStacks.get(i);
- if (current.getWindowingMode() == WINDOWING_MODE_FULLSCREEN) {
+ if (!current.inPinnedWindowingMode()) {
return current == stack;
}
}
diff --git a/services/core/java/com/android/server/am/ActivityManagerConstants.java b/services/core/java/com/android/server/am/ActivityManagerConstants.java
index b3a596c..0d6d2bd 100644
--- a/services/core/java/com/android/server/am/ActivityManagerConstants.java
+++ b/services/core/java/com/android/server/am/ActivityManagerConstants.java
@@ -77,8 +77,8 @@
private static final long DEFAULT_CONTENT_PROVIDER_RETAIN_TIME = 20*1000;
private static final long DEFAULT_GC_TIMEOUT = 5*1000;
private static final long DEFAULT_GC_MIN_INTERVAL = 60*1000;
- private static final long DEFAULT_FULL_PSS_MIN_INTERVAL = 10*60*1000;
- private static final long DEFAULT_FULL_PSS_LOWERED_INTERVAL = 2*60*1000;
+ private static final long DEFAULT_FULL_PSS_MIN_INTERVAL = 20*60*1000;
+ private static final long DEFAULT_FULL_PSS_LOWERED_INTERVAL = 5*60*1000;
private static final long DEFAULT_POWER_CHECK_INTERVAL = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000;
private static final int DEFAULT_POWER_CHECK_MAX_CPU_1 = 25;
private static final int DEFAULT_POWER_CHECK_MAX_CPU_2 = 25;
diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java
index 5936ce1..624035d 100644
--- a/services/core/java/com/android/server/am/ActivityManagerService.java
+++ b/services/core/java/com/android/server/am/ActivityManagerService.java
@@ -2521,13 +2521,15 @@
}
}
if (proc != null) {
+ long startTime = SystemClock.currentThreadTimeMillis();
long pss = Debug.getPss(pid, tmp, null);
+ long endTime = SystemClock.currentThreadTimeMillis();
synchronized (ActivityManagerService.this) {
if (pss != 0 && proc.thread != null && proc.setProcState == procState
&& proc.pid == pid && proc.lastPssTime == lastPssTime) {
num++;
recordPssSampleLocked(proc, procState, pss, tmp[0], tmp[1],
- SystemClock.uptimeMillis());
+ endTime-startTime, SystemClock.uptimeMillis());
}
}
}
@@ -2695,6 +2697,13 @@
}
@Override
+ public void onBootPhase(int phase) {
+ if (phase == PHASE_SYSTEM_SERVICES_READY) {
+ mService.mBatteryStatsService.systemServicesReady();
+ }
+ }
+
+ @Override
public void onCleanupUser(int userId) {
mService.mBatteryStatsService.onCleanupUser(userId);
}
@@ -6539,13 +6548,17 @@
}
}
infos[i] = new Debug.MemoryInfo();
+ long startTime = SystemClock.currentThreadTimeMillis();
Debug.getMemoryInfo(pids[i], infos[i]);
+ long endTime = SystemClock.currentThreadTimeMillis();
if (proc != null) {
synchronized (this) {
if (proc.thread != null && proc.setAdj == oomAdj) {
// Record this for posterity if the process has been stable.
proc.baseProcessTracker.addPss(infos[i].getTotalPss(),
- infos[i].getTotalUss(), false, proc.pkgList);
+ infos[i].getTotalUss(), false,
+ ProcessStats.ADD_PSS_EXTERNAL_SLOW, endTime-startTime,
+ proc.pkgList);
}
}
}
@@ -6567,12 +6580,15 @@
}
}
long[] tmpUss = new long[1];
+ long startTime = SystemClock.currentThreadTimeMillis();
pss[i] = Debug.getPss(pids[i], tmpUss, null);
+ long endTime = SystemClock.currentThreadTimeMillis();
if (proc != null) {
synchronized (this) {
if (proc.thread != null && proc.setAdj == oomAdj) {
// Record this for posterity if the process has been stable.
- proc.baseProcessTracker.addPss(pss[i], tmpUss[0], false, proc.pkgList);
+ proc.baseProcessTracker.addPss(pss[i], tmpUss[0], false,
+ ProcessStats.ADD_PSS_EXTERNAL, endTime-startTime, proc.pkgList);
}
}
}
@@ -12245,6 +12261,7 @@
mConstants.start(mContext.getContentResolver());
mCoreSettingsObserver = new CoreSettingsObserver(this);
mFontScaleSettingObserver = new FontScaleSettingObserver();
+ GlobalSettingsToPropertiesMapper.start(mContext.getContentResolver());
// Now that the settings provider is published we can consider sending
// in a rescue party.
@@ -14875,6 +14892,7 @@
(process != null && process.info != null) ?
(process.info.isInstantApp() ? 1 : 0) : -1,
activity != null ? activity.shortComponentName : null,
+ activity != null ? activity.packageName : null,
process != null ? (process.isInterestingToUserLocked() ? 1 : 0) : -1);
// Rate-limit how often we're willing to do the heavy lifting below to
@@ -17659,11 +17677,20 @@
if (mi == null) {
mi = new Debug.MemoryInfo();
}
+ final int reportType;
+ final long startTime;
+ final long endTime;
if (opts.dumpDetails || (!brief && !opts.oomOnly)) {
+ reportType = ProcessStats.ADD_PSS_EXTERNAL_SLOW;
+ startTime = SystemClock.currentThreadTimeMillis();
Debug.getMemoryInfo(pid, mi);
+ endTime = SystemClock.currentThreadTimeMillis();
hasSwapPss = mi.hasSwappedOutPss;
} else {
+ reportType = ProcessStats.ADD_PSS_EXTERNAL;
+ startTime = SystemClock.currentThreadTimeMillis();
mi.dalvikPss = (int)Debug.getPss(pid, tmpLong, null);
+ endTime = SystemClock.currentThreadTimeMillis();
mi.dalvikPrivateDirty = (int)tmpLong[0];
}
if (opts.dumpDetails) {
@@ -17706,7 +17733,8 @@
synchronized (this) {
if (r.thread != null && oomAdj == r.getSetAdjWithServices()) {
// Record this for posterity if the process has been stable.
- r.baseProcessTracker.addPss(myTotalPss, myTotalUss, true, r.pkgList);
+ r.baseProcessTracker.addPss(myTotalPss, myTotalUss, true,
+ reportType, endTime-startTime, r.pkgList);
}
}
@@ -18149,11 +18177,20 @@
if (mi == null) {
mi = new Debug.MemoryInfo();
}
+ final int reportType;
+ final long startTime;
+ final long endTime;
if (opts.dumpDetails || (!brief && !opts.oomOnly)) {
+ reportType = ProcessStats.ADD_PSS_EXTERNAL_SLOW;
+ startTime = SystemClock.currentThreadTimeMillis();
Debug.getMemoryInfo(pid, mi);
+ endTime = SystemClock.currentThreadTimeMillis();
hasSwapPss = mi.hasSwappedOutPss;
} else {
+ reportType = ProcessStats.ADD_PSS_EXTERNAL;
+ startTime = SystemClock.currentThreadTimeMillis();
mi.dalvikPss = (int) Debug.getPss(pid, tmpLong, null);
+ endTime = SystemClock.currentThreadTimeMillis();
mi.dalvikPrivateDirty = (int) tmpLong[0];
}
if (opts.dumpDetails) {
@@ -18192,7 +18229,8 @@
synchronized (this) {
if (r.thread != null && oomAdj == r.getSetAdjWithServices()) {
// Record this for posterity if the process has been stable.
- r.baseProcessTracker.addPss(myTotalPss, myTotalUss, true, r.pkgList);
+ r.baseProcessTracker.addPss(myTotalPss, myTotalUss, true,
+ reportType, endTime-startTime, r.pkgList);
}
}
@@ -22454,11 +22492,12 @@
* Record new PSS sample for a process.
*/
void recordPssSampleLocked(ProcessRecord proc, int procState, long pss, long uss, long swapPss,
- long now) {
+ long pssDuration, long now) {
EventLogTags.writeAmPss(proc.pid, proc.uid, proc.processName, pss * 1024, uss * 1024,
swapPss * 1024);
proc.lastPssTime = now;
- proc.baseProcessTracker.addPss(pss, uss, true, proc.pkgList);
+ proc.baseProcessTracker.addPss(pss, uss, true, ProcessStats.ADD_PSS_INTERNAL,
+ pssDuration, proc.pkgList);
if (DEBUG_PSS) Slog.d(TAG_PSS,
"PSS of " + proc.toShortString() + ": " + pss + " lastPss=" + proc.lastPss
+ " state=" + ProcessList.makeProcStateString(procState));
@@ -22953,8 +22992,11 @@
// the data right when a process is transitioning between process
// states, which well tend to give noisy data.
long start = SystemClock.uptimeMillis();
+ long startTime = SystemClock.currentThreadTimeMillis();
long pss = Debug.getPss(app.pid, mTmpLong, null);
- recordPssSampleLocked(app, app.curProcState, pss, mTmpLong[0], mTmpLong[1], now);
+ long endTime = SystemClock.currentThreadTimeMillis();
+ recordPssSampleLocked(app, app.curProcState, pss, endTime-startTime,
+ mTmpLong[0], mTmpLong[1], now);
mPendingPssProcesses.remove(app);
Slog.i(TAG, "Recorded pss for " + app + " state " + app.setProcState
+ " to " + app.curProcState + ": "
diff --git a/services/core/java/com/android/server/am/ActivityMetricsLogger.java b/services/core/java/com/android/server/am/ActivityMetricsLogger.java
index eb022b7..66f0592 100644
--- a/services/core/java/com/android/server/am/ActivityMetricsLogger.java
+++ b/services/core/java/com/android/server/am/ActivityMetricsLogger.java
@@ -42,6 +42,7 @@
import android.util.Slog;
import android.util.SparseArray;
import android.util.SparseIntArray;
+import android.util.StatsLog;
import com.android.internal.logging.MetricsLogger;
import com.android.internal.os.SomeArgs;
@@ -431,6 +432,12 @@
builder.setType(type);
builder.addTaggedData(FIELD_CLASS_NAME, info.launchedActivity.info.name);
mMetricsLogger.write(builder);
+ StatsLog.write(
+ StatsLog.APP_START_CANCEL_CHANGED,
+ info.launchedActivity.appInfo.uid,
+ info.launchedActivity.packageName,
+ convertAppStartTransitionType(type),
+ info.launchedActivity.info.name);
}
private void logAppTransitionMultiEvents() {
@@ -450,9 +457,9 @@
builder.addTaggedData(APP_TRANSITION_CALLING_PACKAGE_NAME,
info.launchedActivity.launchedFromPackage);
}
- if (info.launchedActivity.info.launchToken != null) {
- builder.addTaggedData(FIELD_INSTANT_APP_LAUNCH_TOKEN,
- info.launchedActivity.info.launchToken);
+ String launchToken = info.launchedActivity.info.launchToken;
+ if (launchToken != null) {
+ builder.addTaggedData(FIELD_INSTANT_APP_LAUNCH_TOKEN, launchToken);
info.launchedActivity.info.launchToken = null;
}
builder.addTaggedData(APP_TRANSITION_IS_EPHEMERAL, isInstantApp ? 1 : 0);
@@ -470,9 +477,37 @@
}
builder.addTaggedData(APP_TRANSITION_WINDOWS_DRAWN_DELAY_MS, info.windowsDrawnDelayMs);
mMetricsLogger.write(builder);
+ StatsLog.write(
+ StatsLog.APP_START_CHANGED,
+ info.launchedActivity.appInfo.uid,
+ info.launchedActivity.packageName,
+ convertAppStartTransitionType(type),
+ info.launchedActivity.info.name,
+ info.launchedActivity.launchedFromPackage,
+ isInstantApp,
+ mCurrentTransitionDeviceUptime * 1000,
+ info.reason,
+ mCurrentTransitionDelayMs,
+ info.startingWindowDelayMs,
+ info.bindApplicationDelayMs,
+ info.windowsDrawnDelayMs,
+ launchToken);
}
}
+ private int convertAppStartTransitionType(int tronType) {
+ if (tronType == TYPE_TRANSITION_COLD_LAUNCH) {
+ return StatsLog.APP_START_CHANGED__TYPE__COLD;
+ }
+ if (tronType == TYPE_TRANSITION_WARM_LAUNCH) {
+ return StatsLog.APP_START_CHANGED__TYPE__WARM;
+ }
+ if (tronType == TYPE_TRANSITION_HOT_LAUNCH) {
+ return StatsLog.APP_START_CHANGED__TYPE__HOT;
+ }
+ return StatsLog.APP_START_CHANGED__TYPE__APP_START_TRANSITION_TYPE_UNKNOWN;
+ }
+
void logAppTransitionReportedDrawn(ActivityRecord r, boolean restoredFromBundle) {
final StackTransitionInfo info = mLastStackTransitionInfo.get(r.getStackId());
if (info == null) {
@@ -481,14 +516,24 @@
final LogMaker builder = new LogMaker(APP_TRANSITION_REPORTED_DRAWN);
builder.setPackageName(r.packageName);
builder.addTaggedData(FIELD_CLASS_NAME, r.info.name);
- builder.addTaggedData(APP_TRANSITION_REPORTED_DRAWN_MS,
- SystemClock.uptimeMillis() - mLastTransitionStartTime);
+ long startupTimeMs = SystemClock.uptimeMillis() - mLastTransitionStartTime;
+ builder.addTaggedData(APP_TRANSITION_REPORTED_DRAWN_MS, startupTimeMs);
builder.setType(restoredFromBundle
? TYPE_TRANSITION_REPORTED_DRAWN_WITH_BUNDLE
: TYPE_TRANSITION_REPORTED_DRAWN_NO_BUNDLE);
builder.addTaggedData(APP_TRANSITION_PROCESS_RUNNING,
info.currentTransitionProcessRunning ? 1 : 0);
mMetricsLogger.write(builder);
+ StatsLog.write(
+ StatsLog.APP_START_FULLY_DRAWN_CHANGED,
+ info.launchedActivity.appInfo.uid,
+ info.launchedActivity.packageName,
+ restoredFromBundle
+ ? StatsLog.APP_START_FULLY_DRAWN_CHANGED__TYPE__WITH_BUNDLE
+ : StatsLog.APP_START_FULLY_DRAWN_CHANGED__TYPE__WITHOUT_BUNDLE,
+ info.launchedActivity.info.name,
+ info.currentTransitionProcessRunning,
+ startupTimeMs);
}
private int getTransitionType(StackTransitionInfo info) {
diff --git a/services/core/java/com/android/server/am/ActivityRecord.java b/services/core/java/com/android/server/am/ActivityRecord.java
index 8eb5197..e1907d3 100644
--- a/services/core/java/com/android/server/am/ActivityRecord.java
+++ b/services/core/java/com/android/server/am/ActivityRecord.java
@@ -2730,12 +2730,14 @@
}
/**
- * @return true if the activity contains windows that have
- * {@link LayoutParams#FLAG_SHOW_WHEN_LOCKED} set or if the activity has set
- * {@link #mShowWhenLocked}.
+ * @return true if the activity windowing mode is not
+ * {@link android.app.WindowConfiguration#WINDOWING_MODE_PINNED} and activity contains
+ * windows that have {@link LayoutParams#FLAG_SHOW_WHEN_LOCKED} set or if the activity
+ * has set {@link #mShowWhenLocked}.
+ * Multi-windowing mode will be exited if true is returned.
*/
boolean canShowWhenLocked() {
- return !inMultiWindowMode() && (mShowWhenLocked
+ return !inPinnedWindowingMode() && (mShowWhenLocked
|| service.mWindowManager.containsShowWhenLockedWindow(appToken));
}
diff --git a/services/core/java/com/android/server/am/ActivityStack.java b/services/core/java/com/android/server/am/ActivityStack.java
index 10c801d..831b31e 100644
--- a/services/core/java/com/android/server/am/ActivityStack.java
+++ b/services/core/java/com/android/server/am/ActivityStack.java
@@ -16,7 +16,6 @@
package com.android.server.am;
-import static android.app.ITaskStackListener.FORCED_RESIZEABLE_REASON_SECONDARY_DISPLAY;
import static android.app.ITaskStackListener.FORCED_RESIZEABLE_REASON_SPLIT_SCREEN;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_RECENTS;
import static android.app.WindowConfiguration.ACTIVITY_TYPE_STANDARD;
@@ -144,7 +143,6 @@
import com.android.internal.os.BatteryStatsImpl;
import com.android.server.Watchdog;
import com.android.server.am.ActivityManagerService.ItemMatcher;
-import com.android.server.am.EventLogTags;
import com.android.server.wm.ConfigurationContainer;
import com.android.server.wm.StackWindowController;
import com.android.server.wm.StackWindowListener;
@@ -1013,6 +1011,14 @@
return;
}
+ /**
+ * The intent behind moving a primary split screen stack to the back is usually to hide
+ * behind the home stack. Exit split screen in this case.
+ */
+ if (getWindowingMode() == WINDOWING_MODE_SPLIT_SCREEN_PRIMARY) {
+ setWindowingMode(WINDOWING_MODE_FULLSCREEN);
+ }
+
getDisplay().positionChildAtBottom(this);
mStackSupervisor.setFocusStackUnchecked(reason, getDisplay().getTopStack());
if (task != null) {
@@ -1811,7 +1817,7 @@
boolean behindFullscreenActivity = !stackShouldBeVisible;
boolean resumeNextActivity = mStackSupervisor.isFocusedStack(this)
&& (isInStackLocked(starting) == null);
- final boolean isTopFullscreenStack = getDisplay().isTopFullscreenStack(this);
+ final boolean isTopNotPinnedStack = getDisplay().isTopNotPinnedStack(this);
for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
final TaskRecord task = mTaskHistory.get(taskNdx);
final ArrayList<ActivityRecord> activities = task.mActivities;
@@ -1833,7 +1839,7 @@
// Now check whether it's really visible depending on Keyguard state.
final boolean reallyVisible = checkKeyguardVisibility(r,
- visibleIgnoringKeyguard, isTop && isTopFullscreenStack);
+ visibleIgnoringKeyguard, isTop && isTopNotPinnedStack);
if (visibleIgnoringKeyguard) {
behindFullscreenActivity = updateBehindFullscreen(!stackShouldBeVisible,
behindFullscreenActivity, r);
diff --git a/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java b/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java
index 4582430..1fcaeef 100644
--- a/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java
+++ b/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java
@@ -35,6 +35,7 @@
import com.android.internal.annotations.GuardedBy;
import com.android.internal.os.BatteryStatsImpl;
+import com.android.internal.util.function.pooled.PooledLambda;
import libcore.util.EmptyArray;
@@ -117,49 +118,45 @@
}
@Override
- public Future<?> scheduleReadProcStateCpuTimes() {
+ public synchronized Future<?> scheduleCpuSyncDueToSettingChange() {
+ return scheduleSyncLocked("setting-change", UPDATE_CPU);
+ }
+
+ @Override
+ public Future<?> scheduleReadProcStateCpuTimes(boolean onBattery, boolean onBatteryScreenOff) {
synchronized (mStats) {
- if (!mStats.mPerProcStateCpuTimesAvailable) {
+ if (!mStats.trackPerProcStateCpuTimes()) {
return null;
}
}
synchronized (BatteryExternalStatsWorker.this) {
if (!mExecutorService.isShutdown()) {
- return mExecutorService.submit(mReadProcStateCpuTimesTask);
+ return mExecutorService.submit(PooledLambda.obtainRunnable(
+ BatteryStatsImpl::updateProcStateCpuTimes,
+ mStats, onBattery, onBatteryScreenOff).recycleOnUse());
}
}
return null;
}
@Override
- public Future<?> scheduleCopyFromAllUidsCpuTimes() {
+ public Future<?> scheduleCopyFromAllUidsCpuTimes(
+ boolean onBattery, boolean onBatteryScreenOff) {
synchronized (mStats) {
- if (!mStats.mPerProcStateCpuTimesAvailable) {
+ if (!mStats.trackPerProcStateCpuTimes()) {
return null;
}
}
synchronized (BatteryExternalStatsWorker.this) {
if (!mExecutorService.isShutdown()) {
- return mExecutorService.submit(mCopyFromAllUidsCpuTimesTask);
+ return mExecutorService.submit(PooledLambda.obtainRunnable(
+ BatteryStatsImpl::copyFromAllUidsCpuTimes,
+ mStats, onBattery, onBatteryScreenOff).recycleOnUse());
}
}
return null;
}
- private final Runnable mReadProcStateCpuTimesTask = new Runnable() {
- @Override
- public void run() {
- mStats.updateProcStateCpuTimes();
- }
- };
-
- private final Runnable mCopyFromAllUidsCpuTimesTask = new Runnable() {
- @Override
- public void run() {
- mStats.copyFromAllUidsCpuTimes();
- }
- };
-
public synchronized Future<?> scheduleWrite() {
if (mExecutorService.isShutdown()) {
return CompletableFuture.failedFuture(new IllegalStateException("worker shutdown"));
diff --git a/services/core/java/com/android/server/am/BatteryStatsService.java b/services/core/java/com/android/server/am/BatteryStatsService.java
index 430320a..c9aa9a2 100644
--- a/services/core/java/com/android/server/am/BatteryStatsService.java
+++ b/services/core/java/com/android/server/am/BatteryStatsService.java
@@ -185,6 +185,10 @@
ServiceManager.addService(BatteryStats.SERVICE_NAME, asBinder());
}
+ public void systemServicesReady() {
+ mStats.systemServicesReady(mContext);
+ }
+
private final class LocalService extends BatteryStatsInternal {
@Override
public String[] getWifiIfaces() {
@@ -514,6 +518,7 @@
}
}
+ @Override
public void noteLongPartialWakelockStart(String name, String historyName, int uid) {
enforceCallingPermission();
synchronized (mStats) {
@@ -521,6 +526,16 @@
}
}
+ @Override
+ public void noteLongPartialWakelockStartFromSource(String name, String historyName,
+ WorkSource workSource) {
+ enforceCallingPermission();
+ synchronized (mStats) {
+ mStats.noteLongPartialWakelockStartFromSource(name, historyName, workSource);
+ }
+ }
+
+ @Override
public void noteLongPartialWakelockFinish(String name, String historyName, int uid) {
enforceCallingPermission();
synchronized (mStats) {
@@ -528,6 +543,15 @@
}
}
+ @Override
+ public void noteLongPartialWakelockFinishFromSource(String name, String historyName,
+ WorkSource workSource) {
+ enforceCallingPermission();
+ synchronized (mStats) {
+ mStats.noteLongPartialWakelockFinishFromSource(name, historyName, workSource);
+ }
+ }
+
public void noteStartSensor(int uid, int sensor) {
enforceCallingPermission();
synchronized (mStats) {
@@ -1165,6 +1189,7 @@
pw.println(" --write: force write current collected stats to disk.");
pw.println(" --new-daily: immediately create and write new daily stats record.");
pw.println(" --read-daily: read-load last written daily stats.");
+ pw.println(" --settings: dump the settings key/values related to batterystats");
pw.println(" <package.name>: optional name of package to filter output by.");
pw.println(" -h: print this help text.");
pw.println("Battery stats (batterystats) commands:");
@@ -1177,6 +1202,12 @@
pw.println(" pretend-screen-off: pretend the screen is off, even if screen state changes");
}
+ private void dumpSettings(PrintWriter pw) {
+ synchronized (mStats) {
+ mStats.dumpConstantsLocked(pw);
+ }
+ }
+
private int doEnableOrDisable(PrintWriter pw, int i, String[] args, boolean enable) {
i++;
if (i >= args.length) {
@@ -1287,6 +1318,9 @@
} else if ("-h".equals(arg)) {
dumpHelp(pw);
return;
+ } else if ("--settings".equals(arg)) {
+ dumpSettings(pw);
+ return;
} else if ("-a".equals(arg)) {
flags |= BatteryStats.DUMP_VERBOSE;
} else if (arg.length() > 0 && arg.charAt(0) == '-'){
diff --git a/services/core/java/com/android/server/am/GlobalSettingsToPropertiesMapper.java b/services/core/java/com/android/server/am/GlobalSettingsToPropertiesMapper.java
new file mode 100644
index 0000000..5632fc0
--- /dev/null
+++ b/services/core/java/com/android/server/am/GlobalSettingsToPropertiesMapper.java
@@ -0,0 +1,112 @@
+/*
+ * 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.server.am;
+
+import android.content.ContentResolver;
+import android.database.ContentObserver;
+import android.net.Uri;
+import android.os.SystemProperties;
+import android.provider.Settings;
+import android.text.TextUtils;
+import android.util.Slog;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.util.Preconditions;
+
+/**
+ * Maps global system settings to system properties.
+ * <p>The properties are dynamically updated when settings change.
+ */
+class GlobalSettingsToPropertiesMapper {
+
+ private static final String TAG = "GlobalSettingsToPropertiesMapper";
+
+ private static final String[][] sGlobalSettingsMapping = new String[][] {
+ // List mapping entries in the following format:
+ // {Settings.Global.SETTING_NAME, "system_property_name"},
+ };
+
+
+ private final ContentResolver mContentResolver;
+ private final String[][] mGlobalSettingsMapping;
+
+ @VisibleForTesting
+ GlobalSettingsToPropertiesMapper(ContentResolver contentResolver,
+ String[][] globalSettingsMapping) {
+ mContentResolver = contentResolver;
+ mGlobalSettingsMapping = globalSettingsMapping;
+ }
+
+ void updatePropertiesFromGlobalSettings() {
+ for (String[] entry : mGlobalSettingsMapping) {
+ final String settingName = entry[0];
+ final String propName = entry[1];
+ Uri settingUri = Settings.Global.getUriFor(settingName);
+ Preconditions.checkNotNull(settingUri, "Setting " + settingName + " not found");
+ ContentObserver co = new ContentObserver(null) {
+ @Override
+ public void onChange(boolean selfChange) {
+ updatePropertyFromSetting(settingName, propName);
+ }
+ };
+ updatePropertyFromSetting(settingName, propName);
+ mContentResolver.registerContentObserver(settingUri, false, co);
+ }
+ }
+
+ public static void start(ContentResolver contentResolver) {
+ new GlobalSettingsToPropertiesMapper(contentResolver, sGlobalSettingsMapping)
+ .updatePropertiesFromGlobalSettings();
+ }
+
+ private String getGlobalSetting(String name) {
+ return Settings.Global.getString(mContentResolver, name);
+ }
+
+ private void setProperty(String key, String value) {
+ // Check if need to clear the property
+ if (value == null) {
+ // It's impossible to remove system property, therefore we check previous value to
+ // avoid setting an empty string if the property wasn't set.
+ if (TextUtils.isEmpty(systemPropertiesGet(key))) {
+ return;
+ }
+ value = "";
+ }
+ try {
+ systemPropertiesSet(key, value);
+ } catch (IllegalArgumentException e) {
+ Slog.e(TAG, "Unable to set property " + key + " value '" + value + "'", e);
+ }
+ }
+
+ @VisibleForTesting
+ protected String systemPropertiesGet(String key) {
+ return SystemProperties.get(key);
+ }
+
+ @VisibleForTesting
+ protected void systemPropertiesSet(String key, String value) {
+ SystemProperties.set(key, value);
+ }
+
+ @VisibleForTesting
+ void updatePropertyFromSetting(String settingName, String propName) {
+ String settingValue = getGlobalSetting(settingName);
+ setProperty(propName, settingValue);
+ }
+}
diff --git a/services/core/java/com/android/server/am/ProcessList.java b/services/core/java/com/android/server/am/ProcessList.java
index ab5d64c..b39e96d 100644
--- a/services/core/java/com/android/server/am/ProcessList.java
+++ b/services/core/java/com/android/server/am/ProcessList.java
@@ -432,13 +432,13 @@
public static final int PSS_MIN_TIME_FROM_STATE_CHANGE = 15*1000;
// The maximum amount of time we want to go between PSS collections.
- public static final int PSS_MAX_INTERVAL = 30*60*1000;
+ public static final int PSS_MAX_INTERVAL = 40*60*1000;
// The minimum amount of time between successive PSS requests for *all* processes.
- public static final int PSS_ALL_INTERVAL = 10*60*1000;
+ public static final int PSS_ALL_INTERVAL = 20*60*1000;
- // The minimum amount of time between successive PSS requests for a process.
- private static final int PSS_SHORT_INTERVAL = 2*60*1000;
+ // The amount of time until PSS when a persistent process first appears.
+ private static final int PSS_FIRST_PERSISTENT_INTERVAL = 30*1000;
// The amount of time until PSS when a process first becomes top.
private static final int PSS_FIRST_TOP_INTERVAL = 10*1000;
@@ -449,6 +449,9 @@
// The amount of time until PSS when a process first becomes cached.
private static final int PSS_FIRST_CACHED_INTERVAL = 30*1000;
+ // The amount of time until PSS when the top process stays in the same state.
+ private static final int PSS_SAME_TOP_INTERVAL = 5*60*1000;
+
// The amount of time until PSS when an important process stays in the same state.
private static final int PSS_SAME_IMPORTANT_INTERVAL = 15*60*1000;
@@ -458,6 +461,18 @@
// The amount of time until PSS when a cached process stays in the same state.
private static final int PSS_SAME_CACHED_INTERVAL = 30*60*1000;
+ // The amount of time until PSS when a persistent process first appears.
+ private static final int PSS_FIRST_ASLEEP_PERSISTENT_INTERVAL = 1*60*1000;
+
+ // The amount of time until PSS when a process first becomes top.
+ private static final int PSS_FIRST_ASLEEP_TOP_INTERVAL = 20*1000;
+
+ // The amount of time until PSS when a process first goes into the background.
+ private static final int PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL = 30*1000;
+
+ // The amount of time until PSS when a process first becomes cached.
+ private static final int PSS_FIRST_ASLEEP_CACHED_INTERVAL = 1*60*1000;
+
// The minimum time interval after a state change it is safe to collect PSS.
public static final int PSS_TEST_MIN_TIME_FROM_STATE_CHANGE = 10*1000;
@@ -502,8 +517,8 @@
};
private static final long[] sFirstAwakePssTimes = new long[] {
- PSS_SHORT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT
- PSS_SHORT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT_UI
+ PSS_FIRST_PERSISTENT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT
+ PSS_FIRST_PERSISTENT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT_UI
PSS_FIRST_TOP_INTERVAL, // ActivityManager.PROCESS_STATE_TOP
PSS_FIRST_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE
PSS_FIRST_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE
@@ -526,7 +541,51 @@
private static final long[] sSameAwakePssTimes = new long[] {
PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT
PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT_UI
- PSS_SHORT_INTERVAL, // ActivityManager.PROCESS_STATE_TOP
+ PSS_SAME_TOP_INTERVAL, // ActivityManager.PROCESS_STATE_TOP
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_TRANSIENT_BACKGROUND
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_BACKUP
+ PSS_SAME_SERVICE_INTERVAL, // ActivityManager.PROCESS_STATE_SERVICE
+ PSS_SAME_SERVICE_INTERVAL, // ActivityManager.PROCESS_STATE_RECEIVER
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_TOP_SLEEPING
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_HEAVY_WEIGHT
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_HOME
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_LAST_ACTIVITY
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_ACTIVITY
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_RECENT
+ PSS_SAME_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_EMPTY
+ };
+
+ private static final long[] sFirstAsleepPssTimes = new long[] {
+ PSS_FIRST_ASLEEP_PERSISTENT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT
+ PSS_FIRST_ASLEEP_PERSISTENT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT_UI
+ PSS_FIRST_ASLEEP_TOP_INTERVAL, // ActivityManager.PROCESS_STATE_TOP
+ PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE
+ PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE
+ PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND
+ PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND
+ PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_TRANSIENT_BACKGROUND
+ PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_BACKUP
+ PSS_FIRST_ASLEEP_BACKGROUND_INTERVAL, // ActivityManager.PROCESS_STATE_SERVICE
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_RECEIVER
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_TOP_SLEEPING
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_HEAVY_WEIGHT
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_HOME
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_LAST_ACTIVITY
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_ACTIVITY
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_RECENT
+ PSS_FIRST_ASLEEP_CACHED_INTERVAL, // ActivityManager.PROCESS_STATE_CACHED_EMPTY
+ };
+
+ private static final long[] sSameAsleepPssTimes = new long[] {
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT
+ PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_PERSISTENT_UI
+ PSS_SAME_TOP_INTERVAL, // ActivityManager.PROCESS_STATE_TOP
PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE
PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE
PSS_SAME_IMPORTANT_INTERVAL, // ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND
@@ -604,8 +663,8 @@
? sTestFirstPssTimes
: sTestSamePssTimes)
: (first
- ? sFirstAwakePssTimes
- : sSameAwakePssTimes);
+ ? (sleeping ? sFirstAsleepPssTimes : sFirstAwakePssTimes)
+ : (sleeping ? sSameAsleepPssTimes : sSameAwakePssTimes));
return now + table[procState];
}
diff --git a/services/core/java/com/android/server/audio/FocusRequester.java b/services/core/java/com/android/server/audio/FocusRequester.java
index c298fe70..48f0d5a 100644
--- a/services/core/java/com/android/server/audio/FocusRequester.java
+++ b/services/core/java/com/android/server/audio/FocusRequester.java
@@ -25,6 +25,7 @@
import android.os.IBinder;
import android.util.Log;
+import com.android.internal.annotations.GuardedBy;
import com.android.server.audio.MediaFocusControl.AudioFocusDeathHandler;
import java.io.PrintWriter;
@@ -300,16 +301,19 @@
}
/**
- * Called synchronized on MediaFocusControl.mAudioFocusLock
+ * Handle the loss of focus resulting from a given focus gain.
+ * @param focusGain the focus gain from which the loss of focus is resulting
+ * @param frWinner the new focus owner
+ * @return true if the focus loss is definitive, false otherwise.
*/
- void handleExternalFocusGain(int focusGain, final FocusRequester fr) {
- int focusLoss = focusLossForGainRequest(focusGain);
- handleFocusLoss(focusLoss, fr);
+ @GuardedBy("MediaFocusControl.mAudioFocusLock")
+ boolean handleFocusLossFromGain(int focusGain, final FocusRequester frWinner) {
+ final int focusLoss = focusLossForGainRequest(focusGain);
+ handleFocusLoss(focusLoss, frWinner);
+ return (focusLoss == AudioManager.AUDIOFOCUS_LOSS);
}
- /**
- * Called synchronized on MediaFocusControl.mAudioFocusLock
- */
+ @GuardedBy("MediaFocusControl.mAudioFocusLock")
void handleFocusGain(int focusGain) {
try {
mFocusLossReceived = AudioManager.AUDIOFOCUS_NONE;
@@ -331,19 +335,15 @@
}
}
- /**
- * Called synchronized on MediaFocusControl.mAudioFocusLock
- */
+ @GuardedBy("MediaFocusControl.mAudioFocusLock")
void handleFocusGainFromRequest(int focusRequestResult) {
if (focusRequestResult == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
mFocusController.unduckPlayers(this);
}
}
- /**
- * Called synchronized on MediaFocusControl.mAudioFocusLock
- */
- void handleFocusLoss(int focusLoss, @Nullable final FocusRequester fr) {
+ @GuardedBy("MediaFocusControl.mAudioFocusLock")
+ void handleFocusLoss(int focusLoss, @Nullable final FocusRequester frWinner) {
try {
if (focusLoss != mFocusLossReceived) {
mFocusLossReceived = focusLoss;
@@ -371,9 +371,9 @@
boolean handled = false;
if (focusLoss == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK
&& MediaFocusControl.ENFORCE_DUCKING
- && fr != null) {
+ && frWinner != null) {
// candidate for enforcement by the framework
- if (fr.mCallingUid != this.mCallingUid) {
+ if (frWinner.mCallingUid != this.mCallingUid) {
if ((mGrantFlags
& AudioManager.AUDIOFOCUS_FLAG_PAUSES_ON_DUCKABLE_LOSS) != 0) {
// the focus loser declared it would pause instead of duck, let it
@@ -386,7 +386,7 @@
handled = false;
Log.v(TAG, "not ducking uid " + this.mCallingUid + " - old SDK");
} else {
- handled = mFocusController.duckPlayers(fr, this);
+ handled = mFocusController.duckPlayers(frWinner, this);
}
} // else: the focus change is within the same app, so let the dispatching
// happen as if the framework was not involved.
diff --git a/services/core/java/com/android/server/audio/MediaFocusControl.java b/services/core/java/com/android/server/audio/MediaFocusControl.java
index c5f563c7..de58b59 100644
--- a/services/core/java/com/android/server/audio/MediaFocusControl.java
+++ b/services/core/java/com/android/server/audio/MediaFocusControl.java
@@ -32,11 +32,15 @@
import android.os.RemoteException;
import android.util.Log;
+import com.android.internal.annotations.GuardedBy;
+
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.Stack;
@@ -146,9 +150,7 @@
}
}
- /**
- * Called synchronized on mAudioFocusLock
- */
+ @GuardedBy("mAudioFocusLock")
private void notifyTopOfAudioFocusStack() {
// notify the top of the stack it gained focus
if (!mFocusStack.empty()) {
@@ -160,14 +162,24 @@
/**
* Focus is requested, propagate the associated loss throughout the stack.
+ * Will also remove entries in the stack that have just received a definitive loss of focus.
* @param focusGain the new focus gain that will later be added at the top of the stack
*/
+ @GuardedBy("mAudioFocusLock")
private void propagateFocusLossFromGain_syncAf(int focusGain, final FocusRequester fr) {
+ final List<String> clientsToRemove = new LinkedList<String>();
// going through the audio focus stack to signal new focus, traversing order doesn't
// matter as all entries respond to the same external focus gain
- Iterator<FocusRequester> stackIterator = mFocusStack.iterator();
- while(stackIterator.hasNext()) {
- stackIterator.next().handleExternalFocusGain(focusGain, fr);
+ for (FocusRequester focusLoser : mFocusStack) {
+ final boolean isDefinitiveLoss =
+ focusLoser.handleFocusLossFromGain(focusGain, fr);
+ if (isDefinitiveLoss) {
+ clientsToRemove.add(focusLoser.getClientId());
+ }
+ }
+ for (String clientToRemove : clientsToRemove) {
+ removeFocusStackEntry(clientToRemove, false /*signal*/,
+ true /*notifyFocusFollowers*/);
}
}
@@ -198,13 +210,12 @@
}
/**
- * Helper function:
- * Called synchronized on mAudioFocusLock
* Remove a focus listener from the focus stack.
* @param clientToRemove the focus listener
* @param signal if true and the listener was at the top of the focus stack, i.e. it was holding
* focus, notify the next item in the stack it gained focus.
*/
+ @GuardedBy("mAudioFocusLock")
private void removeFocusStackEntry(String clientToRemove, boolean signal,
boolean notifyFocusFollowers) {
// is the current top of the focus stack abandoning focus? (because of request, not death)
@@ -242,10 +253,9 @@
}
/**
- * Helper function:
- * Called synchronized on mAudioFocusLock
* Remove focus listeners from the focus stack for a particular client when it has died.
*/
+ @GuardedBy("mAudioFocusLock")
private void removeFocusStackEntryOnDeath(IBinder cb) {
// is the owner of the audio focus part of the client to remove?
boolean isTopOfStackForClientToRemove = !mFocusStack.isEmpty() &&
@@ -271,10 +281,10 @@
/**
* Helper function for external focus policy:
- * Called synchronized on mAudioFocusLock
* Remove focus listeners from the list of potential focus owners for a particular client when
* it has died.
*/
+ @GuardedBy("mAudioFocusLock")
private void removeFocusEntryForExtPolicy(IBinder cb) {
if (mFocusOwnersForFocusPolicy.isEmpty()) {
return;
@@ -324,6 +334,7 @@
* @return {@link AudioManager#AUDIOFOCUS_REQUEST_GRANTED} or
* {@link AudioManager#AUDIOFOCUS_REQUEST_DELAYED}
*/
+ @GuardedBy("mAudioFocusLock")
private int pushBelowLockedFocusOwners(FocusRequester nfr) {
int lastLockedFocusOwnerIndex = mFocusStack.size();
for (int index = mFocusStack.size()-1; index >= 0; index--) {
diff --git a/services/core/java/com/android/server/broadcastradio/BroadcastRadioService.java b/services/core/java/com/android/server/broadcastradio/BroadcastRadioService.java
index ef51665..7d3b670 100644
--- a/services/core/java/com/android/server/broadcastradio/BroadcastRadioService.java
+++ b/services/core/java/com/android/server/broadcastradio/BroadcastRadioService.java
@@ -94,7 +94,7 @@
}
synchronized (mLock) {
if (mHal2.hasModule(moduleId)) {
- return mHal2.openSession(moduleId, callback);
+ return mHal2.openSession(moduleId, bandConfig, withAudio, callback);
} else {
return mHal1.openTuner(moduleId, bandConfig, withAudio, callback);
}
diff --git a/services/core/java/com/android/server/broadcastradio/hal2/BroadcastRadioService.java b/services/core/java/com/android/server/broadcastradio/hal2/BroadcastRadioService.java
index 413a27c..9158ff0 100644
--- a/services/core/java/com/android/server/broadcastradio/hal2/BroadcastRadioService.java
+++ b/services/core/java/com/android/server/broadcastradio/hal2/BroadcastRadioService.java
@@ -17,6 +17,7 @@
package com.android.server.broadcastradio.hal2;
import android.annotation.NonNull;
+import android.annotation.Nullable;
import android.hardware.radio.ITuner;
import android.hardware.radio.ITunerCallback;
import android.hardware.radio.RadioManager;
@@ -80,14 +81,21 @@
return mModules.containsKey(id);
}
- public ITuner openSession(int moduleId, @NonNull ITunerCallback callback) {
+ public ITuner openSession(int moduleId, @Nullable RadioManager.BandConfig legacyConfig,
+ boolean withAudio, @NonNull ITunerCallback callback) {
Objects.requireNonNull(callback);
+ if (!withAudio) {
+ throw new IllegalArgumentException("Non-audio sessions not supported with HAL 2.x");
+ }
+
RadioModule module = mModules.get(moduleId);
if (module == null) {
throw new IllegalArgumentException("Invalid module ID");
}
- return module.openSession(callback);
+ TunerSession session = module.openSession(callback);
+ session.setConfiguration(legacyConfig);
+ return session;
}
}
diff --git a/services/core/java/com/android/server/broadcastradio/hal2/Convert.java b/services/core/java/com/android/server/broadcastradio/hal2/Convert.java
index 434e262..2c129bb 100644
--- a/services/core/java/com/android/server/broadcastradio/hal2/Convert.java
+++ b/services/core/java/com/android/server/broadcastradio/hal2/Convert.java
@@ -186,7 +186,7 @@
false, // isCaptureSupported
amfmConfigToBands(amfmConfig),
- true, // isBgScanSupported is deprecated
+ false, // isBgScanSupported is deprecated
supportedProgramTypes,
supportedIdentifierTypes,
vendorInfoFromHal(prop.vendorInfo));
diff --git a/services/core/java/com/android/server/broadcastradio/hal2/RadioModule.java b/services/core/java/com/android/server/broadcastradio/hal2/RadioModule.java
index 8a7ac73..45b2190 100644
--- a/services/core/java/com/android/server/broadcastradio/hal2/RadioModule.java
+++ b/services/core/java/com/android/server/broadcastradio/hal2/RadioModule.java
@@ -63,7 +63,7 @@
}
}
- public @NonNull ITuner openSession(@NonNull android.hardware.radio.ITunerCallback userCb) {
+ public @NonNull TunerSession openSession(@NonNull android.hardware.radio.ITunerCallback userCb) {
TunerCallback cb = new TunerCallback(Objects.requireNonNull(userCb));
Mutable<ITunerSession> hwSession = new Mutable<>();
MutableInt halResult = new MutableInt(Result.UNKNOWN_ERROR);
@@ -81,25 +81,6 @@
Convert.throwOnError("openSession", halResult.value);
Objects.requireNonNull(hwSession.value);
- TunerSession session = new TunerSession(hwSession.value, cb);
-
- // send out legacy callback about band configuration
- RadioManager.BandDescriptor[] bands = mProperties.getBands();
- if (bands != null && bands.length > 0) {
- RadioManager.BandDescriptor descr = bands[0]; // just pick first
- Mutable<RadioManager.BandConfig> config = new Mutable<>();
- if (descr instanceof RadioManager.FmBandDescriptor) {
- config.value = new RadioManager.FmBandConfig((RadioManager.FmBandDescriptor)descr);
- } else if (descr instanceof RadioManager.AmBandDescriptor) {
- config.value = new RadioManager.AmBandConfig((RadioManager.AmBandDescriptor)descr);
- } else {
- Slog.w(TAG, "Descriptor is neither AM nor FM");
- }
- if (config.value != null) {
- TunerCallback.dispatch(() -> userCb.onConfigurationChanged(config.value));
- }
- }
-
- return session;
+ return new TunerSession(hwSession.value, cb);
}
}
diff --git a/services/core/java/com/android/server/broadcastradio/hal2/TunerCallback.java b/services/core/java/com/android/server/broadcastradio/hal2/TunerCallback.java
index 5ee6a4c..c9084ee 100644
--- a/services/core/java/com/android/server/broadcastradio/hal2/TunerCallback.java
+++ b/services/core/java/com/android/server/broadcastradio/hal2/TunerCallback.java
@@ -31,14 +31,14 @@
class TunerCallback extends ITunerCallback.Stub {
private static final String TAG = "BcRadio2Srv.cb";
- final android.hardware.radio.ITunerCallback mCb;
+ final android.hardware.radio.ITunerCallback mClientCb;
interface RunnableThrowingRemoteException {
void run() throws RemoteException;
}
TunerCallback(@NonNull android.hardware.radio.ITunerCallback clientCallback) {
- mCb = Objects.requireNonNull(clientCallback);
+ mClientCb = Objects.requireNonNull(clientCallback);
}
static void dispatch(RunnableThrowingRemoteException func) {
diff --git a/services/core/java/com/android/server/broadcastradio/hal2/TunerSession.java b/services/core/java/com/android/server/broadcastradio/hal2/TunerSession.java
index e8faf3d..c4ec94f 100644
--- a/services/core/java/com/android/server/broadcastradio/hal2/TunerSession.java
+++ b/services/core/java/com/android/server/broadcastradio/hal2/TunerSession.java
@@ -18,10 +18,16 @@
import android.annotation.NonNull;
import android.graphics.Bitmap;
+import android.hardware.broadcastradio.V2_0.ConfigFlag;
import android.hardware.broadcastradio.V2_0.ITunerSession;
+import android.hardware.broadcastradio.V2_0.Result;
import android.hardware.radio.ITuner;
import android.hardware.radio.ProgramSelector;
import android.hardware.radio.RadioManager;
+import android.media.AudioSystem;
+import android.os.RemoteException;
+import android.util.MutableBoolean;
+import android.util.MutableInt;
import android.util.Slog;
import java.util.List;
@@ -30,16 +36,23 @@
class TunerSession extends ITuner.Stub {
private static final String TAG = "BcRadio2Srv.session";
+ private static final String kAudioDeviceName = "Radio tuner source";
private final Object mLock = new Object();
private final ITunerSession mHwSession;
private final TunerCallback mCallback;
private boolean mIsClosed = false;
+ private boolean mIsAudioConnected = false;
+ private boolean mIsMuted = false;
+
+ // necessary only for older APIs compatibility
+ private RadioManager.BandConfig mDummyConfig = null;
TunerSession(@NonNull ITunerSession hwSession, @NonNull TunerCallback callback) {
mHwSession = Objects.requireNonNull(hwSession);
mCallback = Objects.requireNonNull(callback);
+ notifyAudioServiceLocked(true);
}
@Override
@@ -47,6 +60,7 @@
synchronized (mLock) {
if (mIsClosed) return;
mIsClosed = true;
+ notifyAudioServiceLocked(false);
}
}
@@ -61,77 +75,197 @@
}
}
+ private void notifyAudioServiceLocked(boolean connected) {
+ if (mIsAudioConnected == connected) return;
+
+ Slog.d(TAG, "Notifying AudioService about new state: " + connected);
+ int ret = AudioSystem.setDeviceConnectionState(AudioSystem.DEVICE_IN_FM_TUNER,
+ connected ? AudioSystem.DEVICE_STATE_AVAILABLE : AudioSystem.DEVICE_STATE_UNAVAILABLE,
+ null, kAudioDeviceName);
+
+ if (ret == AudioSystem.AUDIO_STATUS_OK) {
+ mIsAudioConnected = connected;
+ } else {
+ Slog.e(TAG, "Failed to notify AudioService about new state: " + connected);
+ }
+ }
+
@Override
- public void setConfiguration(RadioManager.BandConfig config) {}
+ public void setConfiguration(RadioManager.BandConfig config) {
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ mDummyConfig = Objects.requireNonNull(config);
+ Slog.i(TAG, "Ignoring setConfiguration - not applicable for broadcastradio HAL 2.x");
+ TunerCallback.dispatch(() -> mCallback.mClientCb.onConfigurationChanged(config));
+ }
+ }
@Override
public RadioManager.BandConfig getConfiguration() {
- return null;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return mDummyConfig;
+ }
}
@Override
- public void setMuted(boolean mute) {}
+ public void setMuted(boolean mute) {
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ if (mIsMuted == mute) return;
+ mIsMuted = mute;
+ notifyAudioServiceLocked(!mute);
+ }
+ }
@Override
public boolean isMuted() {
- return false;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return mIsMuted;
+ }
}
@Override
- public void step(boolean directionDown, boolean skipSubChannel) {}
+ public void step(boolean directionDown, boolean skipSubChannel) {
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ }
+ }
@Override
- public void scan(boolean directionDown, boolean skipSubChannel) {}
+ public void scan(boolean directionDown, boolean skipSubChannel) {
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ }
+ }
@Override
- public void tune(ProgramSelector selector) {}
+ public void tune(ProgramSelector selector) {
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ }
+ }
@Override
- public void cancel() {}
+ public void cancel() {
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ }
+ }
@Override
- public void cancelAnnouncement() {}
+ public void cancelAnnouncement() {
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ }
+ }
@Override
public RadioManager.ProgramInfo getProgramInformation() {
- return null;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return null;
+ }
}
@Override
public Bitmap getImage(int id) {
- return null;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return null;
+ }
}
@Override
public boolean startBackgroundScan() {
+ Slog.i(TAG, "Explicit background scan trigger is not supported with HAL 2.x");
return false;
}
@Override
public List<RadioManager.ProgramInfo> getProgramList(Map vendorFilter) {
- return null;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return null;
+ }
+ }
+
+ private boolean getConfigFlag(int flag) {
+ Slog.v(TAG, "getConfigFlag " + ConfigFlag.toString(flag));
+ synchronized (mLock) {
+ checkNotClosedLocked();
+
+ MutableInt halResult = new MutableInt(Result.UNKNOWN_ERROR);
+ MutableBoolean flagState = new MutableBoolean(false);
+ try {
+ mHwSession.getConfigFlag(flag, (int result, boolean value) -> {
+ halResult.value = result;
+ flagState.value = value;
+ });
+ } catch (RemoteException ex) {
+ throw new RuntimeException("Failed to get flag " + ConfigFlag.toString(flag), ex);
+ }
+ Convert.throwOnError("getConfigFlag", halResult.value);
+
+ return flagState.value;
+ }
+ }
+
+ private void setConfigFlag(int flag, boolean value) {
+ Slog.v(TAG, "setConfigFlag " + ConfigFlag.toString(flag) + " = " + value);
+ synchronized (mLock) {
+ checkNotClosedLocked();
+
+ int halResult;
+ try {
+ halResult = mHwSession.setConfigFlag(flag, value);
+ } catch (RemoteException ex) {
+ throw new RuntimeException("Failed to set flag " + ConfigFlag.toString(flag), ex);
+ }
+ Convert.throwOnError("setConfigFlag", halResult);
+ }
}
@Override
public boolean isAnalogForced() {
- return false;
+ try {
+ return getConfigFlag(ConfigFlag.FORCE_ANALOG);
+ } catch (UnsupportedOperationException ex) {
+ throw new IllegalStateException(ex);
+ }
}
@Override
- public void setAnalogForced(boolean isForced) {}
+ public void setAnalogForced(boolean isForced) {
+ try {
+ setConfigFlag(ConfigFlag.FORCE_ANALOG, isForced);
+ } catch (UnsupportedOperationException ex) {
+ throw new IllegalStateException(ex);
+ }
+ }
@Override
public Map setParameters(Map parameters) {
- return null;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return null;
+ }
}
@Override
public Map getParameters(List<String> keys) {
- return null;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return null;
+ }
}
@Override
public boolean isAntennaConnected() {
- return true;
+ synchronized (mLock) {
+ checkNotClosedLocked();
+ return true;
+ }
}
}
diff --git a/services/core/java/com/android/server/display/BrightnessMappingStrategy.java b/services/core/java/com/android/server/display/BrightnessMappingStrategy.java
index 0b62907..ac0e1b5 100644
--- a/services/core/java/com/android/server/display/BrightnessMappingStrategy.java
+++ b/services/core/java/com/android/server/display/BrightnessMappingStrategy.java
@@ -222,8 +222,6 @@
@Override
public boolean setBrightnessConfiguration(@Nullable BrightnessConfiguration config) {
- Slog.e(TAG,
- "setBrightnessConfiguration called on device without display information.");
return false;
}
diff --git a/services/core/java/com/android/server/display/DisplayPowerController.java b/services/core/java/com/android/server/display/DisplayPowerController.java
index e5a4b0a..d2b8e5c 100644
--- a/services/core/java/com/android/server/display/DisplayPowerController.java
+++ b/services/core/java/com/android/server/display/DisplayPowerController.java
@@ -260,13 +260,6 @@
private long mScreenOnBlockStartRealTime;
private long mScreenOffBlockStartRealTime;
- // The last brightness that was set by the user and not temporary. Set to -1 when a brightness
- // has yet to be recorded.
- private int mLastBrightness;
- // The last auto brightness adjustment that was set by the user and not temporary. Set to
- // Float.NaN when an auto-brightness adjustment hasn't been recorded yet.
- private float mLastAutoBrightnessAdjustment;
-
// Screen state we reported to policy. Must be one of REPORTED_TO_POLICY_SCREEN_* fields.
private int mReportedScreenStateToPolicy;
@@ -299,14 +292,18 @@
@Nullable
private BrightnessMappingStrategy mBrightnessMapper;
- // The default brightness configuration. Used for whenever we don't have a valid brightness
- // configuration set. This is typically seen with users that don't have a brightness
- // configuration that's different from the default.
- private BrightnessConfiguration mDefaultBrightnessConfiguration;
-
// The current brightness configuration.
+ @Nullable
private BrightnessConfiguration mBrightnessConfiguration;
+ // The last brightness that was set by the user and not temporary. Set to -1 when a brightness
+ // has yet to be recorded.
+ private int mLastBrightness;
+
+ // The last auto brightness adjustment that was set by the user and not temporary. Set to
+ // Float.NaN when an auto-brightness adjustment hasn't been recorded yet.
+ private float mLastAutoBrightnessAdjustment;
+
// Animators.
private ObjectAnimator mColorFadeOnAnimator;
private ObjectAnimator mColorFadeOffAnimator;
@@ -1488,8 +1485,7 @@
}
break;
case MSG_CONFIGURE_BRIGHTNESS:
- BrightnessConfiguration c = (BrightnessConfiguration) msg.obj;
- mBrightnessConfiguration = c != null ? c : mDefaultBrightnessConfiguration;
+ mBrightnessConfiguration = (BrightnessConfiguration)msg.obj;
updatePowerState();
break;
}
diff --git a/services/core/java/com/android/server/job/JobSchedulerService.java b/services/core/java/com/android/server/job/JobSchedulerService.java
index bcb57ef..70e2c8d 100644
--- a/services/core/java/com/android/server/job/JobSchedulerService.java
+++ b/services/core/java/com/android/server/job/JobSchedulerService.java
@@ -185,6 +185,11 @@
boolean mReportedActive;
/**
+ * Are we currently in device-wide standby parole?
+ */
+ volatile boolean mInParole;
+
+ /**
* Current limit on the number of concurrent JobServiceContext entries we want to
* keep actively running a job.
*/
@@ -466,11 +471,11 @@
DEFAULT_MAX_STANDARD_RESCHEDULE_COUNT);
MAX_WORK_RESCHEDULE_COUNT = mParser.getInt(KEY_MAX_WORK_RESCHEDULE_COUNT,
DEFAULT_MAX_WORK_RESCHEDULE_COUNT);
- MIN_LINEAR_BACKOFF_TIME = mParser.getLong(KEY_MIN_LINEAR_BACKOFF_TIME,
+ MIN_LINEAR_BACKOFF_TIME = mParser.getDurationMillis(KEY_MIN_LINEAR_BACKOFF_TIME,
DEFAULT_MIN_LINEAR_BACKOFF_TIME);
- MIN_EXP_BACKOFF_TIME = mParser.getLong(KEY_MIN_EXP_BACKOFF_TIME,
+ MIN_EXP_BACKOFF_TIME = mParser.getDurationMillis(KEY_MIN_EXP_BACKOFF_TIME,
DEFAULT_MIN_EXP_BACKOFF_TIME);
- STANDBY_HEARTBEAT_TIME = mParser.getLong(KEY_STANDBY_HEARTBEAT_TIME,
+ STANDBY_HEARTBEAT_TIME = mParser.getDurationMillis(KEY_STANDBY_HEARTBEAT_TIME,
DEFAULT_STANDBY_HEARTBEAT_TIME);
STANDBY_BEATS[1] = mParser.getInt(KEY_STANDBY_WORKING_BEATS,
DEFAULT_STANDBY_WORKING_BEATS);
@@ -1720,28 +1725,31 @@
}
// If the app is in a non-active standby bucket, make sure we've waited
- // an appropriate amount of time since the last invocation
- final int bucket = job.getStandbyBucket();
- if (mHeartbeat < mNextBucketHeartbeat[bucket]) {
- // Only skip this job if it's still waiting for the end of its (initial) nominal
- // bucket interval. Once it's waited that long, we let it go ahead and clear.
- // The final (NEVER) bucket is special; we never age those apps' jobs into
- // runnability.
- if (bucket >= mConstants.STANDBY_BEATS.length
- || (mHeartbeat < job.getBaseHeartbeat() + mConstants.STANDBY_BEATS[bucket])) {
- // TODO: log/trace that we're deferring the job due to bucketing if we hit this
- if (job.getWhenStandbyDeferred() == 0) {
- if (DEBUG_STANDBY) {
- Slog.v(TAG, "Bucket deferral: " + mHeartbeat + " < "
- + mNextBucketHeartbeat[job.getStandbyBucket()] + " for " + job);
+ // an appropriate amount of time since the last invocation. During device-
+ // wide parole, standby bucketing is ignored.
+ if (!mInParole) {
+ final int bucket = job.getStandbyBucket();
+ if (mHeartbeat < mNextBucketHeartbeat[bucket]) {
+ // Only skip this job if it's still waiting for the end of its (initial) nominal
+ // bucket interval. Once it's waited that long, we let it go ahead and clear.
+ // The final (NEVER) bucket is special; we never age those apps' jobs into
+ // runnability.
+ if (bucket >= mConstants.STANDBY_BEATS.length
+ || (mHeartbeat < job.getBaseHeartbeat() + mConstants.STANDBY_BEATS[bucket])) {
+ // TODO: log/trace that we're deferring the job due to bucketing if we hit this
+ if (job.getWhenStandbyDeferred() == 0) {
+ if (DEBUG_STANDBY) {
+ Slog.v(TAG, "Bucket deferral: " + mHeartbeat + " < "
+ + mNextBucketHeartbeat[job.getStandbyBucket()] + " for " + job);
+ }
+ job.setWhenStandbyDeferred(sElapsedRealtimeClock.millis());
}
- job.setWhenStandbyDeferred(sElapsedRealtimeClock.millis());
- }
- return false;
- } else {
- if (DEBUG_STANDBY) {
- Slog.v(TAG, "Bucket deferred job aged into runnability at "
- + mHeartbeat + " : " + job);
+ return false;
+ } else {
+ if (DEBUG_STANDBY) {
+ Slog.v(TAG, "Bucket deferred job aged into runnability at "
+ + mHeartbeat + " : " + job);
+ }
}
}
}
@@ -2086,7 +2094,10 @@
@Override
public void onParoleStateChanged(boolean isParoleOn) {
- // Unused
+ if (DEBUG_STANDBY) {
+ Slog.i(TAG, "Global parole state now " + (isParoleOn ? "ON" : "OFF"));
+ }
+ mInParole = isParoleOn;
}
}
diff --git a/services/core/java/com/android/server/job/JobServiceContext.java b/services/core/java/com/android/server/job/JobServiceContext.java
index 6a3fd04..709deeb 100644
--- a/services/core/java/com/android/server/job/JobServiceContext.java
+++ b/services/core/java/com/android/server/job/JobServiceContext.java
@@ -38,12 +38,14 @@
import android.os.RemoteException;
import android.os.UserHandle;
import android.os.WorkSource;
+import android.util.EventLog;
import android.util.Slog;
import android.util.TimeUtils;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.app.IBatteryStats;
+import com.android.server.EventLogTags;
import com.android.server.job.controllers.JobStatus;
/**
@@ -222,17 +224,20 @@
isDeadlineExpired, triggeredUris, triggeredAuthorities, job.network);
mExecutionStartTimeElapsed = sElapsedRealtimeClock.millis();
- if (DEBUG_STANDBY) {
- final long whenDeferred = job.getWhenStandbyDeferred();
- if (whenDeferred > 0) {
+ final long whenDeferred = job.getWhenStandbyDeferred();
+ if (whenDeferred > 0) {
+ final long deferral = mExecutionStartTimeElapsed - whenDeferred;
+ EventLog.writeEvent(EventLogTags.JOB_DEFERRED_EXECUTION, deferral);
+ if (DEBUG_STANDBY) {
StringBuilder sb = new StringBuilder(128);
sb.append("Starting job deferred for standby by ");
- TimeUtils.formatDuration(mExecutionStartTimeElapsed - whenDeferred, sb);
- sb.append(" : ");
+ TimeUtils.formatDuration(deferral, sb);
+ sb.append(" ms : ");
sb.append(job.toShortString());
Slog.v(TAG, sb.toString());
}
}
+
// Once we'e begun executing a job, we by definition no longer care whether
// it was inflated from disk with not-yet-coherent delay/deadline bounds.
job.clearPersistedUtcTimes();
diff --git a/services/core/java/com/android/server/locksettings/LockSettingsService.java b/services/core/java/com/android/server/locksettings/LockSettingsService.java
index 1fa8da7..1e85232 100644
--- a/services/core/java/com/android/server/locksettings/LockSettingsService.java
+++ b/services/core/java/com/android/server/locksettings/LockSettingsService.java
@@ -2031,6 +2031,11 @@
}
@Override
+ public void removeKey(@NonNull String alias) throws RemoteException {
+ mRecoverableKeyStoreManager.removeKey(alias);
+ }
+
+ @Override
public byte[] generateAndStoreKey(@NonNull String alias) throws RemoteException {
return mRecoverableKeyStoreManager.generateAndStoreKey(alias);
}
diff --git a/services/core/java/com/android/server/locksettings/recoverablekeystore/KeySyncTask.java b/services/core/java/com/android/server/locksettings/recoverablekeystore/KeySyncTask.java
index e385833..6dafd0b 100644
--- a/services/core/java/com/android/server/locksettings/recoverablekeystore/KeySyncTask.java
+++ b/services/core/java/com/android/server/locksettings/recoverablekeystore/KeySyncTask.java
@@ -89,7 +89,7 @@
userId,
credentialType,
credential,
- () -> PlatformKeyManager.getInstance(context, recoverableKeyStoreDb, userId));
+ () -> PlatformKeyManager.getInstance(context, recoverableKeyStoreDb));
}
/**
@@ -246,7 +246,7 @@
throws InsecureUserException, KeyStoreException, UnrecoverableKeyException,
NoSuchAlgorithmException, NoSuchPaddingException, BadPlatformKeyException {
PlatformKeyManager platformKeyManager = mPlatformKeyManagerFactory.newInstance();
- PlatformDecryptionKey decryptKey = platformKeyManager.getDecryptKey();
+ PlatformDecryptionKey decryptKey = platformKeyManager.getDecryptKey(mUserId);
Map<String, WrappedKey> wrappedKeys = mRecoverableKeyStoreDb.getAllKeys(
mUserId, decryptKey.getGenerationId());
return WrappedKey.unwrapKeys(decryptKey, wrappedKeys);
diff --git a/services/core/java/com/android/server/locksettings/recoverablekeystore/PlatformKeyManager.java b/services/core/java/com/android/server/locksettings/recoverablekeystore/PlatformKeyManager.java
index a8b8361..7005de5 100644
--- a/services/core/java/com/android/server/locksettings/recoverablekeystore/PlatformKeyManager.java
+++ b/services/core/java/com/android/server/locksettings/recoverablekeystore/PlatformKeyManager.java
@@ -71,7 +71,6 @@
private final Context mContext;
private final KeyStoreProxy mKeyStore;
private final RecoverableKeyStoreDb mDatabase;
- private final int mUserId;
private static final String ANDROID_KEY_STORE_PROVIDER = "AndroidKeyStore";
@@ -80,34 +79,25 @@
* defined by {@code context}.
*
* @param context This should be the context of the RecoverableKeyStoreLoader service.
- * @param userId The ID of the user to whose lock screen the platform key must be bound.
* @throws KeyStoreException if failed to initialize AndroidKeyStore.
* @throws NoSuchAlgorithmException if AES is unavailable - should never happen.
- * @throws InsecureUserException if the user does not have a lock screen set.
* @throws SecurityException if the caller does not have permission to write to /data/system.
*
* @hide
*/
- public static PlatformKeyManager getInstance(Context context, RecoverableKeyStoreDb database,
- int userId)
- throws KeyStoreException, NoSuchAlgorithmException, InsecureUserException {
- context = context.getApplicationContext();
- PlatformKeyManager keyManager = new PlatformKeyManager(
- userId,
- context,
+ public static PlatformKeyManager getInstance(Context context, RecoverableKeyStoreDb database)
+ throws KeyStoreException, NoSuchAlgorithmException {
+ return new PlatformKeyManager(
+ context.getApplicationContext(),
new KeyStoreProxyImpl(getAndLoadAndroidKeyStore()),
database);
- keyManager.init();
- return keyManager;
}
@VisibleForTesting
PlatformKeyManager(
- int userId,
Context context,
KeyStoreProxy keyStore,
RecoverableKeyStoreDb database) {
- mUserId = userId;
mKeyStore = keyStore;
mContext = context;
mDatabase = database;
@@ -118,67 +108,91 @@
* key has to be replaced. (e.g., because the user has removed and then re-added their lock
* screen). Returns -1 if no key has been generated yet.
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
+ *
* @hide
*/
- public int getGenerationId() {
- return mDatabase.getPlatformKeyGenerationId(mUserId);
+ public int getGenerationId(int userId) {
+ return mDatabase.getPlatformKeyGenerationId(userId);
}
/**
* Returns {@code true} if the platform key is available. A platform key won't be available if
* the user has not set up a lock screen.
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
+ *
* @hide
*/
- public boolean isAvailable() {
- return mContext.getSystemService(KeyguardManager.class).isDeviceSecure(mUserId);
+ public boolean isAvailable(int userId) {
+ return mContext.getSystemService(KeyguardManager.class).isDeviceSecure(userId);
}
/**
* Generates a new key and increments the generation ID. Should be invoked if the platform key
* is corrupted and needs to be rotated.
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
* @throws NoSuchAlgorithmException if AES is unavailable - should never happen.
* @throws KeyStoreException if there is an error in AndroidKeyStore.
+ * @throws InsecureUserException if the user does not have a lock screen set.
*
* @hide
*/
- public void regenerate() throws NoSuchAlgorithmException, KeyStoreException {
- int nextId = getGenerationId() + 1;
- generateAndLoadKey(nextId);
+ public void regenerate(int userId)
+ throws NoSuchAlgorithmException, KeyStoreException, InsecureUserException {
+ if (!isAvailable(userId)) {
+ throw new InsecureUserException(String.format(
+ Locale.US, "%d does not have a lock screen set.", userId));
+ }
+
+ int generationId = getGenerationId(userId);
+ int nextId;
+ if (generationId == -1) {
+ nextId = 1;
+ } else {
+ nextId = generationId + 1;
+ }
+ generateAndLoadKey(userId, nextId);
}
/**
* Returns the platform key used for encryption.
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
* @throws KeyStoreException if there was an AndroidKeyStore error.
* @throws UnrecoverableKeyException if the key could not be recovered.
* @throws NoSuchAlgorithmException if AES is unavailable - should never occur.
+ * @throws InsecureUserException if the user does not have a lock screen set.
*
* @hide
*/
- public PlatformEncryptionKey getEncryptKey()
- throws KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException {
- int generationId = getGenerationId();
+ public PlatformEncryptionKey getEncryptKey(int userId) throws KeyStoreException,
+ UnrecoverableKeyException, NoSuchAlgorithmException, InsecureUserException {
+ init(userId);
+ int generationId = getGenerationId(userId);
AndroidKeyStoreSecretKey key = (AndroidKeyStoreSecretKey) mKeyStore.getKey(
- getEncryptAlias(generationId), /*password=*/ null);
+ getEncryptAlias(userId, generationId), /*password=*/ null);
return new PlatformEncryptionKey(generationId, key);
}
/**
* Returns the platform key used for decryption. Only works after a recent screen unlock.
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
* @throws KeyStoreException if there was an AndroidKeyStore error.
* @throws UnrecoverableKeyException if the key could not be recovered.
* @throws NoSuchAlgorithmException if AES is unavailable - should never occur.
+ * @throws InsecureUserException if the user does not have a lock screen set.
*
* @hide
*/
- public PlatformDecryptionKey getDecryptKey()
- throws KeyStoreException, UnrecoverableKeyException, NoSuchAlgorithmException {
- int generationId = getGenerationId();
+ public PlatformDecryptionKey getDecryptKey(int userId) throws KeyStoreException,
+ UnrecoverableKeyException, NoSuchAlgorithmException, InsecureUserException {
+ init(userId);
+ int generationId = getGenerationId(userId);
AndroidKeyStoreSecretKey key = (AndroidKeyStoreSecretKey) mKeyStore.getKey(
- getDecryptAlias(generationId), /*password=*/ null);
+ getDecryptAlias(userId, generationId), /*password=*/ null);
return new PlatformDecryptionKey(generationId, key);
}
@@ -186,38 +200,36 @@
* Initializes the class. If there is no current platform key, and the user has a lock screen
* set, will create the platform key and set the generation ID.
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
* @throws KeyStoreException if there was an error in AndroidKeyStore.
* @throws NoSuchAlgorithmException if AES is unavailable - should never happen.
*
* @hide
*/
- public void init() throws KeyStoreException, NoSuchAlgorithmException, InsecureUserException {
- if (!isAvailable()) {
+ void init(int userId)
+ throws KeyStoreException, NoSuchAlgorithmException, InsecureUserException {
+ if (!isAvailable(userId)) {
throw new InsecureUserException(String.format(
- Locale.US, "%d does not have a lock screen set.", mUserId));
+ Locale.US, "%d does not have a lock screen set.", userId));
}
- int generationId = getGenerationId();
- if (isKeyLoaded(generationId)) {
+ int generationId = getGenerationId(userId);
+ if (isKeyLoaded(userId, generationId)) {
Log.i(TAG, String.format(
Locale.US, "Platform key generation %d exists already.", generationId));
return;
}
if (generationId == -1) {
Log.i(TAG, "Generating initial platform ID.");
+ generationId = 1;
} else {
Log.w(TAG, String.format(Locale.US, "Platform generation ID was %d but no "
+ "entry was present in AndroidKeyStore. Generating fresh key.", generationId));
- }
-
- if (generationId == -1) {
- generationId = 1;
- } else {
// Had to generate a fresh key, bump the generation id
generationId++;
}
- generateAndLoadKey(generationId);
+ generateAndLoadKey(userId, generationId);
}
/**
@@ -227,11 +239,12 @@
* <p>These IDs look as follows:
* {@code com.security.recoverablekeystore/platform/<user id>/<generation id>/encrypt}
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
* @param generationId The generation ID.
* @return The alias.
*/
- private String getEncryptAlias(int generationId) {
- return KEY_ALIAS_PREFIX + mUserId + "/" + generationId + "/" + ENCRYPT_KEY_ALIAS_SUFFIX;
+ private String getEncryptAlias(int userId, int generationId) {
+ return KEY_ALIAS_PREFIX + userId + "/" + generationId + "/" + ENCRYPT_KEY_ALIAS_SUFFIX;
}
/**
@@ -241,18 +254,19 @@
* <p>These IDs look as follows:
* {@code com.security.recoverablekeystore/platform/<user id>/<generation id>/decrypt}
*
+ * @param userId The ID of the user to whose lock screen the platform key must be bound.
* @param generationId The generation ID.
* @return The alias.
*/
- private String getDecryptAlias(int generationId) {
- return KEY_ALIAS_PREFIX + mUserId + "/" + generationId + "/" + DECRYPT_KEY_ALIAS_SUFFIX;
+ private String getDecryptAlias(int userId, int generationId) {
+ return KEY_ALIAS_PREFIX + userId + "/" + generationId + "/" + DECRYPT_KEY_ALIAS_SUFFIX;
}
/**
* Sets the current generation ID to {@code generationId}.
*/
- private void setGenerationId(int generationId) {
- mDatabase.setPlatformKeyGenerationId(mUserId, generationId);
+ private void setGenerationId(int userId, int generationId) {
+ mDatabase.setPlatformKeyGenerationId(userId, generationId);
}
/**
@@ -261,9 +275,9 @@
*
* @throws KeyStoreException if there was an error checking AndroidKeyStore.
*/
- private boolean isKeyLoaded(int generationId) throws KeyStoreException {
- return mKeyStore.containsAlias(getEncryptAlias(generationId))
- && mKeyStore.containsAlias(getDecryptAlias(generationId));
+ private boolean isKeyLoaded(int userId, int generationId) throws KeyStoreException {
+ return mKeyStore.containsAlias(getEncryptAlias(userId, generationId))
+ && mKeyStore.containsAlias(getDecryptAlias(userId, generationId));
}
/**
@@ -274,10 +288,10 @@
* available since API version 1.
* @throws KeyStoreException if there was an issue loading the keys into AndroidKeyStore.
*/
- private void generateAndLoadKey(int generationId)
+ private void generateAndLoadKey(int userId, int generationId)
throws NoSuchAlgorithmException, KeyStoreException {
- String encryptAlias = getEncryptAlias(generationId);
- String decryptAlias = getDecryptAlias(generationId);
+ String encryptAlias = getEncryptAlias(userId, generationId);
+ String decryptAlias = getDecryptAlias(userId, generationId);
SecretKey secretKey = generateAesKey();
mKeyStore.setEntry(
@@ -296,10 +310,10 @@
USER_AUTHENTICATION_VALIDITY_DURATION_SECONDS)
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
- .setBoundToSpecificSecureUserId(mUserId)
+ .setBoundToSpecificSecureUserId(userId)
.build());
- setGenerationId(generationId);
+ setGenerationId(userId, generationId);
try {
secretKey.destroy();
diff --git a/services/core/java/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManager.java b/services/core/java/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManager.java
index c73f852..54acb87 100644
--- a/services/core/java/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManager.java
+++ b/services/core/java/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManager.java
@@ -16,6 +16,19 @@
package com.android.server.locksettings.recoverablekeystore;
+import static android.security.recoverablekeystore.RecoverableKeyStoreLoader
+ .ERROR_BAD_X509_CERTIFICATE;
+import static android.security.recoverablekeystore.RecoverableKeyStoreLoader.ERROR_DATABASE_ERROR;
+import static android.security.recoverablekeystore.RecoverableKeyStoreLoader
+ .ERROR_DECRYPTION_FAILED;
+import static android.security.recoverablekeystore.RecoverableKeyStoreLoader.ERROR_INSECURE_USER;
+import static android.security.recoverablekeystore.RecoverableKeyStoreLoader
+ .ERROR_KEYSTORE_INTERNAL_ERROR;
+import static android.security.recoverablekeystore.RecoverableKeyStoreLoader
+ .ERROR_NOT_YET_SUPPORTED;
+import static android.security.recoverablekeystore.RecoverableKeyStoreLoader
+ .ERROR_UNEXPECTED_MISSING_ALGORITHM;
+
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.PendingIntent;
@@ -45,6 +58,7 @@
import java.security.UnrecoverableKeyException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.X509EncodedKeySpec;
+import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
@@ -63,12 +77,6 @@
public class RecoverableKeyStoreManager {
private static final String TAG = "RecoverableKeyStoreMgr";
- // TODO: move error codes to RecoverableKeyStoreLoader.
- private static int ERROR_INSECURE_USER = 1;
- private static int ERROR_KEYSTORE_INTERNAL_ERROR = 2;
- private static int ERROR_DATABASE_ERROR = 3;
- private static int ERROR_RECOVERY_SESSION_NOT_FOUND = 4;
-
private static RecoverableKeyStoreManager mInstance;
private final Context mContext;
@@ -78,22 +86,34 @@
private final RecoverySnapshotListenersStorage mListenersStorage;
private final RecoverableKeyGenerator mRecoverableKeyGenerator;
private final RecoverySnapshotStorage mSnapshotStorage;
+ private final PlatformKeyManager mPlatformKeyManager;
/**
* Returns a new or existing instance.
*
* @hide
*/
- public static synchronized RecoverableKeyStoreManager getInstance(Context mContext) {
+ public static synchronized RecoverableKeyStoreManager getInstance(Context context) {
if (mInstance == null) {
- RecoverableKeyStoreDb db = RecoverableKeyStoreDb.newInstance(mContext);
+ RecoverableKeyStoreDb db = RecoverableKeyStoreDb.newInstance(context);
+ PlatformKeyManager platformKeyManager;
+ try {
+ platformKeyManager = PlatformKeyManager.getInstance(context, db);
+ } catch (NoSuchAlgorithmException e) {
+ // Impossible: all algorithms must be supported by AOSP
+ throw new RuntimeException(e);
+ } catch (KeyStoreException e) {
+ throw new ServiceSpecificException(ERROR_KEYSTORE_INTERNAL_ERROR, e.getMessage());
+ }
+
mInstance = new RecoverableKeyStoreManager(
- mContext.getApplicationContext(),
+ context.getApplicationContext(),
db,
new RecoverySessionStorage(),
Executors.newSingleThreadExecutor(),
new RecoverySnapshotStorage(),
- new RecoverySnapshotListenersStorage());
+ new RecoverySnapshotListenersStorage(),
+ platformKeyManager);
}
return mInstance;
}
@@ -105,18 +125,21 @@
RecoverySessionStorage recoverySessionStorage,
ExecutorService executorService,
RecoverySnapshotStorage snapshotStorage,
- RecoverySnapshotListenersStorage listenersStorage) {
+ RecoverySnapshotListenersStorage listenersStorage,
+ PlatformKeyManager platformKeyManager) {
mContext = context;
mDatabase = recoverableKeyStoreDb;
mRecoverySessionStorage = recoverySessionStorage;
mExecutorService = executorService;
mListenersStorage = listenersStorage;
mSnapshotStorage = snapshotStorage;
+ mPlatformKeyManager = platformKeyManager;
+
try {
mRecoverableKeyGenerator = RecoverableKeyGenerator.newInstance(mDatabase);
} catch (NoSuchAlgorithmException e) {
- // Impossible: all AOSP implementations must support AES.
- throw new RuntimeException(e);
+ Log.wtf(TAG, "AES keygen algorithm not available. AOSP must support this.", e);
+ throw new ServiceSpecificException(ERROR_UNEXPECTED_MISSING_ALGORITHM, e.getMessage());
}
}
@@ -133,10 +156,11 @@
X509EncodedKeySpec pkSpec = new X509EncodedKeySpec(signedPublicKeyList);
publicKey = kf.generatePublic(pkSpec);
} catch (NoSuchAlgorithmException e) {
- // Should never happen
- throw new RuntimeException(e);
+ Log.wtf(TAG, "EC algorithm not available. AOSP must support this.", e);
+ throw new ServiceSpecificException(ERROR_UNEXPECTED_MISSING_ALGORITHM, e.getMessage());
} catch (InvalidKeySpecException e) {
- throw new RemoteException("Invalid public key for the recovery service");
+ throw new ServiceSpecificException(
+ ERROR_BAD_X509_CERTIFICATE, "Not a valid X509 certificate.");
}
mDatabase.setRecoveryServicePublicKey(userId, Binder.getCallingUid(), publicKey);
}
@@ -295,7 +319,26 @@
if (secrets.size() != 1) {
// TODO: support multiple secrets
- throw new RemoteException("Only a single KeyStoreRecoveryMetadata is supported");
+ throw new ServiceSpecificException(
+ ERROR_NOT_YET_SUPPORTED,
+ "Only a single KeyStoreRecoveryMetadata is supported");
+ }
+
+ PublicKey publicKey;
+ try {
+ publicKey = KeySyncUtils.deserializePublicKey(verifierPublicKey);
+ } catch (NoSuchAlgorithmException e) {
+ // Should never happen
+ throw new RuntimeException(e);
+ } catch (InvalidKeySpecException e) {
+ throw new ServiceSpecificException(ERROR_BAD_X509_CERTIFICATE, "Not a valid X509 key");
+ }
+ // The raw public key bytes contained in vaultParams must match the ones given in
+ // verifierPublicKey; otherwise, the user secret may be decrypted by a key that is not owned
+ // by the original recovery service.
+ if (!publicKeysMatch(publicKey, vaultParams)) {
+ throw new ServiceSpecificException(ERROR_BAD_X509_CERTIFICATE,
+ "The public keys given in verifierPublicKey and vaultParams do not match.");
}
byte[] keyClaimant = KeySyncUtils.generateKeyClaimant();
@@ -306,7 +349,6 @@
try {
byte[] thmKfHash = KeySyncUtils.calculateThmKfHash(kfHash);
- PublicKey publicKey = KeySyncUtils.deserializePublicKey(verifierPublicKey);
return KeySyncUtils.encryptRecoveryClaim(
publicKey,
vaultParams,
@@ -314,18 +356,10 @@
thmKfHash,
keyClaimant);
} catch (NoSuchAlgorithmException e) {
- // Should never happen: all the algorithms used are required by AOSP implementations.
- throw new RemoteException(
- "Missing required algorithm",
- e,
- /*enableSuppression=*/ true,
- /*writeableStackTrace=*/ true);
- } catch (InvalidKeySpecException | InvalidKeyException e) {
- throw new RemoteException(
- "Not a valid X509 key",
- e,
- /*enableSuppression=*/ true,
- /*writeableStackTrace=*/ true);
+ Log.wtf(TAG, "SecureBox algorithm missing. AOSP must support this.", e);
+ throw new ServiceSpecificException(ERROR_UNEXPECTED_MISSING_ALGORITHM, e.getMessage());
+ } catch (InvalidKeyException e) {
+ throw new ServiceSpecificException(ERROR_BAD_X509_CERTIFICATE, e.getMessage());
}
}
@@ -334,7 +368,7 @@
* service.
*
* @param sessionId The session ID used to generate the claim. See
- * {@link #startRecoverySession(String, byte[], byte[], byte[], List, int)}.
+ * {@link #startRecoverySession(String, byte[], byte[], byte[], List)}.
* @param encryptedRecoveryKey The encrypted recovery key blob returned by the remote vault
* service.
* @param applicationKeys The encrypted key blobs returned by the remote vault service. These
@@ -378,11 +412,8 @@
int userId = UserHandle.getCallingUserId();
PlatformEncryptionKey encryptionKey;
-
try {
- PlatformKeyManager platformKeyManager = PlatformKeyManager.getInstance(
- mContext, mDatabase, userId);
- encryptionKey = platformKeyManager.getEncryptKey();
+ encryptionKey = mPlatformKeyManager.getEncryptKey(userId);
} catch (NoSuchAlgorithmException e) {
// Impossible: all algorithms must be supported by AOSP
throw new RuntimeException(e);
@@ -401,6 +432,10 @@
}
}
+ public void removeKey(@NonNull String alias) throws RemoteException {
+ mDatabase.removeKey(Binder.getCallingUid(), alias);
+ }
+
private byte[] decryptRecoveryKey(
RecoverySessionStorage.Entry sessionEntry, byte[] encryptedClaimResponse)
throws RemoteException, ServiceSpecificException {
@@ -439,18 +474,12 @@
KeySyncUtils.decryptApplicationKey(recoveryKey, encryptedKeyMaterial);
keyMaterialByAlias.put(alias, keyMaterial);
} catch (NoSuchAlgorithmException e) {
- // Should never happen: all the algorithms used are required by AOSP implementations
- throw new RemoteException(
- "Missing required algorithm",
- e,
- /*enableSuppression=*/ true,
- /*writeableStackTrace=*/ true);
+ Log.wtf(TAG, "Missing SecureBox algorithm. AOSP required to support this.", e);
+ throw new ServiceSpecificException(
+ ERROR_UNEXPECTED_MISSING_ALGORITHM, e.getMessage());
} catch (InvalidKeyException | AEADBadTagException e) {
- throw new RemoteException(
- "Failed to recover key with alias '" + alias + "'",
- e,
- /*enableSuppression=*/ true,
- /*writeableStackTrace=*/ true);
+ throw new ServiceSpecificException(ERROR_DECRYPTION_FAILED,
+ "Failed to recover key with alias '" + alias + "': " + e.getMessage());
}
}
return keyMaterialByAlias;
@@ -499,4 +528,9 @@
RecoverableKeyStoreLoader.PERMISSION_RECOVER_KEYSTORE,
"Caller " + Binder.getCallingUid() + " doesn't have RecoverKeyStore permission.");
}
+
+ private boolean publicKeysMatch(PublicKey publicKey, byte[] vaultParams) {
+ byte[] encodedPublicKey = SecureBox.encodePublicKey(publicKey);
+ return Arrays.equals(encodedPublicKey, Arrays.copyOf(vaultParams, encodedPublicKey.length));
+ }
}
diff --git a/services/core/java/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDb.java b/services/core/java/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDb.java
index 5ca5da4..33249e9 100644
--- a/services/core/java/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDb.java
+++ b/services/core/java/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDb.java
@@ -147,6 +147,19 @@
}
/**
+ * Removes key with {@code alias} for app with {@code uid}.
+ *
+ * @return {@code true} if deleted a row.
+ */
+ public boolean removeKey(int uid, String alias) {
+ SQLiteDatabase db = mKeyStoreDbHelper.getWritableDatabase();
+ String selection = KeysEntry.COLUMN_NAME_UID + " = ? AND " +
+ KeysEntry.COLUMN_NAME_ALIAS + " = ?";
+ String[] selectionArgs = { Integer.toString(uid), alias };
+ return db.delete(KeysEntry.TABLE_NAME, selection, selectionArgs) > 0;
+ }
+
+ /**
* Returns all statuses for keys {@code uid} and {@code platformKeyGenerationId}.
*
* @param uid of the application
diff --git a/services/core/java/com/android/server/net/watchlist/NetworkWatchlistService.java b/services/core/java/com/android/server/net/watchlist/NetworkWatchlistService.java
index f35e6ec..3bcc36f 100644
--- a/services/core/java/com/android/server/net/watchlist/NetworkWatchlistService.java
+++ b/services/core/java/com/android/server/net/watchlist/NetworkWatchlistService.java
@@ -29,6 +29,7 @@
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemProperties;
+import android.provider.Settings;
import android.text.TextUtils;
import android.util.Slog;
@@ -53,9 +54,6 @@
private static final String TAG = NetworkWatchlistService.class.getSimpleName();
static final boolean DEBUG = false;
- private static final String PROPERTY_NETWORK_WATCHLIST_ENABLED =
- "ro.network_watchlist_enabled";
-
private static final int MAX_NUM_OF_WATCHLIST_DIGESTS = 10000;
public static class Lifecycle extends SystemService {
@@ -67,8 +65,10 @@
@Override
public void onStart() {
- if (!SystemProperties.getBoolean(PROPERTY_NETWORK_WATCHLIST_ENABLED, false)) {
+ if (Settings.Global.getInt(getContext().getContentResolver(),
+ Settings.Global.NETWORK_WATCHLIST_ENABLED, 0) == 0) {
// Watchlist service is disabled
+ Slog.i(TAG, "Network Watchlist service is disabled");
return;
}
mService = new NetworkWatchlistService(getContext());
@@ -77,11 +77,13 @@
@Override
public void onBootPhase(int phase) {
- if (!SystemProperties.getBoolean(PROPERTY_NETWORK_WATCHLIST_ENABLED, false)) {
- // Watchlist service is disabled
- return;
- }
if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) {
+ if (Settings.Global.getInt(getContext().getContentResolver(),
+ Settings.Global.NETWORK_WATCHLIST_ENABLED, 0) == 0) {
+ // Watchlist service is disabled
+ Slog.i(TAG, "Network Watchlist service is disabled");
+ return;
+ }
try {
mService.initIpConnectivityMetrics();
mService.startWatchlistLogging();
diff --git a/services/core/java/com/android/server/power/Notifier.java b/services/core/java/com/android/server/power/Notifier.java
index e5a23ea..2a153ec 100644
--- a/services/core/java/com/android/server/power/Notifier.java
+++ b/services/core/java/com/android/server/power/Notifier.java
@@ -209,10 +209,7 @@
try {
if (workSource != null) {
- final int N = workSource.size();
- for (int i=0; i<N; i++) {
- mBatteryStats.noteLongPartialWakelockStart(tag, historyTag, workSource.get(i));
- }
+ mBatteryStats.noteLongPartialWakelockStartFromSource(tag, historyTag, workSource);
} else {
mBatteryStats.noteLongPartialWakelockStart(tag, historyTag, ownerUid);
}
@@ -230,10 +227,7 @@
try {
if (workSource != null) {
- final int N = workSource.size();
- for (int i=0; i<N; i++) {
- mBatteryStats.noteLongPartialWakelockFinish(tag, historyTag, workSource.get(i));
- }
+ mBatteryStats.noteLongPartialWakelockFinishFromSource(tag, historyTag, workSource);
} else {
mBatteryStats.noteLongPartialWakelockFinish(tag, historyTag, ownerUid);
}
diff --git a/services/core/java/com/android/server/storage/DeviceStorageMonitorService.java b/services/core/java/com/android/server/storage/DeviceStorageMonitorService.java
index a35383f..f7cc443 100644
--- a/services/core/java/com/android/server/storage/DeviceStorageMonitorService.java
+++ b/services/core/java/com/android/server/storage/DeviceStorageMonitorService.java
@@ -40,6 +40,7 @@
import android.os.storage.VolumeInfo;
import android.text.format.DateUtils;
import android.util.ArrayMap;
+import android.util.DataUnit;
import android.util.Slog;
import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;
@@ -80,13 +81,13 @@
private static final int MSG_CHECK = 1;
- private static final long DEFAULT_LOG_DELTA_BYTES = 64 * TrafficStats.MB_IN_BYTES;
+ private static final long DEFAULT_LOG_DELTA_BYTES = DataUnit.MEBIBYTES.toBytes(64);
private static final long DEFAULT_CHECK_INTERVAL = DateUtils.MINUTE_IN_MILLIS;
// com.android.internal.R.string.low_internal_storage_view_text_no_boot
// hard codes 250MB in the message as the storage space required for the
// boot image.
- private static final long BOOT_IMAGE_STORAGE_REQUIREMENT = 250 * TrafficStats.MB_IN_BYTES;
+ private static final long BOOT_IMAGE_STORAGE_REQUIREMENT = DataUnit.MEBIBYTES.toBytes(250);
private NotificationManager mNotifManager;
diff --git a/services/core/java/com/android/server/updates/CarrierIdInstallReceiver.java b/services/core/java/com/android/server/updates/CarrierIdInstallReceiver.java
new file mode 100644
index 0000000..116fe7f
--- /dev/null
+++ b/services/core/java/com/android/server/updates/CarrierIdInstallReceiver.java
@@ -0,0 +1,39 @@
+/*
+ * 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.updates;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.provider.Telephony;
+import android.util.Log;
+
+public class CarrierIdInstallReceiver extends ConfigUpdateInstallReceiver {
+
+ public CarrierIdInstallReceiver() {
+ super("/data/misc/carrierid", "carrier_list.pb", "metadata/", "version");
+ }
+
+ @Override
+ protected void postInstall(Context context, Intent intent) {
+ ContentResolver resolver = context.getContentResolver();
+ resolver.update(Uri.withAppendedPath(Telephony.CarrierIdentification.CONTENT_URI,
+ "update_db"), new ContentValues(), null, null);
+ }
+}
diff --git a/services/core/java/com/android/server/wm/AppWindowThumbnail.java b/services/core/java/com/android/server/wm/AppWindowThumbnail.java
index c16a531..0d65790 100644
--- a/services/core/java/com/android/server/wm/AppWindowThumbnail.java
+++ b/services/core/java/com/android/server/wm/AppWindowThumbnail.java
@@ -49,7 +49,8 @@
AppWindowThumbnail(Transaction t, AppWindowToken appToken, GraphicBuffer thumbnailHeader) {
mAppToken = appToken;
- mSurfaceAnimator = new SurfaceAnimator(this, this::onAnimationFinished, appToken.mService);
+ mSurfaceAnimator = new SurfaceAnimator(this, this::onAnimationFinished,
+ appToken.mService.mAnimator::addAfterPrepareSurfacesRunnable, appToken.mService);
mWidth = thumbnailHeader.getWidth();
mHeight = thumbnailHeader.getHeight();
diff --git a/services/core/java/com/android/server/wm/AppWindowToken.java b/services/core/java/com/android/server/wm/AppWindowToken.java
index dcd88dd..01e925e 100644
--- a/services/core/java/com/android/server/wm/AppWindowToken.java
+++ b/services/core/java/com/android/server/wm/AppWindowToken.java
@@ -649,8 +649,7 @@
boolean destroyedSomething = false;
// Copying to a different list as multiple children can be removed.
- // TODO: Not sure why this is needed.
- final LinkedList<WindowState> children = new LinkedList<>(mChildren);
+ final ArrayList<WindowState> children = new ArrayList<>(mChildren);
for (int i = children.size() - 1; i >= 0; i--) {
final WindowState win = children.get(i);
destroyedSomething |= win.destroySurface(cleanupOnResume, mAppStopped);
diff --git a/services/core/java/com/android/server/wm/DisplayContent.java b/services/core/java/com/android/server/wm/DisplayContent.java
index 63dfbc2..7224863 100644
--- a/services/core/java/com/android/server/wm/DisplayContent.java
+++ b/services/core/java/com/android/server/wm/DisplayContent.java
@@ -49,6 +49,7 @@
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING;
import static android.view.WindowManager.LayoutParams.TYPE_BOOT_PROGRESS;
+import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER;
import static android.view.WindowManager.LayoutParams.TYPE_DRAWN_APPLICATION;
import static android.view.WindowManager.LayoutParams.TYPE_DREAM;
import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD;
@@ -187,9 +188,10 @@
new NonAppWindowContainers("mBelowAppWindowsContainers", mService);
// Contains all IME window containers. Note that the z-ordering of the IME windows will depend
// on the IME target. We mainly have this container grouping so we can keep track of all the IME
- // window containers together and move them in-sync if/when needed.
- private final NonAppWindowContainers mImeWindowsContainers =
- new NonAppWindowContainers("mImeWindowsContainers", mService);
+ // window containers together and move them in-sync if/when needed. We use a subclass of
+ // WindowContainer which is omitted from screen magnification, as the IME is never magnified.
+ private final NonMagnifiableWindowContainers mImeWindowsContainers =
+ new NonMagnifiableWindowContainers("mImeWindowsContainers", mService);
private WindowState mTmpWindow;
private WindowState mTmpWindow2;
@@ -3495,37 +3497,47 @@
@Override
void assignChildLayers(SurfaceControl.Transaction t) {
+
+ final int NORMAL_STACK_STATE = 0;
+ final int SPLIT_SCREEN_STACK_STATE = 1;
+ final int ASSISTANT_STACK_STATE = 2;
+ final int BOOSTED_STATE = 3;
+ final int ALWAYS_ON_TOP_STATE = 4;
+
int layer = 0;
-
- // We allow stacks to change visual order from the AM specified order due to
- // Z-boosting during animations. However we must take care to ensure TaskStacks
- // which are marked as alwaysOnTop remain that way.
- for (int i = 0; i < mChildren.size(); i++) {
- final TaskStack s = mChildren.get(i);
- s.assignChildLayers();
- if (!s.needsZBoost() && !s.isAlwaysOnTop()) {
- s.assignLayer(t, layer++);
+ for (int state = 0; state <= ALWAYS_ON_TOP_STATE; state++) {
+ for (int i = 0; i < mChildren.size(); i++) {
+ final TaskStack s = mChildren.get(i);
+ layer++;
+ if (state == NORMAL_STACK_STATE && !s.inSplitScreenPrimaryWindowingMode() &&
+ !s.isActivityTypeAssistant() &&
+ !s.needsZBoost() && !s.isAlwaysOnTop()) {
+ s.assignLayer(t, layer);
+ } else if (state == SPLIT_SCREEN_STACK_STATE &&
+ s.inSplitScreenPrimaryWindowingMode()) {
+ s.assignLayer(t, layer);
+ } else if (state == ASSISTANT_STACK_STATE &&
+ s.isActivityTypeAssistant()) {
+ s.assignLayer(t, layer);
+ } else if (state == BOOSTED_STATE && s.needsZBoost()) {
+ s.assignLayer(t, layer);
+ } else if (state == ALWAYS_ON_TOP_STATE &&
+ s.isAlwaysOnTop()) {
+ s.assignLayer(t, layer);
+ }
+ }
+ // The appropriate place for App-Transitions to occur is right
+ // above all other animations but still below things in the Picture-and-Picture
+ // windowing mode.
+ if (state == BOOSTED_STATE && mAppAnimationLayer != null) {
+ t.setLayer(mAppAnimationLayer, layer++);
}
}
for (int i = 0; i < mChildren.size(); i++) {
final TaskStack s = mChildren.get(i);
- if (s.needsZBoost() && !s.isAlwaysOnTop()) {
- s.assignLayer(t, layer++);
- }
- }
- for (int i = 0; i < mChildren.size(); i++) {
- final TaskStack s = mChildren.get(i);
- if (s.isAlwaysOnTop()) {
- s.assignLayer(t, layer++);
- }
+ s.assignChildLayers(t);
}
- // The appropriate place for App-Transitions to occur is right
- // above all other animations but still below things in the Picture-and-Picture
- // windowing mode.
- if (mAppAnimationLayer != null) {
- t.setLayer(mAppAnimationLayer, layer++);
- }
}
@Override
@@ -3559,6 +3571,18 @@
&& imeContainer.getSurfaceControl() != null;
for (int j = 0; j < mChildren.size(); ++j) {
final WindowToken wt = mChildren.get(j);
+
+ // The divider is unique in that it does not have an AppWindowToken but needs to be
+ // interleaved with them. In particular it must be above any split-screen stacks
+ // but below any always-on-top stacks.
+ if (wt.windowType == TYPE_DOCK_DIVIDER) {
+ final TaskStack dockedStack = getSplitScreenPrimaryStack();
+ if (dockedStack != null) {
+ wt.assignRelativeLayer(t, dockedStack.getSurfaceControl(),
+ Integer.MAX_VALUE);
+ continue;
+ }
+ }
wt.assignLayer(t, j);
wt.assignChildLayers(t);
@@ -3651,6 +3675,16 @@
}
}
+ private class NonMagnifiableWindowContainers extends NonAppWindowContainers {
+ NonMagnifiableWindowContainers(String name, WindowManagerService service) {
+ super(name, service);
+ }
+
+ @Override
+ void applyMagnificationSpec(Transaction t, MagnificationSpec spec) {
+ }
+ };
+
SurfaceControl.Builder makeSurface(SurfaceSession s) {
return mService.makeSurfaceBuilder(s)
.setParent(mWindowingLayer);
diff --git a/services/core/java/com/android/server/wm/SurfaceAnimationRunner.java b/services/core/java/com/android/server/wm/SurfaceAnimationRunner.java
index 3a41eb0..dc62cc8 100644
--- a/services/core/java/com/android/server/wm/SurfaceAnimationRunner.java
+++ b/services/core/java/com/android/server/wm/SurfaceAnimationRunner.java
@@ -67,6 +67,9 @@
@VisibleForTesting
final ArrayMap<SurfaceControl, RunningAnimation> mRunningAnimations = new ArrayMap<>();
+ @GuardedBy("mLock")
+ private boolean mAnimationStartDeferred;
+
SurfaceAnimationRunner() {
this(null /* callbackProvider */, null /* animatorFactory */, new Transaction());
}
@@ -86,13 +89,41 @@
: SfValueAnimator::new;
}
+ /**
+ * Defers starting of animations until {@link #continueStartingAnimations} is called. This
+ * method is NOT nestable.
+ *
+ * @see #continueStartingAnimations
+ */
+ void deferStartingAnimations() {
+ synchronized (mLock) {
+ mAnimationStartDeferred = true;
+ }
+ }
+
+ /**
+ * Continues starting of animations.
+ *
+ * @see #deferStartingAnimations
+ */
+ void continueStartingAnimations() {
+ synchronized (mLock) {
+ mAnimationStartDeferred = false;
+ if (!mPendingAnimations.isEmpty()) {
+ mChoreographer.postFrameCallback(this::startAnimations);
+ }
+ }
+ }
+
void startAnimation(AnimationSpec a, SurfaceControl animationLeash, Transaction t,
Runnable finishCallback) {
synchronized (mLock) {
final RunningAnimation runningAnim = new RunningAnimation(a, animationLeash,
finishCallback);
mPendingAnimations.put(animationLeash, runningAnim);
- mChoreographer.postFrameCallback(this::stepAnimation);
+ if (!mAnimationStartDeferred) {
+ mChoreographer.postFrameCallback(this::startAnimations);
+ }
// Some animations (e.g. move animations) require the initial transform to be applied
// immediately.
@@ -185,7 +216,7 @@
a.mAnimSpec.apply(t, a.mLeash, currentPlayTime);
}
- private void stepAnimation(long frameTimeNanos) {
+ private void startAnimations(long frameTimeNanos) {
synchronized (mLock) {
startPendingAnimationsLocked();
}
diff --git a/services/core/java/com/android/server/wm/SurfaceAnimator.java b/services/core/java/com/android/server/wm/SurfaceAnimator.java
index a32e711..e67cdba 100644
--- a/services/core/java/com/android/server/wm/SurfaceAnimator.java
+++ b/services/core/java/com/android/server/wm/SurfaceAnimator.java
@@ -30,6 +30,7 @@
import com.android.internal.annotations.VisibleForTesting;
import java.io.PrintWriter;
+import java.util.function.Consumer;
/**
* A class that can run animations on objects that have a set of child surfaces. We do this by
@@ -55,16 +56,20 @@
/**
* @param animatable The object to animate.
* @param animationFinishedCallback Callback to invoke when an animation has finished running.
+ * @param addAfterPrepareSurfaces Consumer that takes a runnable and executes it after preparing
+ * surfaces in WM. Can be implemented differently during testing.
*/
SurfaceAnimator(Animatable animatable, Runnable animationFinishedCallback,
- WindowManagerService service) {
+ Consumer<Runnable> addAfterPrepareSurfaces, WindowManagerService service) {
mAnimatable = animatable;
mService = service;
mAnimationFinishedCallback = animationFinishedCallback;
- mInnerAnimationFinishedCallback = getFinishedCallback(animationFinishedCallback);
+ mInnerAnimationFinishedCallback = getFinishedCallback(animationFinishedCallback,
+ addAfterPrepareSurfaces);
}
- private OnAnimationFinishedCallback getFinishedCallback(Runnable animationFinishedCallback) {
+ private OnAnimationFinishedCallback getFinishedCallback(Runnable animationFinishedCallback,
+ Consumer<Runnable> addAfterPrepareSurfaces) {
return anim -> {
synchronized (mService.mWindowMap) {
final SurfaceAnimator target = mService.mAnimationTransferMap.remove(anim);
@@ -80,7 +85,7 @@
// reparents the surface onto the leash is executed already. Otherwise this may be
// executed first, leading to surface loss, as the reparent operations wouldn't
// be in order.
- mService.mAnimator.addAfterPrepareSurfacesRunnable(() -> {
+ addAfterPrepareSurfaces.accept(() -> {
if (anim != mAnimation) {
// Callback was from another animation - ignore.
return;
diff --git a/services/core/java/com/android/server/wm/TaskStack.java b/services/core/java/com/android/server/wm/TaskStack.java
index eb8eae1..bdda944 100644
--- a/services/core/java/com/android/server/wm/TaskStack.java
+++ b/services/core/java/com/android/server/wm/TaskStack.java
@@ -44,7 +44,6 @@
import android.annotation.CallSuper;
import android.content.res.Configuration;
-import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.Region;
import android.os.RemoteException;
@@ -146,7 +145,6 @@
* For {@link #prepareSurfaces}.
*/
final Rect mTmpDimBoundsRect = new Rect();
- private final Point mLastSurfaceSize = new Point();
TaskStack(WindowManagerService service, int stackId, StackWindowController controller) {
super(service);
@@ -716,10 +714,11 @@
@Override
public void onConfigurationChanged(Configuration newParentConfig) {
final int prevWindowingMode = getWindowingMode();
+ super.onConfigurationChanged(newParentConfig);
+
// Only need to update surface size here since the super method will handle updating
// surface position.
updateSurfaceSize(getPendingTransaction());
- super.onConfigurationChanged(newParentConfig);
final int windowingMode = getWindowingMode();
if (mDisplayContent == null || prevWindowingMode == windowingMode) {
@@ -745,13 +744,7 @@
}
final Rect stackBounds = getBounds();
- final int width = stackBounds.width();
- final int height = stackBounds.height();
- if (width == mLastSurfaceSize.x && height == mLastSurfaceSize.y) {
- return;
- }
- transaction.setSize(mSurfaceControl, width, height);
- mLastSurfaceSize.set(width, height);
+ transaction.setSize(mSurfaceControl, stackBounds.width(), stackBounds.height());
}
@Override
diff --git a/services/core/java/com/android/server/wm/WindowAnimationSpec.java b/services/core/java/com/android/server/wm/WindowAnimationSpec.java
index 031b57b..0863ee9 100644
--- a/services/core/java/com/android/server/wm/WindowAnimationSpec.java
+++ b/services/core/java/com/android/server/wm/WindowAnimationSpec.java
@@ -89,7 +89,10 @@
if (mStackClipMode == STACK_CLIP_NONE) {
t.setWindowCrop(leash, tmp.transformation.getClipRect());
} else if (mStackClipMode == STACK_CLIP_AFTER_ANIM) {
- t.setFinalCrop(leash, mStackBounds);
+ mTmpRect.set(mStackBounds);
+ // Offset stack bounds to stack position so the final crop is in screen space.
+ mTmpRect.offsetTo(mPosition.x, mPosition.y);
+ t.setFinalCrop(leash, mTmpRect);
t.setWindowCrop(leash, tmp.transformation.getClipRect());
} else {
mTmpRect.set(mStackBounds);
diff --git a/services/core/java/com/android/server/wm/WindowAnimator.java b/services/core/java/com/android/server/wm/WindowAnimator.java
index 7295873..3efd6ac 100644
--- a/services/core/java/com/android/server/wm/WindowAnimator.java
+++ b/services/core/java/com/android/server/wm/WindowAnimator.java
@@ -47,7 +47,6 @@
final WindowManagerService mService;
final Context mContext;
final WindowManagerPolicy mPolicy;
- private final WindowSurfacePlacer mWindowPlacerLocked;
/** Is any window animating? */
private boolean mAnimating;
@@ -74,7 +73,7 @@
SparseArray<DisplayContentsAnimator> mDisplayContentsAnimators = new SparseArray<>(2);
- boolean mInitialized = false;
+ private boolean mInitialized = false;
// When set to true the animator will go over all windows after an animation frame is posted and
// check if some got replaced and can be removed.
@@ -98,7 +97,6 @@
mService = service;
mContext = service.mContext;
mPolicy = service.mPolicy;
- mWindowPlacerLocked = service.mWindowPlacerLocked;
AnimationThread.getHandler().runWithScissors(
() -> mChoreographer = Choreographer.getSfInstance(), 0 /* timeout */);
@@ -241,7 +239,7 @@
}
if (hasPendingLayoutChanges || doRequest) {
- mWindowPlacerLocked.requestTraversal();
+ mService.mWindowPlacerLocked.requestTraversal();
}
final boolean rootAnimating = mService.mRoot.isSelfOrChildAnimating();
@@ -254,7 +252,7 @@
Trace.asyncTraceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "animating", 0);
}
if (!rootAnimating && mLastRootAnimating) {
- mWindowPlacerLocked.requestTraversal();
+ mService.mWindowPlacerLocked.requestTraversal();
mService.mTaskSnapshotController.setPersisterPaused(false);
Trace.asyncTraceEnd(Trace.TRACE_TAG_WINDOW_MANAGER, "animating", 0);
}
diff --git a/services/core/java/com/android/server/wm/WindowContainer.java b/services/core/java/com/android/server/wm/WindowContainer.java
index af31410..5548f3d 100644
--- a/services/core/java/com/android/server/wm/WindowContainer.java
+++ b/services/core/java/com/android/server/wm/WindowContainer.java
@@ -95,7 +95,6 @@
protected final WindowManagerService mService;
private final Point mTmpPos = new Point();
- protected final Point mLastSurfacePosition = new Point();
/** Total number of elements in this subtree, including our own hierarchy element. */
private int mTreeWeight = 1;
@@ -103,7 +102,8 @@
WindowContainer(WindowManagerService service) {
mService = service;
mPendingTransaction = service.mTransactionFactory.make();
- mSurfaceAnimator = new SurfaceAnimator(this, this::onAnimationFinished, service);
+ mSurfaceAnimator = new SurfaceAnimator(this, this::onAnimationFinished,
+ service.mAnimator::addAfterPrepareSurfacesRunnable, service);
}
@Override
@@ -1178,12 +1178,7 @@
}
getRelativePosition(mTmpPos);
- if (mTmpPos.equals(mLastSurfacePosition)) {
- return;
- }
-
transaction.setPosition(mSurfaceControl, mTmpPos.x, mTmpPos.y);
- mLastSurfacePosition.set(mTmpPos.x, mTmpPos.y);
for (int i = mChildren.size() - 1; i >= 0; i--) {
mChildren.get(i).updateSurfacePosition(transaction);
diff --git a/services/core/java/com/android/server/wm/WindowManagerService.java b/services/core/java/com/android/server/wm/WindowManagerService.java
index 0a2ffbc..e91b16d 100644
--- a/services/core/java/com/android/server/wm/WindowManagerService.java
+++ b/services/core/java/com/android/server/wm/WindowManagerService.java
@@ -928,7 +928,6 @@
boolean haveInputMethods, boolean showBootMsgs, boolean onlyCore,
WindowManagerPolicy policy) {
installLock(this, INDEX_WINDOW);
- mRoot = new RootWindowContainer(this);
mContext = context;
mHaveInputMethods = haveInputMethods;
mAllowBootMessages = showBootMsgs;
@@ -952,8 +951,11 @@
mDisplaySettings = new DisplaySettings();
mDisplaySettings.readSettingsLocked();
- mWindowPlacerLocked = new WindowSurfacePlacer(this);
mPolicy = policy;
+ mAnimator = new WindowAnimator(this);
+ mRoot = new RootWindowContainer(this);
+
+ mWindowPlacerLocked = new WindowSurfacePlacer(this);
mTaskSnapshotController = new TaskSnapshotController(this);
mWindowTracing = WindowTracing.createDefaultAndStartLooper(context);
@@ -1051,7 +1053,6 @@
PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE, TAG_WM);
mHoldingScreenWakeLock.setReferenceCounted(false);
- mAnimator = new WindowAnimator(this);
mSurfaceAnimationRunner = new SurfaceAnimationRunner();
mAllowTheaterModeWakeFromLayout = context.getResources().getBoolean(
diff --git a/services/core/java/com/android/server/wm/WindowState.java b/services/core/java/com/android/server/wm/WindowState.java
index fcbc802..b3809dd 100644
--- a/services/core/java/com/android/server/wm/WindowState.java
+++ b/services/core/java/com/android/server/wm/WindowState.java
@@ -1543,10 +1543,13 @@
@Override
public boolean canAffectSystemUiFlags() {
final boolean translucent = mAttrs.alpha == 0.0f;
+ if (translucent) {
+ return false;
+ }
if (mAppToken == null) {
final boolean shown = mWinAnimator.getShown();
final boolean exiting = mAnimatingExit || mDestroying;
- return shown && !exiting && !translucent;
+ return shown && !exiting;
} else {
return !mAppToken.isHidden();
}
@@ -2664,8 +2667,11 @@
boolean destroySurface(boolean cleanupOnResume, boolean appStopped) {
boolean destroyedSomething = false;
- for (int i = mChildren.size() - 1; i >= 0; --i) {
- final WindowState c = mChildren.get(i);
+
+ // Copying to a different list as multiple children can be removed.
+ final ArrayList<WindowState> childWindows = new ArrayList<>(mChildren);
+ for (int i = childWindows.size() - 1; i >= 0; --i) {
+ final WindowState c = childWindows.get(i);
destroyedSomething |= c.destroySurface(cleanupOnResume, appStopped);
}
@@ -3923,8 +3929,7 @@
if (!mChildren.isEmpty()) {
// Copying to a different list as multiple children can be removed.
- // TODO: Not sure if we really need to copy this into a different list.
- final LinkedList<WindowState> childWindows = new LinkedList(mChildren);
+ final ArrayList<WindowState> childWindows = new ArrayList<>(mChildren);
for (int i = childWindows.size() - 1; i >= 0; i--) {
childWindows.get(i).onExitAnimationDone();
}
@@ -4482,7 +4487,6 @@
// Leash is now responsible for position, so set our position to 0.
t.setPosition(mSurfaceControl, 0, 0);
- mLastSurfacePosition.set(0, 0);
}
@Override
@@ -4498,9 +4502,8 @@
}
transformFrameToSurfacePosition(mFrame.left, mFrame.top, mSurfacePosition);
- if (!mSurfaceAnimator.hasLeash() && !mLastSurfacePosition.equals(mSurfacePosition)) {
+ if (!mSurfaceAnimator.hasLeash()) {
t.setPosition(mSurfaceControl, mSurfacePosition.x, mSurfacePosition.y);
- mLastSurfacePosition.set(mSurfacePosition.x, mSurfacePosition.y);
}
}
@@ -4578,7 +4581,8 @@
private MoveAnimationSpec(int fromX, int fromY, int toX, int toY) {
final Animation anim = AnimationUtils.loadAnimation(mContext,
com.android.internal.R.anim.window_move_from_decor);
- mDuration = anim.computeDurationHint();
+ mDuration = (long)
+ (anim.computeDurationHint() * mService.getWindowAnimationScaleLocked());
mInterpolator = anim.getInterpolator();
mFrom.set(fromX, fromY);
mTo.set(toX, toY);
diff --git a/services/core/java/com/android/server/wm/WindowSurfacePlacer.java b/services/core/java/com/android/server/wm/WindowSurfacePlacer.java
index bdab9c7..08f49f6 100644
--- a/services/core/java/com/android/server/wm/WindowSurfacePlacer.java
+++ b/services/core/java/com/android/server/wm/WindowSurfacePlacer.java
@@ -349,21 +349,28 @@
animLp = null;
}
- processApplicationsAnimatingInPlace(transit);
+ final int layoutRedo;
+ mService.mSurfaceAnimationRunner.deferStartingAnimations();
+ try {
+ processApplicationsAnimatingInPlace(transit);
- mTmpLayerAndToken.token = null;
- handleClosingApps(transit, animLp, voiceInteraction, mTmpLayerAndToken);
- final AppWindowToken topClosingApp = mTmpLayerAndToken.token;
- final AppWindowToken topOpeningApp = handleOpeningApps(transit, animLp, voiceInteraction);
+ mTmpLayerAndToken.token = null;
+ handleClosingApps(transit, animLp, voiceInteraction, mTmpLayerAndToken);
+ final AppWindowToken topClosingApp = mTmpLayerAndToken.token;
+ final AppWindowToken topOpeningApp = handleOpeningApps(transit, animLp,
+ voiceInteraction);
- mService.mAppTransition.setLastAppTransition(transit, topOpeningApp, topClosingApp);
+ mService.mAppTransition.setLastAppTransition(transit, topOpeningApp, topClosingApp);
- final int flags = mService.mAppTransition.getTransitFlags();
- int layoutRedo = mService.mAppTransition.goodToGo(transit, topOpeningApp,
- topClosingApp, mService.mOpeningApps, mService.mClosingApps);
- handleNonAppWindowsInTransition(transit, flags);
- mService.mAppTransition.postAnimationCallback();
- mService.mAppTransition.clear();
+ final int flags = mService.mAppTransition.getTransitFlags();
+ layoutRedo = mService.mAppTransition.goodToGo(transit, topOpeningApp,
+ topClosingApp, mService.mOpeningApps, mService.mClosingApps);
+ handleNonAppWindowsInTransition(transit, flags);
+ mService.mAppTransition.postAnimationCallback();
+ mService.mAppTransition.clear();
+ } finally {
+ mService.mSurfaceAnimationRunner.continueStartingAnimations();
+ }
mService.mTaskSnapshotController.onTransitionStarting();
diff --git a/services/robotests/src/com/android/server/backup/BackupManagerConstantsTest.java b/services/robotests/src/com/android/server/backup/BackupManagerConstantsTest.java
index a473bc6..c397f23 100644
--- a/services/robotests/src/com/android/server/backup/BackupManagerConstantsTest.java
+++ b/services/robotests/src/com/android/server/backup/BackupManagerConstantsTest.java
@@ -57,7 +57,6 @@
final BackupManagerConstants constants =
new BackupManagerConstants(handler, context.getContentResolver());
- constants.start();
assertThat(constants.getKeyValueBackupIntervalMilliseconds())
.isEqualTo(4 * AlarmManager.INTERVAL_HOUR);
@@ -89,7 +88,6 @@
final BackupManagerConstants constants =
new BackupManagerConstants(handler, context.getContentResolver());
- constants.start();
assertThat(constants.getBackupFinishedNotificationReceivers())
.isEqualTo(new String[] {PACKAGE_NAME, ANOTHER_PACKAGE_NAME});
diff --git a/services/robotests/src/com/android/server/backup/BackupManagerServiceRoboTest.java b/services/robotests/src/com/android/server/backup/BackupManagerServiceRoboTest.java
new file mode 100644
index 0000000..d9e8f0f
--- /dev/null
+++ b/services/robotests/src/com/android/server/backup/BackupManagerServiceRoboTest.java
@@ -0,0 +1,215 @@
+/*
+ * 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.server.backup;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.testng.Assert.expectThrows;
+
+import android.content.ContextWrapper;
+import android.os.HandlerThread;
+import android.platform.test.annotations.Presubmit;
+
+import com.android.server.backup.testing.ShadowAppBackupUtils;
+import com.android.server.backup.testing.TransportTestUtils;
+import com.android.server.backup.testing.TransportTestUtils.TransportData;
+import com.android.server.backup.transport.TransportNotRegisteredException;
+import com.android.server.testing.FrameworkRobolectricTestRunner;
+import com.android.server.testing.SystemLoaderClasses;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowContextWrapper;
+import org.robolectric.shadows.ShadowLog;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith(FrameworkRobolectricTestRunner.class)
+@Config(
+ manifest = Config.NONE,
+ sdk = 26,
+ shadows = {ShadowAppBackupUtils.class}
+)
+@SystemLoaderClasses({RefactoredBackupManagerService.class, TransportManager.class})
+@Presubmit
+public class BackupManagerServiceRoboTest {
+ private static final String TAG = "BMSTest";
+ private static final String TRANSPORT_NAME =
+ "com.google.android.gms/.backup.BackupTransportService";
+
+ @Mock private TransportManager mTransportManager;
+ private HandlerThread mBackupThread;
+ private File mBaseStateDir;
+ private File mDataDir;
+ private RefactoredBackupManagerService mBackupManagerService;
+ private ShadowContextWrapper mShadowContext;
+
+ @Before
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+
+ mBackupThread = new HandlerThread("backup-test");
+ mBackupThread.setUncaughtExceptionHandler(
+ (t, e) -> ShadowLog.e(TAG, "Uncaught exception in test thread " + t.getName(), e));
+ mBackupThread.start();
+
+ ContextWrapper context = RuntimeEnvironment.application;
+ mShadowContext = Shadows.shadowOf(context);
+
+ File cacheDir = context.getCacheDir();
+ mBaseStateDir = new File(cacheDir, "base_state_dir");
+ mDataDir = new File(cacheDir, "data_dir");
+
+ mBackupManagerService =
+ new RefactoredBackupManagerService(
+ context,
+ new Trampoline(context),
+ mBackupThread,
+ mBaseStateDir,
+ mDataDir,
+ mTransportManager);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ mBackupThread.quit();
+ ShadowAppBackupUtils.reset();
+ }
+
+ @Test
+ public void testDestinationString() throws Exception {
+ mShadowContext.grantPermissions(android.Manifest.permission.BACKUP);
+ when(mTransportManager.getTransportCurrentDestinationString(eq(TRANSPORT_NAME)))
+ .thenReturn("destinationString");
+
+ String destination = mBackupManagerService.getDestinationString(TRANSPORT_NAME);
+
+ assertThat(destination).isEqualTo("destinationString");
+ }
+
+ @Test
+ public void testDestinationString_whenTransportNotRegistered() throws Exception {
+ mShadowContext.grantPermissions(android.Manifest.permission.BACKUP);
+ when(mTransportManager.getTransportCurrentDestinationString(eq(TRANSPORT_NAME)))
+ .thenThrow(TransportNotRegisteredException.class);
+
+ String destination = mBackupManagerService.getDestinationString(TRANSPORT_NAME);
+
+ assertThat(destination).isNull();
+ }
+
+ @Test
+ public void testDestinationString_withoutPermission() throws Exception {
+ mShadowContext.denyPermissions(android.Manifest.permission.BACKUP);
+ when(mTransportManager.getTransportCurrentDestinationString(eq(TRANSPORT_NAME)))
+ .thenThrow(TransportNotRegisteredException.class);
+
+ expectThrows(
+ SecurityException.class,
+ () -> mBackupManagerService.getDestinationString(TRANSPORT_NAME));
+ }
+
+ @Test
+ public void testIsAppEligibleForBackup_whenAppEligible() throws Exception {
+ mShadowContext.grantPermissions(android.Manifest.permission.BACKUP);
+ TransportData transport =
+ TransportTestUtils.setUpCurrentTransport(mTransportManager, TRANSPORT_NAME);
+ ShadowAppBackupUtils.sAppIsRunningAndEligibleForBackupWithTransport = p -> true;
+
+ boolean result = mBackupManagerService.isAppEligibleForBackup("app.package");
+
+ assertThat(result).isTrue();
+ verify(mTransportManager)
+ .disposeOfTransportClient(eq(transport.transportClientMock), any());
+ }
+
+ @Test
+ public void testIsAppEligibleForBackup_whenAppNotEligible() throws Exception {
+ mShadowContext.grantPermissions(android.Manifest.permission.BACKUP);
+ TransportTestUtils.setUpCurrentTransport(mTransportManager, TRANSPORT_NAME);
+ ShadowAppBackupUtils.sAppIsRunningAndEligibleForBackupWithTransport = p -> false;
+
+ boolean result = mBackupManagerService.isAppEligibleForBackup("app.package");
+
+ assertThat(result).isFalse();
+ }
+
+ @Test
+ public void testIsAppEligibleForBackup_withoutPermission() throws Exception {
+ mShadowContext.denyPermissions(android.Manifest.permission.BACKUP);
+ TransportTestUtils.setUpCurrentTransport(mTransportManager, TRANSPORT_NAME);
+
+ expectThrows(
+ SecurityException.class,
+ () -> mBackupManagerService.isAppEligibleForBackup("app.package"));
+ }
+
+ @Test
+ public void testFilterAppsEligibleForBackup() throws Exception {
+ mShadowContext.grantPermissions(android.Manifest.permission.BACKUP);
+ TransportData transport =
+ TransportTestUtils.setUpCurrentTransport(mTransportManager, TRANSPORT_NAME);
+ Map<String, Boolean> packagesMap = new HashMap<>();
+ packagesMap.put("package.a", true);
+ packagesMap.put("package.b", false);
+ ShadowAppBackupUtils.sAppIsRunningAndEligibleForBackupWithTransport = packagesMap::get;
+ String[] packages = packagesMap.keySet().toArray(new String[packagesMap.size()]);
+
+ String[] filtered = mBackupManagerService.filterAppsEligibleForBackup(packages);
+
+ assertThat(filtered).asList().containsExactly("package.a");
+ verify(mTransportManager)
+ .disposeOfTransportClient(eq(transport.transportClientMock), any());
+ }
+
+ @Test
+ public void testFilterAppsEligibleForBackup_whenNoneIsEligible() throws Exception {
+ mShadowContext.grantPermissions(android.Manifest.permission.BACKUP);
+ ShadowAppBackupUtils.sAppIsRunningAndEligibleForBackupWithTransport = p -> false;
+
+ String[] filtered =
+ mBackupManagerService.filterAppsEligibleForBackup(
+ new String[] {"package.a", "package.b"});
+
+ assertThat(filtered).isEmpty();
+ }
+
+ @Test
+ public void testFilterAppsEligibleForBackup_withoutPermission() throws Exception {
+ mShadowContext.denyPermissions(android.Manifest.permission.BACKUP);
+ TransportTestUtils.setUpCurrentTransport(mTransportManager, TRANSPORT_NAME);
+
+ expectThrows(
+ SecurityException.class,
+ () ->
+ mBackupManagerService.filterAppsEligibleForBackup(
+ new String[] {"package.a", "package.b"}));
+ }
+}
diff --git a/services/robotests/src/com/android/server/backup/internal/PerformInitializeTaskTest.java b/services/robotests/src/com/android/server/backup/internal/PerformInitializeTaskTest.java
index 73f1c2f..dfca901 100644
--- a/services/robotests/src/com/android/server/backup/internal/PerformInitializeTaskTest.java
+++ b/services/robotests/src/com/android/server/backup/internal/PerformInitializeTaskTest.java
@@ -19,6 +19,9 @@
import static android.app.backup.BackupTransport.TRANSPORT_ERROR;
import static android.app.backup.BackupTransport.TRANSPORT_OK;
+import static com.android.server.backup.testing.TransportTestUtils.TRANSPORT_NAME;
+import static com.android.server.backup.testing.TransportTestUtils.TRANSPORT_NAMES;
+
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
@@ -30,7 +33,6 @@
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import android.annotation.Nullable;
import android.app.AlarmManager;
import android.app.Application;
import android.app.PendingIntent;
@@ -41,8 +43,9 @@
import com.android.internal.backup.IBackupTransport;
import com.android.server.backup.RefactoredBackupManagerService;
import com.android.server.backup.TransportManager;
+import com.android.server.backup.testing.TransportTestUtils;
+import com.android.server.backup.testing.TransportTestUtils.TransportData;
import com.android.server.backup.transport.TransportClient;
-import com.android.server.backup.transport.TransportNotAvailableException;
import com.android.server.testing.FrameworkRobolectricTestRunner;
import com.android.server.testing.SystemLoaderClasses;
@@ -55,7 +58,6 @@
import org.robolectric.annotation.Config;
import java.io.File;
-import java.util.Arrays;
import java.util.List;
@RunWith(FrameworkRobolectricTestRunner.class)
@@ -63,14 +65,6 @@
@SystemLoaderClasses({PerformInitializeTaskTest.class, TransportManager.class})
@Presubmit
public class PerformInitializeTaskTest {
- private static final String[] TRANSPORT_NAMES = {
- "android/com.android.internal.backup.LocalTransport",
- "com.google.android.gms/.backup.migrate.service.D2dTransport",
- "com.google.android.gms/.backup.BackupTransportService"
- };
-
- private static final String TRANSPORT_NAME = TRANSPORT_NAMES[0];
-
@Mock private RefactoredBackupManagerService mBackupManagerService;
@Mock private TransportManager mTransportManager;
@Mock private OnTaskFinishedListener mListener;
@@ -113,9 +107,14 @@
performInitializeTask.run();
verify(mBackupManagerService)
- .recordInitPending(false, TRANSPORT_NAME, dirName(TRANSPORT_NAME));
+ .recordInitPending(
+ false, TRANSPORT_NAME, TransportTestUtils.transportDirName(TRANSPORT_NAME));
verify(mBackupManagerService)
- .resetBackupState(eq(new File(mBaseStateDir, dirName(TRANSPORT_NAME))));
+ .resetBackupState(
+ eq(
+ new File(
+ mBaseStateDir,
+ TransportTestUtils.transportDirName(TRANSPORT_NAME))));
}
@Test
@@ -142,7 +141,8 @@
verify(mTransport).initializeDevice();
verify(mTransport, never()).finishBackup();
verify(mBackupManagerService)
- .recordInitPending(true, TRANSPORT_NAME, dirName(TRANSPORT_NAME));
+ .recordInitPending(
+ true, TRANSPORT_NAME, TransportTestUtils.transportDirName(TRANSPORT_NAME));
}
@Test
@@ -181,7 +181,8 @@
verify(mTransport).initializeDevice();
verify(mTransport).finishBackup();
verify(mBackupManagerService)
- .recordInitPending(true, TRANSPORT_NAME, dirName(TRANSPORT_NAME));
+ .recordInitPending(
+ true, TRANSPORT_NAME, TransportTestUtils.transportDirName(TRANSPORT_NAME));
}
@Test
@@ -210,7 +211,9 @@
@Test
public void testRun_whenOnlyOneTransportFails() throws Exception {
- List<TransportData> transports = setUpTransports(TRANSPORT_NAMES[0], TRANSPORT_NAMES[1]);
+ List<TransportData> transports =
+ TransportTestUtils.setUpTransports(
+ mTransportManager, TRANSPORT_NAMES[0], TRANSPORT_NAMES[1]);
configureTransport(transports.get(0).transportMock, TRANSPORT_ERROR, 0);
configureTransport(transports.get(1).transportMock, TRANSPORT_OK, TRANSPORT_OK);
PerformInitializeTask performInitializeTask =
@@ -226,7 +229,8 @@
@Test
public void testRun_withMultipleTransports() throws Exception {
- List<TransportData> transports = setUpTransports(TRANSPORT_NAMES);
+ List<TransportData> transports =
+ TransportTestUtils.setUpTransports(mTransportManager, TRANSPORT_NAMES);
configureTransport(transports.get(0).transportMock, TRANSPORT_OK, TRANSPORT_OK);
configureTransport(transports.get(1).transportMock, TRANSPORT_OK, TRANSPORT_OK);
configureTransport(transports.get(2).transportMock, TRANSPORT_OK, TRANSPORT_OK);
@@ -243,7 +247,9 @@
@Test
public void testRun_whenOnlyOneTransportFails_disposesAllTransports() throws Exception {
- List<TransportData> transports = setUpTransports(TRANSPORT_NAMES[0], TRANSPORT_NAMES[1]);
+ List<TransportData> transports =
+ TransportTestUtils.setUpTransports(
+ mTransportManager, TRANSPORT_NAMES[0], TRANSPORT_NAMES[1]);
configureTransport(transports.get(0).transportMock, TRANSPORT_ERROR, 0);
configureTransport(transports.get(1).transportMock, TRANSPORT_OK, TRANSPORT_OK);
PerformInitializeTask performInitializeTask =
@@ -259,7 +265,9 @@
@Test
public void testRun_whenTransportNotRegistered() throws Exception {
- setUpTransport(new TransportData(TRANSPORT_NAME, null, null));
+ TransportTestUtils.setUpTransports(
+ mTransportManager, new TransportData(TRANSPORT_NAME, null, null));
+
PerformInitializeTask performInitializeTask = createPerformInitializeTask(TRANSPORT_NAME);
performInitializeTask.run();
@@ -272,7 +280,8 @@
@Test
public void testRun_whenOnlyOneTransportNotRegistered() throws Exception {
List<TransportData> transports =
- setUpTransports(
+ TransportTestUtils.setUpTransports(
+ mTransportManager,
new TransportData(TRANSPORT_NAMES[0], null, null),
new TransportData(TRANSPORT_NAMES[1]));
String registeredTransportName = transports.get(1).transportName;
@@ -291,7 +300,8 @@
@Test
public void testRun_whenTransportNotAvailable() throws Exception {
TransportClient transportClient = mock(TransportClient.class);
- setUpTransport(new TransportData(TRANSPORT_NAME, null, transportClient));
+ TransportTestUtils.setUpTransports(
+ mTransportManager, new TransportData(TRANSPORT_NAME, null, transportClient));
PerformInitializeTask performInitializeTask = createPerformInitializeTask(TRANSPORT_NAME);
performInitializeTask.run();
@@ -304,7 +314,8 @@
@Test
public void testRun_whenTransportThrowsDeadObjectException() throws Exception {
TransportClient transportClient = mock(TransportClient.class);
- setUpTransport(new TransportData(TRANSPORT_NAME, mTransport, transportClient));
+ TransportTestUtils.setUpTransports(
+ mTransportManager, new TransportData(TRANSPORT_NAME, mTransport, transportClient));
when(mTransport.initializeDevice()).thenThrow(DeadObjectException.class);
PerformInitializeTask performInitializeTask = createPerformInitializeTask(TRANSPORT_NAME);
@@ -332,80 +343,9 @@
when(transportMock.finishBackup()).thenReturn(finishBackupStatus);
}
- private List<TransportData> setUpTransports(String... transportNames) throws Exception {
- return setUpTransports(
- Arrays.stream(transportNames)
- .map(TransportData::new)
- .toArray(TransportData[]::new));
- }
-
- /** @see #setUpTransport(TransportData) */
- private List<TransportData> setUpTransports(TransportData... transports) throws Exception {
- for (TransportData transport : transports) {
- setUpTransport(transport);
- }
- return Arrays.asList(transports);
- }
-
private void setUpTransport(String transportName) throws Exception {
- setUpTransport(new TransportData(transportName, mTransport, mock(TransportClient.class)));
- }
-
- /**
- * Configures transport according to {@link TransportData}:
- *
- * <ul>
- * <li>{@link TransportData#transportMock} {@code null} means {@link
- * TransportClient#connectOrThrow(String)} throws {@link TransportNotAvailableException}.
- * <li>{@link TransportData#transportClientMock} {@code null} means {@link
- * TransportManager#getTransportClient(String, String)} returns {@code null}.
- * </ul>
- */
- private void setUpTransport(TransportData transport) throws Exception {
- String transportName = transport.transportName;
- String transportDirName = dirName(transportName);
- IBackupTransport transportMock = transport.transportMock;
- TransportClient transportClientMock = transport.transportClientMock;
-
- if (transportMock != null) {
- when(transportMock.name()).thenReturn(transportName);
- when(transportMock.transportDirName()).thenReturn(transportDirName);
- }
-
- if (transportClientMock != null) {
- when(transportClientMock.getTransportDirName()).thenReturn(transportDirName);
- if (transportMock != null) {
- when(transportClientMock.connectOrThrow(any())).thenReturn(transportMock);
- } else {
- when(transportClientMock.connectOrThrow(any()))
- .thenThrow(TransportNotAvailableException.class);
- }
- }
-
- when(mTransportManager.getTransportClient(eq(transportName), any()))
- .thenReturn(transportClientMock);
- }
-
- private String dirName(String transportName) {
- return transportName + "_dir_name";
- }
-
- private static class TransportData {
- private final String transportName;
- @Nullable private final IBackupTransport transportMock;
- @Nullable private final TransportClient transportClientMock;
-
- private TransportData(
- String transportName,
- @Nullable IBackupTransport transportMock,
- @Nullable TransportClient transportClientMock) {
- this.transportName = transportName;
- this.transportMock = transportMock;
- this.transportClientMock = transportClientMock;
- }
-
- private TransportData(String transportName) {
- this(transportName, mock(IBackupTransport.class), mock(TransportClient.class));
- }
+ TransportTestUtils.setUpTransport(
+ mTransportManager,
+ new TransportData(transportName, mTransport, mock(TransportClient.class)));
}
}
diff --git a/services/robotests/src/com/android/server/backup/testing/ShadowAppBackupUtils.java b/services/robotests/src/com/android/server/backup/testing/ShadowAppBackupUtils.java
new file mode 100644
index 0000000..73cb4c0
--- /dev/null
+++ b/services/robotests/src/com/android/server/backup/testing/ShadowAppBackupUtils.java
@@ -0,0 +1,46 @@
+/*
+ * 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.server.backup.testing;
+
+import android.annotation.Nullable;
+import android.content.pm.PackageManager;
+
+import com.android.server.backup.transport.TransportClient;
+import com.android.server.backup.utils.AppBackupUtils;
+
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+import java.util.function.Function;
+
+@Implements(AppBackupUtils.class)
+public class ShadowAppBackupUtils {
+ public static Function<String, Boolean> sAppIsRunningAndEligibleForBackupWithTransport;
+ static {
+ reset();
+ }
+
+ @Implementation
+ public static boolean appIsRunningAndEligibleForBackupWithTransport(
+ @Nullable TransportClient transportClient, String packageName, PackageManager pm) {
+ return sAppIsRunningAndEligibleForBackupWithTransport.apply(packageName);
+ }
+
+ public static void reset() {
+ sAppIsRunningAndEligibleForBackupWithTransport = p -> true;
+ }
+}
diff --git a/services/robotests/src/com/android/server/backup/testing/TransportTestUtils.java b/services/robotests/src/com/android/server/backup/testing/TransportTestUtils.java
new file mode 100644
index 0000000..9770e40
--- /dev/null
+++ b/services/robotests/src/com/android/server/backup/testing/TransportTestUtils.java
@@ -0,0 +1,155 @@
+/*
+ * 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.server.backup.testing;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import android.annotation.Nullable;
+import android.content.ComponentName;
+
+import com.android.internal.backup.IBackupTransport;
+import com.android.server.backup.TransportManager;
+import com.android.server.backup.transport.TransportClient;
+import com.android.server.backup.transport.TransportNotAvailableException;
+import com.android.server.backup.transport.TransportNotRegisteredException;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class TransportTestUtils {
+ public static final String[] TRANSPORT_NAMES = {
+ "android/com.android.internal.backup.LocalTransport",
+ "com.google.android.gms/.backup.migrate.service.D2dTransport",
+ "com.google.android.gms/.backup.BackupTransportService"
+ };
+
+ public static final String TRANSPORT_NAME = TRANSPORT_NAMES[0];
+
+ /** {@code transportName} has to be in the {@link ComponentName} format (with '/') */
+ public static TransportData setUpCurrentTransport(
+ TransportManager transportManager, String transportName) throws Exception {
+ TransportData transport = setUpTransports(transportManager, transportName).get(0);
+ when(transportManager.getCurrentTransportClient(any()))
+ .thenReturn(transport.transportClientMock);
+ return transport;
+ }
+
+ /** {@code transportName} has to be in the {@link ComponentName} format (with '/') */
+ public static List<TransportData> setUpTransports(
+ TransportManager transportManager, String... transportNames) throws Exception {
+ return setUpTransports(
+ transportManager,
+ Arrays.stream(transportNames)
+ .map(TransportData::new)
+ .toArray(TransportData[]::new));
+ }
+
+ /** @see #setUpTransport(TransportManager, TransportData) */
+ public static List<TransportData> setUpTransports(
+ TransportManager transportManager, TransportData... transports) throws Exception {
+ for (TransportData transport : transports) {
+ setUpTransport(transportManager, transport);
+ }
+ return Arrays.asList(transports);
+ }
+
+ /**
+ * Configures transport according to {@link TransportData}:
+ *
+ * <ul>
+ * <li>{@link TransportData#transportMock} {@code null} means transport not available.
+ * <li>{@link TransportData#transportClientMock} {@code null} means transport not registered.
+ * </ul>
+ */
+ public static void setUpTransport(TransportManager transportManager, TransportData transport)
+ throws Exception {
+ String transportName = transport.transportName;
+ String transportDirName = transportDirName(transportName);
+ ComponentName transportComponent = transportComponentName(transportName);
+ IBackupTransport transportMock = transport.transportMock;
+ TransportClient transportClientMock = transport.transportClientMock;
+
+ if (transportClientMock != null) {
+ // Transport registered
+ when(transportManager.getTransportClient(eq(transportName), any()))
+ .thenReturn(transportClientMock);
+ when(transportManager.getTransportClientOrThrow(eq(transportName), any()))
+ .thenReturn(transportClientMock);
+ when(transportManager.getTransportName(transportComponent)).thenReturn(transportName);
+ when(transportManager.getTransportDirName(eq(transportName)))
+ .thenReturn(transportDirName);
+ when(transportManager.getTransportDirName(eq(transportComponent)))
+ .thenReturn(transportDirName);
+ when(transportClientMock.getTransportComponent()).thenReturn(transportComponent);
+
+ if (transportMock != null) {
+ // Transport registered and available
+ when(transportClientMock.connectOrThrow(any())).thenReturn(transportMock);
+ when(transportMock.name()).thenReturn(transportName);
+ when(transportMock.transportDirName()).thenReturn(transportDirName);
+ } else {
+ // Transport registered but unavailable
+ when(transportClientMock.connectOrThrow(any()))
+ .thenThrow(TransportNotAvailableException.class);
+ }
+ } else {
+ // Transport not registered
+ when(transportManager.getTransportClient(eq(transportName), any())).thenReturn(null);
+ when(transportManager.getTransportClientOrThrow(eq(transportName), any()))
+ .thenThrow(TransportNotRegisteredException.class);
+ when(transportManager.getTransportName(transportComponent))
+ .thenThrow(TransportNotRegisteredException.class);
+ when(transportManager.getTransportDirName(eq(transportName)))
+ .thenThrow(TransportNotRegisteredException.class);
+ when(transportManager.getTransportDirName(eq(transportComponent)))
+ .thenThrow(TransportNotRegisteredException.class);
+ }
+ }
+
+ /** {@code transportName} has to be in the {@link ComponentName} format (with '/') */
+ public static ComponentName transportComponentName(String transportName) {
+ return ComponentName.unflattenFromString(transportName);
+ }
+
+ public static String transportDirName(String transportName) {
+ return transportName + "_dir_name";
+ }
+
+ public static class TransportData {
+ public final String transportName;
+ @Nullable public final IBackupTransport transportMock;
+ @Nullable public final TransportClient transportClientMock;
+
+ public TransportData(
+ String transportName,
+ @Nullable IBackupTransport transportMock,
+ @Nullable TransportClient transportClientMock) {
+ this.transportName = transportName;
+ this.transportMock = transportMock;
+ this.transportClientMock = transportClientMock;
+ }
+
+ public TransportData(String transportName) {
+ this(transportName, mock(IBackupTransport.class), mock(TransportClient.class));
+ }
+ }
+
+ private TransportTestUtils() {}
+}
diff --git a/services/robotests/src/com/android/server/backup/transport/TransportClientTest.java b/services/robotests/src/com/android/server/backup/transport/TransportClientTest.java
index 4462d2a..3bc0b30 100644
--- a/services/robotests/src/com/android/server/backup/transport/TransportClientTest.java
+++ b/services/robotests/src/com/android/server/backup/transport/TransportClientTest.java
@@ -43,7 +43,6 @@
import com.android.server.testing.SystemLoaderClasses;
import org.junit.Before;
-import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
@@ -65,7 +64,6 @@
@Mock private IBackupTransport.Stub mIBackupTransport;
private TransportClient mTransportClient;
private ComponentName mTransportComponent;
- private String mTransportDirName;
private Intent mBindIntent;
private ShadowLooper mShadowLooper;
@@ -77,14 +75,12 @@
mShadowLooper = shadowOf(mainLooper);
mTransportComponent =
new ComponentName(PACKAGE_NAME, PACKAGE_NAME + ".transport.Transport");
- mTransportDirName = mTransportComponent.toString();
mBindIntent = new Intent(SERVICE_ACTION_TRANSPORT_HOST).setComponent(mTransportComponent);
mTransportClient =
new TransportClient(
mContext,
mBindIntent,
mTransportComponent,
- mTransportDirName,
"1",
new Handler(mainLooper));
@@ -97,11 +93,6 @@
}
@Test
- public void testGetTransportDirName_returnsTransportDirName() {
- assertThat(mTransportClient.getTransportDirName()).isEqualTo(mTransportDirName);
- }
-
- @Test
public void testGetTransportComponent_returnsTransportComponent() {
assertThat(mTransportClient.getTransportComponent()).isEqualTo(mTransportComponent);
}
diff --git a/services/tests/servicestests/src/com/android/server/am/ActivityStackTests.java b/services/tests/servicestests/src/com/android/server/am/ActivityStackTests.java
index 6b09363..bcbf40e 100644
--- a/services/tests/servicestests/src/com/android/server/am/ActivityStackTests.java
+++ b/services/tests/servicestests/src/com/android/server/am/ActivityStackTests.java
@@ -47,7 +47,7 @@
* Tests for the {@link ActivityStack} class.
*
* Build/Install/Run:
- * bit FrameworksServicesTests:com.android.server.am.ActivityStackTests
+ * atest ActivityStackTests
*/
@SmallTest
@Presubmit
@@ -104,6 +104,29 @@
}
@Test
+ public void testPrimarySplitScreenToFullscreenWhenMovedToBack() throws Exception {
+ // Create primary splitscreen stack. This will create secondary stacks and places the
+ // existing fullscreen stack on the bottom.
+ final ActivityStack primarySplitScreen = mService.mStackSupervisor.getDefaultDisplay()
+ .createStack(WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD,
+ true /* onTop */);
+
+ // Assert windowing mode.
+ assertEquals(primarySplitScreen.getWindowingMode(), WINDOWING_MODE_SPLIT_SCREEN_PRIMARY);
+
+ // Move primary to back.
+ primarySplitScreen.moveToBack("testPrimarySplitScreenToFullscreenWhenMovedToBack",
+ null /* task */);
+
+ // Assert that stack is at the bottom.
+ assertEquals(mService.mStackSupervisor.getDefaultDisplay().getIndexOf(primarySplitScreen),
+ 0);
+
+ // Ensure no longer in splitscreen.
+ assertEquals(primarySplitScreen.getWindowingMode(), WINDOWING_MODE_FULLSCREEN);
+ }
+
+ @Test
public void testStopActivityWhenActivityDestroyed() throws Exception {
final ActivityRecord r = new ActivityBuilder(mService).setTask(mTask).build();
r.info.flags |= ActivityInfo.FLAG_NO_HISTORY;
diff --git a/services/tests/servicestests/src/com/android/server/am/GlobalSettingsToPropertiesMapperTest.java b/services/tests/servicestests/src/com/android/server/am/GlobalSettingsToPropertiesMapperTest.java
new file mode 100644
index 0000000..d9b3e1c
--- /dev/null
+++ b/services/tests/servicestests/src/com/android/server/am/GlobalSettingsToPropertiesMapperTest.java
@@ -0,0 +1,112 @@
+/*
+ * 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.server.am;
+
+import android.content.ContentResolver;
+import android.provider.Settings;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.SmallTest;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.mock.MockContentResolver;
+
+import com.android.internal.util.Preconditions;
+import com.android.internal.util.test.FakeSettingsProvider;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Tests for {@link GlobalSettingsToPropertiesMapper}
+ */
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class GlobalSettingsToPropertiesMapperTest {
+ private static final String[][] TEST_MAPPING = new String[][] {
+ {Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS, "TestProperty"}
+ };
+
+ private TestMapper mTestMapper;
+ private MockContentResolver mMockContentResolver;
+
+ @Before
+ public void setup() {
+ // Use FakeSettingsProvider to not affect global state
+ mMockContentResolver = new MockContentResolver(InstrumentationRegistry.getContext());
+ mMockContentResolver.addProvider(Settings.AUTHORITY, new FakeSettingsProvider());
+ mTestMapper = new TestMapper(mMockContentResolver);
+ }
+
+ @Test
+ public void testUpdatePropertiesFromGlobalSettings() {
+ Settings.Global.putString(mMockContentResolver,
+ Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS, "testValue");
+
+ mTestMapper.updatePropertiesFromGlobalSettings();
+ String propValue = mTestMapper.systemPropertiesGet("TestProperty");
+ Assert.assertEquals("testValue", propValue);
+
+ Settings.Global.putString(mMockContentResolver,
+ Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS, "testValue2");
+ mTestMapper.updatePropertyFromSetting(Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS,
+ "TestProperty");
+ propValue = mTestMapper.systemPropertiesGet("TestProperty");
+ Assert.assertEquals("testValue2", propValue);
+
+ Settings.Global.putString(mMockContentResolver,
+ Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS, null);
+ mTestMapper.updatePropertyFromSetting(Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS,
+ "TestProperty");
+ propValue = mTestMapper.systemPropertiesGet("TestProperty");
+ Assert.assertEquals("", propValue);
+ }
+
+ @Test
+ public void testUpdatePropertiesFromGlobalSettings_PropertyAndSettingNotPresent() {
+ // Test that empty property will not not be set if setting is not set
+ mTestMapper.updatePropertiesFromGlobalSettings();
+ String propValue = mTestMapper.systemPropertiesGet("TestProperty");
+ Assert.assertNull("Property should not be set if setting is null", propValue);
+ }
+
+ private static class TestMapper extends GlobalSettingsToPropertiesMapper {
+ private final Map<String, String> mProps = new HashMap<>();
+
+ TestMapper(ContentResolver contentResolver) {
+ super(contentResolver, TEST_MAPPING);
+ }
+
+ @Override
+ protected String systemPropertiesGet(String key) {
+ Preconditions.checkNotNull(key);
+ return mProps.get(key);
+ }
+
+ @Override
+ protected void systemPropertiesSet(String key, String value) {
+ Preconditions.checkNotNull(value);
+ Preconditions.checkNotNull(key);
+ mProps.put(key, value);
+ }
+ }
+
+}
+
diff --git a/services/tests/servicestests/src/com/android/server/backup/BackupManagerServiceTest.java b/services/tests/servicestests/src/com/android/server/backup/BackupManagerServiceTest.java
index f4c5442..766d30d 100644
--- a/services/tests/servicestests/src/com/android/server/backup/BackupManagerServiceTest.java
+++ b/services/tests/servicestests/src/com/android/server/backup/BackupManagerServiceTest.java
@@ -48,6 +48,7 @@
@SmallTest
@Presubmit
@RunWith(AndroidJUnit4.class)
+// TODO: Migrate this to Robolectric and merge with BackupManagerServiceRoboTest (and remove 'Robo')
public class BackupManagerServiceTest {
private static final String TAG = "BMSTest";
private static final ComponentName TRANSPORT_COMPONENT =
diff --git a/services/tests/servicestests/src/com/android/server/display/BrightnessMappingStrategyTest.java b/services/tests/servicestests/src/com/android/server/display/BrightnessMappingStrategyTest.java
index 5105f4e..9e7ef65 100644
--- a/services/tests/servicestests/src/com/android/server/display/BrightnessMappingStrategyTest.java
+++ b/services/tests/servicestests/src/com/android/server/display/BrightnessMappingStrategyTest.java
@@ -17,6 +17,7 @@
package com.android.server.display;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
@@ -27,6 +28,7 @@
import android.content.res.Resources;
import android.content.res.TypedArray;
+import android.hardware.display.BrightnessConfiguration;
import android.os.PowerManager;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
@@ -111,12 +113,41 @@
final float lux = (LUX_LEVELS[i - 1] + LUX_LEVELS[i]) / 2;
final float backlight = simple.getBrightness(lux) * PowerManager.BRIGHTNESS_ON;
assertTrue("Desired brightness should be between adjacent control points.",
- backlight > DISPLAY_LEVELS_BACKLIGHT[i-1]
+ backlight > DISPLAY_LEVELS_BACKLIGHT[i - 1]
&& backlight < DISPLAY_LEVELS_BACKLIGHT[i]);
}
}
@Test
+ public void testSimpleStrategyIgnoresNewConfiguration() {
+ Resources res = createResources(LUX_LEVELS, DISPLAY_LEVELS_BACKLIGHT);
+ BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res);
+
+ final int N = LUX_LEVELS.length;
+ final float[] lux = { 0f, 1f };
+ final float[] nits = { 0, PowerManager.BRIGHTNESS_ON };
+
+ BrightnessConfiguration config = new BrightnessConfiguration.Builder()
+ .setCurve(lux, nits)
+ .build();
+ strategy.setBrightnessConfiguration(config);
+ assertNotEquals(1.0f, strategy.getBrightness(1f), 0.01 /*tolerance*/);
+ }
+
+ @Test
+ public void testSimpleStrategyIgnoresNullConfiguration() {
+ Resources res = createResources(LUX_LEVELS, DISPLAY_LEVELS_BACKLIGHT);
+ BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res);
+
+ strategy.setBrightnessConfiguration(null);
+ final int N = DISPLAY_LEVELS_BACKLIGHT.length;
+ final float expectedBrightness =
+ (float) DISPLAY_LEVELS_BACKLIGHT[N - 1] / PowerManager.BRIGHTNESS_ON;
+ assertEquals(expectedBrightness,
+ strategy.getBrightness(LUX_LEVELS[N - 1]), 0.01 /*tolerance*/);
+ }
+
+ @Test
public void testPhysicalStrategyMappingAtControlPoints() {
Resources res = createResources(LUX_LEVELS, DISPLAY_LEVELS_NITS,
DISPLAY_RANGE_NITS, BACKLIGHT_RANGE);
@@ -142,11 +173,37 @@
final float backlight = physical.getBrightness(lux) * PowerManager.BRIGHTNESS_ON;
final float nits = backlightToBrightness.interpolate(backlight);
assertTrue("Desired brightness should be between adjacent control points.",
- nits > DISPLAY_LEVELS_NITS[i-1] && nits < DISPLAY_LEVELS_NITS[i]);
+ nits > DISPLAY_LEVELS_NITS[i - 1] && nits < DISPLAY_LEVELS_NITS[i]);
}
}
@Test
+ public void testPhysicalStrategyUsesNewConfigurations() {
+ Resources res = createResources(LUX_LEVELS, DISPLAY_LEVELS_NITS,
+ DISPLAY_RANGE_NITS, BACKLIGHT_RANGE);
+ BrightnessMappingStrategy strategy = BrightnessMappingStrategy.create(res);
+
+ final float[] lux = { 0f, 1f };
+ final float[] nits = {
+ DISPLAY_RANGE_NITS[0],
+ DISPLAY_RANGE_NITS[DISPLAY_RANGE_NITS.length - 1]
+ };
+
+ BrightnessConfiguration config = new BrightnessConfiguration.Builder()
+ .setCurve(lux, nits)
+ .build();
+ strategy.setBrightnessConfiguration(config);
+ assertEquals(1.0f, strategy.getBrightness(1f), 0.01 /*tolerance*/);
+
+ // Check that null returns us to the default configuration.
+ strategy.setBrightnessConfiguration(null);
+ final int N = DISPLAY_LEVELS_NITS.length;
+ final float expectedBrightness = DISPLAY_LEVELS_NITS[N - 1] / DISPLAY_RANGE_NITS[1];
+ assertEquals(expectedBrightness,
+ strategy.getBrightness(LUX_LEVELS[N - 1]), 0.01f /*tolerance*/);
+ }
+
+ @Test
public void testDefaultStrategyIsPhysical() {
Resources res = createResources(LUX_LEVELS, DISPLAY_LEVELS_BACKLIGHT,
DISPLAY_LEVELS_NITS, DISPLAY_RANGE_NITS, BACKLIGHT_RANGE);
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/KeySyncTaskTest.java b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/KeySyncTaskTest.java
index 1aac8ce..a0dcfdc 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/KeySyncTaskTest.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/KeySyncTaskTest.java
@@ -114,7 +114,7 @@
mWrappingKey = generateAndroidKeyStoreKey();
mEncryptKey = new PlatformEncryptionKey(TEST_GENERATION_ID, mWrappingKey);
- when(mPlatformKeyManager.getDecryptKey()).thenReturn(
+ when(mPlatformKeyManager.getDecryptKey(TEST_USER_ID)).thenReturn(
new PlatformDecryptionKey(TEST_GENERATION_ID, mWrappingKey));
}
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/PlatformKeyManagerTest.java b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/PlatformKeyManagerTest.java
index 97fbca2..b1bff70 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/PlatformKeyManagerTest.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/PlatformKeyManagerTest.java
@@ -78,7 +78,7 @@
mDatabaseFile = context.getDatabasePath(DATABASE_FILE_NAME);
mRecoverableKeyStoreDb = RecoverableKeyStoreDb.newInstance(context);
mPlatformKeyManager = new PlatformKeyManager(
- USER_ID_FIXTURE, mContext, mKeyStoreProxy, mRecoverableKeyStoreDb);
+ mContext, mKeyStoreProxy, mRecoverableKeyStoreDb);
when(mContext.getSystemService(anyString())).thenReturn(mKeyguardManager);
when(mContext.getSystemServiceName(any())).thenReturn("test");
@@ -93,7 +93,7 @@
@Test
public void init_createsEncryptKeyWithCorrectAlias() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
verify(mKeyStoreProxy).setEntry(
eq("com.android.server.locksettings.recoverablekeystore/platform/42/1/encrypt"),
@@ -103,14 +103,14 @@
@Test
public void init_createsEncryptKeyWithCorrectPurposes() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertEquals(KeyProperties.PURPOSE_ENCRYPT, getEncryptKeyProtection().getPurposes());
}
@Test
public void init_createsEncryptKeyWithCorrectPaddings() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertArrayEquals(
new String[] { KeyProperties.ENCRYPTION_PADDING_NONE },
@@ -119,7 +119,7 @@
@Test
public void init_createsEncryptKeyWithCorrectBlockModes() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertArrayEquals(
new String[] { KeyProperties.BLOCK_MODE_GCM },
@@ -128,14 +128,14 @@
@Test
public void init_createsEncryptKeyWithoutAuthenticationRequired() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertFalse(getEncryptKeyProtection().isUserAuthenticationRequired());
}
@Test
public void init_createsDecryptKeyWithCorrectAlias() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
verify(mKeyStoreProxy).setEntry(
eq("com.android.server.locksettings.recoverablekeystore/platform/42/1/decrypt"),
@@ -145,14 +145,14 @@
@Test
public void init_createsDecryptKeyWithCorrectPurposes() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertEquals(KeyProperties.PURPOSE_DECRYPT, getDecryptKeyProtection().getPurposes());
}
@Test
public void init_createsDecryptKeyWithCorrectPaddings() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertArrayEquals(
new String[] { KeyProperties.ENCRYPTION_PADDING_NONE },
@@ -161,7 +161,7 @@
@Test
public void init_createsDecryptKeyWithCorrectBlockModes() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertArrayEquals(
new String[] { KeyProperties.BLOCK_MODE_GCM },
@@ -170,14 +170,14 @@
@Test
public void init_createsDecryptKeyWithAuthenticationRequired() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertTrue(getDecryptKeyProtection().isUserAuthenticationRequired());
}
@Test
public void init_createsDecryptKeyWithAuthenticationValidFor15Seconds() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertEquals(
USER_AUTHENTICATION_VALIDITY_DURATION_SECONDS,
@@ -186,7 +186,7 @@
@Test
public void init_createsDecryptKeyBoundToTheUsersAuthentication() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertEquals(
USER_ID_FIXTURE,
@@ -195,7 +195,7 @@
@Test
public void init_createsBothKeysWithSameMaterial() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
verify(mKeyStoreProxy, times(2)).setEntry(any(), mEntryArgumentCaptor.capture(), any());
List<KeyStore.Entry> entries = mEntryArgumentCaptor.getAllValues();
@@ -206,7 +206,7 @@
@Test
public void init_savesGenerationIdToDatabase() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
assertEquals(1,
mRecoverableKeyStoreDb.getPlatformKeyGenerationId(USER_ID_FIXTURE));
@@ -214,23 +214,23 @@
@Test
public void init_setsGenerationIdTo1() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
- assertEquals(1, mPlatformKeyManager.getGenerationId());
+ assertEquals(1, mPlatformKeyManager.getGenerationId(USER_ID_FIXTURE));
}
@Test
public void init_incrementsGenerationIdIfKeyIsUnavailable() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
- assertEquals(2, mPlatformKeyManager.getGenerationId());
+ assertEquals(2, mPlatformKeyManager.getGenerationId(USER_ID_FIXTURE));
}
@Test
public void init_doesNotIncrementGenerationIdIfKeyAvailable() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
when(mKeyStoreProxy
.containsAlias("com.android.server.locksettings.recoverablekeystore/"
+ "platform/42/1/decrypt")).thenReturn(true);
@@ -238,21 +238,19 @@
.containsAlias("com.android.server.locksettings.recoverablekeystore/"
+ "platform/42/1/encrypt")).thenReturn(true);
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
- assertEquals(1, mPlatformKeyManager.getGenerationId());
+ assertEquals(1, mPlatformKeyManager.getGenerationId(USER_ID_FIXTURE));
}
@Test
public void getGenerationId_returnsMinusOneIfNotInitialized() throws Exception {
- assertEquals(-1, mPlatformKeyManager.getGenerationId());
+ assertEquals(-1, mPlatformKeyManager.getGenerationId(USER_ID_FIXTURE));
}
@Test
public void getDecryptKey_getsDecryptKeyWithCorrectAlias() throws Exception {
- mPlatformKeyManager.init();
-
- mPlatformKeyManager.getDecryptKey();
+ mPlatformKeyManager.getDecryptKey(USER_ID_FIXTURE);
verify(mKeyStoreProxy).getKey(
eq("com.android.server.locksettings.recoverablekeystore/platform/42/1/decrypt"),
@@ -261,9 +259,7 @@
@Test
public void getEncryptKey_getsDecryptKeyWithCorrectAlias() throws Exception {
- mPlatformKeyManager.init();
-
- mPlatformKeyManager.getEncryptKey();
+ mPlatformKeyManager.getEncryptKey(USER_ID_FIXTURE);
verify(mKeyStoreProxy).getKey(
eq("com.android.server.locksettings.recoverablekeystore/platform/42/1/encrypt"),
@@ -272,18 +268,18 @@
@Test
public void regenerate_incrementsTheGenerationId() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
- mPlatformKeyManager.regenerate();
+ mPlatformKeyManager.regenerate(USER_ID_FIXTURE);
- assertEquals(2, mPlatformKeyManager.getGenerationId());
+ assertEquals(2, mPlatformKeyManager.getGenerationId(USER_ID_FIXTURE));
}
@Test
public void regenerate_generatesANewEncryptKeyWithTheCorrectAlias() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
- mPlatformKeyManager.regenerate();
+ mPlatformKeyManager.regenerate(USER_ID_FIXTURE);
verify(mKeyStoreProxy).setEntry(
eq("com.android.server.locksettings.recoverablekeystore/platform/42/2/encrypt"),
@@ -293,9 +289,9 @@
@Test
public void regenerate_generatesANewDecryptKeyWithTheCorrectAlias() throws Exception {
- mPlatformKeyManager.init();
+ mPlatformKeyManager.init(USER_ID_FIXTURE);
- mPlatformKeyManager.regenerate();
+ mPlatformKeyManager.regenerate(USER_ID_FIXTURE);
verify(mKeyStoreProxy).setEntry(
eq("com.android.server.locksettings.recoverablekeystore/platform/42/2/decrypt"),
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManagerTest.java b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManagerTest.java
index 445fbde..967c3b8 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManagerTest.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/RecoverableKeyStoreManagerTest.java
@@ -36,9 +36,11 @@
import android.content.Context;
import android.content.Intent;
import android.os.Binder;
-import android.os.RemoteException;
import android.os.ServiceSpecificException;
import android.os.UserHandle;
+import android.security.keystore.AndroidKeyStoreSecretKey;
+import android.security.keystore.KeyGenParameterSpec;
+import android.security.keystore.KeyProperties;
import android.security.recoverablekeystore.KeyDerivationParameters;
import android.security.recoverablekeystore.KeyEntryRecoveryData;
import android.security.recoverablekeystore.KeyStoreRecoveryMetadata;
@@ -67,9 +69,8 @@
import java.util.Map;
import java.util.Random;
-import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
-import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
@SmallTest
@@ -77,7 +78,6 @@
public class RecoverableKeyStoreManagerTest {
private static final String DATABASE_FILE_NAME = "recoverablekeystore.db";
- private static final String KEY_WRAP_CIPHER_ALGORITHM = "AES/GCM/NoPadding";
private static final String TEST_SESSION_ID = "karlin";
private static final byte[] TEST_PUBLIC_KEY = new byte[] {
(byte) 0x30, (byte) 0x59, (byte) 0x30, (byte) 0x13, (byte) 0x06, (byte) 0x07, (byte) 0x2a,
@@ -96,7 +96,28 @@
private static final byte[] TEST_SALT = getUtf8Bytes("salt");
private static final byte[] TEST_SECRET = getUtf8Bytes("password1234");
private static final byte[] TEST_VAULT_CHALLENGE = getUtf8Bytes("vault_challenge");
- private static final byte[] TEST_VAULT_PARAMS = getUtf8Bytes("vault_params");
+ private static final byte[] TEST_VAULT_PARAMS = new byte[] {
+ // backend_key
+ (byte) 0x04, (byte) 0xb8, (byte) 0x00, (byte) 0x11, (byte) 0x18, (byte) 0x98, (byte) 0x1d,
+ (byte) 0xf0, (byte) 0x6e, (byte) 0xb4, (byte) 0x94, (byte) 0xfe, (byte) 0x86, (byte) 0xda,
+ (byte) 0x1c, (byte) 0x07, (byte) 0x8d, (byte) 0x01, (byte) 0xb4, (byte) 0x3a, (byte) 0xf6,
+ (byte) 0x8d, (byte) 0xdc, (byte) 0x61, (byte) 0xd0, (byte) 0x46, (byte) 0x49, (byte) 0x95,
+ (byte) 0x0f, (byte) 0x10, (byte) 0x86, (byte) 0x93, (byte) 0x24, (byte) 0x66, (byte) 0xe0,
+ (byte) 0x3f, (byte) 0xd2, (byte) 0xdf, (byte) 0xf3, (byte) 0x79, (byte) 0x20, (byte) 0x1d,
+ (byte) 0x91, (byte) 0x55, (byte) 0xb0, (byte) 0xe5, (byte) 0xbd, (byte) 0x7a, (byte) 0x8b,
+ (byte) 0x32, (byte) 0x7d, (byte) 0x25, (byte) 0x53, (byte) 0xa2, (byte) 0xfc, (byte) 0xa5,
+ (byte) 0x65, (byte) 0xe1, (byte) 0xbd, (byte) 0x21, (byte) 0x44, (byte) 0x7e, (byte) 0x78,
+ (byte) 0x52, (byte) 0xfa,
+ // counter_id
+ (byte) 0x31, (byte) 0x32, (byte) 0x33, (byte) 0x34, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+ (byte) 0x00,
+ // device_parameter
+ (byte) 0x78, (byte) 0x56, (byte) 0x34, (byte) 0x12, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+ (byte) 0x0,
+ // max_attempts
+ (byte) 0x0a, (byte) 0x00, (byte) 0x00, (byte) 0x00};
+ private static final int TEST_GENERATION_ID = 2;
+ private static final int TEST_USER_ID = 10009;
private static final int KEY_CLAIMANT_LENGTH_BYTES = 16;
private static final byte[] RECOVERY_RESPONSE_HEADER =
"V1 reencrypted_recovery_key".getBytes(StandardCharsets.UTF_8);
@@ -105,20 +126,24 @@
private static final int GENERATION_ID = 1;
private static final byte[] NONCE = getUtf8Bytes("nonce");
private static final byte[] KEY_MATERIAL = getUtf8Bytes("keymaterial");
- private static final int GCM_TAG_SIZE_BITS = 128;
+ private static final String KEY_ALGORITHM = "AES";
+ private static final String ANDROID_KEY_STORE_PROVIDER = "AndroidKeyStore";
+ private static final String WRAPPING_KEY_ALIAS = "RecoverableKeyStoreManagerTest/WrappingKey";
@Mock private Context mMockContext;
@Mock private RecoverySnapshotListenersStorage mMockListenersStorage;
@Mock private KeyguardManager mKeyguardManager;
+ @Mock private PlatformKeyManager mPlatformKeyManager;
private RecoverableKeyStoreDb mRecoverableKeyStoreDb;
private File mDatabaseFile;
private RecoverableKeyStoreManager mRecoverableKeyStoreManager;
private RecoverySessionStorage mRecoverySessionStorage;
private RecoverySnapshotStorage mRecoverySnapshotStorage;
+ private PlatformEncryptionKey mPlatformEncryptionKey;
@Before
- public void setUp() {
+ public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
Context context = InstrumentationRegistry.getTargetContext();
@@ -130,7 +155,11 @@
when(mMockContext.getSystemService(anyString())).thenReturn(mKeyguardManager);
when(mMockContext.getSystemServiceName(any())).thenReturn("test");
when(mMockContext.getApplicationContext()).thenReturn(mMockContext);
- when(mKeyguardManager.isDeviceSecure(anyInt())).thenReturn(true);
+ when(mKeyguardManager.isDeviceSecure(TEST_USER_ID)).thenReturn(true);
+
+ mPlatformEncryptionKey =
+ new PlatformEncryptionKey(TEST_GENERATION_ID, generateAndroidKeyStoreKey());
+ when(mPlatformKeyManager.getEncryptKey(anyInt())).thenReturn(mPlatformEncryptionKey);
mRecoverableKeyStoreManager = new RecoverableKeyStoreManager(
mMockContext,
@@ -138,7 +167,8 @@
mRecoverySessionStorage,
Executors.newSingleThreadExecutor(),
mRecoverySnapshotStorage,
- mMockListenersStorage);
+ mMockListenersStorage,
+ mPlatformKeyManager);
}
@After
@@ -163,6 +193,16 @@
}
@Test
+ public void removeKey_removesAKey() throws Exception {
+ int uid = Binder.getCallingUid();
+ mRecoverableKeyStoreManager.generateAndStoreKey(TEST_ALIAS);
+
+ mRecoverableKeyStoreManager.removeKey(TEST_ALIAS);
+
+ assertThat(mRecoverableKeyStoreDb.getKey(uid, TEST_ALIAS)).isNull();
+ }
+
+ @Test
public void startRecoverySession_checksPermissionFirst() throws Exception {
mRecoverableKeyStoreManager.startRecoverySession(
TEST_SESSION_ID,
@@ -212,7 +252,7 @@
TEST_VAULT_CHALLENGE,
ImmutableList.of());
fail("should have thrown");
- } catch (RemoteException e) {
+ } catch (ServiceSpecificException e) {
assertEquals("Only a single KeyStoreRecoveryMetadata is supported", e.getMessage());
}
}
@@ -232,12 +272,34 @@
KeyDerivationParameters.createSHA256Parameters(TEST_SALT),
TEST_SECRET)));
fail("should have thrown");
- } catch (RemoteException e) {
+ } catch (ServiceSpecificException e) {
assertEquals("Not a valid X509 key", e.getMessage());
}
}
@Test
+ public void startRecoverySession_throwsIfPublicKeysMismatch() throws Exception {
+ byte[] vaultParams = TEST_VAULT_PARAMS.clone();
+ vaultParams[1] ^= (byte) 1; // Flip 1 bit
+ try {
+ mRecoverableKeyStoreManager.startRecoverySession(
+ TEST_SESSION_ID,
+ TEST_PUBLIC_KEY,
+ vaultParams,
+ TEST_VAULT_CHALLENGE,
+ ImmutableList.of(
+ new KeyStoreRecoveryMetadata(
+ TYPE_LOCKSCREEN,
+ TYPE_PASSWORD,
+ KeyDerivationParameters.createSHA256Parameters(TEST_SALT),
+ TEST_SECRET)));
+ fail("should have thrown");
+ } catch (ServiceSpecificException e) {
+ assertThat(e.getMessage()).contains("do not match");
+ }
+ }
+
+ @Test
public void recoverKeys_throwsIfNoSessionIsPresent() throws Exception {
try {
mRecoverableKeyStoreManager.recoverKeys(
@@ -273,7 +335,6 @@
fail("should have thrown");
} catch (ServiceSpecificException e) {
assertThat(e.getMessage()).startsWith("Failed to decrypt recovery key");
- //assertEquals("Failed to decrypt recovery key", e.getMessage());
}
}
@@ -304,8 +365,8 @@
/*encryptedRecoveryKey=*/ encryptedClaimResponse,
/*applicationKeys=*/ ImmutableList.of(badApplicationKey));
fail("should have thrown");
- } catch (RemoteException e) {
- assertEquals("Failed to recover key with alias 'nick'", e.getMessage());
+ } catch (ServiceSpecificException e) {
+ assertThat(e.getMessage()).startsWith("Failed to recover key with alias 'nick'");
}
}
@@ -466,4 +527,16 @@
new Random().nextBytes(bytes);
return bytes;
}
+
+ private AndroidKeyStoreSecretKey generateAndroidKeyStoreKey() throws Exception {
+ KeyGenerator keyGenerator = KeyGenerator.getInstance(
+ KEY_ALGORITHM,
+ ANDROID_KEY_STORE_PROVIDER);
+ keyGenerator.init(new KeyGenParameterSpec.Builder(
+ WRAPPING_KEY_ALIAS, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
+ .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+ .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+ .build());
+ return (AndroidKeyStoreSecretKey) keyGenerator.generateKey();
+ }
}
diff --git a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDbTest.java b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDbTest.java
index a8c7d5e..c7b338c 100644
--- a/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDbTest.java
+++ b/services/tests/servicestests/src/com/android/server/locksettings/recoverablekeystore/storage/RecoverableKeyStoreDbTest.java
@@ -113,6 +113,22 @@
}
@Test
+ public void removeKey_removesAKey() {
+ int userId = 6;
+ int uid = 60001;
+ String alias = "rupertbates";
+ WrappedKey key = new WrappedKey(
+ getUtf8Bytes("nonce1"),
+ getUtf8Bytes("key1"),
+ /*platformKeyGenerationId=*/ 1);
+ mRecoverableKeyStoreDb.insertKey(userId, uid, alias, key);
+
+ assertTrue(mRecoverableKeyStoreDb.removeKey(uid, alias));
+
+ assertNull(mRecoverableKeyStoreDb.getKey(uid, alias));
+ }
+
+ @Test
public void getKey_returnsNullIfNoKey() {
WrappedKey key = mRecoverableKeyStoreDb.getKey(
/*userId=*/ 1, /*alias=*/ "hello");
diff --git a/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimationRunnerTest.java b/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimationRunnerTest.java
index 17fe642..b36c7d9 100644
--- a/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimationRunnerTest.java
+++ b/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimationRunnerTest.java
@@ -34,8 +34,10 @@
import android.graphics.Matrix;
import android.graphics.Point;
import android.platform.test.annotations.Presubmit;
+import android.support.test.filters.FlakyTest;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
+import android.util.Log;
import android.view.Choreographer;
import android.view.Choreographer.FrameCallback;
import android.view.SurfaceControl;
@@ -135,6 +137,7 @@
assertFinishCallbackNotCalled();
}
+ @FlakyTest(bugId = 71719744)
@Test
public void testCancel_sneakyCancelBeforeUpdate() throws Exception {
mSurfaceAnimationRunner = new SurfaceAnimationRunner(null, () -> new ValueAnimator() {
@@ -157,9 +160,27 @@
when(mMockAnimationSpec.getDuration()).thenReturn(200L);
mSurfaceAnimationRunner.startAnimation(mMockAnimationSpec, mMockSurface, mMockTransaction,
this::finishedCallback);
+
+ // We need to wait for two frames: The first frame starts the animation, the second frame
+ // actually cancels the animation.
+ waitUntilNextFrame();
+ waitUntilNextFrame();
+ assertTrue(mSurfaceAnimationRunner.mRunningAnimations.isEmpty());
+ verify(mMockAnimationSpec, atLeastOnce()).apply(any(), any(), eq(0L));
+ }
+
+ @Test
+ public void testDeferStartingAnimations() throws Exception {
+ mSurfaceAnimationRunner.deferStartingAnimations();
+ mSurfaceAnimationRunner.startAnimation(createTranslateAnimation(), mMockSurface,
+ mMockTransaction, this::finishedCallback);
+ waitUntilNextFrame();
+ assertTrue(mSurfaceAnimationRunner.mRunningAnimations.isEmpty());
+ mSurfaceAnimationRunner.continueStartingAnimations();
waitUntilNextFrame();
assertFalse(mSurfaceAnimationRunner.mRunningAnimations.isEmpty());
- verify(mMockAnimationSpec, atLeastOnce()).apply(any(), any(), eq(0L));
+ mFinishCallbackLatch.await(1, SECONDS);
+ assertFinishCallbackCalled();
}
private void waitUntilNextFrame() throws Exception {
diff --git a/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimatorTest.java b/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimatorTest.java
index 463ceeb..64c3037 100644
--- a/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimatorTest.java
+++ b/services/tests/servicestests/src/com/android/server/wm/SurfaceAnimatorTest.java
@@ -75,10 +75,7 @@
mAnimatable2 = new MyAnimatable();
}
- // TODO: Tests are flaky, and timeout after 5 minutes. Instead of wasting everybody's time we
- // mark them as ignore.
@Test
- @Ignore
public void testRunAnimation() throws Exception {
mAnimatable.mSurfaceAnimator.startAnimation(mTransaction, mSpec, true /* hidden */);
final ArgumentCaptor<OnAnimationFinishedCallback> callbackCaptor = ArgumentCaptor.forClass(
@@ -88,17 +85,13 @@
verify(mSpec).startAnimation(any(), any(), callbackCaptor.capture());
callbackCaptor.getValue().onAnimationFinished(mSpec);
- waitUntilPrepareSurfaces();
assertNotAnimating(mAnimatable);
assertTrue(mAnimatable.mFinishedCallbackCalled);
assertTrue(mAnimatable.mPendingDestroySurfaces.contains(mAnimatable.mLeash));
// TODO: Verify reparenting once we use mPendingTransaction to reparent it back
}
- // TODO: Tests are flaky, and timeout after 5 minutes. Instead of wasting everybody's time we
- // mark them as ignore.
@Test
- @Ignore
public void testOverrideAnimation() throws Exception {
mAnimatable.mSurfaceAnimator.startAnimation(mTransaction, mSpec, true /* hidden */);
final SurfaceControl firstLeash = mAnimatable.mLeash;
@@ -114,13 +107,11 @@
// First animation was finished, but this shouldn't cancel the second animation
callbackCaptor.getValue().onAnimationFinished(mSpec);
- waitUntilPrepareSurfaces();
assertTrue(mAnimatable.mSurfaceAnimator.isAnimating());
// Second animation was finished
verify(mSpec2).startAnimation(any(), any(), callbackCaptor.capture());
callbackCaptor.getValue().onAnimationFinished(mSpec2);
- waitUntilPrepareSurfaces();
assertNotAnimating(mAnimatable);
assertTrue(mAnimatable.mFinishedCallbackCalled);
}
@@ -157,10 +148,7 @@
assertTrue(mAnimatable.mPendingDestroySurfaces.contains(mAnimatable.mLeash));
}
- // TODO: Tests are flaky, and timeout after 5 minutes. Instead of wasting everybody's time we
- // mark them as ignore.
@Test
- @Ignore
public void testTransferAnimation() throws Exception {
mAnimatable.mSurfaceAnimator.startAnimation(mTransaction, mSpec, true /* hidden */);
@@ -175,7 +163,6 @@
assertEquals(leash, mAnimatable2.mSurfaceAnimator.mLeash);
assertFalse(mAnimatable.mPendingDestroySurfaces.contains(leash));
callbackCaptor.getValue().onAnimationFinished(mSpec);
- waitUntilPrepareSurfaces();
assertNotAnimating(mAnimatable2);
assertTrue(mAnimatable2.mFinishedCallbackCalled);
assertTrue(mAnimatable2.mPendingDestroySurfaces.contains(leash));
@@ -191,14 +178,6 @@
assertNull(animatable.mSurfaceAnimator.getAnimation());
}
- private void waitUntilPrepareSurfaces() throws Exception {
- final CountDownLatch latch = new CountDownLatch(1);
- synchronized (sWm.mWindowMap) {
- sWm.mAnimator.addAfterPrepareSurfacesRunnable(latch::countDown);
- }
- latch.await();
- }
-
private class MyAnimatable implements Animatable {
final SurfaceControl mParent;
@@ -219,7 +198,7 @@
.build();
mFinishedCallbackCalled = false;
mLeash = null;
- mSurfaceAnimator = new SurfaceAnimator(this, mFinishedCallback, sWm);
+ mSurfaceAnimator = new SurfaceAnimator(this, mFinishedCallback, Runnable::run, sWm);
}
@Override
diff --git a/services/tests/servicestests/src/com/android/server/wm/WindowAnimationSpecTest.java b/services/tests/servicestests/src/com/android/server/wm/WindowAnimationSpecTest.java
index 9cdef16..f8db4fa 100644
--- a/services/tests/servicestests/src/com/android/server/wm/WindowAnimationSpecTest.java
+++ b/services/tests/servicestests/src/com/android/server/wm/WindowAnimationSpecTest.java
@@ -25,6 +25,7 @@
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import android.graphics.Point;
import android.graphics.Rect;
import android.platform.test.annotations.Presubmit;
import android.support.test.filters.SmallTest;
@@ -72,6 +73,19 @@
}
@Test
+ public void testApply_clipAfterOffsetPosition() {
+ // Stack bounds is (0, 0, 10, 10) position is (20, 40)
+ WindowAnimationSpec windowAnimationSpec = new WindowAnimationSpec(mAnimation,
+ new Point(20, 40), mStackBounds, false /* canSkipFirstFrame */,
+ STACK_CLIP_AFTER_ANIM);
+ windowAnimationSpec.apply(mTransaction, mSurfaceControl, 0);
+ verify(mTransaction).setWindowCrop(eq(mSurfaceControl), argThat(Rect::isEmpty));
+ verify(mTransaction).setFinalCrop(eq(mSurfaceControl),
+ argThat(rect -> rect.left == 20 && rect.top == 40 && rect.right == 30
+ && rect.bottom == 50));
+ }
+
+ @Test
public void testApply_clipBeforeNoAnimationBounds() {
// Stack bounds is (0, 0, 10, 10) animation clip is (0, 0, 0, 0)
WindowAnimationSpec windowAnimationSpec = new WindowAnimationSpec(mAnimation, null,
diff --git a/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java b/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
index 67db5f4..7be203a 100644
--- a/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
+++ b/services/tests/servicestests/src/com/android/server/wm/WindowStateTests.java
@@ -16,7 +16,6 @@
package com.android.server.wm;
-import android.util.MergedConfiguration;
import android.view.WindowManager;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -45,8 +44,7 @@
/**
* Tests for the {@link WindowState} class.
*
- * Build/Install/Run:
- * bit FrameworksServicesTests:com.android.server.wm.WindowStateTests
+ * atest FrameworksServicesTests:com.android.server.wm.WindowStateTests
*/
@SmallTest
@Presubmit
@@ -213,6 +211,18 @@
testPrepareWindowToDisplayDuringRelayout(true /*wasVisible*/);
}
+ @Test
+ public void testCanAffectSystemUiFlags() throws Exception {
+ final WindowState app = createWindow(null, TYPE_APPLICATION, "app");
+ app.mToken.setHidden(false);
+ assertTrue(app.canAffectSystemUiFlags());
+ app.mToken.setHidden(true);
+ assertFalse(app.canAffectSystemUiFlags());
+ app.mToken.setHidden(false);
+ app.mAttrs.alpha = 0.0f;
+ assertFalse(app.canAffectSystemUiFlags());
+ }
+
private void testPrepareWindowToDisplayDuringRelayout(boolean wasVisible) {
final WindowState root = createWindow(null, TYPE_APPLICATION, "root");
root.mAttrs.flags |= WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
diff --git a/services/tests/servicestests/src/com/android/server/wm/WindowTestsBase.java b/services/tests/servicestests/src/com/android/server/wm/WindowTestsBase.java
index ff840f3..c699a94 100644
--- a/services/tests/servicestests/src/com/android/server/wm/WindowTestsBase.java
+++ b/services/tests/servicestests/src/com/android/server/wm/WindowTestsBase.java
@@ -103,7 +103,6 @@
context.getDisplay().getDisplayInfo(mDisplayInfo);
mDisplayContent = createNewDisplay();
- sWm.mAnimator.mInitialized = true;
sWm.mDisplayEnabled = true;
sWm.mDisplayReady = true;
diff --git a/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java b/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java
index 6468763..bcc9a1c 100644
--- a/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java
+++ b/services/tests/servicestests/src/com/android/server/wm/ZOrderingTests.java
@@ -21,10 +21,12 @@
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.app.WindowConfiguration.WINDOWING_MODE_PINNED;
import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_PRIMARY;
+import static android.app.WindowConfiguration.WINDOWING_MODE_SPLIT_SCREEN_SECONDARY;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY;
import static android.view.WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
+import static android.view.WindowManager.LayoutParams.TYPE_DOCK_DIVIDER;
import static android.view.WindowManager.LayoutParams.TYPE_NAVIGATION_BAR_PANEL;
import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL;
import static android.view.WindowManager.LayoutParams.TYPE_STATUS_BAR_SUB_PANEL;
@@ -74,11 +76,11 @@
return super.setRelativeLayer(sc, relativeTo, layer);
}
- int getLayer(SurfaceControl sc) {
+ private int getLayer(SurfaceControl sc) {
return mLayersForControl.getOrDefault(sc, 0);
}
- SurfaceControl getRelativeLayer(SurfaceControl sc) {
+ private SurfaceControl getRelativeLayer(SurfaceControl sc) {
return mRelativeLayersForControl.get(sc);
}
};
@@ -146,8 +148,9 @@
return p;
}
- void assertZOrderGreaterThan(LayerRecordingTransaction t,
- SurfaceControl left, SurfaceControl right) throws Exception {
+
+ void assertZOrderGreaterThan(LayerRecordingTransaction t, SurfaceControl left,
+ SurfaceControl right) throws Exception {
final LinkedList<SurfaceControl> leftParentChain = getAncestors(t, left);
final LinkedList<SurfaceControl> rightParentChain = getAncestors(t, right);
@@ -171,9 +174,12 @@
}
}
- void assertWindowLayerGreaterThan(LayerRecordingTransaction t,
- WindowState left, WindowState right) throws Exception {
- assertZOrderGreaterThan(t, left.getSurfaceControl(), right.getSurfaceControl());
+ void assertWindowHigher(WindowState left, WindowState right) throws Exception {
+ assertZOrderGreaterThan(mTransaction, left.getSurfaceControl(), right.getSurfaceControl());
+ }
+
+ WindowState createWindow(String name) {
+ return createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, name);
}
@Test
@@ -184,38 +190,37 @@
// The Ime has an higher base layer than app windows and lower base layer than system
// windows, so it should be above app windows and below system windows if there isn't an IME
// target.
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mChildAppWindowAbove);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mAppWindow);
- assertWindowLayerGreaterThan(mTransaction, mNavBarWindow, mImeWindow);
- assertWindowLayerGreaterThan(mTransaction, mStatusBarWindow, mImeWindow);
+ assertWindowHigher(mImeWindow, mChildAppWindowAbove);
+ assertWindowHigher(mImeWindow, mAppWindow);
+ assertWindowHigher(mNavBarWindow, mImeWindow);
+ assertWindowHigher(mStatusBarWindow, mImeWindow);
// And, IME dialogs should always have an higher layer than the IME.
- assertWindowLayerGreaterThan(mTransaction, mImeDialogWindow, mImeWindow);
+ assertWindowHigher(mImeDialogWindow, mImeWindow);
}
@Test
public void testAssignWindowLayers_ForImeWithAppTarget() throws Exception {
- final WindowState imeAppTarget =
- createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, "imeAppTarget");
+ final WindowState imeAppTarget = createWindow("imeAppTarget");
sWm.mInputMethodTarget = imeAppTarget;
+
mDisplayContent.assignChildLayers(mTransaction);
// Ime should be above all app windows and below system windows if it is targeting an app
// window.
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, imeAppTarget);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mChildAppWindowAbove);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mAppWindow);
- assertWindowLayerGreaterThan(mTransaction, mNavBarWindow, mImeWindow);
- assertWindowLayerGreaterThan(mTransaction, mStatusBarWindow, mImeWindow);
+ assertWindowHigher(mImeWindow, imeAppTarget);
+ assertWindowHigher(mImeWindow, mChildAppWindowAbove);
+ assertWindowHigher(mImeWindow, mAppWindow);
+ assertWindowHigher(mNavBarWindow, mImeWindow);
+ assertWindowHigher(mStatusBarWindow, mImeWindow);
// And, IME dialogs should always have an higher layer than the IME.
- assertWindowLayerGreaterThan(mTransaction, mImeDialogWindow, mImeWindow);
+ assertWindowHigher(mImeDialogWindow, mImeWindow);
}
@Test
public void testAssignWindowLayers_ForImeWithAppTargetWithChildWindows() throws Exception {
- final WindowState imeAppTarget =
- createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, "imeAppTarget");
+ final WindowState imeAppTarget = createWindow("imeAppTarget");
final WindowState imeAppTargetChildAboveWindow = createWindow(imeAppTarget,
TYPE_APPLICATION_ATTACHED_DIALOG, imeAppTarget.mToken,
"imeAppTargetChildAboveWindow");
@@ -228,41 +233,38 @@
// Ime should be above all app windows except for child windows that are z-ordered above it
// and below system windows if it is targeting an app window.
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, imeAppTarget);
- assertWindowLayerGreaterThan(mTransaction, imeAppTargetChildAboveWindow, mImeWindow);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mChildAppWindowAbove);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mAppWindow);
- assertWindowLayerGreaterThan(mTransaction, mNavBarWindow, mImeWindow);
- assertWindowLayerGreaterThan(mTransaction, mStatusBarWindow, mImeWindow);
+ assertWindowHigher(mImeWindow, imeAppTarget);
+ assertWindowHigher(imeAppTargetChildAboveWindow, mImeWindow);
+ assertWindowHigher(mImeWindow, mChildAppWindowAbove);
+ assertWindowHigher(mImeWindow, mAppWindow);
+ assertWindowHigher(mNavBarWindow, mImeWindow);
+ assertWindowHigher(mStatusBarWindow, mImeWindow);
// And, IME dialogs should always have an higher layer than the IME.
- assertWindowLayerGreaterThan(mTransaction, mImeDialogWindow, mImeWindow);
+ assertWindowHigher(mImeDialogWindow, mImeWindow);
}
@Test
public void testAssignWindowLayers_ForImeWithAppTargetAndAppAbove() throws Exception {
- final WindowState appBelowImeTarget =
- createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, "appBelowImeTarget");
- final WindowState imeAppTarget =
- createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, "imeAppTarget");
- final WindowState appAboveImeTarget =
- createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, "appAboveImeTarget");
+ final WindowState appBelowImeTarget = createWindow("appBelowImeTarget");
+ final WindowState imeAppTarget = createWindow("imeAppTarget");
+ final WindowState appAboveImeTarget = createWindow("appAboveImeTarget");
sWm.mInputMethodTarget = imeAppTarget;
mDisplayContent.assignChildLayers(mTransaction);
// Ime should be above all app windows except for non-fullscreen app window above it and
// below system windows if it is targeting an app window.
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, imeAppTarget);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, appBelowImeTarget);
- assertWindowLayerGreaterThan(mTransaction, appAboveImeTarget, mImeWindow);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mChildAppWindowAbove);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mAppWindow);
- assertWindowLayerGreaterThan(mTransaction, mNavBarWindow, mImeWindow);
- assertWindowLayerGreaterThan(mTransaction, mStatusBarWindow, mImeWindow);
+ assertWindowHigher(mImeWindow, imeAppTarget);
+ assertWindowHigher(mImeWindow, appBelowImeTarget);
+ assertWindowHigher(appAboveImeTarget, mImeWindow);
+ assertWindowHigher(mImeWindow, mChildAppWindowAbove);
+ assertWindowHigher(mImeWindow, mAppWindow);
+ assertWindowHigher(mNavBarWindow, mImeWindow);
+ assertWindowHigher(mStatusBarWindow, mImeWindow);
// And, IME dialogs should always have an higher layer than the IME.
- assertWindowLayerGreaterThan(mTransaction, mImeDialogWindow, mImeWindow);
+ assertWindowHigher(mImeDialogWindow, mImeWindow);
}
@Test
@@ -276,20 +278,20 @@
// The IME target base layer is higher than all window except for the nav bar window, so the
// IME should be above all windows except for the nav bar.
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, imeSystemOverlayTarget);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mChildAppWindowAbove);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mAppWindow);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mDockedDividerWindow);
+ assertWindowHigher(mImeWindow, imeSystemOverlayTarget);
+ assertWindowHigher(mImeWindow, mChildAppWindowAbove);
+ assertWindowHigher(mImeWindow, mAppWindow);
+ assertWindowHigher(mImeWindow, mDockedDividerWindow);
// The IME has a higher base layer than the status bar so we may expect it to go
// above the status bar once they are both in the Non-App layer, as past versions of this
// test enforced. However this seems like the wrong behavior unless the status bar is the
// IME target.
- assertWindowLayerGreaterThan(mTransaction, mNavBarWindow, mImeWindow);
- assertWindowLayerGreaterThan(mTransaction, mStatusBarWindow, mImeWindow);
+ assertWindowHigher(mNavBarWindow, mImeWindow);
+ assertWindowHigher(mStatusBarWindow, mImeWindow);
// And, IME dialogs should always have an higher layer than the IME.
- assertWindowLayerGreaterThan(mTransaction, mImeDialogWindow, mImeWindow);
+ assertWindowHigher(mImeDialogWindow, mImeWindow);
}
@Test
@@ -297,17 +299,18 @@
sWm.mInputMethodTarget = mStatusBarWindow;
mDisplayContent.assignChildLayers(mTransaction);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mChildAppWindowAbove);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mAppWindow);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mDockedDividerWindow);
- assertWindowLayerGreaterThan(mTransaction, mImeWindow, mStatusBarWindow);
+ assertWindowHigher(mImeWindow, mChildAppWindowAbove);
+ assertWindowHigher(mImeWindow, mAppWindow);
+ assertWindowHigher(mImeWindow, mDockedDividerWindow);
+ assertWindowHigher(mImeWindow, mStatusBarWindow);
// And, IME dialogs should always have an higher layer than the IME.
- assertWindowLayerGreaterThan(mTransaction, mImeDialogWindow, mImeWindow);
+ assertWindowHigher(mImeDialogWindow, mImeWindow);
}
@Test
public void testStackLayers() throws Exception {
+ final WindowState anyWindow1 = createWindow("anyWindow");
final WindowState pinnedStackWindow = createWindowOnStack(null, WINDOWING_MODE_PINNED,
ACTIVITY_TYPE_STANDARD, TYPE_BASE_APPLICATION, mDisplayContent,
"pinnedStackWindow");
@@ -317,12 +320,17 @@
final WindowState assistantStackWindow = createWindowOnStack(null, WINDOWING_MODE_FULLSCREEN,
ACTIVITY_TYPE_ASSISTANT, TYPE_BASE_APPLICATION,
mDisplayContent, "assistantStackWindow");
+ final WindowState anyWindow2 = createWindow("anyWindow2");
mDisplayContent.assignChildLayers(mTransaction);
- assertWindowLayerGreaterThan(mTransaction, dockedStackWindow, mAppWindow);
- assertWindowLayerGreaterThan(mTransaction, assistantStackWindow, dockedStackWindow);
- assertWindowLayerGreaterThan(mTransaction, pinnedStackWindow, assistantStackWindow);
+ // We compare the split-screen windowing mode to two different normal windowing
+ // mode windows added before and after it to ensure the correct Z ordering irrespective
+ // of ordering in the child list.
+ assertWindowHigher(dockedStackWindow, anyWindow1);
+ assertWindowHigher(dockedStackWindow, anyWindow2);
+ assertWindowHigher(assistantStackWindow, dockedStackWindow);
+ assertWindowHigher(pinnedStackWindow, assistantStackWindow);
}
@Test
@@ -337,9 +345,9 @@
// Ime should be above all app windows and below system windows if it is targeting an app
// window.
- assertWindowLayerGreaterThan(mTransaction, navBarPanel, mNavBarWindow);
- assertWindowLayerGreaterThan(mTransaction, statusBarPanel, mStatusBarWindow);
- assertWindowLayerGreaterThan(mTransaction, statusBarSubPanel, statusBarPanel);
+ assertWindowHigher(navBarPanel, mNavBarWindow);
+ assertWindowHigher(statusBarPanel, mStatusBarWindow);
+ assertWindowHigher(statusBarSubPanel, statusBarPanel);
}
@Test
@@ -347,8 +355,7 @@
// TODO(b/70040778): We should aim to eliminate the last user of TYPE_APPLICATION_MEDIA
// then we can drop all negative layering on the windowing side.
- final WindowState anyWindow =
- createWindow(null, TYPE_BASE_APPLICATION, mDisplayContent, "anyWindow");
+ final WindowState anyWindow = createWindow("anyWindow");
final WindowState child = createWindow(anyWindow, TYPE_APPLICATION_MEDIA, mDisplayContent,
"TypeApplicationMediaChild");
final WindowState mediaOverlayChild = createWindow(anyWindow, TYPE_APPLICATION_MEDIA_OVERLAY,
@@ -356,7 +363,32 @@
mDisplayContent.assignChildLayers(mTransaction);
- assertWindowLayerGreaterThan(mTransaction, anyWindow, mediaOverlayChild);
- assertWindowLayerGreaterThan(mTransaction, mediaOverlayChild, child);
+ assertWindowHigher(anyWindow, mediaOverlayChild);
+ assertWindowHigher(mediaOverlayChild, child);
+ }
+
+ @Test
+ public void testDockedDividerPosition() throws Exception {
+ final WindowState pinnedStackWindow = createWindowOnStack(null, WINDOWING_MODE_PINNED,
+ ACTIVITY_TYPE_STANDARD, TYPE_BASE_APPLICATION, mDisplayContent,
+ "pinnedStackWindow");
+ final WindowState splitScreenWindow = createWindowOnStack(null,
+ WINDOWING_MODE_SPLIT_SCREEN_PRIMARY, ACTIVITY_TYPE_STANDARD, TYPE_BASE_APPLICATION,
+ mDisplayContent, "splitScreenWindow");
+ final WindowState splitScreenSecondaryWindow = createWindowOnStack(null,
+ WINDOWING_MODE_SPLIT_SCREEN_SECONDARY, ACTIVITY_TYPE_STANDARD,
+ TYPE_BASE_APPLICATION, mDisplayContent, "splitScreenSecondaryWindow");
+ final WindowState assistantStackWindow = createWindowOnStack(null, WINDOWING_MODE_FULLSCREEN,
+ ACTIVITY_TYPE_ASSISTANT, TYPE_BASE_APPLICATION,
+ mDisplayContent, "assistantStackWindow");
+ final WindowState dockedDividerWindow = createWindow(null, TYPE_DOCK_DIVIDER,
+ mDisplayContent, "dockedDivider");
+
+ mDisplayContent.assignChildLayers(mTransaction);
+
+ assertWindowHigher(dockedDividerWindow, splitScreenWindow);
+ assertWindowHigher(dockedDividerWindow, splitScreenSecondaryWindow);
+ assertWindowHigher(assistantStackWindow, dockedDividerWindow);
+ assertWindowHigher(pinnedStackWindow, dockedDividerWindow);
}
}
diff --git a/services/usage/java/com/android/server/usage/AppStandbyController.java b/services/usage/java/com/android/server/usage/AppStandbyController.java
index 9b588fa..e0970f2 100644
--- a/services/usage/java/com/android/server/usage/AppStandbyController.java
+++ b/services/usage/java/com/android/server/usage/AppStandbyController.java
@@ -36,7 +36,6 @@
import android.app.admin.DevicePolicyManager;
import android.app.usage.UsageStatsManager.StandbyBuckets;
import android.app.usage.UsageEvents;
-import android.app.usage.UsageStatsManager;
import android.app.usage.UsageStatsManagerInternal.AppIdleStateChangeListener;
import android.appwidget.AppWidgetManager;
import android.content.BroadcastReceiver;
@@ -82,6 +81,8 @@
import java.io.File;
import java.io.PrintWriter;
+import java.time.Duration;
+import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@@ -1278,10 +1279,10 @@
synchronized (mAppIdleLock) {
// Default: 24 hours between paroles
- mAppIdleParoleIntervalMillis = mParser.getLong(KEY_PAROLE_INTERVAL,
+ mAppIdleParoleIntervalMillis = mParser.getDurationMillis(KEY_PAROLE_INTERVAL,
COMPRESS_TIME ? ONE_MINUTE * 10 : 24 * 60 * ONE_MINUTE);
- mAppIdleParoleDurationMillis = mParser.getLong(KEY_PAROLE_DURATION,
+ mAppIdleParoleDurationMillis = mParser.getDurationMillis(KEY_PAROLE_DURATION,
COMPRESS_TIME ? ONE_MINUTE : 10 * ONE_MINUTE); // 10 minutes
String screenThresholdsValue = mParser.getString(KEY_SCREEN_TIME_THRESHOLDS, null);
@@ -1308,7 +1309,15 @@
if (thresholds.length == THRESHOLD_BUCKETS.length) {
long[] array = new long[THRESHOLD_BUCKETS.length];
for (int i = 0; i < THRESHOLD_BUCKETS.length; i++) {
- array[i] = Long.parseLong(thresholds[i]);
+ try {
+ if (thresholds[i].startsWith("P") || thresholds[i].startsWith("p")) {
+ array[i] = Duration.parse(thresholds[i]).toMillis();
+ } else {
+ array[i] = Long.parseLong(thresholds[i]);
+ }
+ } catch (NumberFormatException|DateTimeParseException e) {
+ return defaults;
+ }
}
return array;
} else {
diff --git a/services/usage/java/com/android/server/usage/StorageStatsService.java b/services/usage/java/com/android/server/usage/StorageStatsService.java
index 82f8001..2fec20a 100644
--- a/services/usage/java/com/android/server/usage/StorageStatsService.java
+++ b/services/usage/java/com/android/server/usage/StorageStatsService.java
@@ -49,6 +49,7 @@
import android.provider.Settings;
import android.text.format.DateUtils;
import android.util.ArrayMap;
+import android.util.DataUnit;
import android.util.Slog;
import android.util.SparseLongArray;
@@ -73,7 +74,7 @@
private static final String PROP_VERIFY_STORAGE = "fw.verify_storage";
private static final long DELAY_IN_MILLIS = 30 * DateUtils.SECOND_IN_MILLIS;
- private static final long DEFAULT_QUOTA = 64 * TrafficStats.MB_IN_BYTES;
+ private static final long DEFAULT_QUOTA = DataUnit.MEBIBYTES.toBytes(64);
public static class Lifecycle extends SystemService {
private StorageStatsService mService;
@@ -167,8 +168,11 @@
public boolean isReservedSupported(String volumeUuid, String callingPackage) {
enforcePermission(Binder.getCallingUid(), callingPackage);
- // TODO: implement as part of b/62024591
- return false;
+ if (volumeUuid == StorageManager.UUID_PRIVATE_INTERNAL) {
+ return SystemProperties.getBoolean(StorageManager.PROP_HAS_RESERVED, false);
+ } else {
+ return false;
+ }
}
@Override
diff --git a/telephony/java/android/telephony/CarrierConfigManager.java b/telephony/java/android/telephony/CarrierConfigManager.java
index 6a47d05..6b40e7f 100644
--- a/telephony/java/android/telephony/CarrierConfigManager.java
+++ b/telephony/java/android/telephony/CarrierConfigManager.java
@@ -1724,6 +1724,15 @@
*/
public static final String KEY_CARRIER_CONFIG_APPLIED_BOOL = "carrier_config_applied_bool";
+ /**
+ * Determines whether we should show a warning asking the user to check with their carrier
+ * on pricing when the user enabled data roaming.
+ * default to false.
+ * @hide
+ */
+ public static final String KEY_CHECK_PRICING_WITH_CARRIER_FOR_DATA_ROAMING_BOOL =
+ "check_pricing_with_carrier_data_roaming_bool";
+
/** The default value for every variable. */
private final static PersistableBundle sDefaults;
@@ -2010,6 +2019,7 @@
sDefaults.putBoolean(KEY_SPN_DISPLAY_RULE_USE_ROAMING_FROM_SERVICE_STATE_BOOL, false);
sDefaults.putBoolean(KEY_ALWAYS_SHOW_DATA_RAT_ICON_BOOL, false);
sDefaults.putBoolean(KEY_CARRIER_CONFIG_APPLIED_BOOL, false);
+ sDefaults.putBoolean(KEY_CHECK_PRICING_WITH_CARRIER_FOR_DATA_ROAMING_BOOL, false);
}
/**
diff --git a/telephony/java/android/telephony/SubscriptionManager.java b/telephony/java/android/telephony/SubscriptionManager.java
index a494799..2396a9e 100644
--- a/telephony/java/android/telephony/SubscriptionManager.java
+++ b/telephony/java/android/telephony/SubscriptionManager.java
@@ -548,7 +548,8 @@
*/
@Deprecated
public static SubscriptionManager from(Context context) {
- return context.getSystemService(SubscriptionManager.class);
+ return (SubscriptionManager) context
+ .getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
}
/**
diff --git a/telephony/java/android/telephony/euicc/EuiccManager.java b/telephony/java/android/telephony/euicc/EuiccManager.java
index 176057d..9b114a8 100644
--- a/telephony/java/android/telephony/euicc/EuiccManager.java
+++ b/telephony/java/android/telephony/euicc/EuiccManager.java
@@ -251,8 +251,8 @@
*
* @return the status of eUICC OTA. If {@link #isEnabled()} is false or the eUICC is not ready,
* {@link OtaStatus#EUICC_OTA_STATUS_UNAVAILABLE} will be returned.
+ * TODO(b/35851809): Make this a SystemApi.
*/
- @SystemApi
public int getOtaStatus() {
if (!isEnabled()) {
return EUICC_OTA_STATUS_UNAVAILABLE;
diff --git a/test-base/Android.mk b/test-base/Android.mk
index 5e5d040..8613854 100644
--- a/test-base/Android.mk
+++ b/test-base/Android.mk
@@ -112,17 +112,6 @@
endif # not TARGET_BUILD_APPS not TARGET_BUILD_PDK=true
-# Build the legacy.test.stubs library
-# ===================================
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := legacy.test.stubs
-LOCAL_SDK_VERSION := current
-
-LOCAL_STATIC_JAVA_LIBRARIES := android.test.base.stubs
-
-include $(BUILD_STATIC_JAVA_LIBRARY)
-
ifeq ($(HOST_OS),linux)
# Build the legacy-performance-test-hostdex library
# =================================================
diff --git a/tests/Camera2Tests/SmartCamera/SimpleCamera/jni/Android.mk b/tests/Camera2Tests/SmartCamera/SimpleCamera/jni/Android.mk
index 088f322..6e0d58a 100644
--- a/tests/Camera2Tests/SmartCamera/SimpleCamera/jni/Android.mk
+++ b/tests/Camera2Tests/SmartCamera/SimpleCamera/jni/Android.mk
@@ -40,6 +40,6 @@
LOCAL_CFLAGS += -Wall -Wextra -Werror -Wno-unused-parameter
-LOCAL_NDK_STL_VARIANT := stlport_static
+LOCAL_NDK_STL_VARIANT := c++_static
include $(BUILD_SHARED_LIBRARY)
diff --git a/tests/DexLoggerIntegrationTests/src/com/android/server/pm/DexLoggerIntegrationTests.java b/tests/DexLoggerIntegrationTests/src/com/android/server/pm/DexLoggerIntegrationTests.java
index d9f34d5..8df7f53 100644
--- a/tests/DexLoggerIntegrationTests/src/com/android/server/pm/DexLoggerIntegrationTests.java
+++ b/tests/DexLoggerIntegrationTests/src/com/android/server/pm/DexLoggerIntegrationTests.java
@@ -57,11 +57,11 @@
@RunWith(JUnit4.class)
public final class DexLoggerIntegrationTests {
- private static final String TAG = DexLoggerIntegrationTests.class.getSimpleName();
-
private static final String PACKAGE_NAME = "com.android.frameworks.dexloggertest";
+ // Event log tag used for SNET related events
private static final int SNET_TAG = 0x534e4554;
+ // Subtag used to distinguish dynamic code loading events
private static final String DCL_SUBTAG = "dcl";
// Obtained via "echo -n copied.jar | sha256sum"
@@ -77,7 +77,8 @@
// Copy the jar from our Java resources to a private data directory
File privateCopy = new File(context.getDir("jars", Context.MODE_PRIVATE), "copied.jar");
- try (InputStream input = DexLoggerIntegrationTests.class.getResourceAsStream("/javalib.jar");
+ Class<?> thisClass = DexLoggerIntegrationTests.class;
+ try (InputStream input = thisClass.getResourceAsStream("/javalib.jar");
OutputStream output = new FileOutputStream(privateCopy)) {
byte[] buffer = new byte[1024];
while (true) {
@@ -112,7 +113,8 @@
// There may already be events in the event log - figure out the most recent one
EventLog.readEvents(tagList, events);
- long previousEventNanos = events.isEmpty() ? 0 : events.get(events.size() - 1).getTimeNanos();
+ long previousEventNanos =
+ events.isEmpty() ? 0 : events.get(events.size() - 1).getTimeNanos();
events.clear();
Process process = Runtime.getRuntime().exec(
diff --git a/tools/aapt2/filter/AbiFilter.h b/tools/aapt2/filter/AbiFilter.h
index d875cb2..2832711 100644
--- a/tools/aapt2/filter/AbiFilter.h
+++ b/tools/aapt2/filter/AbiFilter.h
@@ -33,6 +33,8 @@
*/
class AbiFilter : public IPathFilter {
public:
+ virtual ~AbiFilter() = default;
+
/** Factory method to create a filter from a list of configuration::Abi. */
static std::unique_ptr<AbiFilter> FromAbiList(const std::vector<configuration::Abi>& abi_list);
diff --git a/tools/aapt2/filter/Filter.h b/tools/aapt2/filter/Filter.h
index d737dc9..f932f9c 100644
--- a/tools/aapt2/filter/Filter.h
+++ b/tools/aapt2/filter/Filter.h
@@ -27,7 +27,7 @@
/** A filter to be applied to a path segment. */
class IPathFilter {
public:
- ~IPathFilter() = default;
+ virtual ~IPathFilter() = default;
/** Returns true if the path should be kept. */
virtual bool Keep(const std::string& path) = 0;
diff --git a/tools/incident_section_gen/main.cpp b/tools/incident_section_gen/main.cpp
index 102bbf9..e7b269a 100644
--- a/tools/incident_section_gen/main.cpp
+++ b/tools/incident_section_gen/main.cpp
@@ -408,6 +408,9 @@
splitAndPrint(s.args());
printf(" NULL),\n");
break;
+ case SECTION_LOG:
+ printf(" new LogSection(%d, %s),\n", field->number(), s.args().c_str());
+ break;
}
}
printf(" NULL };\n");
diff --git a/tools/stats_log_api_gen/main.cpp b/tools/stats_log_api_gen/main.cpp
index 89749fb..bbe6d63 100644
--- a/tools/stats_log_api_gen/main.cpp
+++ b/tools/stats_log_api_gen/main.cpp
@@ -166,7 +166,15 @@
attributionDecl.fields.front().name.c_str());
fprintf(out, " event.begin();\n");
for (const auto &chainField : attributionDecl.fields) {
- fprintf(out, " event << %s[i];\n", chainField.name.c_str());
+ if (chainField.javaType == JAVA_TYPE_STRING) {
+ fprintf(out, " if (%s[i] != NULL) {\n", chainField.name.c_str());
+ fprintf(out, " event << %s[i];\n", chainField.name.c_str());
+ fprintf(out, " } else {\n");
+ fprintf(out, " event << \"\";\n");
+ fprintf(out, " }\n");
+ } else {
+ fprintf(out, " event << %s[i];\n", chainField.name.c_str());
+ }
}
fprintf(out, " event.end();\n");
fprintf(out, " }\n");
@@ -589,13 +597,18 @@
fprintf(out, " jstring jstr = "
"(jstring)env->GetObjectArrayElement(%s, i);\n",
chainField.name.c_str());
- fprintf(out, " ScopedUtfChars* scoped_%s = "
+ fprintf(out, " if (jstr == NULL) {\n");
+ fprintf(out, " %s_vec.push_back(NULL);\n",
+ chainField.name.c_str());
+ fprintf(out, " } else {\n");
+ fprintf(out, " ScopedUtfChars* scoped_%s = "
"new ScopedUtfChars(env, jstr);\n",
chainField.name.c_str());
- fprintf(out, " %s_vec.push_back(scoped_%s->c_str());\n",
+ fprintf(out, " %s_vec.push_back(scoped_%s->c_str());\n",
chainField.name.c_str(), chainField.name.c_str());
- fprintf(out, " scoped_%s_vec.push_back(scoped_%s);\n",
+ fprintf(out, " scoped_%s_vec.push_back(scoped_%s);\n",
chainField.name.c_str(), chainField.name.c_str());
+ fprintf(out, " }\n");
fprintf(out, " }\n");
}
fprintf(out, "\n");
@@ -648,7 +661,7 @@
fprintf(out, " env->ReleaseIntArrayElements(%s, %s_array, 0);\n",
chainField.name.c_str(), chainField.name.c_str());
} else if (chainField.javaType == JAVA_TYPE_STRING) {
- fprintf(out, " for (size_t i = 0; i < %s_length; ++i) {\n",
+ fprintf(out, " for (size_t i = 0; i < scoped_%s_vec.size(); ++i) {\n",
chainField.name.c_str());
fprintf(out, " delete scoped_%s_vec[i];\n", chainField.name.c_str());
fprintf(out, " }\n");
diff --git a/wifi/java/android/net/wifi/ScanResult.java b/wifi/java/android/net/wifi/ScanResult.java
index b6ad926..eaad137 100644
--- a/wifi/java/android/net/wifi/ScanResult.java
+++ b/wifi/java/android/net/wifi/ScanResult.java
@@ -21,7 +21,9 @@
import android.os.Parcelable;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
+import java.util.Objects;
/**
* Describes information about a detected access point. In addition
@@ -227,6 +229,50 @@
public long seen;
/**
+ * On devices with multiple hardware radio chains, this class provides metadata about
+ * each radio chain that was used to receive this scan result (probe response or beacon).
+ * {@hide}
+ */
+ public static class RadioChainInfo {
+ /** Vendor defined id for a radio chain. */
+ public int id;
+ /** Detected signal level in dBm (also known as the RSSI) on this radio chain. */
+ public int level;
+
+ @Override
+ public String toString() {
+ return "RadioChainInfo: id=" + id + ", level=" + level;
+ }
+
+ @Override
+ public boolean equals(Object otherObj) {
+ if (this == otherObj) {
+ return true;
+ }
+ if (!(otherObj instanceof RadioChainInfo)) {
+ return false;
+ }
+ RadioChainInfo other = (RadioChainInfo) otherObj;
+ return id == other.id && level == other.level;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(id, level);
+ }
+ };
+
+ /**
+ * Information about the list of the radio chains used to receive this scan result
+ * (probe response or beacon).
+ *
+ * For Example: On devices with 2 hardware radio chains, this list could hold 1 or 2
+ * entries based on whether this scan result was received using one or both the chains.
+ * {@hide}
+ */
+ public RadioChainInfo[] radioChainInfos;
+
+ /**
* @hide
* Update RSSI of the scan result
* @param previousRssi
@@ -481,6 +527,7 @@
this.isCarrierAp = false;
this.carrierApEapType = UNSPECIFIED;
this.carrierName = null;
+ this.radioChainInfos = null;
}
/** {@hide} */
@@ -502,6 +549,7 @@
this.isCarrierAp = false;
this.carrierApEapType = UNSPECIFIED;
this.carrierName = null;
+ this.radioChainInfos = null;
}
/** {@hide} */
@@ -530,6 +578,7 @@
this.isCarrierAp = false;
this.carrierApEapType = UNSPECIFIED;
this.carrierName = null;
+ this.radioChainInfos = null;
}
/** {@hide} */
@@ -572,6 +621,7 @@
isCarrierAp = source.isCarrierAp;
carrierApEapType = source.carrierApEapType;
carrierName = source.carrierName;
+ radioChainInfos = source.radioChainInfos;
}
}
@@ -615,6 +665,7 @@
sb.append(", Carrier AP: ").append(isCarrierAp ? "yes" : "no");
sb.append(", Carrier AP EAP Type: ").append(carrierApEapType);
sb.append(", Carrier name: ").append(carrierName);
+ sb.append(", Radio Chain Infos: ").append(Arrays.toString(radioChainInfos));
return sb.toString();
}
@@ -687,6 +738,16 @@
dest.writeInt(isCarrierAp ? 1 : 0);
dest.writeInt(carrierApEapType);
dest.writeString(carrierName);
+
+ if (radioChainInfos != null) {
+ dest.writeInt(radioChainInfos.length);
+ for (int i = 0; i < radioChainInfos.length; i++) {
+ dest.writeInt(radioChainInfos[i].id);
+ dest.writeInt(radioChainInfos[i].level);
+ }
+ } else {
+ dest.writeInt(0);
+ }
}
/** Implement the Parcelable interface {@hide} */
@@ -759,6 +820,15 @@
sr.isCarrierAp = in.readInt() != 0;
sr.carrierApEapType = in.readInt();
sr.carrierName = in.readString();
+ n = in.readInt();
+ if (n != 0) {
+ sr.radioChainInfos = new RadioChainInfo[n];
+ for (int i = 0; i < n; i++) {
+ sr.radioChainInfos[i] = new RadioChainInfo();
+ sr.radioChainInfos[i].id = in.readInt();
+ sr.radioChainInfos[i].level = in.readInt();
+ }
+ }
return sr;
}
diff --git a/wifi/tests/src/android/net/wifi/ScanResultTest.java b/wifi/tests/src/android/net/wifi/ScanResultTest.java
new file mode 100644
index 0000000..689ebba
--- /dev/null
+++ b/wifi/tests/src/android/net/wifi/ScanResultTest.java
@@ -0,0 +1,193 @@
+/*
+ * 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.net.wifi;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.validateMockitoUsage;
+
+import android.os.Parcel;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.net.wifi.WifiScanner.ScanSettings;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.MockitoAnnotations;
+
+
+/**
+ * Unit tests for {@link android.net.wifi.WifiScanner}.
+ */
+@SmallTest
+public class ScanResultTest {
+ public static final String TEST_SSID = "\"test_ssid\"";
+ public static final String TEST_BSSID = "04:ac:fe:45:34:10";
+ public static final String TEST_CAPS = "CCMP";
+ public static final int TEST_LEVEL = -56;
+ public static final int TEST_FREQUENCY = 2412;
+ public static final long TEST_TSF = 04660l;
+
+ /**
+ * Setup before tests.
+ */
+ @Before
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ }
+
+ /**
+ * Clean up after tests.
+ */
+ @After
+ public void cleanup() {
+ validateMockitoUsage();
+ }
+
+ /**
+ * Verify parcel read/write for ScanResult.
+ */
+ @Test
+ public void verifyScanResultParcelWithoutRadioChainInfo() throws Exception {
+ ScanResult writeScanResult = createScanResult();
+ ScanResult readScanResult = parcelReadWrite(writeScanResult);
+ assertScanResultEquals(writeScanResult, readScanResult);
+ }
+
+ /**
+ * Verify parcel read/write for ScanResult.
+ */
+ @Test
+ public void verifyScanResultParcelWithZeroRadioChainInfo() throws Exception {
+ ScanResult writeScanResult = createScanResult();
+ writeScanResult.radioChainInfos = new ScanResult.RadioChainInfo[0];
+ ScanResult readScanResult = parcelReadWrite(writeScanResult);
+ assertNull(readScanResult.radioChainInfos);
+ }
+
+ /**
+ * Verify parcel read/write for ScanResult.
+ */
+ @Test
+ public void verifyScanResultParcelWithRadioChainInfo() throws Exception {
+ ScanResult writeScanResult = createScanResult();
+ writeScanResult.radioChainInfos = new ScanResult.RadioChainInfo[2];
+ writeScanResult.radioChainInfos[0] = new ScanResult.RadioChainInfo();
+ writeScanResult.radioChainInfos[0].id = 0;
+ writeScanResult.radioChainInfos[0].level = -45;
+ writeScanResult.radioChainInfos[1] = new ScanResult.RadioChainInfo();
+ writeScanResult.radioChainInfos[1].id = 1;
+ writeScanResult.radioChainInfos[1].level = -54;
+ ScanResult readScanResult = parcelReadWrite(writeScanResult);
+ assertScanResultEquals(writeScanResult, readScanResult);
+ }
+
+ /**
+ * Verify copy constructor for ScanResult.
+ */
+ @Test
+ public void verifyScanResultCopyWithoutRadioChainInfo() throws Exception {
+ ScanResult scanResult = createScanResult();
+ ScanResult copyScanResult = new ScanResult(scanResult);
+ assertScanResultEquals(scanResult, copyScanResult);
+ }
+
+ /**
+ * Verify copy constructor for ScanResult.
+ */
+ @Test
+ public void verifyScanResultCopyWithRadioChainInfo() throws Exception {
+ ScanResult scanResult = createScanResult();
+ scanResult.radioChainInfos = new ScanResult.RadioChainInfo[2];
+ scanResult.radioChainInfos[0] = new ScanResult.RadioChainInfo();
+ scanResult.radioChainInfos[0].id = 0;
+ scanResult.radioChainInfos[0].level = -45;
+ scanResult.radioChainInfos[1] = new ScanResult.RadioChainInfo();
+ scanResult.radioChainInfos[1].id = 1;
+ scanResult.radioChainInfos[1].level = -54;
+ ScanResult copyScanResult = new ScanResult(scanResult);
+ assertScanResultEquals(scanResult, copyScanResult);
+ }
+
+ /**
+ * Verify toString for ScanResult.
+ */
+ @Test
+ public void verifyScanResultToStringWithoutRadioChainInfo() throws Exception {
+ ScanResult scanResult = createScanResult();
+ assertEquals("SSID: \"test_ssid\", BSSID: 04:ac:fe:45:34:10, capabilities: CCMP, " +
+ "level: -56, frequency: 2412, timestamp: 2480, distance: 0(cm), distanceSd: 0(cm), " +
+ "passpoint: no, ChannelBandwidth: 0, centerFreq0: 0, centerFreq1: 0, " +
+ "80211mcResponder: is not supported, Carrier AP: no, " +
+ "Carrier AP EAP Type: 0, Carrier name: null, " +
+ "Radio Chain Infos: null", scanResult.toString());
+ }
+
+ /**
+ * Verify toString for ScanResult.
+ */
+ @Test
+ public void verifyScanResultToStringWithRadioChainInfo() throws Exception {
+ ScanResult scanResult = createScanResult();
+ scanResult.radioChainInfos = new ScanResult.RadioChainInfo[2];
+ scanResult.radioChainInfos[0] = new ScanResult.RadioChainInfo();
+ scanResult.radioChainInfos[0].id = 0;
+ scanResult.radioChainInfos[0].level = -45;
+ scanResult.radioChainInfos[1] = new ScanResult.RadioChainInfo();
+ scanResult.radioChainInfos[1].id = 1;
+ scanResult.radioChainInfos[1].level = -54;
+ assertEquals("SSID: \"test_ssid\", BSSID: 04:ac:fe:45:34:10, capabilities: CCMP, " +
+ "level: -56, frequency: 2412, timestamp: 2480, distance: 0(cm), distanceSd: 0(cm), " +
+ "passpoint: no, ChannelBandwidth: 0, centerFreq0: 0, centerFreq1: 0, " +
+ "80211mcResponder: is not supported, Carrier AP: no, " +
+ "Carrier AP EAP Type: 0, Carrier name: null, " +
+ "Radio Chain Infos: [RadioChainInfo: id=0, level=-45, " +
+ "RadioChainInfo: id=1, level=-54]", scanResult.toString());
+ }
+
+ /**
+ * Write the provided {@link ScanResult} to a parcel and deserialize it.
+ */
+ private static ScanResult parcelReadWrite(ScanResult writeResult) throws Exception {
+ Parcel parcel = Parcel.obtain();
+ writeResult.writeToParcel(parcel, 0);
+ parcel.setDataPosition(0); // Rewind data position back to the beginning for read.
+ return ScanResult.CREATOR.createFromParcel(parcel);
+ }
+
+ private static ScanResult createScanResult() {
+ ScanResult result = new ScanResult();
+ result.wifiSsid = WifiSsid.createFromAsciiEncoded(TEST_SSID);
+ result.BSSID = TEST_BSSID;
+ result.capabilities = TEST_CAPS;
+ result.level = TEST_LEVEL;
+ result.frequency = TEST_FREQUENCY;
+ result.timestamp = TEST_TSF;
+ return result;
+ }
+
+ private static void assertScanResultEquals(ScanResult expected, ScanResult actual) {
+ assertEquals(expected.SSID, actual.SSID);
+ assertEquals(expected.BSSID, actual.BSSID);
+ assertEquals(expected.capabilities, actual.capabilities);
+ assertEquals(expected.level, actual.level);
+ assertEquals(expected.frequency, actual.frequency);
+ assertEquals(expected.timestamp, actual.timestamp);
+ assertArrayEquals(expected.radioChainInfos, actual.radioChainInfos);
+ }
+}