From 2328946b581276088cd37cc316c15f38b0f9129d Mon Sep 17 00:00:00 2001 From: Fyodor Kupolov Date: Fri, 13 Jan 2017 15:14:24 -0800 Subject: [PATCH] Tron metrics for special permissions Added tron metrics for the following special permissions: Battery optimisation - APP_SPECIAL_PERMISSION_BATTERY_ALLOW - APP_SPECIAL_PERMISSION_BATTERY_DENY Device administrators - APP_SPECIAL_PERMISSION_ADMIN_ALLOW (when checked) - APP_SPECIAL_PERMISSION_ADMIN_DENY (when unchecked) Do not disturb access - APP_SPECIAL_PERMISSION_DND_ALLOW - APP_SPECIAL_PERMISSION_DND_DENY Daw over other apps - APP_SPECIAL_PERMISSION_APPDRAW_ALLOW - APP_SPECIAL_PERMISSION_APPDRAW_DENY VR helper services - APP_SPECIAL_PERMISSION_VRHELPER_ALLOW - APP_SPECIAL_PERMISSION_VRHELPER_DENY Modify system settings - APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_ALLOW - APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_DENY Notification access - APP_SPECIAL_PERMISSION_NOTIVIEW_ALLOW - APP_SPECIAL_PERMISSION_NOTIVIEW_DENY Premium SMS access - APP_SPECIAL_PERMISSION_PREMIUM_SMS_ALWAYS_ALLOW - APP_SPECIAL_PERMISSION_PREMIUM_SMS_ASK - APP_SPECIAL_PERMISSION_PREMIUM_SMS_DENY Unrestricted data access - APP_SPECIAL_PERMISSION_UNL_DATA_ALLOW - APP_SPECIAL_PERMISSION_UNL_DATA_DENY Usage access - APP_SPECIAL_PERMISSION_USAGE_VIEW_ALLOW - APP_SPECIAL_PERMISSION_USAGE_VIEW_DENY Test: Manual + make RunSettingsRoboTests Bug: 31008660 Change-Id: Id977e2c9f5aa811a2b0af036372b72c684621435 --- src/com/android/settings/DeviceAdminAdd.java | 11 +++ .../applications/DrawOverlayDetails.java | 11 +++ .../applications/PremiumSmsAccess.java | 30 +++++++- .../applications/UsageAccessDetails.java | 12 +++ .../applications/VrListenerSettings.java | 17 ++++ .../applications/WriteSettingsDetails.java | 9 +++ .../datausage/UnrestrictedDataAccess.java | 12 ++- .../settings/fuelgauge/HighPowerDetail.java | 11 +++ .../NotificationAccessSettings.java | 12 +++ .../notification/ZenAccessSettings.java | 12 +++ tests/robotests/Android.mk | 3 +- .../android/settings/DeviceAdminAddTest.java | 64 +++++++++++++++ .../applications/DrawOverlayDetailsTest.java | 69 +++++++++++++++++ .../applications/PremiumSmsAccessTest.java | 77 +++++++++++++++++++ .../applications/UsageAccessDetailsTest.java | 68 ++++++++++++++++ .../applications/VrListenerSettingsTest.java | 66 ++++++++++++++++ .../WriteSettingsDetailsTest.java | 68 ++++++++++++++++ .../datausage/UnrestrictedDataAccessTest.java | 24 ++++++ .../fuelgauge/HighPowerDetailTest.java | 66 ++++++++++++++++ .../NotificationAccessSettingsTest.java | 68 ++++++++++++++++ .../notification/ZenAccessSettingsTest.java | 66 ++++++++++++++++ 21 files changed, 772 insertions(+), 4 deletions(-) create mode 100644 tests/robotests/src/com/android/settings/DeviceAdminAddTest.java create mode 100644 tests/robotests/src/com/android/settings/applications/DrawOverlayDetailsTest.java create mode 100644 tests/robotests/src/com/android/settings/applications/PremiumSmsAccessTest.java create mode 100644 tests/robotests/src/com/android/settings/applications/UsageAccessDetailsTest.java create mode 100644 tests/robotests/src/com/android/settings/applications/VrListenerSettingsTest.java create mode 100644 tests/robotests/src/com/android/settings/applications/WriteSettingsDetailsTest.java create mode 100644 tests/robotests/src/com/android/settings/fuelgauge/HighPowerDetailTest.java create mode 100644 tests/robotests/src/com/android/settings/notification/NotificationAccessSettingsTest.java create mode 100644 tests/robotests/src/com/android/settings/notification/ZenAccessSettingsTest.java diff --git a/src/com/android/settings/DeviceAdminAdd.java b/src/com/android/settings/DeviceAdminAdd.java index 14d42c0acec..d6a072ce555 100644 --- a/src/com/android/settings/DeviceAdminAdd.java +++ b/src/com/android/settings/DeviceAdminAdd.java @@ -58,6 +58,9 @@ import android.widget.Button; import android.widget.ImageView; import android.widget.TextView; +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.core.instrumentation.MetricsFeatureProvider; +import com.android.settings.overlay.FeatureFactory; import com.android.settings.users.UserDialogs; import org.xmlpull.v1.XmlPullParserException; @@ -395,6 +398,7 @@ public class DeviceAdminAdd extends Activity { void addAndFinish() { try { + logSpecialPermissionChange(true, mDeviceAdmin.getComponent().getPackageName()); mDPM.setActiveAdmin(mDeviceAdmin.getComponent(), mRefreshing); EventLog.writeEvent(EventLogTags.EXP_DET_DEVICE_ADMIN_ACTIVATED_BY_USER, mDeviceAdmin.getActivityInfo().applicationInfo.uid); @@ -429,6 +433,7 @@ public class DeviceAdminAdd extends Activity { ActivityManager.getService().resumeAppSwitches(); } catch (RemoteException e) { } + logSpecialPermissionChange(false, mDeviceAdmin.getComponent().getPackageName()); mDPM.removeActiveAdmin(mDeviceAdmin.getComponent()); finish(); } else { @@ -444,6 +449,12 @@ public class DeviceAdminAdd extends Activity { } } + void logSpecialPermissionChange(boolean allow, String packageName) { + int logCategory = allow ? MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_ADMIN_ALLOW : + MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_ADMIN_DENY; + FeatureFactory.getFactory(this).getMetricsFeatureProvider().action(this, logCategory, packageName); + } + @Override protected void onResume() { super.onResume(); diff --git a/src/com/android/settings/applications/DrawOverlayDetails.java b/src/com/android/settings/applications/DrawOverlayDetails.java index dfaa95f7f1a..39b8919430a 100644 --- a/src/com/android/settings/applications/DrawOverlayDetails.java +++ b/src/com/android/settings/applications/DrawOverlayDetails.java @@ -31,10 +31,12 @@ import android.support.v7.preference.Preference.OnPreferenceChangeListener; import android.support.v7.preference.Preference.OnPreferenceClickListener; import android.util.Log; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.applications.AppStateAppOpsBridge.PermissionState; import com.android.settings.applications.AppStateOverlayBridge.OverlayState; +import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.applications.ApplicationsState.AppEntry; public class DrawOverlayDetails extends AppInfoWithHeader implements OnPreferenceChangeListener, @@ -121,11 +123,20 @@ public class DrawOverlayDetails extends AppInfoWithHeader implements OnPreferenc } private void setCanDrawOverlay(boolean newState) { + logSpecialPermissionChange(newState, mPackageName); mAppOpsManager.setMode(AppOpsManager.OP_SYSTEM_ALERT_WINDOW, mPackageInfo.applicationInfo.uid, mPackageName, newState ? AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_ERRORED); } + @VisibleForTesting + void logSpecialPermissionChange(boolean newState, String packageName) { + int logCategory = newState ? MetricsEvent.APP_SPECIAL_PERMISSION_APPDRAW_ALLOW + : MetricsEvent.APP_SPECIAL_PERMISSION_APPDRAW_DENY; + FeatureFactory.getFactory(getContext()) + .getMetricsFeatureProvider().action(getContext(), logCategory, packageName); + } + private boolean canDrawOverlay(String pkgName) { int result = mAppOpsManager.noteOpNoThrow(AppOpsManager.OP_SYSTEM_ALERT_WINDOW, mPackageInfo.applicationInfo.uid, pkgName); diff --git a/src/com/android/settings/applications/PremiumSmsAccess.java b/src/com/android/settings/applications/PremiumSmsAccess.java index fa97537cbc2..2b0942f2c61 100644 --- a/src/com/android/settings/applications/PremiumSmsAccess.java +++ b/src/com/android/settings/applications/PremiumSmsAccess.java @@ -24,13 +24,17 @@ import android.support.v7.preference.Preference.OnPreferenceChangeListener; import android.support.v7.preference.PreferenceScreen; import android.support.v7.preference.PreferenceViewHolder; import android.view.View; + +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto; import com.android.internal.telephony.SmsUsageMonitor; import com.android.settings.DividerPreference; import com.android.settings.R; import com.android.settings.applications.AppStateBaseBridge.Callback; import com.android.settings.applications.AppStateSmsPremBridge.SmsState; +import com.android.settings.core.instrumentation.MetricsFeatureProvider; import com.android.settings.notification.EmptyTextSettings; +import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.applications.ApplicationsState; import com.android.settingslib.applications.ApplicationsState.AppEntry; import com.android.settingslib.applications.ApplicationsState.Callbacks; @@ -81,11 +85,33 @@ public class PremiumSmsAccess extends EmptyTextSettings implements Callback, Cal @Override public boolean onPreferenceChange(Preference preference, Object newValue) { PremiumSmsPreference pref = (PremiumSmsPreference) preference; - mSmsBackend.setSmsState(pref.mAppEntry.info.packageName, - Integer.parseInt((String) newValue)); + int smsState = Integer.parseInt((String) newValue); + logSpecialPermissionChange(smsState, pref.mAppEntry.info.packageName); + mSmsBackend.setSmsState(pref.mAppEntry.info.packageName, smsState); return true; } + @VisibleForTesting + void logSpecialPermissionChange(int smsState, String packageName) { + int category = SmsUsageMonitor.PREMIUM_SMS_PERMISSION_UNKNOWN; + switch (smsState) { + case SmsUsageMonitor.PREMIUM_SMS_PERMISSION_ASK_USER: + category = MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_ASK; + break; + case SmsUsageMonitor.PREMIUM_SMS_PERMISSION_NEVER_ALLOW: + category = MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_DENY; + break; + case SmsUsageMonitor.PREMIUM_SMS_PERMISSION_ALWAYS_ALLOW: + category = MetricsProto.MetricsEvent. + APP_SPECIAL_PERMISSION_PREMIUM_SMS_ALWAYS_ALLOW; + break; + } + if (category != SmsUsageMonitor.PREMIUM_SMS_PERMISSION_UNKNOWN) { + FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action( + getContext(), category, packageName); + } + } + private void updatePrefs(ArrayList apps) { if (apps == null) return; setEmptyText(R.string.premium_sms_none); diff --git a/src/com/android/settings/applications/UsageAccessDetails.java b/src/com/android/settings/applications/UsageAccessDetails.java index 2fa0253651a..e40ae37c23f 100644 --- a/src/com/android/settings/applications/UsageAccessDetails.java +++ b/src/com/android/settings/applications/UsageAccessDetails.java @@ -33,9 +33,12 @@ import android.support.v7.preference.Preference.OnPreferenceChangeListener; import android.support.v7.preference.Preference.OnPreferenceClickListener; import android.util.Log; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.applications.AppStateUsageBridge.UsageState; +import com.android.settings.core.instrumentation.MetricsFeatureProvider; +import com.android.settings.overlay.FeatureFactory; public class UsageAccessDetails extends AppInfoWithHeader implements OnPreferenceChangeListener, OnPreferenceClickListener { @@ -119,10 +122,19 @@ public class UsageAccessDetails extends AppInfoWithHeader implements OnPreferenc } private void setHasAccess(boolean newState) { + logSpecialPermissionChange(newState, mPackageName); mAppOpsManager.setMode(AppOpsManager.OP_GET_USAGE_STATS, mPackageInfo.applicationInfo.uid, mPackageName, newState ? AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_IGNORED); } + @VisibleForTesting + void logSpecialPermissionChange(boolean newState, String packageName) { + int logCategory = newState ? MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_ALLOW + : MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_DENY; + FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action(getContext(), + logCategory, packageName); + } + @Override protected boolean refreshUi() { mUsageState = mUsageBridge.getUsageInfo(mPackageName, diff --git a/src/com/android/settings/applications/VrListenerSettings.java b/src/com/android/settings/applications/VrListenerSettings.java index 08d1367b3cf..99340b19170 100644 --- a/src/com/android/settings/applications/VrListenerSettings.java +++ b/src/com/android/settings/applications/VrListenerSettings.java @@ -15,11 +15,14 @@ */ package com.android.settings.applications; +import android.content.ComponentName; import android.provider.Settings; import android.service.vr.VrListenerService; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; +import com.android.settings.overlay.FeatureFactory; import com.android.settings.utils.ManagedServiceSettings; public class VrListenerSettings extends ManagedServiceSettings { @@ -48,4 +51,18 @@ public class VrListenerSettings extends ManagedServiceSettings { public int getMetricsCategory() { return MetricsEvent.VR_MANAGE_LISTENERS; } + + @Override + protected boolean setEnabled(ComponentName service, String title, boolean enable) { + logSpecialPermissionChange(enable, service.getPackageName()); + return super.setEnabled(service, title, enable); + } + + @VisibleForTesting + void logSpecialPermissionChange(boolean enable, String packageName) { + int logCategory = enable ? MetricsEvent.APP_SPECIAL_PERMISSION_VRHELPER_ALLOW + : MetricsEvent.APP_SPECIAL_PERMISSION_VRHELPER_DENY; + FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action(getContext(), + logCategory, packageName); + } } diff --git a/src/com/android/settings/applications/WriteSettingsDetails.java b/src/com/android/settings/applications/WriteSettingsDetails.java index 9f9016d3a00..aea05b3bbb0 100644 --- a/src/com/android/settings/applications/WriteSettingsDetails.java +++ b/src/com/android/settings/applications/WriteSettingsDetails.java @@ -35,6 +35,7 @@ import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.applications.AppStateAppOpsBridge.PermissionState; import com.android.settings.applications.AppStateWriteSettingsBridge.WriteSettingsState; +import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.applications.ApplicationsState.AppEntry; import java.util.List; @@ -117,11 +118,19 @@ public class WriteSettingsDetails extends AppInfoWithHeader implements OnPrefere } private void setCanWriteSettings(boolean newState) { + logSpecialPermissionChange(newState, mPackageName); mAppOpsManager.setMode(AppOpsManager.OP_WRITE_SETTINGS, mPackageInfo.applicationInfo.uid, mPackageName, newState ? AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_ERRORED); } + void logSpecialPermissionChange(boolean newState, String packageName) { + int logCategory = newState ? MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_ALLOW + : MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_DENY; + FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action(getContext(), + logCategory, packageName); + } + private boolean canWriteSettings(String pkgName) { int result = mAppOpsManager.noteOpNoThrow(AppOpsManager.OP_WRITE_SETTINGS, mPackageInfo.applicationInfo.uid, pkgName); diff --git a/src/com/android/settings/datausage/UnrestrictedDataAccess.java b/src/com/android/settings/datausage/UnrestrictedDataAccess.java index 0839114dbbf..58a34b91101 100644 --- a/src/com/android/settings/datausage/UnrestrictedDataAccess.java +++ b/src/com/android/settings/datausage/UnrestrictedDataAccess.java @@ -18,7 +18,6 @@ import android.app.Application; import android.content.Context; import android.os.Bundle; import android.os.UserHandle; -import android.support.annotation.VisibleForTesting; import android.support.v14.preference.SwitchPreference; import android.support.v7.preference.Preference; import android.support.v7.preference.PreferenceViewHolder; @@ -27,12 +26,14 @@ import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.SettingsPreferenceFragment; import com.android.settings.applications.AppStateBaseBridge; import com.android.settings.applications.InstalledAppDetails; import com.android.settings.datausage.AppStateDataUsageBridge.DataUsageState; +import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.applications.ApplicationsState; import com.android.settingslib.applications.ApplicationsState.AppEntry; import com.android.settingslib.applications.ApplicationsState.AppFilter; @@ -215,6 +216,7 @@ public class UnrestrictedDataAccess extends SettingsPreferenceFragment if (preference instanceof AccessPreference) { AccessPreference accessPreference = (AccessPreference) preference; boolean whitelisted = newValue == Boolean.TRUE; + logSpecialPermissionChange(whitelisted, accessPreference.mEntry.info.packageName); mDataSaverBackend.setIsWhitelisted(accessPreference.mEntry.info.uid, accessPreference.mEntry.info.packageName, whitelisted); accessPreference.mState.isDataSaverWhitelisted = whitelisted; @@ -223,6 +225,14 @@ public class UnrestrictedDataAccess extends SettingsPreferenceFragment return false; } + @VisibleForTesting + void logSpecialPermissionChange(boolean whitelisted, String packageName) { + int logCategory = whitelisted ? MetricsEvent.APP_SPECIAL_PERMISSION_UNL_DATA_ALLOW + : MetricsEvent.APP_SPECIAL_PERMISSION_UNL_DATA_DENY; + FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action(getContext(), + logCategory, packageName); + } + @VisibleForTesting boolean shouldAddPreference(AppEntry app) { return app != null && UserHandle.isApp(app.info.uid); diff --git a/src/com/android/settings/fuelgauge/HighPowerDetail.java b/src/com/android/settings/fuelgauge/HighPowerDetail.java index a59dc78f04f..296f973707f 100644 --- a/src/com/android/settings/fuelgauge/HighPowerDetail.java +++ b/src/com/android/settings/fuelgauge/HighPowerDetail.java @@ -30,10 +30,12 @@ import android.view.View; import android.widget.Checkable; import android.widget.TextView; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto; import com.android.settings.R; import com.android.settings.applications.AppInfoBase; import com.android.settings.core.instrumentation.InstrumentedDialogFragment; +import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.applications.ApplicationsState.AppEntry; public class HighPowerDetail extends InstrumentedDialogFragment implements OnClickListener, @@ -125,6 +127,7 @@ public class HighPowerDetail extends InstrumentedDialogFragment implements OnCli boolean newValue = mIsEnabled; boolean oldValue = mBackend.isWhitelisted(mPackageName); if (newValue != oldValue) { + logSpecialPermissionChange(newValue, mPackageName, getContext()); if (newValue) { mBackend.addApp(mPackageName); } else { @@ -134,6 +137,14 @@ public class HighPowerDetail extends InstrumentedDialogFragment implements OnCli } } + @VisibleForTesting + static void logSpecialPermissionChange(boolean whitelist, String packageName, Context context) { + int logCategory = whitelist ? MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_DENY + : MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_ALLOW; + FeatureFactory.getFactory(context).getMetricsFeatureProvider().action(context, logCategory, + packageName); + } + @Override public void onDismiss(DialogInterface dialog) { super.onDismiss(dialog); diff --git a/src/com/android/settings/notification/NotificationAccessSettings.java b/src/com/android/settings/notification/NotificationAccessSettings.java index b032358ba7e..2cd728cb1d7 100644 --- a/src/com/android/settings/notification/NotificationAccessSettings.java +++ b/src/com/android/settings/notification/NotificationAccessSettings.java @@ -29,9 +29,12 @@ import android.provider.Settings; import android.service.notification.NotificationListenerService; import android.util.Log; +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.logging.MetricsLogger; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.core.instrumentation.InstrumentedDialogFragment; +import com.android.settings.overlay.FeatureFactory; import com.android.settings.utils.ManagedServiceSettings; public class NotificationAccessSettings extends ManagedServiceSettings { @@ -68,6 +71,7 @@ public class NotificationAccessSettings extends ManagedServiceSettings { } protected boolean setEnabled(ComponentName service, String title, boolean enable) { + logSpecialPermissionChange(enable, service.getPackageName()); if (!enable) { if (!mServiceListing.isEnabled(service)) { return true; // already disabled @@ -82,6 +86,14 @@ public class NotificationAccessSettings extends ManagedServiceSettings { } } + @VisibleForTesting + void logSpecialPermissionChange(boolean enable, String packageName) { + int logCategory = enable ? MetricsEvent.APP_SPECIAL_PERMISSION_NOTIVIEW_ALLOW + : MetricsEvent.APP_SPECIAL_PERMISSION_NOTIVIEW_DENY; + FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action(getContext(), + logCategory, packageName); + } + private static void disable(final Context context, final NotificationAccessSettings parent, final ComponentName cn) { parent.mServiceListing.setEnabled(cn, false); diff --git a/src/com/android/settings/notification/ZenAccessSettings.java b/src/com/android/settings/notification/ZenAccessSettings.java index f9b1c12bf28..a41a7339d0c 100644 --- a/src/com/android/settings/notification/ZenAccessSettings.java +++ b/src/com/android/settings/notification/ZenAccessSettings.java @@ -44,9 +44,11 @@ import android.util.ArraySet; import android.view.View; import android.widget.Toast; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.core.instrumentation.InstrumentedDialogFragment; +import com.android.settings.overlay.FeatureFactory; import java.util.ArrayList; import java.util.Collections; @@ -171,6 +173,7 @@ public class ZenAccessSettings extends EmptyTextSettings { } private static void setAccess(final Context context, final String pkg, final boolean access) { + logSpecialPermissionChange(access, pkg, context); AsyncTask.execute(new Runnable() { @Override public void run() { @@ -180,6 +183,15 @@ public class ZenAccessSettings extends EmptyTextSettings { }); } + @VisibleForTesting + static void logSpecialPermissionChange(boolean enable, String packageName, Context context) { + int logCategory = enable ? MetricsEvent.APP_SPECIAL_PERMISSION_DND_ALLOW + : MetricsEvent.APP_SPECIAL_PERMISSION_DND_DENY; + FeatureFactory.getFactory(context).getMetricsFeatureProvider().action(context, + logCategory, packageName); + } + + private static void deleteRules(final Context context, final String pkg) { AsyncTask.execute(new Runnable() { @Override diff --git a/tests/robotests/Android.mk b/tests/robotests/Android.mk index 0a49be2df60..3fc034dd809 100644 --- a/tests/robotests/Android.mk +++ b/tests/robotests/Android.mk @@ -14,7 +14,8 @@ LOCAL_STATIC_JAVA_LIBRARIES := \ LOCAL_JAVA_LIBRARIES := \ junit \ platform-robolectric-prebuilt \ - sdk_vcurrent + sdk_vcurrent \ + telephony-common LOCAL_INSTRUMENTATION_FOR := Settings LOCAL_MODULE := SettingsRoboTests diff --git a/tests/robotests/src/com/android/settings/DeviceAdminAddTest.java b/tests/robotests/src/com/android/settings/DeviceAdminAddTest.java new file mode 100644 index 00000000000..42aed2b5fd9 --- /dev/null +++ b/tests/robotests/src/com/android/settings/DeviceAdminAddTest.java @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.Robolectric; +import org.robolectric.annotation.Config; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class DeviceAdminAddTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + private FakeFeatureFactory mFeatureFactory; + private DeviceAdminAdd mDeviceAdminAdd; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mDeviceAdminAdd = Robolectric.buildActivity(DeviceAdminAdd.class).get(); + } + + @Test + public void logSpecialPermissionChange() { + mDeviceAdminAdd.logSpecialPermissionChange(true, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_ADMIN_ALLOW), eq("app")); + + mDeviceAdminAdd.logSpecialPermissionChange(false, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_ADMIN_DENY), eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/applications/DrawOverlayDetailsTest.java b/tests/robotests/src/com/android/settings/applications/DrawOverlayDetailsTest.java new file mode 100644 index 00000000000..a5306a2ca5c --- /dev/null +++ b/tests/robotests/src/com/android/settings/applications/DrawOverlayDetailsTest.java @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.applications; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.internal.telephony.SmsUsageMonitor; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplication; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class DrawOverlayDetailsTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + private DrawOverlayDetails mFragment; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mFragment = new DrawOverlayDetails(); + mFragment.onAttach(ShadowApplication.getInstance().getApplicationContext()); + } + + @Test + public void logSpecialPermissionChange() { + mFragment.logSpecialPermissionChange(true, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_APPDRAW_ALLOW), eq("app")); + + mFragment.logSpecialPermissionChange(false, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_APPDRAW_DENY), eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/applications/PremiumSmsAccessTest.java b/tests/robotests/src/com/android/settings/applications/PremiumSmsAccessTest.java new file mode 100644 index 00000000000..d9c88ff9a64 --- /dev/null +++ b/tests/robotests/src/com/android/settings/applications/PremiumSmsAccessTest.java @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.applications; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.internal.telephony.SmsUsageMonitor; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplication; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class PremiumSmsAccessTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + private PremiumSmsAccess mFragment; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mFragment = new PremiumSmsAccess(); + mFragment.onAttach(ShadowApplication.getInstance().getApplicationContext()); + } + + @Test + public void logSpecialPermissionChange() { + mFragment.logSpecialPermissionChange(SmsUsageMonitor.PREMIUM_SMS_PERMISSION_ASK_USER, + "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_ASK), eq("app")); + + mFragment.logSpecialPermissionChange(SmsUsageMonitor.PREMIUM_SMS_PERMISSION_NEVER_ALLOW, + "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_DENY), eq("app")); + + mFragment.logSpecialPermissionChange(SmsUsageMonitor.PREMIUM_SMS_PERMISSION_ALWAYS_ALLOW, + "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_PREMIUM_SMS_ALWAYS_ALLOW), + eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/applications/UsageAccessDetailsTest.java b/tests/robotests/src/com/android/settings/applications/UsageAccessDetailsTest.java new file mode 100644 index 00000000000..532a92350fc --- /dev/null +++ b/tests/robotests/src/com/android/settings/applications/UsageAccessDetailsTest.java @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.applications; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; +import org.robolectric.shadows.ShadowApplication; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class UsageAccessDetailsTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + private UsageAccessDetails mFragment; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mFragment = new UsageAccessDetails(); + mFragment.onAttach(ShadowApplication.getInstance().getApplicationContext()); + } + + @Test + public void logSpecialPermissionChange() { + mFragment.logSpecialPermissionChange(true, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_ALLOW), eq("app")); + + mFragment.logSpecialPermissionChange(false, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_DENY), eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/applications/VrListenerSettingsTest.java b/tests/robotests/src/com/android/settings/applications/VrListenerSettingsTest.java new file mode 100644 index 00000000000..3abe3f4aaad --- /dev/null +++ b/tests/robotests/src/com/android/settings/applications/VrListenerSettingsTest.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.applications; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class VrListenerSettingsTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + private VrListenerSettings mFragment; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mFragment = new VrListenerSettings(); + } + + @Test + public void logSpecialPermissionChange() { + mFragment.logSpecialPermissionChange(true, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_VRHELPER_ALLOW), eq("app")); + + mFragment.logSpecialPermissionChange(false, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_VRHELPER_DENY), eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/applications/WriteSettingsDetailsTest.java b/tests/robotests/src/com/android/settings/applications/WriteSettingsDetailsTest.java new file mode 100644 index 00000000000..a6321180e03 --- /dev/null +++ b/tests/robotests/src/com/android/settings/applications/WriteSettingsDetailsTest.java @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.applications; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class WriteSettingsDetailsTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + private WriteSettingsDetails mFragment; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mFragment = new WriteSettingsDetails(); + } + + @Test + public void logSpecialPermissionChange() { + mFragment.logSpecialPermissionChange(true, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_ALLOW), + eq("app")); + + mFragment.logSpecialPermissionChange(false, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_DENY), + eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/datausage/UnrestrictedDataAccessTest.java b/tests/robotests/src/com/android/settings/datausage/UnrestrictedDataAccessTest.java index c7b8deed648..d674c770db1 100644 --- a/tests/robotests/src/com/android/settings/datausage/UnrestrictedDataAccessTest.java +++ b/tests/robotests/src/com/android/settings/datausage/UnrestrictedDataAccessTest.java @@ -15,31 +15,44 @@ */ package com.android.settings.datausage; +import com.android.internal.logging.nano.MetricsProto; +import android.content.Context; import android.content.pm.ApplicationInfo; import android.os.Process; import com.android.settings.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; import com.android.settingslib.applications.ApplicationsState; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Answers; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.robolectric.annotation.Config; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; @RunWith(SettingsRobolectricTestRunner.class) @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) public class UnrestrictedDataAccessTest { + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + @Mock private ApplicationsState.AppEntry mAppEntry; private UnrestrictedDataAccess mFragment; + private FakeFeatureFactory mFeatureFactory; @Before public void setUp() { MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); mFragment = new UnrestrictedDataAccess(); } @@ -59,4 +72,15 @@ public class UnrestrictedDataAccessTest { assertThat(mFragment.shouldAddPreference(mAppEntry)).isFalse(); } + @Test + public void logSpecialPermissionChange() { + mFragment.logSpecialPermissionChange(true, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_UNL_DATA_ALLOW), eq("app")); + + mFragment.logSpecialPermissionChange(false, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_UNL_DATA_DENY), eq("app")); + } + } diff --git a/tests/robotests/src/com/android/settings/fuelgauge/HighPowerDetailTest.java b/tests/robotests/src/com/android/settings/fuelgauge/HighPowerDetailTest.java new file mode 100644 index 00000000000..a60bc65080b --- /dev/null +++ b/tests/robotests/src/com/android/settings/fuelgauge/HighPowerDetailTest.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.fuelgauge; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class HighPowerDetailTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + } + + @Test + public void logSpecialPermissionChange() { + // Deny means app is whitelisted to opt out of power save restrictions + HighPowerDetail.logSpecialPermissionChange(true, "app", mContext); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_DENY), eq("app")); + + // Allow means app is NOT whitelisted to opt out of power save restrictions + HighPowerDetail.logSpecialPermissionChange(false, "app", mContext); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_BATTERY_ALLOW), eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/notification/NotificationAccessSettingsTest.java b/tests/robotests/src/com/android/settings/notification/NotificationAccessSettingsTest.java new file mode 100644 index 00000000000..b0aa856c864 --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/NotificationAccessSettingsTest.java @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.notification; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class NotificationAccessSettingsTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + private NotificationAccessSettings mFragment; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mFragment = new NotificationAccessSettings(); + } + + @Test + public void logSpecialPermissionChange() { + mFragment.logSpecialPermissionChange(true, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_NOTIVIEW_ALLOW), + eq("app")); + + mFragment.logSpecialPermissionChange(false, "app"); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_NOTIVIEW_DENY), + eq("app")); + } +} diff --git a/tests/robotests/src/com/android/settings/notification/ZenAccessSettingsTest.java b/tests/robotests/src/com/android/settings/notification/ZenAccessSettingsTest.java new file mode 100644 index 00000000000..854edcda61e --- /dev/null +++ b/tests/robotests/src/com/android/settings/notification/ZenAccessSettingsTest.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License + */ + +package com.android.settings.notification; + +import android.content.Context; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.SettingsRobolectricTestRunner; +import com.android.settings.TestConfig; +import com.android.settings.testutils.FakeFeatureFactory; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.annotation.Config; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class ZenAccessSettingsTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private Context mContext; + + private FakeFeatureFactory mFeatureFactory; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + FakeFeatureFactory.setupForTest(mContext); + mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + } + + @Test + public void logSpecialPermissionChange() { + ZenAccessSettings.logSpecialPermissionChange(true, "app", mContext); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_DND_ALLOW), + eq("app")); + + ZenAccessSettings.logSpecialPermissionChange(false, "app", mContext); + verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class), + eq(MetricsProto.MetricsEvent.APP_SPECIAL_PERMISSION_DND_DENY), + eq("app")); + } +}