JsonReply *RulesHandler::GetRuleDetails(const QVariantMap ¶ms)
{
RuleId ruleId = RuleId(params.value("ruleId").toString());
Rule rule = GuhCore::instance()->findRule(ruleId);
if (rule.id().isNull()) {
return createReply(statusToReply(RuleEngine::RuleErrorRuleNotFound));
}
QVariantMap returns = statusToReply(RuleEngine::RuleErrorNoError);
returns.insert("rule", JsonTypes::packRule(rule));
return createReply(returns);
}
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);
}
JsonReply* RulesHandler::RemoveRule(const QVariantMap ¶ms)
{
QVariantMap returns;
RuleId ruleId(params.value("ruleId").toString());
RuleEngine::RuleError status = GuhCore::instance()->removeRule(ruleId);
returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
return createReply(returns);
}
JsonReply* DeviceHandler::GetPlugins(const QVariantMap ¶ms) const
{
Q_UNUSED(params)
QVariantMap returns;
returns.insert("plugins", JsonTypes::packPlugins());
return createReply(returns);
}
JsonReply* DeviceHandler::GetSupportedVendors(const QVariantMap ¶ms) const
{
Q_UNUSED(params)
QVariantMap returns;
returns.insert("vendors", JsonTypes::packSupportedVendors());
return createReply(returns);
}
JsonReply* RulesHandler::GetRules(const QVariantMap ¶ms)
{
Q_UNUSED(params)
QVariantMap returns;
returns.insert("ruleDescriptions", JsonTypes::packRuleDescriptions());
return createReply(returns);
}
JsonReply* DeviceHandler::SetPluginConfiguration(const QVariantMap ¶ms)
{
QVariantMap returns;
PluginId pluginId = PluginId(params.value("pluginId").toString());
ParamList pluginParams = JsonTypes::unpackParams(params.value("configuration").toList());
DeviceManager::DeviceError result = GuhCore::instance()->setPluginConfig(pluginId, pluginParams);
returns.insert("deviceError", JsonTypes::deviceErrorToString(result));
return createReply(returns);
}
ActionReply Helper::managekeyboard(QVariantMap args)
{
int code = 0;
QString layouts = args.value("layouts").toString();
QString variants = args.value("variants").toString();
code = (writeKeyboard(layouts,variants) ? 0 : WriteKeyboardError);
return createReply(code);
}
void
DocsumAdapter::Run(FastOS_ThreadInterface *, void *)
{
setupRequest();
handleRequest();
createReply();
writeLog();
cleanup();
delete this;
}
JsonReply *RulesHandler::EditRule(const QVariantMap ¶ms)
{
// check rule consistency
RuleEngine::RuleError ruleConsistencyError = JsonTypes::verifyRuleConsistency(params);
if (ruleConsistencyError != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(ruleConsistencyError));
return createReply(returns);
}
// Check and upack eventDescriptorList
QPair<QList<EventDescriptor>, RuleEngine::RuleError> eventDescriptorVerification = JsonTypes::verifyEventDescriptors(params);
QList<EventDescriptor> eventDescriptorList = eventDescriptorVerification.first;
if (eventDescriptorVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(eventDescriptorVerification.second));
return createReply(returns);
}
// Check and unpack stateEvaluator
qCDebug(dcJsonRpc) << "unpacking stateEvaluator:" << params.value("stateEvaluator").toMap();
StateEvaluator stateEvaluator = JsonTypes::unpackStateEvaluator(params.value("stateEvaluator").toMap());
if (!stateEvaluator.isValid()) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(RuleEngine::RuleErrorInvalidStateEvaluatorValue));
return createReply(returns);
}
// Check and unpack actions
QPair<QList<RuleAction>, RuleEngine::RuleError> actionsVerification = JsonTypes::verifyActions(params, eventDescriptorList);
QList<RuleAction> actions = actionsVerification.first;
if (actionsVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(actionsVerification.second));
return createReply(returns);
}
// Check and unpack exitActions
QPair<QList<RuleAction>, RuleEngine::RuleError> exitActionsVerification = JsonTypes::verifyExitActions(params);
QList<RuleAction> exitActions = exitActionsVerification.first;
if (exitActionsVerification.second != RuleEngine::RuleErrorNoError) {
QVariantMap returns;
returns.insert("ruleError", JsonTypes::ruleErrorToString(exitActionsVerification.second));
return createReply(returns);
}
QString name = params.value("name", QString()).toString();
bool enabled = params.value("enabled", true).toBool();
bool executable = params.value("executable", true).toBool();
RuleId ruleId = RuleId(params.value("ruleId").toString());
RuleEngine::RuleError status = GuhCore::instance()->editRule(ruleId, name, eventDescriptorList, stateEvaluator, actions, exitActions, enabled, executable);
QVariantMap returns;
if (status == RuleEngine::RuleErrorNoError) {
returns.insert("rule", JsonTypes::packRule(GuhCore::instance()->findRule(ruleId)));
}
returns.insert("ruleError", JsonTypes::ruleErrorToString(status));
return createReply(returns);
}
JsonReply* EventHandler::GetEventType(const QVariantMap ¶ms) const
{
qCDebug(dcJsonRpc) << "asked for event type" << params;
EventTypeId eventTypeId(params.value("eventTypeId").toString());
foreach (const DeviceClass &deviceClass, GuhCore::instance()->deviceManager()->supportedDevices()) {
foreach (const EventType &eventType, deviceClass.eventTypes()) {
if (eventType.id() == eventTypeId) {
QVariantMap data = statusToReply(DeviceManager::DeviceErrorNoError);
data.insert("eventType", JsonTypes::packEventType(eventType));
return createReply(data);
}
}
}
JsonReply *DeviceHandler::GetPluginConfiguration(const QVariantMap ¶ms) const
{
DevicePlugin *plugin = 0;
foreach (DevicePlugin *p, GuhCore::instance()->plugins()) {
if (p->pluginId() == PluginId(params.value("pluginId").toString())) {
plugin = p;
}
}
QVariantMap returns;
if (!plugin) {
returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorPluginNotFound));
return createReply(returns);
}
QVariantList paramVariantList;
foreach (const Param ¶m, plugin->configuration()) {
paramVariantList.append(JsonTypes::packParam(param));
}
returns.insert("configuration", paramVariantList);
returns.insert("deviceError", JsonTypes::deviceErrorToString(DeviceManager::DeviceErrorNoError));
return createReply(returns);
}
JsonReply *DeviceHandler::ConfirmPairing(const QVariantMap ¶ms)
{
PairingTransactionId pairingTransactionId = PairingTransactionId(params.value("pairingTransactionId").toString());
QString secret = params.value("secret").toString();
DeviceManager::DeviceError status = GuhCore::instance()->confirmPairing(pairingTransactionId, secret);
JsonReply *reply = 0;
if (status == DeviceManager::DeviceErrorAsync) {
reply = createAsyncReply("ConfirmPairing");
m_asyncPairingRequests.insert(pairingTransactionId, reply);
return reply;
}
QVariantMap returns;
returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
reply = createReply(returns);
return reply;
}
JsonReply *DeviceHandler::GetDiscoveredDevices(const QVariantMap ¶ms) const
{
QVariantMap returns;
DeviceClassId deviceClassId = DeviceClassId(params.value("deviceClassId").toString());
ParamList discoveryParams = JsonTypes::unpackParams(params.value("discoveryParams").toList());
DeviceManager::DeviceError status = GuhCore::instance()->discoverDevices(deviceClassId, discoveryParams);
if (status == DeviceManager::DeviceErrorAsync ) {
JsonReply *reply = createAsyncReply("GetDiscoveredDevices");
m_discoverRequests.insert(deviceClassId, reply);
return reply;
}
returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
return createReply(returns);
}
JsonReply *DeviceHandler::PairDevice(const QVariantMap ¶ms)
{
DeviceClassId deviceClassId(params.value("deviceClassId").toString());
DeviceClass deviceClass = GuhCore::instance()->findDeviceClass(deviceClassId);
DeviceManager::DeviceError status;
PairingTransactionId pairingTransactionId = PairingTransactionId::createPairingTransactionId();
if (params.contains("deviceDescriptorId")) {
DeviceDescriptorId deviceDescriptorId(params.value("deviceDescriptorId").toString());
status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceDescriptorId);
} else {
ParamList deviceParams = JsonTypes::unpackParams(params.value("deviceParams").toList());
status = GuhCore::instance()->pairDevice(pairingTransactionId, deviceClassId, deviceParams);
}
QVariantMap returns;
returns.insert("deviceError", JsonTypes::deviceErrorToString(status));
if (status == DeviceManager::DeviceErrorNoError) {
returns.insert("displayMessage", deviceClass.pairingInfo());
returns.insert("pairingTransactionId", pairingTransactionId.toString());
returns.insert("setupMethod", JsonTypes::setupMethod().at(deviceClass.setupMethod()));
}
return createReply(returns);
}
JsonReply* DeviceHandler::GetSupportedDevices(const QVariantMap ¶ms) const
{
QVariantMap returns;
returns.insert("deviceClasses", JsonTypes::packSupportedDevices(VendorId(params.value("vendorId").toString())));
return createReply(returns);
}
