return true;
}
-bool ctx::ClientRequest::reply(int error, ctx::Json& requestResult)
+bool ctx::ClientRequest::reply(int error, ctx::CtxJson1& requestResult)
{
IF_FAIL_RETURN(__invocation, true);
IF_FAIL_RETURN(error != ERR_NONE || __type != REQ_READ_SYNC, true);
return true;
}
-bool ctx::ClientRequest::reply(int error, ctx::Json& requestResult, ctx::Json& dataRead)
+bool ctx::ClientRequest::reply(int error, ctx::CtxJson1& requestResult, ctx::CtxJson1& dataRead)
{
if (__invocation == NULL) {
return publish(error, dataRead);
return true;
}
-bool ctx::ClientRequest::publish(int error, ctx::Json& data)
+bool ctx::ClientRequest::publish(int error, ctx::CtxJson1& data)
{
DBusServer::publish(__dbusSender, __reqId, __subject, error, data.str());
return true;
const char* getPackageId();
const char* getClient();
bool reply(int error);
- bool reply(int error, ctx::Json &requestResult);
- bool reply(int error, ctx::Json &requestResult, ctx::Json &dataRead);
- bool publish(int error, ctx::Json &data);
+ bool reply(int error, ctx::CtxJson1 &requestResult);
+ bool reply(int error, ctx::CtxJson1 &requestResult, ctx::CtxJson1 &dataRead);
+ bool publish(int error, ctx::CtxJson1 &data);
private:
Credentials *__credentials;
#include <Types.h>
#include <DBusTypes.h>
-#include <Json.h>
+#include <CtxJson1.h>
#include <ContextProvider.h>
#include <CustomRegister.h>
return handle->isAllowed(creds);
}
-void ContextManager::__publish(const char* subject, Json &option, int error, Json &dataUpdated)
+void ContextManager::__publish(const char* subject, CtxJson1 &option, int error, CtxJson1 &dataUpdated)
{
_I("Publishing '%s'", subject);
_J("Option", option);
handle->publish(option, error, dataUpdated);
}
-void ContextManager::__replyToRead(const char* subject, Json &option, int error, Json &dataRead)
+void ContextManager::__replyToRead(const char* subject, CtxJson1 &option, int error, CtxJson1 &dataRead)
{
_I("Sending data of '%s'", subject);
_J("Option", option);
ContextManager *mgr;
std::string subject;
int error;
- Json option;
- Json data;
- PublishedData(int t, ContextManager *m, const char* s, Json& o, int e, Json& d)
+ CtxJson1 option;
+ CtxJson1 data;
+ PublishedData(int t, ContextManager *m, const char* s, CtxJson1& o, int e, CtxJson1& d)
: type(t), mgr(m), subject(s), error(e)
{
option = o.str();
return FALSE;
}
-bool ContextManager::publish(const char* subject, Json& option, int error, Json& dataUpdated)
+bool ContextManager::publish(const char* subject, CtxJson1& option, int error, CtxJson1& dataUpdated)
{
IF_FAIL_RETURN_TAG(subject, false, _E, "Invalid parameter");
return true;
}
-bool ContextManager::replyToRead(const char* subject, Json& option, int error, Json& dataRead)
+bool ContextManager::replyToRead(const char* subject, CtxJson1& option, int error, CtxJson1& dataRead)
{
IF_FAIL_RETURN_TAG(subject, false, _E, "Invalid parameter");
return true;
}
-bool ContextManager::popTriggerTemplate(std::string &subject, int &operation, Json &attribute, Json &option)
+bool ContextManager::popTriggerTemplate(std::string &subject, int &operation, CtxJson1 &attribute, CtxJson1 &option)
{
return ProviderLoader::popTriggerTemplate(subject, operation, attribute, option);
}
/* Only for explicit request of custom provider */
-bool ContextManager::registerCustomProvider(const char* subject, int operation, ctx::Json &attribute, ctx::Json &option, const char* owner)
+bool ContextManager::registerCustomProvider(const char* subject, int operation, ctx::CtxJson1 &attribute, ctx::CtxJson1 &option, const char* owner)
{
IF_FAIL_RETURN_TAG(ProviderHandler::getInstance(subject, true), false, _E, "Register provider failed");
bool isAllowed(const Credentials *creds, const char *subject);
/* From the interface class */
- bool publish(const char *subject, ctx::Json &option, int error, ctx::Json &dataUpdated);
- bool replyToRead(const char *subject, ctx::Json &option, int error, ctx::Json &dataRead);
- bool registerCustomProvider(const char* subject, int operation, ctx::Json &attribute, ctx::Json &option, const char* owner);
+ bool publish(const char *subject, ctx::CtxJson1 &option, int error, ctx::CtxJson1 &dataUpdated);
+ bool replyToRead(const char *subject, ctx::CtxJson1 &option, int error, ctx::CtxJson1 &dataRead);
+ bool registerCustomProvider(const char* subject, int operation, ctx::CtxJson1 &attribute, ctx::CtxJson1 &option, const char* owner);
bool unregisterCustomProvider(const char* subject);
- bool popTriggerTemplate(std::string &subject, int &operation, Json &attribute, Json &option);
+ bool popTriggerTemplate(std::string &subject, int &operation, CtxJson1 &attribute, CtxJson1 &option);
private:
ContextManager();
static gboolean __threadSwitcher(gpointer data);
- void __publish(const char *subject, ctx::Json &option, int error, ctx::Json &dataUpdated);
- void __replyToRead(const char *subject, ctx::Json &option, int error, ctx::Json &dataRead);
+ void __publish(const char *subject, ctx::CtxJson1 &option, int error, ctx::CtxJson1 &dataUpdated);
+ void __replyToRead(const char *subject, ctx::CtxJson1 &option, int error, ctx::CtxJson1 &dataRead);
friend class Server;
{
_I(CYAN("'%s' subscribes '%s' (RID-%d)"), request->getClient(), __subject.c_str(), request->getId());
- Json requestResult;
+ CtxJson1 requestResult;
int error = __provider->subscribe(request->getDescription().str(), &requestResult);
if (!request->reply(error, requestResult) || error != ERR_NONE) {
{
_I(CYAN("'%s' reads '%s' (RID-%d)"), request->getClient(), __subject.c_str(), request->getId());
- Json requestResult;
+ CtxJson1 requestResult;
int error = __provider->read(request->getDescription().str(), &requestResult);
if (!request->reply(error, requestResult) || error != ERR_NONE) {
{
_I(CYAN("'%s' writes '%s' (RID-%d)"), request->getClient(), __subject.c_str(), request->getId());
- Json requestResult;
+ CtxJson1 requestResult;
request->getDescription().set(NULL, KEY_CLIENT_PKG_ID, request->getPackageId()? request->getPackageId() : "SYSTEM");
int error = __provider->write(request->getDescription(), &requestResult);
__scheduleToDelete();
}
-bool ProviderHandler::publish(Json &option, int error, Json &dataUpdated)
+bool ProviderHandler::publish(CtxJson1 &option, int error, CtxJson1 &dataUpdated)
{
auto end = __subscribeRequests.end();
auto target = __findRequest(__subscribeRequests.begin(), end, option);
return true;
}
-bool ProviderHandler::replyToRead(Json &option, int error, Json &dataRead)
+bool ProviderHandler::replyToRead(CtxJson1 &option, int error, CtxJson1 &dataRead)
{
auto end = __readRequests.end();
auto target = __findRequest(__readRequests.begin(), end, option);
auto prev = target;
- Json dummy;
+ CtxJson1 dummy;
while (target != end) {
(*target)->reply(error, dummy, dataRead);
}
ProviderHandler::RequestList::iterator
-ProviderHandler::__findRequest(RequestList &reqList, Json &option)
+ProviderHandler::__findRequest(RequestList &reqList, CtxJson1 &option)
{
return __findRequest(reqList.begin(), reqList.end(), option);
}
}
ProviderHandler::RequestList::iterator
-ProviderHandler::__findRequest(RequestList::iterator begin, RequestList::iterator end, Json &option)
+ProviderHandler::__findRequest(RequestList::iterator begin, RequestList::iterator end, CtxJson1 &option)
{
for (auto it = begin; it != end; ++it) {
if (option == (*it)->getDescription()) {
void read(RequestInfo *request);
void write(RequestInfo *request);
- bool publish(ctx::Json &option, int error, ctx::Json &dataUpdated);
- bool replyToRead(ctx::Json &option, int error, ctx::Json &dataRead);
+ bool publish(ctx::CtxJson1 &option, int error, ctx::CtxJson1 &dataUpdated);
+ bool replyToRead(ctx::CtxJson1 &option, int error, ctx::CtxJson1 &dataRead);
static ProviderHandler* getInstance(std::string subject, bool force);
static void purge();
bool __idle();
void __scheduleToDelete();
- RequestList::iterator __findRequest(RequestList &reqList, Json &option);
+ RequestList::iterator __findRequest(RequestList &reqList, CtxJson1 &option);
RequestList::iterator __findRequest(RequestList &reqList, std::string client, int reqId);
- RequestList::iterator __findRequest(RequestList::iterator begin, RequestList::iterator end, Json &option);
+ RequestList::iterator __findRequest(RequestList::iterator begin, RequestList::iterator end, CtxJson1 &option);
static gboolean __deletor(gpointer data);
return true;
}
-bool ProviderLoader::popTriggerTemplate(std::string &subject, int &operation, Json &attribute, Json &option)
+bool ProviderLoader::popTriggerTemplate(std::string &subject, int &operation, CtxJson1 &attribute, CtxJson1 &option)
{
static int i = 0;
static int size = ARRAY_SIZE(triggerTemplateList);
ContextProvider* load(const char *subject);
static bool init();
- static bool popTriggerTemplate(std::string &subject, int &operation, Json &attribute, Json &option);
+ static bool popTriggerTemplate(std::string &subject, int &operation, CtxJson1 &attribute, CtxJson1 &option);
private:
ContextProvider* __load(const char *soPath, const char *subject);
return __subject.c_str();
}
-ctx::Json& ctx::RequestInfo::getDescription()
+ctx::CtxJson1& ctx::RequestInfo::getDescription()
{
return __description;
}
#define _CONTEXT_REQUEST_INFO_H_
#include <string>
-#include <Json.h>
+#include <CtxJson1.h>
namespace ctx {
int getType();
int getId();
const char* getSubject();
- ctx::Json& getDescription();
+ ctx::CtxJson1& getDescription();
virtual const Credentials* getCredentials();
virtual const char* getPackageId();
/* TODO: remove this getClient() */
virtual const char* getClient();
virtual bool reply(int error) = 0;
- virtual bool reply(int error, ctx::Json &requestResult) = 0;
- virtual bool reply(int error, ctx::Json &requestResult, ctx::Json &dataRead) = 0;
- virtual bool publish(int error, ctx::Json &data) = 0;
+ virtual bool reply(int error, ctx::CtxJson1 &requestResult) = 0;
+ virtual bool reply(int error, ctx::CtxJson1 &requestResult, ctx::CtxJson1 &dataRead) = 0;
+ virtual bool publish(int error, ctx::CtxJson1 &data) = 0;
protected:
int __type;
int __reqId;
std::string __subject;
- ctx::Json __description;
+ ctx::CtxJson1 __description;
};
} /* namespace ctx */
return true;
}
-bool PolicyRequest::reply(int error, ctx::Json &requestResult)
+bool PolicyRequest::reply(int error, ctx::CtxJson1 &requestResult)
{
return true;
}
-bool PolicyRequest::reply(int error, ctx::Json &requestResult, ctx::Json &dataRead)
+bool PolicyRequest::reply(int error, ctx::CtxJson1 &requestResult, ctx::CtxJson1 &dataRead)
{
return true;
}
-bool PolicyRequest::publish(int error, ctx::Json &data)
+bool PolicyRequest::publish(int error, ctx::CtxJson1 &data)
{
return true;
}
const char* getClient();
bool reply(int error);
- bool reply(int error, ctx::Json &requestResult);
- bool reply(int error, ctx::Json &requestResult, ctx::Json &dataRead);
- bool publish(int error, ctx::Json &data);
+ bool reply(int error, ctx::CtxJson1 &requestResult);
+ bool reply(int error, ctx::CtxJson1 &requestResult, ctx::CtxJson1 &dataRead);
+ bool publish(int error, ctx::CtxJson1 &data);
};
} /* namespace ctx */
*/
#include <Types.h>
-#include <Json.h>
+#include <CtxJson1.h>
#include <app_control.h>
#include <app_control_internal.h>
#include <bundle.h>
using namespace ctx;
-static void __triggerActionAppControl(Json& action);
-static void __triggerActionNotification(Json& action, std::string pkgId);
-static void __triggerActionDbusCall(Json& action);
+static void __triggerActionAppControl(CtxJson1& action);
+static void __triggerActionNotification(CtxJson1& action, std::string pkgId);
+static void __triggerActionDbusCall(CtxJson1& action);
-void trigger::action_manager::triggerAction(Json& action, std::string pkgId)
+void trigger::action_manager::triggerAction(CtxJson1& action, std::string pkgId)
{
std::list<std::string> types;
action.getKeys(&types);
}
}
-void __triggerActionAppControl(Json& action)
+void __triggerActionAppControl(CtxJson1& action)
{
int error;
std::string appctlStr;
}
}
-void __triggerActionNotification(Json& action, std::string pkgId)
+void __triggerActionNotification(CtxJson1& action, std::string pkgId)
{
int error;
notification_h notification = notification_create(NOTIFICATION_TYPE_NOTI);
}
}
-void __triggerActionDbusCall(Json& action)
+void __triggerActionDbusCall(CtxJson1& action)
{
std::string busName, object, iface, method;
GVariant *param = NULL;
namespace ctx {
/* Forward Declaration */
- class Json;
+ class CtxJson1;
namespace trigger {
namespace action_manager {
- void triggerAction(Json& action, std::string pkgId);
+ void triggerAction(CtxJson1& action, std::string pkgId);
} /* namespace action_manager */
}
}
-int ContextMonitor::subscribe(int ruleId, std::string subject, Json option, IContextListener* listener)
+int ContextMonitor::subscribe(int ruleId, std::string subject, CtxJson1 option, IContextListener* listener)
{
int reqId = __subscribe(subject.c_str(), &option, listener);
IF_FAIL_RETURN_TAG(reqId > 0, reqId, _E, "Subscribe event failed");
return ERR_NONE;
}
-int ContextMonitor::__subscribe(const char* subject, Json* option, IContextListener* listener)
+int ContextMonitor::__subscribe(const char* subject, CtxJson1* option, IContextListener* listener)
{
IF_FAIL_RETURN(subject, ERR_INVALID_PARAMETER);
return rid;
}
-int ContextMonitor::unsubscribe(int ruleId, std::string subject, Json option, IContextListener* listener)
+int ContextMonitor::unsubscribe(int ruleId, std::string subject, CtxJson1 option, IContextListener* listener)
{
int rid = __findSub(REQ_SUBSCRIBE, subject.c_str(), &option);
if (rid < 0) {
__removeSub(REQ_SUBSCRIBE, subscriptionId);
}
-int ContextMonitor::read(std::string subject, Json option, IContextListener* listener)
+int ContextMonitor::read(std::string subject, CtxJson1 option, IContextListener* listener)
{
int reqId = __read(subject.c_str(), &option, listener);
IF_FAIL_RETURN_TAG(reqId > 0, ERR_OPERATION_FAILED, _E, "Read condition failed");
return ERR_NONE;
}
-int ContextMonitor::__read(const char* subject, Json* option, IContextListener* listener)
+int ContextMonitor::__read(const char* subject, CtxJson1* option, IContextListener* listener)
{
IF_FAIL_RETURN(subject, ERR_INVALID_PARAMETER);
return true;
}
-int ContextMonitor::__findSub(RequestType type, const char* subject, Json* option)
+int ContextMonitor::__findSub(RequestType type, const char* subject, CtxJson1* option)
{
// @return request id
std::map<int, SubscrInfo*>* map = (type == REQ_SUBSCRIBE)? &__subscrMap : &__readMap;
- Json jOpt;
+ CtxJson1 jOpt;
if (option) {
jOpt = *option;
}
return -1;
}
-bool ContextMonitor::__addSub(RequestType type, int sid, const char* subject, Json* option, IContextListener* listener)
+bool ContextMonitor::__addSub(RequestType type, int sid, const char* subject, CtxJson1* option, IContextListener* listener)
{
std::map<int, SubscrInfo*>* map = (type == REQ_SUBSCRIBE)? &__subscrMap : &__readMap;
return true;
}
-void ContextMonitor::__removeSub(RequestType type, const char* subject, Json* option)
+void ContextMonitor::__removeSub(RequestType type, const char* subject, CtxJson1* option)
{
std::map<int, SubscrInfo*>* map = (type == REQ_SUBSCRIBE)? &__subscrMap : &__readMap;
- Json jOpt;
+ CtxJson1 jOpt;
if (option) {
jOpt = *option;
}
return info->listenerList.size();
}
-void ContextMonitor::replyResult(int reqId, int error, Json* requestResult)
+void ContextMonitor::replyResult(int reqId, int error, CtxJson1* requestResult)
{
_D("Request result received: %d", reqId);
__lastErr = error;
}
-void ContextMonitor::replyResult(int reqId, int error, const char* subject, Json* option, Json* fact)
+void ContextMonitor::replyResult(int reqId, int error, const char* subject, CtxJson1* option, CtxJson1* fact)
{
_D(YELLOW("Condition received: subject(%s), option(%s), fact(%s)"), subject, option->str().c_str(), fact->str().c_str());
__removeSub(REQ_READ, reqId);
}
-void ContextMonitor::publishFact(int reqId, int error, const char* subject, Json* option, Json* fact)
+void ContextMonitor::publishFact(int reqId, int error, const char* subject, CtxJson1* option, CtxJson1* fact)
{
_D(YELLOW("Event received: subject(%s), option(%s), fact(%s)"), subject, option->str().c_str(), fact->str().c_str());
#include <list>
#include <map>
-#include <Json.h>
+#include <CtxJson1.h>
#include <DBusTypes.h>
namespace ctx {
static void setContextManager(ContextManager* ctxMgr);
static void destroy();
- int subscribe(int ruleId, std::string subject, Json option, IContextListener* listener);
- int unsubscribe(int ruleId, std::string subject, Json option, IContextListener* listener);
- int read(std::string subject, Json option, IContextListener* listener);
+ int subscribe(int ruleId, std::string subject, CtxJson1 option, IContextListener* listener);
+ int unsubscribe(int ruleId, std::string subject, CtxJson1 option, IContextListener* listener);
+ int read(std::string subject, CtxJson1 option, IContextListener* listener);
bool isSupported(std::string subject);
bool isAllowed(const char *client, const char *subject);
- void replyResult(int reqId, int error, Json *requestResult = NULL);
- void replyResult(int reqId, int error, const char *subject, Json *option, Json *fact);
- void publishFact(int reqId, int error, const char *subject, Json *option, Json *fact);
+ void replyResult(int reqId, int error, CtxJson1 *requestResult = NULL);
+ void replyResult(int reqId, int error, const char *subject, CtxJson1 *option, CtxJson1 *fact);
+ void publishFact(int reqId, int error, const char *subject, CtxJson1 *option, CtxJson1 *fact);
private:
ContextMonitor();
static ContextMonitor *__instance;
static ContextManager *__contextMgr;
- int __subscribe(const char* subject, Json* option, IContextListener* listener);
+ int __subscribe(const char* subject, CtxJson1* option, IContextListener* listener);
void __unsubscribe(const char *subject, int subscriptionId);
- int __read(const char *subject, Json *option, IContextListener* listener);
+ int __read(const char *subject, CtxJson1 *option, IContextListener* listener);
struct SubscrInfo {
int sid;
std::string subject;
- Json option;
+ CtxJson1 option;
std::list<IContextListener*> listenerList;
- SubscrInfo(int id, const char *subj, Json *opt) :
+ SubscrInfo(int id, const char *subj, CtxJson1 *opt) :
sid(id),
subject(subj)
{
std::map<int, SubscrInfo*> __subscrMap;
std::map<int, SubscrInfo*> __readMap;
- int __findSub(RequestType type, const char *subject, Json *option);
- bool __addSub(RequestType type, int sid, const char *subject, Json *option, IContextListener* listener);
- void __removeSub(RequestType type, const char *subject, Json *option);
+ int __findSub(RequestType type, const char *subject, CtxJson1 *option);
+ bool __addSub(RequestType type, int sid, const char *subject, CtxJson1 *option, IContextListener* listener);
+ void __removeSub(RequestType type, const char *subject, CtxJson1 *option);
void __removeSub(RequestType type, int sid);
int __addListener(RequestType type, int sid, IContextListener* listener);
int __removeListener(RequestType type, int sid, IContextListener* listener);
return true;
}
-bool FactRequest::reply(int error, Json& requestResult)
+bool FactRequest::reply(int error, CtxJson1& requestResult)
{
IF_FAIL_RETURN(!__replied && __ctxMonitor, true);
__ctxMonitor->replyResult(__reqId, error, &requestResult);
return true;
}
-bool FactRequest::reply(int error, Json& requestResult, Json& dataRead)
+bool FactRequest::reply(int error, CtxJson1& requestResult, CtxJson1& dataRead)
{
IF_FAIL_RETURN(!__replied && __ctxMonitor, true);
__ctxMonitor->replyResult(__reqId, error, __subject.c_str(), &getDescription(), &dataRead);
return (__replied = true);
}
-bool FactRequest::publish(int error, Json& data)
+bool FactRequest::publish(int error, CtxJson1& data)
{
IF_FAIL_RETURN(__ctxMonitor, true);
__ctxMonitor->publishFact(__reqId, error, __subject.c_str(), &getDescription(), &data);
const char* getClient();
bool reply(int error);
- bool reply(int error, ctx::Json& requestResult);
- bool reply(int error, ctx::Json& requestResult, ctx::Json& dataRead);
- bool publish(int error, ctx::Json& data);
+ bool reply(int error, ctx::CtxJson1& requestResult);
+ bool reply(int error, ctx::CtxJson1& requestResult, ctx::CtxJson1& dataRead);
+ bool publish(int error, ctx::CtxJson1& data);
private:
ContextMonitor *__ctxMonitor;
namespace ctx {
/* Forward Declaration */
- class Json;
+ class CtxJson1;
namespace trigger {
public:
virtual ~IContextListener() {}
- virtual void onEventReceived(std::string name, Json option, Json data) = 0;
+ virtual void onEventReceived(std::string name, CtxJson1 option, CtxJson1 data) = 0;
- virtual void onConditionReceived(std::string name, Json option, Json data) = 0;
+ virtual void onConditionReceived(std::string name, CtxJson1 option, CtxJson1 data) = 0;
};
} /* namespace trigger */
RuleManager *Rule::__ruleMgr = NULL;
-Rule::Rule(int i, Json& d, const char* p, RuleManager* rm) :
+Rule::Rule(int i, CtxJson1& d, const char* p, RuleManager* rm) :
__result(EMPTY_JSON_OBJECT),
id(i),
pkgId(p)
__statement = d.str();
// Event
- Json e;
+ CtxJson1 e;
d.get(NULL, TRIG_RULE_KEY_EVENT, &e);
__event = new(std::nothrow) ContextItem(e);
// Condition
int condNum = d.getSize(NULL, TRIG_RULE_KEY_CONDITION);
for (int j = 0; j < condNum; j++) {
- Json c;
+ CtxJson1 c;
d.getAt(NULL, TRIG_RULE_KEY_CONDITION, j, &c);
__condition.push_back(new(std::nothrow) ContextItem(c));
}
// Extra
- Json extra;
+ CtxJson1 extra;
d.get(NULL, _TRIG_RULE_KEY_EXTRA, &extra);
__extra = extra.str();
// Action
- Json a;
+ CtxJson1 a;
d.get(NULL, TRIG_RULE_KEY_ACTION, &a);
__action = a.str();
}
return error;
}
-bool Rule::__setConditionOptionBasedOnEvent(Json& option)
+bool Rule::__setConditionOptionBasedOnEvent(CtxJson1& option)
{
// Set condition option if it references event data
std::list<std::string> optionKeys;
return true;
}
-void Rule::onEventReceived(std::string name, Json option, Json data)
+void Rule::onEventReceived(std::string name, CtxJson1 option, CtxJson1 data)
{
if (__result != EMPTY_JSON_OBJECT) {
__clearResult();
// Request read conditions
for (auto it = __condition.begin(); it != __condition.end(); ++it) {
- Json condOption = (*it)->option.str();
+ CtxJson1 condOption = (*it)->option.str();
if (!__setConditionOptionBasedOnEvent(condOption)) { // condOption should be copy of original option.
__clearResult();
return;
// TODO timer set
}
-void Rule::onConditionReceived(std::string name, Json option, Json data)
+void Rule::onConditionReceived(std::string name, CtxJson1 option, CtxJson1 data)
{
_D("Rule%d received condition data", id);
// Set condition data
- Json item;
+ CtxJson1 item;
item.set(NULL, FACT_KEY_NAME, name);
item.set(NULL, FACT_KEY_OPTION, option);
item.set(NULL, FACT_KEY_DATA, data);
#include <string>
#include <list>
-#include <Json.h>
+#include <CtxJson1.h>
#include "IContextListener.h"
namespace ctx {
private:
struct ContextItem {
std::string name;
- ctx::Json option;
- ContextItem(ctx::Json item) {
+ ctx::CtxJson1 option;
+ ContextItem(ctx::CtxJson1 item) {
std::list<std::string> keyList;
item.getKeys(&keyList);
name = *keyList.begin();
- ctx::Json o;
+ ctx::CtxJson1 o;
if (item.get(name.c_str(), TRIG_RULE_KEY_OPTION, &o))
option = o.str();
}
};
- ctx::Json __statement;
+ ctx::CtxJson1 __statement;
ContextItem* __event;
std::list<ContextItem*> __condition;
- ctx::Json __extra;
- ctx::Json __action;
- ctx::Json __result;
+ ctx::CtxJson1 __extra;
+ ctx::CtxJson1 __action;
+ ctx::CtxJson1 __result;
static RuleManager* __ruleMgr;
void __clearResult(void);
- bool __setConditionOptionBasedOnEvent(ctx::Json& option);
+ bool __setConditionOptionBasedOnEvent(ctx::CtxJson1& option);
void __onContextDataPrepared(void);
static gboolean __handleUninstalledRule(gpointer data);
int id;
std::string pkgId;
- Rule(int i, ctx::Json& d, const char* p, RuleManager* rm);
+ Rule(int i, ctx::CtxJson1& d, const char* p, RuleManager* rm);
~Rule();
int start(void);
int stop(void);
- void onEventReceived(std::string name, ctx::Json option, ctx::Json data);
- void onConditionReceived(std::string name, ctx::Json option, ctx::Json data);
+ void onEventReceived(std::string name, ctx::CtxJson1 option, ctx::CtxJson1 data);
+ void onConditionReceived(std::string name, ctx::CtxJson1 option, ctx::CtxJson1 data);
};
* limitations under the License.
*/
-#include <Json.h>
+#include <CtxJson1.h>
#include <Types.h>
#include <TriggerRuleTypes.h>
#include "RuleEvaluator.h"
}
template <typename T>
-bool RuleEvaluator::__evaluateSingleData(T factVal, Json& comparison, std::string op)
+bool RuleEvaluator::__evaluateSingleData(T factVal, CtxJson1& comparison, std::string op)
{
T ruleVal;
comparison.get(NULL, TRIG_RULE_KEY_VALUE, &ruleVal);
}
template <typename T>
-bool RuleEvaluator::__evaluateDualData(T factVal, Json& comparison, std::string op)
+bool RuleEvaluator::__evaluateDualData(T factVal, CtxJson1& comparison, std::string op)
{
T ruleVal1, ruleVal2;
comparison.getAt(NULL, TRIG_RULE_KEY_VALUE, 0, &ruleVal1);
}
template <typename T>
-bool RuleEvaluator::__evaluateMultipleData(T factVal, Json& comparison, std::string op)
+bool RuleEvaluator::__evaluateMultipleData(T factVal, CtxJson1& comparison, std::string op)
{
T ruleVal;
for (int i = 0; comparison.getAt(NULL, TRIG_RULE_KEY_VALUE, i, &ruleVal); i++) {
}
template <typename T>
-bool RuleEvaluator::__evaluateData(T factVal, Json& comparison)
+bool RuleEvaluator::__evaluateData(T factVal, CtxJson1& comparison)
{
std::string op;
comparison.get(NULL, TRIG_RULE_KEY_OPERATOR, &op);
return false;
}
-void RuleEvaluator::__replaceSingleDataReferences(Json& eventFactData, Json& ruleComp, std::string& dataKey)
+void RuleEvaluator::__replaceSingleDataReferences(CtxJson1& eventFactData, CtxJson1& ruleComp, std::string& dataKey)
{
std::string refVal;
std::string eventRefStr;
}
}
-void RuleEvaluator::__replaceMultipleDataReferences(Json& eventFactData, Json& ruleComp, std::string& dataKey)
+void RuleEvaluator::__replaceMultipleDataReferences(CtxJson1& eventFactData, CtxJson1& ruleComp, std::string& dataKey)
{
std::string refVal;
std::string eventRefStr;
}
}
-void RuleEvaluator::__replaceDataReferences(Json eventFactData, Json& ruleComp)
+void RuleEvaluator::__replaceDataReferences(CtxJson1 eventFactData, CtxJson1& ruleComp)
{
// Replace referencing data to actual value
std::list<std::string> compKeys;
}
}
-bool RuleEvaluator::__evaluateItem(Json& factItem, Json& ruleItem, std::string logicalOp)
+bool RuleEvaluator::__evaluateItem(CtxJson1& factItem, CtxJson1& ruleItem, std::string logicalOp)
{
std::string name;
factItem.get(NULL, FACT_KEY_NAME, &name);
- Json comparison;
+ CtxJson1 comparison;
ruleItem.get(name.c_str(), TRIG_RULE_KEY_COMPARISON, &comparison);
std::list<std::string> compKeys;
for (auto it = compKeys.begin(); it != compKeys.end(); ++it) {
std::string dataKey = *it;
- Json comp;
+ CtxJson1 comp;
comparison.get(NULL, dataKey.c_str(), &comp);
std::string factValStr;
return isConjunction;
}
-bool RuleEvaluator::__evaluateRuleEvent(Json& fact, Json& rule)
+bool RuleEvaluator::__evaluateRuleEvent(CtxJson1& fact, CtxJson1& rule)
{
- Json factItem;
- Json ruleItem;
+ CtxJson1 factItem;
+ CtxJson1 ruleItem;
fact.get(NULL, FACT_KEY_EVENT, &factItem);
rule.get(NULL, TRIG_RULE_KEY_EVENT, &ruleItem);
return __evaluateItem(factItem, ruleItem, eventOp);
}
-Json RuleEvaluator::__getConditionFact(Json& fact, Json& ruleCond)
+CtxJson1 RuleEvaluator::__getConditionFact(CtxJson1& fact, CtxJson1& ruleCond)
{
std::list<std::string> condKey;
ruleCond.getKeys(&condKey);
std::string ruleCondName = *(condKey.begin());
- Json factCond;
+ CtxJson1 factCond;
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;
}
// Check if fact item option is mathced with condition
- Json ruleCondOption;
- Json factCondOption;
+ CtxJson1 ruleCondOption;
+ CtxJson1 factCondOption;
ruleCond.get(ruleCondName.c_str(), TRIG_RULE_KEY_OPTION, &ruleCondOption);
factCond.get(NULL, FACT_KEY_OPTION, &factCondOption);
if (factCondOption == ruleCondOption) {
return EMPTY_JSON_OBJECT;
}
-bool RuleEvaluator::__evaluateRuleCondition(Json& fact, Json& rule)
+bool RuleEvaluator::__evaluateRuleCondition(CtxJson1& fact, CtxJson1& rule)
{
std::string ruleOp;
rule.get(_TRIG_RULE_KEY_EXTRA, _TRIG_RULE_KEY_RULE_LOGICAL_OP, &ruleOp);
bool isConjunction = (TRIG_RULE_LOGICAL_CONJUNCTION == ruleOp);
- Json ruleCond;
+ CtxJson1 ruleCond;
for (int i = 0; rule.getAt(NULL, TRIG_RULE_KEY_CONDITION, i, &ruleCond); i++) {
- Json factCond = __getConditionFact(fact, ruleCond);
+ CtxJson1 factCond = __getConditionFact(fact, ruleCond);
bool result;
if (factCond == EMPTY_JSON_OBJECT) {
return isConjunction;
}
-bool RuleEvaluator::__replaceOptionReferences(Json eventFactData, Json& ruleOption)
+bool RuleEvaluator::__replaceOptionReferences(CtxJson1 eventFactData, CtxJson1& ruleOption)
{
// Replace referencing option to actual value
std::string refVal;
return true;
}
-bool RuleEvaluator::__replaceEventReferences(Json& fact, Json& rule)
+bool RuleEvaluator::__replaceEventReferences(CtxJson1& fact, CtxJson1& rule)
{
// Replace referencing data/option to actual value
- Json eventFactData;
+ CtxJson1 eventFactData;
if (!fact.get(FACT_KEY_EVENT, FACT_KEY_DATA, &eventFactData)) {
_E("No event data found, error");
return false;
}
- Json ruleCond;
+ CtxJson1 ruleCond;
for (int i = 0; rule.getAt(NULL, TRIG_RULE_KEY_CONDITION, i, &ruleCond); i++) {
std::list<std::string> condKey;
ruleCond.getKeys(&condKey);
std::string ruleCondName = *(condKey.begin());
- Json ruleComp;
+ CtxJson1 ruleComp;
for (int j = 0; ruleCond.getAt(ruleCondName.c_str(), TRIG_RULE_KEY_COMPARISON, j, &ruleComp); j++) {
__replaceDataReferences(eventFactData, ruleComp);
}
- Json ruleOption;
+ CtxJson1 ruleOption;
if (ruleCond.get(ruleCondName.c_str(), TRIG_RULE_KEY_OPTION, &ruleOption)) {
__replaceOptionReferences(eventFactData, ruleOption);
}
return true;
}
-bool RuleEvaluator::evaluateRule(Json rule, Json fact)
+bool RuleEvaluator::evaluateRule(CtxJson1 rule, CtxJson1 fact)
{
_D("Rule is %s ", rule.str().c_str());
_D("fact is %s ", fact.str().c_str());
RuleEvaluator eval;
bool ret;
- Json tempJson;
+ CtxJson1 tempJson;
if (fact.get(NULL, FACT_KEY_CONDITION, &tempJson)) {
- Json ruleCopy(rule.str());
+ CtxJson1 ruleCopy(rule.str());
if (!eval.__replaceEventReferences(fact, ruleCopy)) {
_W("Replace failed");
}
namespace ctx {
- class Json;
+ class CtxJson1;
namespace trigger {
private:
RuleEvaluator();
- bool __evaluateRuleEvent(ctx::Json& fact, ctx::Json& rule);
- bool __evaluateRuleCondition(ctx::Json& fact, ctx::Json& rule);
- bool __evaluateItem(ctx::Json& factItem, ctx::Json& ruleItem, std::string logicalOp);
- template <typename T> bool __evaluateData(T factVal, Json& comparison);
- template <typename T> bool __evaluateSingleData(T factVal, Json& comparison, std::string op);
- template <typename T> bool __evaluateDualData(T factVal, Json& comparison, std::string op);
- template <typename T> bool __evaluateMultipleData(T factVal, Json& comparison, std::string op);
+ bool __evaluateRuleEvent(ctx::CtxJson1& fact, ctx::CtxJson1& rule);
+ bool __evaluateRuleCondition(ctx::CtxJson1& fact, ctx::CtxJson1& rule);
+ bool __evaluateItem(ctx::CtxJson1& factItem, ctx::CtxJson1& ruleItem, std::string logicalOp);
+ template <typename T> bool __evaluateData(T factVal, CtxJson1& comparison);
+ template <typename T> bool __evaluateSingleData(T factVal, CtxJson1& comparison, std::string op);
+ template <typename T> bool __evaluateDualData(T factVal, CtxJson1& comparison, std::string op);
+ template <typename T> bool __evaluateMultipleData(T factVal, CtxJson1& comparison, std::string op);
- ctx::Json __getConditionFact(ctx::Json& fact, ctx::Json& ruleCond);
+ ctx::CtxJson1 __getConditionFact(ctx::CtxJson1& fact, ctx::CtxJson1& ruleCond);
- bool __replaceEventReferences(ctx::Json& fact, ctx::Json& rule);
- void __replaceDataReferences(ctx::Json eventFactData, ctx::Json& ruleComp);
- void __replaceSingleDataReferences(ctx::Json& eventFactData, ctx::Json& ruleComp, std::string& dataKey);
- void __replaceMultipleDataReferences(ctx::Json& eventFactData, ctx::Json& ruleComp, std::string& dataKey);
- bool __replaceOptionReferences(ctx::Json eventFactData, ctx::Json& ruleOption);
+ bool __replaceEventReferences(ctx::CtxJson1& fact, ctx::CtxJson1& rule);
+ void __replaceDataReferences(ctx::CtxJson1 eventFactData, ctx::CtxJson1& ruleComp);
+ void __replaceSingleDataReferences(ctx::CtxJson1& eventFactData, ctx::CtxJson1& ruleComp, std::string& dataKey);
+ void __replaceMultipleDataReferences(ctx::CtxJson1& eventFactData, ctx::CtxJson1& ruleComp, std::string& dataKey);
+ bool __replaceOptionReferences(ctx::CtxJson1 eventFactData, ctx::CtxJson1& ruleOption);
public:
- static bool evaluateRule(ctx::Json rule, ctx::Json data);
+ static bool evaluateRule(ctx::CtxJson1 rule, ctx::CtxJson1 data);
};
} /* namespace trigger */
#include <TriggerTypes.h>
#include <TriggerRuleTypes.h>
#include <package_manager.h>
-#include <Json.h>
+#include <CtxJson1.h>
#include "RuleManager.h"
#include "ContextMonitor.h"
#include "Rule.h"
// Return number of uninstalled apps
std::string q1 = "SELECT DISTINCT packageId FROM ContextTriggerRule";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q1.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, -1, _E, "Query package ids of registered rules failed");
- std::vector<Json>::iterator vecEnd = record.end();
- for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
- Json elem = *vecPos;
+ std::vector<CtxJson1>::iterator vecEnd = record.end();
+ for (std::vector<CtxJson1>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
+ CtxJson1 elem = *vecPos;
std::string pkgId;
elem.get(NULL, "packageId", &pkgId);
q1 += pkgList;
q1 += ")";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
ret = __dbManager.executeSync(q1.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Failed to query enabled rules of uninstalled packages");
- std::vector<Json>::iterator vecEnd = record.end();
- for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
- Json elem = *vecPos;
+ std::vector<CtxJson1>::iterator vecEnd = record.end();
+ for (std::vector<CtxJson1>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
+ CtxJson1 elem = *vecPos;
int ruleId;
elem.get(NULL, "rowId", &ruleId);
error = disableRule(ruleId);
// Delete rules of uninstalled packages from DB
std::string q2 = "DELETE FROM ContextTriggerRule WHERE " + pkgList;
- std::vector<Json> dummy;
+ std::vector<CtxJson1> dummy;
ret = __dbManager.executeSync(q2.c_str(), &dummy);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Failed to remove rules from db");
_D("Uninstalled packages' rules are deleted from db");
int RuleManager::pauseRuleWithItem(std::string& subject)
{
std::string q = "SELECT rowId FROM ContextTriggerRule WHERE (status=2) AND (details LIKE '%\"ITEM_NAME\":\"" + subject + "\"%');";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Failed to query rowIds to be paused");
IF_FAIL_RETURN(record.size() > 0, ERR_NONE);
_D("Pause rules related to %s", subject.c_str());
- std::vector<Json>::iterator vecEnd = record.end();
- for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
- Json elem = *vecPos;
+ std::vector<CtxJson1>::iterator vecEnd = record.end();
+ for (std::vector<CtxJson1>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
+ CtxJson1 elem = *vecPos;
int rowId;
elem.get(NULL, "rowId", &rowId);
int RuleManager::resumeRuleWithItem(std::string& subject)
{
std::string q = "SELECT rowId FROM ContextTriggerRule WHERE (status=1) AND (details LIKE '%\"ITEM_NAME\":\"" + subject + "\"%');";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Query paused rule ids failed");
IF_FAIL_RETURN(record.size() > 0, ERR_NONE);
_D("Resume rules related to %s", subject.c_str());
std::string qRowId;
- std::vector<Json>::iterator vecEnd = record.end();
- for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
- Json elem = *vecPos;
+ std::vector<CtxJson1>::iterator vecEnd = record.end();
+ for (std::vector<CtxJson1>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
+ CtxJson1 elem = *vecPos;
int rowId;
elem.get(NULL, "rowId", &rowId);
int error;
std::string q = "SELECT rowId FROM ContextTriggerRule WHERE status = 2";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, false, _E, "Query rowIds of enabled rules failed");
IF_FAIL_RETURN_TAG(record.size() > 0, true, _D, "No rule to re-enable");
std::string qRowId;
qRowId.clear();
- std::vector<Json>::iterator vecEnd = record.end();
- for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
- Json elem = *vecPos;
+ std::vector<CtxJson1>::iterator vecEnd = record.end();
+ for (std::vector<CtxJson1>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
+ CtxJson1 elem = *vecPos;
int rowId;
elem.get(NULL, "rowId", &rowId);
// For rules which is failed to re-enable
std::string qUpdate = "UPDATE ContextTriggerRule SET status = 1 WHERE " + qRowId;
- std::vector<Json> record2;
+ std::vector<CtxJson1> record2;
ret = __dbManager.executeSync(qUpdate.c_str(), &record2);
IF_FAIL_RETURN_TAG(ret, false, _E, "Failed to update rules as paused");
return true;
}
-bool RuleManager::__ruleEquals(Json& lRule, Json& rRule)
+bool RuleManager::__ruleEquals(CtxJson1& lRule, CtxJson1& rRule)
{
// Compare event
- Json lEvent, rEvent;
+ CtxJson1 lEvent, rEvent;
lRule.get(NULL, TRIG_RULE_KEY_EVENT, &lEvent);
rRule.get(NULL, TRIG_RULE_KEY_EVENT, &rEvent);
for (int i = 0; i < lCondCnt; i++) {
bool found = false;
- Json lCond;
+ CtxJson1 lCond;
lRule.getAt(NULL, TRIG_RULE_KEY_CONDITION, i, &lCond);
std::string lCOp;
lRule.getAt(_TRIG_RULE_KEY_EXTRA, _TRIG_RULE_KEY_CONDITION_LOGICAL_OP, i, &lCOp);
for (int j = 0; j < lCondCnt; j++) {
- Json rCond;
+ CtxJson1 rCond;
rRule.getAt(NULL, TRIG_RULE_KEY_CONDITION, j, &rCond);
std::string rCOp;
}
// Compare action
- Json lAction, rAction;
+ CtxJson1 lAction, rAction;
lRule.get(NULL, TRIG_RULE_KEY_ACTION, &lAction);
rRule.get(NULL, TRIG_RULE_KEY_ACTION, &rAction);
if (lAction != rAction)
return true;
}
-int64_t RuleManager::__getDuplicatedRuleId(std::string pkgId, Json& rule)
+int64_t RuleManager::__getDuplicatedRuleId(std::string pkgId, CtxJson1& rule)
{
std::string q = "SELECT rowId, description, details FROM ContextTriggerRule WHERE packageId = '";
q += pkgId;
q += "'";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, false, _E, "Query rowId, details by package id failed");
std::string rDesc;
rule.get(NULL, TRIG_RULE_KEY_DESCRIPTION, &rDesc);
- Json rDetails = rule.str();
+ CtxJson1 rDetails = rule.str();
rDetails.remove(NULL, TRIG_RULE_KEY_DESCRIPTION);
- std::vector<Json>::iterator vecEnd = record.end();
- for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
- Json elem = *vecPos;
+ std::vector<CtxJson1>::iterator vecEnd = record.end();
+ for (std::vector<CtxJson1>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
+ CtxJson1 elem = *vecPos;
std::string dStr;
- Json details;
+ CtxJson1 details;
elem.get(NULL, "details", &dStr);
details = dStr;
// Only description is changed
std::string qUpdate = "UPDATE ContextTriggerRule SET description='" + rDesc + "' WHERE rowId = " + __intToString(rowId);
- std::vector<Json> dummy;
+ std::vector<CtxJson1> dummy;
ret = __dbManager.executeSync(qUpdate.c_str(), &dummy);
if (ret) {
_D("Rule%lld description is updated", rowId);
return -1;
}
-int RuleManager::__verifyRule(Json& rule, const char* creator)
+int RuleManager::__verifyRule(CtxJson1& rule, const char* creator)
{
ContextMonitor* ctxMonitor = ContextMonitor::getInstance();
IF_FAIL_RETURN_TAG(ctxMonitor, ERR_OUT_OF_MEMORY, _E, "Memory allocation failed");
// Event
- Json event;
+ CtxJson1 event;
rule.get(NULL, TRIG_RULE_KEY_EVENT, &event);
std::list<std::string> eventKey;
}
// Conditions
- Json cond;
+ CtxJson1 cond;
for (int i = 0; rule.getAt(NULL, TRIG_RULE_KEY_CONDITION, i, &cond); i++) {
std::list<std::string> condKey;
cond.getKeys(&condKey);
return ERR_NONE;
}
-int RuleManager::addRule(std::string creator, const char* pkgId, Json rule, Json* ruleId)
+int RuleManager::addRule(std::string creator, const char* pkgId, CtxJson1 rule, CtxJson1* ruleId)
{
bool ret;
int64_t rid;
}
// Insert rule to rule table, get rule id
- Json record;
+ CtxJson1 record;
std::string description;
rule.get(NULL, TRIG_RULE_KEY_DESCRIPTION, &description);
- Json details = rule.str();
+ CtxJson1 details = rule.str();
details.remove(NULL, TRIG_RULE_KEY_DESCRIPTION);
record.set(NULL, "details", details.str());
std::string query = "DELETE FROM 'ContextTriggerRule' where rowId = ";
query += __intToString(ruleId);
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
ret = __dbManager.executeSync(query.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Remove rule from db failed");
{
int error;
std::string query;
- std::vector<Json> record;
- std::vector<Json> dummy;
+ std::vector<CtxJson1> record;
+ std::vector<CtxJson1> dummy;
std::string pkgId;
- Json jRule;
+ CtxJson1 jRule;
std::string tmp;
std::string idStr = __intToString(ruleId);
Rule* rule;
- // Get rule Json by rule id;
+ // Get rule CtxJson1 by rule id;
query = "SELECT details, packageId FROM ContextTriggerRule WHERE rowId = ";
query += idStr;
error = (__dbManager.executeSync(query.c_str(), &record))? ERR_NONE : ERR_OPERATION_FAILED;
// Update db to set 'disabled' // TODO skip while clear uninstalled rule
std::string query = "UPDATE ContextTriggerRule SET status = 0 WHERE rowId = ";
query += __intToString(ruleId);
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
ret = __dbManager.executeSync(query.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Update db failed");
std::string query = "UPDATE ContextTriggerRule SET status = 1 WHERE rowId = ";
query += __intToString(ruleId);
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
ret = __dbManager.executeSync(query.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Update db failed");
std::string q = "SELECT packageId FROM ContextTriggerRule WHERE rowId =";
q += __intToString(ruleId);
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, false, _E, "Query package id by rule id failed");
std::string q = "SELECT status FROM ContextTriggerRule WHERE rowId =";
q += __intToString(ruleId);
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, false, _E, "Query enabled by rule id failed");
return (status != 0);
}
-int RuleManager::getRuleById(std::string pkgId, int ruleId, Json* requestResult)
+int RuleManager::getRuleById(std::string pkgId, int ruleId, CtxJson1* requestResult)
{
std::string q = "SELECT description FROM ContextTriggerRule WHERE (packageId = '";
q += pkgId;
q += __intToString(ruleId);
q += ")";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, false, _E, "Query rule by rule id failed");
return ERR_NONE;
}
-int RuleManager::getRuleIds(std::string pkgId, Json* requestResult)
+int RuleManager::getRuleIds(std::string pkgId, CtxJson1* requestResult)
{
(*requestResult) = RULE_IDS_JSON;
q += pkgId;
q += "')";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Query rules failed");
- std::vector<Json>::iterator vecEnd = record.end();
- for (std::vector<Json>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
- Json elem = *vecPos;
+ std::vector<CtxJson1>::iterator vecEnd = record.end();
+ for (std::vector<CtxJson1>::iterator vecPos = record.begin(); vecPos != vecEnd; ++vecPos) {
+ CtxJson1 elem = *vecPos;
std::string id;
int status;
namespace ctx {
- class Json;
+ class CtxJson1;
namespace trigger {
~RuleManager();
bool init();
- int addRule(std::string creator, const char* pkgId, Json rule, Json* ruleId);
+ int addRule(std::string creator, const char* pkgId, CtxJson1 rule, CtxJson1* ruleId);
int removeRule(int ruleId);
int enableRule(int ruleId);
int disableRule(int ruleId);
- int getRuleById(std::string pkgId, int ruleId, Json* requestResult);
- int getRuleIds(std::string pkgId, Json* requestResult);
+ int getRuleById(std::string pkgId, int ruleId, CtxJson1* requestResult);
+ int getRuleIds(std::string pkgId, CtxJson1* requestResult);
int checkRule(std::string pkgId, int ruleId);
bool isRuleEnabled(int ruleId);
int pauseRuleWithItem(std::string& subject);
private:
bool __reenableRule(void);
- int __verifyRule(Json& rule, const char* creator);
- int64_t __getDuplicatedRuleId(std::string pkgId, Json& rule);
- bool __ruleEquals(Json& lRule, Json& rRule);
+ int __verifyRule(CtxJson1& rule, const char* creator);
+ int64_t __getDuplicatedRuleId(std::string pkgId, CtxJson1& rule);
+ bool __ruleEquals(CtxJson1& lRule, CtxJson1& rRule);
int __getUninstalledApp(void);
int __clearRuleOfUninstalledPackage(bool isInit = false);
void __applyTemplates(void);
+ "(name TEXT DEFAULT '' NOT NULL PRIMARY KEY, operation INTEGER DEFAULT 3 NOT NULL, "
+ "attributes TEXT DEFAULT '' NOT NULL, options TEXT DEFAULT '' NOT NULL, owner TEXT DEFAULT '' NOT NULL)";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, false, _E, "Create template table failed");
{
std::string subject;
int operation;
- Json attributes;
- Json options;
+ CtxJson1 attributes;
+ CtxJson1 options;
std::string owner;
std::string query;
query.clear();
}
}
-void TemplateManager::registerTemplate(std::string subject, int operation, Json attributes, Json options, std::string owner)
+void TemplateManager::registerTemplate(std::string subject, int operation, CtxJson1 attributes, CtxJson1 options, std::string owner)
{
_D("[Add template] Subject: %s, Ops: %d, Owner: %s", subject.c_str(), operation, owner.c_str());
_J("Attr", attributes);
+ subject + "', " + __intToString(operation) + ", '" + attributes.str() + "', '" + options.str() + "', '"
+ owner + "'); ";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(query.c_str(), &record);
IF_FAIL_VOID_TAG(ret, _E, "Update template db failed");
_D("[Remove template] Subject: %s", subject.c_str());
std::string query = "DELETE FROM ContextTriggerTemplate WHERE name = '" + subject + "'; ";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(query.c_str(), &record);
IF_FAIL_VOID_TAG(ret, _E, "Update template db failed");
}
-std::string TemplateManager::__addTemplate(std::string &subject, int &operation, Json &attributes, Json &options, std::string &owner)
+std::string TemplateManager::__addTemplate(std::string &subject, int &operation, CtxJson1 &attributes, CtxJson1 &options, std::string &owner)
{
_D("[Add template] Subject: %s, Ops: %d, Owner: %s", subject.c_str(), operation, owner.c_str());
_J("Attr", attributes);
return query;
}
-int TemplateManager::getTemplate(std::string &subject, Json* tmpl)
+int TemplateManager::getTemplate(std::string &subject, CtxJson1* tmpl)
{
if (!__contextMgr->isSupported(subject.c_str()))
return ERR_NOT_SUPPORTED;
// Update latest template information
std::string q = "SELECT * FROM ContextTriggerTemplate WHERE name = '" + subject + "'";
- std::vector<Json> record;
+ std::vector<CtxJson1> record;
bool ret = __dbManager.executeSync(q.c_str(), &record);
IF_FAIL_RETURN_TAG(ret, ERR_OPERATION_FAILED, _E, "Query template failed");
IF_FAIL_RETURN_TAG(record.size() > 0, ERR_NOT_SUPPORTED, _E, "Template(%s) not found", subject.c_str());
tmpl->get(NULL, TRIG_TMPL_KEY_OPTION, &optStr);
tmpl->get(NULL, TRIG_TMPL_KEY_ATTRIBUTE, &attrStr);
- Json opt = optStr;
- Json attr = attrStr;
+ CtxJson1 opt = optStr;
+ CtxJson1 attr = attrStr;
tmpl->set(NULL, TRIG_TMPL_KEY_OPTION, opt);
tmpl->set(NULL, TRIG_TMPL_KEY_ATTRIBUTE, attr);
#ifndef _CONTEXT_TRIGGER_TEMPLATE_MANAGER_H_
#define _CONTEXT_TRIGGER_TEMPLATE_MANAGER_H_
-#include <Json.h>
+#include <CtxJson1.h>
#include <DatabaseManager.h>
namespace ctx {
bool init();
void applyTemplates();
- int getTemplate(std::string &subject, Json* tmpl);
- void registerTemplate(std::string subject, int operation, Json attributes, Json options, std::string owner);
+ int getTemplate(std::string &subject, CtxJson1* tmpl);
+ void registerTemplate(std::string subject, int operation, CtxJson1 attributes, CtxJson1 options, std::string owner);
void unregisterTemplate(std::string subject);
private:
DatabaseManager __dbManager;
- std::string __addTemplate(std::string &subject, int &operation, Json &attributes, Json &options, std::string &owner);
+ std::string __addTemplate(std::string &subject, int &operation, CtxJson1 &attributes, CtxJson1 &options, std::string &owner);
std::string __removeTemplate(std::string &subject);
}; /* class TemplateManager */
void Trigger::__addRule(RequestInfo* request)
{
- Json ruleId;
+ CtxJson1 ruleId;
const char* client = request->getClient();
if (client == NULL) {
const char* pkgId = request->getPackageId();
- Json ruleId = request->getDescription();
+ CtxJson1 ruleId = request->getDescription();
ruleId.get(NULL, TRIG_KEY_RULE_ID, &id);
error = __ruleMgr->checkRule((pkgId)? pkgId : "", id);
const char* pkgId = request->getPackageId();
- Json ruleId = request->getDescription();
+ CtxJson1 ruleId = request->getDescription();
ruleId.get(NULL, TRIG_KEY_RULE_ID, &id);
error = __ruleMgr->checkRule((pkgId)? pkgId : "", id);
const char* pkgId = request->getPackageId();
- Json ruleId = request->getDescription();
+ CtxJson1 ruleId = request->getDescription();
ruleId.get(NULL, TRIG_KEY_RULE_ID, &id);
error = __ruleMgr->checkRule((pkgId)? pkgId : "", id);
{
int error;
- Json option = request->getDescription();
+ CtxJson1 option = request->getDescription();
int id;
option.get(NULL, TRIG_KEY_RULE_ID, &id);
const char* pkgId = request->getPackageId();
- Json readData;
+ CtxJson1 readData;
error = __ruleMgr->getRuleById((pkgId)? pkgId : "", id, &readData);
- Json dummy;
+ CtxJson1 dummy;
request->reply(error, dummy, readData);
}
const char* pkgId = request->getPackageId();
- Json readData;
+ CtxJson1 readData;
error = __ruleMgr->getRuleIds((pkgId)? pkgId : "", &readData);
- Json dummy;
+ CtxJson1 dummy;
request->reply(error, dummy, readData);
}
{
int error;
- Json option = request->getDescription();
+ CtxJson1 option = request->getDescription();
std::string name;
option.get(NULL, TRIG_TMPL_KEY_SUBJECT, &name);
return;
}
- Json tmpl;
+ CtxJson1 tmpl;
error = tmplMgr->getTemplate(name, &tmpl);
- Json dummy;
+ CtxJson1 dummy;
request->reply(error, dummy, tmpl);
}
projects / platform / core / context / context-service.git / commitdiff