void Scene::saveToFile(QFile &file)
{
QString s;
QString t;
// Comment line
s = QString("# Function entry\n");
file.writeBlock((const char*) s, s.length());
// Entry type
s = QString("Entry = Function") + QString("\n");
file.writeBlock((const char*) s, s.length());
// Name
s = QString("Name = ") + name() + QString("\n");
file.writeBlock((const char*) s, s.length());
// Type
s = QString("Type = ") + typeString() + QString("\n");
file.writeBlock((const char*) s, s.length());
// Device class, device name or "Global"
if (deviceClass() != NULL)
{
// Write only the data for device class scenes
for (unsigned i = 1; i < deviceClass()->m_channels.count(); i++)
{
t.setNum(i);
s = t + QString(" = ");
t.setNum(m_values[i]);
s += t + QString("\n");
file.writeBlock((const char*) s, s.length());
}
}
else if (device() != NULL)
{
// For device scenes (that are saved in the workspace file)
// write also the device name that this scene is attached to
s = QString("Device = ") + device()->name() + QString("\n");
file.writeBlock((const char*) s, s.length());
// Data
for (unsigned i = 1; i < device()->deviceClass()->m_channels.count(); i++)
{
t.setNum(i);
s = t + QString(" = ");
t.setNum(m_values[i]);
s += t + QString("\n");
file.writeBlock((const char*) s, s.length());
}
}
else
{
// For global scenes the device name is "Global"
s = QString("Device = Global") + QString("\n");
file.writeBlock((const char*) s, s.length());
}
}
JsonReply* DeviceHandler::AddConfiguredDevice(const QVariantMap ¶ms)
{
DeviceClassId deviceClass(params.value("deviceClassId").toString());
ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList());
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
DeviceId newDeviceId = DeviceId::createDeviceId();
DeviceManager::DeviceError status;
if (deviceDescriptorId.isNull()) {
status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceParams, newDeviceId);
} else {
status = GuhCore::instance()->addConfiguredDevice(deviceClass, deviceDescriptorId, newDeviceId);
}
QVariantMap returns;
switch (status) {
case DeviceManager::DeviceErrorAsync: {
JsonReply *asyncReply = createAsyncReply("AddConfiguredDevice");
m_asynDeviceAdditions.insert(newDeviceId, asyncReply);
return asyncReply;
}
case DeviceManager::DeviceErrorNoError:
returns.insert("deviceId", newDeviceId);
default:
returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
}
return createReply(returns);
}
//------------------------------------------------------------
// CNSmlBTServiceSearcher::SelectDeviceByDiscoveryL( TRequestStatus& aObserverRequestStatus )
//------------------------------------------------------------
void CNSmlBTServiceSearcher::SelectDeviceByDiscoveryL( TRequestStatus& aObserverRequestStatus )
{
if( !iIsDeviceSelectorConnected )
{
/*
User::LeaveIfError( iDeviceSelector.Connect() );
iIsDeviceSelectorConnected = ETrue;
*/
}
// Request a device selection
TBTDeviceClass deviceClass(0 ,0 ,0);
TBTDeviceSelectionParams parameters;
parameters.SetDeviceClass(deviceClass);
TBTDeviceSelectionParamsPckg pckg(parameters);
pckg().SetUUID( iBTConnInfo.iServiceClass );
// iDeviceSelector.StartNotifierAndGetResponse(
// aObserverRequestStatus,
// KDeviceSelectionNotifierUid,
// /*selectionFilter*/pckg,
// iResponse);
}
void Chaser::saveToFile(QFile &file)
{
QString s;
QString t;
// Comment line
s = QString("# Function entry\n");
file.writeBlock((const char*) s, s.length());
// Entry type
s = QString("Entry = Function") + QString("\n");
file.writeBlock((const char*) s, s.length());
// Name
s = QString("Name = ") + name() + QString("\n");
file.writeBlock((const char*) s, s.length());
// Type
s = QString("Type = ") + typeString() + QString("\n");
file.writeBlock((const char*) s, s.length());
// Device class, device name or "Global"
if (deviceClass() != NULL)
{
// For device class chasers we need to save only the steps because
// all scenes are inside the device class
for (ChaserStep* step = m_steps.first(); step != NULL; step = m_steps.next())
{
s = QString("Function = ") + step->feederFunction->name() + QString("\n");
file.writeBlock((const char*) s, s.length());
}
}
else if (device() != NULL)
{
// For device chasers (that are saved in the workspace file)
// write also the device name that this chaser is attached to
s = QString("Device = ") + device()->name() + QString("\n");
file.writeBlock((const char*) s, s.length());
for (ChaserStep* step = m_steps.first(); step != NULL; step = m_steps.next())
{
s = QString("Function = ") + step->feederFunction->name() + QString("\n");
file.writeBlock((const char*) s, s.length());
}
}
else
{
// For global chasers, write device+scene pairs
for (ChaserStep* step = m_steps.first(); step != NULL; step = m_steps.next())
{
// Global chasers need a device+scene pair
s = QString("Device = ") + step->callerDevice->name() + QString("\n");
file.writeBlock((const char*) s, s.length());
s = QString("Function = ") + step->feederFunction->name() + QString("\n");
file.writeBlock((const char*) s, s.length());
}
}
}
void Device::saveToFile(QFile &file)
{
QString s;
QString t;
// Comment
s = QString("# Device Entry\n");
file.writeBlock((const char*) s, s.length());
// Entry type
s = QString("Entry = Device") + QString("\n");
file.writeBlock((const char*) s, s.length());
// Name
s = QString("Name = ") + name() + QString("\n");
file.writeBlock((const char*) s, s.length());
// Manufacturer
s = QString("Manufacturer = ") + deviceClass()->manufacturer()
+ QString("\n");
file.writeBlock((const char*) s, s.length());
// Model
s = QString("Model = ") + deviceClass()->model() + QString("\n");
file.writeBlock((const char*) s, s.length());
// ID
t.setNum(m_id);
s = QString("ID = ") + t + QString("\n");
file.writeBlock((const char*) s, s.length());
// Address
t.setNum(address());
s = QString("Address = ") + t + QString("\n");
file.writeBlock((const char*) s, s.length());
// Universe
t.setNum(universe());
s = QString("Universe = ") + t + QString("\n");
file.writeBlock((const char*) s, s.length());
}
void Device::viewMonitor()
{
t_channel channels = deviceClass()->channels()->count();
if (m_monitor == NULL)
{
m_monitor = new Monitor(_app->workspace(), universeAddress(),
universeAddress() + channels - 1);
m_monitor->init();
m_monitor->setCaption(m_name + " Monitor");
m_monitor->setIcon(PIXMAPS + QString("monitor.xpm"));
connect(m_monitor, SIGNAL(closed()), this, SLOT(slotMonitorClosed()));
m_monitor->show();
}
else
{
m_monitor->hide();
m_monitor->show();
}
}
/*! Return a list of \l{DeviceClass}{DeviceClasses} describing all the devices supported by this plugin. */
QList<DeviceClass> DevicePlugin::supportedDevices() const
{
QList<DeviceClass> deviceClasses;
foreach (const QJsonValue &vendorJson, m_metaData.value("vendors").toArray()) {
bool broken = false;
VendorId vendorId = vendorJson.toObject().value("id").toString();
foreach (const QJsonValue &deviceClassJson, vendorJson.toObject().value("deviceClasses").toArray()) {
QJsonObject jo = deviceClassJson.toObject();
DeviceClass deviceClass(pluginId(), vendorId, jo.value("deviceClassId").toString());
deviceClass.setName(jo.value("name").toString());
DeviceClass::CreateMethods createMethods;
foreach (const QJsonValue &createMethodValue, jo.value("createMethods").toArray()) {
if (createMethodValue.toString() == "discovery") {
createMethods |= DeviceClass::CreateMethodDiscovery;
} else if (createMethodValue.toString() == "auto") {
createMethods |= DeviceClass::CreateMethodAuto;
} else {
createMethods |= DeviceClass::CreateMethodUser;
}
}
deviceClass.setCreateMethods(createMethods);
deviceClass.setDiscoveryParamTypes(parseParamTypes(jo.value("discoveryParamTypes").toArray()));
QString setupMethod = jo.value("setupMethod").toString();
if (setupMethod == "pushButton") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodPushButton);
} else if (setupMethod == "displayPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodDisplayPin);
} else if (setupMethod == "enterPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodEnterPin);
} else {
deviceClass.setSetupMethod(DeviceClass::SetupMethodJustAdd);
}
deviceClass.setPairingInfo(jo.value("pairingInfo").toString());
deviceClass.setParamTypes(parseParamTypes(jo.value("paramTypes").toArray()));
QList<ActionType> actionTypes;
QList<StateType> stateTypes;
foreach (const QJsonValue &stateTypesJson, jo.value("stateTypes").toArray()) {
QJsonObject st = stateTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "type" << "id" << "name", st);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in stateTypes";
broken = true;
break;
}
QVariant::Type t = QVariant::nameToType(st.value("type").toString().toLatin1().data());
StateType stateType(st.value("id").toString());
stateType.setName(st.value("name").toString());
stateType.setType(t);
stateType.setUnit(unitStringToUnit(st.value("unit").toString()));
stateType.setDefaultValue(st.value("defaultValue").toVariant());
stateTypes.append(stateType);
// create ActionType if this StateType is writable
if (st.contains("writable")) {
ActionType actionType(st.value("id").toString());
actionType.setName("set " + st.value("name").toString());
// Note: fields already checked in StateType
ParamType paramType(st.value("name").toString(), t, st.value("defaultValue").toVariant());
if (st.value("writable").toObject().contains("allowedValues")) {
QVariantList allowedValues;
foreach (const QJsonValue &allowedTypesJson, st.value("writable").toObject().value("allowedValues").toArray()) {
allowedValues.append(allowedTypesJson.toVariant());
}
paramType.setAllowedValues(allowedValues);
}
paramType.setInputType(inputTypeStringToInputType(st.value("writable").toObject().value("inputType").toString()));
paramType.setUnit(unitStringToUnit(st.value("unit").toString()));
paramType.setLimits(st.value("writable").toObject().value("minValue").toVariant(),
st.value("writable").toObject().value("maxValue").toVariant());
actionType.setParamTypes(QList<ParamType>() << paramType);
actionTypes.append(actionType);
}
}
deviceClass.setStateTypes(stateTypes);
foreach (const QJsonValue &actionTypesJson, jo.value("actionTypes").toArray()) {
QJsonObject at = actionTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", at);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in actionTypes";
broken = true;
break;
}
ActionType actionType(at.value("id").toString());
actionType.setName(at.value("name").toString());
actionType.setParamTypes(parseParamTypes(at.value("paramTypes").toArray()));
actionTypes.append(actionType);
}
deviceClass.setActionTypes(actionTypes);
QList<EventType> eventTypes;
foreach (const QJsonValue &eventTypesJson, jo.value("eventTypes").toArray()) {
QJsonObject et = eventTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", et);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in eventTypes";
broken = true;
break;
}
EventType eventType(et.value("id").toString());
eventType.setName(et.value("name").toString());
eventType.setParamTypes(parseParamTypes(et.value("paramTypes").toArray()));
eventTypes.append(eventType);
}
deviceClass.setEventTypes(eventTypes);
if (!broken) {
deviceClasses.append(deviceClass);
}
}
bool LcmsColorProfileContainer::isSuitableForDisplay() const
{
return deviceClass() == cmsSigDisplayClass;
}
bool LcmsColorProfileContainer::isSuitableForPrinting() const
{
return deviceClass() == cmsSigOutputClass;
}
/*! Return a list of \l{DeviceClass}{DeviceClasses} describing all the devices supported by this plugin.
If a DeviceClass has an invalid parameter it will be ignored.
*/
QList<DeviceClass> DevicePlugin::supportedDevices() const
{
QList<DeviceClass> deviceClasses;
foreach (const QJsonValue &vendorJson, m_metaData.value("vendors").toArray()) {
bool broken = false;
VendorId vendorId = vendorJson.toObject().value("id").toString();
foreach (const QJsonValue &deviceClassJson, vendorJson.toObject().value("deviceClasses").toArray()) {
QJsonObject jo = deviceClassJson.toObject();
DeviceClass deviceClass(pluginId(), vendorId, jo.value("deviceClassId").toString());
deviceClass.setName(jo.value("name").toString());
DeviceClass::CreateMethods createMethods;
foreach (const QJsonValue &createMethodValue, jo.value("createMethods").toArray()) {
if (createMethodValue.toString() == "discovery") {
createMethods |= DeviceClass::CreateMethodDiscovery;
} else if (createMethodValue.toString() == "auto") {
createMethods |= DeviceClass::CreateMethodAuto;
} else if (createMethodValue.toString() == "user") {
createMethods |= DeviceClass::CreateMethodUser;
} else {
qCWarning(dcDeviceManager) << "Unknown createMehtod" << createMethodValue.toString() <<
"in deviceClass " << deviceClass.name() << ". Falling back to CreateMethodUser.";
createMethods |= DeviceClass::CreateMethodUser;
}
}
deviceClass.setCreateMethods(createMethods);
deviceClass.setDeviceIcon(loadAndVerifyDeviceIcon(jo.value("deviceIcon").toString()));
deviceClass.setDiscoveryParamTypes(parseParamTypes(jo.value("discoveryParamTypes").toArray()));
QString setupMethod = jo.value("setupMethod").toString();
if (setupMethod == "pushButton") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodPushButton);
} else if (setupMethod == "displayPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodDisplayPin);
} else if (setupMethod == "enterPin") {
deviceClass.setSetupMethod(DeviceClass::SetupMethodEnterPin);
} else if (setupMethod == "justAdd") {
qCWarning(dcDeviceManager) << "Unknown setupMehtod" << setupMethod <<
"in deviceClass " << deviceClass.name() << ". Falling back to SetupMethodJustAdd.";
deviceClass.setSetupMethod(DeviceClass::SetupMethodJustAdd);
}
deviceClass.setPairingInfo(jo.value("pairingInfo").toString());
deviceClass.setParamTypes(parseParamTypes(jo.value("paramTypes").toArray()));
QList<DeviceClass::BasicTag> basicTags;
foreach (const QJsonValue &basicTagJson, jo.value("basicTags").toArray()) {
basicTags.append(loadAndVerifyBasicTag(basicTagJson.toString()));
}
deviceClass.setBasicTags(basicTags);
QList<ActionType> actionTypes;
QList<StateType> stateTypes;
foreach (const QJsonValue &stateTypesJson, jo.value("stateTypes").toArray()) {
QJsonObject st = stateTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "type" << "id" << "name", st);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in stateTypes";
broken = true;
break;
}
QVariant::Type t = QVariant::nameToType(st.value("type").toString().toLatin1().data());
StateType stateType(st.value("id").toString());
stateType.setName(st.value("name").toString());
stateType.setType(t);
stateType.setUnit(loadAndVerifyUnit(st.value("unit").toString()));
stateType.setDefaultValue(st.value("defaultValue").toVariant());
if (st.contains("minValue"))
stateType.setMinValue(st.value("minValue").toVariant());
if (st.contains("maxValue"))
stateType.setMaxValue(st.value("maxValue").toVariant());
if (st.contains("possibleValues")) {
QVariantList possibleValues;
foreach (const QJsonValue &possibleValueJson, st.value("possibleValues").toArray()) {
possibleValues.append(possibleValueJson.toVariant());
}
stateType.setPossibleValues(possibleValues);
// inform the plugin developer about the error in the plugin json file
Q_ASSERT_X(stateType.possibleValues().contains(stateType.defaultValue()),
QString("\"%1\" plugin").arg(pluginName()).toLatin1().data(),
QString("The given default value \"%1\" is not in the possible values of the stateType \"%2\".")
.arg(stateType.defaultValue().toString()).arg(stateType.name()).toLatin1().data());
}
stateTypes.append(stateType);
// create ActionType if this StateType is writable
if (st.contains("writable") && st.value("writable").toBool()) {
// Note: fields already checked in StateType
ActionType actionType(ActionTypeId(stateType.id().toString()));
actionType.setName("set " + stateType.name());
ParamType paramType(stateType.name(), t, stateType.defaultValue());
paramType.setAllowedValues(stateType.possibleValues());
paramType.setUnit(stateType.unit());
paramType.setLimits(stateType.minValue(), stateType.maxValue());
actionType.setParamTypes(QList<ParamType>() << paramType);
actionTypes.append(actionType);
}
}
deviceClass.setStateTypes(stateTypes);
foreach (const QJsonValue &actionTypesJson, jo.value("actionTypes").toArray()) {
QJsonObject at = actionTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", at);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in actionTypes";
broken = true;
break;
}
ActionType actionType(at.value("id").toString());
actionType.setName(at.value("name").toString());
actionType.setParamTypes(parseParamTypes(at.value("paramTypes").toArray()));
actionTypes.append(actionType);
}
deviceClass.setActionTypes(actionTypes);
QList<EventType> eventTypes;
foreach (const QJsonValue &eventTypesJson, jo.value("eventTypes").toArray()) {
QJsonObject et = eventTypesJson.toObject();
QStringList missingFields = verifyFields(QStringList() << "id" << "name", et);
if (!missingFields.isEmpty()) {
qCWarning(dcDeviceManager) << "Skipping device class" << deviceClass.name() << "because of missing" << missingFields.join(", ") << "in eventTypes";
broken = true;
break;
}
EventType eventType(et.value("id").toString());
eventType.setName(et.value("name").toString());
eventType.setParamTypes(parseParamTypes(et.value("paramTypes").toArray()));
eventTypes.append(eventType);
}
deviceClass.setEventTypes(eventTypes);
if (!broken)
deviceClasses.append(deviceClass);
}
}