Home | History | Annotate | Download | only in applications 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.settings.applications;
     17 
     18 import android.app.AlertDialog;
     19 import android.app.AppOpsManager;
     20 import android.app.admin.DevicePolicyManager;
     21 import android.content.ActivityNotFoundException;
     22 import android.content.ComponentName;
     23 import android.content.Context;
     24 import android.content.Intent;
     25 import android.content.pm.PackageManager;
     26 import android.content.pm.ResolveInfo;
     27 import android.os.Bundle;
     28 import android.os.UserHandle;
     29 import android.provider.Settings;
     30 import android.support.v14.preference.SwitchPreference;
     31 import android.support.v7.preference.Preference;
     32 import android.support.v7.preference.Preference.OnPreferenceChangeListener;
     33 import android.support.v7.preference.Preference.OnPreferenceClickListener;
     34 import android.util.Log;
     35 
     36 import com.android.internal.annotations.VisibleForTesting;
     37 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
     38 import com.android.settings.R;
     39 import com.android.settings.applications.AppStateUsageBridge.UsageState;
     40 import com.android.settings.core.instrumentation.MetricsFeatureProvider;
     41 import com.android.settings.overlay.FeatureFactory;
     42 
     43 public class UsageAccessDetails extends AppInfoWithHeader implements OnPreferenceChangeListener,
     44         OnPreferenceClickListener {
     45 
     46     private static final String KEY_APP_OPS_PREFERENCE_SCREEN = "app_ops_preference_screen";
     47     private static final String KEY_APP_OPS_SETTINGS_SWITCH = "app_ops_settings_switch";
     48     private static final String KEY_APP_OPS_SETTINGS_PREFS = "app_ops_settings_preference";
     49     private static final String KEY_APP_OPS_SETTINGS_DESC = "app_ops_settings_description";
     50 
     51     // Use a bridge to get the usage stats but don't initialize it to connect with all state.
     52     // TODO: Break out this functionality into its own class.
     53     private AppStateUsageBridge mUsageBridge;
     54     private AppOpsManager mAppOpsManager;
     55     private SwitchPreference mSwitchPref;
     56     private Preference mUsagePrefs;
     57     private Preference mUsageDesc;
     58     private Intent mSettingsIntent;
     59     private UsageState mUsageState;
     60     private DevicePolicyManager mDpm;
     61 
     62     @Override
     63     public void onCreate(Bundle savedInstanceState) {
     64         super.onCreate(savedInstanceState);
     65 
     66         Context context = getActivity();
     67         mUsageBridge = new AppStateUsageBridge(context, mState, null);
     68         mAppOpsManager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE);
     69         mDpm = context.getSystemService(DevicePolicyManager.class);
     70 
     71         addPreferencesFromResource(R.xml.app_ops_permissions_details);
     72         mSwitchPref = (SwitchPreference) findPreference(KEY_APP_OPS_SETTINGS_SWITCH);
     73         mUsagePrefs = findPreference(KEY_APP_OPS_SETTINGS_PREFS);
     74         mUsageDesc = findPreference(KEY_APP_OPS_SETTINGS_DESC);
     75 
     76         getPreferenceScreen().setTitle(R.string.usage_access);
     77         mSwitchPref.setTitle(R.string.permit_usage_access);
     78         mUsagePrefs.setTitle(R.string.app_usage_preference);
     79         mUsageDesc.setSummary(R.string.usage_access_description);
     80 
     81         mSwitchPref.setOnPreferenceChangeListener(this);
     82         mUsagePrefs.setOnPreferenceClickListener(this);
     83 
     84         mSettingsIntent = new Intent(Intent.ACTION_MAIN)
     85                 .addCategory(Settings.INTENT_CATEGORY_USAGE_ACCESS_CONFIG)
     86                 .setPackage(mPackageName);
     87     }
     88 
     89     @Override
     90     public boolean onPreferenceClick(Preference preference) {
     91         if (preference == mUsagePrefs) {
     92             if (mSettingsIntent != null) {
     93                 try {
     94                     getActivity().startActivityAsUser(mSettingsIntent, new UserHandle(mUserId));
     95                 } catch (ActivityNotFoundException e) {
     96                     Log.w(TAG, "Unable to launch app usage access settings " + mSettingsIntent, e);
     97                 }
     98             }
     99             return true;
    100         }
    101         return false;
    102     }
    103 
    104     @Override
    105     public boolean onPreferenceChange(Preference preference, Object newValue) {
    106         if (preference == mSwitchPref) {
    107             if (mUsageState != null && (Boolean) newValue != mUsageState.isPermissible()) {
    108                 if (mUsageState.isPermissible() && mDpm.isProfileOwnerApp(mPackageName)) {
    109                     new AlertDialog.Builder(getContext())
    110                             .setIcon(com.android.internal.R.drawable.ic_dialog_alert_material)
    111                             .setTitle(android.R.string.dialog_alert_title)
    112                             .setMessage(R.string.work_profile_usage_access_warning)
    113                             .setPositiveButton(R.string.okay, null)
    114                             .show();
    115                 }
    116                 setHasAccess(!mUsageState.isPermissible());
    117                 refreshUi();
    118             }
    119             return true;
    120         }
    121         return false;
    122     }
    123 
    124     private void setHasAccess(boolean newState) {
    125         logSpecialPermissionChange(newState, mPackageName);
    126         mAppOpsManager.setMode(AppOpsManager.OP_GET_USAGE_STATS, mPackageInfo.applicationInfo.uid,
    127                 mPackageName, newState ? AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_IGNORED);
    128     }
    129 
    130     @VisibleForTesting
    131     void logSpecialPermissionChange(boolean newState, String packageName) {
    132         int logCategory = newState ? MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_ALLOW
    133                 : MetricsEvent.APP_SPECIAL_PERMISSION_USAGE_VIEW_DENY;
    134         FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action(getContext(),
    135                 logCategory, packageName);
    136     }
    137 
    138     @Override
    139     protected boolean refreshUi() {
    140         mUsageState = mUsageBridge.getUsageInfo(mPackageName,
    141                 mPackageInfo.applicationInfo.uid);
    142 
    143         boolean hasAccess = mUsageState.isPermissible();
    144         mSwitchPref.setChecked(hasAccess);
    145         mSwitchPref.setEnabled(mUsageState.permissionDeclared);
    146         mUsagePrefs.setEnabled(hasAccess);
    147 
    148         ResolveInfo resolveInfo = mPm.resolveActivityAsUser(mSettingsIntent,
    149                 PackageManager.GET_META_DATA, mUserId);
    150         if (resolveInfo != null) {
    151             if (findPreference(KEY_APP_OPS_SETTINGS_PREFS) == null) {
    152                 getPreferenceScreen().addPreference(mUsagePrefs);
    153             }
    154             Bundle metaData = resolveInfo.activityInfo.metaData;
    155             mSettingsIntent.setComponent(new ComponentName(resolveInfo.activityInfo.packageName,
    156                     resolveInfo.activityInfo.name));
    157             if (metaData != null
    158                     && metaData.containsKey(Settings.METADATA_USAGE_ACCESS_REASON)) {
    159                 mSwitchPref.setSummary(
    160                         metaData.getString(Settings.METADATA_USAGE_ACCESS_REASON));
    161             }
    162         } else {
    163             if (findPreference(KEY_APP_OPS_SETTINGS_PREFS) != null) {
    164                 getPreferenceScreen().removePreference(mUsagePrefs);
    165             }
    166         }
    167 
    168         return true;
    169     }
    170 
    171     @Override
    172     protected AlertDialog createDialog(int id, int errorCode) {
    173         return null;
    174     }
    175 
    176     @Override
    177     public int getMetricsCategory() {
    178         return MetricsEvent.APPLICATIONS_USAGE_ACCESS_DETAIL;
    179     }
    180 
    181 }
    182