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