if (bClose && m_communication)
{
- m_communication->PersistConfiguration(&m_configuration);
- m_communication->Close();
delete m_communication;
m_communication = NULL;
}
m_bConnectionOpened = (m_communication != NULL);
}
- /* check for an already opened connection */
- if (m_communication->IsOpen())
- {
- CLibCEC::AddLog(CEC_LOG_ERROR, "connection already opened");
- return bReturn;
- }
-
CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
/* open a new connection */
}
if (m_configuration.bGetSettingsFromROM == 1)
- m_communication->GetConfiguration(&m_configuration);
+ {
+ libcec_configuration config;
+ config.Clear();
+ m_communication->GetConfiguration(&config);
+
+ CLockObject lock(m_mutex);
+ if (!config.deviceTypes.IsEmpty())
+ m_configuration.deviceTypes = config.deviceTypes;
+ if (config.iPhysicalAddress > 0)
+ m_configuration.iPhysicalAddress = config.iPhysicalAddress;
+ snprintf(m_configuration.strDeviceName, 13, "%s", config.strDeviceName);
+ }
return bReturn;
}
SetActiveView();
if (bReturn)
- CLibCEC::ConfigurationChanged(m_configuration);
+ {
+ libcec_configuration config;
+ {
+ CLockObject lock(m_mutex);
+ config = m_configuration;
+ }
+
+ PersistConfiguration(&config);
+ CLibCEC::ConfigurationChanged(config);
+ }
return bReturn;
}
CCECBusDevice *primary = IsRunning() ? GetPrimaryDevice() : NULL;
cec_device_type oldPrimaryType = primary ? primary->GetType() : CEC_DEVICE_TYPE_RECORDING_DEVICE;
m_configuration.clientVersion = configuration->clientVersion;
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using client version '%s'", __FUNCTION__, ToString((cec_client_version)configuration->clientVersion));
// client version 1.5.0
// device types
bool bDeviceTypeChanged = IsRunning () && m_configuration.deviceTypes != configuration->deviceTypes;
m_configuration.deviceTypes = configuration->deviceTypes;
+ if (bDeviceTypeChanged)
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using primary device type '%s'", __FUNCTION__, ToString(configuration->deviceTypes[0]));
bool bPhysicalAddressChanged(false);
{
if (IsRunning())
CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - autodetected physical address '%4x'", __FUNCTION__, iPhysicalAddress);
+ else
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using physical address '%x'", __FUNCTION__, iPhysicalAddress);
bPhysicalAddressChanged = (m_configuration.iPhysicalAddress != iPhysicalAddress);
m_configuration.iPhysicalAddress = iPhysicalAddress;
m_configuration.iHDMIPort = 0;
bPhysicalAddressChanged = IsRunning() && m_configuration.iPhysicalAddress != configuration->iPhysicalAddress;
if (bPhysicalAddressChanged)
{
- if (IsRunning())
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using physical address '%4x'", __FUNCTION__, configuration->iPhysicalAddress);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - physical address '%x'", __FUNCTION__, configuration->iPhysicalAddress);
m_configuration.iPhysicalAddress = configuration->iPhysicalAddress;
}
}
{
// base device
bHdmiPortChanged = IsRunning() && m_configuration.baseDevice != configuration->baseDevice;
- if (IsRunning())
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using base device '%x'", __FUNCTION__, (int)configuration->baseDevice);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using base device '%x'", __FUNCTION__, (int)configuration->baseDevice);
m_configuration.baseDevice = configuration->baseDevice;
// hdmi port
bHdmiPortChanged |= IsRunning() && m_configuration.iHDMIPort != configuration->iHDMIPort;
- if (IsRunning())
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using HDMI port '%d'", __FUNCTION__, configuration->iHDMIPort);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using HDMI port '%d'", __FUNCTION__, configuration->iHDMIPort);
m_configuration.iHDMIPort = configuration->iHDMIPort;
}
else
{
- if (IsRunning())
- CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - resetting HDMI port and base device to defaults", __FUNCTION__);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - resetting HDMI port and base device to defaults", __FUNCTION__);
m_configuration.baseDevice = CECDEVICE_UNKNOWN;
m_configuration.iHDMIPort = 0;
}
bReinit = bPhysicalAddressChanged || bHdmiPortChanged || bDeviceTypeChanged;
// device name
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - using OSD name '%s'", __FUNCTION__, configuration->strDeviceName);
snprintf(m_configuration.strDeviceName, 13, "%s", configuration->strDeviceName);
if (primary && !primary->GetOSDName().Equals(m_configuration.strDeviceName))
{
}
// tv vendor id override
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "%s - vendor id '%s'", __FUNCTION__, ToString((cec_vendor_id)configuration->tvVendor));
if (m_configuration.tvVendor != configuration->tvVendor)
{
m_configuration.tvVendor= configuration->tvVendor;
}
// just copy these
- m_configuration.clientVersion = configuration->clientVersion;
m_configuration.bUseTVMenuLanguage = configuration->bUseTVMenuLanguage;
m_configuration.bActivateSource = configuration->bActivateSource;
m_configuration.bGetSettingsFromROM = configuration->bGetSettingsFromROM;
if (m_configuration.deviceTypes.IsEmpty())
m_configuration.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
+ // persist the configuration
+ if (IsRunning())
+ m_communication->PersistConfiguration(&m_configuration);
+
if (bReinit)
{
if (bDeviceTypeChanged)
using namespace CEC;
using namespace PLATFORM;
+CUSBCECAdapterCommands::CUSBCECAdapterCommands(CUSBCECAdapterCommunication *comm) :
+ m_comm(comm),
+ m_bSettingsRetrieved(false),
+ m_bSettingAutoEnabled(false),
+ m_settingCecVersion(CEC_VERSION_UNKNOWN),
+ m_iSettingLAMask(0),
+ m_bNeedsWrite(false)
+{
+ m_persistedConfiguration.Clear();
+}
+
cec_datapacket CUSBCECAdapterCommands::RequestSetting(cec_adapter_messagecode msgCode)
{
cec_datapacket retVal;
uint16_t CUSBCECAdapterCommands::RequestFirmwareVersion(void)
{
- m_iFirmwareVersion = CEC_FW_VERSION_UNKNOWN;
+ m_persistedConfiguration.iFirmwareVersion = CEC_FW_VERSION_UNKNOWN;
unsigned int iFwVersionTry(0);
- while (m_iFirmwareVersion == CEC_FW_VERSION_UNKNOWN && iFwVersionTry++ < 3)
+ while (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN && iFwVersionTry++ < 3)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting the firmware version");
cec_datapacket response = RequestSetting(MSGCODE_FIRMWARE_VERSION);
if (response.size == 2)
- m_iFirmwareVersion = (response[0] << 8 | response[1]);
+ m_persistedConfiguration.iFirmwareVersion = (response[0] << 8 | response[1]);
else
{
CLibCEC::AddLog(CEC_LOG_WARNING, "the adapter did not respond with a correct firmware version (try %d)", iFwVersionTry);
}
}
- if (m_iFirmwareVersion == CEC_FW_VERSION_UNKNOWN)
+ if (m_persistedConfiguration.iFirmwareVersion == CEC_FW_VERSION_UNKNOWN)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "defaulting to firmware version 1");
- m_iFirmwareVersion = 1;
+ m_persistedConfiguration.iFirmwareVersion = 1;
}
- return m_iFirmwareVersion;
+ return m_persistedConfiguration.iFirmwareVersion;
}
-bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(bool &enabled)
+bool CUSBCECAdapterCommands::RequestSettingAutoEnabled(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting autonomous mode setting");
cec_datapacket response = RequestSetting(MSGCODE_GET_AUTO_ENABLED);
if (response.size == 1)
{
- enabled = response[0] == 1;
+ m_bSettingAutoEnabled = response[0] == 1;
return true;
}
return false;
}
-bool CUSBCECAdapterCommands::RequestSettingCECVersion(cec_version &version)
+bool CUSBCECAdapterCommands::RequestSettingCECVersion(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting CEC version setting");
cec_datapacket response = RequestSetting(MSGCODE_GET_HDMI_VERSION);
if (response.size == 1)
{
- version = (cec_version)response[0];
+ m_settingCecVersion = (cec_version)response[0];
return true;
}
return false;
}
-bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(cec_logical_address &address)
+bool CUSBCECAdapterCommands::RequestSettingDefaultLogicalAddress(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting default logical address setting");
cec_datapacket response = RequestSetting(MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS);
if (response.size == 1)
{
- address = (cec_logical_address)response[0];
+ m_persistedConfiguration.logicalAddresses.primary = (cec_logical_address)response[0];
return true;
}
return false;
}
-bool CUSBCECAdapterCommands::RequestSettingDeviceType(cec_device_type &value)
+bool CUSBCECAdapterCommands::RequestSettingDeviceType(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting device type setting");
+ m_persistedConfiguration.deviceTypes.Clear();
cec_datapacket response = RequestSetting(MSGCODE_GET_DEVICE_TYPE);
if (response.size == 1)
{
- value = (cec_device_type)response[0];
+ m_persistedConfiguration.deviceTypes.Add((cec_device_type)response[0]);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device type setting %s", CLibCEC::GetInstance()->ToString((cec_device_type)response[0]));
return true;
}
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device type setting");
return false;
}
-bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(uint16_t &iMask)
+bool CUSBCECAdapterCommands::RequestSettingLogicalAddressMask(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting logical address mask setting");
cec_datapacket response = RequestSetting(MSGCODE_GET_LOGICAL_ADDRESS_MASK);
if (response.size == 2)
{
- iMask = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
+ m_iSettingLAMask = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
return true;
}
return false;
}
-bool CUSBCECAdapterCommands::RequestSettingOSDName(CStdString &strOSDName)
+bool CUSBCECAdapterCommands::RequestSettingOSDName(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting OSD name setting");
+ memset(m_persistedConfiguration.strDeviceName, 0, 13);
cec_datapacket response = RequestSetting(MSGCODE_GET_OSD_NAME);
if (response.size == 0)
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device name setting");
return false;
+ }
char buf[14];
for (uint8_t iPtr = 0; iPtr < response.size && iPtr < 13; iPtr++)
buf[iPtr] = (char)response[iPtr];
buf[response.size] = 0;
- strOSDName.Format("%s", buf);
+ snprintf(m_persistedConfiguration.strDeviceName, 13, "%s", buf);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device name setting %s", buf);
return true;
}
-bool CUSBCECAdapterCommands::RequestSettingPhysicalAddress(uint16_t &iPhysicalAddress)
+bool CUSBCECAdapterCommands::RequestSettingPhysicalAddress(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "requesting physical address setting");
cec_datapacket response = RequestSetting(MSGCODE_GET_PHYSICAL_ADDRESS);
if (response.size == 2)
{
- iPhysicalAddress = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
+ m_persistedConfiguration.iPhysicalAddress = ((uint16_t)response[0] << 8) | ((uint16_t)response[1]);
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted physical address setting %4x", m_persistedConfiguration.iPhysicalAddress);
return true;
}
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted physical address setting");
return false;
}
bool CUSBCECAdapterCommands::SetSettingAutoEnabled(bool enabled)
{
+ bool bReturn(true);
+
+ /* check whether this value was changed */
+ if (m_bSettingAutoEnabled == enabled)
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "autonomous mode setting unchanged (%s)", enabled ? "on" : "off");
+ return bReturn;
+ }
+
+ m_bNeedsWrite = true;
CLibCEC::AddLog(CEC_LOG_DEBUG, "turning autonomous mode %s", enabled ? "on" : "off");
CCECAdapterMessage params;
params.PushEscaped(enabled ? 1 : 0);
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_AUTO_ENABLED, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
+ if (bReturn)
+ m_bSettingAutoEnabled = enabled;
+
return bReturn;
}
bool CUSBCECAdapterCommands::SetSettingDeviceType(cec_device_type type)
{
- CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the device type to %1X", (uint8_t)type);
+ bool bReturn(true);
+
+ /* check whether this value was changed */
+ if (m_persistedConfiguration.deviceTypes.types[0] == type)
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "device type setting unchanged (%X)", (uint8_t)type);
+ return bReturn;
+ }
+
+ m_bNeedsWrite = true;
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the device type to %X", (uint8_t)type);
CCECAdapterMessage params;
params.PushEscaped((uint8_t)type);
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEVICE_TYPE, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
return bReturn;
}
bool CUSBCECAdapterCommands::SetSettingDefaultLogicalAddress(cec_logical_address address)
{
- CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the default logical address to %1X", address);
+ bool bReturn(true);
+
+ /* check whether this value was changed */
+ if (m_persistedConfiguration.logicalAddresses.primary == address)
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "logical address setting unchanged (%X)", (uint8_t)address);
+ return bReturn;
+ }
+
+ m_bNeedsWrite = true;
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the default logical address to %X", (uint8_t)address);
CCECAdapterMessage params;
params.PushEscaped((uint8_t)address);
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
+ if (bReturn)
+ m_persistedConfiguration.logicalAddresses.primary = address;
+
return bReturn;
}
bool CUSBCECAdapterCommands::SetSettingLogicalAddressMask(uint16_t iMask)
{
+ bool bReturn(true);
+
+ /* check whether this value was changed */
+ if (m_iSettingLAMask == iMask)
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "logical address mask setting unchanged (%2X)", iMask);
+ return bReturn;
+ }
+
+ m_bNeedsWrite = true;
CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the logical address mask to %2X", iMask);
CCECAdapterMessage params;
params.PushEscaped(iMask >> 8);
params.PushEscaped((uint8_t)iMask);
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_LOGICAL_ADDRESS_MASK, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
+ if (bReturn)
+ m_iSettingLAMask = iMask;
+
return bReturn;
}
bool CUSBCECAdapterCommands::SetSettingPhysicalAddress(uint16_t iPhysicalAddress)
{
+ bool bReturn(true);
+
+ /* check whether this value was changed */
+ if (m_persistedConfiguration.iPhysicalAddress == iPhysicalAddress)
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "logical address mask setting unchanged (%04X)", iPhysicalAddress);
+ return bReturn;
+ }
+
+ m_bNeedsWrite = true;
CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the physical address to %04X", iPhysicalAddress);
CCECAdapterMessage params;
params.PushEscaped(iPhysicalAddress >> 8);
params.PushEscaped((uint8_t)iPhysicalAddress);
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_PHYSICAL_ADDRESS, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
+ if (bReturn)
+ m_persistedConfiguration.iPhysicalAddress = iPhysicalAddress;
+
return bReturn;
}
bool CUSBCECAdapterCommands::SetSettingCECVersion(cec_version version)
{
+ bool bReturn(true);
+
+ /* check whether this value was changed */
+ if (m_settingCecVersion == version)
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "CEC version setting unchanged (%s)", CLibCEC::GetInstance()->ToString(version));
+ return bReturn;
+ }
+
+ m_bNeedsWrite = true;
CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the CEC version to %s", CLibCEC::GetInstance()->ToString(version));
CCECAdapterMessage params;
params.PushEscaped((uint8_t)version);
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_HDMI_VERSION, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
+ if (bReturn)
+ m_settingCecVersion = version;
+
return bReturn;
}
bool CUSBCECAdapterCommands::SetSettingOSDName(const char *strOSDName)
{
+ bool bReturn(true);
+
+ /* check whether this value was changed */
+ if (!strcmp(m_persistedConfiguration.strDeviceName, strOSDName))
+ {
+ CLibCEC::AddLog(CEC_LOG_DEBUG, "OSD name setting unchanged (%s)", strOSDName);
+ return bReturn;
+ }
+
CLibCEC::AddLog(CEC_LOG_DEBUG, "setting the OSD name to %s", strOSDName);
CCECAdapterMessage params;
for (size_t iPtr = 0; iPtr < strlen(strOSDName); iPtr++)
params.PushEscaped(strOSDName[iPtr]);
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_SET_OSD_NAME, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
delete message;
+
+ if (bReturn)
+ snprintf(m_persistedConfiguration.strDeviceName, 13, "%s", strOSDName);
+
return bReturn;
}
bool CUSBCECAdapterCommands::WriteEEPROM(void)
{
+ if (!m_bNeedsWrite)
+ return true;
+
CLibCEC::AddLog(CEC_LOG_DEBUG, "writing settings in the EEPROM");
CCECAdapterMessage params;
CCECAdapterMessage *message = m_comm->SendCommand(MSGCODE_WRITE_EEPROM, params);
- bool bReturn = message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED;
+ m_bNeedsWrite = !(message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED);
delete message;
- return bReturn;
+ return m_bNeedsWrite;
}
bool CUSBCECAdapterCommands::PersistConfiguration(libcec_configuration *configuration)
{
- if (m_iFirmwareVersion < 2)
+ if (m_persistedConfiguration.iFirmwareVersion < 2)
+ return false;
+
+ if (!RequestSettings())
return false;
bool bReturn(true);
bReturn &= SetSettingPhysicalAddress(configuration->iPhysicalAddress);
bReturn &= SetSettingCECVersion(CEC_VERSION_1_3A);
bReturn &= SetSettingOSDName(configuration->strDeviceName);
- if (bReturn)
- bReturn = WriteEEPROM();
+ bReturn &= WriteEEPROM();
return bReturn;
}
-bool CUSBCECAdapterCommands::GetConfiguration(libcec_configuration *configuration)
+bool CUSBCECAdapterCommands::RequestSettings(void)
{
- configuration->iFirmwareVersion = m_iFirmwareVersion;
- if (m_iFirmwareVersion < 2)
- return false;
-
- bool bReturn(true);
- cec_device_type type;
- if (RequestSettingDeviceType(type))
- {
- CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device type setting %s", CLibCEC::GetInstance()->ToString(type));
- configuration->deviceTypes.Clear();
- configuration->deviceTypes.Add(type);
- }
- else
+ if (m_persistedConfiguration.iFirmwareVersion < 2)
{
- CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device type setting");
- bReturn = false;
+ // settings can only be persisted with firmware v2+
+ return false;
}
- if (RequestSettingPhysicalAddress(configuration->iPhysicalAddress))
- {
- CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted physical address setting %4x", configuration->iPhysicalAddress);
- }
- else
- {
- CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted physical address setting");
- bReturn = false;
- }
+ if (!m_bSettingsRetrieved)
+ return true;
- CStdString strDeviceName;
- if (RequestSettingOSDName(strDeviceName))
- {
- snprintf(configuration->strDeviceName, 13, "%s", strDeviceName.c_str());
- CLibCEC::AddLog(CEC_LOG_DEBUG, "using persisted device name setting %s", configuration->strDeviceName);
- }
- else
- {
- CLibCEC::AddLog(CEC_LOG_DEBUG, "no persisted device name setting");
- bReturn = false;
- }
+ bool bReturn(true);
+ bReturn &= RequestSettingAutoEnabled();
+ bReturn &= RequestSettingCECVersion();
+ bReturn &= RequestSettingDefaultLogicalAddress();
+ bReturn &= RequestSettingDeviceType();
+ bReturn &= RequestSettingLogicalAddressMask();
+ bReturn &= RequestSettingOSDName();
+ bReturn &= RequestSettingPhysicalAddress();
// don't read the following settings:
// - auto enabled (always enabled)
// - power off screensaver (1 bit)
// - power off on standby (1 bit)
// - send inactive source (1 bit)
+
+ m_bSettingsRetrieved = true;
+
return bReturn;
}
+bool CUSBCECAdapterCommands::GetConfiguration(libcec_configuration *configuration)
+{
+ // get the settings from the eeprom if needed
+ if (!RequestSettings())
+ return false;
+
+ // copy the settings
+ configuration->iFirmwareVersion = m_persistedConfiguration.iFirmwareVersion;
+ configuration->deviceTypes = m_persistedConfiguration.deviceTypes;
+ configuration->iPhysicalAddress = m_persistedConfiguration.iPhysicalAddress;
+ snprintf(configuration->strDeviceName, 13, "%s", m_persistedConfiguration.strDeviceName);
+
+ return true;
+}
+
bool CUSBCECAdapterCommands::PingAdapter(void)
{
CLibCEC::AddLog(CEC_LOG_DEBUG, "sending ping");
class CUSBCECAdapterCommands
{
public:
- CUSBCECAdapterCommands(CUSBCECAdapterCommunication *comm) :
- m_comm(comm),
- m_iFirmwareVersion(CEC_FW_VERSION_UNKNOWN) {}
+ CUSBCECAdapterCommands(CUSBCECAdapterCommunication *comm);
/*!
* @brief Request the firmware version from the adapter.
*/
uint16_t RequestFirmwareVersion(void);
+ /*!
+ * @return The firmware version of the adapter, retrieved when the connection is opened.
+ */
+ uint16_t GetFirmwareVersion(void) const { return m_persistedConfiguration.iFirmwareVersion; };
+
+ /*!
+ * @brief Persist the current configuration in the EEPROM.
+ * @attention Not all settings are persisted at this time.
+ * @param configuration The configuration to persist.
+ * @return True when persisted, false otherwise.
+ */
+ bool PersistConfiguration(libcec_configuration *configuration);
+
+ /*!
+ * @brief Get the persisted configuration from the EEPROM.
+ * @param configuration The persisted configuration.
+ * @return True when retrieved, false otherwise.
+ */
+ bool GetConfiguration(libcec_configuration *configuration);
+
+ /*!
+ * @brief Send a ping command to the adapter.
+ * @return True when acked by the adapter, false otherwise.
+ */
+ bool PingAdapter(void);
+
+ /*!
+ * @brief Change the ackmask of the adapter.
+ * @param iMask The new mask.
+ * @return True when the change was acked by the adapter, false otherwise.
+ */
+ bool SetAckMask(uint16_t iMask);
+
+ /*!
+ * @brief Put the adapter in bootloader mode.
+ * @attention The connection needs to be closed after this call, since the adapter will no longer be available.
+ * @return True when the command was sent, false otherwise.
+ */
+ bool StartBootloader(void);
+
+ /*!
+ * @brief Change the current CEC line timeout.
+ * @param iTimeout The new timeout.
+ * @return True when the change was acked by the adapter, false otherwise.
+ */
+ bool SetLineTimeout(uint8_t iTimeout);
+
+ /*!
+ * @brief Put the adapter in controlled or autonomous mode.
+ * @param controlled True to switch to controlled mode, false to switch to auto mode.
+ * @return True when acked by the controller, false otherwise.
+ */
+ bool SetControlledMode(bool controlled);
+
+ private:
+ /*!
+ * @brief Reads all settings from the eeprom.
+ * @return True when read, false otherwise.
+ */
+ bool RequestSettings(void);
+
/*!
* @brief Request a setting value from the adapter.
* @param msgCode The setting to retrieve.
/*!
* @brief Request the value of the "auto enabled" setting from the adapter.
- * @param enabled The current value.
* @return True when retrieved, false otherwise.
*/
- bool RequestSettingAutoEnabled(bool &enabled);
+ bool RequestSettingAutoEnabled(void);
/*!
* @brief Change the value of the "device type" setting, used when the device is in autonomous mode.
/*!
* @brief Request the value of the "device type" setting from the adapter.
- * @param type The current value.
* @return True when retrieved, false otherwise.
*/
- bool RequestSettingDeviceType(cec_device_type &type);
+ bool RequestSettingDeviceType(void);
/*!
* @brief Change the value of the "default logical address" setting, used when the device is in autonomous mode.
/*!
* @brief Request the value of the "default logical address" setting from the adapter.
- * @param address The current value.
* @return True when retrieved, false otherwise.
*/
- bool RequestSettingDefaultLogicalAddress(cec_logical_address &address);
+ bool RequestSettingDefaultLogicalAddress(void);
/*!
* @brief Change the value of the "logical address mask" setting, used when the device is in autonomous mode.
/*!
* @brief Request the value of the "logical address mask" setting from the adapter.
- * @param iMask The current value.
* @return True when retrieved, false otherwise.
*/
- bool RequestSettingLogicalAddressMask(uint16_t &iMask);
+ bool RequestSettingLogicalAddressMask(void);
/*!
* @brief Change the value of the "physical address" setting, used when the device is in autonomous mode.
/*!
* @brief Request the value of the "physical address" setting from the adapter.
- * @param iPhysicalAddress The current value.
* @return True when retrieved, false otherwise.
*/
- bool RequestSettingPhysicalAddress(uint16_t &iPhysicalAddress);
+ bool RequestSettingPhysicalAddress(void);
/*!
* @brief Change the value of the "CEC version" setting, used when the device is in autonomous mode.
/*!
* @brief Request the value of the "CEC version" setting from the adapter.
- * @param version The current value.
* @return True when retrieved, false otherwise.
*/
- bool RequestSettingCECVersion(cec_version &version);
+ bool RequestSettingCECVersion(void);
/*!
* @brief Change the value of the "OSD name" setting, used when the device is in autonomous mode.
/*!
* @brief Request the value of the "OSD name" setting from the adapter.
- * @param strOSDName The current value.
* @return True when retrieved, false otherwise.
*/
- bool RequestSettingOSDName(CStdString &strOSDName);
+ bool RequestSettingOSDName(void);
/*!
* @brief Persist the current settings in the EEPROM
*/
bool WriteEEPROM(void);
- /*!
- * @return The firmware version of the adapter, retrieved when the connection is opened.
- */
- uint16_t GetFirmwareVersion(void) const { return m_iFirmwareVersion; };
-
- /*!
- * @brief Persist the current configuration in the EEPROM.
- * @attention Not all settings are persisted at this time.
- * @param configuration The configuration to persist.
- * @return True when persisted, false otherwise.
- */
- bool PersistConfiguration(libcec_configuration *configuration);
-
- /*!
- * @brief Get the persisted configuration from the EEPROM.
- * @param configuration The persisted configuration.
- * @return True when retrieved, false otherwise.
- */
- bool GetConfiguration(libcec_configuration *configuration);
-
- /*!
- * @brief Send a ping command to the adapter.
- * @return True when acked by the adapter, false otherwise.
- */
- bool PingAdapter(void);
-
- /*!
- * @brief Change the ackmask of the adapter.
- * @param iMask The new mask.
- * @return True when the change was acked by the adapter, false otherwise.
- */
- bool SetAckMask(uint16_t iMask);
-
- /*!
- * @brief Put the adapter in bootloader mode.
- * @attention The connection needs to be closed after this call, since the adapter will no longer be available.
- * @return True when the command was sent, false otherwise.
- */
- bool StartBootloader(void);
-
- /*!
- * @brief Change the current CEC line timeout.
- * @param iTimeout The new timeout.
- * @return True when the change was acked by the adapter, false otherwise.
- */
- bool SetLineTimeout(uint8_t iTimeout);
-
- /*!
- * @brief Put the adapter in controlled or autonomous mode.
- * @param controlled True to switch to controlled mode, false to switch to auto mode.
- * @return True when acked by the controller, false otherwise.
- */
- bool SetControlledMode(bool controlled);
-
- private:
- CUSBCECAdapterCommunication *m_comm; /**< the communication handler */
- uint16_t m_iFirmwareVersion; /**< the firwmare version that was retrieved while opening the connection */
+ CUSBCECAdapterCommunication *m_comm; /**< the communication handler */
+ bool m_bSettingsRetrieved; /**< true when the settings were read from the eeprom, false otherwise */
+ bool m_bSettingAutoEnabled; /**< the value of the auto-enabled setting */
+ cec_version m_settingCecVersion; /**< the value of the cec version setting */
+ uint16_t m_iSettingLAMask; /**< the value of the LA mask setting */
+ bool m_bNeedsWrite; /**< true when we sent changed settings to the adapter that have not been persisted */
+ libcec_configuration m_persistedConfiguration; /**< the configuration that is persisted in the eeprom */
};
}
repositories / deb_libcec.git / commitdiff
