public void resume() {
final ContentResolver cr = mContext.getContentResolver();
cr.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.DEFAULT_INPUT_METHOD), false, this);
cr.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.SELECTED_INPUT_METHOD_SUBTYPE), false, this);
}
private class SettingsObserver extends ContentObserver {
private final Uri mSecureSettingsUri = Settings.Secure.getUriFor(mConfig.secureSettingName);
private SettingsObserver(Handler handler) {
super(handler);
}
private void observe() {
ContentResolver resolver = mContext.getContentResolver();
resolver.registerContentObserver(mSecureSettingsUri, false, this, UserHandle.USER_ALL);
update(null);
}
@Override
public void onChange(boolean selfChange, Uri uri) {
update(uri);
}
private void update(Uri uri) {
if (uri == null || mSecureSettingsUri.equals(uri)) {
if (DEBUG)
Slog.d(
TAG, "Setting changed: mSecureSettingsUri=" + mSecureSettingsUri + " / uri=" + uri);
rebindServices();
}
}
}
public NetworkAdbTile(Context context, QuickSettingsController qsc) {
super(context, qsc);
mOnClick =
new View.OnClickListener() {
@Override
public void onClick(View v) {
Settings.Secure.putIntForUser(
mContext.getContentResolver(),
Settings.Secure.ADB_PORT,
isEnabled() ? -1 : 5555,
UserHandle.USER_CURRENT);
}
};
mOnLongClick =
new View.OnLongClickListener() {
@Override
public boolean onLongClick(View v) {
startSettingsActivity(Settings.ACTION_APPLICATION_DEVELOPMENT_SETTINGS);
return true;
}
};
qsc.registerObservedContent(Settings.Secure.getUriFor(Settings.Secure.ADB_PORT), this);
updateResources();
}
@Override
public void onCreate() {
super.onCreate();
final Resources res = getResources();
mGranularityTypes = res.getStringArray(R.array.granularity_types);
mGranularitySet = res.getString(R.string.set_granularity);
mActionTypes = res.getStringArray(R.array.action_types);
mActionSet = res.getString(R.string.set_action);
mAltString = res.getString(R.string.alt_pressed);
mShiftString = res.getString(R.string.shift_pressed);
mPreviousDpadDownEvent = null;
mWasUpDownPressed = false;
mUserCommandHandler = new UserCommandHandler(this);
mAccessibilityManager = (AccessibilityManager) getSystemService(ACCESSIBILITY_SERVICE);
// Register content observer to receive accessibility status changes.
getContentResolver()
.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.ACCESSIBILITY_ENABLED),
false,
mAccessibilityObserver);
updateAccessibilityState();
}
void registerObserver() {
getContext()
.getContentResolver()
.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.APP_IDLE_DURATION),
false,
this,
UserHandle.USER_OWNER);
}
private void registerFingerSwitchObserver() {
readFingerprintSwitchValue();
mContext
.getContentResolver()
.registerContentObserver(
Settings.Secure.getUriFor(FINGERPRINT_FOR_UNLOCK_SWITCH_KEY),
false,
new FingerSwitchContentObserver(mFingerHandler));
}
void observe() {
ContentResolver resolver = mContext.getContentResolver();
resolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.QS_SHOW_BRIGHTNESS_SLIDER),
false,
this,
UserHandle.USER_ALL);
resolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.System.QUICK_SETTINGS_TILES_VIBRATE),
false,
this,
UserHandle.USER_ALL);
resolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.QS_USE_FOUR_COLUMNS),
false,
this,
UserHandle.USER_ALL);
update();
}
public void register() {
if (mRegistered) {
mContext.getContentResolver().unregisterContentObserver(this);
}
mContext
.getContentResolver()
.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.QS_TILES),
false,
this,
mUserTracker.getCurrentUserId());
mContext
.getContentResolver()
.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.QS_USE_MAIN_TILES),
false,
this,
mUserTracker.getCurrentUserId());
mRegistered = true;
}
public AssistManager(BaseStatusBar bar, Context context) {
mContext = context;
mBar = bar;
mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
mAssistUtils = new AssistUtils(context);
mContext
.getContentResolver()
.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.ASSISTANT), false, mAssistSettingsObserver);
mAssistSettingsObserver.onChange(false);
mAssistDisclosure = new AssistDisclosure(context, new Handler());
}
public UsbHandler(Looper looper) {
super(looper);
try {
// Restore default functions.
mCurrentFunctions = SystemProperties.get(USB_CONFIG_PROPERTY, UsbManager.USB_FUNCTION_NONE);
if (UsbManager.USB_FUNCTION_NONE.equals(mCurrentFunctions)) {
mCurrentFunctions = UsbManager.USB_FUNCTION_MTP;
}
mCurrentFunctionsApplied =
mCurrentFunctions.equals(SystemProperties.get(USB_STATE_PROPERTY));
mAdbEnabled =
UsbManager.containsFunction(getDefaultFunctions(), UsbManager.USB_FUNCTION_ADB);
setEnabledFunctions(null, false);
String state = FileUtils.readTextFile(new File(STATE_PATH), 0, null).trim();
updateState(state);
// register observer to listen for settings changes
mContentResolver.registerContentObserver(
Settings.Global.getUriFor(Settings.Global.ADB_ENABLED),
false,
new AdbSettingsObserver());
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.ADB_NOTIFY),
false,
new ContentObserver(null) {
public void onChange(boolean selfChange) {
updateAdbNotification();
}
});
// Watch for USB configuration changes
mUEventObserver.startObserving(USB_STATE_MATCH);
mUEventObserver.startObserving(ACCESSORY_START_MATCH);
} catch (Exception e) {
Slog.e(TAG, "Error initializing UsbHandler", e);
}
}
public UsbHandler(Looper looper) {
super(looper);
try {
// persist.sys.usb.config should never be unset. But if it is, set it to "adb"
// so we have a chance of debugging what happened.
mDefaultFunctions = SystemProperties.get("persist.sys.usb.config", "adb");
// Check if USB mode needs to be overridden depending on OEM specific bootmode.
mDefaultFunctions = processOemUsbOverride(mDefaultFunctions);
// sanity check the sys.usb.config system property
// this may be necessary if we crashed while switching USB configurations
String config = SystemProperties.get("sys.usb.config", "none");
if (!config.equals(mDefaultFunctions)) {
Slog.w(TAG, "resetting config to persistent property: " + mDefaultFunctions);
SystemProperties.set("sys.usb.config", mDefaultFunctions);
}
mCurrentFunctions = mDefaultFunctions;
String state = FileUtils.readTextFile(new File(STATE_PATH), 0, null).trim();
updateState(state);
mAdbEnabled = containsFunction(mCurrentFunctions, UsbManager.USB_FUNCTION_ADB);
// Upgrade step for previous versions that used persist.service.adb.enable
String value = SystemProperties.get("persist.service.adb.enable", "");
if (value.length() > 0) {
char enable = value.charAt(0);
if (enable == '1') {
setAdbEnabled(true);
} else if (enable == '0') {
setAdbEnabled(false);
}
SystemProperties.set("persist.service.adb.enable", "");
}
// register observer to listen for settings changes
mContentResolver.registerContentObserver(
Settings.Global.getUriFor(Settings.Global.ADB_ENABLED),
false,
new AdbSettingsObserver());
mContentResolver.registerContentObserver(
Settings.Secure.getUriFor(Settings.Secure.ADB_NOTIFY),
false,
new ContentObserver(null) {
public void onChange(boolean selfChange) {
updateAdbNotification();
}
});
// Watch for USB configuration changes
mUEventObserver.startObserving(USB_STATE_MATCH);
mUEventObserver.startObserving(ACCESSORY_START_MATCH);
mContext.registerReceiver(
mBootCompletedReceiver, new IntentFilter(Intent.ACTION_BOOT_COMPLETED));
mContext.registerReceiver(
mUserSwitchedReceiver, new IntentFilter(Intent.ACTION_USER_SWITCHED));
} catch (Exception e) {
Slog.e(TAG, "Error initializing UsbHandler", e);
}
}
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
private void registerTouchSettingObserver() {
final Uri uri = Settings.Secure.getUriFor(Settings.Secure.TOUCH_EXPLORATION_ENABLED);
getContentResolver().registerContentObserver(uri, false, mTouchExploreObserver);
}