ace_settings/src/ace_api_settings.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 /**
  17  * @file        ace_api_settings.cpp
  18  * @author      Tomasz Swierczek (t.swierczek@samsung.com)
  19  * @version     1.0
  20  * @brief       This file contains implementation ACE settings API
  21  */
  22
  23 #include <string>
  24 #include <dpl/log/log.h>
  25 #include <ace-dao-rw/AceDAO.h>
  26
  27 #include "ace_api_settings.h"
  28
  29 // helper functions
  30 static ace_preference_t to_ace_preference(const AceDB::PreferenceTypes& db_preference)
  31 {
  32     switch (db_preference) {
  33     case AceDB::PreferenceTypes::PREFERENCE_BLANKET_PROMPT: {
  34         return ACE_PREFERENCE_BLANKET_PROMPT; }
  35     case AceDB::PreferenceTypes::PREFERENCE_DEFAULT: {
  36         return ACE_PREFERENCE_DEFAULT;}
  37     case AceDB::PreferenceTypes::PREFERENCE_DENY: {
  38         return ACE_PREFERENCE_DENY;}
  39     case AceDB::PreferenceTypes::PREFERENCE_ONE_SHOT_PROMPT: {
  40         return ACE_PREFERENCE_ONE_SHOT_PROMPT;}
  41     case AceDB::PreferenceTypes::PREFERENCE_PERMIT: {
  42         return ACE_PREFERENCE_PERMIT;}
  43     case AceDB::PreferenceTypes::PREFERENCE_SESSION_PROMPT: {
  44         return ACE_PREFERENCE_SESSION_PROMPT;}
  45     default: {
  46         return ACE_PREFERENCE_DEFAULT;}
  47     }
  48 }
  49
  50
  51 static AceDB::PreferenceTypes to_ace_db_preference(const ace_preference_t& preference)
  52 {
  53     switch (preference) {
  54     case ACE_PREFERENCE_BLANKET_PROMPT: {
  55         return AceDB::PreferenceTypes::PREFERENCE_BLANKET_PROMPT; }
  56     case ACE_PREFERENCE_DEFAULT: {
  57         return AceDB::PreferenceTypes::PREFERENCE_DEFAULT;}
  58     case ACE_PREFERENCE_DENY: {
  59         return AceDB::PreferenceTypes::PREFERENCE_DENY;}
  60     case ACE_PREFERENCE_ONE_SHOT_PROMPT: {
  61         return AceDB::PreferenceTypes::PREFERENCE_ONE_SHOT_PROMPT;}
  62     case ACE_PREFERENCE_PERMIT: {
  63         return AceDB::PreferenceTypes::PREFERENCE_PERMIT;}
  64     case ACE_PREFERENCE_SESSION_PROMPT: {
  65         return AceDB::PreferenceTypes::PREFERENCE_SESSION_PROMPT;}
  66     default: {
  67         return AceDB::PreferenceTypes::PREFERENCE_DEFAULT;}
  68     }
  69 }
  70
  71 ace_return_t ace_settings_initialize(void)
  72 {
  73     AceDB::AceDAO::attachToThreadRW();
  74     return ACE_OK;
  75 }
  76
  77 ace_return_t ace_settings_shutdown(void)
  78 {
  79     AceDB::AceDAO::detachFromThread();
  80     return ACE_OK;
  81 }
  82
  83 ace_return_t ace_get_widget_resource_preference(ace_widget_handle_t handle,
  84                                                 const ace_resource_t resource,
  85                                                 ace_preference_t* preference)
  86 {
  87     if (NULL == resource || NULL == preference) {
  88         LogError("NULL argument(s) passed");
  89         return ACE_INVALID_ARGUMENTS;
  90     }
  91     Try {
  92         std::string resource_str(resource);
  93         AceDB::PreferenceTypes db_preference =
  94                 AceDB::AceDAO::getWidgetDevCapSetting(resource_str, handle);
  95         *preference = to_ace_preference(db_preference);
  96     } Catch(AceDB::AceDAOReadOnly::Exception::DatabaseError) {
  97         return ACE_INTERNAL_ERROR;
  98     }
  99     return ACE_OK;
 100 }
 101
 102 ace_return_t ace_get_global_resource_preference(const ace_resource_t resource,
 103                                                 ace_preference_t* preference)
 104 {
 105     if (NULL == resource || NULL == preference) {
 106         LogError("NULL argument(s) passed");
 107         return ACE_INVALID_ARGUMENTS;
 108     }
 109     Try {
 110         AceDB::PreferenceTypes db_preference =
 111                 AceDB::AceDAO::getDevCapSetting(resource);
 112         *preference = to_ace_preference(db_preference);
 113     } Catch(AceDB::AceDAOReadOnly::Exception::DatabaseError) {
 114         return ACE_INTERNAL_ERROR;
 115     }
 116     return ACE_OK;
 117 }
 118
 119 ace_return_t ace_set_widget_resource_preference(ace_widget_handle_t handle,
 120                                                 const ace_resource_t resource,
 121                                                 ace_preference_t preference)
 122 {
 123     if (NULL == resource) {
 124         LogError("NULL argument passed");
 125         return ACE_INVALID_ARGUMENTS;
 126     }
 127     Try {
 128         AceDB::AceDAO::addResource(resource);
 129         AceDB::PreferenceTypes db_preference = to_ace_db_preference(preference);
 130         AceDB::AceDAO::removeWidgetDevCapSetting(resource, handle);
 131         AceDB::AceDAO::setWidgetDevCapSetting(resource, handle, db_preference);
 132     } Catch(AceDB::AceDAO::Exception::DatabaseError) {
 133         return ACE_INTERNAL_ERROR;
 134     }
 135     return ACE_OK;
 136 }
 137
 138 ace_return_t ace_set_global_resource_preference(const ace_resource_t resource,
 139                                                 ace_preference_t preference)
 140 {
 141     if (NULL == resource) {
 142         LogError("NULL argument passed");
 143         return ACE_INVALID_ARGUMENTS;
 144     }
 145     Try {
 146         AceDB::AceDAO::addResource(resource);
 147         AceDB::PreferenceTypes db_preference = to_ace_db_preference(preference);
 148         AceDB::AceDAO::setDevCapSetting(resource, db_preference);
 149     } Catch(AceDB::AceDAO::Exception::DatabaseError) {
 150         return ACE_INTERNAL_ERROR;
 151     }
 152     return ACE_OK;
 153 }
 154
 155 ace_return_t ace_reset_widget_resource_settings()
 156 {
 157     Try {
 158         AceDB::AceDAO::clearWidgetDevCapSettings();
 159     } Catch(AceDB::AceDAO::Exception::DatabaseError) {
 160         return ACE_INTERNAL_ERROR;
 161     }
 162     return ACE_OK;
 163 }
 164
 165 ace_return_t ace_reset_global_resource_settings(void)
 166 {
 167     Try {
 168         AceDB::AceDAO::clearDevCapSettings();
 169     } Catch(AceDB::AceDAO::Exception::DatabaseError) {
 170         return ACE_INTERNAL_ERROR;
 171     }
 172     return ACE_OK;
 173 }
 174
 175 ace_return_t ace_is_private_api(const ace_resource_t resource_name, ace_bool_t* is_private_api)
 176 {
 177     static const char * const private_api[] = {
 178         "bluetooth.admin",
 179         "bluetooth.gap",
 180         "bluetooth.spp",
 181         "calendar.read",
 182         "calendar.write",
 183         "callhistory.read",
 184         "callhistory.write",
 185         "contact.read",
 186         "contact.write",
 187         "nfc.admin",
 188         "nfc.common",
 189         "nfc.cardemulation",
 190         "nfc.p2p",
 191         "nfc.tag",
 192         NULL
 193     };
 194
 195     *is_private_api = ACE_TRUE;
 196     for (int i=0; private_api[i]; ++i)
 197         if (!strcmp(resource_name, private_api[i]))
 198             return ACE_OK;
 199
 200     *is_private_api = ACE_FALSE;
 201     return ACE_OK;
 202 }
 203