#include <notification.h>
#include <notification_internal.h>
#include <vconf.h>
-#include <context_trigger_types_internal.h>
+#include <TriggerRuleTypes.h>
#include "../DBusServer.h"
#include "ActionManager.h"
void ctx::trigger::action_manager::triggerAction(ctx::Json& action, std::string pkgId)
{
std::string type;
- action.get(NULL, CT_RULE_ACTION_TYPE, &type);
+ action.get(NULL, TRIG_RULE_ACTION_TYPE, &type);
- if (type.compare(CT_RULE_ACTION_TYPE_APP_CONTROL) == 0) {
+ if (type.compare(TRIG_RULE_ACTION_TYPE_APP_CONTROL) == 0) {
__triggerActionAppControl(action);
- } else if (type.compare(CT_RULE_ACTION_TYPE_NOTIFICATION) == 0) {
+ } else if (type.compare(TRIG_RULE_ACTION_TYPE_NOTIFICATION) == 0) {
__triggerActionNotification(action, pkgId);
- } else if (type.compare(CT_RULE_ACTION_TYPE_DBUS_CALL) == 0) {
+ } else if (type.compare(TRIG_RULE_ACTION_TYPE_DBUS_CALL) == 0) {
__triggerActionDbusCall(action);
}
}
{
int error;
std::string appctlStr;
- action.get(NULL, CT_RULE_ACTION_APP_CONTROL, &appctlStr);
+ action.get(NULL, TRIG_RULE_ACTION_APP_CONTROL, &appctlStr);
char* str = static_cast<char*>(malloc(appctlStr.length()));
if (str == NULL) {
int error;
notification_h notification = notification_create(NOTIFICATION_TYPE_NOTI);
std::string title;
- if (action.get(NULL, CT_RULE_ACTION_NOTI_TITLE, &title)) {
+ if (action.get(NULL, TRIG_RULE_ACTION_NOTI_TITLE, &title)) {
error = notification_set_text(notification, NOTIFICATION_TEXT_TYPE_TITLE, title.c_str(), NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
if (error != NOTIFICATION_ERROR_NONE) {
_E("Set notification title failed(%d)", error);
}
std::string content;
- if (action.get(NULL, CT_RULE_ACTION_NOTI_CONTENT, &content)) {
+ if (action.get(NULL, TRIG_RULE_ACTION_NOTI_CONTENT, &content)) {
error = notification_set_text(notification, NOTIFICATION_TEXT_TYPE_CONTENT, content.c_str(), NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
if (error != NOTIFICATION_ERROR_NONE) {
_E("Set notification contents failed(%d)", error);
}
std::string imagePath;
- if (action.get(NULL, CT_RULE_ACTION_NOTI_ICON_PATH, &imagePath)) {
+ if (action.get(NULL, TRIG_RULE_ACTION_NOTI_ICON_PATH, &imagePath)) {
error = notification_set_image(notification, NOTIFICATION_IMAGE_TYPE_ICON, imagePath.c_str());
if (error != NOTIFICATION_ERROR_NONE) {
_E("Set notification icon image failed(%d)", error);
bundle_raw* encoded = NULL;
bundle* appctlBundle = NULL;
app_control_h app = NULL;
- if (action.get(NULL, CT_RULE_ACTION_APP_CONTROL, &appctlStr)) {
+ if (action.get(NULL, TRIG_RULE_ACTION_APP_CONTROL, &appctlStr)) {
str = static_cast<char*>(malloc(appctlStr.length()));
if (str == NULL) {
_E("Memory allocation failed");
std::string busName, object, iface, method;
GVariant *param = NULL;
- action.get(NULL, CT_RULE_ACTION_DBUS_NAME, &busName);
+ action.get(NULL, TRIG_RULE_ACTION_DBUS_NAME, &busName);
IF_FAIL_VOID_TAG(!busName.empty(), _E, "No target bus name");
- action.get(NULL, CT_RULE_ACTION_DBUS_OBJECT, &object);
+ action.get(NULL, TRIG_RULE_ACTION_DBUS_OBJECT, &object);
IF_FAIL_VOID_TAG(!object.empty(), _E, "No object path");
- action.get(NULL, CT_RULE_ACTION_DBUS_INTERFACE, &iface);
+ action.get(NULL, TRIG_RULE_ACTION_DBUS_INTERFACE, &iface);
IF_FAIL_VOID_TAG(!iface.empty(), _E, "No interface name");
- action.get(NULL, CT_RULE_ACTION_DBUS_METHOD, &method);
+ action.get(NULL, TRIG_RULE_ACTION_DBUS_METHOD, &method);
IF_FAIL_VOID_TAG(!method.empty(), _E, "No method name");
- action.get(NULL, CT_RULE_ACTION_DBUS_PARAMETER, ¶m);
+ action.get(NULL, TRIG_RULE_ACTION_DBUS_PARAMETER, ¶m);
ctx::DBusServer::call(busName, object, iface, method, param);
}
#ifndef _CONTEXT_TRIGGER_FACT_TYPES_H_
#define _CONTEXT_TRIGGER_FACT_TYPES_H_
-#define CONTEXT_FACT_EVENT "EVENT"
-#define CONTEXT_FACT_CONDITION "CONDITION"
-#define CONTEXT_FACT_NAME "NAME"
-#define CONTEXT_FACT_OPTION "OPTION"
-#define CONTEXT_FACT_DATA "DATA"
+#define FACT_KEY_EVENT "event"
+#define FACT_KEY_CONDITION "condition"
+#define FACT_KEY_NAME "name"
+#define FACT_KEY_OPTION "option"
+#define FACT_KEY_DATA "data"
#endif /* End of _CONTEXT_TRIGGER_FACT_TYPES_H_ */
* limitations under the License.
*/
-#include <context_trigger_types_internal.h>
+#include <TriggerRuleTypes.h>
#include "Rule.h"
#include "ActionManager.h"
#include "RuleEvaluator.h"
// Event
Json e;
- d.get(NULL, CT_RULE_EVENT, &e);
+ d.get(NULL, TRIG_RULE_EVENT, &e);
__event = new(std::nothrow) ContextItem(e);
// Condition
- int cond_num = d.getSize(NULL, CT_RULE_CONDITION);
+ int cond_num = d.getSize(NULL, TRIG_RULE_CONDITION);
for (int j = 0; j < cond_num; j++) {
Json c;
- d.getAt(NULL, CT_RULE_CONDITION, j, &c);
+ d.getAt(NULL, TRIG_RULE_CONDITION, j, &c);
__condition.push_back(new(std::nothrow) ContextItem(c));
}
// Action
Json a;
- d.get(NULL, CT_RULE_ACTION, &a);
+ d.get(NULL, TRIG_RULE_ACTION, &a);
__action = a.str();
}
std::string newStr;
int new_val;
- if (__result.get(CONTEXT_FACT_EVENT "." CONTEXT_FACT_DATA, eventKey.c_str(), &newStr)) {
+ if (__result.get(FACT_KEY_EVENT "." FACT_KEY_DATA, eventKey.c_str(), &newStr)) {
option.set(NULL, optKey.c_str(), newStr);
- } else if (__result.get(CONTEXT_FACT_EVENT "." CONTEXT_FACT_DATA, eventKey.c_str(), &new_val)) {
+ } else if (__result.get(FACT_KEY_EVENT "." FACT_KEY_DATA, eventKey.c_str(), &new_val)) {
option.set(NULL, optKey.c_str(), new_val);
} else {
_W("Failed to find '%s' in event data", eventKey.c_str());
_D("Rule%d received event data", id);
// Set event data
- __result.set(CONTEXT_FACT_EVENT, CONTEXT_FACT_NAME, name);
- __result.set(CONTEXT_FACT_EVENT, CONTEXT_FACT_OPTION, option);
- __result.set(CONTEXT_FACT_EVENT, CONTEXT_FACT_DATA, data);
+ __result.set(FACT_KEY_EVENT, FACT_KEY_NAME, name);
+ __result.set(FACT_KEY_EVENT, FACT_KEY_OPTION, option);
+ __result.set(FACT_KEY_EVENT, FACT_KEY_DATA, data);
if (__condition.size() == 0) {
__onContextDataPrepared();
// Set condition data
Json item;
- item.set(NULL, CONTEXT_FACT_NAME, name);
- item.set(NULL, CONTEXT_FACT_OPTION, option);
- item.set(NULL, CONTEXT_FACT_DATA, data);
- __result.append(NULL, CONTEXT_FACT_CONDITION, item);
+ item.set(NULL, FACT_KEY_NAME, name);
+ item.set(NULL, FACT_KEY_OPTION, option);
+ item.set(NULL, FACT_KEY_DATA, data);
+ __result.append(NULL, FACT_KEY_CONDITION, item);
- if (__result.getSize(NULL, CONTEXT_FACT_CONDITION) == (int) __condition.size()) {
+ if (__result.getSize(NULL, FACT_KEY_CONDITION) == (int) __condition.size()) {
__onContextDataPrepared();
}
}
ctx::Json option;
ContextItem(ctx::Json item) {
std::string n;
- item.get(NULL, CT_RULE_EVENT_ITEM, &n);
+ item.get(NULL, TRIG_RULE_EVENT_ITEM, &n);
name = n;
ctx::Json o;
- if (item.get(NULL, CT_RULE_EVENT_OPTION, &o))
+ if (item.get(NULL, TRIG_RULE_EVENT_OPTION, &o))
option = o.str();
}
};
#include <Json.h>
#include <Types.h>
-#include <context_trigger_types_internal.h>
+#include <TriggerRuleTypes.h>
#include "RuleEvaluator.h"
#include "FactTypes.h"
-#define AND_STRING "and"
-#define OR_STRING "or"
-#define EVENT_REFERENCE "?"
#define OPERATOR_EQ "=="
#define OPERATOR_NEQ "!="
#define OPERATOR_LEQ "<="
std::string eventRefStr;
int eventRefInt;
- for (int i = 0; i < ruleDataArr.getSize(NULL, CT_RULE_DATA_VALUE_ARR); i++) {
- if (!ruleDataArr.getAt(NULL, CT_RULE_DATA_VALUE_ARR, i, &refVal)) {
+ for (int i = 0; i < ruleDataArr.getSize(NULL, TRIG_RULE_DATA_VALUE_ARR); i++) {
+ if (!ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &refVal)) {
continue;
}
- if (refVal.substr(0, 1) != EVENT_REFERENCE) {
+ if (refVal.substr(0, 1) != TRIG_RULE_REF_KEY_PREFIX) {
continue;
}
std::string eventKey = refVal.substr(1, refVal.length() - 1);
if (eventFactData.get(NULL, eventKey.c_str(), &eventRefStr)) {
- ruleDataArr.setAt(NULL, CT_RULE_DATA_VALUE_ARR, i, eventRefStr);
+ ruleDataArr.setAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, eventRefStr);
} else if (eventFactData.get(NULL, eventKey.c_str(), &eventRefInt)) {
- ruleDataArr.setAt(NULL, CT_RULE_DATA_VALUE_ARR, i, eventRefInt);
+ ruleDataArr.setAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, eventRefInt);
} else {
_W("Option %s not found in event_data", eventKey.c_str());
}
if (!ruleOption.get(NULL, (*it).c_str(), &refVal)) {
continue;
}
- if (!(refVal.substr(0, 1) == EVENT_REFERENCE)) {
+ if (!(refVal.substr(0, 1) == TRIG_RULE_REF_KEY_PREFIX)) {
continue;
}
{
// Replace referencing data/option to actual value
Json eventFactData;
- if (!fact.get(CONTEXT_FACT_EVENT, CONTEXT_FACT_DATA, &eventFactData)) {
+ if (!fact.get(FACT_KEY_EVENT, FACT_KEY_DATA, &eventFactData)) {
_E("No event data found, error");
return false;
}
Json ruleCond;
- for (int i = 0; rule.getAt(NULL, CT_RULE_CONDITION, i, &ruleCond); i++) {
+ for (int i = 0; rule.getAt(NULL, TRIG_RULE_CONDITION, i, &ruleCond); i++) {
Json ruleDataArr;
- for (int j = 0; ruleCond.getAt(NULL, CT_RULE_DATA_ARR, j, &ruleDataArr); j++) {
+ for (int j = 0; ruleCond.getAt(NULL, TRIG_RULE_DATA_ARR, j, &ruleDataArr); j++) {
__replaceDataReferences(ruleDataArr, eventFactData);
}
Json ruleOption;
- if (ruleCond.get(NULL, CT_RULE_CONDITION_OPTION, &ruleOption)) {
+ if (ruleCond.get(NULL, TRIG_RULE_CONDITION_OPTION, &ruleOption)) {
__replaceOptionReferences(ruleOption, eventFactData);
}
}
bool RuleEvaluator::__evaluateDataString(Json& ruleDataArr, std::string factValStr)
{
std::string opVal;
- ruleDataArr.get(NULL, CT_RULE_DATA_KEY_OPERATOR, &opVal);
- bool conjunction = (AND_STRING == opVal);
+ ruleDataArr.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &opVal);
+ bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opVal);
std::string op;
- for (int i = 0; ruleDataArr.getAt(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
+ for (int i = 0; ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
bool result;
std::string valStr;
- ruleDataArr.getAt(NULL, CT_RULE_DATA_VALUE_ARR, i, &valStr);
+ ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &valStr);
result = __compareString(op, factValStr, valStr);
if (conjunction && !result) {
bool RuleEvaluator::__evaluateDataInt(Json& ruleDataArr, int factValInt)
{
std::string opVal;
- ruleDataArr.get(NULL, CT_RULE_DATA_KEY_OPERATOR, &opVal);
- bool conjunction = (AND_STRING == opVal);
+ ruleDataArr.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &opVal);
+ bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opVal);
std::string op;
- for (int i = 0; ruleDataArr.getAt(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
+ for (int i = 0; ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &op); i++) {
bool result;
int valInt;
- if (!ruleDataArr.getAt(NULL, CT_RULE_DATA_VALUE_ARR, i, &valInt)) {
+ if (!ruleDataArr.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &valInt)) {
result = false;
}
result = __compareInt(op, factValInt, valInt);
bool RuleEvaluator::__evaluateItem(Json& ruleItem, Json& factItem)
{
Json ruleDataArr;
- if (ruleItem.getSize(NULL, CT_RULE_DATA_ARR) == 0) {
+ if (ruleItem.getSize(NULL, TRIG_RULE_DATA_ARR) == 0) {
return true;
}
std::string opKey;
- ruleItem.get(NULL, CT_RULE_CONDITION_OPERATOR, &opKey);
- bool conjunction = (AND_STRING == opKey);
+ ruleItem.get(NULL, TRIG_RULE_CONDITION_OPERATOR, &opKey);
+ bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opKey);
- for (int i = 0; ruleItem.getAt(NULL, CT_RULE_DATA_ARR, i, &ruleDataArr); i++) {
+ for (int i = 0; ruleItem.getAt(NULL, TRIG_RULE_DATA_ARR, i, &ruleDataArr); i++) {
std::string dataKey;
- ruleDataArr.get(NULL, CT_RULE_DATA_KEY, &dataKey);
+ ruleDataArr.get(NULL, TRIG_RULE_DATA_KEY, &dataKey);
std::string factValStr;
int factValInt;
bool result;
- if (factItem.get(CONTEXT_FACT_DATA, dataKey.c_str(), &factValStr)) {
+ if (factItem.get(FACT_KEY_DATA, dataKey.c_str(), &factValStr)) {
result = __evaluateDataString(ruleDataArr, factValStr);
- } else if (factItem.get(CONTEXT_FACT_DATA, dataKey.c_str(), &factValInt)) {
+ } else if (factItem.get(FACT_KEY_DATA, dataKey.c_str(), &factValInt)) {
result = __evaluateDataInt(ruleDataArr, factValInt);
} else {
_W("Could not get value corresponding to data key %s", dataKey.c_str());
{
Json factItem;
Json ruleItem;
- fact.get(NULL, CONTEXT_FACT_EVENT, &factItem);
- rule.get(NULL, CT_RULE_EVENT, &ruleItem);
+ fact.get(NULL, FACT_KEY_EVENT, &factItem);
+ rule.get(NULL, TRIG_RULE_EVENT, &ruleItem);
return __evaluateItem(ruleItem, factItem);
}
Json RuleEvaluator::__getConditionFact(Json& ruleCond, Json& fact)
{
std::string ruleCondName;
- ruleCond.get(NULL, CT_RULE_CONDITION_ITEM, &ruleCondName);
+ ruleCond.get(NULL, TRIG_RULE_CONDITION_ITEM, &ruleCondName);
Json factCond;
- for (int i = 0; fact.getAt(NULL, CONTEXT_FACT_CONDITION, i, &factCond); i++) {
+ for (int i = 0; fact.getAt(NULL, FACT_KEY_CONDITION, i, &factCond); i++) {
// Check if fact item name is matched with condition
std::string factCondName;
- factCond.get(NULL, CONTEXT_FACT_NAME, &factCondName);
+ factCond.get(NULL, FACT_KEY_NAME, &factCondName);
if (factCondName != ruleCondName) {
continue;
}
// Check if fact item option is mathced with condition
Json ruleCondOption;
Json factCondOption;
- ruleCond.get(NULL, CT_RULE_CONDITION_OPTION, &ruleCondOption);
- factCond.get(NULL, CONTEXT_FACT_OPTION, &factCondOption);
+ ruleCond.get(NULL, TRIG_RULE_CONDITION_OPTION, &ruleCondOption);
+ factCond.get(NULL, FACT_KEY_OPTION, &factCondOption);
if (factCondOption == ruleCondOption) {
return factCond;
}
Json factCond;
std::string opCond;
- rule.get(NULL, CT_RULE_OPERATOR, &opCond);
- bool conjunction = (AND_STRING == opCond);
+ rule.get(NULL, TRIG_RULE_OPERATOR, &opCond);
+ bool conjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == opCond);
- for (int i = 0; rule.getAt(NULL, CT_RULE_CONDITION, i, &ruleCond); i++) {
+ for (int i = 0; rule.getAt(NULL, TRIG_RULE_CONDITION, i, &ruleCond); i++) {
factCond = __getConditionFact(ruleCond, fact);
bool result;
if (factCond == EMPTY_JSON_OBJECT) {
RuleEvaluator eval;
bool ret;
Json tempJson;
- if (fact.get(NULL, CT_RULE_CONDITION, &tempJson)) {
+ if (fact.get(NULL, TRIG_RULE_CONDITION, &tempJson)) {
Json ruleCopy(rule.str());
if (!eval.__replaceEventReferences(ruleCopy, fact)) {
_W("Replace failed");
*/
#include <sstream>
-#include <context_trigger_types_internal.h>
+#include <TriggerTypes.h>
+#include <TriggerRuleTypes.h>
#include <package_manager.h>
#include <Json.h>
#include "RuleManager.h"
bool RuleManager::__ruleDataArrElemEquals(Json& lElem, Json& rElem)
{
std::string lKey, rKey;
- lElem.get(NULL, CT_RULE_DATA_KEY, &lKey);
- rElem.get(NULL, CT_RULE_DATA_KEY, &rKey);
+ lElem.get(NULL, TRIG_RULE_DATA_KEY, &lKey);
+ rElem.get(NULL, TRIG_RULE_DATA_KEY, &rKey);
if (lKey.compare(rKey))
return false;
int lValCnt, rValCnt, lValOpCnt, rValOpCnt;
- lValCnt = lElem.getSize(NULL, CT_RULE_DATA_VALUE_ARR);
- rValCnt = rElem.getSize(NULL, CT_RULE_DATA_VALUE_ARR);
- lValOpCnt = lElem.getSize(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR);
- rValOpCnt = rElem.getSize(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR);
+ lValCnt = lElem.getSize(NULL, TRIG_RULE_DATA_VALUE_ARR);
+ rValCnt = rElem.getSize(NULL, TRIG_RULE_DATA_VALUE_ARR);
+ lValOpCnt = lElem.getSize(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR);
+ rValOpCnt = rElem.getSize(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR);
if (!((lValCnt == rValCnt) && (lValCnt == lValOpCnt) && (lValCnt && rValOpCnt)))
return false;
if (lValCnt > 1) {
std::string lOp, rOp;
- lElem.get(NULL, CT_RULE_DATA_KEY_OPERATOR, &lOp);
- rElem.get(NULL, CT_RULE_DATA_KEY_OPERATOR, &rOp);
+ lElem.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &lOp);
+ rElem.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &rOp);
if (lOp.compare(rOp))
return false;
}
for (int i = 0; i < lValCnt; i++) {
bool found = false;
std::string lVal, lValOp;
- lElem.getAt(NULL, CT_RULE_DATA_VALUE_ARR, i, &lVal);
- lElem.getAt(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR, i, &lValOp);
+ lElem.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &lVal);
+ lElem.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &lValOp);
for (int j = 0; j < lValCnt; j++) {
std::string rVal, rValOp;
- rElem.getAt(NULL, CT_RULE_DATA_VALUE_ARR, j, &rVal);
- rElem.getAt(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR, j, &rValOp);
+ rElem.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, j, &rVal);
+ rElem.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, j, &rValOp);
if (!lVal.compare(rVal) && !lValOp.compare(rValOp)) {
found = true;
{
// Compare item name
std::string lItemName, rItemName;
- lItem.get(NULL, CT_RULE_EVENT_ITEM, &lItemName);
- rItem.get(NULL, CT_RULE_EVENT_ITEM, &rItemName);
+ lItem.get(NULL, TRIG_RULE_EVENT_ITEM, &lItemName);
+ rItem.get(NULL, TRIG_RULE_EVENT_ITEM, &rItemName);
if (lItemName.compare(rItemName))
return false;
// Compare option
Json lOption, rOption;
- lItem.get(NULL, CT_RULE_EVENT_OPTION, &lOption);
- rItem.get(NULL, CT_RULE_EVENT_OPTION, &rOption);
+ lItem.get(NULL, TRIG_RULE_EVENT_OPTION, &lOption);
+ rItem.get(NULL, TRIG_RULE_EVENT_OPTION, &rOption);
if (lOption != rOption)
return false;
int lDataArrCnt, rDataArrCnt;
- lDataArrCnt = lItem.getSize(NULL, CT_RULE_DATA_ARR);
- rDataArrCnt = rItem.getSize(NULL, CT_RULE_DATA_ARR);
+ lDataArrCnt = lItem.getSize(NULL, TRIG_RULE_DATA_ARR);
+ rDataArrCnt = rItem.getSize(NULL, TRIG_RULE_DATA_ARR);
if (lDataArrCnt != rDataArrCnt)
return false;
// Compare item operator;
if (lDataArrCnt > 1) {
std::string lOp, rOp;
- lItem.get(NULL, CT_RULE_EVENT_OPERATOR, &lOp);
- rItem.get(NULL, CT_RULE_EVENT_OPERATOR, &rOp);
+ lItem.get(NULL, TRIG_RULE_EVENT_OPERATOR, &lOp);
+ rItem.get(NULL, TRIG_RULE_EVENT_OPERATOR, &rOp);
if (lOp.compare(rOp))
return false;
}
for (int i = 0; i < lDataArrCnt; i++) {
bool found = false;
Json lElem;
- lItem.getAt(NULL, CT_RULE_DATA_ARR, i, &lElem);
+ lItem.getAt(NULL, TRIG_RULE_DATA_ARR, i, &lElem);
for (int j = 0; j < lDataArrCnt; j++) {
Json rElem;
- rItem.getAt(NULL, CT_RULE_DATA_ARR, j, &rElem);
+ rItem.getAt(NULL, TRIG_RULE_DATA_ARR, j, &rElem);
if (__ruleDataArrElemEquals(lElem, rElem)) {
found = true;
{
// Compare event
Json lEvent, rEvent;
- lRule.get(NULL, CT_RULE_EVENT, &lEvent);
- rRule.get(NULL, CT_RULE_EVENT, &rEvent);
+ lRule.get(NULL, TRIG_RULE_EVENT, &lEvent);
+ rRule.get(NULL, TRIG_RULE_EVENT, &rEvent);
if (!__ruleItemEquals(lEvent, rEvent))
return false;
// Compare conditions
int lCondCnt, rCondCnt;
- lCondCnt = lRule.getSize(NULL, CT_RULE_CONDITION);
- rCondCnt = rRule.getSize(NULL, CT_RULE_CONDITION);
+ lCondCnt = lRule.getSize(NULL, TRIG_RULE_CONDITION);
+ rCondCnt = rRule.getSize(NULL, TRIG_RULE_CONDITION);
if (lCondCnt != rCondCnt)
return false;
if (lCondCnt > 1) {
std::string lOp, rOp;
- lRule.get(NULL, CT_RULE_OPERATOR, &lOp);
- rRule.get(NULL, CT_RULE_OPERATOR, &rOp);
+ lRule.get(NULL, TRIG_RULE_OPERATOR, &lOp);
+ rRule.get(NULL, TRIG_RULE_OPERATOR, &rOp);
if (lOp.compare(rOp))
return false;
}
for (int i = 0; i < lCondCnt; i++) {
bool found = false;
Json lCond;
- lRule.getAt(NULL, CT_RULE_CONDITION, i, &lCond);
+ lRule.getAt(NULL, TRIG_RULE_CONDITION, i, &lCond);
for (int j = 0; j < lCondCnt; j++) {
Json rCond;
- rRule.getAt(NULL, CT_RULE_CONDITION, j, &rCond);
+ rRule.getAt(NULL, TRIG_RULE_CONDITION, j, &rCond);
if (__ruleItemEquals(lCond, rCond)) {
found = true;
// Compare action
Json lAction, rAction;
- lRule.get(NULL, CT_RULE_ACTION, &lAction);
- rRule.get(NULL, CT_RULE_ACTION, &rAction);
+ lRule.get(NULL, TRIG_RULE_ACTION, &lAction);
+ rRule.get(NULL, TRIG_RULE_ACTION, &rAction);
if (lAction != rAction)
return false;
IF_FAIL_RETURN_TAG(ret, false, _E, "Query rowId, details by package id failed");
Json rDetails;
- rule.get(NULL, CT_RULE_DETAILS, &rDetails);
+ rule.get(NULL, TRIG_RULE_DETAILS, &rDetails);
std::string rDesc;
- rule.get(NULL, CT_RULE_DESCRIPTION, &rDesc);
+ rule.get(NULL, TRIG_RULE_DESCRIPTION, &rDesc);
std::vector<Json>::iterator vecEnd = record.end();
for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
int RuleManager::__verifyRule(Json& rule, const char* creator)
{
Json details;
- rule.get(NULL, CT_RULE_DETAILS, &details);
+ rule.get(NULL, TRIG_RULE_DETAILS, &details);
std::string eventName;
- rule.get(CT_RULE_DETAILS "." CT_RULE_EVENT, CT_RULE_EVENT_ITEM, &eventName);
+ rule.get(TRIG_RULE_DETAILS "." TRIG_RULE_EVENT, TRIG_RULE_EVENT_ITEM, &eventName);
ContextMonitor* ctxMonitor = ContextMonitor::getInstance();
IF_FAIL_RETURN_TAG(ctxMonitor, ERR_OUT_OF_MEMORY, _E, "Memory allocation failed");
}
Json it;
- for (int i = 0; rule.getAt(CT_RULE_DETAILS, CT_RULE_CONDITION, i, &it); i++) {
+ for (int i = 0; rule.getAt(TRIG_RULE_DETAILS, TRIG_RULE_CONDITION, i, &it); i++) {
std::string condName;
- it.get(NULL, CT_RULE_CONDITION_ITEM, &condName);
+ it.get(NULL, TRIG_RULE_CONDITION_ITEM, &condName);
IF_FAIL_RETURN_TAG(ctxMonitor->isSupported(condName), ERR_NOT_SUPPORTED, _I, "Condition(%s) is not supported", condName.c_str());
// Check if duplicated rule exits
if ((rid = __getDuplicatedRuleId(pkgId, rule)) > 0) {
// Save rule id
- ruleId->set(NULL, CT_RULE_ID, rid);
+ ruleId->set(NULL, TRIG_KEY_RULE_ID, rid);
_D("Duplicated rule found");
return ERR_NONE;
}
Json record;
std::string description;
Json details;
- rule.get(NULL, CT_RULE_DESCRIPTION, &description);
- rule.get(NULL, CT_RULE_DETAILS, &details);
+ rule.get(NULL, TRIG_RULE_DESCRIPTION, &description);
+ rule.get(NULL, TRIG_RULE_DETAILS, &details);
record.set(NULL, "creator", creator);
if (pkgId) {
record.set(NULL, "packageId", pkgId);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Insert rule to db failed");
// Save rule id
- ruleId->set(NULL, CT_RULE_ID, rid);
+ ruleId->set(NULL, TRIG_KEY_RULE_ID, rid);
_D("Add rule%d succeeded", (int)rid);
return ERR_NONE;
std::string description;
record[0].get(NULL, "description", &description);
- (*requestResult).set(NULL, CT_RULE_ID, ruleId);
- (*requestResult).set(NULL, CT_RULE_DESCRIPTION, description);
+ (*requestResult).set(NULL, TRIG_KEY_RULE_ID, ruleId);
+ (*requestResult).set(NULL, TRIG_RULE_DESCRIPTION, description);
return ERR_NONE;
}
int RuleManager::getRuleIds(std::string pkgId, Json* requestResult)
{
- (*requestResult) = "{ \"" CT_RULE_ARRAY_ENABLED "\" : [ ] , \"" CT_RULE_ARRAY_DISABLED "\" : [ ] }";
+ (*requestResult) = "{ \"" TRIG_KEY_ENABLED_IDS "\" : [ ] , \"" TRIG_KEY_DISABLED_IDS "\" : [ ] }";
std::string q = "SELECT rowId, status FROM ContextTriggerRule WHERE (packageId = '";
q += pkgId;
elem.get(NULL, "status", &status);
if (status >= 1) {
- (*requestResult).append(NULL, CT_RULE_ARRAY_ENABLED, __stringToInt(id));
+ (*requestResult).append(NULL, TRIG_KEY_ENABLED_IDS, __stringToInt(id));
} else if (status == 0) {
- (*requestResult).append(NULL, CT_RULE_ARRAY_DISABLED, __stringToInt(id));
+ (*requestResult).append(NULL, TRIG_KEY_DISABLED_IDS, __stringToInt(id));
}
}
#include <sstream>
#include <Types.h>
-#include <context_trigger_types_internal.h>
+#include <TriggerTypes.h>
#include "../ContextManager.h"
#include "RuleManager.h"
#include "TemplateManager.h"
std::string optStr;
std::string attrStr;
- tmpl->get(NULL, TYPE_OPTION_STR, &optStr);
- tmpl->get(NULL, TYPE_ATTR_STR, &attrStr);
+ tmpl->get(NULL, TRIG_TMPL_KEY_OPTION, &optStr);
+ tmpl->get(NULL, TRIG_TMPL_KEY_ATTRIBUTE, &attrStr);
Json opt = optStr;
Json attr = attrStr;
- tmpl->set(NULL, TYPE_OPTION_STR, opt);
- tmpl->set(NULL, TYPE_ATTR_STR, attr);
+ tmpl->set(NULL, TRIG_TMPL_KEY_OPTION, opt);
+ tmpl->set(NULL, TRIG_TMPL_KEY_ATTRIBUTE, attr);
return ERR_NONE;
}
*/
#include <context_trigger.h>
-#include <context_trigger_types_internal.h>
+#include <TriggerRuleTypes.h>
#include <Types.h>
+#include <ProviderTypes.h>
#include <TimerManager.h>
#include "Timer.h"
-#define TIMER_DAY_OF_WEEK "DayOfWeek"
-#define TIMER_TIME_OF_DAY "TimeOfDay"
-
using namespace ctx;
using namespace ctx::trigger;
int result = 0;
std::string key_op;
- if (!dayInfo.get(NULL, CT_RULE_DATA_KEY_OPERATOR, &key_op)) {
+ if (!dayInfo.get(NULL, TRIG_RULE_DATA_KEY_OPERATOR, &key_op)) {
result = TimerManager::dowToInt(DOW_EVERYDAY);
return result;
}
}
std::string tmp_d;
- for (int i = 0; dayInfo.getAt(NULL, CT_RULE_DATA_VALUE_ARR, i, &tmp_d); i++) {
+ for (int i = 0; dayInfo.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, i, &tmp_d); i++) {
int dow = TimerManager::dowToInt(tmp_d);
std::string op;
- dayInfo.getAt(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR, i, &op);
+ dayInfo.getAt(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, i, &op);
if (op.compare(CONTEXT_TRIGGER_NOT_EQUAL_TO) == 0) {
dow = TimerManager::dowToInt(DOW_EVERYDAY) & ~dow;
void timer::handleTimerEvent(Json& rule)
{
Json event;
- rule.get(NULL, CT_RULE_EVENT, &event);
+ rule.get(NULL, TRIG_RULE_EVENT, &event);
std::string eventName;
- event.get(NULL, CT_RULE_EVENT_ITEM, &eventName);
- if (eventName.compare(CT_EVENT_TIME) != 0) {
+ event.get(NULL, TRIG_RULE_EVENT_ITEM, &eventName);
+ if (eventName.compare(SUBJ_STATE_ALARM) != 0) {
return;
}
Json dayInfo;
Json it;
int dow;
- for (int i = 0; event.getAt(NULL, CT_RULE_DATA_ARR, i, &it); i++) {
+ for (int i = 0; event.getAt(NULL, TRIG_RULE_DATA_ARR, i, &it); i++) {
std::string key;
- it.get(NULL, CT_RULE_DATA_KEY, &key);
+ it.get(NULL, TRIG_RULE_DATA_KEY, &key);
- if (key.compare(TIMER_DAY_OF_WEEK) == 0) {
+ if (key.compare(KEY_DAY_OF_WEEK) == 0) {
dow = __arrangeDayOfWeek(it);
- dayInfo.set(NULL, CT_RULE_DATA_KEY, TIMER_DAY_OF_WEEK);
- dayInfo.set(NULL, CT_RULE_DATA_KEY_OPERATOR, "or");
+ dayInfo.set(NULL, TRIG_RULE_DATA_KEY, KEY_DAY_OF_WEEK);
+ dayInfo.set(NULL, TRIG_RULE_DATA_KEY_OPERATOR, "or");
for (int j = 0; j < DAYS_PER_WEEK; j++) {
int d = 0x01 << j;
if (dow & d) {
std::string day = TimerManager::dowToStr(d);
- dayInfo.append(NULL, CT_RULE_DATA_VALUE_ARR, day);
- dayInfo.append(NULL, CT_RULE_DATA_VALUE_OPERATOR_ARR, CONTEXT_TRIGGER_EQUAL_TO);
+ dayInfo.append(NULL, TRIG_RULE_DATA_VALUE_ARR, day);
+ dayInfo.append(NULL, TRIG_RULE_DATA_VALUE_OPERATOR_ARR, CONTEXT_TRIGGER_EQUAL_TO);
// Set option
- event.append(CT_RULE_EVENT_OPTION, TIMER_DAY_OF_WEEK, day);
+ event.append(TRIG_RULE_EVENT_OPTION, KEY_DAY_OF_WEEK, day);
}
}
- event.setAt(NULL, CT_RULE_DATA_ARR, i, dayInfo);
- } else if (key.compare(TIMER_TIME_OF_DAY) == 0) {
+ event.setAt(NULL, TRIG_RULE_DATA_ARR, i, dayInfo);
+ } else if (key.compare(KEY_TIME_OF_DAY) == 0) {
int time;
- for (int j = 0; it.getAt(NULL, CT_RULE_DATA_VALUE_ARR, j, &time); j++) {
- event.append(CT_RULE_EVENT_OPTION, TIMER_TIME_OF_DAY, time);
+ for (int j = 0; it.getAt(NULL, TRIG_RULE_DATA_VALUE_ARR, j, &time); j++) {
+ event.append(TRIG_RULE_EVENT_OPTION, KEY_TIME_OF_DAY, time);
}
}
}
- rule.set(NULL, CT_RULE_EVENT, event);
+ rule.set(NULL, TRIG_RULE_EVENT, event);
}
*/
#include <Types.h>
-#include <context_trigger_types_internal.h>
+#include <TriggerTypes.h>
#include "Trigger.h"
#include "ContextMonitor.h"
#include "TemplateManager.h"
bool Trigger::assignRequest(RequestInfo* request)
{
std::string subject = request->getSubject();
- if (subject != CONTEXT_TRIGGER_SUBJECT_ADD && subject != CONTEXT_TRIGGER_SUBJECT_REMOVE &&
- subject != CONTEXT_TRIGGER_SUBJECT_ENABLE && subject != CONTEXT_TRIGGER_SUBJECT_DISABLE &&
- subject != CONTEXT_TRIGGER_SUBJECT_GET && subject != CONTEXT_TRIGGER_SUBJECT_GET_RULE_IDS &&
- subject != CONTEXT_TRIGGER_SUBJECT_GET_TEMPLATE) {
+ if (subject != SUBJ_TRIGGER_ADD && subject != SUBJ_TRIGGER_REMOVE &&
+ subject != SUBJ_TRIGGER_ENABLE && subject != SUBJ_TRIGGER_DISABLE &&
+ subject != SUBJ_TRIGGER_GET && subject != SUBJ_TRIGGER_GET_RULE_IDS &&
+ subject != SUBJ_TRIGGER_GET_TEMPLATE) {
return false;
}
_D("Request is %s", reqSubj);
std::string subject(reqSubj);
- if (subject == CONTEXT_TRIGGER_SUBJECT_ADD) {
+ if (subject == SUBJ_TRIGGER_ADD) {
__addRule(request);
- } else if (subject == CONTEXT_TRIGGER_SUBJECT_REMOVE) {
+ } else if (subject == SUBJ_TRIGGER_REMOVE) {
__removeRule(request);
- } else if (subject == CONTEXT_TRIGGER_SUBJECT_ENABLE) {
+ } else if (subject == SUBJ_TRIGGER_ENABLE) {
__enableRule(request);
- } else if (subject == CONTEXT_TRIGGER_SUBJECT_DISABLE) {
+ } else if (subject == SUBJ_TRIGGER_DISABLE) {
__disableRule(request);
- } else if (subject == CONTEXT_TRIGGER_SUBJECT_GET) {
+ } else if (subject == SUBJ_TRIGGER_GET) {
__getRuleById(request);
- } else if (subject == CONTEXT_TRIGGER_SUBJECT_GET_RULE_IDS) {
+ } else if (subject == SUBJ_TRIGGER_GET_RULE_IDS) {
__getRuleIds(request);
- } else if (subject == CONTEXT_TRIGGER_SUBJECT_GET_TEMPLATE) {
+ } else if (subject == SUBJ_TRIGGER_GET_TEMPLATE) {
__getTemplate(request);
} else {
_E("Invalid request");
const char* pkgId = request->getPackageId();
Json ruleId = request->getDescription();
- ruleId.get(NULL, CT_RULE_ID, &id);
+ ruleId.get(NULL, TRIG_KEY_RULE_ID, &id);
error = __ruleMgr->checkRule((pkgId)? pkgId : "", id);
if (error != ERR_NONE) {
const char* pkgId = request->getPackageId();
Json ruleId = request->getDescription();
- ruleId.get(NULL, CT_RULE_ID, &id);
+ ruleId.get(NULL, TRIG_KEY_RULE_ID, &id);
error = __ruleMgr->checkRule((pkgId)? pkgId : "", id);
if (error != ERR_NONE) {
const char* pkgId = request->getPackageId();
Json ruleId = request->getDescription();
- ruleId.get(NULL, CT_RULE_ID, &id);
+ ruleId.get(NULL, TRIG_KEY_RULE_ID, &id);
error = __ruleMgr->checkRule((pkgId)? pkgId : "", id);
if (error != ERR_NONE) {
Json option = request->getDescription();
int id;
- option.get(NULL, CT_RULE_ID, &id);
+ option.get(NULL, TRIG_KEY_RULE_ID, &id);
const char* pkgId = request->getPackageId();
Json option = request->getDescription();
std::string name;
- option.get(NULL, SUBJECT_STR, &name);
+ option.get(NULL, TRIG_TMPL_KEY_SUBJECT, &name);
TemplateManager* tmplMgr = TemplateManager::getInstance();
if (!tmplMgr) {