77b5d394ff
Synced to developers/samples/android commit 97b2cfe5ba6d8fa8daaf3273141b321b5fe9e910. Change-Id: I360cfa147e71dd519b841df41b4e878f86b9b27b
335 lines
12 KiB
Java
335 lines
12 KiB
Java
/*
|
|
* Copyright (C) 2015 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.example.android.deviceowner;
|
|
|
|
import android.app.Activity;
|
|
import android.app.Fragment;
|
|
import android.app.admin.DevicePolicyManager;
|
|
import android.content.ComponentName;
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.SharedPreferences;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.os.Bundle;
|
|
import android.provider.Settings;
|
|
import android.support.annotation.Nullable;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.Button;
|
|
import android.widget.CompoundButton;
|
|
import android.widget.SimpleAdapter;
|
|
import android.widget.Spinner;
|
|
import android.widget.Switch;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Demonstrates the usage of the most common device management APIs for the device owner case.
|
|
* In addition to various features available for profile owners, device owners can perform extra
|
|
* actions, such as configuring global settings and enforcing a preferred Activity for a specific
|
|
* IntentFilter.
|
|
*/
|
|
public class DeviceOwnerFragment extends Fragment {
|
|
|
|
// Keys for SharedPreferences
|
|
private static final String PREFS_DEVICE_OWNER = "DeviceOwnerFragment";
|
|
private static final String PREF_LAUNCHER = "launcher";
|
|
|
|
private DevicePolicyManager mDevicePolicyManager;
|
|
|
|
// View references
|
|
private Switch mSwitchAutoTime;
|
|
private Switch mSwitchAutoTimeZone;
|
|
private Spinner mAvailableLaunchers;
|
|
private Button mButtonLauncher;
|
|
|
|
// Adapter for the spinner to show list of available launchers
|
|
private LauncherAdapter mAdapter;
|
|
|
|
/**
|
|
* Handles events on the Switches.
|
|
*/
|
|
private Switch.OnCheckedChangeListener mOnCheckedChangeListener
|
|
= new Switch.OnCheckedChangeListener() {
|
|
|
|
@Override
|
|
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
|
|
switch (buttonView.getId()) {
|
|
case R.id.switch_auto_time:
|
|
setBooleanGlobalSetting(Settings.Global.AUTO_TIME, isChecked);
|
|
retrieveCurrentSettings(getActivity());
|
|
break;
|
|
case R.id.switch_auto_time_zone:
|
|
setBooleanGlobalSetting(Settings.Global.AUTO_TIME_ZONE, isChecked);
|
|
retrieveCurrentSettings(getActivity());
|
|
break;
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Handles click events on the Button.
|
|
*/
|
|
private View.OnClickListener mOnClickListener
|
|
= new View.OnClickListener() {
|
|
|
|
@Override
|
|
public void onClick(View v) {
|
|
switch (v.getId()) {
|
|
case R.id.set_preferred_launcher:
|
|
if (loadPersistentPreferredLauncher(getActivity()) == null) {
|
|
setPreferredLauncher();
|
|
} else {
|
|
clearPreferredLauncher();
|
|
}
|
|
retrieveCurrentSettings(getActivity());
|
|
break;
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* @return A newly instantiated {@link DeviceOwnerFragment}.
|
|
*/
|
|
public static DeviceOwnerFragment newInstance() {
|
|
return new DeviceOwnerFragment();
|
|
}
|
|
|
|
@Nullable
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, ViewGroup container,
|
|
Bundle savedInstanceState) {
|
|
return inflater.inflate(R.layout.fragment_device_owner, container, false);
|
|
}
|
|
|
|
@Override
|
|
public void onViewCreated(View view, Bundle savedInstanceState) {
|
|
// Retain references
|
|
mSwitchAutoTime = (Switch) view.findViewById(R.id.switch_auto_time);
|
|
mSwitchAutoTimeZone = (Switch) view.findViewById(R.id.switch_auto_time_zone);
|
|
mAvailableLaunchers = (Spinner) view.findViewById(R.id.available_launchers);
|
|
mButtonLauncher = (Button) view.findViewById(R.id.set_preferred_launcher);
|
|
// Bind event handlers
|
|
mSwitchAutoTime.setOnCheckedChangeListener(mOnCheckedChangeListener);
|
|
mSwitchAutoTimeZone.setOnCheckedChangeListener(mOnCheckedChangeListener);
|
|
mButtonLauncher.setOnClickListener(mOnClickListener);
|
|
}
|
|
|
|
@Override
|
|
public void onAttach(Activity activity) {
|
|
super.onAttach(activity);
|
|
mDevicePolicyManager =
|
|
(DevicePolicyManager) activity.getSystemService(Activity.DEVICE_POLICY_SERVICE);
|
|
}
|
|
|
|
@Override
|
|
public void onDetach() {
|
|
mDevicePolicyManager = null;
|
|
super.onDetach();
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
Activity activity = getActivity();
|
|
if (activity != null) {
|
|
retrieveCurrentSettings(activity);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieves the current global settings and changes the UI accordingly.
|
|
*
|
|
* @param activity The activity
|
|
*/
|
|
private void retrieveCurrentSettings(Activity activity) {
|
|
// Global settings
|
|
setCheckedSafely(mSwitchAutoTime,
|
|
getBooleanGlobalSetting(activity.getContentResolver(), Settings.Global.AUTO_TIME));
|
|
setCheckedSafely(mSwitchAutoTimeZone,
|
|
getBooleanGlobalSetting(activity.getContentResolver(),
|
|
Settings.Global.AUTO_TIME_ZONE));
|
|
|
|
// Launcher
|
|
Intent intent = new Intent(Intent.ACTION_MAIN);
|
|
intent.addCategory(Intent.CATEGORY_HOME);
|
|
List<ResolveInfo> list = activity.getPackageManager()
|
|
.queryIntentActivities(intent, /* default flags */ 0);
|
|
mAdapter = new LauncherAdapter(activity, list);
|
|
mAvailableLaunchers.setAdapter(mAdapter);
|
|
String packageName = loadPersistentPreferredLauncher(activity);
|
|
if (packageName == null) { // No preferred launcher is set
|
|
mAvailableLaunchers.setEnabled(true);
|
|
mButtonLauncher.setText(R.string.set_as_preferred);
|
|
} else {
|
|
int position = -1;
|
|
for (int i = 0; i < list.size(); ++i) {
|
|
if (list.get(i).activityInfo.packageName.equals(packageName)) {
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
if (position != -1) {
|
|
mAvailableLaunchers.setSelection(position);
|
|
mAvailableLaunchers.setEnabled(false);
|
|
mButtonLauncher.setText(R.string.clear_preferred);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieves the current boolean value of the specified global setting.
|
|
*
|
|
* @param resolver The ContentResolver
|
|
* @param setting The setting to be retrieved
|
|
* @return The current boolean value
|
|
*/
|
|
private static boolean getBooleanGlobalSetting(ContentResolver resolver, String setting) {
|
|
return 0 != Settings.Global.getInt(resolver, setting, 0);
|
|
}
|
|
|
|
/**
|
|
* Sets the boolean value of the specified global setting.
|
|
*
|
|
* @param setting The setting to be set
|
|
* @param value The value to be set
|
|
*/
|
|
private void setBooleanGlobalSetting(String setting, boolean value) {
|
|
mDevicePolicyManager.setGlobalSetting(
|
|
// The ComponentName of the device owner
|
|
DeviceOwnerReceiver.getComponentName(getActivity()),
|
|
// The settings to be set
|
|
setting,
|
|
// The value we write here is a string representation for SQLite
|
|
value ? "1" : "0");
|
|
}
|
|
|
|
/**
|
|
* A utility method to set the checked state of the button without invoking its listener.
|
|
*
|
|
* @param button The button
|
|
* @param checked The value to be set
|
|
*/
|
|
private void setCheckedSafely(CompoundButton button, boolean checked) {
|
|
button.setOnCheckedChangeListener(null);
|
|
button.setChecked(checked);
|
|
button.setOnCheckedChangeListener(mOnCheckedChangeListener);
|
|
}
|
|
|
|
/**
|
|
* Loads the package name from SharedPreferences.
|
|
*
|
|
* @param activity The activity
|
|
* @return The package name of the launcher currently set as preferred, or null if there is no
|
|
* preferred launcher.
|
|
*/
|
|
private static String loadPersistentPreferredLauncher(Activity activity) {
|
|
return activity.getSharedPreferences(PREFS_DEVICE_OWNER, Context.MODE_PRIVATE)
|
|
.getString(PREF_LAUNCHER, null);
|
|
}
|
|
|
|
/**
|
|
* Saves the package name into SharedPreferences.
|
|
*
|
|
* @param activity The activity
|
|
* @param packageName The package name to be saved. Pass null to remove the preferred launcher.
|
|
*/
|
|
private static void savePersistentPreferredLauncher(Activity activity, String packageName) {
|
|
SharedPreferences.Editor editor = activity.getSharedPreferences(PREFS_DEVICE_OWNER,
|
|
Context.MODE_PRIVATE).edit();
|
|
if (packageName == null) {
|
|
editor.remove(PREF_LAUNCHER);
|
|
} else {
|
|
editor.putString(PREF_LAUNCHER, packageName);
|
|
}
|
|
editor.apply();
|
|
}
|
|
|
|
/**
|
|
* Sets the selected launcher as preferred.
|
|
*/
|
|
private void setPreferredLauncher() {
|
|
Activity activity = getActivity();
|
|
if (activity == null) {
|
|
return;
|
|
}
|
|
IntentFilter filter = new IntentFilter(Intent.ACTION_MAIN);
|
|
filter.addCategory(Intent.CATEGORY_HOME);
|
|
filter.addCategory(Intent.CATEGORY_DEFAULT);
|
|
ComponentName componentName = mAdapter.getComponentName(
|
|
mAvailableLaunchers.getSelectedItemPosition());
|
|
mDevicePolicyManager.addPersistentPreferredActivity(
|
|
DeviceOwnerReceiver.getComponentName(activity), filter, componentName);
|
|
savePersistentPreferredLauncher(activity, componentName.getPackageName());
|
|
}
|
|
|
|
/**
|
|
* Clears the launcher currently set as preferred.
|
|
*/
|
|
private void clearPreferredLauncher() {
|
|
Activity activity = getActivity();
|
|
if (activity == null) {
|
|
return;
|
|
}
|
|
mDevicePolicyManager.clearPackagePersistentPreferredActivities(
|
|
DeviceOwnerReceiver.getComponentName(activity),
|
|
loadPersistentPreferredLauncher(activity));
|
|
savePersistentPreferredLauncher(activity, null);
|
|
}
|
|
|
|
/**
|
|
* Shows list of {@link ResolveInfo} in a {@link Spinner}.
|
|
*/
|
|
private static class LauncherAdapter extends SimpleAdapter {
|
|
|
|
private static final String KEY_PACKAGE_NAME = "package_name";
|
|
private static final String KEY_ACTIVITY_NAME = "activity_name";
|
|
|
|
public LauncherAdapter(Context context, List<ResolveInfo> list) {
|
|
super(context, createData(list), android.R.layout.simple_list_item_1,
|
|
new String[]{KEY_PACKAGE_NAME},
|
|
new int[]{android.R.id.text1});
|
|
}
|
|
|
|
private static List<HashMap<String, String>> createData(List<ResolveInfo> list) {
|
|
List<HashMap<String, String>> data = new ArrayList<>();
|
|
for (ResolveInfo info : list) {
|
|
HashMap<String, String> map = new HashMap<>();
|
|
map.put(KEY_PACKAGE_NAME, info.activityInfo.packageName);
|
|
map.put(KEY_ACTIVITY_NAME, info.activityInfo.name);
|
|
data.add(map);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
public ComponentName getComponentName(int position) {
|
|
@SuppressWarnings("unchecked")
|
|
HashMap<String, String> map = (HashMap<String, String>) getItem(position);
|
|
return new ComponentName(map.get(KEY_PACKAGE_NAME), map.get(KEY_ACTIVITY_NAME));
|
|
}
|
|
|
|
}
|
|
|
|
}
|