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.content.ActivityNotFoundException; 21 import android.content.Context; 22 import android.content.Intent; 23 import android.content.pm.ApplicationInfo; 24 import android.content.pm.PackageManager; 25 import android.os.Bundle; 26 import android.os.UserHandle; 27 import android.provider.Settings; 28 import android.support.v14.preference.SwitchPreference; 29 import android.support.v7.preference.Preference; 30 import android.support.v7.preference.Preference.OnPreferenceChangeListener; 31 import android.support.v7.preference.Preference.OnPreferenceClickListener; 32 import android.util.Log; 33 34 import com.android.internal.logging.nano.MetricsProto.MetricsEvent; 35 import com.android.settings.R; 36 import com.android.settings.applications.AppStateAppOpsBridge.PermissionState; 37 import com.android.settings.applications.AppStateWriteSettingsBridge.WriteSettingsState; 38 import com.android.settings.overlay.FeatureFactory; 39 import com.android.settingslib.applications.ApplicationsState.AppEntry; 40 41 import java.util.List; 42 43 public class WriteSettingsDetails 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 private static final String LOG_TAG = "WriteSettingsDetails"; 51 52 private static final int [] APP_OPS_OP_CODE = { 53 AppOpsManager.OP_WRITE_SETTINGS 54 }; 55 56 // Use a bridge to get the overlay details but don't initialize it to connect with all state. 57 // TODO: Break out this functionality into its own class. 58 private AppStateWriteSettingsBridge mAppBridge; 59 private AppOpsManager mAppOpsManager; 60 private SwitchPreference mSwitchPref; 61 private Preference mWriteSettingsPrefs; 62 private Preference mWriteSettingsDesc; 63 private Intent mSettingsIntent; 64 private WriteSettingsState mWriteSettingsState; 65 66 @Override onCreate(Bundle savedInstanceState)67 public void onCreate(Bundle savedInstanceState) { 68 super.onCreate(savedInstanceState); 69 70 Context context = getActivity(); 71 mAppBridge = new AppStateWriteSettingsBridge(context, mState, null); 72 mAppOpsManager = (AppOpsManager) context.getSystemService(Context.APP_OPS_SERVICE); 73 74 addPreferencesFromResource(R.xml.app_ops_permissions_details); 75 mSwitchPref = (SwitchPreference) findPreference(KEY_APP_OPS_SETTINGS_SWITCH); 76 mWriteSettingsPrefs = findPreference(KEY_APP_OPS_SETTINGS_PREFS); 77 mWriteSettingsDesc = findPreference(KEY_APP_OPS_SETTINGS_DESC); 78 79 getPreferenceScreen().setTitle(R.string.write_settings); 80 mSwitchPref.setTitle(R.string.permit_write_settings); 81 mWriteSettingsPrefs.setTitle(R.string.write_settings_preference); 82 mWriteSettingsDesc.setSummary(R.string.write_settings_description); 83 84 mSwitchPref.setOnPreferenceChangeListener(this); 85 mWriteSettingsPrefs.setOnPreferenceClickListener(this); 86 87 mSettingsIntent = new Intent(Intent.ACTION_MAIN) 88 .addCategory(Settings.INTENT_CATEGORY_USAGE_ACCESS_CONFIG) 89 .setPackage(mPackageName); 90 } 91 92 @Override onPreferenceClick(Preference preference)93 public boolean onPreferenceClick(Preference preference) { 94 if (preference == mWriteSettingsPrefs) { 95 if (mSettingsIntent != null) { 96 try { 97 getActivity().startActivityAsUser(mSettingsIntent, new UserHandle(mUserId)); 98 } catch (ActivityNotFoundException e) { 99 Log.w(LOG_TAG, "Unable to launch write system settings " + mSettingsIntent, e); 100 } 101 } 102 return true; 103 } 104 return false; 105 } 106 107 @Override onPreferenceChange(Preference preference, Object newValue)108 public boolean onPreferenceChange(Preference preference, Object newValue) { 109 if (preference == mSwitchPref) { 110 if (mWriteSettingsState != null && (Boolean) newValue != mWriteSettingsState 111 .isPermissible()) { 112 setCanWriteSettings(!mWriteSettingsState.isPermissible()); 113 refreshUi(); 114 } 115 return true; 116 } 117 return false; 118 } 119 setCanWriteSettings(boolean newState)120 private void setCanWriteSettings(boolean newState) { 121 logSpecialPermissionChange(newState, mPackageName); 122 mAppOpsManager.setMode(AppOpsManager.OP_WRITE_SETTINGS, 123 mPackageInfo.applicationInfo.uid, mPackageName, newState 124 ? AppOpsManager.MODE_ALLOWED : AppOpsManager.MODE_ERRORED); 125 } 126 logSpecialPermissionChange(boolean newState, String packageName)127 void logSpecialPermissionChange(boolean newState, String packageName) { 128 int logCategory = newState ? MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_ALLOW 129 : MetricsEvent.APP_SPECIAL_PERMISSION_SETTINGS_CHANGE_DENY; 130 FeatureFactory.getFactory(getContext()).getMetricsFeatureProvider().action(getContext(), 131 logCategory, packageName); 132 } 133 canWriteSettings(String pkgName)134 private boolean canWriteSettings(String pkgName) { 135 int result = mAppOpsManager.noteOpNoThrow(AppOpsManager.OP_WRITE_SETTINGS, 136 mPackageInfo.applicationInfo.uid, pkgName); 137 if (result == AppOpsManager.MODE_ALLOWED) { 138 return true; 139 } 140 141 return false; 142 } 143 144 @Override refreshUi()145 protected boolean refreshUi() { 146 mWriteSettingsState = mAppBridge.getWriteSettingsInfo(mPackageName, 147 mPackageInfo.applicationInfo.uid); 148 149 boolean canWrite = mWriteSettingsState.isPermissible(); 150 mSwitchPref.setChecked(canWrite); 151 // you can't ask a user for a permission you didn't even declare! 152 mSwitchPref.setEnabled(mWriteSettingsState.permissionDeclared); 153 mWriteSettingsPrefs.setEnabled(canWrite); 154 if (getPreferenceScreen().findPreference(KEY_APP_OPS_SETTINGS_PREFS) != null) { 155 getPreferenceScreen().removePreference(mWriteSettingsPrefs); 156 } 157 return true; 158 } 159 160 @Override createDialog(int id, int errorCode)161 protected AlertDialog createDialog(int id, int errorCode) { 162 return null; 163 } 164 165 @Override getMetricsCategory()166 public int getMetricsCategory() { 167 return MetricsEvent.SYSTEM_ALERT_WINDOW_APPS; 168 } 169 getSummary(Context context, AppEntry entry)170 public static CharSequence getSummary(Context context, AppEntry entry) { 171 WriteSettingsState state; 172 if (entry.extraInfo instanceof WriteSettingsState) { 173 state = (WriteSettingsState) entry.extraInfo; 174 } else if (entry.extraInfo instanceof PermissionState) { 175 state = new WriteSettingsState((PermissionState) entry.extraInfo); 176 } else { 177 state = new AppStateWriteSettingsBridge(context, null, null).getWriteSettingsInfo( 178 entry.info.packageName, entry.info.uid); 179 } 180 181 return getSummary(context, state); 182 } 183 getSummary(Context context, WriteSettingsState writeSettingsState)184 public static CharSequence getSummary(Context context, WriteSettingsState writeSettingsState) { 185 return context.getString(writeSettingsState.isPermissible() ? R.string.write_settings_on : 186 R.string.write_settings_off); 187 } 188 getSummary(Context context, String pkg)189 public static CharSequence getSummary(Context context, String pkg) { 190 // first check if pkg is a system pkg 191 boolean isSystem = false; 192 PackageManager packageManager = context.getPackageManager(); 193 try { 194 ApplicationInfo appInfo = packageManager.getApplicationInfo(pkg, 0); 195 if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) { 196 isSystem = true; 197 } 198 } catch (PackageManager.NameNotFoundException e) { 199 // pkg doesn't even exist? 200 Log.w(LOG_TAG, "Package " + pkg + " not found", e); 201 return context.getString(R.string.write_settings_off); 202 } 203 204 AppOpsManager appOpsManager = (AppOpsManager) context.getSystemService(Context 205 .APP_OPS_SERVICE); 206 List<AppOpsManager.PackageOps> packageOps = appOpsManager.getPackagesForOps( 207 APP_OPS_OP_CODE); 208 if (packageOps == null) { 209 return context.getString(R.string.write_settings_off); 210 } 211 212 int uid = isSystem ? 0 : -1; 213 for (AppOpsManager.PackageOps packageOp : packageOps) { 214 if (pkg.equals(packageOp.getPackageName())) { 215 uid = packageOp.getUid(); 216 break; 217 } 218 } 219 220 if (uid == -1) { 221 return context.getString(R.string.write_settings_off); 222 } 223 224 int mode = appOpsManager.noteOpNoThrow(AppOpsManager.OP_WRITE_SETTINGS, uid, pkg); 225 return context.getString((mode == AppOpsManager.MODE_ALLOWED) ? 226 R.string.write_settings_on : R.string.write_settings_off); 227 } 228 } 229