Use modified names of keys & types' definition

Change-Id: Ic03c7ec1e9b81ceb2af2798bcd1cf00fd59810ca
Signed-off-by: Somin Kim <somin926.kim@samsung.com>

diff --git a/src/trigger/ActionManager.cpp b/src/trigger/ActionManager.cpp
index 5601fb2..34d1dc2 100644 (file)
--- a/src/trigger/ActionManager.cpp
+++ b/src/trigger/ActionManager.cpp
@@ -23,7 +23,7 @@
 #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"
 
@@ -34,13 +34,13 @@ static void __triggerActionDbusCall(ctx::Json& action);
 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);
        }
 }
@@ -49,7 +49,7 @@ void __triggerActionAppControl(ctx::Json& 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) {
@@ -85,7 +85,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        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);
@@ -93,7 +93,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        }
 
        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);
@@ -101,7 +101,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        }
 
        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);
@@ -113,7 +113,7 @@ void __triggerActionNotification(ctx::Json& action, std::string pkgId)
        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");
@@ -187,19 +187,19 @@ void __triggerActionDbusCall(ctx::Json& action)
        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, &param);
+       action.get(NULL, TRIG_RULE_ACTION_DBUS_PARAMETER, &param);
 
        ctx::DBusServer::call(busName, object, iface, method, param);
 }

diff --git a/src/trigger/FactTypes.h b/src/trigger/FactTypes.h
index 7a0c41f..fe50f11 100644 (file)
--- a/src/trigger/FactTypes.h
+++ b/src/trigger/FactTypes.h
@@ -17,10 +17,10 @@
 #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_ */

diff --git a/src/trigger/Rule.cpp b/src/trigger/Rule.cpp
index 04c6a8e..abffa68 100644 (file)
--- a/src/trigger/Rule.cpp
+++ b/src/trigger/Rule.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include <context_trigger_types_internal.h>
+#include <TriggerRuleTypes.h>
 #include "Rule.h"
 #include "ActionManager.h"
 #include "RuleEvaluator.h"
@@ -42,20 +42,20 @@ Rule::Rule(int i, Json& d, const char* p, RuleManager* rm) :
 
        // 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();
 }
 
@@ -109,9 +109,9 @@ bool Rule::__setConditionOptionBasedOnEvent(Json& option)
 
                        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());
@@ -139,9 +139,9 @@ void Rule::onEventReceived(std::string name, Json option, Json data)
        _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();
@@ -171,12 +171,12 @@ void Rule::onConditionReceived(std::string name, Json option, Json data)
 
        // 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();
        }
 }

diff --git a/src/trigger/Rule.h b/src/trigger/Rule.h
index 19323e4..bb90926 100644 (file)
--- a/src/trigger/Rule.h
+++ b/src/trigger/Rule.h
@@ -34,11 +34,11 @@ namespace trigger {
                                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();
                                }
                        };

diff --git a/src/trigger/RuleEvaluator.cpp b/src/trigger/RuleEvaluator.cpp
index 66a55c6..1f85688 100644 (file)
--- a/src/trigger/RuleEvaluator.cpp
+++ b/src/trigger/RuleEvaluator.cpp
@@ -16,13 +16,10 @@
 
 #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 "<="
@@ -76,19 +73,19 @@ bool RuleEvaluator::__replaceDataReferences(Json& ruleDataArr, Json eventFactDat
        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());
                }
@@ -113,7 +110,7 @@ bool RuleEvaluator::__replaceOptionReferences(Json& ruleOption, Json eventFactDa
                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;
                }
 
@@ -135,20 +132,20 @@ bool RuleEvaluator::__replaceEventReferences(Json& rule, Json& fact)
 {
        // 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);
                }
        }
@@ -159,14 +156,14 @@ bool RuleEvaluator::__replaceEventReferences(Json& rule, Json& fact)
 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) {
@@ -181,14 +178,14 @@ bool RuleEvaluator::__evaluateDataString(Json& ruleDataArr, std::string factValS
 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);
@@ -205,24 +202,24 @@ bool RuleEvaluator::__evaluateDataInt(Json& ruleDataArr, int factValInt)
 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());
@@ -242,8 +239,8 @@ bool RuleEvaluator::__evaluateRuleEvent(Json& rule, Json& fact)
 {
        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);
 }
@@ -251,13 +248,13 @@ bool RuleEvaluator::__evaluateRuleEvent(Json& rule, Json& fact)
 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;
                }
@@ -265,8 +262,8 @@ Json RuleEvaluator::__getConditionFact(Json& ruleCond, Json& fact)
                // 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;
                }
@@ -282,10 +279,10 @@ bool RuleEvaluator::__evaluateRuleCondition(Json& rule, Json& fact)
        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) {
@@ -312,7 +309,7 @@ bool RuleEvaluator::evaluateRule(Json rule, Json fact)
        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");

diff --git a/src/trigger/RuleManager.cpp b/src/trigger/RuleManager.cpp
index 5a35d39..8b4cca7 100644 (file)
--- a/src/trigger/RuleManager.cpp
+++ b/src/trigger/RuleManager.cpp
@@ -15,7 +15,8 @@
  */
 
 #include <sstream>
-#include <context_trigger_types_internal.h>
+#include <TriggerTypes.h>
+#include <TriggerRuleTypes.h>
 #include <package_manager.h>
 #include <Json.h>
 #include "RuleManager.h"
@@ -279,23 +280,23 @@ bool RuleManager::__reenableRule(void)
 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;
        }
@@ -303,13 +304,13 @@ bool RuleManager::__ruleDataArrElemEquals(Json& lElem, Json& rElem)
        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;
@@ -327,29 +328,29 @@ bool RuleManager::__ruleItemEquals(Json& lItem, Json& rItem)
 {
        // 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;
        }
@@ -357,11 +358,11 @@ bool RuleManager::__ruleItemEquals(Json& lItem, Json& rItem)
        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;
@@ -379,22 +380,22 @@ bool RuleManager::__ruleEquals(Json& lRule, Json& rRule)
 {
        // 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;
        }
@@ -402,11 +403,11 @@ bool RuleManager::__ruleEquals(Json& lRule, Json& rRule)
        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;
@@ -419,8 +420,8 @@ bool RuleManager::__ruleEquals(Json& lRule, Json& rRule)
 
        // 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;
 
@@ -438,9 +439,9 @@ int64_t RuleManager::__getDuplicatedRuleId(std::string pkgId, Json& rule)
        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) {
@@ -481,10 +482,10 @@ int64_t RuleManager::__getDuplicatedRuleId(std::string pkgId, Json& rule)
 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");
@@ -499,9 +500,9 @@ int RuleManager::__verifyRule(Json& rule, const char* creator)
        }
 
        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());
 
@@ -526,7 +527,7 @@ int RuleManager::addRule(std::string creator, const char* pkgId, Json rule, Json
        // 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;
        }
@@ -535,8 +536,8 @@ int RuleManager::addRule(std::string creator, const char* pkgId, Json rule, Json
        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);
@@ -551,7 +552,7 @@ int RuleManager::addRule(std::string creator, const char* pkgId, Json rule, Json
        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;
@@ -745,15 +746,15 @@ int RuleManager::getRuleById(std::string pkgId, int ruleId, Json* requestResult)
        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;
@@ -773,9 +774,9 @@ int RuleManager::getRuleIds(std::string pkgId, Json* requestResult)
                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));
                }
        }
 

diff --git a/src/trigger/TemplateManager.cpp b/src/trigger/TemplateManager.cpp
index 2f77962..65ddc39 100644 (file)
--- a/src/trigger/TemplateManager.cpp
+++ b/src/trigger/TemplateManager.cpp
@@ -16,7 +16,7 @@
 
 #include <sstream>
 #include <Types.h>
-#include <context_trigger_types_internal.h>
+#include <TriggerTypes.h>
 #include "../ContextManager.h"
 #include "RuleManager.h"
 #include "TemplateManager.h"
@@ -183,14 +183,14 @@ int TemplateManager::getTemplate(std::string &subject, Json* tmpl)
 
        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;
 }

diff --git a/src/trigger/Timer.cpp b/src/trigger/Timer.cpp
index 967d7f2..33f4721 100644 (file)
--- a/src/trigger/Timer.cpp
+++ b/src/trigger/Timer.cpp
@@ -15,14 +15,12 @@
  */
 
 #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;
 
@@ -31,7 +29,7 @@ static int __arrangeDayOfWeek(Json dayInfo)
        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;
        }
@@ -41,10 +39,10 @@ static int __arrangeDayOfWeek(Json dayInfo)
        }
 
        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;
@@ -64,46 +62,46 @@ static int __arrangeDayOfWeek(Json dayInfo)
 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);
 }

diff --git a/src/trigger/Trigger.cpp b/src/trigger/Trigger.cpp
index 244ac1f..bb3c7aa 100644 (file)
--- a/src/trigger/Trigger.cpp
+++ b/src/trigger/Trigger.cpp
@@ -15,7 +15,7 @@
  */
 
 #include <Types.h>
-#include <context_trigger_types_internal.h>
+#include <TriggerTypes.h>
 #include "Trigger.h"
 #include "ContextMonitor.h"
 #include "TemplateManager.h"
@@ -62,10 +62,10 @@ void Trigger::release()
 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;
        }
 
@@ -80,19 +80,19 @@ void Trigger::__processRequest(RequestInfo* request)
        _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");
@@ -153,7 +153,7 @@ void Trigger::__removeRule(RequestInfo* 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) {
@@ -180,7 +180,7 @@ void Trigger::__enableRule(RequestInfo* 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) {
@@ -207,7 +207,7 @@ void Trigger::__disableRule(RequestInfo* 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) {
@@ -232,7 +232,7 @@ void Trigger::__getRuleById(RequestInfo* request)
 
        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();
 
@@ -262,7 +262,7 @@ void Trigger::__getTemplate(RequestInfo* request)
 
        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) {