@Override
 public void onClick(View v) {
   if (user.isVibrateOnKeypress()) {
     v.performHapticFeedback(KEYBOARD_TAP, FLAG_IGNORE_GLOBAL_SETTING | FLAG_IGNORE_VIEW_SETTING);
   }
   switch (v.getId()) {
     case R.id.cpp_kb_button_close:
       user.done();
       break;
     case R.id.cpp_kb_button_change_case:
       changeCase((Button) v);
       break;
     case R.id.cpp_kb_button_keyboard:
       user.showIme();
       break;
     case R.id.cpp_kb_button_clear:
       user.getEditor().setText("");
       user.getEditor().setSelection(0);
       break;
     default:
       user.getEditor().append(((TextView) v).getText());
       break;
   }
   user.getEditor().requestFocus();
 }
        @Override
        public void onClick(View view) {

          // BZZZT! Give the user a brief haptic feedback touch response.
          view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);

          // Update the playback UI elements.
          if (mApp.getService().isPlayingMusic()) {
            animatePauseToPlay();
            mHandler.removeCallbacks(seekbarUpdateRunnable);
          } else {
            animatePlayToPause();
            mHandler.post(seekbarUpdateRunnable);
          }

          /*
           * Toggle the playback state in a separate thread. This
           * will allow the play/pause button animation to remain
           * buttery smooth.
           */
          new AsyncTask() {

            @Override
            protected Object doInBackground(Object[] params) {
              mApp.getService().togglePlaybackState();
              return null;
            }
          }.execute();
        }
Пример #3
0
    @Override
    boolean performItemLongClick(RecyclerView parent, View view, int position, long id) {
      if (mItemLongClickListener != null) {
        view.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
        return mItemLongClickListener.onItemLongClick(parent, view, position, id);
      }

      return false;
    }
Пример #4
0
  /**
   * Handles forwarded events.
   *
   * @param activePointerId id of the pointer that activated forwarding
   * @return whether the event was handled
   */
  public boolean onForwardedEvent(MotionEvent event, int activePointerId) {
    boolean handledEvent = true;
    View vibrateView = null;

    final int actionMasked = event.getActionMasked();
    switch (actionMasked) {
      case MotionEvent.ACTION_CANCEL:
        handledEvent = false;
        break;
      case MotionEvent.ACTION_UP:
        handledEvent = false;
        // $FALL-THROUGH$
      case MotionEvent.ACTION_DOWN:
      case MotionEvent.ACTION_MOVE:
        final int activeIndex = event.findPointerIndex(activePointerId);
        if (activeIndex < 0) {
          handledEvent = false;
          break;
        }

        final int x = (int) event.getX(activeIndex);
        final int y = (int) event.getY(activeIndex);

        View pressedView = findViewByCoordinate(this, x, y, 0);
        if (mPressedChild != pressedView) {
          vibrateView = pressedView != null ? pressedView : mPressedChild;
          if (pressedView != null) pressedView.setPressed(true);
          if (mPressedChild != null) mPressedChild.setPressed(false);
          mPressedChild = pressedView;

          if (mOnForwardedEventListener != null) {
            mOnForwardedEventListener.onPressedView(event, activePointerId, mPressedChild);
          }
        }

        if (actionMasked == MotionEvent.ACTION_UP) {
          vibrateView = mPressedChild;
          clickPressedItem();
        }
        break;
    }

    // Failure to handle the event cancels forwarding.
    if (!handledEvent) {
      clearPressedItem();
    }

    if (vibrateView != null && mVibrateOnForwarded) {
      vibrateView.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
    }

    if (mOnForwardedEventListener != null) {
      mOnForwardedEventListener.onForwardedEvent(event, activePointerId);
    }

    return handledEvent;
  }
Пример #5
0
 @OnClick(R.id.countUpButton)
 protected void OnCountUpClick(View view) {
   statsAggregator = ((MainActivity) getActivity()).getStatsAggregator();
   data = statsAggregator.newEvent();
   refreshPercent(votersEditText.getText().toString());
   bucketAdapter.notifyDataSetChanged();
   listView.smoothScrollToPosition(statsAggregator.getFilteredBuckets().size());
   view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
 }
 // TODO: make this private when LatinIME does not call it any more
 public void vibrate(final View viewToPerformHapticFeedbackOn) {
   if (!mSettingsValues.mVibrateOn) {
     return;
   }
   if (mSettingsValues.mKeypressVibrationDuration < 0) {
     // Go ahead with the system default
     if (viewToPerformHapticFeedbackOn != null) {
       viewToPerformHapticFeedbackOn.performHapticFeedback(
           HapticFeedbackConstants.KEYBOARD_TAP,
           HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING);
     }
   } else if (mVibratorUtils != null) {
     mVibratorUtils.vibrate(mSettingsValues.mKeypressVibrationDuration);
   }
 }
  // Touch
  @Override
  public boolean onTouch(View view, MotionEvent event) {
    int eventCase = event.getAction() & MotionEvent.ACTION_MASK;
    if (eventCase == MotionEvent.ACTION_DOWN) {
      // keep track of where on the button we originally pressed in order
      // to tell if we've swiped
      touchX = event.getX();
    } else {
      if (eventCase == MotionEvent.ACTION_CANCEL) {
        return true;
      }

      float distanceFromTouchX = Math.abs(touchX - event.getX());

      // if we release our click without swiping much
      if (eventCase == MotionEvent.ACTION_UP) {
        if (distanceFromTouchX < DRAG_THRESHOLD_X) {
          onClick(view);
          view.performClick();
          return true;
        } else {
          return true;
        }
      }
      // if we swipe our a certain amount either left or right
      else if (eventCase == MotionEvent.ACTION_MOVE) {
        if (distanceFromTouchX > DRAG_THRESHOLD_X) {
          WordTrain entry = m_section.WordEntry(m_id);

          // if swipe right
          if (touchX < event.getX()) {
            entry.SetScore(DataTrainWord.TRAIN_LEVELS - 1);
          } else { // swipe left
            entry.SetScore(0);
          }

          // update the color on the view
          m_color_level = entry.Score();
          TextView view_score = (TextView) view.findViewById(R.id.score);
          updateViewColor(view_score);

          view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
          return true;
        }
      }
    }
    return true;
  }
  /**
   * Starts showing a context menu for {@code view} based on {@code params}.
   *
   * @param contentViewCore The {@link ContentViewCore} to show the menu to.
   * @param params The {@link ContextMenuParams} that indicate what menu items to show.
   */
  @CalledByNative
  private void showContextMenu(ContentViewCore contentViewCore, ContextMenuParams params) {
    final View view = contentViewCore.getContainerView();

    if (!shouldShowMenu(params)
        || view == null
        || view.getVisibility() != View.VISIBLE
        || view.getParent() == null) {
      return;
    }

    mCurrentContextMenuParams = params;

    view.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
    view.setOnCreateContextMenuListener(this);
    view.showContextMenu();
  }
  @Override
  public void onClick(View v) {
    if (!alarmActive) return;
    String button = (String) v.getTag();
    v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
    if (button.equalsIgnoreCase("clear")) {
      if (answerBuilder.length() > 0) {
        answerBuilder.setLength(answerBuilder.length() - 1);
        answerView.setText(answerBuilder.toString());
      }
    } else if (button.equalsIgnoreCase(".")) {
      if (!answerBuilder.toString().contains(button)) {
        if (answerBuilder.length() == 0) answerBuilder.append(0);
        answerBuilder.append(button);
        answerView.setText(answerBuilder.toString());
      }
    } else if (button.equalsIgnoreCase("-")) {
      if (answerBuilder.length() == 0) {
        answerBuilder.append(button);
        answerView.setText(answerBuilder.toString());
      }
    } else {
      answerBuilder.append(button);
      answerView.setText(answerBuilder.toString());
      if (isAnswerCorrect()) {
        alarmActive = false;
        if (vibrator != null) vibrator.cancel();
        try {
          mediaPlayer.stop();
        } catch (IllegalStateException ise) {

        }
        try {
          mediaPlayer.release();
        } catch (Exception e) {

        }
        this.finish();
      }
    }
    if (answerView.getText().length() >= answerString.length() && !isAnswerCorrect()) {
      answerView.setTextColor(Color.RED);
    } else {
      answerView.setTextColor(Color.WHITE);
    }
  }
  @Override
  public boolean onTouch(View v, MotionEvent event) {
    switch (v.getId()) {
      case R.id.button_click_fast:
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
          button_click_fast.setBackgroundColor(
              getResources().getColor(R.color.button_background_pressed));
          v.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);
          return true;
        } else if (event.getAction() == MotionEvent.ACTION_UP) {
          button_click_fast.setBackgroundColor(getResources().getColor(R.color.button_background));
          totalClicks++;
          clicks.setText(String.valueOf(totalClicks));
          return true;
        }
        return false;

      default:
        return false;
    }
  }
Пример #11
0
 public static boolean performLongPressHaptic(View v) {
   return v.performHapticFeedback(
       HapticFeedbackConstants.LONG_PRESS,
       HapticFeedbackConstants.FLAG_IGNORE_GLOBAL_SETTING
           | HapticFeedbackConstants.FLAG_IGNORE_VIEW_SETTING);
 }
  boolean onKeyDown(int keyCode, KeyEvent event) {
    /* ****************************************************************************
     * HOW TO DECIDE WHERE YOUR KEY HANDLING GOES.
     * See the comment in PhoneWindow.onKeyDown
     * ****************************************************************************/
    final KeyEvent.DispatcherState dispatcher = mView.getKeyDispatcherState();

    switch (keyCode) {
      case KeyEvent.KEYCODE_VOLUME_UP:
      case KeyEvent.KEYCODE_VOLUME_DOWN:
      case KeyEvent.KEYCODE_VOLUME_MUTE:
        {
          MediaSessionLegacyHelper.getHelper(mContext).sendVolumeKeyEvent(event, false);
          return true;
        }

      case KeyEvent.KEYCODE_MEDIA_PLAY:
      case KeyEvent.KEYCODE_MEDIA_PAUSE:
      case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
        /* Suppress PLAY/PAUSE toggle when phone is ringing or in-call
         * to avoid music playback */
        if (getTelephonyManager().getCallState() != TelephonyManager.CALL_STATE_IDLE) {
          return true; // suppress key event
        }
      case KeyEvent.KEYCODE_MUTE:
      case KeyEvent.KEYCODE_HEADSETHOOK:
      case KeyEvent.KEYCODE_MEDIA_STOP:
      case KeyEvent.KEYCODE_MEDIA_NEXT:
      case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
      case KeyEvent.KEYCODE_MEDIA_REWIND:
      case KeyEvent.KEYCODE_MEDIA_RECORD:
      case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
      case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK:
        {
          handleMediaKeyEvent(event);
          return true;
        }

      case KeyEvent.KEYCODE_CALL:
        {
          if (getKeyguardManager().inKeyguardRestrictedInputMode() || dispatcher == null) {
            break;
          }
          if (event.getRepeatCount() == 0) {
            dispatcher.startTracking(event, this);
          } else if (event.isLongPress() && dispatcher.isTracking(event)) {
            dispatcher.performedLongPress(event);
            if (isUserSetupComplete()) {
              mView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
              // launch the VoiceDialer
              Intent intent = new Intent(Intent.ACTION_VOICE_COMMAND);
              intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
              try {
                sendCloseSystemWindows();
                mContext.startActivity(intent);
              } catch (ActivityNotFoundException e) {
                startCallActivity();
              }
            } else {
              Log.i(TAG, "Not starting call activity because user " + "setup is in progress.");
            }
          }
          return true;
        }

      case KeyEvent.KEYCODE_CAMERA:
        {
          if (getKeyguardManager().inKeyguardRestrictedInputMode() || dispatcher == null) {
            break;
          }
          if (event.getRepeatCount() == 0) {
            dispatcher.startTracking(event, this);
          } else if (event.isLongPress() && dispatcher.isTracking(event)) {
            dispatcher.performedLongPress(event);
            if (isUserSetupComplete()) {
              mView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
              sendCloseSystemWindows();
              // Broadcast an intent that the Camera button was longpressed
              Intent intent = new Intent(Intent.ACTION_CAMERA_BUTTON, null);
              intent.putExtra(Intent.EXTRA_KEY_EVENT, event);
              mContext.sendOrderedBroadcastAsUser(
                  intent, UserHandle.CURRENT_OR_SELF, null, null, null, 0, null, null);
            } else {
              Log.i(
                  TAG, "Not dispatching CAMERA long press because user " + "setup is in progress.");
            }
          }
          return true;
        }

      case KeyEvent.KEYCODE_SEARCH:
        {
          if (getKeyguardManager().inKeyguardRestrictedInputMode() || dispatcher == null) {
            break;
          }
          if (event.getRepeatCount() == 0) {
            dispatcher.startTracking(event, this);
          } else if (event.isLongPress() && dispatcher.isTracking(event)) {
            Configuration config = mContext.getResources().getConfiguration();
            if (config.keyboard == Configuration.KEYBOARD_NOKEYS
                || config.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES) {
              if (isUserSetupComplete()) {
                // launch the search activity
                Intent intent = new Intent(Intent.ACTION_SEARCH_LONG_PRESS);
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                try {
                  mView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
                  sendCloseSystemWindows();
                  getSearchManager().stopSearch();
                  mContext.startActivity(intent);
                  // Only clear this if we successfully start the
                  // activity; otherwise we will allow the normal short
                  // press action to be performed.
                  dispatcher.performedLongPress(event);
                  return true;
                } catch (ActivityNotFoundException e) {
                  // Ignore
                }
              } else {
                Log.i(
                    TAG,
                    "Not dispatching SEARCH long press because user " + "setup is in progress.");
              }
            }
          }
          break;
        }
    }
    return false;
  }