Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2014 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.server.hdmi; |
| 18 | |
Jungshik Jang | 61f4fbd | 2014-08-06 19:21:12 +0900 | [diff] [blame] | 19 | import android.hardware.hdmi.HdmiDeviceInfo; |
Jinsuk Kim | c0c20d0 | 2014-07-04 14:34:31 +0900 | [diff] [blame] | 20 | import android.hardware.hdmi.HdmiControlManager; |
Jungshik Jang | 79c58a4 | 2014-06-16 16:45:36 +0900 | [diff] [blame] | 21 | import android.hardware.hdmi.HdmiTvClient; |
| 22 | import android.hardware.hdmi.IHdmiControlCallback; |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 23 | import android.os.RemoteException; |
| 24 | import android.util.Slog; |
| 25 | |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 26 | import com.android.server.hdmi.HdmiControlService.SendMessageCallback; |
| 27 | |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 28 | /** |
| 29 | * Handles an action that selects a logical device as a new active source. |
| 30 | * |
| 31 | * Triggered by {@link HdmiTvClient}, attempts to select the given target device |
| 32 | * for a new active source. It does its best to wake up the target in standby mode |
| 33 | * before issuing the command >Set Stream path<. |
| 34 | */ |
Jungshik Jang | b509c2e | 2014-08-07 13:45:01 +0900 | [diff] [blame] | 35 | final class DeviceSelectAction extends HdmiCecFeatureAction { |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 36 | private static final String TAG = "DeviceSelect"; |
| 37 | |
| 38 | // Time in milliseconds we wait for the device power status to switch to 'Standby' |
| 39 | private static final int TIMEOUT_TRANSIT_TO_STANDBY_MS = 5 * 1000; |
| 40 | |
| 41 | // Time in milliseconds we wait for the device power status to turn to 'On'. |
| 42 | private static final int TIMEOUT_POWER_ON_MS = 5 * 1000; |
| 43 | |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 44 | // The number of times we try to wake up the target device before we give up |
| 45 | // and just send <Set Stream Path>. |
| 46 | private static final int LOOP_COUNTER_MAX = 20; |
| 47 | |
| 48 | // State in which we wait for <Report Power Status> to come in response to the command |
| 49 | // <Give Device Power Status> we have sent. |
| 50 | private static final int STATE_WAIT_FOR_REPORT_POWER_STATUS = 1; |
| 51 | |
| 52 | // State in which we wait for the device power status to switch to 'Standby'. |
| 53 | // We wait till the status becomes 'Standby' before we send <Set Stream Path> |
| 54 | // to wake up the device again. |
| 55 | private static final int STATE_WAIT_FOR_DEVICE_TO_TRANSIT_TO_STANDBY = 2; |
| 56 | |
| 57 | // State in which we wait for the device power status to switch to 'on'. We wait |
| 58 | // maximum 100 seconds (20 * 5) before we give up and just send <Set Stream Path>. |
| 59 | private static final int STATE_WAIT_FOR_DEVICE_POWER_ON = 3; |
| 60 | |
Jungshik Jang | 61f4fbd | 2014-08-06 19:21:12 +0900 | [diff] [blame] | 61 | private final HdmiDeviceInfo mTarget; |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 62 | private final IHdmiControlCallback mCallback; |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 63 | private final HdmiCecMessage mGivePowerStatus; |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 64 | |
| 65 | private int mPowerStatusCounter = 0; |
| 66 | |
| 67 | /** |
| 68 | * Constructor. |
| 69 | * |
Jungshik Jang | 79c58a4 | 2014-06-16 16:45:36 +0900 | [diff] [blame] | 70 | * @param source {@link HdmiCecLocalDevice} instance |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 71 | * @param target target logical device that will be a new active source |
| 72 | * @param callback callback object |
| 73 | */ |
Jinsuk Kim | 8333571 | 2014-06-24 07:57:00 +0900 | [diff] [blame] | 74 | public DeviceSelectAction(HdmiCecLocalDeviceTv source, |
Jungshik Jang | 61f4fbd | 2014-08-06 19:21:12 +0900 | [diff] [blame] | 75 | HdmiDeviceInfo target, IHdmiControlCallback callback) { |
Jungshik Jang | 79c58a4 | 2014-06-16 16:45:36 +0900 | [diff] [blame] | 76 | super(source); |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 77 | mCallback = callback; |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 78 | mTarget = target; |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 79 | mGivePowerStatus = HdmiCecMessageBuilder.buildGiveDevicePowerStatus( |
| 80 | getSourceAddress(), getTargetAddress()); |
| 81 | } |
| 82 | |
| 83 | int getTargetAddress() { |
| 84 | return mTarget.getLogicalAddress(); |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | @Override |
| 88 | public boolean start() { |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 89 | // Seq #9 |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 90 | queryDevicePowerStatus(); |
| 91 | return true; |
| 92 | } |
| 93 | |
| 94 | private void queryDevicePowerStatus() { |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 95 | sendCommand(mGivePowerStatus, new SendMessageCallback() { |
| 96 | @Override |
| 97 | public void onSendCompleted(int error) { |
Jungshik Jang | 5352081c | 2014-09-22 15:14:49 +0900 | [diff] [blame] | 98 | if (error != Constants.SEND_RESULT_SUCCESS) { |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 99 | invokeCallback(HdmiControlManager.RESULT_COMMUNICATION_FAILED); |
| 100 | finish(); |
| 101 | return; |
| 102 | } |
| 103 | } |
| 104 | }); |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 105 | mState = STATE_WAIT_FOR_REPORT_POWER_STATUS; |
Jinsuk Kim | 5fba96d | 2014-07-11 11:51:34 +0900 | [diff] [blame] | 106 | addTimer(mState, HdmiConfig.TIMEOUT_MS); |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | @Override |
| 110 | public boolean processCommand(HdmiCecMessage cmd) { |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 111 | if (cmd.getSource() != getTargetAddress()) { |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 112 | return false; |
| 113 | } |
| 114 | int opcode = cmd.getOpcode(); |
| 115 | byte[] params = cmd.getParams(); |
| 116 | |
| 117 | switch (mState) { |
| 118 | case STATE_WAIT_FOR_REPORT_POWER_STATUS: |
Yuncheol Heo | 75a77e7 | 2014-07-09 18:27:53 +0900 | [diff] [blame] | 119 | if (opcode == Constants.MESSAGE_REPORT_POWER_STATUS) { |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 120 | return handleReportPowerStatus(params[0]); |
| 121 | } |
| 122 | return false; |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 123 | default: |
| 124 | break; |
| 125 | } |
| 126 | return false; |
| 127 | } |
| 128 | |
| 129 | private boolean handleReportPowerStatus(int powerStatus) { |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 130 | switch (powerStatus) { |
Jinsuk Kim | c0c20d0 | 2014-07-04 14:34:31 +0900 | [diff] [blame] | 131 | case HdmiControlManager.POWER_STATUS_ON: |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 132 | sendSetStreamPath(); |
| 133 | return true; |
Jinsuk Kim | c0c20d0 | 2014-07-04 14:34:31 +0900 | [diff] [blame] | 134 | case HdmiControlManager.POWER_STATUS_TRANSIENT_TO_STANDBY: |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 135 | if (mPowerStatusCounter < 4) { |
| 136 | mState = STATE_WAIT_FOR_DEVICE_TO_TRANSIT_TO_STANDBY; |
| 137 | addTimer(mState, TIMEOUT_TRANSIT_TO_STANDBY_MS); |
| 138 | } else { |
| 139 | sendSetStreamPath(); |
| 140 | } |
| 141 | return true; |
Jinsuk Kim | c0c20d0 | 2014-07-04 14:34:31 +0900 | [diff] [blame] | 142 | case HdmiControlManager.POWER_STATUS_STANDBY: |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 143 | if (mPowerStatusCounter == 0) { |
| 144 | turnOnDevice(); |
| 145 | } else { |
| 146 | sendSetStreamPath(); |
| 147 | } |
| 148 | return true; |
Jinsuk Kim | c0c20d0 | 2014-07-04 14:34:31 +0900 | [diff] [blame] | 149 | case HdmiControlManager.POWER_STATUS_TRANSIENT_TO_ON: |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 150 | if (mPowerStatusCounter < LOOP_COUNTER_MAX) { |
| 151 | mState = STATE_WAIT_FOR_DEVICE_POWER_ON; |
| 152 | addTimer(mState, TIMEOUT_POWER_ON_MS); |
| 153 | } else { |
| 154 | sendSetStreamPath(); |
| 155 | } |
| 156 | return true; |
| 157 | } |
| 158 | return false; |
| 159 | } |
| 160 | |
| 161 | private void turnOnDevice() { |
Jungshik Jang | 8fa36b1 | 2014-06-25 15:51:36 +0900 | [diff] [blame] | 162 | sendUserControlPressedAndReleased(mTarget.getLogicalAddress(), |
Jungshik Jang | 210d73d | 2014-07-04 11:11:29 +0900 | [diff] [blame] | 163 | HdmiCecKeycode.CEC_KEYCODE_POWER); |
Jungshik Jang | 8fa36b1 | 2014-06-25 15:51:36 +0900 | [diff] [blame] | 164 | sendUserControlPressedAndReleased(mTarget.getLogicalAddress(), |
Jungshik Jang | 210d73d | 2014-07-04 11:11:29 +0900 | [diff] [blame] | 165 | HdmiCecKeycode.CEC_KEYCODE_POWER_ON_FUNCTION); |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 166 | mState = STATE_WAIT_FOR_DEVICE_POWER_ON; |
| 167 | addTimer(mState, TIMEOUT_POWER_ON_MS); |
| 168 | } |
| 169 | |
| 170 | private void sendSetStreamPath() { |
Jinsuk Kim | 7543497 | 2014-09-25 13:52:50 +0900 | [diff] [blame] | 171 | // Turn the active source invalidated, which remains so till <Active Source> comes from |
| 172 | // the selected device. |
| 173 | tv().getActiveSource().invalidate(); |
| 174 | tv().setActivePath(mTarget.getPhysicalAddress()); |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 175 | sendCommand(HdmiCecMessageBuilder.buildSetStreamPath( |
Jungshik Jang | 79c58a4 | 2014-06-16 16:45:36 +0900 | [diff] [blame] | 176 | getSourceAddress(), mTarget.getPhysicalAddress())); |
Jinsuk Kim | 8e083ec | 2014-08-12 18:10:21 +0900 | [diff] [blame] | 177 | invokeCallback(HdmiControlManager.RESULT_SUCCESS); |
| 178 | finish(); |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 179 | } |
| 180 | |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 181 | @Override |
| 182 | public void handleTimerEvent(int timeoutState) { |
| 183 | if (mState != timeoutState) { |
| 184 | Slog.w(TAG, "Timer in a wrong state. Ignored."); |
| 185 | return; |
| 186 | } |
| 187 | switch (mState) { |
| 188 | case STATE_WAIT_FOR_REPORT_POWER_STATUS: |
Jinsuk Kim | b38cd68 | 2014-07-07 08:05:03 +0900 | [diff] [blame] | 189 | if (tv().isPowerStandbyOrTransient()) { |
| 190 | invokeCallback(HdmiControlManager.RESULT_INCORRECT_MODE); |
| 191 | finish(); |
| 192 | return; |
| 193 | } |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 194 | sendSetStreamPath(); |
| 195 | break; |
| 196 | case STATE_WAIT_FOR_DEVICE_TO_TRANSIT_TO_STANDBY: |
| 197 | case STATE_WAIT_FOR_DEVICE_POWER_ON: |
| 198 | mPowerStatusCounter++; |
| 199 | queryDevicePowerStatus(); |
| 200 | break; |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 201 | } |
| 202 | } |
| 203 | |
| 204 | private void invokeCallback(int result) { |
| 205 | if (mCallback == null) { |
| 206 | return; |
| 207 | } |
| 208 | try { |
| 209 | mCallback.onComplete(result); |
| 210 | } catch (RemoteException e) { |
| 211 | Slog.e(TAG, "Callback failed:" + e); |
| 212 | } |
| 213 | } |
Jinsuk Kim | a6ce770 | 2014-05-11 06:54:49 +0900 | [diff] [blame] | 214 | } |