android限制安装包来源,Android系统设置settings应用学习（一）--允许未知来源应用安装...

settings，是Android系统应用--设置的源代码，包名称为：com.android.settings

安全设置代码：SecuritySettings.java

/*

* Copyright (C) 2007 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 static android.provider.Settings.System.SCREEN_OFF_TIMEOUT;

import android.app.Activity;

import android.app.AlertDialog;

import android.app.admin.DevicePolicyManager;

import android.content.Context;

import android.content.DialogInterface;

import android.content.Intent;

import android.os.Bundle;

import android.os.Vibrator;

import android.preference.CheckBoxPreference;

import android.preference.ListPreference;

import android.preference.Preference;

import android.preference.Preference.OnPreferenceChangeListener;

import android.preference.PreferenceGroup;

import android.preference.PreferenceScreen;

import android.provider.Settings;

import android.provider.Telephony.SIMInfo;

import android.security.KeyStore;

import android.telephony.TelephonyManager;

import android.util.Log;

import com.android.internal.telephony.Phone;

import com.android.internal.widget.LockPatternUtils;

import com.android.settings.gemini.SimListEntrance;

import com.mediatek.xlog.Xlog;

import java.util.ArrayList;

import java.util.List;

import com.mediatek.featureoption.FeatureOption;

/**

* Gesture lock pattern settings.

*/

public class SecuritySettings extends SettingsPreferenceFragment

implements OnPreferenceChangeListener, DialogInterface.OnClickListener {

private static final String TAG = "SecuritySettings";

// Lock Settings

private static final String KEY_UNLOCK_SET_OR_CHANGE = "unlock_set_or_change";

private static final String KEY_BIOMETRIC_WEAK_IMPROVE_MATCHING =

"biometric_weak_improve_matching";

private static final String KEY_LOCK_ENABLED = "lockenabled";

private static final String KEY_VISIBLE_PATTERN = "visiblepattern";

private static final String KEY_TACTILE_FEEDBACK_ENABLED = "unlock_tactile_feedback";

private static final String KEY_SECURITY_CATEGORY = "security_category";

private static final String KEY_LOCK_AFTER_TIMEOUT = "lock_after_timeout";

private static final int SET_OR_CHANGE_LOCK_METHOD_REQUEST = 123;

private static final int CONFIRM_EXISTING_FOR_BIOMETRIC_IMPROVE_REQUEST = 124;

// Misc Settings

private static final String KEY_SIM_LOCK = "sim_lock";

private static final String KEY_SIM_LOCK_PREF = "sim_lock_pref";

private static final String KEY_SHOW_PASSWORD = "show_password";

private static final String KEY_RESET_CREDENTIALS = "reset_credentials";

private static final String KEY_TOGGLE_INSTALL_APPLICATIONS = "toggle_install_applications";

DevicePolicyManager mDPM;

private ChooseLockSettingsHelper mChooseLockSettingsHelper;

private LockPatternUtils mLockPatternUtils;

private ListPreference mLockAfter;

private CheckBoxPreference mVisiblePattern;

private CheckBoxPreference mTactileFeedback;

private CheckBoxPreference mShowPassword;

private Preference mResetCredentials;

private CheckBoxPreference mToggleAppInstallation;

private DialogInterface mWarnInstallApps;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

mLockPatternUtils = new LockPatternUtils(getActivity());

mDPM = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);

mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity());

}

private PreferenceScreen createPreferenceHierarchy() {

PreferenceScreen root = getPreferenceScreen();

if (root != null) {

root.removeAll();

}

addPreferencesFromResource(R.xml.security_settings);

root = getPreferenceScreen();

// Add options for lock/unlock screen

int resid = 0;

if (!mLockPatternUtils.isSecure()) {

if (mLockPatternUtils.isLockScreenDisabled()) {

resid = R.xml.security_settings_lockscreen;

} else {

resid = R.xml.security_settings_chooser;

}

} else if (mLockPatternUtils.usingBiometricWeak() &&

mLockPatternUtils.isBiometricWeakInstalled()) {

resid = R.xml.security_settings_biometric_weak;

} else {

switch (mLockPatternUtils.getKeyguardStoredPasswordQuality()) {

case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING:

resid = R.xml.security_settings_pattern;

break;

case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC:

resid = R.xml.security_settings_pin;

break;

case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:

case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:

case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX:

resid = R.xml.security_settings_password;

break;

}

}

addPreferencesFromResource(resid);

// Add options for device encryption

Xlog.d(TAG,"FeatureOption.MTK_EMMC_SUPPORT="+FeatureOption.MTK_EMMC_SUPPORT);

if(FeatureOption.MTK_EMMC_SUPPORT) {

// Add options for device encryption

DevicePolicyManager dpm =

(DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE);

switch (dpm.getStorageEncryptionStatus()) {

case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE:

// The device is currently encrypted.

addPreferencesFromResource(R.xml.security_settings_encrypted);

break;

case DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE:

// This device supports encryption but isn't encrypted.

addPreferencesFromResource(R.xml.security_settings_unencrypted);

break;

}

}

// lock after preference

mLockAfter = (ListPreference) root.findPreference(KEY_LOCK_AFTER_TIMEOUT);

if (mLockAfter != null) {

setupLockAfterPreference();

updateLockAfterPreferenceSummary();

}

// visible pattern

mVisiblePattern = (CheckBoxPreference) root.findPreference(KEY_VISIBLE_PATTERN);

// don't display visible pattern if biometric and backup is not pattern

if (resid == R.xml.security_settings_biometric_weak &&

mLockPatternUtils.getKeyguardStoredPasswordQuality() !=

DevicePolicyManager.PASSWORD_QUALITY_SOMETHING) {

PreferenceGroup securityCategory = (PreferenceGroup)

root.findPreference(KEY_SECURITY_CATEGORY);

if (securityCategory != null && mVisiblePattern != null) {

securityCategory.removePreference(root.findPreference(KEY_VISIBLE_PATTERN));

}

}

// tactile feedback. Should be common to all unlock preference screens.

mTactileFeedback = (CheckBoxPreference) root.findPreference(KEY_TACTILE_FEEDBACK_ENABLED);

if (!((Vibrator) getSystemService(Context.VIBRATOR_SERVICE)).hasVibrator()) {

PreferenceGroup securityCategory = (PreferenceGroup)

root.findPreference(KEY_SECURITY_CATEGORY);

if (securityCategory != null && mTactileFeedback != null) {

securityCategory.removePreference(mTactileFeedback);

}

}

// Append the rest of the settings

addPreferencesFromResource(R.xml.security_settings_misc);

// Do not display SIM lock for CDMA phone

TelephonyManager tm = TelephonyManager.getDefault();

if ((TelephonyManager.PHONE_TYPE_CDMA == tm.getCurrentPhoneType()) &&

(tm.getLteOnCdmaMode() != Phone.LTE_ON_CDMA_TRUE)) {

root.removePreference(root.findPreference(KEY_SIM_LOCK));

}else{

//Preference simLockPreferences = root.findPreference(KEY_SIM_LOCK);

Preference simLockPref = root.findPreference(KEY_SIM_LOCK_PREF);

List simList = SIMInfo.getInsertedSIMList(getActivity());

int nSimNum = simList.size();

if (nSimNum == 0) {

Xlog.d(TAG,"No sim found");

simLockPref.setEnabled(false);

}else if (nSimNum == 1) {

SIMInfo simInfo = simList.get(0);

Xlog.d(TAG,"Only one Sim inserted");

if (simInfo != null) {

Intent intent = new Intent();

intent.setClassName("com.android.settings", "com.android.settings.IccLockSettings");

int slot = SIMInfo.getSlotById(getActivity(), simInfo.mSimId);

intent.putExtra("slotid", simInfo.mSlot);

simLockPref.setIntent(intent);

}

} else if (nSimNum>1) {

Xlog.d(TAG,"two Sims inserted");

simLockPref.getExtras().putInt("type", SimListEntrance.PIN_SETTING_INDEX);

simLockPref.setFragment(SimListEntrance.class.getName());

}

}

// Show password

mShowPassword = (CheckBoxPreference) root.findPreference(KEY_SHOW_PASSWORD);

// Credential storage

mResetCredentials = root.findPreference(KEY_RESET_CREDENTIALS);

mToggleAppInstallation = (CheckBoxPreference) findPreference(

KEY_TOGGLE_INSTALL_APPLICATIONS);

mToggleAppInstallation.setChecked(isNonMarketAppsAllowed());

return root;

}

private boolean isNonMarketAppsAllowed() {

return Settings.Secure.getInt(getContentResolver(),

Settings.Secure.INSTALL_NON_MARKET_APPS, 0) > 0;

}

private void setNonMarketAppsAllowed(boolean enabled) {

// Change the system setting

Settings.Secure.putInt(getContentResolver(), Settings.Secure.INSTALL_NON_MARKET_APPS,

enabled ? 1 : 0);

}

private void warnAppInstallation() {

// TODO: DialogFragment?

mWarnInstallApps = new AlertDialog.Builder(getActivity()).setTitle(

getResources().getString(R.string.error_title))

.setIcon(com.android.internal.R.drawable.ic_dialog_alert)

.setMessage(getResources().getString(R.string.install_all_warning))

.setPositiveButton(android.R.string.yes, this)

.setNegativeButton(android.R.string.no, null)

.show();

}

public void onClick(DialogInterface dialog, int which) {

if (dialog == mWarnInstallApps && which == DialogInterface.BUTTON_POSITIVE) {

setNonMarketAppsAllowed(true);

mToggleAppInstallation.setChecked(true);

}

}

@Override

public void onDestroy() {

super.onDestroy();

if (mWarnInstallApps != null) {

mWarnInstallApps.dismiss();

}

}

private void setupLockAfterPreference() {

// Compatible with pre-Froyo

long currentTimeout = Settings.Secure.getLong(getContentResolver(),

Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000);

mLockAfter.setValue(String.valueOf(currentTimeout));

mLockAfter.setOnPreferenceChangeListener(this);

final long adminTimeout = (mDPM != null ? mDPM.getMaximumTimeToLock(null) : 0);

final long displayTimeout = Math.max(0,

Settings.System.getInt(getContentResolver(), SCREEN_OFF_TIMEOUT, 0));

if (adminTimeout > 0) {

// This setting is a slave to display timeout when a device policy is enforced.

// As such, maxLockTimeout = adminTimeout - displayTimeout.

// If there isn't enough time, shows "immediately" setting.

disableUnusableTimeouts(Math.max(0, adminTimeout - displayTimeout));

}

}

private void updateLockAfterPreferenceSummary() {

// Update summary message with current value

long currentTimeout = Settings.Secure.getLong(getContentResolver(),

Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, 5000);

final CharSequence[] entries = mLockAfter.getEntries();

final CharSequence[] values = mLockAfter.getEntryValues();

int best = 0;

for (int i = 0; i < values.length; i++) {

long timeout = Long.valueOf(values[i].toString());

if (currentTimeout >= timeout) {

best = i;

}

}

mLockAfter.setSummary(getString(R.string.lock_after_timeout_summary, entries[best]));

}

private void disableUnusableTimeouts(long maxTimeout) {

final CharSequence[] entries = mLockAfter.getEntries();

final CharSequence[] values = mLockAfter.getEntryValues();

ArrayList revisedEntries = new ArrayList();

ArrayList revisedValues = new ArrayList();

for (int i = 0; i < values.length; i++) {

long timeout = Long.valueOf(values[i].toString());

if (timeout <= maxTimeout) {

revisedEntries.add(entries[i]);

revisedValues.add(values[i]);

}

}

if (revisedEntries.size() != entries.length || revisedValues.size() != values.length) {

mLockAfter.setEntries(

revisedEntries.toArray(new CharSequence[revisedEntries.size()]));

mLockAfter.setEntryValues(

revisedValues.toArray(new CharSequence[revisedValues.size()]));

final int userPreference = Integer.valueOf(mLockAfter.getValue());

if (userPreference <= maxTimeout) {

mLockAfter.setValue(String.valueOf(userPreference));

} else {

// There will be no highlighted selection since nothing in the list matches

// maxTimeout. The user can still select anything less than maxTimeout.

// TODO: maybe append maxTimeout to the list and mark selected.

}

}

mLockAfter.setEnabled(revisedEntries.size() > 0);

}

@Override

public void onResume() {

super.onResume();

// Make sure we reload the preference hierarchy since some of these settings

// depend on others...

createPreferenceHierarchy();

final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils();

if (mVisiblePattern != null) {

mVisiblePattern.setChecked(lockPatternUtils.isVisiblePatternEnabled());

}

if (mTactileFeedback != null) {

mTactileFeedback.setChecked(lockPatternUtils.isTactileFeedbackEnabled());

}

mShowPassword.setChecked(Settings.System.getInt(getContentResolver(),

Settings.System.TEXT_SHOW_PASSWORD, 1) != 0);

KeyStore.State state = KeyStore.getInstance().state();

mResetCredentials.setEnabled(state != KeyStore.State.UNINITIALIZED);

}

@Override

public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {

final String key = preference.getKey();

final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils();

if (KEY_UNLOCK_SET_OR_CHANGE.equals(key)) {

startFragment(this, "com.android.settings.ChooseLockGeneric$ChooseLockGenericFragment",

SET_OR_CHANGE_LOCK_METHOD_REQUEST, null);

} else if (KEY_BIOMETRIC_WEAK_IMPROVE_MATCHING.equals(key)) {

ChooseLockSettingsHelper helper =

new ChooseLockSettingsHelper(this.getActivity(), this);

if (!helper.launchConfirmationActivity(

CONFIRM_EXISTING_FOR_BIOMETRIC_IMPROVE_REQUEST, null, null)) {

startBiometricWeakImprove(); // no password set, so no need to confirm

}

} else if (KEY_LOCK_ENABLED.equals(key)) {

lockPatternUtils.setLockPatternEnabled(isToggled(preference));

} else if (KEY_VISIBLE_PATTERN.equals(key)) {

lockPatternUtils.setVisiblePatternEnabled(isToggled(preference));

} else if (KEY_TACTILE_FEEDBACK_ENABLED.equals(key)) {

lockPatternUtils.setTactileFeedbackEnabled(isToggled(preference));

} else if (preference == mShowPassword) {

Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD,

mShowPassword.isChecked() ? 1 : 0);

} else if (preference == mToggleAppInstallation) {

if (mToggleAppInstallation.isChecked()) {

mToggleAppInstallation.setChecked(false);

warnAppInstallation();

} else {

setNonMarketAppsAllowed(false);

}

} else {

// If we didn't handle it, let preferences handle it.

return super.onPreferenceTreeClick(preferenceScreen, preference);

}

return true;

}

private boolean isToggled(Preference pref) {

return ((CheckBoxPreference) pref).isChecked();

}

/**

* see confirmPatternThenDisableAndClear

*/

@Override

public void onActivityResult(int requestCode, int resultCode, Intent data) {

super.onActivityResult(requestCode, resultCode, data);

if (requestCode == CONFIRM_EXISTING_FOR_BIOMETRIC_IMPROVE_REQUEST &&

resultCode == Activity.RESULT_OK) {

startBiometricWeakImprove();

return;

}

createPreferenceHierarchy();

}

public boolean onPreferenceChange(Preference preference, Object value) {

if (preference == mLockAfter) {

int timeout = Integer.parseInt((String) value);

try {

Settings.Secure.putInt(getContentResolver(),

Settings.Secure.LOCK_SCREEN_LOCK_AFTER_TIMEOUT, timeout);

} catch (NumberFormatException e) {

Log.e("SecuritySettings", "could not persist lockAfter timeout setting", e);

}

updateLockAfterPreferenceSummary();

}

return true;

}

public void startBiometricWeakImprove(){

Intent intent = new Intent();

intent.setClassName("com.android.facelock", "com.android.facelock.AddToSetup");

startActivity(intent);

}

}

其中有关未知来源应用安装的有：

mToggleAppInstallation = (CheckBoxPreference) findPreference(

KEY_TOGGLE_INSTALL_APPLICATIONS);

mToggleAppInstallation.setChecked(isNonMarketAppsAllowed());

private boolean isNonMarketAppsAllowed() {

return Settings.Secure.getInt(getContentResolver(),

Settings.Secure.INSTALL_NON_MARKET_APPS, 0) > 0;

}

private void setNonMarketAppsAllowed(boolean enabled) {

// Change the system setting

Settings.Secure.putInt(getContentResolver(), Settings.Secure.INSTALL_NON_MARKET_APPS,

enabled ? 1 : 0);

}

public void onClick(DialogInterface dialog, int which) {

if (dialog == mWarnInstallApps && which == DialogInterface.BUTTON_POSITIVE) {

setNonMarketAppsAllowed(true);

mToggleAppInstallation.setChecked(true);

}

}

源代码Settings$Secure.class中有关允许未知来源应用安装

/**

* Whether the package installer should allow installation of apps downloaded from

* sources other than the Android Market (vending machine).

*

* 1 = allow installing from other sources

* 0 = only allow installing from the Android Market

*/

public static final String INSTALL_NON_MARKET_APPS = "install_non_market_apps";