public:
LibCecSharp(LibCECConfiguration ^config)
{
- m_configuration = config;
- m_configuration->SetCallbacks(this);
- if (!InitialiseLibCec())
+ m_callbacks = config->Callbacks;
+ CecCallbackMethods::EnableCallbacks(m_callbacks);
+ if (!InitialiseLibCec(config))
throw gcnew Exception("Could not initialise LibCecSharp");
}
LibCecSharp(String ^ strDeviceName, CecDeviceTypeList ^ deviceTypes)
{
- m_configuration = gcnew LibCECConfiguration();
- m_configuration->SetCallbacks(this);
- m_configuration->DeviceName = strDeviceName;
- m_configuration->DeviceTypes = deviceTypes;
- if (!InitialiseLibCec())
+ m_callbacks = gcnew CecCallbackMethods();
+ LibCECConfiguration ^config = gcnew LibCECConfiguration();
+ config->SetCallbacks(this);
+ config->DeviceName = strDeviceName;
+ config->DeviceTypes = deviceTypes;
+ if (!InitialiseLibCec(config))
throw gcnew Exception("Could not initialise LibCecSharp");
}
m_libCec = NULL;
}
- bool InitialiseLibCec(void)
+ bool InitialiseLibCec(LibCECConfiguration ^config)
{
marshal_context ^ context = gcnew marshal_context();
- libcec_configuration config;
- GetConfiguration(context, config);
+ libcec_configuration libCecConfig;
+ ConvertConfiguration(context, config, libCecConfig);
- m_libCec = (ICECAdapter *) CECInitialise(&config);
+ m_libCec = (ICECAdapter *) CECInitialise(&libCecConfig);
+ config->Update(libCecConfig);
delete context;
return m_libCec != NULL;
}
- void GetConfiguration(marshal_context ^context, libcec_configuration &config)
+ void ConvertConfiguration(marshal_context ^context, LibCECConfiguration ^netConfig, CEC::libcec_configuration &config)
{
config.Clear();
- _snprintf_s(config.strDeviceName, 13, context->marshal_as<const char*>(m_configuration->DeviceName));
+ const char *strDeviceName = context->marshal_as<const char*>(netConfig->DeviceName);
+ memcpy_s(config.strDeviceName, 13, strDeviceName, 13);
for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
- config.deviceTypes.types[iPtr] = (cec_device_type)m_configuration->DeviceTypes->Types[iPtr];
-
- config.iPhysicalAddress = m_configuration->PhysicalAddress;
- config.baseDevice = (cec_logical_address)m_configuration->BaseDevice;
- config.iHDMIPort = m_configuration->HDMIPort;
- config.clientVersion = (cec_client_version)m_configuration->ClientVersion;
- config.bGetSettingsFromROM = m_configuration->GetSettingsFromROM;
- config.bPowerOnStartup = m_configuration->PowerOnStartup;
- config.bPowerOffShutdown = m_configuration->PowerOffShutdown;
- config.bPowerOffScreensaver = m_configuration->PowerOffScreensaver;
- config.bPowerOffOnStandby = m_configuration->PowerOffOnStandby;
+ config.deviceTypes.types[iPtr] = (cec_device_type)netConfig->DeviceTypes->Types[iPtr];
+
+ config.bAutodetectAddress = netConfig->AutodetectAddress ? 1 : 0;
+ config.iPhysicalAddress = netConfig->PhysicalAddress;
+ config.baseDevice = (cec_logical_address)netConfig->BaseDevice;
+ config.iHDMIPort = netConfig->HDMIPort;
+ config.clientVersion = (cec_client_version)netConfig->ClientVersion;
+ config.bGetSettingsFromROM = netConfig->GetSettingsFromROM ? 1 : 0;
+ config.bActivateSource = netConfig->ActivateSource ? 1 : 0;
+ config.tvVendor = (cec_vendor_id)netConfig->TvVendor;
+ config.wakeDevices.Clear();
+ for (int iPtr = 0; iPtr < 16; iPtr++)
+ {
+ if (netConfig->WakeDevices->IsSet((CecLogicalAddress)iPtr))
+ config.wakeDevices.Set((cec_logical_address)iPtr);
+ }
+ config.powerOffDevices.Clear();
+ for (int iPtr = 0; iPtr < 16; iPtr++)
+ {
+ if (netConfig->PowerOffDevices->IsSet((CecLogicalAddress)iPtr))
+ config.powerOffDevices.Set((cec_logical_address)iPtr);
+ }
+ config.bPowerOffScreensaver = netConfig->PowerOffScreensaver ? 1 : 0;
+ config.bPowerOffOnStandby = netConfig->PowerOffOnStandby ? 1 : 0;
+
+ if (netConfig->ServerVersion >= CecServerVersion::Version1_5_1)
+ config.bSendInactiveSource = netConfig->SendInactiveSource ? 1 : 0;
+
+ if (netConfig->ServerVersion >= CecServerVersion::Version1_6_0)
+ {
+ config.bPowerOffDevicesOnStandby = netConfig->PowerOffDevicesOnStandby ? 1 : 0;
+ config.bShutdownOnStandby = netConfig->ShutdownOnStandby ? 1 : 0;
+ }
+
+ if (netConfig->ServerVersion >= CecServerVersion::Version1_6_2)
+ {
+ const char *strDeviceLanguage = context->marshal_as<const char*>(netConfig->DeviceLanguage);
+ memcpy_s(config.strDeviceLanguage, 3, strDeviceLanguage, 3);
+ }
+
+ if (netConfig->ServerVersion >= CecServerVersion::Version1_6_3)
+ config.bMonitorOnly = netConfig->MonitorOnlyClient ? 1 : 0;
+
config.callbacks = &g_cecCallbacks;
}
bool Open(String ^ strPort, int iTimeoutMs)
{
+ CecCallbackMethods::EnableCallbacks(m_callbacks);
+ EnableCallbacks(m_callbacks);
marshal_context ^ context = gcnew marshal_context();
const char* strPortC = context->marshal_as<const char*>(strPort);
bool bReturn = m_libCec->Open(strPortC, iTimeoutMs);
void Close(void)
{
+ DisableCallbacks();
m_libCec->Close();
}
+ virtual void DisableCallbacks(void) override
+ {
+ // delete the callbacks, since these might already have been destroyed in .NET
+ CecCallbackMethods::DisableCallbacks();
+ if (m_libCec)
+ m_libCec->EnableCallbacks(NULL, NULL);
+ }
+
virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks) override
{
if (m_libCec && CecCallbackMethods::EnableCallbacks(callbacks))
- return m_libCec->EnableCallbacks(NULL, &g_cecCallbacks);
+ return m_libCec->EnableCallbacks((void*)GetCallbackPtr(), &g_cecCallbacks);
return false;
}
cec_keypress key;
if (m_libCec->GetNextKeypress(&key))
{
- return gcnew CecKeypress(key.keycode, key.duration);
+ return gcnew CecKeypress((CecUserControlCode)key.keycode, key.duration);
}
return gcnew CecKeypress();
return m_libCec->SetLogicalAddress((cec_logical_address) logicalAddress);
}
- bool SetPhysicalAddress(int16_t physicalAddress)
+ bool SetPhysicalAddress(uint16_t physicalAddress)
{
return m_libCec->SetPhysicalAddress(physicalAddress);
}
return (CecPowerStatus) m_libCec->GetDevicePowerStatus((cec_logical_address) logicalAddress);
}
+ void RescanActiveDevices(void)
+ {
+ m_libCec->RescanActiveDevices();
+ }
+
CecLogicalAddresses ^ GetActiveDevices(void)
{
CecLogicalAddresses ^ retVal = gcnew CecLogicalAddresses();
return m_libCec->GetDevicePhysicalAddress((cec_logical_address)iAddress);
}
+ bool SetStreamPath(CecLogicalAddress iAddress)
+ {
+ return m_libCec->SetStreamPath((cec_logical_address)iAddress);
+ }
+
+ bool SetStreamPath(uint16_t iPhysicalAddress)
+ {
+ return m_libCec->SetStreamPath(iPhysicalAddress);
+ }
+
+ CecLogicalAddresses ^GetLogicalAddresses(void)
+ {
+ CecLogicalAddresses ^addr = gcnew CecLogicalAddresses();
+ cec_logical_addresses libAddr = m_libCec->GetLogicalAddresses();
+ for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
+ addr->Addresses[iPtr] = (CecLogicalAddress)libAddr.addresses[iPtr];
+ addr->Primary = (CecLogicalAddress)libAddr.primary;
+ return addr;
+ }
+
bool GetCurrentConfiguration(LibCECConfiguration ^configuration)
{
libcec_configuration config;
+ config.Clear();
+
if (m_libCec->GetCurrentConfiguration(&config))
{
- configuration->BaseDevice = (CecLogicalAddress)config.baseDevice;
- configuration->DeviceName = gcnew String(config.strDeviceName);
- configuration->HDMIPort = config.iHDMIPort;
- configuration->PhysicalAddress = config.iPhysicalAddress;
- configuration->PowerOffOnStandby = config.bPowerOffOnStandby == 1;
- configuration->PowerOffScreensaver = config.bPowerOffScreensaver == 1;
- configuration->PowerOffShutdown = config.bPowerOffShutdown == 1;
- configuration->PowerOnStartup = config.bPowerOnStartup == 1;
- configuration->UseTVMenuLanguage = config.bUseTVMenuLanguage == 1;
- for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
- m_configuration->DeviceTypes->Types[iPtr] = (CecDeviceType)config.deviceTypes.types[iPtr];
+ configuration->Update(config);
return true;
}
return false;
{
marshal_context ^ context = gcnew marshal_context();
libcec_configuration config;
- GetConfiguration(context, config);
+ ConvertConfiguration(context, configuration, config);
bool bReturn = m_libCec->PersistConfiguration(&config);
return bReturn;
}
+ bool SetConfiguration(LibCECConfiguration ^configuration)
+ {
+ marshal_context ^ context = gcnew marshal_context();
+ libcec_configuration config;
+ ConvertConfiguration(context, configuration, config);
+
+ bool bReturn = m_libCec->SetConfiguration(&config);
+
+ delete context;
+ return bReturn;
+ }
+
+ bool IsLibCECActiveSource()
+ {
+ return m_libCec->IsLibCECActiveSource();
+ }
+
+ bool GetDeviceInformation(String ^ port, LibCECConfiguration ^configuration, uint32_t timeoutMs)
+ {
+ bool bReturn(false);
+ marshal_context ^ context = gcnew marshal_context();
+
+ libcec_configuration config;
+ config.Clear();
+
+ const char* strPortC = port->Length > 0 ? context->marshal_as<const char*>(port) : NULL;
+
+ if (m_libCec->GetDeviceInformation(strPortC, &config, timeoutMs))
+ {
+ configuration->Update(config);
+ bReturn = true;
+ }
+
+ delete context;
+ return bReturn;
+ }
+
String ^ ToString(CecLogicalAddress iAddress)
{
const char *retVal = m_libCec->ToString((cec_logical_address)iAddress);
return gcnew String(retVal);
}
+ String ^ ToString(CecClientVersion version)
+ {
+ const char *retVal = m_libCec->ToString((cec_client_version)version);
+ return gcnew String(retVal);
+ }
+
+ String ^ ToString(CecServerVersion version)
+ {
+ const char *retVal = m_libCec->ToString((cec_server_version)version);
+ return gcnew String(retVal);
+ }
+
+ String ^ GetLibInfo()
+ {
+ const char *retVal = m_libCec->GetLibInfo();
+ return gcnew String(retVal);
+ }
+
private:
ICECAdapter * m_libCec;
- LibCECConfiguration ^m_configuration;
+ CecCallbackMethods ^ m_callbacks;
};
}
repositories / deb_libcec.git / blobdiff