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;
    }
}
HDiscoveryType::HDiscoveryType(
    const HUdn& udn, bool isRootDevice, HValidityCheckLevel checkLevel) :
        h_ptr(new HDiscoveryTypePrivate())
{
    if (udn.isValid(checkLevel))
    {
        if (isRootDevice)
        {
            h_ptr->m_type = HDiscoveryType::SpecificRootDevice;
            h_ptr->m_contents =
                QString("%1::upnp:rootdevice").arg(udn.toString());
        }
        else
        {
            h_ptr->m_type = HDiscoveryType::SpecificDevice;
            h_ptr->m_contents = udn.toString();
        }

        h_ptr->m_udn = udn;
    }
}
Beispiel #3
0
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));
}
Beispiel #5
0
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());
}
    bool parse(const QString& arg, HValidityCheckLevel checkLevel)
    {
        HLOG(H_AT, H_FUN);

        QString tmp(arg.simplified());

        HUdn udn;
        qint32 indx = tmp.indexOf("::");
        if (indx == 41) // the length of "uuid:UUID" is 41
        {
            udn = HUdn(tmp.left(41));
            if (!udn.isValid(checkLevel))
            {
                return false;
            }

            if (tmp.size() > 43)
            {
                tmp = tmp.mid(43);
            }
            else
            {
                m_udn = udn;
                m_type = HDiscoveryType::SpecificDevice;
                m_contents = udn.toString();
                return true;
            }
        }

        QStringList parsed = tmp.split(':');
        if (parsed.size() < 2)
        {
            HLOG_WARN(QString("Invalid resource identifier: %1").arg(arg));
            return false;
        }

        if (!udn.isValid(checkLevel))
        {
            if (parsed[0] == "ssdp" && parsed[1] == "all")
            {
                m_type = HDiscoveryType::All;
                m_contents = "ssdp:all";
                return true;
            }
        }

        if (parsed[0] == "upnp" && parsed[1] == "rootdevice")
        {
            m_udn = udn;

            if (m_udn.isValid(checkLevel))
            {
                m_type = HDiscoveryType::SpecificRootDevice;
                m_contents = QString("%1::upnp:rootdevice").arg(udn.toString());
            }
            else
            {
                m_type = HDiscoveryType::RootDevices;
                m_contents = "upnp:rootdevice";
            }
            return true;
        }
        else if (parsed[0] == "uuid")
        {
            udn = HUdn(parsed[1]);
            if (udn.isValid(checkLevel))
            {
                m_udn = udn;
                m_type = HDiscoveryType::SpecificDevice;
                m_contents = udn.toString();
                return true;
            }
        }

        HResourceType resourceType(tmp);
        if (parse(resourceType))
        {
            m_udn = udn;
            if (m_udn.isValid(checkLevel))
            {
                m_type = resourceType.isDeviceType() ?
                     HDiscoveryType::SpecificDeviceWithType :
                     HDiscoveryType::SpecificServiceWithType;

                m_contents = QString("%1::%2").arg(
                    udn.toString(), resourceType.toString());
            }
            else
            {
                m_type = resourceType.isDeviceType() ?
                     HDiscoveryType::DeviceType :
                     HDiscoveryType::ServiceType;

                m_contents = QString("%1").arg(resourceType.toString());
            }

            return true;
        }

        HLOG_WARN(QString("Invalid resource identifier: %1").arg(arg));
        return false;
    }
    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;
    }