fixed - updating the device status after a poll was broken and could reset the status...
[deb_libcec.git] / src / lib / implementations / VLCommandHandler.cpp
... / ...
CommitLineData
1/*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33#include "env.h"
34#include "VLCommandHandler.h"
35
36#include "lib/devices/CECBusDevice.h"
37#include "lib/devices/CECPlaybackDevice.h"
38#include "lib/devices/CECTV.h"
39#include "lib/CECProcessor.h"
40#include "lib/LibCEC.h"
41#include "lib/CECClient.h"
42
43#define VL_POWER_CHANGE 0x20
44#define VL_POWERED_UP 0x00
45#define VL_POWERED_DOWN 0x01
46#define VL_UNKNOWN1 0x06
47
48#define VL_REQUEST_POWER_STATUS_TIMEOUT 5000
49
50using namespace CEC;
51using namespace PLATFORM;
52
53#define LIB_CEC m_busDevice->GetProcessor()->GetLib()
54#define ToString(p) LIB_CEC->ToString(p)
55
56// wait this amount of ms before trying to switch sources after receiving the message from the TV that it's powered on
57#define SOURCE_SWITCH_DELAY_MS 3000
58
59CVLCommandHandler::CVLCommandHandler(CCECBusDevice *busDevice,
60 int32_t iTransmitTimeout /* = CEC_DEFAULT_TRANSMIT_TIMEOUT */,
61 int32_t iTransmitWait /* = CEC_DEFAULT_TRANSMIT_WAIT */,
62 int8_t iTransmitRetries /* = CEC_DEFAULT_TRANSMIT_RETRIES */,
63 int64_t iActiveSourcePending /* = 0 */) :
64 CCECCommandHandler(busDevice, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending),
65 m_iPowerUpEventReceived(0),
66 m_bCapabilitiesSent(false),
67 m_iPowerStatusRequested(0)
68{
69 m_vendorId = CEC_VENDOR_PANASONIC;
70}
71
72bool CVLCommandHandler::InitHandler(void)
73{
74 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
75 if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
76 {
77 /* use the VL commandhandler for the primary device that is handled by libCEC */
78 if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
79 {
80 if (primary && m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
81 {
82 primary->SetVendorId(CEC_VENDOR_PANASONIC);
83 primary->ReplaceHandler(false);
84 }
85 }
86
87 if (primary->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
88 return m_processor->GetPrimaryClient()->ChangeDeviceType(CEC_DEVICE_TYPE_RECORDING_DEVICE, CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
89 }
90
91 return CCECCommandHandler::InitHandler();
92}
93
94int CVLCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
95{
96 if (!m_processor->IsHandledByLibCEC(command.destination))
97 return CEC_ABORT_REASON_INVALID_OPERAND;
98
99 if (command.parameters[0] != 0x00 ||
100 command.parameters[1] != 0x80 ||
101 command.parameters[2] != 0x45)
102 return CEC_ABORT_REASON_INVALID_OPERAND;
103
104 // XXX this is also sent when the TV is powered off
105#if 0
106 if (command.initiator == CECDEVICE_TV &&
107 command.parameters.At(3) == VL_UNKNOWN1)
108 {
109 // set the power up event time
110 {
111 CLockObject lock(m_mutex);
112 if (m_iPowerUpEventReceived == 0)
113 m_iPowerUpEventReceived = GetTimeMs();
114 }
115 // mark the TV as powered on
116 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
117 }
118 else
119#endif
120 if (command.initiator == CECDEVICE_TV &&
121 command.destination == CECDEVICE_BROADCAST &&
122 command.parameters.At(3) == VL_POWER_CHANGE)
123 {
124 if (command.parameters.At(4) == VL_POWERED_UP)
125 {
126 // set the power up event time
127 {
128 CLockObject lock(m_mutex);
129 if (m_iPowerUpEventReceived == 0)
130 m_iPowerUpEventReceived = GetTimeMs();
131 }
132 // mark the TV as powered on
133 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
134
135 // send capabilties
136 SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), command.initiator);
137
138 // reactivate the source, so the tv switches channels
139 if (m_processor->IsActiveSource(m_processor->GetLogicalAddress()))
140 m_processor->GetDevice(m_processor->GetLogicalAddress())->TransmitActiveSource(false);
141 }
142 else if (command.parameters.At(4) == VL_POWERED_DOWN)
143 {
144 // reset the power up event time
145 {
146 CLockObject lock(m_mutex);
147 m_iPowerUpEventReceived = 0;
148 }
149 // mark the TV as powered off
150 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
151 }
152 else
153 LIB_CEC->AddLog(CEC_LOG_DEBUG, "skipping unknown vendor command");
154
155 return COMMAND_HANDLED;
156 }
157
158 return CCECCommandHandler::HandleDeviceVendorCommandWithId(command);
159}
160
161bool CVLCommandHandler::PowerUpEventReceived(void)
162{
163 bool bPowerUpEventReceived(true);
164
165 if (m_busDevice->GetLogicalAddress() != CECDEVICE_TV)
166 {
167 CCECBusDevice* tv = m_processor->GetTV();
168 if (tv && tv->GetStatus() != CEC_DEVICE_STATUS_PRESENT)
169 return true;
170
171 // get the status from the TV
172 if (tv && tv->GetCurrentVendorId() == CEC_VENDOR_PANASONIC)
173 {
174 CVLCommandHandler *handler = static_cast<CVLCommandHandler *>(tv->GetHandler());
175 bPowerUpEventReceived = handler ? handler->PowerUpEventReceived() : false;
176 tv->MarkHandlerReady();
177 }
178 }
179 else
180 {
181 // get the current status
182 {
183 CLockObject lock(m_mutex);
184 bPowerUpEventReceived = m_iPowerUpEventReceived > 0 &&
185 GetTimeMs() - m_iPowerUpEventReceived > SOURCE_SWITCH_DELAY_MS;
186 }
187
188 // if we didn't receive the event, check if the TV is already marked as powered on
189 if (!bPowerUpEventReceived && m_busDevice->GetCurrentPowerStatus() == CEC_POWER_STATUS_ON)
190 {
191 CLockObject lock(m_mutex);
192 m_iPowerUpEventReceived = GetTimeMs();
193 bPowerUpEventReceived = true;
194 }
195 }
196
197 return bPowerUpEventReceived;
198}
199
200int CVLCommandHandler::HandleStandby(const cec_command &command)
201{
202 // reset the power up event time
203 {
204 CLockObject lock(m_mutex);
205 m_iPowerUpEventReceived = 0;
206 }
207
208 return CCECCommandHandler::HandleStandby(command);
209}
210
211void CVLCommandHandler::VendorPreActivateSourceHook(void)
212{
213 bool bTransmit(false);
214 {
215 CLockObject lock(m_mutex);
216 bTransmit = !m_bCapabilitiesSent;
217 }
218 if (bTransmit)
219 SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), CECDEVICE_TV);
220}
221
222void CVLCommandHandler::SendVendorCommandCapabilities(const cec_logical_address initiator, const cec_logical_address destination)
223{
224 cec_command response;
225 cec_command::Format(response, initiator, destination, CEC_OPCODE_VENDOR_COMMAND);
226 uint8_t iResponseData[] = {0x10, 0x02, 0xFF, 0xFF, 0x00, 0x05, 0x05, 0x45, 0x55, 0x5c, 0x58, 0x32};
227 response.PushArray(12, iResponseData);
228
229 if (Transmit(response, false, true))
230 {
231 if (PowerUpEventReceived())
232 {
233 CLockObject lock(m_mutex);
234 m_bCapabilitiesSent = true;
235 }
236 }
237}
238
239int CVLCommandHandler::HandleVendorCommand(const cec_command &command)
240{
241 // some vendor command voodoo that will enable more buttons on the remote
242 if (command.parameters.size == 3 &&
243 command.parameters[0] == 0x10 &&
244 command.parameters[1] == 0x01 &&
245 command.parameters[2] == 0x05 &&
246 m_processor->IsHandledByLibCEC(command.destination))
247 {
248 SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), command.initiator);
249 return COMMAND_HANDLED;
250 }
251
252 return CEC_ABORT_REASON_INVALID_OPERAND;
253}
254
255bool CVLCommandHandler::TransmitRequestPowerStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
256{
257 m_iPowerStatusRequested = GetTimeMs();
258 return CCECCommandHandler::TransmitRequestPowerStatus(iInitiator, iDestination, bWaitForResponse);
259}
260
261bool CVLCommandHandler::SourceSwitchAllowed(void)
262{
263 int64_t now(GetTimeMs());
264 if (!PowerUpEventReceived() && now - m_iPowerStatusRequested > VL_REQUEST_POWER_STATUS_TIMEOUT)
265 TransmitRequestPowerStatus(m_processor->GetPrimaryDevice()->GetLogicalAddress(), CECDEVICE_TV, false);
266
267 return PowerUpEventReceived();
268}
269
270int CVLCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
271{
272 if (command.initiator == CECDEVICE_TV)
273 {
274 // set the power up event time
275 {
276 CLockObject lock(m_mutex);
277 if (m_iPowerUpEventReceived == 0)
278 m_iPowerUpEventReceived = GetTimeMs();
279 }
280 // mark the TV as powered on
281 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
282 }
283
284 return CCECCommandHandler::HandleSystemAudioModeRequest(command);
285}
286
287int CVLCommandHandler::HandleReportPowerStatus(const cec_command &command)
288{
289 if (command.initiator == m_busDevice->GetLogicalAddress() &&
290 command.parameters.size == 1 &&
291 (cec_power_status)command.parameters[0] == CEC_POWER_STATUS_ON)
292 {
293 CLockObject lock(m_mutex);
294 if (m_iPowerUpEventReceived == 0)
295 m_iPowerUpEventReceived = GetTimeMs();
296 }
297
298 return CCECCommandHandler::HandleReportPowerStatus(command);
299}