Merge "Add flag to intent in AccountAccessSameCertTest"
diff --git a/hostsidetests/security/src/android/security/cts/SELinuxHostTest.java b/hostsidetests/security/src/android/security/cts/SELinuxHostTest.java
index c005749..a75352c 100644
--- a/hostsidetests/security/src/android/security/cts/SELinuxHostTest.java
+++ b/hostsidetests/security/src/android/security/cts/SELinuxHostTest.java
@@ -719,6 +719,15 @@
}
/**
+ * Tests that all types on /vendor have the vendor_file_type attribute.
+ *
+ * @throws Exception
+ */
+ public void testVendorTypeViolators() throws Exception {
+ assertSepolicyTests("TestVendorTypeViolations", "/sepolicy_tests");
+ }
+
+ /**
* Tests that all domains with entrypoints on /system have the coredomain
* attribute, and that all domains with entrypoints on /vendor do not have the
* coredomain attribute.
diff --git a/tests/camera/src/android/hardware/camera2/cts/CaptureResultTest.java b/tests/camera/src/android/hardware/camera2/cts/CaptureResultTest.java
index 3857b93..f84d520 100644
--- a/tests/camera/src/android/hardware/camera2/cts/CaptureResultTest.java
+++ b/tests/camera/src/android/hardware/camera2/cts/CaptureResultTest.java
@@ -426,6 +426,10 @@
result.get(CaptureResult.NOISE_REDUCTION_MODE));
} else if (key.equals(CaptureResult.REQUEST_PIPELINE_DEPTH)) {
+ } else if (key.equals(CaptureResult.STATISTICS_OIS_DATA_MODE)) {
+ mCollector.expectEquals(msg,
+ requestBuilder.get(CaptureRequest.STATISTICS_OIS_DATA_MODE),
+ result.get(CaptureResult.STATISTICS_OIS_DATA_MODE));
} else {
// Only do non-null check for the rest of keys.
mCollector.expectKeyValueNotNull(failMsg, result, key);
@@ -539,6 +543,13 @@
waiverKeys.add(CaptureResult.CONTROL_AF_SCENE_CHANGE);
}
+ if (!mStaticInfo.isOisDataModeSupported()) {
+ waiverKeys.add(CaptureResult.STATISTICS_OIS_DATA_MODE);
+ waiverKeys.add(CaptureResult.STATISTICS_OIS_TIMESTAMPS);
+ waiverKeys.add(CaptureResult.STATISTICS_OIS_X_SHIFTS);
+ waiverKeys.add(CaptureResult.STATISTICS_OIS_Y_SHIFTS);
+ }
+
if (mStaticInfo.isHardwareLevelAtLeastFull()) {
return waiverKeys;
}
@@ -818,6 +829,10 @@
resultKeys.add(CaptureResult.STATISTICS_SCENE_FLICKER);
resultKeys.add(CaptureResult.STATISTICS_HOT_PIXEL_MAP);
resultKeys.add(CaptureResult.STATISTICS_LENS_SHADING_MAP_MODE);
+ resultKeys.add(CaptureResult.STATISTICS_OIS_DATA_MODE);
+ resultKeys.add(CaptureResult.STATISTICS_OIS_TIMESTAMPS);
+ resultKeys.add(CaptureResult.STATISTICS_OIS_X_SHIFTS);
+ resultKeys.add(CaptureResult.STATISTICS_OIS_Y_SHIFTS);
resultKeys.add(CaptureResult.TONEMAP_CURVE);
resultKeys.add(CaptureResult.TONEMAP_MODE);
resultKeys.add(CaptureResult.TONEMAP_GAMMA);
diff --git a/tests/camera/src/android/hardware/camera2/cts/RobustnessTest.java b/tests/camera/src/android/hardware/camera2/cts/RobustnessTest.java
index 54405a4..fc8b187 100644
--- a/tests/camera/src/android/hardware/camera2/cts/RobustnessTest.java
+++ b/tests/camera/src/android/hardware/camera2/cts/RobustnessTest.java
@@ -1016,6 +1016,83 @@
}
}
+ public void testOisDataMode() throws Exception {
+ final int NUM_FRAMES_VERIFIED = 3;
+
+ for (String id : mCameraIds) {
+ Log.i(TAG, String.format("Testing Camera %s for OIS mode", id));
+
+ StaticMetadata staticInfo =
+ new StaticMetadata(mCameraManager.getCameraCharacteristics(id));
+ if (!staticInfo.isOisDataModeSupported()) {
+ continue;
+ }
+
+ openDevice(id);
+
+ try {
+ SurfaceTexture preview = new SurfaceTexture(/*random int*/ 1);
+ Surface previewSurface = new Surface(preview);
+
+ CaptureRequest.Builder previewRequest = preparePreviewTestSession(preview);
+ SimpleCaptureCallback previewListener = new CameraTestUtils.SimpleCaptureCallback();
+
+ int[] availableOisDataModes = staticInfo.getCharacteristics().get(
+ CameraCharacteristics.STATISTICS_INFO_AVAILABLE_OIS_DATA_MODES);
+
+ // Test each OIS data mode
+ for (int oisMode : availableOisDataModes) {
+ previewRequest.set(CaptureRequest.STATISTICS_OIS_DATA_MODE, oisMode);
+
+ int sequenceId = mCameraSession.setRepeatingRequest(previewRequest.build(),
+ previewListener, mHandler);
+
+ // Check OIS data in each mode.
+ for (int i = 0; i < NUM_FRAMES_VERIFIED; i++) {
+ TotalCaptureResult result =
+ previewListener.getTotalCaptureResult(CAPTURE_TIMEOUT);
+
+ long[] oisTimestamps = result.get(CaptureResult.STATISTICS_OIS_TIMESTAMPS);
+ float[] oisXShifts = result.get(CaptureResult.STATISTICS_OIS_X_SHIFTS);
+ float[] oisYShifts = result.get(CaptureResult.STATISTICS_OIS_Y_SHIFTS);
+
+ if (oisMode == CameraCharacteristics.STATISTICS_OIS_DATA_MODE_OFF) {
+ mCollector.expectKeyValueEquals(result,
+ CaptureResult.STATISTICS_OIS_DATA_MODE,
+ CaptureResult.STATISTICS_OIS_DATA_MODE_OFF);
+ mCollector.expectTrue("OIS timestamps reported in OIS_DATA_MODE_OFF",
+ oisTimestamps == null || oisTimestamps.length == 0);
+ mCollector.expectTrue("OIS x shifts reported in OIS_DATA_MODE_OFF",
+ oisXShifts == null || oisXShifts.length == 0);
+ mCollector.expectTrue("OIS y shifts reported in OIS_DATA_MODE_OFF",
+ oisYShifts == null || oisYShifts.length == 0);
+
+ } else if (oisMode == CameraCharacteristics.STATISTICS_OIS_DATA_MODE_ON) {
+ mCollector.expectKeyValueEquals(result,
+ CaptureResult.STATISTICS_OIS_DATA_MODE,
+ CaptureResult.STATISTICS_OIS_DATA_MODE_ON);
+ mCollector.expectTrue("OIS timestamps not reported in OIS_DATA_MODE_ON",
+ oisTimestamps != null && oisTimestamps.length != 0);
+ mCollector.expectTrue(
+ "Number of x shifts doesn't match number of OIS timetamps.",
+ oisXShifts != null && oisXShifts.length == oisTimestamps.length);
+ mCollector.expectTrue(
+ "Number of y shifts doesn't match number of OIS timetamps.",
+ oisYShifts != null && oisYShifts.length == oisTimestamps.length);
+ } else {
+ mCollector.addMessage(String.format("Invalid OIS mode: %d", oisMode));
+ }
+ }
+
+ mCameraSession.stopRepeating();
+ previewListener.getCaptureSequenceLastFrameNumber(sequenceId, CAPTURE_TIMEOUT);
+ previewListener.drain();
+ }
+ } finally {
+ closeDevice(id);
+ }
+ }
+ }
private CaptureRequest.Builder preparePreviewTestSession(SurfaceTexture preview)
throws Exception {
diff --git a/tests/camera/utils/src/android/hardware/camera2/cts/helpers/StaticMetadata.java b/tests/camera/utils/src/android/hardware/camera2/cts/helpers/StaticMetadata.java
index 3c551f8..5921dda 100644
--- a/tests/camera/utils/src/android/hardware/camera2/cts/helpers/StaticMetadata.java
+++ b/tests/camera/utils/src/android/hardware/camera2/cts/helpers/StaticMetadata.java
@@ -2265,6 +2265,26 @@
}
/**
+ * Check if OIS data mode is supported.
+ */
+ public boolean isOisDataModeSupported() {
+ int[] availableOisDataModes = mCharacteristics.get(
+ CameraCharacteristics.STATISTICS_INFO_AVAILABLE_OIS_DATA_MODES);
+
+ if (availableOisDataModes == null) {
+ return false;
+ }
+
+ for (int mode : availableOisDataModes) {
+ if (mode == CameraMetadata.STATISTICS_OIS_DATA_MODE_ON) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
* Get the value in index for a fixed-size array from a given key.
*
* <p>If the camera device is incorrectly reporting values, log a warning and return
diff --git a/tests/tests/media/src/android/media/cts/MediaScannerTest.java b/tests/tests/media/src/android/media/cts/MediaScannerTest.java
index 401e2d5..4a1dc09 100644
--- a/tests/tests/media/src/android/media/cts/MediaScannerTest.java
+++ b/tests/tests/media/src/android/media/cts/MediaScannerTest.java
@@ -391,11 +391,21 @@
mMediaScannerConnection.connect();
checkConnectionState(true);
+ // test unlocalizable file
+ canonicalizeTest(R.raw.testmp3);
+
+ mMediaScannerConnectionClient.reset();
+
+ // test localizable file
+ canonicalizeTest(R.raw.testmp3_4);
+ }
+
+ private void canonicalizeTest(int resId) throws Exception {
// write file and scan to insert into database
String fileDir = Environment.getExternalStorageDirectory() + "/"
+ getClass().getCanonicalName() + "/canonicaltest-" + System.currentTimeMillis();
String fileName = fileDir + "/test.mp3";
- writeFile(R.raw.testmp3, fileName);
+ writeFile(resId, fileName);
mMediaScannerConnection.scanFile(fileName, MEDIA_TYPE);
checkMediaScannerConnection();
@@ -420,7 +430,7 @@
// write same file again and scan to insert into database
mMediaScannerConnectionClient.reset();
String fileName2 = fileDir + "/test2.mp3";
- writeFile(R.raw.testmp3, fileName2);
+ writeFile(resId, fileName2);
mMediaScannerConnection.scanFile(fileName2, MEDIA_TYPE);
checkMediaScannerConnection();
diff --git a/tests/tests/nativemedia/aaudio/jni/Android.mk b/tests/tests/nativemedia/aaudio/jni/Android.mk
index c6f0902..9795b70 100644
--- a/tests/tests/nativemedia/aaudio/jni/Android.mk
+++ b/tests/tests/nativemedia/aaudio/jni/Android.mk
@@ -22,6 +22,7 @@
LOCAL_SRC_FILES := \
test_aaudio.cpp \
+ test_aaudio_attributes.cpp \
test_aaudio_callback.cpp \
test_aaudio_mmap.cpp \
test_aaudio_misc.cpp \
diff --git a/tests/tests/nativemedia/aaudio/jni/test_aaudio_attributes.cpp b/tests/tests/nativemedia/aaudio/jni/test_aaudio_attributes.cpp
new file mode 100644
index 0000000..6143613
--- /dev/null
+++ b/tests/tests/nativemedia/aaudio/jni/test_aaudio_attributes.cpp
@@ -0,0 +1,179 @@
+/*
+ * 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.
+ */
+
+// Test AAudio attributes such as Usage, ContentType and InputPreset.
+
+#include <stdio.h>
+#include <unistd.h>
+
+#include <aaudio/AAudio.h>
+#include <gtest/gtest.h>
+
+constexpr int64_t kNanosPerSecond = 1000000000;
+constexpr int kNumFrames = 256;
+constexpr int kChannelCount = 2;
+
+constexpr int32_t DONT_SET = -1000;
+
+static void checkAttributes(aaudio_performance_mode_t perfMode,
+ aaudio_usage_t usage,
+ aaudio_content_type_t contentType,
+ aaudio_input_preset_t preset = DONT_SET,
+ aaudio_direction_t direction = AAUDIO_DIRECTION_OUTPUT) {
+
+ float *buffer = new float[kNumFrames * kChannelCount];
+
+ AAudioStreamBuilder *aaudioBuilder = nullptr;
+ AAudioStream *aaudioStream = nullptr;
+
+ // Use an AAudioStreamBuilder to contain requested parameters.
+ ASSERT_EQ(AAUDIO_OK, AAudio_createStreamBuilder(&aaudioBuilder));
+
+ // Request stream properties.
+ AAudioStreamBuilder_setPerformanceMode(aaudioBuilder, perfMode);
+ AAudioStreamBuilder_setDirection(aaudioBuilder, direction);
+
+ // Set the attribute in the builder.
+ if (usage != DONT_SET) {
+ AAudioStreamBuilder_setUsage(aaudioBuilder, usage);
+ }
+ if (contentType != DONT_SET) {
+ AAudioStreamBuilder_setContentType(aaudioBuilder, contentType);
+ }
+ if (preset != DONT_SET) {
+ AAudioStreamBuilder_setInputPreset(aaudioBuilder, preset);
+ }
+
+ // Create an AAudioStream using the Builder.
+ ASSERT_EQ(AAUDIO_OK, AAudioStreamBuilder_openStream(aaudioBuilder, &aaudioStream));
+ AAudioStreamBuilder_delete(aaudioBuilder);
+
+ // Make sure we get the same attributes back from the stream.
+ aaudio_usage_t expectedUsage =
+ (usage == DONT_SET || usage == AAUDIO_UNSPECIFIED)
+ ? AAUDIO_USAGE_MEDIA // default
+ : usage;
+ EXPECT_EQ(expectedUsage, AAudioStream_getUsage(aaudioStream));
+
+ aaudio_content_type_t expectedContentType =
+ (contentType == DONT_SET || contentType == AAUDIO_UNSPECIFIED)
+ ? AAUDIO_CONTENT_TYPE_MUSIC // default
+ : contentType;
+ EXPECT_EQ(expectedContentType, AAudioStream_getContentType(aaudioStream));
+
+ aaudio_input_preset_t expectedPreset =
+ (preset == DONT_SET || preset == AAUDIO_UNSPECIFIED)
+ ? AAUDIO_INPUT_PRESET_VOICE_RECOGNITION // default
+ : preset;
+ EXPECT_EQ(expectedPreset, AAudioStream_getInputPreset(aaudioStream));
+
+ EXPECT_EQ(AAUDIO_OK, AAudioStream_requestStart(aaudioStream));
+
+ if (direction == AAUDIO_DIRECTION_INPUT) {
+ EXPECT_EQ(kNumFrames,
+ AAudioStream_read(aaudioStream, buffer, kNumFrames, kNanosPerSecond));
+ } else {
+ EXPECT_EQ(kNumFrames,
+ AAudioStream_write(aaudioStream, buffer, kNumFrames, kNanosPerSecond));
+ }
+
+ EXPECT_EQ(AAUDIO_OK, AAudioStream_requestStop(aaudioStream));
+
+ EXPECT_EQ(AAUDIO_OK, AAudioStream_close(aaudioStream));
+ delete[] buffer;
+}
+
+static const aaudio_usage_t sUsages[] = {
+ DONT_SET,
+ AAUDIO_UNSPECIFIED,
+ AAUDIO_USAGE_MEDIA,
+ AAUDIO_USAGE_VOICE_COMMUNICATION,
+ AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING,
+ AAUDIO_USAGE_ALARM,
+ AAUDIO_USAGE_NOTIFICATION,
+ AAUDIO_USAGE_NOTIFICATION_RINGTONE,
+ AAUDIO_USAGE_NOTIFICATION_EVENT,
+ AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY,
+ AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
+ AAUDIO_USAGE_ASSISTANCE_SONIFICATION,
+ AAUDIO_USAGE_GAME,
+ AAUDIO_USAGE_ASSISTANT
+};
+
+static const aaudio_content_type_t sContentypes[] = {
+ DONT_SET,
+ AAUDIO_UNSPECIFIED,
+ AAUDIO_CONTENT_TYPE_SPEECH,
+ AAUDIO_CONTENT_TYPE_MUSIC,
+ AAUDIO_CONTENT_TYPE_MOVIE,
+ AAUDIO_CONTENT_TYPE_SONIFICATION
+};
+
+static const aaudio_input_preset_t sInputPresets[] = {
+ DONT_SET,
+ AAUDIO_UNSPECIFIED,
+ AAUDIO_INPUT_PRESET_GENERIC,
+ AAUDIO_INPUT_PRESET_CAMCORDER,
+ AAUDIO_INPUT_PRESET_VOICE_RECOGNITION,
+ AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION,
+ AAUDIO_INPUT_PRESET_UNPROCESSED,
+};
+
+static void checkAttributesUsage(aaudio_performance_mode_t perfMode) {
+ for (aaudio_usage_t usage : sUsages) {
+ checkAttributes(perfMode, usage, DONT_SET);
+ }
+}
+
+static void checkAttributesContentType(aaudio_input_preset_t perfMode) {
+ for (aaudio_content_type_t contentType : sContentypes) {
+ checkAttributes(perfMode, DONT_SET, contentType);
+ }
+}
+
+static void checkAttributesInputPreset(aaudio_performance_mode_t perfMode) {
+ for (aaudio_input_preset_t inputPreset : sInputPresets) {
+ checkAttributes(perfMode,
+ DONT_SET,
+ DONT_SET,
+ inputPreset,
+ AAUDIO_DIRECTION_INPUT);
+ }
+}
+
+TEST(test_attributes, aaudio_usage_perfnone) {
+ checkAttributesUsage(AAUDIO_PERFORMANCE_MODE_NONE);
+}
+
+TEST(test_attributes, aaudio_content_type_perfnone) {
+ checkAttributesContentType(AAUDIO_PERFORMANCE_MODE_NONE);
+}
+
+TEST(test_attributes, aaudio_input_preset_perfnone) {
+ checkAttributesInputPreset(AAUDIO_PERFORMANCE_MODE_NONE);
+}
+
+TEST(test_attributes, aaudio_usage_lowlat) {
+ checkAttributesUsage(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
+}
+
+TEST(test_attributes, aaudio_content_type_lowlat) {
+ checkAttributesContentType(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
+}
+
+TEST(test_attributes, aaudio_input_preset_lowlat) {
+ checkAttributesInputPreset(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
+}
diff --git a/tests/tests/nativemedia/aaudio/jni/test_aaudio_misc.cpp b/tests/tests/nativemedia/aaudio/jni/test_aaudio_misc.cpp
index 42c9f42..01ed9f6 100644
--- a/tests/tests/nativemedia/aaudio/jni/test_aaudio_misc.cpp
+++ b/tests/tests/nativemedia/aaudio/jni/test_aaudio_misc.cpp
@@ -75,4 +75,28 @@
static_assert(0 == AAUDIO_CALLBACK_RESULT_CONTINUE, ENUM_CANNOT_CHANGE);
static_assert(1 == AAUDIO_CALLBACK_RESULT_STOP, ENUM_CANNOT_CHANGE);
+
+ static_assert(1 == AAUDIO_USAGE_MEDIA, ENUM_CANNOT_CHANGE);
+ static_assert(2 == AAUDIO_USAGE_VOICE_COMMUNICATION, ENUM_CANNOT_CHANGE);
+ static_assert(3 == AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING, ENUM_CANNOT_CHANGE);
+ static_assert(4 == AAUDIO_USAGE_ALARM, ENUM_CANNOT_CHANGE);
+ static_assert(5 == AAUDIO_USAGE_NOTIFICATION, ENUM_CANNOT_CHANGE);
+ static_assert(6 == AAUDIO_USAGE_NOTIFICATION_RINGTONE, ENUM_CANNOT_CHANGE);
+ static_assert(10 == AAUDIO_USAGE_NOTIFICATION_EVENT, ENUM_CANNOT_CHANGE);
+ static_assert(11 == AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY, ENUM_CANNOT_CHANGE);
+ static_assert(12 == AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE, ENUM_CANNOT_CHANGE);
+ static_assert(13 == AAUDIO_USAGE_ASSISTANCE_SONIFICATION, ENUM_CANNOT_CHANGE);
+ static_assert(14 == AAUDIO_USAGE_GAME, ENUM_CANNOT_CHANGE);
+ static_assert(16 == AAUDIO_USAGE_ASSISTANT, ENUM_CANNOT_CHANGE);
+
+ static_assert(1 == AAUDIO_CONTENT_TYPE_SPEECH, ENUM_CANNOT_CHANGE);
+ static_assert(2 == AAUDIO_CONTENT_TYPE_MUSIC, ENUM_CANNOT_CHANGE);
+ static_assert(3 == AAUDIO_CONTENT_TYPE_MOVIE, ENUM_CANNOT_CHANGE);
+ static_assert(4 == AAUDIO_CONTENT_TYPE_SONIFICATION, ENUM_CANNOT_CHANGE);
+
+ static_assert(1 == AAUDIO_INPUT_PRESET_GENERIC, ENUM_CANNOT_CHANGE);
+ static_assert(5 == AAUDIO_INPUT_PRESET_CAMCORDER, ENUM_CANNOT_CHANGE);
+ static_assert(6 == AAUDIO_INPUT_PRESET_VOICE_RECOGNITION, ENUM_CANNOT_CHANGE);
+ static_assert(7 == AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION, ENUM_CANNOT_CHANGE);
+ static_assert(9 == AAUDIO_INPUT_PRESET_UNPROCESSED, ENUM_CANNOT_CHANGE);
}
diff --git a/tools/cts-device-info/src/com/android/cts/deviceinfo/CameraDeviceInfo.java b/tools/cts-device-info/src/com/android/cts/deviceinfo/CameraDeviceInfo.java
index ff642ba..01917d3 100644
--- a/tools/cts-device-info/src/com/android/cts/deviceinfo/CameraDeviceInfo.java
+++ b/tools/cts-device-info/src/com/android/cts/deviceinfo/CameraDeviceInfo.java
@@ -516,6 +516,7 @@
charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_MAX_FACE_COUNT.getName());
charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES.getName());
charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES.getName());
+ charsKeyNames.add(CameraCharacteristics.STATISTICS_INFO_AVAILABLE_OIS_DATA_MODES.getName());
charsKeyNames.add(CameraCharacteristics.TONEMAP_MAX_CURVE_POINTS.getName());
charsKeyNames.add(CameraCharacteristics.TONEMAP_AVAILABLE_TONE_MAP_MODES.getName());
charsKeyNames.add(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL.getName());