b6c0812d2cbb1de4c37ab17b44fc2be7b44db83e
[deb_libcec.git] / src / lib / CECClient.cpp
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 "CECClient.h"
35
36 #include "CECProcessor.h"
37 #include "LibCEC.h"
38 #include "CECTypeUtils.h"
39 #include "devices/CECPlaybackDevice.h"
40 #include "devices/CECAudioSystem.h"
41 #include "devices/CECTV.h"
42 #include "implementations/CECCommandHandler.h"
43
44 using namespace CEC;
45 using namespace PLATFORM;
46
47 #define LIB_CEC m_processor->GetLib()
48 #define ToString(x) CCECTypeUtils::ToString(x)
49
50 CCECClient::CCECClient(CCECProcessor *processor, const libcec_configuration &configuration) :
51 m_processor(processor),
52 m_bInitialised(false),
53 m_bRegistered(false),
54 m_iCurrentButton(CEC_USER_CONTROL_CODE_UNKNOWN),
55 m_buttontime(0),
56 m_iPreventForwardingPowerOffCommand(0)
57 {
58 m_configuration.Clear();
59 // set the initial configuration
60 SetConfiguration(configuration);
61 }
62
63 CCECClient::~CCECClient(void)
64 {
65 // unregister the client
66 if (m_processor && IsRegistered())
67 m_processor->UnregisterClient(this);
68 }
69
70 bool CCECClient::IsInitialised(void)
71 {
72 CLockObject lock(m_mutex);
73 return m_bInitialised && m_processor;
74 }
75
76 void CCECClient::SetInitialised(bool bSetTo)
77 {
78 CLockObject lock(m_mutex);
79 m_bInitialised = bSetTo;
80 }
81
82 bool CCECClient::IsRegistered(void)
83 {
84 CLockObject lock(m_mutex);
85 return m_bRegistered && m_processor;
86 }
87
88 void CCECClient::SetRegistered(bool bSetTo)
89 {
90 CLockObject lock(m_mutex);
91 m_bRegistered = bSetTo;
92 }
93
94 bool CCECClient::OnRegister(void)
95 {
96 // return false if already initialised
97 if (IsInitialised())
98 return true;
99
100 // get all device we control
101 CECDEVICEVEC devices;
102 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
103
104 // return false when no devices were found
105 if (devices.empty())
106 {
107 LIB_CEC->AddLog(CEC_LOG_WARNING, "cannot find the primary device (logical address %x)", GetPrimaryLogicalAdddress());
108 return false;
109 }
110
111 // mark as initialised
112 SetInitialised(true);
113
114 // configure all devices
115 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
116 {
117 // only set our OSD name for the primary device
118 if ((*it)->GetLogicalAddress() == GetPrimaryLogicalAdddress())
119 (*it)->SetOSDName(m_configuration.strDeviceName);
120
121 // set the default menu language for devices we control
122 (*it)->SetMenuLanguage(m_configuration.strDeviceLanguage);
123 }
124
125 // set the physical address
126 SetPhysicalAddress(m_configuration);
127
128 // make the primary device the active source if the option is set
129 if (m_configuration.bActivateSource == 1)
130 GetPrimaryDevice()->ActivateSource(500);
131
132 return true;
133 }
134
135 bool CCECClient::SetHDMIPort(const cec_logical_address iBaseDevice, const uint8_t iPort, bool bForce /* = false */)
136 {
137 bool bReturn(false);
138
139 // limit the HDMI port range to 1-15
140 if (iPort < CEC_MIN_HDMI_PORTNUMBER ||
141 iPort > CEC_MAX_HDMI_PORTNUMBER)
142 return bReturn;
143
144 LIB_CEC->AddLog(CEC_LOG_NOTICE, "setting HDMI port to %d on device %s (%d)", iPort, ToString(iBaseDevice), (int)iBaseDevice);
145
146 // update the configuration
147 {
148 CLockObject lock(m_mutex);
149 m_configuration.baseDevice = iBaseDevice;
150 m_configuration.iHDMIPort = iPort;
151 }
152
153 // don't continue if the connection isn't opened
154 if (!m_processor->CECInitialised() && !bForce)
155 return true;
156
157 // get the PA of the base device
158 uint16_t iPhysicalAddress(CEC_INVALID_PHYSICAL_ADDRESS);
159 CCECBusDevice *baseDevice = m_processor->GetDevice(iBaseDevice);
160 if (baseDevice)
161 iPhysicalAddress = baseDevice->GetPhysicalAddress(GetPrimaryLogicalAdddress());
162
163 // add our port number
164 if (iPhysicalAddress <= CEC_MAX_PHYSICAL_ADDRESS)
165 {
166 if (iPhysicalAddress == 0)
167 iPhysicalAddress += 0x1000 * iPort;
168 else if (iPhysicalAddress % 0x1000 == 0)
169 iPhysicalAddress += 0x100 * iPort;
170 else if (iPhysicalAddress % 0x100 == 0)
171 iPhysicalAddress += 0x10 * iPort;
172 else if (iPhysicalAddress % 0x10 == 0)
173 iPhysicalAddress += iPort;
174
175 bReturn = true;
176 }
177
178 // set the default address when something went wrong
179 if (!bReturn)
180 {
181 LIB_CEC->AddLog(CEC_LOG_WARNING, "failed to set the physical address to %04X, setting it to the default value %04X", iPhysicalAddress, CEC_DEFAULT_PHYSICAL_ADDRESS);
182 iPhysicalAddress = CEC_DEFAULT_PHYSICAL_ADDRESS;
183 }
184
185 // and set the address
186 SetDevicePhysicalAddress(iPhysicalAddress);
187
188 CallbackConfigurationChanged(m_configuration);
189
190 return bReturn;
191 }
192
193 void CCECClient::ResetPhysicalAddress(void)
194 {
195 SetPhysicalAddress(m_configuration);
196 }
197
198 void CCECClient::SetPhysicalAddress(const libcec_configuration &configuration)
199 {
200 bool bPASet(false);
201
202 // override the physical address from configuration.iPhysicalAddress if it's set
203 if (!bPASet && CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress))
204 bPASet = SetPhysicalAddress(configuration.iPhysicalAddress);
205
206 // try to autodetect the address
207 if (!bPASet && m_processor->CECInitialised())
208 {
209 bPASet = AutodetectPhysicalAddress();
210 m_configuration.bAutodetectAddress = bPASet ? 1 : 0;
211 }
212
213 // use the base device + hdmi port settings
214 if (!bPASet)
215 bPASet = SetHDMIPort(configuration.baseDevice, configuration.iHDMIPort);
216
217 // reset to defaults if something went wrong
218 if (!bPASet)
219 {
220 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - resetting HDMI port and base device to defaults", __FUNCTION__);
221 m_configuration.baseDevice = CECDEVICE_UNKNOWN;
222 m_configuration.iHDMIPort = CEC_HDMI_PORTNUMBER_NONE;
223 }
224 }
225
226 bool CCECClient::SetPhysicalAddress(const uint16_t iPhysicalAddress)
227 {
228 // update the configuration
229 bool bChanged(true);
230 {
231 CLockObject lock(m_mutex);
232 if (m_configuration.iPhysicalAddress == iPhysicalAddress)
233 bChanged = false;
234 else
235 m_configuration.iPhysicalAddress = iPhysicalAddress;
236 }
237 if (!bChanged)
238 {
239 LIB_CEC->AddLog(CEC_LOG_DEBUG, "physical address unchanged (%04X)", iPhysicalAddress);
240 return true;
241 }
242
243 LIB_CEC->AddLog(CEC_LOG_DEBUG, "setting physical address to '%04X'", iPhysicalAddress);
244
245 // set the physical address for each device
246 SetDevicePhysicalAddress(iPhysicalAddress);
247
248 // and send back the updated configuration
249 CallbackConfigurationChanged(m_configuration);
250
251 return true;
252 }
253
254 void CCECClient::SetSupportedDeviceTypes(void)
255 {
256 cec_device_type_list types;
257 types.Clear();
258
259 // get the command handler for the tv
260 CCECCommandHandler *tvHandler = m_processor->GetTV()->GetHandler();
261 if (!tvHandler)
262 return;
263
264 // check all device types
265 for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
266 {
267 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
268 continue;
269
270 // get the supported device type. the handler will replace types it doesn't support by one it does support
271 cec_device_type type = tvHandler->GetReplacementDeviceType(m_configuration.deviceTypes.types[iPtr]);
272 if (!types.IsSet(type))
273 types.Add(type);
274 }
275 m_processor->GetTV()->MarkHandlerReady();
276
277 // set the new type list
278 m_configuration.deviceTypes = types;
279
280 // persist the new configuration
281 PersistConfiguration(m_configuration);
282 }
283
284 bool CCECClient::AllocateLogicalAddresses(void)
285 {
286 // reset all previous LAs that were set
287 m_configuration.logicalAddresses.Clear();
288
289 // get the supported device types from the command handler of the TV
290 SetSupportedDeviceTypes();
291
292 // display an error if no device types are set
293 if (m_configuration.deviceTypes.IsEmpty())
294 {
295 LIB_CEC->AddLog(CEC_LOG_ERROR, "no device types given");
296 return false;
297 }
298
299 // check each entry of the list
300 for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
301 {
302 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
303 continue;
304
305 // find an LA for this type
306 cec_logical_address address(CECDEVICE_UNKNOWN);
307 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RECORDING_DEVICE)
308 address = AllocateLogicalAddressRecordingDevice();
309 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_TUNER)
310 address = AllocateLogicalAddressTuner();
311 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_PLAYBACK_DEVICE)
312 address = AllocateLogicalAddressPlaybackDevice();
313 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
314 address = AllocateLogicalAddressAudioSystem();
315
316 // display an error if no LA could be allocated
317 if (address == CECDEVICE_UNKNOWN)
318 {
319 LIB_CEC->AddLog(CEC_LOG_ERROR, "%s - failed to allocate device '%d', type '%s'", __FUNCTION__, iPtr, ToString(m_configuration.deviceTypes.types[iPtr]));
320 return false;
321 }
322
323 // display the registered LA
324 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - device '%d', type '%s', LA '%X'", __FUNCTION__, iPtr, ToString(m_configuration.deviceTypes.types[iPtr]), address);
325 m_configuration.logicalAddresses.Set(address);
326 }
327
328 // persist the new configuration
329 PersistConfiguration(m_configuration);
330
331 return true;
332 }
333
334 cec_logical_address CCECClient::AllocateLogicalAddressRecordingDevice(void)
335 {
336 cec_logical_address retVal(CECDEVICE_UNKNOWN);
337
338 LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'recording device'");
339 if (m_processor->TryLogicalAddress(CECDEVICE_RECORDINGDEVICE1, m_configuration.cecVersion))
340 retVal = CECDEVICE_RECORDINGDEVICE1;
341 else if (m_processor->TryLogicalAddress(CECDEVICE_RECORDINGDEVICE2, m_configuration.cecVersion))
342 retVal = CECDEVICE_RECORDINGDEVICE2;
343 else if (m_processor->TryLogicalAddress(CECDEVICE_RECORDINGDEVICE3, m_configuration.cecVersion))
344 retVal = CECDEVICE_RECORDINGDEVICE3;
345
346 return retVal;
347 }
348
349 cec_logical_address CCECClient::AllocateLogicalAddressTuner(void)
350 {
351 cec_logical_address retVal(CECDEVICE_UNKNOWN);
352
353 LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'tuner'");
354 if (m_processor->TryLogicalAddress(CECDEVICE_TUNER1, m_configuration.cecVersion))
355 retVal = CECDEVICE_TUNER1;
356 else if (m_processor->TryLogicalAddress(CECDEVICE_TUNER2, m_configuration.cecVersion))
357 retVal = CECDEVICE_TUNER2;
358 else if (m_processor->TryLogicalAddress(CECDEVICE_TUNER3, m_configuration.cecVersion))
359 retVal = CECDEVICE_TUNER3;
360 else if (m_processor->TryLogicalAddress(CECDEVICE_TUNER4, m_configuration.cecVersion))
361 retVal = CECDEVICE_TUNER4;
362
363 return retVal;
364 }
365
366 cec_logical_address CCECClient::AllocateLogicalAddressPlaybackDevice(void)
367 {
368 cec_logical_address retVal(CECDEVICE_UNKNOWN);
369
370 LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'playback device'");
371 if (m_processor->TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE1, m_configuration.cecVersion))
372 retVal = CECDEVICE_PLAYBACKDEVICE1;
373 else if (m_processor->TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE2, m_configuration.cecVersion))
374 retVal = CECDEVICE_PLAYBACKDEVICE2;
375 else if (m_processor->TryLogicalAddress(CECDEVICE_PLAYBACKDEVICE3, m_configuration.cecVersion))
376 retVal = CECDEVICE_PLAYBACKDEVICE3;
377
378 return retVal;
379 }
380
381 cec_logical_address CCECClient::AllocateLogicalAddressAudioSystem(void)
382 {
383 cec_logical_address retVal(CECDEVICE_UNKNOWN);
384
385 LIB_CEC->AddLog(CEC_LOG_DEBUG, "detecting logical address for type 'audiosystem'");
386 if (m_processor->TryLogicalAddress(CECDEVICE_AUDIOSYSTEM, m_configuration.cecVersion))
387 retVal = CECDEVICE_AUDIOSYSTEM;
388
389 return retVal;
390 }
391
392 CCECBusDevice *CCECClient::GetDeviceByType(const cec_device_type type) const
393 {
394 // get all devices that match our logical addresses
395 CECDEVICEVEC devices;
396 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
397
398 // filter the type we need
399 CCECDeviceMap::FilterType(type, devices);
400
401 return devices.empty() ?
402 NULL :
403 *devices.begin();
404 }
405
406 bool CCECClient::ChangeDeviceType(const cec_device_type from, const cec_device_type to)
407 {
408 if (from == to)
409 return true;
410
411 LIB_CEC->AddLog(CEC_LOG_NOTICE, "changing device type '%s' into '%s'", ToString(from), ToString(to));
412
413 {
414 CLockObject lock(m_mutex);
415
416 // get the previous device that was allocated
417 CCECBusDevice *previousDevice = GetDeviceByType(from);
418 if (!previousDevice)
419 return false;
420
421 // change the type in the device type list
422 bool bChanged(false);
423 for (uint8_t iPtr = 0; iPtr < 5; iPtr++)
424 {
425 if (m_configuration.deviceTypes.types[iPtr] == CEC_DEVICE_TYPE_RESERVED)
426 continue;
427
428 if (m_configuration.deviceTypes.types[iPtr] == from)
429 {
430 bChanged = true;
431 m_configuration.deviceTypes.types[iPtr] = to;
432 }
433 else if (m_configuration.deviceTypes.types[iPtr] == to && bChanged)
434 {
435 // ensure that dupes are removed
436 m_configuration.deviceTypes.types[iPtr] = CEC_DEVICE_TYPE_RESERVED;
437 }
438 }
439 }
440
441 // re-register the client to set the new ackmask
442 if (!m_processor->RegisterClient(this))
443 return false;
444
445 // persist the new configuration
446 PersistConfiguration(m_configuration);
447
448 return true;
449 }
450
451 bool CCECClient::SetLogicalAddress(const cec_logical_address iLogicalAddress)
452 {
453 bool bReturn(true);
454
455 if (GetPrimaryLogicalAdddress() != iLogicalAddress)
456 {
457 LIB_CEC->AddLog(CEC_LOG_NOTICE, "<< setting primary logical address to %1x", iLogicalAddress);
458 {
459 CLockObject lock(m_mutex);
460 m_configuration.logicalAddresses.primary = iLogicalAddress;
461 m_configuration.logicalAddresses.Set(iLogicalAddress);
462 }
463
464 bReturn = m_processor->RegisterClient(this);
465
466 // persist the new configuration
467 if (bReturn)
468 PersistConfiguration(m_configuration);
469 }
470
471 return bReturn;
472 }
473
474 bool CCECClient::Transmit(const cec_command &data, bool bIsReply)
475 {
476 return m_processor ? m_processor->Transmit(data, bIsReply) : false;
477 }
478
479 bool CCECClient::SendPowerOnDevices(const cec_logical_address address /* = CECDEVICE_TV */)
480 {
481 // if the broadcast address if set as destination and the client version >=1.5.0, read the wakeDevices setting
482 if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0)
483 {
484 CECDEVICEVEC devices;
485 m_processor->GetDevices()->GetWakeDevices(m_configuration, devices);
486 return m_processor->PowerOnDevices(GetPrimaryLogicalAdddress(), devices);
487 }
488
489 return m_processor->PowerOnDevice(GetPrimaryLogicalAdddress(), address);
490 }
491
492 bool CCECClient::SendStandbyDevices(const cec_logical_address address /* = CECDEVICE_BROADCAST */)
493 {
494 // if the broadcast address if set as destination and the client version >=1.5.0, read the standbyDevices setting
495 if (address == CECDEVICE_BROADCAST && m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0)
496 {
497 CECDEVICEVEC devices;
498 m_processor->GetDevices()->GetPowerOffDevices(m_configuration, devices);
499 return m_processor->StandbyDevices(GetPrimaryLogicalAdddress(), devices);
500 }
501
502 return m_processor->StandbyDevice(GetPrimaryLogicalAdddress(), address);
503 }
504
505 bool CCECClient::SendSetActiveSource(const cec_device_type type /* = CEC_DEVICE_TYPE_RESERVED */)
506 {
507 // get the devices that are controlled by us
508 CECDEVICEVEC devices;
509 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
510
511 // filter out the device that matches the given type
512 if (type != CEC_DEVICE_TYPE_RESERVED)
513 CCECDeviceMap::FilterType(type, devices);
514
515 // no devices left, re-fetch the list of devices that are controlled by us
516 if (devices.empty())
517 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
518
519 if (!devices.empty())
520 {
521 // get the first device from the list
522 CCECBusDevice *device = *devices.begin();
523
524 // and activate it
525 if (!m_processor->CECInitialised())
526 device->MarkAsActiveSource();
527 else if (device->HasValidPhysicalAddress())
528 return device->ActivateSource();
529 }
530
531 return false;
532 }
533
534 CCECPlaybackDevice *CCECClient::GetPlaybackDevice(void)
535 {
536 CCECPlaybackDevice *device(NULL);
537 CECDEVICEVEC devices;
538
539 // get the playback devices
540 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
541 CCECDeviceMap::FilterType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE, devices);
542
543 // no matches, get the recording devices
544 if (devices.empty())
545 {
546 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
547 CCECDeviceMap::FilterType(CEC_DEVICE_TYPE_RECORDING_DEVICE, devices);
548 }
549
550 // get the first device that matches, and cast it to CCECPlaybackDevice
551 if (!devices.empty())
552 device = (*devices.begin())->AsPlaybackDevice();
553
554 return device;
555 }
556
557 cec_logical_address CCECClient::GetPrimaryLogicalAdddress(void)
558 {
559 CLockObject lock(m_mutex);
560 return m_configuration.logicalAddresses.primary;
561 }
562
563 CCECBusDevice *CCECClient::GetPrimaryDevice(void)
564 {
565 return m_processor->GetDevice(GetPrimaryLogicalAdddress());
566 }
567
568 bool CCECClient::SendSetDeckControlMode(const cec_deck_control_mode mode, bool bSendUpdate /* = true */)
569 {
570 // find a playback device that we control
571 CCECPlaybackDevice *device = GetPlaybackDevice();
572 if (device)
573 {
574 // and set the deck control mode if there is a match
575 device->SetDeckControlMode(mode);
576 if (bSendUpdate)
577 return device->TransmitDeckStatus(CECDEVICE_TV, false);
578 return true;
579 }
580
581 // no match
582 return false;
583 }
584
585 bool CCECClient::SendSetDeckInfo(const cec_deck_info info, bool bSendUpdate /* = true */)
586 {
587 // find a playback device that we control
588 CCECPlaybackDevice *device = GetPlaybackDevice();
589 if (device)
590 {
591 // and set the deck status if there is a match
592 device->SetDeckStatus(info);
593 if (bSendUpdate)
594 return device->AsPlaybackDevice()->TransmitDeckStatus(CECDEVICE_TV, false);
595 return true;
596 }
597
598 // no match
599 return false;
600 }
601
602 bool CCECClient::SendSetMenuState(const cec_menu_state state, bool bSendUpdate /* = true */)
603 {
604 CECDEVICEVEC devices;
605
606 // set the menu state for all devices that are controlled by us
607 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
608 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
609 {
610 (*it)->SetMenuState(state);
611 if (bSendUpdate)
612 (*it)->TransmitMenuState(CECDEVICE_TV, false);
613 }
614
615 return true;
616 }
617
618 bool CCECClient::SendSetInactiveView(void)
619 {
620 CECDEVICEVEC devices;
621
622 // mark all devices that are controlled by us as inactive source
623 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
624 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
625 {
626 if ((*it)->IsActiveSource())
627 {
628 (*it)->MarkAsInactiveSource();
629 return (*it)->TransmitInactiveSource();
630 }
631 }
632
633 return true;
634 }
635
636 bool CCECClient::SendSetOSDString(const cec_logical_address iLogicalAddress, const cec_display_control duration, const char *strMessage)
637 {
638 CCECBusDevice *primary = GetPrimaryDevice();
639 if (primary)
640 return primary->TransmitOSDString(iLogicalAddress, duration, strMessage, false);
641
642 return false;
643 }
644
645 cec_version CCECClient::GetDeviceCecVersion(const cec_logical_address iAddress)
646 {
647 CCECBusDevice *device = m_processor->GetDevice(iAddress);
648 if (device)
649 return device->GetCecVersion(GetPrimaryLogicalAdddress());
650 return CEC_VERSION_UNKNOWN;
651 }
652
653 bool CCECClient::GetDeviceMenuLanguage(const cec_logical_address iAddress, cec_menu_language &language)
654 {
655 CCECBusDevice *device = m_processor->GetDevice(iAddress);
656 if (device)
657 {
658 language = device->GetMenuLanguage(GetPrimaryLogicalAdddress());
659 return (strcmp(language.language, "???") != 0);
660 }
661 return false;
662 }
663
664 cec_osd_name CCECClient::GetDeviceOSDName(const cec_logical_address iAddress)
665 {
666 cec_osd_name retVal;
667 retVal.device = iAddress;
668 retVal.name[0] = 0;
669
670 CCECBusDevice *device = m_processor->GetDevice(iAddress);
671 if (device)
672 {
673 CStdString strOSDName = device->GetOSDName(GetPrimaryLogicalAdddress());
674 snprintf(retVal.name, sizeof(retVal.name), "%s", strOSDName.c_str());
675 retVal.device = iAddress;
676 }
677
678 return retVal;
679 }
680
681 uint16_t CCECClient::GetDevicePhysicalAddress(const cec_logical_address iAddress)
682 {
683 CCECBusDevice *device = m_processor->GetDevice(iAddress);
684 if (device)
685 return device->GetPhysicalAddress(GetPrimaryLogicalAdddress());
686 return CEC_INVALID_PHYSICAL_ADDRESS;
687 }
688
689 cec_power_status CCECClient::GetDevicePowerStatus(const cec_logical_address iAddress)
690 {
691 CCECBusDevice *device = m_processor->GetDevice(iAddress);
692 if (device)
693 return device->GetPowerStatus(GetPrimaryLogicalAdddress());
694 return CEC_POWER_STATUS_UNKNOWN;
695 }
696
697 uint64_t CCECClient::GetDeviceVendorId(const cec_logical_address iAddress)
698 {
699 CCECBusDevice *device = m_processor->GetDevice(iAddress);
700 if (device)
701 return device->GetVendorId(GetPrimaryLogicalAdddress());
702 return CEC_VENDOR_UNKNOWN;
703 }
704
705 uint8_t CCECClient::SendVolumeUp(bool bSendRelease /* = true */)
706 {
707 CCECBusDevice *device = GetPrimaryDevice();
708 CCECAudioSystem *audio = m_processor->GetAudioSystem();
709
710 return device && audio && audio->IsPresent() ?
711 audio->VolumeUp(device->GetLogicalAddress(), bSendRelease) :
712 (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
713 }
714
715 uint8_t CCECClient::SendVolumeDown(bool bSendRelease /* = true */)
716 {
717 CCECBusDevice *device = GetPrimaryDevice();
718 CCECAudioSystem *audio = m_processor->GetAudioSystem();
719
720 return device && audio && audio->IsPresent() ?
721 audio->VolumeDown(device->GetLogicalAddress(), bSendRelease) :
722 (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
723 }
724
725 uint8_t CCECClient::SendMuteAudio(void)
726 {
727 CCECBusDevice *device = GetPrimaryDevice();
728 CCECAudioSystem *audio = m_processor->GetAudioSystem();
729
730 return device && audio && audio->IsPresent() ?
731 audio->MuteAudio(device->GetLogicalAddress()) :
732 (uint8_t)CEC_AUDIO_VOLUME_STATUS_UNKNOWN;
733 }
734
735 bool CCECClient::SendKeypress(const cec_logical_address iDestination, const cec_user_control_code key, bool bWait /* = true */)
736 {
737 CCECBusDevice *dest = m_processor->GetDevice(iDestination);
738
739 return dest ?
740 dest->TransmitKeypress(GetPrimaryLogicalAdddress(), key, bWait) :
741 false;
742 }
743
744 bool CCECClient::SendKeyRelease(const cec_logical_address iDestination, bool bWait /* = true */)
745 {
746 CCECBusDevice *dest = m_processor->GetDevice(iDestination);
747
748 return dest ?
749 dest->TransmitKeyRelease(GetPrimaryLogicalAdddress(), bWait) :
750 false;
751 }
752
753 bool CCECClient::GetCurrentConfiguration(libcec_configuration &configuration)
754 {
755 CLockObject lock(m_mutex);
756
757 // client version 1.5.0
758 snprintf(configuration.strDeviceName, 13, "%s", m_configuration.strDeviceName);
759 configuration.deviceTypes = m_configuration.deviceTypes;
760 configuration.bAutodetectAddress = m_configuration.bAutodetectAddress;
761 configuration.iPhysicalAddress = m_configuration.iPhysicalAddress;
762 configuration.baseDevice = m_configuration.baseDevice;
763 configuration.iHDMIPort = m_configuration.iHDMIPort;
764 configuration.clientVersion = m_configuration.clientVersion;
765 configuration.serverVersion = m_configuration.serverVersion;
766 configuration.tvVendor = m_configuration.tvVendor;
767
768 configuration.bGetSettingsFromROM = m_configuration.bGetSettingsFromROM;
769 configuration.bUseTVMenuLanguage = m_configuration.bUseTVMenuLanguage;
770 configuration.bActivateSource = m_configuration.bActivateSource;
771 configuration.wakeDevices = m_configuration.wakeDevices;
772 configuration.powerOffDevices = m_configuration.powerOffDevices;
773 configuration.bPowerOffScreensaver = m_configuration.bPowerOffScreensaver;
774 configuration.bPowerOffOnStandby = m_configuration.bPowerOffOnStandby;
775
776 // client version 1.5.1
777 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_1)
778 configuration.bSendInactiveSource = m_configuration.bSendInactiveSource;
779
780 // client version 1.5.3
781 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_3)
782 configuration.logicalAddresses = m_configuration.logicalAddresses;
783
784 // client version 1.6.0
785 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_0)
786 {
787 configuration.iFirmwareVersion = m_configuration.iFirmwareVersion;
788 configuration.bPowerOffDevicesOnStandby = m_configuration.bPowerOffDevicesOnStandby;
789 configuration.bShutdownOnStandby = m_configuration.bShutdownOnStandby;
790 }
791
792 // client version 1.6.2
793 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_2)
794 {
795 memcpy(configuration.strDeviceLanguage, m_configuration.strDeviceLanguage, 3);
796 configuration.iFirmwareBuildDate = m_configuration.iFirmwareBuildDate;
797 }
798
799 // client version 1.6.3
800 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_3)
801 {
802 configuration.bMonitorOnly = m_configuration.bMonitorOnly;
803 }
804
805 return true;
806 }
807
808 bool CCECClient::SetConfiguration(const libcec_configuration &configuration)
809 {
810 bool bIsRunning(m_processor && m_processor->CECInitialised());
811 CCECBusDevice *primary = bIsRunning ? GetPrimaryDevice() : NULL;
812 uint16_t iPA = primary ? primary->GetCurrentPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS;
813
814 // update the callbacks
815 if (configuration.callbacks)
816 EnableCallbacks(configuration.callbackParam, configuration.callbacks);
817
818 // update the client version
819 SetClientVersion((cec_client_version)configuration.clientVersion);
820
821 // update the OSD name
822 CStdString strOSDName(configuration.strDeviceName);
823 SetOSDName(strOSDName);
824
825 // update the TV vendor override
826 SetTVVendorOverride((cec_vendor_id)configuration.tvVendor);
827
828 // just copy these
829 {
830 CLockObject lock(m_mutex);
831 m_configuration.bUseTVMenuLanguage = configuration.bUseTVMenuLanguage;
832 m_configuration.bActivateSource = configuration.bActivateSource;
833 m_configuration.bGetSettingsFromROM = configuration.bGetSettingsFromROM;
834 m_configuration.wakeDevices = configuration.wakeDevices;
835 m_configuration.powerOffDevices = configuration.powerOffDevices;
836 m_configuration.bPowerOffScreensaver = configuration.bPowerOffScreensaver;
837 m_configuration.bPowerOffOnStandby = configuration.bPowerOffOnStandby;
838
839 // client version 1.5.1
840 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_1)
841 m_configuration.bSendInactiveSource = configuration.bSendInactiveSource;
842
843 // client version 1.6.0
844 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_0)
845 {
846 m_configuration.bPowerOffDevicesOnStandby = configuration.bPowerOffDevicesOnStandby;
847 m_configuration.bShutdownOnStandby = configuration.bShutdownOnStandby;
848 }
849
850 // client version 1.6.2
851 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_2)
852 {
853 memcpy(m_configuration.strDeviceLanguage, configuration.strDeviceLanguage, 3);
854 }
855
856 // client version 1.6.3
857 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_3)
858 {
859 m_configuration.bMonitorOnly = configuration.bMonitorOnly;
860 }
861
862 // ensure that there is at least 1 device type set
863 if (m_configuration.deviceTypes.IsEmpty())
864 m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
865 }
866
867 bool bNeedReinit(false);
868
869 // device types
870 if (SetDeviceTypes(configuration.deviceTypes))
871 {
872 // the device type changed. just copy the rest, and re-register
873 {
874 CLockObject lock(m_mutex);
875 m_configuration.iPhysicalAddress = configuration.iPhysicalAddress;
876 m_configuration.baseDevice = configuration.baseDevice;
877 m_configuration.iHDMIPort = configuration.iHDMIPort;
878 bNeedReinit = true;
879 }
880 }
881 else
882 {
883 // set the physical address
884 SetPhysicalAddress(configuration);
885 }
886
887 // persist the new configuration
888 PersistConfiguration(m_configuration);
889
890 if (!primary)
891 primary = GetPrimaryDevice();
892
893 if (bNeedReinit || !primary || primary->GetCurrentPhysicalAddress() != iPA)
894 {
895 // PA or device type changed
896 m_processor->RegisterClient(this);
897 }
898 else if (primary && configuration.bActivateSource == 1 && bIsRunning && !primary->IsActiveSource())
899 {
900 // activate the source if we're not already the active source
901 primary->ActivateSource();
902 }
903
904 return true;
905 }
906
907 void CCECClient::AddCommand(const cec_command &command)
908 {
909 // don't forward the standby opcode more than once every 10 seconds
910 if (command.opcode == CEC_OPCODE_STANDBY)
911 {
912 CLockObject lock(m_mutex);
913 if (m_iPreventForwardingPowerOffCommand != 0 &&
914 m_iPreventForwardingPowerOffCommand > GetTimeMs())
915 return;
916 else
917 m_iPreventForwardingPowerOffCommand = GetTimeMs() + CEC_FORWARD_STANDBY_MIN_INTERVAL;
918 }
919
920 if (command.destination == CECDEVICE_BROADCAST || GetLogicalAddresses().IsSet(command.destination))
921 {
922 LIB_CEC->AddLog(CEC_LOG_NOTICE, ">> %s (%X) -> %s (%X): %s (%2X)", ToString(command.initiator), command.initiator, ToString(command.destination), command.destination, ToString(command.opcode), command.opcode);
923 CallbackAddCommand(command);
924 }
925 }
926
927 int CCECClient::MenuStateChanged(const cec_menu_state newState)
928 {
929 LIB_CEC->AddLog(CEC_LOG_NOTICE, ">> %s: %s", ToString(CEC_OPCODE_MENU_REQUEST), ToString(newState));
930 return CallbackMenuStateChanged(newState);
931 }
932
933 void CCECClient::AddKey(void)
934 {
935 cec_keypress key;
936 key.keycode = CEC_USER_CONTROL_CODE_UNKNOWN;
937
938 {
939 CLockObject lock(m_mutex);
940 if (m_iCurrentButton != CEC_USER_CONTROL_CODE_UNKNOWN)
941 {
942 key.duration = (unsigned int) (GetTimeMs() - m_buttontime);
943 key.keycode = m_iCurrentButton;
944
945 m_iCurrentButton = CEC_USER_CONTROL_CODE_UNKNOWN;
946 m_buttontime = 0;
947 }
948 }
949
950 if (key.keycode != CEC_USER_CONTROL_CODE_UNKNOWN)
951 {
952 LIB_CEC->AddLog(CEC_LOG_DEBUG, "key released: %s (%1x)", ToString(key.keycode), key.keycode);
953 CallbackAddKey(key);
954 }
955 }
956
957 void CCECClient::AddKey(const cec_keypress &key)
958 {
959 {
960 CLockObject lock(m_mutex);
961 m_iCurrentButton = key.duration > 0 ? CEC_USER_CONTROL_CODE_UNKNOWN : key.keycode;
962 m_buttontime = key.duration > 0 ? 0 : GetTimeMs();
963 }
964
965 LIB_CEC->AddLog(CEC_LOG_DEBUG, "key pressed: %s (%1x)", ToString(key.keycode), key.keycode);
966 CallbackAddKey(key);
967 }
968
969 void CCECClient::SetCurrentButton(const cec_user_control_code iButtonCode)
970 {
971 // push a keypress to the buffer with 0 duration and another with the duration set when released
972 cec_keypress key;
973 key.duration = 0;
974 key.keycode = iButtonCode;
975
976 AddKey(key);
977 }
978
979 void CCECClient::CheckKeypressTimeout(void)
980 {
981 cec_keypress key;
982
983 {
984 CLockObject lock(m_mutex);
985 uint64_t iNow = GetTimeMs();
986
987 if (m_iCurrentButton != CEC_USER_CONTROL_CODE_UNKNOWN &&
988 iNow - m_buttontime > CEC_BUTTON_TIMEOUT)
989 {
990 key.duration = (unsigned int) (iNow - m_buttontime);
991 key.keycode = m_iCurrentButton;
992
993 m_iCurrentButton = CEC_USER_CONTROL_CODE_UNKNOWN;
994 m_buttontime = 0;
995 }
996 else
997 {
998 return;
999 }
1000 }
1001
1002 LIB_CEC->AddLog(CEC_LOG_DEBUG, "key auto-released: %s (%1x)", ToString(key.keycode), key.keycode);
1003 CallbackAddKey(key);
1004 }
1005
1006 bool CCECClient::EnableCallbacks(void *cbParam, ICECCallbacks *callbacks)
1007 {
1008 CLockObject lock(m_cbMutex);
1009 m_configuration.callbackParam = cbParam;
1010 m_configuration.callbacks = callbacks;
1011 return true;
1012 }
1013
1014 bool CCECClient::PingAdapter(void)
1015 {
1016 return m_processor ? m_processor->PingAdapter() : false;
1017 }
1018
1019 bool CCECClient::GetNextLogMessage(cec_log_message *message)
1020 {
1021 return (m_logBuffer.Pop(*message));
1022 }
1023
1024 bool CCECClient::GetNextKeypress(cec_keypress *key)
1025 {
1026 return m_keyBuffer.Pop(*key);
1027 }
1028
1029 bool CCECClient::GetNextCommand(cec_command *command)
1030 {
1031 return m_commandBuffer.Pop(*command);
1032 }
1033
1034 std::string CCECClient::GetConnectionInfo(void)
1035 {
1036 CStdString strLog;
1037 strLog.Format("libCEC version = %s, client version = %s, firmware version = %d", ToString((cec_server_version)m_configuration.serverVersion), ToString((cec_client_version)m_configuration.clientVersion), m_configuration.iFirmwareVersion);
1038 if (m_configuration.iFirmwareBuildDate != CEC_FW_BUILD_UNKNOWN)
1039 {
1040 time_t buildTime = (time_t)m_configuration.iFirmwareBuildDate;
1041 strLog.AppendFormat(", firmware build date: %s", asctime(gmtime(&buildTime)));
1042 strLog = strLog.Left((int)strLog.length() - 1); // strip \n added by asctime
1043 strLog.append(" +0000");
1044 }
1045
1046 // log the addresses that are being used
1047 if (!m_configuration.logicalAddresses.IsEmpty())
1048 {
1049 strLog.append(", logical address(es) = ");
1050 CECDEVICEVEC devices;
1051 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
1052 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
1053 strLog.AppendFormat("%s (%X) ", (*it)->GetLogicalAddressName(), (*it)->GetLogicalAddress());
1054 }
1055
1056 if (!CLibCEC::IsValidPhysicalAddress(m_configuration.iPhysicalAddress))
1057 strLog.AppendFormat(", base device: %s (%X), HDMI port number: %d", ToString(m_configuration.baseDevice), m_configuration.baseDevice, m_configuration.iHDMIPort);
1058 else
1059 strLog.AppendFormat(", physical address: %04x", m_configuration.iPhysicalAddress);
1060
1061 strLog.AppendFormat(", %s", LIB_CEC->GetLibInfo());
1062
1063 std::string strReturn(strLog.c_str());
1064 return strReturn;
1065 }
1066
1067 void CCECClient::SetTVVendorOverride(const cec_vendor_id id)
1068 {
1069 {
1070 CLockObject lock(m_mutex);
1071 m_configuration.tvVendor = id;
1072 }
1073
1074 if (id != CEC_VENDOR_UNKNOWN)
1075 {
1076 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - vendor id '%s'", __FUNCTION__, ToString(id));
1077
1078 CCECBusDevice *tv = m_processor ? m_processor->GetTV() : NULL;
1079 if (tv)
1080 tv->SetVendorId((uint64_t)id);
1081 }
1082
1083 // persist the new configuration
1084 PersistConfiguration(m_configuration);
1085 }
1086
1087 cec_vendor_id CCECClient::GetTVVendorOverride(void)
1088 {
1089 CLockObject lock(m_mutex);
1090 return (cec_vendor_id)m_configuration.tvVendor;
1091 }
1092
1093 void CCECClient::SetOSDName(const std::string &strDeviceName)
1094 {
1095 {
1096 CLockObject lock(m_mutex);
1097 snprintf(m_configuration.strDeviceName, 13, "%s", strDeviceName.c_str());
1098 }
1099
1100 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - using OSD name '%s'", __FUNCTION__, strDeviceName.c_str());
1101
1102 CCECBusDevice *primary = GetPrimaryDevice();
1103 if (primary && !primary->GetCurrentOSDName().Equals(strDeviceName.c_str()))
1104 {
1105 primary->SetOSDName(strDeviceName);
1106 if (m_processor && m_processor->CECInitialised())
1107 primary->TransmitOSDName(CECDEVICE_TV, false);
1108 }
1109
1110 // persist the new configuration
1111 PersistConfiguration(m_configuration);
1112 }
1113
1114 std::string CCECClient::GetOSDName(void)
1115 {
1116 CLockObject lock(m_mutex);
1117 std::string strOSDName(m_configuration.strDeviceName);
1118 return strOSDName;
1119 }
1120
1121 void CCECClient::SetWakeDevices(const cec_logical_addresses &addresses)
1122 {
1123 {
1124 CLockObject lock(m_mutex);
1125 m_configuration.wakeDevices = addresses;
1126 }
1127 // persist the new configuration
1128 PersistConfiguration(m_configuration);
1129 }
1130
1131 cec_logical_addresses CCECClient::GetWakeDevices(void)
1132 {
1133 CLockObject lock(m_mutex);
1134 return m_configuration.wakeDevices;
1135 }
1136
1137 bool CCECClient::AutodetectPhysicalAddress(void)
1138 {
1139 bool bPhysicalAutodetected(false);
1140 uint16_t iPhysicalAddress = m_processor ? m_processor->GetDetectedPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS;
1141
1142 if (CLibCEC::IsValidPhysicalAddress(iPhysicalAddress))
1143 {
1144 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - autodetected physical address '%04X'", __FUNCTION__, iPhysicalAddress);
1145
1146 CLockObject lock(m_mutex);
1147 m_configuration.iPhysicalAddress = iPhysicalAddress;
1148 m_configuration.iHDMIPort = CEC_HDMI_PORTNUMBER_NONE;
1149 m_configuration.baseDevice = CECDEVICE_UNKNOWN;
1150 bPhysicalAutodetected = true;
1151 }
1152
1153 SetDevicePhysicalAddress(iPhysicalAddress);
1154
1155 return bPhysicalAutodetected;
1156 }
1157
1158 void CCECClient::SetClientVersion(const cec_client_version version)
1159 {
1160 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - using client version '%s'", __FUNCTION__, ToString(version));
1161
1162 CLockObject lock(m_mutex);
1163 m_configuration.clientVersion = (uint32_t)version;
1164 }
1165
1166 cec_client_version CCECClient::GetClientVersion(void)
1167 {
1168 CLockObject lock(m_mutex);
1169 return (cec_client_version)m_configuration.clientVersion;
1170 }
1171
1172 bool CCECClient::SetDeviceTypes(const cec_device_type_list &deviceTypes)
1173 {
1174 bool bNeedReinit(false);
1175
1176 {
1177 CLockObject lock(m_mutex);
1178 bNeedReinit = m_processor && m_processor->CECInitialised() &&
1179 (m_configuration.deviceTypes != deviceTypes);
1180 m_configuration.deviceTypes = deviceTypes;
1181 }
1182
1183 // persist the new configuration
1184 PersistConfiguration(m_configuration);
1185
1186 if (bNeedReinit)
1187 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - using primary device type '%s'", __FUNCTION__, ToString(deviceTypes[0]));
1188
1189 return bNeedReinit;
1190 }
1191
1192 cec_device_type_list CCECClient::GetDeviceTypes(void)
1193 {
1194 cec_device_type_list retVal;
1195 CLockObject lock(m_mutex);
1196 retVal = m_configuration.deviceTypes;
1197 return retVal;
1198 }
1199
1200 bool CCECClient::SetDevicePhysicalAddress(const uint16_t iPhysicalAddress)
1201 {
1202 if (!CLibCEC::IsValidPhysicalAddress(iPhysicalAddress))
1203 {
1204 LIB_CEC->AddLog(CEC_LOG_DEBUG, "%s - not setting invalid physical address %04x", __FUNCTION__, iPhysicalAddress);
1205 return false;
1206 }
1207
1208 // reconfigure all devices
1209 cec_logical_address reactivateSource(CECDEVICE_UNKNOWN);
1210 CECDEVICEVEC devices;
1211 m_processor->GetDevices()->GetByLogicalAddresses(devices, m_configuration.logicalAddresses);
1212 for (CECDEVICEVEC::iterator it = devices.begin(); it != devices.end(); it++)
1213 {
1214 // if this device was the active source, reactivate it afterwards
1215 if ((*it)->IsActiveSource())
1216 reactivateSource = (*it)->GetLogicalAddress();
1217
1218 // mark the device as inactive source
1219 if (IsInitialised())
1220 (*it)->MarkAsInactiveSource();
1221
1222 // set the new physical address
1223 (*it)->SetPhysicalAddress(iPhysicalAddress);
1224
1225 // and transmit it
1226 if (IsInitialised())
1227 (*it)->TransmitPhysicalAddress(false);
1228 }
1229
1230 // reactivate the previous active source
1231 if (reactivateSource != CECDEVICE_UNKNOWN &&
1232 m_processor->CECInitialised() &&
1233 IsInitialised())
1234 {
1235 CCECBusDevice *device = m_processor->GetDevice(reactivateSource);
1236 if (device)
1237 device->ActivateSource();
1238 }
1239
1240 // persist the new configuration
1241 PersistConfiguration(m_configuration);
1242
1243 return true;
1244 }
1245
1246 bool CCECClient::SwitchMonitoring(bool bEnable)
1247 {
1248 LIB_CEC->AddLog(CEC_LOG_NOTICE, "== %s monitoring mode ==", bEnable ? "enabling" : "disabling");
1249
1250 if (m_processor)
1251 {
1252 if (bEnable)
1253 return m_processor->UnregisterClient(this);
1254 else
1255 {
1256 m_configuration.bMonitorOnly = false;
1257 return m_processor->RegisterClient(this);
1258 }
1259 }
1260
1261 return false;
1262 }
1263
1264 bool CCECClient::PollDevice(const cec_logical_address iAddress)
1265 {
1266 // try to find the primary device
1267 CCECBusDevice *primary = GetPrimaryDevice();
1268 // poll the destination, with the primary as source
1269 if (primary)
1270 return primary->TransmitPoll(iAddress, false);
1271
1272 return m_processor ? m_processor->PollDevice(iAddress) : false;
1273 }
1274
1275 cec_logical_addresses CCECClient::GetActiveDevices(void)
1276 {
1277 CECDEVICEVEC activeDevices;
1278 if (m_processor)
1279 m_processor->GetDevices()->GetActive(activeDevices);
1280 return CCECDeviceMap::ToLogicalAddresses(activeDevices);
1281 }
1282
1283 bool CCECClient::IsActiveDevice(const cec_logical_address iAddress)
1284 {
1285 cec_logical_addresses activeDevices = GetActiveDevices();
1286 return activeDevices.IsSet(iAddress);
1287 }
1288
1289 bool CCECClient::IsActiveDeviceType(const cec_device_type type)
1290 {
1291 CECDEVICEVEC activeDevices;
1292 if (m_processor)
1293 m_processor->GetDevices()->GetActive(activeDevices);
1294 CCECDeviceMap::FilterType(type, activeDevices);
1295 return !activeDevices.empty();
1296 }
1297
1298 cec_logical_address CCECClient::GetActiveSource(void)
1299 {
1300 return m_processor ? m_processor->GetActiveSource() : CECDEVICE_UNKNOWN;
1301 }
1302
1303 bool CCECClient::IsActiveSource(const cec_logical_address iAddress)
1304 {
1305 return m_processor ? m_processor->IsActiveSource(iAddress) : false;
1306 }
1307
1308 bool CCECClient::SetStreamPath(const cec_logical_address iAddress)
1309 {
1310 uint16_t iPhysicalAddress = GetDevicePhysicalAddress(iAddress);
1311 if (iPhysicalAddress != CEC_INVALID_PHYSICAL_ADDRESS)
1312 return SetStreamPath(iPhysicalAddress);
1313 return false;
1314 }
1315
1316 bool CCECClient::SetStreamPath(const uint16_t iPhysicalAddress)
1317 {
1318 bool bReturn(false);
1319
1320 CCECBusDevice *device = GetDeviceByType(CEC_DEVICE_TYPE_TV);
1321 if (device)
1322 {
1323 device->SetStreamPath(iPhysicalAddress);
1324 bReturn = device->GetHandler()->TransmitSetStreamPath(iPhysicalAddress, false);
1325 device->MarkHandlerReady();
1326 }
1327 else
1328 {
1329 LIB_CEC->AddLog(CEC_LOG_ERROR, "only the TV is allowed to send CEC_OPCODE_SET_STREAM_PATH");
1330 }
1331
1332 return bReturn;
1333 }
1334
1335 cec_logical_addresses CCECClient::GetLogicalAddresses(void)
1336 {
1337 cec_logical_addresses addresses;
1338 CLockObject lock(m_mutex);
1339 addresses = m_configuration.logicalAddresses;
1340 return addresses;
1341 }
1342
1343 bool CCECClient::CanPersistConfiguration(void)
1344 {
1345 return m_processor ? m_processor->CanPersistConfiguration() : false;
1346 }
1347
1348 bool CCECClient::PersistConfiguration(const libcec_configuration &configuration)
1349 {
1350 return m_processor && IsRegistered() ?
1351 m_processor->PersistConfiguration(configuration) :
1352 false;
1353 }
1354
1355 void CCECClient::RescanActiveDevices(void)
1356 {
1357 if (m_processor)
1358 m_processor->RescanActiveDevices();
1359 }
1360
1361 bool CCECClient::IsLibCECActiveSource(void)
1362 {
1363 bool bReturn(false);
1364 if (m_processor)
1365 {
1366 cec_logical_address activeSource = m_processor->GetActiveSource();
1367 CCECBusDevice *device = m_processor->GetDevice(activeSource);
1368 if (device)
1369 bReturn = device->IsHandledByLibCEC();
1370 }
1371 return bReturn;
1372 }
1373
1374 void CCECClient::SourceActivated(const cec_logical_address logicalAddress)
1375 {
1376 LIB_CEC->AddLog(CEC_LOG_NOTICE, ">> source activated: %s (%x)", ToString(logicalAddress), logicalAddress);
1377 CallbackSourceActivated(true, logicalAddress);
1378 }
1379
1380 void CCECClient::SourceDeactivated(const cec_logical_address logicalAddress)
1381 {
1382 LIB_CEC->AddLog(CEC_LOG_NOTICE, ">> source deactivated: %s (%x)", ToString(logicalAddress), logicalAddress);
1383 CallbackSourceActivated(false, logicalAddress);
1384 }
1385
1386 void CCECClient::CallbackAddCommand(const cec_command &command)
1387 {
1388 {
1389 CLockObject lock(m_cbMutex);
1390 if (m_configuration.callbacks && m_configuration.callbacks->CBCecCommand)
1391 {
1392 m_configuration.callbacks->CBCecCommand(m_configuration.callbackParam, command);
1393 return;
1394 }
1395 }
1396 m_commandBuffer.Push(command);
1397 }
1398
1399 void CCECClient::CallbackAddKey(const cec_keypress &key)
1400 {
1401 {
1402 CLockObject lock(m_cbMutex);
1403 if (m_configuration.callbacks && m_configuration.callbacks->CBCecKeyPress)
1404 {
1405 m_configuration.callbacks->CBCecKeyPress(m_configuration.callbackParam, key);
1406 return;
1407 }
1408 }
1409 m_keyBuffer.Push(key);
1410 }
1411
1412 void CCECClient::CallbackAddLog(const cec_log_message &message)
1413 {
1414 {
1415 CLockObject lock(m_cbMutex);
1416 if (m_configuration.callbacks && m_configuration.callbacks->CBCecLogMessage)
1417 {
1418 m_configuration.callbacks->CBCecLogMessage(m_configuration.callbackParam, message);
1419 return;
1420 }
1421 }
1422 m_logBuffer.Push(message);
1423 }
1424
1425 void CCECClient::CallbackConfigurationChanged(const libcec_configuration &config)
1426 {
1427 CLockObject lock(m_cbMutex);
1428 if (m_configuration.callbacks &&
1429 m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_5_0 &&
1430 m_configuration.callbacks->CBCecConfigurationChanged &&
1431 m_processor->CECInitialised())
1432 m_configuration.callbacks->CBCecConfigurationChanged(m_configuration.callbackParam, config);
1433 }
1434
1435 void CCECClient::CallbackSourceActivated(bool bActivated, const cec_logical_address logicalAddress)
1436 {
1437 CLockObject lock(m_cbMutex);
1438 if (m_configuration.callbacks &&
1439 m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_7_1 &&
1440 m_configuration.callbacks->CBCecSourceActivated)
1441 m_configuration.callbacks->CBCecSourceActivated(m_configuration.callbackParam, logicalAddress, bActivated ? 1 : 0);
1442 }
1443
1444 void CCECClient::CallbackAlert(const libcec_alert type, const libcec_parameter &param)
1445 {
1446 CLockObject lock(m_cbMutex);
1447 if (m_configuration.callbacks &&
1448 m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_0 &&
1449 m_configuration.callbacks->CBCecAlert)
1450 m_configuration.callbacks->CBCecAlert(m_configuration.callbackParam, type, param);
1451 }
1452
1453 int CCECClient::CallbackMenuStateChanged(const cec_menu_state newState)
1454 {
1455 CLockObject lock(m_cbMutex);
1456 if (m_configuration.callbacks &&
1457 m_configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_2 &&
1458 m_configuration.callbacks->CBCecMenuStateChanged)
1459 return m_configuration.callbacks->CBCecMenuStateChanged(m_configuration.callbackParam, newState);
1460 return 0;
1461 }