Java Code Examples for android.view.KeyEvent#ACTION_UP

public boolean sendKey(int keyCode, int metaState) {
    if (DEBUG) {
        Log.d(LOG_TAG, "sendKey (" + keyCode + ", " + metaState + ")");
    }

    final long eventTime = SystemClock.uptimeMillis();
    KeyEvent downEvent = new KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN,
            keyCode, 0, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
            InputDevice.SOURCE_KEYBOARD);
    if (injectEventSync(downEvent)) {
        KeyEvent upEvent = new KeyEvent(eventTime, eventTime, KeyEvent.ACTION_UP,
                keyCode, 0, metaState, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0,
                InputDevice.SOURCE_KEYBOARD);
        if(injectEventSync(upEvent)) {
            return true;
        }
    }
    return false;
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    final int keyCode = event.getKeyCode();
    switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
        case KeyEvent.KEYCODE_ENTER:
            removeAllCallbacks();
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
        case KeyEvent.KEYCODE_DPAD_UP:
            if (!mHasSelectorWheel) {
                break;
            }
            switch (event.getAction()) {
                case KeyEvent.ACTION_DOWN:
                    if (mWrapSelectorWheel || ((keyCode == KeyEvent.KEYCODE_DPAD_DOWN)
                            ? getValue() < getMaxValue() : getValue() > getMinValue())) {
                        requestFocus();
                        mLastHandledDownDpadKeyCode = keyCode;
                        removeAllCallbacks();
                        if (mFlingScroller.isFinished()) {
                            changeValueByOne(keyCode == KeyEvent.KEYCODE_DPAD_DOWN);
                        }
                        return true;
                    }
                    break;
                case KeyEvent.ACTION_UP:
                    if (mLastHandledDownDpadKeyCode == keyCode) {
                        mLastHandledDownDpadKeyCode = -1;
                        return true;
                    }
                    break;
            }
    }
    return super.dispatchKeyEvent(event);
}
 

@Override
public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_UP
            && !event.isCanceled() && mCancelable && !mDismissing) {
        dismiss();
        return true;
    }
    return false;
}
 

@Override
public boolean dispatchKeyEventPreIme(KeyEvent event) {
    if (event != null && event.getKeyCode() == KeyEvent.KEYCODE_BACK
            && event.getAction() == KeyEvent.ACTION_UP) {
        return delegate != null && delegate.onPreIme() || super.dispatchKeyEventPreIme(event);
    }
    return super.dispatchKeyEventPreIme(event);
}
 

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_UP) {
        return processKeyUp(keyCode);
    }
    return false;
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    final int keyCode = event.getKeyCode();
    switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_CENTER:
        case KeyEvent.KEYCODE_ENTER:
            removeAllCallbacks();
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
        case KeyEvent.KEYCODE_DPAD_UP:
            if (!mHasSelectorWheel) {
                break;
            }
            switch (event.getAction()) {
                case KeyEvent.ACTION_DOWN:
                    if (mWrapSelectorWheel || ((keyCode == KeyEvent.KEYCODE_DPAD_DOWN)
                            ? getValue() < getMaxValue() : getValue() > getMinValue())) {
                        requestFocus();
                        mLastHandledDownDpadKeyCode = keyCode;
                        removeAllCallbacks();
                        if (mFlingScroller.isFinished()) {
                            changeValueByOne(keyCode == KeyEvent.KEYCODE_DPAD_DOWN);
                        }
                        return true;
                    }
                    break;
                case KeyEvent.ACTION_UP:
                    if (mLastHandledDownDpadKeyCode == keyCode) {
                        mLastHandledDownDpadKeyCode = -1;
                        return true;
                    }
                    break;
            }
    }
    return super.dispatchKeyEvent(event);
}
 

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
	if (BuildConfig.DEBUG) {
		Log.v("PopupWindow", "--onKey(" + String.valueOf(keyCode) + ')');
	}
	
	switch (keyCode) {
		case KeyEvent.KEYCODE_BACK: {
			switch (event.getAction()) {
				case KeyEvent.ACTION_UP: {
					if (!event.isCanceled()) {
						onBackPressed();
					}
					break;
				}
			}
			return true;
		}
	}
	
	// Delay auto-hiding if set to do so (and we didn't already handle this event).
	if (event.getAction() == KeyEvent.ACTION_DOWN) {
		onUserInteraction();
	}
	
	return false;
}
 

public boolean handleKeyUp(int keyCode, KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_UP) {
        synchronized(field) {
            if (!field.getGameState().isGameInProgress() || field.getGameState().isPaused()) {
                return false;
            }
            return updateFlippersForKeyCode(keyCode, false);
        }
    }
    return false;
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] event: " + event);

    final int keyCode = event.getKeyCode();

    // Not handled by the view hierarchy, does the action bar want it
    // to cancel out of something special?
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        final int action = event.getAction();
        // Back cancels action modes first.
        if (mActionMode != null) {
            if (action == KeyEvent.ACTION_UP) {
                mActionMode.finish();
            }
            if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] returning true");
            return true;
        }

        // Next collapse any expanded action views.
        if (wActionBar != null && wActionBar.hasExpandedActionView()) {
            if (action == KeyEvent.ACTION_UP) {
                wActionBar.collapseActionView();
            }
            if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] returning true");
            return true;
        }
    }

    if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] returning false");
    return false;
}
 

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] event: " + event);

    final int keyCode = event.getKeyCode();

    // Not handled by the view hierarchy, does the action bar want it
    // to cancel out of something special?
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        final int action = event.getAction();
        // Back cancels action modes first.
        if (mActionMode != null) {
            if (action == KeyEvent.ACTION_UP) {
                mActionMode.finish();
            }
            if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] returning true");
            return true;
        }

        // Next collapse any expanded action views.
        if (wActionBar != null && wActionBar.hasExpandedActionView()) {
            if (action == KeyEvent.ACTION_UP) {
                wActionBar.collapseActionView();
            }
            if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] returning true");
            return true;
        }
    }

    if (ActionBarSherlock.DEBUG) Log.d(TAG, "[dispatchKeyEvent] returning false");
    return false;
}
 

public boolean onKey(View v, int keyCode, KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_MENU) {
        dismiss();
        return true;
    }
    return false;
}
 

@Override
public boolean onKeyPreIme(int keyCode, KeyEvent event) {
    if (KeyEvent.KEYCODE_BACK == keyCode && event.getAction() == KeyEvent.ACTION_UP) {
        mKeyboardHideHelper.monitorForKeyboardHidden();
    }
    return super.onKeyPreIme(keyCode, event);
}
 

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_UP) {
        return processKeyUp(keyCode);
    }
    return false;
}
 

/**
 * Handles key events in the workspace hotseat (bottom of the screen).
 */
static boolean handleHotseatButtonKeyEvent(View v, int keyCode, KeyEvent e, int orientation) {
    final ViewGroup parent = (ViewGroup) v.getParent();
    final ViewGroup launcher = (ViewGroup) parent.getParent();
    final Workspace workspace = (Workspace) launcher.findViewById(R.id.workspace);
    final int buttonIndex = parent.indexOfChild(v);
    final int buttonCount = parent.getChildCount();
    final int pageIndex = workspace.getCurrentPage();

    // NOTE: currently we don't special case for the phone UI in different
    // orientations, even though the hotseat is on the side in landscape mode.  This
    // is to ensure that accessibility consistency is maintained across rotations.

    final int action = e.getAction();
    final boolean handleKeyEvent = (action != KeyEvent.ACTION_UP);
    boolean wasHandled = false;
    switch (keyCode) {
        case KeyEvent.KEYCODE_DPAD_LEFT:
            if (handleKeyEvent) {
                // Select the previous button, otherwise snap to the previous page
                if (buttonIndex > 0) {
                    parent.getChildAt(buttonIndex - 1).requestFocus();
                } else {
                    workspace.snapToPage(pageIndex - 1);
                }
            }
            wasHandled = true;
            break;
        case KeyEvent.KEYCODE_DPAD_RIGHT:
            if (handleKeyEvent) {
                // Select the next button, otherwise snap to the next page
                if (buttonIndex < (buttonCount - 1)) {
                    parent.getChildAt(buttonIndex + 1).requestFocus();
                } else {
                    workspace.snapToPage(pageIndex + 1);
                }
            }
            wasHandled = true;
            break;
        case KeyEvent.KEYCODE_DPAD_UP:
            if (handleKeyEvent) {
                // Select the first bubble text view in the current page of the workspace
                final CellLayout layout = (CellLayout) workspace.getChildAt(pageIndex);
                final ShortcutAndWidgetContainer children = layout.getShortcutsAndWidgets();
                final View newIcon = getIconInDirection(layout, children, -1, 1);
                if (newIcon != null) {
                    newIcon.requestFocus();
                } else {
                    workspace.requestFocus();
                }
            }
            wasHandled = true;
            break;
        case KeyEvent.KEYCODE_DPAD_DOWN:
            // Do nothing
            wasHandled = true;
            break;
        default: break;
    }
    return wasHandled;
}
 

public void dealWithKeyEvent(KeyEvent event){
    if (event == null) {
        return;
    }
    switch (event.getAction()) {
    case KeyEvent.ACTION_DOWN:
        if (event.getKeyCode() == mEmergencyBtn){
            //quick solution
            mControls.resetAxisValues();
            mActivity.getPresenter().disconnect();
            Toast.makeText(mActivity, "Emergency Stop", Toast.LENGTH_SHORT).show();
        } else if (event.getKeyCode() == mRollTrimPlusBtn) {
            mControls.increaseTrim(PreferencesActivity.KEY_PREF_ROLLTRIM);
        } else if (event.getKeyCode() == mRollTrimMinusBtn) {
            mControls.decreaseTrim(PreferencesActivity.KEY_PREF_ROLLTRIM);
        } else if (event.getKeyCode() == mPitchTrimPlusBtn) {
            mControls.increaseTrim(PreferencesActivity.KEY_PREF_PITCHTRIM);
        } else if (event.getKeyCode() == mPitchTrimMinusBtn) {
            mControls.decreaseTrim(PreferencesActivity.KEY_PREF_PITCHTRIM);
        } else if (event.getKeyCode() == mAlt1Btn) {
            mActivity.getPresenter().runAltAction(mControls.getAlt1Action());
        } else if (event.getKeyCode() == mAlt2Btn) {
            mActivity.getPresenter().runAltAction(mControls.getAlt2Action());
        } else if (event.getKeyCode() == mHoverBtn) {
            // workaround until BleLink supports param subsystem
            if (mActivity.getPresenter() != null && mActivity.getPresenter().getCrazyflie() != null && mActivity.getPresenter().getCrazyflie().getDriver() instanceof RadioDriver) {
                mHover = true;
                mActivity.getPresenter().enableAltHoldMode(mHover);
            }
        }
        break;
    case KeyEvent.ACTION_UP:
        if(event.getKeyCode() == mHoverBtn) {
            // workaround until BleLink supports param subsystem
            if (mActivity.getPresenter() != null && mActivity.getPresenter().getCrazyflie() != null && mActivity.getPresenter().getCrazyflie().getDriver() instanceof RadioDriver) {
                mHover = false;
                mActivity.getPresenter().enableAltHoldMode(mHover);
            }
        }
        break;
    default:
        break;
    }
}
 

private void dispatchVolumeKeyEventLocked(String packageName, int pid, int uid,
        boolean asSystemService, KeyEvent keyEvent, int stream, boolean musicOnly) {
    boolean down = keyEvent.getAction() == KeyEvent.ACTION_DOWN;
    boolean up = keyEvent.getAction() == KeyEvent.ACTION_UP;
    int direction = 0;
    boolean isMute = false;
    switch (keyEvent.getKeyCode()) {
        case KeyEvent.KEYCODE_VOLUME_UP:
            direction = AudioManager.ADJUST_RAISE;
            break;
        case KeyEvent.KEYCODE_VOLUME_DOWN:
            direction = AudioManager.ADJUST_LOWER;
            break;
        case KeyEvent.KEYCODE_VOLUME_MUTE:
            isMute = true;
            break;
    }
    if (down || up) {
        int flags = AudioManager.FLAG_FROM_KEY;
        if (musicOnly) {
            // This flag is used when the screen is off to only affect active media.
            flags |= AudioManager.FLAG_ACTIVE_MEDIA_ONLY;
        } else {
            // These flags are consistent with the home screen
            if (up) {
                flags |= AudioManager.FLAG_PLAY_SOUND | AudioManager.FLAG_VIBRATE;
            } else {
                flags |= AudioManager.FLAG_SHOW_UI | AudioManager.FLAG_VIBRATE;
            }
        }
        if (direction != 0) {
            // If this is action up we want to send a beep for non-music events
            if (up) {
                direction = 0;
            }
            dispatchAdjustVolumeLocked(packageName, pid, uid, asSystemService, stream,
                    direction, flags);
        } else if (isMute) {
            if (down && keyEvent.getRepeatCount() == 0) {
                dispatchAdjustVolumeLocked(packageName, pid, uid, asSystemService, stream,
                        AudioManager.ADJUST_TOGGLE_MUTE, flags);
            }
        }
    }
}
 

private void handleKeyEvent(KeyEvent event) {
    if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() > 0) {
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                downloadService.fastForward();
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                downloadService.rewind();
                break;
        }
    } else if (event.getAction() == KeyEvent.ACTION_UP) {
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_HEADSETHOOK:
            case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
                if (lastPressTime < (System.currentTimeMillis() - 500)) {
                    lastPressTime = System.currentTimeMillis();
                    downloadService.togglePlayPause();
                } else {
                    downloadService.next(true);
                }
                break;
            case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
                if (lastPressTime < (System.currentTimeMillis() - DEBOUNCE_TIME)) {
                    lastPressTime = System.currentTimeMillis();
                    downloadService.previous();
                }
                break;
            case KeyEvent.KEYCODE_MEDIA_NEXT:
                if (lastPressTime < (System.currentTimeMillis() - DEBOUNCE_TIME)) {
                    lastPressTime = System.currentTimeMillis();
                    downloadService.next();
                }
                break;
            case KeyEvent.KEYCODE_MEDIA_REWIND:
                downloadService.rewind();
                break;
            case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
                downloadService.fastForward();
                break;
            case KeyEvent.KEYCODE_MEDIA_STOP:
                downloadService.stop();
                break;
            case KeyEvent.KEYCODE_MEDIA_PLAY:
                if (downloadService.getPlayerState() != PlayerState.STARTED) {
                    downloadService.start();
                }
                break;
            case KeyEvent.KEYCODE_MEDIA_PAUSE:
                downloadService.pause();
            default:
                break;
        }
    }
}
 

/**
 * 执行floatPage create
 *
 * @param context 上下文环境
 */
@SuppressLint("ClickableViewAccessibility")
void performCreate(Context context) {
    try {
        //调用onCreate方法
        onCreate(context);
        if (!isNormalMode()) {
            DokitViewManager.getInstance().addDokitViewAttachedListener(this);
        }
        if (isNormalMode()) {
            mRootView = new DokitFrameLayout(context);
        } else {
            //系统悬浮窗的返回按键监听
            mRootView = new DokitFrameLayout(context) {
                @Override
                public boolean dispatchKeyEvent(KeyEvent event) {
                    if (event.getAction() == KeyEvent.ACTION_UP && shouldDealBackKey()) {
                        //监听返回键
                        if (event.getKeyCode() == KeyEvent.KEYCODE_BACK || event.getKeyCode() == KeyEvent.KEYCODE_HOME) {
                            return onBackPressed();
                        }
                    }
                    return super.dispatchKeyEvent(event);
                }
            };
        }
        //添加根布局的layout回调
        addViewTreeObserverListener();


        //调用onCreateView抽象方法
        mChildView = onCreateView(context, mRootView);
        //将子View添加到rootview中
        mRootView.addView(mChildView);
        //设置根布局的手势拦截
        mRootView.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                if (getRootView() != null) {
                    return mTouchProxy.onTouchEvent(v, event);
                } else {
                    return false;
                }
            }
        });
        //调用onViewCreated回调
        onViewCreated(mRootView);

        mDokitViewLayoutParams = new DokitViewLayoutParams();
        //分别创建对应的LayoutParams
        if (isNormalMode()) {
            mFrameLayoutParams = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT);
            mFrameLayoutParams.gravity = Gravity.LEFT | Gravity.TOP;
            mDokitViewLayoutParams.gravity = Gravity.LEFT | Gravity.TOP;
        } else {
            mWindowLayoutParams = new WindowManager.LayoutParams();
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                //android 8.0
                mWindowLayoutParams.type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
            } else {
                mWindowLayoutParams.type = WindowManager.LayoutParams.TYPE_PHONE;
            }
            if (!shouldDealBackKey()) {
                //参考：http://www.shirlman.com/tec/20160426/362
                //设置WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE会导致rootview监听不到返回按键的监听失效
                mWindowLayoutParams.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
                mDokitViewLayoutParams.flags = DokitViewLayoutParams.FLAG_NOT_FOCUSABLE;
            }
            mWindowLayoutParams.format = PixelFormat.TRANSPARENT;
            mWindowLayoutParams.gravity = Gravity.LEFT | Gravity.TOP;
            mDokitViewLayoutParams.gravity = Gravity.LEFT | Gravity.TOP;
            //动态注册关闭系统弹窗的广播
            IntentFilter intentFilter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
            context.registerReceiver(mInnerReceiver, intentFilter);
        }
        initDokitViewLayoutParams(mDokitViewLayoutParams);
        if (isNormalMode()) {
            onNormalLayoutParamsCreated(mFrameLayoutParams);
        } else {
            onSystemLayoutParamsCreated(mWindowLayoutParams);
        }
    } catch (Exception e) {
        LogHelper.e(TAG, "e===>" + e.getMessage());
        e.printStackTrace();
    }

}
 

public boolean onKeyEvent(KeyEvent event) {
	XulLayout layout;
	if (_page == null || (layout = _page.getLayout()) == null) {
		lastKeyAction = -1;
		lastKeyCode = -1;
		lastKeyEventView = null;
		lastDownHandled = false;
		return false;
	}
	int keyAction = event.getAction();
	int keyCode = event.getKeyCode();
	XulView focusView = layout.getFocus();
	boolean ret = false;

	if (keyAction == KeyEvent.ACTION_DOWN) {
		if (layout.onKeyEvent(event)) {
			lastKeyAction = keyAction;
			lastKeyCode = keyCode;
			lastKeyEventView = getWeakReference(focusView);
			ret = true;
		} else switch (keyCode) {
		case KeyEvent.KEYCODE_DPAD_LEFT:
			ret = layout.moveFocus(XulLayout.FocusDirection.MOVE_LEFT);
			break;
		case KeyEvent.KEYCODE_DPAD_RIGHT:
			ret = layout.moveFocus(XulLayout.FocusDirection.MOVE_RIGHT);
			break;
		case KeyEvent.KEYCODE_DPAD_UP:
			ret = layout.moveFocus(XulLayout.FocusDirection.MOVE_UP);
			break;
		case KeyEvent.KEYCODE_DPAD_DOWN:
			ret = layout.moveFocus(XulLayout.FocusDirection.MOVE_DOWN);
			break;
		case KeyEvent.KEYCODE_DPAD_CENTER:
		case KeyEvent.KEYCODE_ENTER:
			ret = layout.doClick(actionCallback);
			break;
		case KeyEvent.KEYCODE_BACK:
			ret = _page.popStates();
			if (ret) {
				XulPage.invokeActionNoPopup(_page, "statesRestored");
			}
			break;
		}
		lastDownHandled = ret;
	} else if (keyAction == KeyEvent.ACTION_UP) {
		XulView xulView = lastKeyEventView == null ? null : lastKeyEventView.get();
		if (xulView != focusView) {
			ret = lastDownHandled;
		} else if (layout.onKeyEvent(event)) {
			lastKeyAction = keyAction;
			lastKeyCode = keyCode;
			lastKeyEventView = getWeakReference(focusView);
			ret = true;
		} else switch (keyCode) {
		default:
			ret = lastDownHandled;
			break;
		}
		lastDownHandled = false;
	}

	lastKeyAction = keyAction;
	lastKeyCode = keyCode;
	lastKeyEventView = getWeakReference(focusView);

	if (ret) {
		suspendDrawableWorker();
	}
	return ret;
}
 

/**
 * Show the context menu for the currently focused view and executes a
 * particular context menu item.
 * 
 * @param targetActivity The activity in question.
 * @param id The identifier associated with the context menu item.
 * @param flag Additional flags, if any.
 * @return Whether the invocation was successful (for example, it could be
 *         false if item is disabled).
 */
public boolean invokeContextMenuAction(Activity targetActivity, int id, int flag) {
    validateNotAppThread();
    
    // Bring up context menu for current focus.
    // It'd be nice to do this through code, but currently ListView depends on
    //   long press to set metadata for its selected child
    
    final KeyEvent downEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_CENTER); 
    sendKeySync(downEvent);

    // Need to wait for long press
    waitForIdleSync();
    try {
        Thread.sleep(ViewConfiguration.getLongPressTimeout());
    } catch (InterruptedException e) {
        Log.e(TAG, "Could not sleep for long press timeout", e);
        return false;
    }

    final KeyEvent upEvent = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DPAD_CENTER); 
    sendKeySync(upEvent);

    // Wait for context menu to appear
    waitForIdleSync();
    
    class ContextMenuRunnable implements Runnable {
        private final Activity activity;
        private final int identifier;
        private final int flags;
        boolean returnValue;
        
        public ContextMenuRunnable(Activity _activity, int _identifier,
                                int _flags) {
            activity = _activity;
            identifier = _identifier;
            flags = _flags;
        }
        
        public void run() {
            Window win = activity.getWindow();
            returnValue = win.performContextMenuIdentifierAction(
                        identifier, 
                        flags);                
        }
        
    }        
    
    ContextMenuRunnable cmr = new ContextMenuRunnable(targetActivity, id, flag);
    runOnMainSync(cmr);
    return cmr.returnValue;
}