HDiscoveryType::HDiscoveryType(const HResourceType& resourceType) :
h_ptr(new HDiscoveryTypePrivate())
{
if (h_ptr->parse(resourceType))
{
h_ptr->m_contents = resourceType.toString();
h_ptr->m_type = resourceType.isDeviceType() ?
HDiscoveryType::DeviceType :
HDiscoveryType::ServiceType;
}
}
bool HDeviceInfoPrivate::setDeviceType(const HResourceType& deviceType)
{
if (!deviceType.isValid())
{
return false;
}
if (deviceType.type() != HResourceType::StandardDeviceType &&
deviceType.type() != HResourceType::VendorSpecifiedDeviceType)
{
return false;
}
m_deviceType = deviceType;
return true;
}
HDiscoveryType::HDiscoveryType(
const HUdn& udn, const HResourceType& resourceType,
HValidityCheckLevel checkLevel) :
h_ptr(new HDiscoveryTypePrivate())
{
if (h_ptr->parse(resourceType) && udn.isValid(checkLevel))
{
h_ptr->m_udn = udn;
h_ptr->m_contents =
QString("%1::%2").arg(udn.toString(), resourceType.toString());
h_ptr->m_type = resourceType.isDeviceType() ?
HDiscoveryType::SpecificDeviceWithType :
HDiscoveryType::SpecificServiceWithType;
}
}
/*******************************************************************************
* HClientServiceAdapter
******************************************************************************/
HClientServiceAdapter::HClientServiceAdapter(
const HResourceType& serviceType, QObject* parent) :
QObject(parent),
h_ptr(new HClientServiceAdapterPrivate(serviceType))
{
h_ptr->q_ptr = this;
Q_ASSERT(serviceType.isValid());
}
bool HClientServiceAdapter::setService(
HClientService* service, ValidationType vt)
{
HResourceType st = service->info().serviceType();
if (!service || !st.compare(serviceType(), HResourceType::Inclusive))
{
setLastErrorDescription(QString("Unsupported service type: [%1]").arg(st.toString()));
return false;
}
if (vt == FullValidation)
{
if (deviceModelInfoProvider())
{
if (!h_ptr->validate(service))
{
return false;
}
}
}
if (!prepareService(service))
{
return false;
}
h_ptr->m_service = service;
if (deviceModelInfoProvider())
{
HActionsSetupData actionsSetupData =
deviceModelInfoProvider()->actionsSetupData(
service->info(), service->parentDevice()->info());
if (!actionsSetupData.isEmpty())
{
h_ptr->m_actionsSetupData.reset(
new HActionsSetupData(actionsSetupData));
}
}
return true;
}
bool parse(const HResourceType& rt)
{
if (!rt.isValid())
{
return false;
}
m_resourceType = rt;
return true;
}
HServiceInfo::HServiceInfo(
const HServiceId& serviceId,
const HResourceType& serviceType,
const QUrl& controlUrl,
const QUrl& eventSubUrl,
const QUrl& scpdUrl,
HInclusionRequirement inclusionRequirement,
HValidityCheckLevel checkLevel,
QString* err) :
h_ptr(new HServiceInfoPrivate())
{
QString errTmp;
if (!serviceId.isValid(checkLevel))
{
errTmp = "Invalid service ID";
}
else if (!serviceType.isValid())
{
errTmp = "Invalid service type";
}
else if (controlUrl.isEmpty() || !controlUrl.isValid())
{
errTmp = "Invalid control URL";
}
else if (eventSubUrl.isEmpty() || !eventSubUrl.isValid())
{
errTmp = "Invalid event sub URL";
}
else if (scpdUrl.isEmpty() || !scpdUrl.isValid())
{
errTmp = "Invalid SCPD URL";
}
else
{
h_ptr->m_controlUrl = controlUrl;
h_ptr->m_eventSubUrl = eventSubUrl;
h_ptr->m_scpdUrl = scpdUrl;
h_ptr->m_serviceId = serviceId;
h_ptr->m_serviceType = serviceType;
h_ptr->m_inclusionRequirement = inclusionRequirement;
}
if (err && !errTmp.isEmpty())
{
*err = errTmp;
}
}
HDeviceInfo::HDeviceInfo(
const HResourceType& deviceType,
const QString& friendlyName,
const QString& manufacturer,
const QString& modelName,
const HUdn& udn,
HValidityCheckLevel checkLevel,
QString* err) :
h_ptr(new HDeviceInfoPrivate())
{
QScopedPointer<HDeviceInfoPrivate> tmp(new HDeviceInfoPrivate());
QString errTmp;
if (!tmp->setDeviceType(deviceType))
{
errTmp = QString("Invalid device type: [%1]").arg(deviceType.toString());
}
else if (!tmp->setFriendlyName(friendlyName))
{
errTmp = QString("Invalid friendly name: [%1]").arg(friendlyName);
}
else if (!tmp->setManufacturer(manufacturer))
{
errTmp = QString("Invalid manufacturer: [%1]").arg(manufacturer);
}
else if (!tmp->setModelName(modelName))
{
errTmp = QString("Invalid model name: [%1]").arg(modelName);
}
else if (!tmp->setUdn(udn, checkLevel))
{
errTmp = QString("Invalid UDN: [%1]").arg(udn.toString());
}
if (!errTmp.isEmpty())
{
if (err)
{
*err = errTmp;
}
}
else
{
h_ptr = tmp.take();
}
}
HClientAdapterOp<QStringList> HRenderingControlAdapter::setStateVariables(
const HUdn& renderingControlUdn,
const HResourceType& serviceType, const HServiceId& serviceId,
const QString& stateVariableValuePairs)
{
qint32 rc = UpnpUndefinedFailure;
HClientAction* action = h_ptr->getAction("SetStateVariables", &rc);
if (!action)
{
return HClientAdapterOp<QStringList>::createInvalid(rc, "");
}
H_D(HRenderingControlAdapter);
HActionArguments inArgs = action->info().inputArguments();
inArgs.setValue("InstanceID", h->m_instanceId);
inArgs.setValue("RenderingControlUDN", renderingControlUdn.toString());
inArgs.setValue("ServiceType", serviceType.toString());
inArgs.setValue("ServiceId", serviceId.toString());
inArgs.setValue("StateVariableValuePairs", stateVariableValuePairs);
return h_ptr->beginInvoke<QStringList>(
action, inArgs,
HActionInvokeCallback(h, &HRenderingControlAdapterPrivate::setStateVariables));
}
HDeviceInfo::HDeviceInfo(
const HResourceType& deviceType,
const QString& friendlyName,
const QString& manufacturer,
const QUrl& manufacturerUrl,
const QString& modelDescription,
const QString& modelName,
const QString& modelNumber,
const QUrl& modelUrl,
const QString& serialNumber,
const HUdn& udn,
const QString& upc,
const QList<QUrl>& icons,
const QUrl& presentationUrl,
HValidityCheckLevel checkLevel,
QString* err) :
h_ptr(new HDeviceInfoPrivate())
{
QScopedPointer<HDeviceInfoPrivate> tmp(new HDeviceInfoPrivate());
QString errTmp;
if (!tmp->setDeviceType(deviceType))
{
errTmp = QString("Invalid device type: [%1]").arg(deviceType.toString());
}
else if (!tmp->setFriendlyName(friendlyName))
{
errTmp = QString("Invalid friendly name: [%1]").arg(friendlyName);
}
else if (!tmp->setManufacturer(manufacturer))
{
errTmp = QString("Invalid manufacturer: [%1]").arg(manufacturer);
}
else if (!tmp->setModelName(modelName))
{
errTmp = QString("Invalid model name: [%1]").arg(modelName);
}
else if (!tmp->setUdn(udn, checkLevel))
{
errTmp = QString("Invalid UDN: [%1]").arg(udn.toString());
}
if (!errTmp.isEmpty())
{
if (err)
{
*err = errTmp;
}
}
else
{
h_ptr = tmp.take();
}
// these are optional ==> no need to be strict
h_ptr->setManufacturerUrl (manufacturerUrl.toString());
h_ptr->setModelDescription(modelDescription);
h_ptr->setModelNumber (modelNumber);
h_ptr->setModelUrl (modelUrl.toString());
h_ptr->setSerialNumber (serialNumber);
h_ptr->setUpc (upc);
h_ptr->setIcons (icons);
h_ptr->setPresentationUrl (presentationUrl.toString());
}
void setState(
const HUdn& udn, const HResourceType& rt, HValidityCheckLevel checkLevel)
{
if (udn.isValid(checkLevel))
{
switch(rt.type())
{
case HResourceType::Undefined:
m_udn = udn;
m_type = HDiscoveryType::SpecificDevice;
m_resourceType = rt;
m_contents = udn.toString();
return;
case HResourceType::StandardDeviceType:
case HResourceType::VendorSpecifiedDeviceType:
m_type = HDiscoveryType::SpecificDeviceWithType;
break;
case HResourceType::StandardServiceType:
case HResourceType::VendorSpecifiedServiceType:
m_type = HDiscoveryType::SpecificServiceWithType;
break;
default:
Q_ASSERT(false);
}
m_contents = QString("%1::%2").arg(udn.toString(), rt.toString());
}
else
{
switch(rt.type())
{
case HResourceType::Undefined:
m_udn = udn;
m_type = HDiscoveryType::Undefined;
m_resourceType = rt;
m_contents = QString();
return;
case HResourceType::StandardDeviceType:
case HResourceType::VendorSpecifiedDeviceType:
m_type = HDiscoveryType::DeviceType;
break;
case HResourceType::StandardServiceType:
case HResourceType::VendorSpecifiedServiceType:
m_type = HDiscoveryType::ServiceType;
break;
default:
Q_ASSERT(false);
}
m_contents = QString("%1").arg(rt.toString());
}
m_udn = udn;
m_resourceType = rt;
}
