/*
* Copyright (C) 2014 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.search;
import android.accessibilityservice.AccessibilityService;
import android.accessibilityservice.AccessibilityServiceInfo;
import android.app.Activity;
import android.app.LoaderManager;
import android.content.Context;
import android.content.Intent;
import android.content.Loader;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.database.ContentObserver;
import android.hardware.input.InputManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.UserHandle;
import android.os.UserManager;
import android.print.PrintManager;
import android.print.PrintServicesLoader;
import android.printservice.PrintServiceInfo;
import android.provider.UserDictionary;
import android.util.Log;
import android.view.accessibility.AccessibilityManager;
import android.view.inputmethod.InputMethodInfo;
import android.view.inputmethod.InputMethodManager;
import com.android.internal.content.PackageMonitor;
import com.android.settings.accessibility.AccessibilitySettings;
import com.android.settings.inputmethod.InputMethodAndLanguageSettings;
import com.android.settings.print.PrintSettingsFragment;
import java.util.ArrayList;
import java.util.List;
public final class DynamicIndexableContentMonitor extends PackageMonitor implements
InputManager.InputDeviceListener,
LoaderManager.LoaderCallbacks<List<PrintServiceInfo>> {
private static final String TAG = "DynamicIndexableContentMonitor";
private static final long DELAY_PROCESS_PACKAGE_CHANGE = 2000;
private static final int MSG_PACKAGE_AVAILABLE = 1;
private static final int MSG_PACKAGE_UNAVAILABLE = 2;
private final List<String> mAccessibilityServices = new ArrayList<String>();
private final List<String> mImeServices = new ArrayList<String>();
private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_PACKAGE_AVAILABLE: {
String packageName = (String) msg.obj;
handlePackageAvailable(packageName);
} break;
case MSG_PACKAGE_UNAVAILABLE: {
String packageName = (String) msg.obj;
handlePackageUnavailable(packageName);
} break;
}
}
};
private final ContentObserver mUserDictionaryContentObserver =
new UserDictionaryContentObserver(mHandler);
private Context mContext;
private boolean mHasFeatureIme;
private boolean mRegistered;
private static Intent getAccessibilityServiceIntent(String packageName) {
final Intent intent = new Intent(AccessibilityService.SERVICE_INTERFACE);
intent.setPackage(packageName);
return intent;
}
private static Intent getIMEServiceIntent(String packageName) {
final Intent intent = new Intent("android.view.InputMethod");
intent.setPackage(packageName);
return intent;
}
public void register(Activity activity, int loaderId) {
mContext = activity;
if (!mContext.getSystemService(UserManager.class).isUserUnlocked()) {
Log.w(TAG, "Skipping content monitoring because user is locked");
mRegistered = false;
return;
} else {
mRegistered = true;
}
boolean hasFeaturePrinting = mContext.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_PRINTING);
mHasFeatureIme = mContext.getPackageManager().hasSystemFeature(
PackageManager.FEATURE_INPUT_METHODS);
// Cache accessibility service packages to know when they go away.
AccessibilityManager accessibilityManager = (AccessibilityManager)
mContext.getSystemService(Context.ACCESSIBILITY_SERVICE);
List<AccessibilityServiceInfo> accessibilityServices = accessibilityManager
.getInstalledAccessibilityServiceList();
final int accessibilityServiceCount = accessibilityServices.size();
for (int i = 0; i < accessibilityServiceCount; i++) {
AccessibilityServiceInfo accessibilityService = accessibilityServices.get(i);
ResolveInfo resolveInfo = accessibilityService.getResolveInfo();
if (resolveInfo == null || resolveInfo.serviceInfo == null) {
continue;
}
mAccessibilityServices.add(resolveInfo.serviceInfo.packageName);
}
if (hasFeaturePrinting) {
activity.getLoaderManager().initLoader(loaderId, null, this);
}
// Cache IME service packages to know when they go away.
if (mHasFeatureIme) {
InputMethodManager imeManager = (InputMethodManager)
mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
List<InputMethodInfo> inputMethods = imeManager.getInputMethodList();
final int inputMethodCount = inputMethods.size();
for (int i = 0; i < inputMethodCount; i++) {
InputMethodInfo inputMethod = inputMethods.get(i);
ServiceInfo serviceInfo = inputMethod.getServiceInfo();
if (serviceInfo == null) continue;
mImeServices.add(serviceInfo.packageName);
}
// Watch for related content URIs.
mContext.getContentResolver().registerContentObserver(
UserDictionary.Words.CONTENT_URI, true, mUserDictionaryContentObserver);
}
// Watch for input device changes.
InputManager inputManager = (InputManager) activity.getSystemService(
Context.INPUT_SERVICE);
inputManager.registerInputDeviceListener(this, mHandler);
// Start tracking packages.
register(activity, Looper.getMainLooper(), UserHandle.CURRENT, false);
}
@Override
public void unregister() {
if (!mRegistered) return;
super.unregister();
InputManager inputManager = (InputManager) mContext.getSystemService(
Context.INPUT_SERVICE);
inputManager.unregisterInputDeviceListener(this);
if (mHasFeatureIme) {
mContext.getContentResolver().unregisterContentObserver(
mUserDictionaryContentObserver);
}
mAccessibilityServices.clear();
mImeServices.clear();
}
// Covers installed, appeared external storage with the package, upgraded.
@Override
public void onPackageAppeared(String packageName, int uid) {
postMessage(MSG_PACKAGE_AVAILABLE, packageName);
}
// Covers uninstalled, removed external storage with the package.
@Override
public void onPackageDisappeared(String packageName, int uid) {
postMessage(MSG_PACKAGE_UNAVAILABLE, packageName);
}
// Covers enabled, disabled.
@Override
public void onPackageModified(String packageName) {
super.onPackageModified(packageName);
try {
final int state = mContext.getPackageManager().getApplicationEnabledSetting(
packageName);
if (state == PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
|| state == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
postMessage(MSG_PACKAGE_AVAILABLE, packageName);
} else {
postMessage(MSG_PACKAGE_UNAVAILABLE, packageName);
}
} catch (IllegalArgumentException e) {
Log.e(TAG, "Package does not exist: " + packageName, e);
}
}
@Override
public void onInputDeviceAdded(int deviceId) {
Index.getInstance(mContext).updateFromClassNameResource(
InputMethodAndLanguageSettings.class.getName(), false, true);
}
@Override
public void onInputDeviceRemoved(int deviceId) {
onInputDeviceChanged(deviceId);
}
@Override
public void onInputDeviceChanged(int deviceId) {
Index.getInstance(mContext).updateFromClassNameResource(
InputMethodAndLanguageSettings.class.getName(), true, true);
}
private void postMessage(int what, String packageName) {
Message message = mHandler.obtainMessage(what, packageName);
mHandler.sendMessageDelayed(message, DELAY_PROCESS_PACKAGE_CHANGE);
}
private void handlePackageAvailable(String packageName) {
if (!mAccessibilityServices.contains(packageName)) {
final Intent intent = getAccessibilityServiceIntent(packageName);
List<?> services = mContext.getPackageManager().queryIntentServices(intent, 0);
if (services != null && !services.isEmpty()) {
mAccessibilityServices.add(packageName);
Index.getInstance(mContext).updateFromClassNameResource(
AccessibilitySettings.class.getName(), false, true);
}
}
if (mHasFeatureIme) {
if (!mImeServices.contains(packageName)) {
Intent intent = getIMEServiceIntent(packageName);
List<?> services = mContext.getPackageManager().queryIntentServices(intent, 0);
if (services != null && !services.isEmpty()) {
mImeServices.add(packageName);
Index.getInstance(mContext).updateFromClassNameResource(
InputMethodAndLanguageSettings.class.getName(), false, true);
}
}
}
}
private void handlePackageUnavailable(String packageName) {
final int accessibilityIndex = mAccessibilityServices.indexOf(packageName);
if (accessibilityIndex >= 0) {
mAccessibilityServices.remove(accessibilityIndex);
Index.getInstance(mContext).updateFromClassNameResource(
AccessibilitySettings.class.getName(), true, true);
}
if (mHasFeatureIme) {
final int imeIndex = mImeServices.indexOf(packageName);
if (imeIndex >= 0) {
mImeServices.remove(imeIndex);
Index.getInstance(mContext).updateFromClassNameResource(
InputMethodAndLanguageSettings.class.getName(), true, true);
}
}
}
@Override
public Loader<List<PrintServiceInfo>> onCreateLoader(int id, Bundle args) {
return new PrintServicesLoader(
(PrintManager) mContext.getSystemService(Context.PRINT_SERVICE), mContext,
PrintManager.ALL_SERVICES);
}
@Override
public void onLoadFinished(Loader<List<PrintServiceInfo>> loader,
List<PrintServiceInfo> services) {
Index.getInstance(mContext).updateFromClassNameResource(
PrintSettingsFragment.class.getName(), false, true);
}
@Override
public void onLoaderReset(Loader<List<PrintServiceInfo>> loader) {
// nothing to do
}
private final class UserDictionaryContentObserver extends ContentObserver {
public UserDictionaryContentObserver(Handler handler) {
super(handler);
}
@Override
public void onChange(boolean selfChange, Uri uri) {
if (UserDictionary.Words.CONTENT_URI.equals(uri)) {
Index.getInstance(mContext).updateFromClassNameResource(
InputMethodAndLanguageSettings.class.getName(), true, true);
}
};
}
}