/*
* 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));
}
}
}