use of com.android.internal.statusbar.IStatusBarService in project android_frameworks_base by ResurrectionRemix.
the class PieAction method processActionWithOptions.
public static void processActionWithOptions(Context context, String action, boolean isLongpress, boolean collapseShade) {
if (action == null || action.equals(PieConstants.NULL_BUTTON)) {
return;
}
boolean isKeyguardShowing = false;
try {
isKeyguardShowing = WindowManagerGlobal.getWindowManagerService().isKeyguardLocked();
} catch (RemoteException e) {
Log.w("Action", "Error getting window manager service", e);
}
final IStatusBarService barService = IStatusBarService.Stub.asInterface(ServiceManager.getService(Context.STATUS_BAR_SERVICE));
if (barService == null) {
// ouch
return;
}
final IWindowManager windowManagerService = IWindowManager.Stub.asInterface(ServiceManager.getService(Context.WINDOW_SERVICE));
if (windowManagerService == null) {
// ouch
return;
}
boolean isKeyguardSecure = false;
try {
isKeyguardSecure = windowManagerService.isKeyguardSecure();
} catch (RemoteException e) {
Log.w("Action", "Error getting window manager service", e);
}
if (collapseShade) {
if (!action.equals(PieConstants.SETTINGS_PANEL_BUTTON) && !action.equals(PieConstants.NOTIFICATIONS_BUTTON) && !action.equals(PieConstants.THEME_SWITCH_BUTTON)) {
try {
barService.collapsePanels();
} catch (RemoteException ex) {
}
}
}
// process the actions
if (action.equals(PieConstants.HOME_BUTTON)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_HOME, isLongpress);
return;
} else if (action.equals(PieConstants.BACK_BUTTON)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_BACK, isLongpress);
return;
} else if (action.equals(PieConstants.MENU_BUTTON) || action.equals(PieConstants.MENU_BIG_BUTTON)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_MENU, isLongpress);
return;
} else if (action.equals(PieConstants.KILL_TASK_BUTTON)) {
if (isKeyguardShowing) {
return;
}
try {
barService.toggleKillApp();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.NOTIFICATIONS_BUTTON)) {
if (isKeyguardShowing && isKeyguardSecure) {
return;
}
try {
barService.expandNotificationsPanel();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.SETTINGS_PANEL_BUTTON)) {
if (isKeyguardShowing && isKeyguardSecure) {
return;
}
try {
barService.expandSettingsPanel(null);
} catch (RemoteException e) {
}
} else if (action.equals(PieConstants.LAST_APP_BUTTON)) {
if (isKeyguardShowing) {
return;
}
try {
barService.toggleLastApp();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.RECENT_BUTTON)) {
if (isKeyguardShowing) {
return;
}
try {
barService.toggleRecentApps();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.SCREENSHOT_BUTTON)) {
try {
barService.toggleScreenshot();
} catch (RemoteException e) {
}
return;
} else {
// we must have a custom uri
Intent intent = null;
try {
intent = Intent.parseUri(action, 0);
} catch (URISyntaxException e) {
Log.e("PieAction:", "URISyntaxException: [" + action + "]");
return;
}
startActivity(context, intent, barService, isKeyguardShowing);
return;
}
}
use of com.android.internal.statusbar.IStatusBarService in project android_frameworks_base by ResurrectionRemix.
the class Action method processActionWithOptions.
public static void processActionWithOptions(Context context, String action, boolean isLongpress, boolean collapseShade) {
if (action == null || action.equals(ActionConstants.ACTION_NULL)) {
return;
}
boolean isKeyguardShowing = false;
try {
isKeyguardShowing = WindowManagerGlobal.getWindowManagerService().isKeyguardLocked();
} catch (RemoteException e) {
Log.w("Action", "Error getting window manager service", e);
}
IStatusBarService barService = IStatusBarService.Stub.asInterface(ServiceManager.getService(Context.STATUS_BAR_SERVICE));
if (barService == null) {
// ouch
return;
}
// process the actions
if (action.equals(ActionConstants.ACTION_HOME)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_HOME, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_BACK)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_BACK, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_SEARCH)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_SEARCH, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_MENU) || action.equals(ActionConstants.ACTION_MENU_BIG)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_MENU, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_IME_NAVIGATION_LEFT)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_DPAD_LEFT, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_IME_NAVIGATION_RIGHT)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_DPAD_RIGHT, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_IME_NAVIGATION_UP)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_DPAD_UP, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_IME_NAVIGATION_DOWN)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_DPAD_DOWN, isLongpress);
return;
} else if (action.equals(ActionConstants.ACTION_POWER)) {
PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
pm.goToSleep(SystemClock.uptimeMillis());
return;
} else if (action.equals(ActionConstants.ACTION_IME)) {
if (isKeyguardShowing) {
return;
}
context.sendBroadcastAsUser(new Intent("android.settings.SHOW_INPUT_METHOD_PICKER"), new UserHandle(UserHandle.USER_CURRENT));
return;
} else if (action.equals(ActionConstants.ACTION_VOICE_SEARCH)) {
// launch the search activity
Intent intent = new Intent(Intent.ACTION_SEARCH_LONG_PRESS);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
// TODO: This only stops the factory-installed search manager.
// Need to formalize an API to handle others
SearchManager searchManager = (SearchManager) context.getSystemService(Context.SEARCH_SERVICE);
if (searchManager != null) {
searchManager.stopSearch();
}
startActivity(context, intent, barService, isKeyguardShowing);
} catch (ActivityNotFoundException e) {
Log.e("SlimActions:", "No activity to handle assist long press action.", e);
}
return;
} else if (action.equals(ActionConstants.ACTION_VIB)) {
AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
if (am != null && ActivityManagerNative.isSystemReady()) {
if (am.getRingerMode() != AudioManager.RINGER_MODE_VIBRATE) {
am.setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
Vibrator vib = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
if (vib != null) {
vib.vibrate(50);
}
} else {
am.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
ToneGenerator tg = new ToneGenerator(AudioManager.STREAM_NOTIFICATION, (int) (ToneGenerator.MAX_VOLUME * 0.85));
if (tg != null) {
tg.startTone(ToneGenerator.TONE_PROP_BEEP);
}
}
}
return;
} else if (action.equals(ActionConstants.ACTION_SILENT)) {
AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
if (am != null && ActivityManagerNative.isSystemReady()) {
if (am.getRingerMode() != AudioManager.RINGER_MODE_SILENT) {
am.setRingerMode(AudioManager.RINGER_MODE_SILENT);
} else {
am.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
ToneGenerator tg = new ToneGenerator(AudioManager.STREAM_NOTIFICATION, (int) (ToneGenerator.MAX_VOLUME * 0.85));
if (tg != null) {
tg.startTone(ToneGenerator.TONE_PROP_BEEP);
}
}
}
return;
} else if (action.equals(ActionConstants.ACTION_VIB_SILENT)) {
AudioManager am = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
if (am != null && ActivityManagerNative.isSystemReady()) {
if (am.getRingerMode() == AudioManager.RINGER_MODE_NORMAL) {
am.setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
Vibrator vib = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
if (vib != null) {
vib.vibrate(50);
}
} else if (am.getRingerMode() == AudioManager.RINGER_MODE_VIBRATE) {
am.setRingerMode(AudioManager.RINGER_MODE_SILENT);
} else {
am.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
ToneGenerator tg = new ToneGenerator(AudioManager.STREAM_NOTIFICATION, (int) (ToneGenerator.MAX_VOLUME * 0.85));
if (tg != null) {
tg.startTone(ToneGenerator.TONE_PROP_BEEP);
}
}
}
return;
} else if (action.equals(ActionConstants.ACTION_CAMERA)) {
// ToDo: Send for secure keyguard secure camera intent.
// We need to add support for it first.
Intent intent = new Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA, null);
startActivity(context, intent, barService, isKeyguardShowing);
return;
} else if (action.equals(ActionConstants.ACTION_MEDIA_PREVIOUS)) {
dispatchMediaKeyWithWakeLock(KeyEvent.KEYCODE_MEDIA_PREVIOUS, context);
return;
} else if (action.equals(ActionConstants.ACTION_MEDIA_NEXT)) {
dispatchMediaKeyWithWakeLock(KeyEvent.KEYCODE_MEDIA_NEXT, context);
return;
} else if (action.equals(ActionConstants.ACTION_MEDIA_PLAY_PAUSE)) {
dispatchMediaKeyWithWakeLock(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE, context);
return;
} else if (action.equals(ActionConstants.ACTION_WAKE_DEVICE)) {
PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
if (!powerManager.isScreenOn()) {
powerManager.wakeUp(SystemClock.uptimeMillis());
}
return;
} else {
// we must have a custom uri
Intent intent = null;
try {
intent = Intent.parseUri(action, 0);
} catch (URISyntaxException e) {
Log.e("SlimActions:", "URISyntaxException: [" + action + "]");
return;
}
startActivity(context, intent, barService, isKeyguardShowing);
return;
}
}
use of com.android.internal.statusbar.IStatusBarService in project android_frameworks_base by ResurrectionRemix.
the class PhoneWindowManager method interceptKeyBeforeDispatching.
/** {@inheritDoc} */
@Override
public long interceptKeyBeforeDispatching(WindowState win, KeyEvent event, int policyFlags) {
final boolean keyguardOn = keyguardOn();
final int repeatCount = event.getRepeatCount();
final int metaState = event.getMetaState();
final int flags = event.getFlags();
final boolean down = event.getAction() == KeyEvent.ACTION_DOWN;
final boolean canceled = event.isCanceled();
final int keyCode = event.getKeyCode();
final boolean longPress = (flags & KeyEvent.FLAG_LONG_PRESS) != 0;
final boolean virtualKey = event.getDeviceId() == KeyCharacterMap.VIRTUAL_KEYBOARD;
final int scanCode = event.getScanCode();
if (DEBUG_INPUT) {
Log.d(TAG, "interceptKeyTi keyCode=" + keyCode + " down=" + down + " repeatCount=" + repeatCount + " keyguardOn=" + keyguardOn + " mHomePressed=" + mHomePressed + " canceled=" + canceled);
}
// implementation handle event
if (mKeyHandler != null && !keyguardOn && !virtualKey) {
boolean handled = mKeyHandler.handleKeyEvent(win, keyCode, repeatCount, down, canceled, longPress, keyguardOn);
if (handled)
return -1;
}
// try again later before dispatching.
if (mScreenshotChordEnabled && (flags & KeyEvent.FLAG_FALLBACK) == 0) {
if (mVolumeDownKeyTriggered && !mPowerKeyTriggered) {
final long now = SystemClock.uptimeMillis();
final long timeoutTime = mVolumeDownKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS;
if (now < timeoutTime) {
return timeoutTime - now;
}
}
if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN && mScreenshotChordVolumeDownKeyConsumed) {
if (!down) {
mScreenshotChordVolumeDownKeyConsumed = false;
}
return -1;
}
}
// try again later before dispatching.
if (mScreenrecordChordEnabled && (flags & KeyEvent.FLAG_FALLBACK) == 0) {
if (mVolumeUpKeyTriggered && !mPowerKeyTriggered) {
final long now = SystemClock.uptimeMillis();
final long timeoutTime = mVolumeUpKeyTime + SCREENSHOT_CHORD_DEBOUNCE_DELAY_MILLIS;
if (now < timeoutTime) {
return timeoutTime - now;
}
}
if (keyCode == KeyEvent.KEYCODE_VOLUME_UP && mScreenrecordChordVolumeUpKeyConsumed) {
if (!down) {
mScreenrecordChordVolumeUpKeyConsumed = false;
}
return -1;
}
}
// of the meta key and its corresponding up.
if (mPendingMetaAction && !KeyEvent.isMetaKey(keyCode)) {
mPendingMetaAction = false;
}
// Any key that is not Alt or Meta cancels Caps Lock combo tracking.
if (mPendingCapsLockToggle && !KeyEvent.isMetaKey(keyCode) && !KeyEvent.isAltKey(keyCode)) {
mPendingCapsLockToggle = false;
}
if (keyCode == KeyEvent.KEYCODE_BACK && !down) {
mHandler.removeCallbacks(mBackLongPress);
}
// timeout.
if (keyCode == KeyEvent.KEYCODE_HOME) {
// while it was pressed, then it is time to go home!
if (!down) {
if (mDoubleTapOnHomeBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
mHomePressed = false;
if (mHomeConsumed) {
mHomeConsumed = false;
return -1;
}
if (canceled) {
Log.i(TAG, "Ignoring HOME; event canceled.");
return -1;
}
if ((mRingHomeBehavior & CMSettings.Secure.RING_HOME_BUTTON_BEHAVIOR_ANSWER) != 0) {
final TelecomManager telecomManager = getTelecommService();
if (telecomManager != null && telecomManager.isRinging()) {
telecomManager.acceptRingingCall();
return -1;
}
}
// Delay handling home if a double-tap is possible.
if (mDoubleTapOnHomeBehavior != KEY_ACTION_NOTHING) {
// just in case
mHandler.removeCallbacks(mHomeDoubleTapTimeoutRunnable);
mHomeDoubleTapPending = true;
mHandler.postDelayed(mHomeDoubleTapTimeoutRunnable, ViewConfiguration.getDoubleTapTimeout());
return -1;
}
handleShortPressOnHome();
return -1;
}
// If a system window has focus, then it doesn't make sense
// right now to interact with applications.
WindowManager.LayoutParams attrs = win != null ? win.getAttrs() : null;
if (attrs != null) {
final int type = attrs.type;
if (type == WindowManager.LayoutParams.TYPE_KEYGUARD_SCRIM || type == WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG || (attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) {
// the "app" is keyguard, so give it the key
return 0;
}
final int typeCount = WINDOW_TYPES_WHERE_HOME_DOESNT_WORK.length;
for (int i = 0; i < typeCount; i++) {
if (type == WINDOW_TYPES_WHERE_HOME_DOESNT_WORK[i]) {
// don't do anything, but also don't pass it to the app
return -1;
}
}
}
// Remember that home is pressed and handle special actions.
if (repeatCount == 0) {
mHomePressed = true;
if (mHomeDoubleTapPending) {
mHomeDoubleTapPending = false;
mHandler.removeCallbacks(mHomeDoubleTapTimeoutRunnable);
performKeyAction(mDoubleTapOnHomeBehavior, event);
if (mDoubleTapOnHomeBehavior != KEY_ACTION_SLEEP) {
mHomeConsumed = true;
}
} else if (mLongPressOnHomeBehavior == KEY_ACTION_APP_SWITCH || mDoubleTapOnHomeBehavior == KEY_ACTION_APP_SWITCH) {
preloadRecentApps();
}
} else if (longPress) {
if (!keyguardOn && !mHomeConsumed && mLongPressOnHomeBehavior != KEY_ACTION_NOTHING) {
if (mLongPressOnHomeBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
mHomePressed = true;
performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
performKeyAction(mLongPressOnHomeBehavior, event);
if (mLongPressOnHomeBehavior != KEY_ACTION_SLEEP) {
mHomeConsumed = true;
}
}
}
return -1;
} else if (keyCode == KeyEvent.KEYCODE_MENU) {
// Hijack modified menu keys for debugging features
final int chordBug = KeyEvent.META_SHIFT_ON;
if (virtualKey || keyguardOn) {
// Let the app handle the key
return 0;
}
if (down) {
if (mPressOnMenuBehavior == KEY_ACTION_APP_SWITCH || mLongPressOnMenuBehavior == KEY_ACTION_APP_SWITCH) {
preloadRecentApps();
}
if (repeatCount == 0) {
mMenuPressed = true;
if (mEnableShiftMenuBugReports && (metaState & chordBug) == chordBug) {
Intent intent = new Intent(Intent.ACTION_BUG_REPORT);
mContext.sendOrderedBroadcastAsUser(intent, UserHandle.CURRENT, null, null, null, 0, null, null);
return -1;
}
} else if (longPress) {
if (!keyguardOn && mLongPressOnMenuBehavior != KEY_ACTION_NOTHING) {
if (mLongPressOnMenuBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
performKeyAction(mLongPressOnMenuBehavior, event);
mMenuPressed = false;
return -1;
}
}
}
if (!down && mMenuPressed) {
if (mPressOnMenuBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
mMenuPressed = false;
if (!canceled) {
performKeyAction(mPressOnMenuBehavior, event);
}
}
return -1;
} else if (keyCode == KeyEvent.KEYCODE_SEARCH) {
if (down) {
if (repeatCount == 0) {
mSearchKeyShortcutPending = true;
mConsumeSearchKeyUp = false;
}
} else {
mSearchKeyShortcutPending = false;
if (mConsumeSearchKeyUp) {
mConsumeSearchKeyUp = false;
return -1;
}
}
return 0;
} else if (keyCode == KeyEvent.KEYCODE_APP_SWITCH) {
if (!keyguardOn) {
if (down) {
if (mPressOnAppSwitchBehavior == KEY_ACTION_APP_SWITCH || mLongPressOnAppSwitchBehavior == KEY_ACTION_APP_SWITCH) {
preloadRecentApps();
}
if (repeatCount == 0) {
mAppSwitchLongPressed = false;
} else if (longPress) {
if (!keyguardOn && mLongPressOnAppSwitchBehavior != KEY_ACTION_NOTHING) {
if (mLongPressOnAppSwitchBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
performKeyAction(mLongPressOnAppSwitchBehavior, event);
mAppSwitchLongPressed = true;
}
}
} else {
if (mAppSwitchLongPressed) {
mAppSwitchLongPressed = false;
} else {
if (mPressOnAppSwitchBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
if (!canceled) {
performKeyAction(mPressOnAppSwitchBehavior, event);
}
}
}
}
return -1;
} else if (keyCode == KeyEvent.KEYCODE_N && event.isMetaPressed()) {
if (down) {
IStatusBarService service = getStatusBarService();
if (service != null) {
try {
service.expandNotificationsPanel();
} catch (RemoteException e) {
// do nothing.
}
}
}
} else if (keyCode == KeyEvent.KEYCODE_S && event.isMetaPressed() && event.isCtrlPressed()) {
if (down && repeatCount == 0) {
int type = (event.isShiftPressed() || Settings.System.getInt(mContext.getContentResolver(), Settings.System.SCREENSHOT_TYPE, 0) == 1) ? TAKE_SCREENSHOT_SELECTED_REGION : TAKE_SCREENSHOT_FULLSCREEN;
mScreenshotRunnable.setScreenshotType(type);
mHandler.post(mScreenshotRunnable);
return -1;
}
} else if (keyCode == KeyEvent.KEYCODE_SLASH && event.isMetaPressed()) {
if (down && repeatCount == 0 && !isKeyguardLocked()) {
toggleKeyboardShortcutsMenu(event.getDeviceId());
}
} else if (keyCode == KeyEvent.KEYCODE_ASSIST) {
if (down) {
if (mPressOnAssistBehavior == KEY_ACTION_APP_SWITCH || mLongPressOnAssistBehavior == KEY_ACTION_APP_SWITCH) {
preloadRecentApps();
}
if (repeatCount == 0) {
mAssistKeyLongPressed = false;
} else if (longPress) {
if (!keyguardOn && mLongPressOnAssistBehavior != KEY_ACTION_NOTHING) {
if (mLongPressOnAssistBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
performHapticFeedbackLw(null, HapticFeedbackConstants.LONG_PRESS, false);
performKeyAction(mLongPressOnAssistBehavior, event);
mAssistKeyLongPressed = true;
}
}
} else {
if (mAssistKeyLongPressed) {
mAssistKeyLongPressed = false;
} else {
if (mPressOnAssistBehavior != KEY_ACTION_APP_SWITCH) {
cancelPreloadRecentApps();
}
if (!canceled) {
performKeyAction(mPressOnAssistBehavior, event);
}
}
}
return -1;
} else if (keyCode == KeyEvent.KEYCODE_VOICE_ASSIST) {
if (!down) {
Intent voiceIntent;
if (!keyguardOn) {
voiceIntent = new Intent(RecognizerIntent.ACTION_WEB_SEARCH);
} else {
IDeviceIdleController dic = IDeviceIdleController.Stub.asInterface(ServiceManager.getService(Context.DEVICE_IDLE_CONTROLLER));
if (dic != null) {
try {
dic.exitIdle("voice-search");
} catch (RemoteException e) {
}
}
voiceIntent = new Intent(RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE);
voiceIntent.putExtra(RecognizerIntent.EXTRA_SECURE, true);
}
startActivityAsUser(voiceIntent, UserHandle.CURRENT_OR_SELF);
}
} else if (keyCode == KeyEvent.KEYCODE_SYSRQ) {
if (down && repeatCount == 0) {
if (Settings.System.getInt(mContext.getContentResolver(), Settings.System.SCREENSHOT_TYPE, 0) == 1) {
mScreenshotRunnable.setScreenshotType(TAKE_SCREENSHOT_SELECTED_REGION);
} else {
mScreenshotRunnable.setScreenshotType(TAKE_SCREENSHOT_FULLSCREEN);
}
mHandler.post(mScreenshotRunnable);
}
return -1;
} else if (keyCode == KeyEvent.KEYCODE_BACK) {
// Disable back key if navbar hw keys is set to off
if (scanCode != 0 && isHwKeysDisabled() && !mContext.getResources().getBoolean(com.android.internal.R.bool.config_hwKeysBackAlwaysOn)) {
Log.i(TAG, "Ignoring Back Key: we have hw keys disabled");
return 0;
}
if (Settings.Secure.getIntForUser(mContext.getContentResolver(), Settings.Secure.KILL_APP_LONGPRESS_BACK, 0, UserHandle.USER_CURRENT) == 1) {
if (down && repeatCount == 0) {
mHandler.postDelayed(mBackLongPress, mBackKillTimeout);
}
}
} else if (keyCode == KeyEvent.KEYCODE_BRIGHTNESS_UP || keyCode == KeyEvent.KEYCODE_BRIGHTNESS_DOWN) {
if (down) {
int direction = keyCode == KeyEvent.KEYCODE_BRIGHTNESS_UP ? 1 : -1;
// Disable autobrightness if it's on
int auto = Settings.System.getIntForUser(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE, Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL, UserHandle.USER_CURRENT_OR_SELF);
if (auto != 0) {
Settings.System.putIntForUser(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS_MODE, Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL, UserHandle.USER_CURRENT_OR_SELF);
}
int min = mPowerManager.getMinimumScreenBrightnessSetting();
int max = mPowerManager.getMaximumScreenBrightnessSetting();
int step = (max - min + BRIGHTNESS_STEPS - 1) / BRIGHTNESS_STEPS * direction;
int brightness = Settings.System.getIntForUser(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS, mPowerManager.getDefaultScreenBrightnessSetting(), UserHandle.USER_CURRENT_OR_SELF);
brightness += step;
// Make sure we don't go beyond the limits.
brightness = Math.min(max, brightness);
brightness = Math.max(min, brightness);
Settings.System.putIntForUser(mContext.getContentResolver(), Settings.System.SCREEN_BRIGHTNESS, brightness, UserHandle.USER_CURRENT_OR_SELF);
startActivityAsUser(new Intent(Intent.ACTION_SHOW_BRIGHTNESS_DIALOG), UserHandle.CURRENT_OR_SELF);
}
return -1;
} else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP || keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_MUTE) {
if (mUseTvRouting) {
// On TVs volume keys never go to the foreground app.
dispatchDirectAudioEvent(event);
return -1;
}
}
// Toggle Caps Lock on META-ALT.
boolean actionTriggered = false;
if (KeyEvent.isModifierKey(keyCode)) {
if (!mPendingCapsLockToggle) {
// Start tracking meta state for combo.
mInitialMetaState = mMetaState;
mPendingCapsLockToggle = true;
} else if (event.getAction() == KeyEvent.ACTION_UP) {
int altOnMask = mMetaState & KeyEvent.META_ALT_MASK;
int metaOnMask = mMetaState & KeyEvent.META_META_MASK;
// Check for Caps Lock toggle
if ((metaOnMask != 0) && (altOnMask != 0)) {
// Check if nothing else is pressed
if (mInitialMetaState == (mMetaState ^ (altOnMask | metaOnMask))) {
// Handle Caps Lock Toggle
mInputManagerInternal.toggleCapsLock(event.getDeviceId());
actionTriggered = true;
}
}
// Always stop tracking when key goes up.
mPendingCapsLockToggle = false;
}
}
// Store current meta state to be able to evaluate it later.
mMetaState = metaState;
if (actionTriggered) {
return -1;
}
if (KeyEvent.isMetaKey(keyCode)) {
if (down) {
mPendingMetaAction = true;
} else if (mPendingMetaAction) {
launchAssistAction(Intent.EXTRA_ASSIST_INPUT_HINT_KEYBOARD, event.getDeviceId());
}
return -1;
} else if (keyCode == KeyEvent.KEYCODE_BACK) {
if (unpinActivity(true) || CMSettings.Secure.getInt(mContext.getContentResolver(), CMSettings.Secure.KILL_APP_LONGPRESS_BACK, 0) == 1) {
if (down && repeatCount == 0) {
mHandler.postDelayed(mBackLongPress, mBackKillTimeout);
}
}
}
// shortcut keys (that emit Search+x) and some of them are not registered.
if (mSearchKeyShortcutPending) {
final KeyCharacterMap kcm = event.getKeyCharacterMap();
if (kcm.isPrintingKey(keyCode)) {
mConsumeSearchKeyUp = true;
mSearchKeyShortcutPending = false;
if (down && repeatCount == 0 && !keyguardOn) {
Intent shortcutIntent = mShortcutManager.getIntent(kcm, keyCode, metaState);
if (shortcutIntent != null) {
shortcutIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
startActivityAsUser(shortcutIntent, UserHandle.CURRENT);
dismissKeyboardShortcutsMenu();
} catch (ActivityNotFoundException ex) {
Slog.w(TAG, "Dropping shortcut key combination because " + "the activity to which it is registered was not found: " + "SEARCH+" + KeyEvent.keyCodeToString(keyCode), ex);
}
} else {
Slog.i(TAG, "Dropping unregistered shortcut key combination: " + "SEARCH+" + KeyEvent.keyCodeToString(keyCode));
}
}
return -1;
}
}
// Invoke shortcuts using Meta.
if (down && repeatCount == 0 && !keyguardOn && (metaState & KeyEvent.META_META_ON) != 0) {
final KeyCharacterMap kcm = event.getKeyCharacterMap();
if (kcm.isPrintingKey(keyCode)) {
Intent shortcutIntent = mShortcutManager.getIntent(kcm, keyCode, metaState & ~(KeyEvent.META_META_ON | KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_RIGHT_ON));
if (shortcutIntent != null) {
shortcutIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
startActivityAsUser(shortcutIntent, UserHandle.CURRENT);
dismissKeyboardShortcutsMenu();
} catch (ActivityNotFoundException ex) {
Slog.w(TAG, "Dropping shortcut key combination because " + "the activity to which it is registered was not found: " + "META+" + KeyEvent.keyCodeToString(keyCode), ex);
}
return -1;
}
}
}
// Handle application launch keys.
if (down && repeatCount == 0 && !keyguardOn) {
String category = sApplicationLaunchKeyCategories.get(keyCode);
if (category != null) {
Intent intent = Intent.makeMainSelectorActivity(Intent.ACTION_MAIN, category);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
startActivityAsUser(intent, UserHandle.CURRENT);
dismissKeyboardShortcutsMenu();
} catch (ActivityNotFoundException ex) {
Slog.w(TAG, "Dropping application launch key because " + "the activity to which it is registered was not found: " + "keyCode=" + keyCode + ", category=" + category, ex);
}
return -1;
}
}
// Display task switcher for ALT-TAB.
if (down && repeatCount == 0 && keyCode == KeyEvent.KEYCODE_TAB) {
if (mRecentAppsHeldModifiers == 0 && !keyguardOn && isUserSetupComplete()) {
final int shiftlessModifiers = event.getModifiers() & ~KeyEvent.META_SHIFT_MASK;
if (KeyEvent.metaStateHasModifiers(shiftlessModifiers, KeyEvent.META_ALT_ON)) {
mRecentAppsHeldModifiers = shiftlessModifiers;
showRecentApps(true, false);
return -1;
}
}
} else if (!down && mRecentAppsHeldModifiers != 0 && (metaState & mRecentAppsHeldModifiers) == 0) {
mRecentAppsHeldModifiers = 0;
hideRecentApps(true, false);
}
// Handle input method switching.
if (down && repeatCount == 0 && (keyCode == KeyEvent.KEYCODE_LANGUAGE_SWITCH || (keyCode == KeyEvent.KEYCODE_SPACE && (metaState & KeyEvent.META_META_MASK) != 0))) {
final boolean forwardDirection = (metaState & KeyEvent.META_SHIFT_MASK) == 0;
mWindowManagerFuncs.switchInputMethod(forwardDirection);
return -1;
}
if (mLanguageSwitchKeyPressed && !down && (keyCode == KeyEvent.KEYCODE_LANGUAGE_SWITCH || keyCode == KeyEvent.KEYCODE_SPACE)) {
mLanguageSwitchKeyPressed = false;
return -1;
}
if (isValidGlobalKey(keyCode) && mGlobalKeyManager.handleGlobalKey(mContext, keyCode, event)) {
return -1;
}
// Specific device key handling
if (dispatchKeyToKeyHandlers(event)) {
return -1;
}
if (down) {
long shortcutCode = keyCode;
if (event.isCtrlPressed()) {
shortcutCode |= ((long) KeyEvent.META_CTRL_ON) << Integer.SIZE;
}
if (event.isAltPressed()) {
shortcutCode |= ((long) KeyEvent.META_ALT_ON) << Integer.SIZE;
}
if (event.isShiftPressed()) {
shortcutCode |= ((long) KeyEvent.META_SHIFT_ON) << Integer.SIZE;
}
if (event.isMetaPressed()) {
shortcutCode |= ((long) KeyEvent.META_META_ON) << Integer.SIZE;
}
IShortcutService shortcutService = mShortcutKeyServices.get(shortcutCode);
if (shortcutService != null) {
try {
if (isUserSetupComplete()) {
shortcutService.notifyShortcutKeyPressed(shortcutCode);
}
} catch (RemoteException e) {
mShortcutKeyServices.delete(shortcutCode);
}
return -1;
}
}
// Reserve all the META modifier combos for system behavior
if ((metaState & KeyEvent.META_META_ON) != 0) {
return -1;
}
// Let the application handle the key.
return 0;
}
use of com.android.internal.statusbar.IStatusBarService in project android_frameworks_base by ResurrectionRemix.
the class DevicePolicyManagerService method setStatusBarDisabledInternal.
private boolean setStatusBarDisabledInternal(boolean disabled, int userId) {
long ident = mInjector.binderClearCallingIdentity();
try {
IStatusBarService statusBarService = IStatusBarService.Stub.asInterface(ServiceManager.checkService(Context.STATUS_BAR_SERVICE));
if (statusBarService != null) {
int flags1 = disabled ? STATUS_BAR_DISABLE_MASK : StatusBarManager.DISABLE_NONE;
int flags2 = disabled ? STATUS_BAR_DISABLE2_MASK : StatusBarManager.DISABLE2_NONE;
statusBarService.disableForUser(flags1, mToken, mContext.getPackageName(), userId);
statusBarService.disable2ForUser(flags2, mToken, mContext.getPackageName(), userId);
return true;
}
} catch (RemoteException e) {
Slog.e(LOG_TAG, "Failed to disable the status bar", e);
} finally {
mInjector.binderRestoreCallingIdentity(ident);
}
return false;
}
use of com.android.internal.statusbar.IStatusBarService in project android_frameworks_base by crdroidandroid.
the class PieAction method processActionWithOptions.
public static void processActionWithOptions(Context context, String action, boolean isLongpress, boolean collapseShade) {
if (action == null || action.equals(PieConstants.NULL_BUTTON)) {
return;
}
boolean isKeyguardShowing = false;
try {
isKeyguardShowing = WindowManagerGlobal.getWindowManagerService().isKeyguardLocked();
} catch (RemoteException e) {
Log.w("Action", "Error getting window manager service", e);
}
final IStatusBarService barService = IStatusBarService.Stub.asInterface(ServiceManager.getService(Context.STATUS_BAR_SERVICE));
if (barService == null) {
// ouch
return;
}
final IWindowManager windowManagerService = IWindowManager.Stub.asInterface(ServiceManager.getService(Context.WINDOW_SERVICE));
if (windowManagerService == null) {
// ouch
return;
}
boolean isKeyguardSecure = false;
try {
isKeyguardSecure = windowManagerService.isKeyguardSecure();
} catch (RemoteException e) {
Log.w("Action", "Error getting window manager service", e);
}
if (collapseShade) {
if (!action.equals(PieConstants.SETTINGS_PANEL_BUTTON) && !action.equals(PieConstants.NOTIFICATIONS_BUTTON) && !action.equals(PieConstants.THEME_SWITCH_BUTTON)) {
try {
barService.collapsePanels();
} catch (RemoteException ex) {
}
}
}
// process the actions
if (action.equals(PieConstants.HOME_BUTTON)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_HOME, isLongpress);
return;
} else if (action.equals(PieConstants.BACK_BUTTON)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_BACK, isLongpress);
return;
} else if (action.equals(PieConstants.MENU_BUTTON) || action.equals(PieConstants.MENU_BIG_BUTTON)) {
triggerVirtualKeypress(KeyEvent.KEYCODE_MENU, isLongpress);
return;
} else if (action.equals(PieConstants.KILL_TASK_BUTTON)) {
if (isKeyguardShowing) {
return;
}
try {
barService.toggleKillApp();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.NOTIFICATIONS_BUTTON)) {
if (isKeyguardShowing && isKeyguardSecure) {
return;
}
try {
barService.expandNotificationsPanel();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.SETTINGS_PANEL_BUTTON)) {
if (isKeyguardShowing && isKeyguardSecure) {
return;
}
try {
barService.expandSettingsPanel(null);
} catch (RemoteException e) {
}
} else if (action.equals(PieConstants.LAST_APP_BUTTON)) {
if (isKeyguardShowing) {
return;
}
try {
barService.toggleLastApp();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.RECENT_BUTTON)) {
if (isKeyguardShowing) {
return;
}
try {
barService.toggleRecentApps();
} catch (RemoteException e) {
}
return;
} else if (action.equals(PieConstants.SCREENSHOT_BUTTON)) {
try {
barService.toggleScreenshot();
} catch (RemoteException e) {
}
return;
} else {
// we must have a custom uri
Intent intent = null;
try {
intent = Intent.parseUri(action, 0);
} catch (URISyntaxException e) {
Log.e("PieAction:", "URISyntaxException: [" + action + "]");
return;
}
startActivity(context, intent, barService, isKeyguardShowing);
return;
}
}
Aggregations