src/modules/tizen/VConf/Key.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 #include "Key.h"
  17 #include <cassert>
  18 #include <Commons/Exception.h>
  19
  20 namespace WrtDeviceApis {
  21 namespace VConf {
  22 Key::Key(const char* name) :
  23     m_callback(NULL),
  24     m_callbackData(NULL)
  25 {
  26     if (name != NULL) {
  27         m_name = name;
  28     }
  29 }
  30
  31 Key::~Key()
  32 {
  33     detachCallback();
  34 }
  35
  36 bool Key::attachCallback(KeyChangeCallback callback,
  37         void* data)
  38 {
  39     assert(!m_name.empty() && "Key name cannot be empty.");
  40     if (!callback) {
  41         return false;
  42     }
  43
  44     DPL::Mutex::ScopedLock lock(&m_mtx);
  45     bool firstTime = (m_callback == NULL);
  46     m_callback = callback;
  47     m_callbackData = data;
  48
  49     if (firstTime) {
  50         if (vconf_notify_key_changed(m_name.c_str(), Key::callback,
  51                                      this) != 0) {
  52             m_callback = NULL;
  53             m_callbackData = NULL;
  54             return false;
  55         }
  56     }
  57
  58     return true;
  59 }
  60
  61 void Key::detachCallback()
  62 {
  63     DPL::Mutex::ScopedLock lock(&m_mtx);
  64     if (m_callback) {
  65         assert(!m_name.empty() && "Key name cannot be empty.");
  66         vconf_ignore_key_changed(m_name.c_str(), Key::callback);
  67         m_callback = NULL;
  68         m_callbackData = NULL;
  69     }
  70 }
  71
  72 void Key::callback(keynode_t* node,
  73         void* data)
  74 {
  75     Key* this_ = static_cast<Key*>(data);
  76     if (this_) {
  77         DPL::Mutex::ScopedLock lock(&this_->m_mtx);
  78         if (this_->m_callback) {
  79             NodePtr ptr(new Node(node));
  80             (*this_->m_callback)(ptr.Get(), this_->m_callbackData);
  81         }
  82     }
  83 }
  84
  85 bool Key::getBool() const
  86 {
  87     assert(!m_name.empty() && "Key name cannot be empty.");
  88     int result = 0;
  89     if (vconf_get_bool(m_name.c_str(), &result) != 0) {
  90         Throw(Commons::ConversionException);
  91     }
  92     return (result != 0);
  93 }
  94
  95 void Key::setValue(bool value)
  96 {
  97     assert(!m_name.empty() && "Key name cannot be empty.");
  98     if (vconf_set_bool(m_name.c_str(), value) != 0) {
  99         Throw(Commons::PlatformException);
 100     }
 101 }
 102
 103 int Key::getInt() const
 104 {
 105     assert(!m_name.empty() && "Key name cannot be empty.");
 106     int result = 0;
 107     if (vconf_get_int(m_name.c_str(), &result) != 0) {
 108         Throw(Commons::ConversionException);
 109     }
 110     return result;
 111 }
 112
 113 void Key::setValue(int value)
 114 {
 115     assert(!m_name.empty() && "Key name cannot be empty.");
 116     if (vconf_set_int(m_name.c_str(), value) != 0) {
 117         Throw(Commons::PlatformException);
 118     }
 119 }
 120
 121 double Key::getDouble() const
 122 {
 123     assert(!m_name.empty() && "Key name cannot be empty.");
 124     double result = 0;
 125     if (vconf_get_dbl(m_name.c_str(), &result) != 0) {
 126         Throw(Commons::ConversionException);
 127     }
 128     return result;
 129 }
 130
 131 void Key::setValue(double value)
 132 {
 133     assert(!m_name.empty() && "Key name cannot be empty.");
 134     if (vconf_set_dbl(m_name.c_str(), value) != 0) {
 135         Throw(Commons::PlatformException);
 136     }
 137 }
 138
 139 std::string Key::getString() const
 140 {
 141     assert(!m_name.empty() && "Key name cannot be empty.");
 142     char* result = vconf_get_str(m_name.c_str());
 143     if (result == NULL) {
 144         Throw(Commons::ConversionException);
 145     }
 146     return result;
 147 }
 148
 149 void Key::setValue(const std::string& value)
 150 {
 151     assert(!m_name.empty() && "Key name cannot be empty.");
 152     setValue(value.c_str());
 153 }
 154
 155 void Key::setValue(const char* value)
 156 {
 157     assert(!m_name.empty() && "Key name cannot be empty.");
 158     if (vconf_set_str(m_name.c_str(), value) != 0) {
 159         Throw(Commons::PlatformException);
 160     }
 161 }
 162
 163 void Key::reset(const char* name)
 164 {
 165     detachCallback();
 166     m_name = (name == NULL ? std::string() : name);
 167 }
 168 } // VConf
 169 } // WrtDeviceApis