| /* |
| * 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.server.hdmi; |
| |
| import static com.android.server.hdmi.HdmiConfig.IRT_MS; |
| |
| import android.hardware.tv.cec.V1_0.SendMessageResult; |
| import android.util.Slog; |
| import android.view.KeyEvent; |
| import com.android.server.hdmi.HdmiControlService.SendMessageCallback; |
| |
| /** |
| * Feature action that transmits remote control key command (User Control Press/ |
| * User Control Release) to CEC bus. |
| * |
| * <p>This action is created when a new key event is passed to CEC service. It optionally |
| * does key repeat (a.k.a. press-and-hold) operation until it receives a key release event. |
| * If another key press event is received before the key in use is released, CEC service |
| * does not create a new action but recycles the current one by updating the key used |
| * for press-and-hold operation. |
| * |
| * <p>Package-private, accessed by {@link HdmiControlService} only. |
| */ |
| final class SendKeyAction extends HdmiCecFeatureAction { |
| private static final String TAG = "SendKeyAction"; |
| |
| // If the first key press lasts this much amount of time without any other key event |
| // coming down, we trigger the press-and-hold operation. Set to the value slightly |
| // shorter than the threshold(500ms) between two successive key press events |
| // as specified in the standard for the operation. |
| private static final int AWAIT_LONGPRESS_MS = 400; |
| |
| // Amount of time this action waits for a new release key input event. When timed out, |
| // the action sends out UCR and finishes its lifecycle. Used to deal with missing key release |
| // event, which can lead the device on the receiving end to generating unintended key repeats. |
| private static final int AWAIT_RELEASE_KEY_MS = 1000; |
| |
| // State in which the long press is being checked at the beginning. The state is set in |
| // {@link #start()} and lasts for {@link #AWAIT_LONGPRESS_MS}. |
| private static final int STATE_CHECKING_LONGPRESS = 1; |
| |
| // State in which the action is handling incoming keys. Persists throughout the process |
| // till it is set back to {@code STATE_NONE} at the end when a release key event for |
| // the last key is processed. |
| private static final int STATE_PROCESSING_KEYCODE = 2; |
| |
| // Logical address of the device to which the UCP/UCP commands are sent. |
| private final int mTargetAddress; |
| |
| // The key code of the last key press event the action is passed via processKeyEvent. |
| private int mLastKeycode; |
| |
| // The time stamp when the last CEC key command was sent. Used to determine the press-and-hold |
| // operation. |
| private long mLastSendKeyTime; |
| |
| /** |
| * Constructor. |
| * |
| * @param source {@link HdmiCecLocalDevice} instance |
| * @param targetAddress logical address of the device to send the keys to |
| * @param keycode remote control key code as defined in {@link KeyEvent} |
| */ |
| SendKeyAction(HdmiCecLocalDevice source, int targetAddress, int keycode) { |
| super(source); |
| mTargetAddress = targetAddress; |
| mLastKeycode = keycode; |
| } |
| |
| @Override |
| public boolean start() { |
| sendKeyDown(mLastKeycode); |
| mLastSendKeyTime = getCurrentTime(); |
| // finish action for non-repeatable key. |
| if (!HdmiCecKeycode.isRepeatableKey(mLastKeycode)) { |
| sendKeyUp(); |
| finish(); |
| return true; |
| } |
| mState = STATE_CHECKING_LONGPRESS; |
| addTimer(mState, AWAIT_LONGPRESS_MS); |
| return true; |
| } |
| |
| private long getCurrentTime() { |
| return System.currentTimeMillis(); |
| } |
| |
| /** |
| * Called when a key event should be handled for the action. |
| * |
| * @param keycode key code of {@link KeyEvent} object |
| * @param isPressed true if the key event is of {@link KeyEvent#ACTION_DOWN} |
| */ |
| void processKeyEvent(int keycode, boolean isPressed) { |
| if (mState != STATE_CHECKING_LONGPRESS && mState != STATE_PROCESSING_KEYCODE) { |
| Slog.w(TAG, "Not in a valid state"); |
| return; |
| } |
| if (isPressed) { |
| // A new key press event that comes in with a key code different from the last |
| // one becomes a new key code to be used for press-and-hold operation. |
| if (keycode != mLastKeycode) { |
| sendKeyDown(keycode); |
| mLastSendKeyTime = getCurrentTime(); |
| if (!HdmiCecKeycode.isRepeatableKey(keycode)) { |
| sendKeyUp(); |
| finish(); |
| return; |
| } |
| } else { |
| // Press-and-hold key transmission takes place if Android key inputs are |
| // repeatedly coming in and more than IRT_MS has passed since the last |
| // press-and-hold key transmission. |
| if (getCurrentTime() - mLastSendKeyTime >= IRT_MS) { |
| sendKeyDown(keycode); |
| mLastSendKeyTime = getCurrentTime(); |
| } |
| } |
| mActionTimer.clearTimerMessage(); |
| addTimer(mState, AWAIT_RELEASE_KEY_MS); |
| mLastKeycode = keycode; |
| } else { |
| // Key release event indicates that the action shall be finished. Send UCR |
| // command and terminate the action. Other release events are ignored. |
| if (keycode == mLastKeycode) { |
| sendKeyUp(); |
| finish(); |
| } |
| } |
| } |
| |
| private void sendKeyDown(int keycode) { |
| byte[] cecKeycodeAndParams = HdmiCecKeycode.androidKeyToCecKey(keycode); |
| if (cecKeycodeAndParams == null) { |
| return; |
| } |
| // Devices that are not directly connected with audio system device can't detect if the |
| // audio system device is still plugged in. Framework checks if the volume key forwarding is |
| // successful or not every time to make sure the System Audio Mode status is still updated. |
| if (mTargetAddress == Constants.ADDR_AUDIO_SYSTEM |
| && localDevice().mAddress != Constants.ADDR_TV) { |
| sendCommand(HdmiCecMessageBuilder.buildUserControlPressed(getSourceAddress(), |
| mTargetAddress, cecKeycodeAndParams), new SendMessageCallback() { |
| @Override |
| public void onSendCompleted(int error) { |
| if (error != SendMessageResult.SUCCESS) { |
| HdmiLogger.debug( |
| "AVR did not respond to <User Control Pressed>"); |
| localDevice().mService.setSystemAudioActivated(false); |
| } |
| } |
| }); |
| } else { |
| sendCommand(HdmiCecMessageBuilder.buildUserControlPressed(getSourceAddress(), |
| mTargetAddress, cecKeycodeAndParams)); |
| } |
| } |
| |
| private void sendKeyUp() { |
| sendCommand(HdmiCecMessageBuilder.buildUserControlReleased(getSourceAddress(), |
| mTargetAddress)); |
| } |
| |
| @Override |
| public boolean processCommand(HdmiCecMessage cmd) { |
| // Send key action doesn't need any incoming CEC command, hence does not consume it. |
| return false; |
| } |
| |
| @Override |
| public void handleTimerEvent(int state) { |
| switch (mState) { |
| case STATE_CHECKING_LONGPRESS: |
| // The first key press lasts long enough to start press-and-hold. |
| mActionTimer.clearTimerMessage(); |
| mState = STATE_PROCESSING_KEYCODE; |
| sendKeyDown(mLastKeycode); |
| mLastSendKeyTime = getCurrentTime(); |
| addTimer(mState, AWAIT_RELEASE_KEY_MS); |
| break; |
| case STATE_PROCESSING_KEYCODE: |
| // Timeout on waiting for the release key event. Send UCR and quit the action. |
| sendKeyUp(); |
| finish(); |
| break; |
| default: |
| Slog.w(TAG, "Not in a valid state"); |
| break; |
| } |
| } |
| } |