Remove Vasum zone control code

Change-Id: If7eb4588c9ffd859295797ac9e038edaffc9fa44
Signed-off-by: Mu-Woong <muwoong.lee@samsung.com>

diff --git a/include/device_context_provider.h b/include/device_context_provider.h
index 69a7473..14b8fc8 100644 (file)
--- a/include/device_context_provider.h
+++ b/include/device_context_provider.h
@@ -27,11 +27,11 @@ namespace ctx {
                        ~device_context_provider();
 
                        bool init();
-                       bool is_supported(const char* subject, const char* zone);
-                       int subscribe(const char* subject, ctx::json option, ctx::json* request_result, const char* zone);
-                       int unsubscribe(const char* subject, ctx::json option, const char* zone);
-                       int read(const char* subject, ctx::json option, ctx::json* request_result, const char* zone);
-                       int write(const char* subject, ctx::json data, ctx::json* request_result, const char* zone);
+                       bool is_supported(const char* subject);
+                       int subscribe(const char* subject, ctx::json option, ctx::json* request_result);
+                       int unsubscribe(const char* subject, ctx::json option);
+                       int read(const char* subject, ctx::json option, ctx::json* request_result);
+                       int write(const char* subject, ctx::json data, ctx::json* request_result);
        };
 
 }

diff --git a/src/device_context_provider.cpp b/src/device_context_provider.cpp
index a35c740..3f188c8 100644 (file)
--- a/src/device_context_provider.cpp
+++ b/src/device_context_provider.cpp
@@ -54,7 +54,7 @@
 
 #define CREATE_SUB_PROVIDER(subject, subprovider) do { \
        ctx::sub_provider_base *sub = new ctx::subprovider(); \
-       if (sub->is_supported(subject, NULL)) { \
+       if (sub->is_supported(subject)) { \
                subject_map[(subject)] = sub; \
        } else { \
                _E("%s is not supported", subject); \
@@ -138,56 +138,56 @@ bool ctx::device_context_provider::init()
        return true;
 }
 
-bool ctx::device_context_provider::is_supported(const char* subject, const char* zone)
+bool ctx::device_context_provider::is_supported(const char* subject)
 {
        subject_map_t::iterator it = subject_map.find(subject);
 
        if (it != subject_map.end())
-               return it->second->is_supported(subject, zone);
+               return it->second->is_supported(subject);
 
        return false;
 }
 
-int ctx::device_context_provider::subscribe(const char* subject, ctx::json option, ctx::json* request_result, const char* zone)
+int ctx::device_context_provider::subscribe(const char* subject, ctx::json option, ctx::json* request_result)
 {
-       _D("Starts to publish '%s' on '%s'", subject, zone);
+       _D("Starts to publish '%s'", subject);
 
        subject_map_t::iterator it = subject_map.find(subject);
 
        if (it != subject_map.end())
-               return it->second->subscribe(subject, zone);
+               return it->second->subscribe(subject);
 
        return ERR_NOT_SUPPORTED;
 }
 
 
-int ctx::device_context_provider::unsubscribe(const char* subject, ctx::json option, const char* zone)
+int ctx::device_context_provider::unsubscribe(const char* subject, ctx::json option)
 {
-       _D("Stops publishing '%s' on '%s'", subject, zone);
+       _D("Stops publishing '%s'", subject);
 
        subject_map_t::iterator it = subject_map.find(subject);
 
        if (it != subject_map.end())
-               return it->second->unsubscribe(subject, zone);
+               return it->second->unsubscribe(subject);
 
        return ERR_NOT_SUPPORTED;
 }
 
 
-int ctx::device_context_provider::read(const char* subject, ctx::json option, ctx::json* request_result, const char* zone)
+int ctx::device_context_provider::read(const char* subject, ctx::json option, ctx::json* request_result)
 {
-       _D("Reads '%s' on '%s'", subject, zone);
+       _D("Reads '%s'", subject);
 
        subject_map_t::iterator it = subject_map.find(subject);
 
        if (it != subject_map.end())
-               return it->second->read(subject, zone);
+               return it->second->read(subject);
 
        return ERR_NOT_SUPPORTED;
 }
 
 
-int ctx::device_context_provider::write(const char* subject, ctx::json data, ctx::json* request_result, const char* zone)
+int ctx::device_context_provider::write(const char* subject, ctx::json data, ctx::json* request_result)
 {
        return ERR_NOT_SUPPORTED;
 }

diff --git a/src/device_status/activity.cpp b/src/device_status/activity.cpp
index 9a7fb2b..26cf906 100644 (file)
--- a/src/device_status/activity.cpp
+++ b/src/device_status/activity.cpp
@@ -21,7 +21,6 @@
 struct activity_recog_s {
        const char *name;
        activity_h handle;
-       ctx::string_set_t client_zone;
        activity_recog_s() : name(NULL), handle(NULL) {}
 };
 
@@ -51,7 +50,6 @@ ctx::device_status_activity::~device_status_activity()
                if (activity_recog[i].handle == NULL) continue;
                activity_release(activity_recog[i].handle);
                activity_recog[i].handle = NULL;
-               activity_recog[i].client_zone.clear();
        }
 }
 
@@ -84,10 +82,10 @@ void ctx::device_status_activity::handle_event(activity_type_e activity, const a
                break;
        }
 
-       publish(activity_recog[activity].name, ERR_NONE, data_read, activity_recog[activity].client_zone);
+       publish(activity_recog[activity].name, ERR_NONE, data_read);
 }
 
-int ctx::device_status_activity::subscribe(const char* subject, const char* zone)
+int ctx::device_status_activity::subscribe(const char* subject)
 {
        int act_num = get_activity_id(subject);
        IF_FAIL_RETURN(act_num > 0, ERR_INVALID_PARAMETER);
@@ -115,17 +113,15 @@ int ctx::device_status_activity::subscribe(const char* subject, const char* zone
        activity_recog[act_num].handle = handle;
 
 CATCH:
-       activity_recog[act_num].client_zone.insert(zone);
        return ERR_NONE;
 }
 
-int ctx::device_status_activity::unsubscribe(const char* subject, const char* zone)
+int ctx::device_status_activity::unsubscribe(const char* subject)
 {
        int act_num = get_activity_id(subject);
        IF_FAIL_RETURN(act_num > 0, ERR_INVALID_PARAMETER);
 
-       activity_recog[act_num].client_zone.erase(zone);
-       IF_FAIL_RETURN(activity_recog[act_num].client_zone.empty(), ERR_NONE);
+       IF_FAIL_RETURN(activity_recog[act_num].handle, ERR_NONE);
 
        _D("Stop monitoring %s", subject);
 
@@ -136,7 +132,7 @@ int ctx::device_status_activity::unsubscribe(const char* subject, const char* zo
        return ERR_NONE;
 }
 
-bool ctx::device_status_activity::is_supported(const char* subject, const char* zone)
+bool ctx::device_status_activity::is_supported(const char* subject)
 {
        bool supported = false;
        activity_is_supported(static_cast<activity_type_e>(get_activity_id(subject)), &supported);

diff --git a/src/device_status/activity.h b/src/device_status/activity.h
index 3e358c5..7b72420 100644 (file)
--- a/src/device_status/activity.h
+++ b/src/device_status/activity.h
@@ -27,9 +27,9 @@ namespace ctx {
                        device_status_activity();
                        ~device_status_activity();
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
-                       bool is_supported(const char* subject, const char* zone);
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
+                       bool is_supported(const char* subject);
 
                private:
                        void handle_event(activity_type_e activity, const activity_data_h data, double timestamp);

diff --git a/src/device_status/battery.cpp b/src/device_status/battery.cpp
index cb81362..bd89cd7 100644 (file)
--- a/src/device_status/battery.cpp
+++ b/src/device_status/battery.cpp
@@ -50,6 +50,11 @@ static const char* trans_to_string(intptr_t level)
        }
 }
 
+ctx::device_status_battery_level::device_status_battery_level()
+       : being_subscribed(false)
+{
+}
+
 void ctx::device_status_battery_level::update_cb(device_callback_e device_type, void* value, void* user_data)
 {
        IF_FAIL_VOID(device_type == DEVICE_CALLBACK_BATTERY_LEVEL);
@@ -74,32 +79,30 @@ void ctx::device_status_battery_level::handle_update(device_callback_e device_ty
 
        data_read.set(NULL, DEVICE_ST_IS_CHARGING, charging_state ? DEVICE_ST_TRUE : DEVICE_ST_FALSE);
 
-       publish(DEVICE_ST_SUBJ_BATTERY, ERR_NONE, data_read, client_zone);
+       publish(DEVICE_ST_SUBJ_BATTERY, ERR_NONE, data_read);
 }
 
-int ctx::device_status_battery_level::subscribe(const char* subject, const char* zone)
+int ctx::device_status_battery_level::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                int ret = device_add_callback(DEVICE_CALLBACK_BATTERY_LEVEL, update_cb, this);
                IF_FAIL_RETURN(ret == DEVICE_ERROR_NONE, ERR_OPERATION_FAILED);
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
-int ctx::device_status_battery_level::unsubscribe(const char* subject, const char* zone)
+int ctx::device_status_battery_level::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
-
+       being_subscribed = false;
        int ret = device_remove_callback(DEVICE_CALLBACK_BATTERY_LEVEL, update_cb);
        IF_FAIL_RETURN(ret == DEVICE_ERROR_NONE, ERR_OPERATION_FAILED);
 
        return ERR_NONE;
 }
 
-int ctx::device_status_battery_level::read(const char* subject, const char* zone)
+int ctx::device_status_battery_level::read(const char* subject)
 {
        device_battery_level_e level;
        ctx::json data_read;
@@ -118,6 +121,6 @@ int ctx::device_status_battery_level::read(const char* subject, const char* zone
 
        data_read.set(NULL, DEVICE_ST_IS_CHARGING, charging_state ? DEVICE_ST_TRUE : DEVICE_ST_FALSE);
 
-       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_BATTERY, NULL, ERR_NONE, data_read, zone);
+       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_BATTERY, NULL, ERR_NONE, data_read);
        return ERR_NONE;
 }

diff --git a/src/device_status/battery.h b/src/device_status/battery.h
index 118764f..2f08071 100644 (file)
--- a/src/device_status/battery.h
+++ b/src/device_status/battery.h
@@ -25,14 +25,15 @@ namespace ctx {
 
        class device_status_battery_level : public sub_provider_base {
                public:
+                       device_status_battery_level();
                        ~device_status_battery_level(){}
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
-                       int read(const char* subject, const char* zone);
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
+                       int read(const char* subject);
 
                private:
-                       string_set_t client_zone;
+                       bool being_subscribed;
 
                        void handle_update(device_callback_e device_type, void* value);
                        static void update_cb(device_callback_e device_type, void* value, void* user_data);

diff --git a/src/device_status/headphone.cpp b/src/device_status/headphone.cpp
index a3765f0..3782460 100644 (file)
--- a/src/device_status/headphone.cpp
+++ b/src/device_status/headphone.cpp
@@ -20,7 +20,8 @@
 #define MAX_HANDLING_COUNT 3
 
 ctx::device_status_headphone::device_status_headphone()
-       : connected(false)
+       : being_subscribed(false)
+       , connected(false)
        , audio_jack_state(RUNTIME_INFO_AUDIO_JACK_STATUS_UNCONNECTED)
        , bt_audio_state(false)
        , bt_audio_callback_on(false)
@@ -29,9 +30,9 @@ ctx::device_status_headphone::device_status_headphone()
 {
 }
 
-int ctx::device_status_headphone::subscribe(const char* subject, const char* zone)
+int ctx::device_status_headphone::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                connected = get_current_status();
 
                // Wired headphone
@@ -42,14 +43,13 @@ int ctx::device_status_headphone::subscribe(const char* subject, const char* zon
                set_bt_audio_callback();
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
-int ctx::device_status_headphone::unsubscribe(const char* subject, const char* zone)
+int ctx::device_status_headphone::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
+       being_subscribed = false;
 
        runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_AUDIO_JACK_STATUS);
        unset_bt_audio_callback();
@@ -57,14 +57,14 @@ int ctx::device_status_headphone::unsubscribe(const char* subject, const char* z
        return ERR_NONE;
 }
 
-int ctx::device_status_headphone::read(const char* subject, const char* zone)
+int ctx::device_status_headphone::read(const char* subject)
 {
-       if (client_zone.empty())
+       if (!being_subscribed)
                connected = get_current_status();
 
        json data;
        generate_data_packet(data);
-       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_HEADPHONE, NULL, ERR_NONE, data, zone);
+       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_HEADPHONE, NULL, ERR_NONE, data);
 
        return ERR_NONE;
 }
@@ -150,7 +150,7 @@ bool ctx::device_status_headphone::handle_event()
 
        ctx::json data;
        generate_data_packet(data);
-       publish(DEVICE_ST_SUBJ_HEADPHONE, ERR_NONE, data, client_zone);
+       publish(DEVICE_ST_SUBJ_HEADPHONE, ERR_NONE, data);
        return true;
 }
 

diff --git a/src/device_status/headphone.h b/src/device_status/headphone.h
index 0f5bb67..9357d4e 100644 (file)
--- a/src/device_status/headphone.h
+++ b/src/device_status/headphone.h
@@ -29,13 +29,12 @@ namespace ctx {
                        device_status_headphone();
                        ~device_status_headphone() {}
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
-                       int read(const char* subject, const char* zone);
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
+                       int read(const char* subject);
 
                private:
-                       string_set_t client_zone;
-
+                       bool being_subscribed;
                        bool connected;
                        int audio_jack_state;
                        bool bt_audio_state;

diff --git a/src/device_status/psmode.cpp b/src/device_status/psmode.cpp
index 5a050ac..f14c91d 100644 (file)
--- a/src/device_status/psmode.cpp
+++ b/src/device_status/psmode.cpp
@@ -16,6 +16,11 @@
 
 #include "psmode.h"
 
+ctx::device_status_power_saving_mode::device_status_power_saving_mode()
+       : being_subscribed(false)
+{
+}
+
 void ctx::device_status_power_saving_mode::update_cb(keynode_t *node, void* user_data)
 {
        device_status_power_saving_mode *instance = static_cast<device_status_power_saving_mode*>(user_data);
@@ -32,24 +37,23 @@ void ctx::device_status_power_saving_mode::handle_update(keynode_t *node)
 
        data_read.set(NULL, DEVICE_ST_IS_ENABLED, status == 0 ? DEVICE_ST_FALSE : DEVICE_ST_TRUE);
 
-       publish(DEVICE_ST_SUBJ_POWER_SAVING_MODE, ERR_NONE, data_read, client_zone);
+       publish(DEVICE_ST_SUBJ_POWER_SAVING_MODE, ERR_NONE, data_read);
 }
 
-int ctx::device_status_power_saving_mode::subscribe(const char* subject, const char* zone)
+int ctx::device_status_power_saving_mode::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                int ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE, update_cb, this);
                IF_FAIL_RETURN(ret == VCONF_OK, ERR_OPERATION_FAILED);
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
-int ctx::device_status_power_saving_mode::unsubscribe(const char* subject, const char* zone)
+int ctx::device_status_power_saving_mode::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
+       being_subscribed = false;
 
        int ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_PSMODE, update_cb);
        IF_FAIL_RETURN(ret == VCONF_OK, ERR_OPERATION_FAILED);
@@ -57,7 +61,7 @@ int ctx::device_status_power_saving_mode::unsubscribe(const char* subject, const
        return ERR_NONE;
 }
 
-int ctx::device_status_power_saving_mode::read(const char* subject, const char* zone)
+int ctx::device_status_power_saving_mode::read(const char* subject)
 {
        int mode;
        int ret = vconf_get_int(VCONFKEY_SETAPPL_PSMODE, &mode);
@@ -66,6 +70,6 @@ int ctx::device_status_power_saving_mode::read(const char* subject, const char*
        ctx::json data_read;
        data_read.set(NULL, DEVICE_ST_IS_ENABLED, mode == 0 ? DEVICE_ST_FALSE : DEVICE_ST_TRUE);
 
-       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_POWER_SAVING_MODE, NULL, ERR_NONE, data_read, zone);
+       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_POWER_SAVING_MODE, NULL, ERR_NONE, data_read);
        return ERR_NONE;
 }

diff --git a/src/device_status/psmode.h b/src/device_status/psmode.h
index 0d2d82a..85bbe39 100644 (file)
--- a/src/device_status/psmode.h
+++ b/src/device_status/psmode.h
@@ -24,14 +24,15 @@ namespace ctx {
 
        class device_status_power_saving_mode : public sub_provider_base {
                public:
+                       device_status_power_saving_mode();
                        ~device_status_power_saving_mode(){}
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
-                       int read(const char* subject, const char* zone);
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
+                       int read(const char* subject);
 
                private:
-                       string_set_t client_zone;
+                       bool being_subscribed;
 
                        void handle_update(keynode_t *node);
                        static void update_cb(keynode_t *node, void* user_data);

diff --git a/src/device_status/runtime-info/base_rtinfo.cpp b/src/device_status/runtime-info/base_rtinfo.cpp
index 0a6d640..59ccdbc 100644 (file)
--- a/src/device_status/runtime-info/base_rtinfo.cpp
+++ b/src/device_status/runtime-info/base_rtinfo.cpp
@@ -17,7 +17,8 @@
 #include "base_rtinfo.h"
 
 ctx::device_status_runtime_info::device_status_runtime_info(runtime_info_key_e key)
-       : info_key (key)
+       : being_subscribed(false)
+       , info_key(key)
 {
 }
 
@@ -33,21 +34,20 @@ void ctx::device_status_runtime_info::update_cb(runtime_info_key_e key, void* us
        instance->handle_update();
 }
 
-int ctx::device_status_runtime_info::subscribe(const char* subject, const char* zone)
+int ctx::device_status_runtime_info::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                int ret = runtime_info_set_changed_cb(info_key, update_cb, this);
                IF_FAIL_RETURN(ret == RUNTIME_INFO_ERROR_NONE, ERR_OPERATION_FAILED);
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
-int ctx::device_status_runtime_info::unsubscribe(const char* subject, const char* zone)
+int ctx::device_status_runtime_info::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
+       being_subscribed = false;
 
        int ret = runtime_info_unset_changed_cb(info_key);
        IF_FAIL_RETURN(ret == RUNTIME_INFO_ERROR_NONE, ERR_OPERATION_FAILED);

diff --git a/src/device_status/runtime-info/base_rtinfo.h b/src/device_status/runtime-info/base_rtinfo.h
index 79a8dbd..165eec3 100644 (file)
--- a/src/device_status/runtime-info/base_rtinfo.h
+++ b/src/device_status/runtime-info/base_rtinfo.h
@@ -29,12 +29,12 @@ namespace ctx {
                        device_status_runtime_info(runtime_info_key_e key);
                        virtual ~device_status_runtime_info(){}
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
-                       virtual int read(const char* subject, const char* zone) = 0;
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
+                       virtual int read(const char* subject) = 0;
 
                protected:
-                       string_set_t client_zone;
+                       bool being_subscribed;
                        runtime_info_key_e info_key;
 
                        static void update_cb(runtime_info_key_e runtime_key, void* user_data);

diff --git a/src/device_status/runtime-info/charger.cpp b/src/device_status/runtime-info/charger.cpp
index 21094f7..b4bbf94 100644 (file)
--- a/src/device_status/runtime-info/charger.cpp
+++ b/src/device_status/runtime-info/charger.cpp
@@ -26,10 +26,10 @@ void ctx::device_status_charger::handle_update()
        ctx::json data_read;
        data_read.set(NULL, DEVICE_ST_IS_CONNECTED, charger_status ? DEVICE_ST_TRUE : DEVICE_ST_FALSE);
 
-       publish(DEVICE_ST_SUBJ_CHARGER, ERR_NONE, data_read, client_zone);
+       publish(DEVICE_ST_SUBJ_CHARGER, ERR_NONE, data_read);
 }
 
-int ctx::device_status_charger::read(const char* subject, const char* zone)
+int ctx::device_status_charger::read(const char* subject)
 {
        bool charger_status = false;
        ctx::json data_read;
@@ -39,6 +39,6 @@ int ctx::device_status_charger::read(const char* subject, const char* zone)
 
        data_read.set(NULL, DEVICE_ST_IS_CONNECTED, charger_status ? DEVICE_ST_TRUE : DEVICE_ST_FALSE);
 
-       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_CHARGER, NULL, ERR_NONE, data_read, zone);
+       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_CHARGER, NULL, ERR_NONE, data_read);
        return ERR_NONE;
 }

diff --git a/src/device_status/runtime-info/charger.h b/src/device_status/runtime-info/charger.h
index 11dba52..0e474bd 100644 (file)
--- a/src/device_status/runtime-info/charger.h
+++ b/src/device_status/runtime-info/charger.h
@@ -26,7 +26,7 @@ namespace ctx {
                        device_status_charger() : device_status_runtime_info(RUNTIME_INFO_KEY_CHARGER_CONNECTED) {}
                        ~device_status_charger(){}
 
-                       int read(const char* subject, const char* zone);
+                       int read(const char* subject);
 
                private:
                        void handle_update();

diff --git a/src/device_status/runtime-info/gps.cpp b/src/device_status/runtime-info/gps.cpp
index 81bc982..8bf741c 100644 (file)
--- a/src/device_status/runtime-info/gps.cpp
+++ b/src/device_status/runtime-info/gps.cpp
@@ -48,10 +48,10 @@ void ctx::device_status_gps::handle_update()
 
        data_read.set(NULL, DEVICE_ST_STATE, state_str);
 
-       publish(DEVICE_ST_SUBJ_GPS, ERR_NONE, data_read, client_zone);
+       publish(DEVICE_ST_SUBJ_GPS, ERR_NONE, data_read);
 }
 
-int ctx::device_status_gps::read(const char* subject, const char* zone)
+int ctx::device_status_gps::read(const char* subject)
 {
        int gps_status;
        ctx::json data_read;
@@ -64,11 +64,11 @@ int ctx::device_status_gps::read(const char* subject, const char* zone)
 
        data_read.set(NULL, DEVICE_ST_STATE, state_str);
 
-       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_GPS, NULL, ERR_NONE, data_read, zone);
+       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_GPS, NULL, ERR_NONE, data_read);
        return ERR_NONE;
 }
 
-bool ctx::device_status_gps::is_supported(const char* subject, const char* zone)
+bool ctx::device_status_gps::is_supported(const char* subject)
 {
        bool supported = false;
 

diff --git a/src/device_status/runtime-info/gps.h b/src/device_status/runtime-info/gps.h
index 1bd5246..6754a7e 100644 (file)
--- a/src/device_status/runtime-info/gps.h
+++ b/src/device_status/runtime-info/gps.h
@@ -26,8 +26,8 @@ namespace ctx {
                        device_status_gps() : device_status_runtime_info(RUNTIME_INFO_KEY_GPS_STATUS) {}
                        ~device_status_gps(){}
 
-                       int read(const char* subject, const char* zone);
-                       bool is_supported(const char* subject, const char* zone);
+                       int read(const char* subject);
+                       bool is_supported(const char* subject);
 
                private:
                        void handle_update();

diff --git a/src/device_status/runtime-info/usb.cpp b/src/device_status/runtime-info/usb.cpp
index a8a206a..4b62f94 100644 (file)
--- a/src/device_status/runtime-info/usb.cpp
+++ b/src/device_status/runtime-info/usb.cpp
@@ -27,10 +27,10 @@ void ctx::device_status_usb::handle_update()
        ctx::json data_read;
        data_read.set(NULL, DEVICE_ST_IS_CONNECTED, status ? DEVICE_ST_TRUE : DEVICE_ST_FALSE);
 
-       publish(DEVICE_ST_SUBJ_USB, ERR_NONE, data_read, client_zone);
+       publish(DEVICE_ST_SUBJ_USB, ERR_NONE, data_read);
 }
 
-int ctx::device_status_usb::read(const char* subject, const char* zone)
+int ctx::device_status_usb::read(const char* subject)
 {
        bool status = false;
        ctx::json data_read;
@@ -40,11 +40,11 @@ int ctx::device_status_usb::read(const char* subject, const char* zone)
 
        data_read.set(NULL, DEVICE_ST_IS_CONNECTED, status ? DEVICE_ST_TRUE : DEVICE_ST_FALSE);
 
-       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_USB, NULL, ERR_NONE, data_read, zone);
+       ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_USB, NULL, ERR_NONE, data_read);
        return ERR_NONE;
 }
 
-bool ctx::device_status_usb::is_supported(const char* subject, const char* zone)
+bool ctx::device_status_usb::is_supported(const char* subject)
 {
        bool supported = false;
 

diff --git a/src/device_status/runtime-info/usb.h b/src/device_status/runtime-info/usb.h
index 1093461..19e5e92 100644 (file)
--- a/src/device_status/runtime-info/usb.h
+++ b/src/device_status/runtime-info/usb.h
@@ -26,8 +26,8 @@ namespace ctx {
                        device_status_usb() : device_status_runtime_info(RUNTIME_INFO_KEY_USB_CONNECTED) {}
                        ~device_status_usb(){}
 
-                       int read(const char* subject, const char* zone);
-                       bool is_supported(const char* subject, const char* zone);
+                       int read(const char* subject);
+                       bool is_supported(const char* subject);
 
                private:
                        void handle_update();

diff --git a/src/device_status/wifi.cpp b/src/device_status/wifi.cpp
index 97bbd25..0dc29b3 100644 (file)
--- a/src/device_status/wifi.cpp
+++ b/src/device_status/wifi.cpp
@@ -18,13 +18,14 @@
 #include "wifi.h"
 
 ctx::device_status_wifi::device_status_wifi()
-       : last_state(_UNKNOWN)
+       : being_subscribed(false)
+       , last_state(_UNKNOWN)
        , is_initialized(false)
        , is_activated(false)
 {
 }
 
-bool ctx::device_status_wifi::is_supported(const char* subject, const char* zone)
+bool ctx::device_status_wifi::is_supported(const char* subject)
 {
        bool supported = false;
 
@@ -110,14 +111,14 @@ bool ctx::device_status_wifi::get_response_packet(ctx::json &data)
        return true;
 }
 
-int ctx::device_status_wifi::read(const char* subject, const char* zone)
+int ctx::device_status_wifi::read(const char* subject)
 {
        IF_FAIL_RETURN(get_current_state(), ERR_OPERATION_FAILED);
 
        ctx::json data_read;
 
        if (get_response_packet(data_read)) {
-               ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_WIFI, NULL, ERR_NONE, data_read, zone);
+               ctx::context_manager::reply_to_read(DEVICE_ST_SUBJ_WIFI, NULL, ERR_NONE, data_read);
                return ERR_NONE;
        }
 
@@ -156,9 +157,9 @@ void ctx::device_status_wifi::stop_monitor()
        is_initialized = false;
 }
 
-int ctx::device_status_wifi::subscribe(const char* subject, const char* zone)
+int ctx::device_status_wifi::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                IF_FAIL_RETURN(start_monitor(), ERR_OPERATION_FAILED);
                if (!get_current_state()) {
                        stop_monitor();
@@ -166,14 +167,13 @@ int ctx::device_status_wifi::subscribe(const char* subject, const char* zone)
                }
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
-int ctx::device_status_wifi::unsubscribe(const char* subject, const char* zone)
+int ctx::device_status_wifi::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
+       being_subscribed = false;
 
        stop_monitor();
        return ERR_NONE;
@@ -199,7 +199,7 @@ void ctx::device_status_wifi::aggregate_updated_data()
 
                ctx::json data;
                if (get_response_packet(data))
-                       publish(DEVICE_ST_SUBJ_WIFI, ERR_NONE, data, client_zone);
+                       publish(DEVICE_ST_SUBJ_WIFI, ERR_NONE, data);
        }
 }
 

diff --git a/src/device_status/wifi.h b/src/device_status/wifi.h
index 2ee2c14..2cb7779 100644 (file)
--- a/src/device_status/wifi.h
+++ b/src/device_status/wifi.h
@@ -28,10 +28,10 @@ namespace ctx {
                device_status_wifi();
                ~device_status_wifi(){}
 
-               int subscribe(const char* subject, const char* zone);
-               int unsubscribe(const char* subject, const char* zone);
-               int read(const char* subject, const char* zone);
-               bool is_supported(const char* subject, const char* zone);
+               int subscribe(const char* subject);
+               int unsubscribe(const char* subject);
+               int read(const char* subject);
+               bool is_supported(const char* subject);
 
        private:
                enum _state_e {
@@ -41,8 +41,7 @@ namespace ctx {
                        _CONNECTED,
                };
 
-               string_set_t client_zone;
-
+               bool being_subscribed;
                int last_state;
                bool is_initialized;
                bool is_activated;

diff --git a/src/social_status/call.cpp b/src/social_status/call.cpp
index 97461ae..97d58ca 100644 (file)
--- a/src/social_status/call.cpp
+++ b/src/social_status/call.cpp
@@ -33,6 +33,7 @@ static void call_status_cb(TelCallStatus_t *out, void *user_data)
 }
 
 ctx::social_status_call::social_status_call()
+       : being_subscribed(false)
 {
        tapi_handle = NULL;
 }
@@ -84,7 +85,7 @@ void ctx::social_status_call::handle_call_event(telephony_h handle, telephony_no
                break;
        }
 
-       publish(SOCIAL_ST_SUBJ_CALL, ERR_NONE, data, client_zone);
+       publish(SOCIAL_ST_SUBJ_CALL, ERR_NONE, data);
 }
 
 bool ctx::social_status_call::init_telephony()
@@ -164,23 +165,21 @@ bool ctx::social_status_call::get_call_address(std::string& address)
        return true;
 }
 
-int ctx::social_status_call::subscribe(const char* subject, const char* zone)
+int ctx::social_status_call::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                bool ret = set_callback();
                IF_FAIL_RETURN(ret, ERR_OPERATION_FAILED);
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
 
-int ctx::social_status_call::unsubscribe(const char* subject, const char* zone)
+int ctx::social_status_call::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
-
+       being_subscribed = false;
        unset_callback();
        return ERR_NONE;
 }
@@ -216,7 +215,7 @@ bool ctx::social_status_call::read_current_status(ctx::json& data)
        return true;
 }
 
-int ctx::social_status_call::read(const char* subject, const char* zone)
+int ctx::social_status_call::read(const char* subject)
 {
        bool temporary_handle = false;
        if (!telephony_initialized) {
@@ -231,14 +230,14 @@ int ctx::social_status_call::read(const char* subject, const char* zone)
                release_telephony();
 
        if (ret) {
-               ctx::context_manager::reply_to_read(SOCIAL_ST_SUBJ_CALL, NULL, ERR_NONE, data, zone);
+               ctx::context_manager::reply_to_read(SOCIAL_ST_SUBJ_CALL, NULL, ERR_NONE, data);
                return ERR_NONE;
        }
 
        return ERR_OPERATION_FAILED;
 }
 
-bool ctx::social_status_call::is_supported(const char* subject, const char* zone)
+bool ctx::social_status_call::is_supported(const char* subject)
 {
        bool supported = false;
        int ret = system_info_get_platform_bool("tizen.org/feature/network.telephony", &supported);

diff --git a/src/social_status/call.h b/src/social_status/call.h
index b93cf69..27035fc 100644 (file)
--- a/src/social_status/call.h
+++ b/src/social_status/call.h
@@ -27,14 +27,14 @@ namespace ctx {
                        social_status_call();
                        ~social_status_call();
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
-                       int read(const char* subject, const char* zone);
-                       bool is_supported(const char* subject, const char* zone);
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
+                       int read(const char* subject);
+                       bool is_supported(const char* subject);
 
                private:
                        telephony_handle_list_s handle_list;
-                       string_set_t client_zone;
+                       bool being_subscribed;
 
                        bool init_telephony();
                        void release_telephony();

diff --git a/src/social_status/email.cpp b/src/social_status/email.cpp
index 4ae058c..e4ea558 100644 (file)
--- a/src/social_status/email.cpp
+++ b/src/social_status/email.cpp
@@ -21,6 +21,10 @@
 #include <dbus_server.h>
 #include "email.h"
 
+ctx::social_status_email::social_status_email()
+       : being_subscribed(false)
+{
+}
 
 void ctx::social_status_email::on_signal_received(const char* sender, const char* path, const char* iface, const char* name, GVariant* param)
 {
@@ -37,34 +41,32 @@ void ctx::social_status_email::on_signal_received(const char* sender, const char
                _D("sub type: %d, gi1: %d, gc: %s, gi2: %d, gi3: %d", sub_type, gi1, gc, gi2, gi3);
                ctx::json data_updated;
                data_updated.set(NULL, SOCIAL_ST_EVENT, SOCIAL_ST_RECEIVED);
-               publish(SOCIAL_ST_SUBJ_EMAIL, ERR_NONE, data_updated, client_zone);
+               publish(SOCIAL_ST_SUBJ_EMAIL, ERR_NONE, data_updated);
 
        } else if (sub_type == NOTI_SEND_FINISH) {
                _D("sub type: %d, gi1: %d, gc: %s, gi2: %d, gi3: %d", sub_type, gi1, gc, gi2, gi3);
                ctx::json data_updated;
                data_updated.set(NULL, SOCIAL_ST_EVENT, SOCIAL_ST_SENT);
-               publish(SOCIAL_ST_SUBJ_EMAIL, ERR_NONE, data_updated, client_zone);
+               publish(SOCIAL_ST_SUBJ_EMAIL, ERR_NONE, data_updated);
        }
 }
 
 
-int ctx::social_status_email::subscribe(const char* subject, const char* zone)
+int ctx::social_status_email::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                dbus_signal_id = ctx::dbus_server::signal_subscribe(NULL, NULL, "User.Email.NetworkStatus", "email", this);
                IF_FAIL_RETURN_TAG(dbus_signal_id >= 0, ERR_OPERATION_FAILED, _E, "Email dbus signal subscription failed");
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
 
-int ctx::social_status_email::unsubscribe(const char* subject, const char* zone)
+int ctx::social_status_email::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
-
+       being_subscribed = false;
        ctx::dbus_server::signal_unsubscribe(dbus_signal_id);
        return ERR_NONE;
 }

diff --git a/src/social_status/email.h b/src/social_status/email.h
index 7e86805..e7a17f1 100644 (file)
--- a/src/social_status/email.h
+++ b/src/social_status/email.h
@@ -24,17 +24,17 @@ namespace ctx {
 
        class social_status_email : public sub_provider_base, public dbus_listener_iface {
                public:
-                       social_status_email() {}
+                       social_status_email();
                        ~social_status_email() {}
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
 
                        void on_signal_received(const char* sender, const char* path, const char* iface, const char* name, GVariant* param);
 
                private:
                        int64_t dbus_signal_id;
-                       string_set_t client_zone;
+                       bool being_subscribed;
        };
 }
 

diff --git a/src/social_status/message.cpp b/src/social_status/message.cpp
index 1e46259..ae6a753 100644 (file)
--- a/src/social_status/message.cpp
+++ b/src/social_status/message.cpp
@@ -22,6 +22,7 @@
 
 ctx::social_status_message::social_status_message()
        : message_handle(NULL)
+       , being_subscribed(false)
 {
 }
 
@@ -68,7 +69,7 @@ void ctx::social_status_message::handle_state_change(msg_struct_t msg)
        data.set(NULL, SOCIAL_ST_EVENT, SOCIAL_ST_RECEIVED);
        data.set(NULL, SOCIAL_ST_ADDRESS, address);
 
-       publish(SOCIAL_ST_SUBJ_MESSAGE, ERR_NONE, data, client_zone);
+       publish(SOCIAL_ST_SUBJ_MESSAGE, ERR_NONE, data);
 }
 
 bool ctx::social_status_message::set_callback()
@@ -97,27 +98,25 @@ void ctx::social_status_message::unset_callback()
        message_handle = NULL;
 }
 
-int ctx::social_status_message::subscribe(const char* subject, const char* zone)
+int ctx::social_status_message::subscribe(const char* subject)
 {
-       if (client_zone.empty()) {
+       if (!being_subscribed) {
                bool ret = set_callback();
                IF_FAIL_RETURN(ret, ERR_OPERATION_FAILED);
        }
 
-       client_zone.insert(zone);
+       being_subscribed = true;
        return ERR_NONE;
 }
 
-int ctx::social_status_message::unsubscribe(const char* subject, const char* zone)
+int ctx::social_status_message::unsubscribe(const char* subject)
 {
-       client_zone.erase(zone);
-       IF_FAIL_RETURN(client_zone.empty(), ERR_NONE);
-
+       being_subscribed = false;
        unset_callback();
        return ERR_NONE;
 }
 
-bool ctx::social_status_message::is_supported(const char* subject, const char* zone)
+bool ctx::social_status_message::is_supported(const char* subject)
 {
        bool supported = false;
        int ret = system_info_get_platform_bool("tizen.org/feature/network.telephony", &supported);

diff --git a/src/social_status/message.h b/src/social_status/message.h
index d651de9..e9dbc86 100644 (file)
--- a/src/social_status/message.h
+++ b/src/social_status/message.h
@@ -28,13 +28,13 @@ namespace ctx {
                        social_status_message();
                        ~social_status_message() {}
 
-                       int subscribe(const char* subject, const char* zone);
-                       int unsubscribe(const char* subject, const char* zone);
-                       bool is_supported(const char* subject, const char* zone);
+                       int subscribe(const char* subject);
+                       int unsubscribe(const char* subject);
+                       bool is_supported(const char* subject);
 
                private:
                        msg_handle_t message_handle;
-                       string_set_t client_zone;
+                       bool being_subscribed;
 
                        bool set_callback();
                        void unset_callback();

diff --git a/src/sub_provider_base.cpp b/src/sub_provider_base.cpp
index 2094bdf..829f8ce 100644 (file)
--- a/src/sub_provider_base.cpp
+++ b/src/sub_provider_base.cpp
@@ -16,32 +16,30 @@
 
 #include "sub_provider_base.h"
 
-int ctx::sub_provider_base::subscribe(const char* subject, const char* zone)
+int ctx::sub_provider_base::subscribe(const char* subject)
 {
        return ERR_NOT_SUPPORTED;
 }
 
-int ctx::sub_provider_base::unsubscribe(const char* subject, const char* zone)
+int ctx::sub_provider_base::unsubscribe(const char* subject)
 {
        return ERR_NOT_SUPPORTED;
 }
 
-int ctx::sub_provider_base::read(const char* subject, const char* zone)
+int ctx::sub_provider_base::read(const char* subject)
 {
        return ERR_NOT_SUPPORTED;
 }
 
-bool ctx::sub_provider_base::is_supported(const char* subject, const char* zone)
+bool ctx::sub_provider_base::is_supported(const char* subject)
 {
        // Generally, if a sub-analyzer is implemented by inheriting this class, "subject" is supported.
        return true;
 }
 
-void ctx::sub_provider_base::publish(const char* subject, int error, ctx::json data, string_set_t& zone_list)
+void ctx::sub_provider_base::publish(const char* subject, int error, ctx::json data)
 {
        ctx::json option;
-       for (string_set_t::iterator it = zone_list.begin(); it != zone_list.end(); ++it) {
-               _D("Publishing '%s' on '%s'", subject, (*it).c_str());
-               ctx::context_manager::publish(subject, option, error, data, (*it).c_str());
-       }
+       _D("Publishing '%s'", subject);
+       ctx::context_manager::publish(subject, option, error, data);
 }

diff --git a/src/sub_provider_base.h b/src/sub_provider_base.h
index e20192b..de1bc60 100644 (file)
--- a/src/sub_provider_base.h
+++ b/src/sub_provider_base.h
@@ -27,20 +27,18 @@
 
 namespace ctx {
 
-       typedef std::set<std::string> string_set_t;
-
        class sub_provider_base {
                public:
                        sub_provider_base(){}
                        virtual ~sub_provider_base(){}
 
-                       virtual int subscribe(const char* subject, const char* zone);
-                       virtual int unsubscribe(const char* subject, const char* zone);
-                       virtual int read(const char* subject, const char* zone);
-                       virtual bool is_supported(const char* subject, const char* zone);
+                       virtual int subscribe(const char* subject);
+                       virtual int unsubscribe(const char* subject);
+                       virtual int read(const char* subject);
+                       virtual bool is_supported(const char* subject);
 
                protected:
-                       void publish(const char* subject, int error, ctx::json data, string_set_t& zone_list);
+                       void publish(const char* subject, int error, ctx::json data);
        };
 }