client/src/PrivacyManagerClient.cpp

   1 /*
   2  * Copyright (c) 2012 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 #include <PrivacyManagerClient.h>
  18 #include <PrivacyDb.h>
  19 #include <SocketClient.h>
  20 #include <PrivacyIdInfo.h>
  21 #include <algorithm>
  22 #include <memory>
  23 #include <Utils.h>
  24
  25 #undef __READ_DB_IPC__
  26
  27
  28 std::mutex PrivacyManagerClient::m_singletonMutex;
  29 PrivacyManagerClient* PrivacyManagerClient::m_pInstance = NULL;
  30 const std::string PrivacyManagerClient::INTERFACE_NAME("PrivacyInfoService");
  31
  32 PrivacyManagerClient::PrivacyManagerClient(void)
  33 {
  34         std::unique_ptr<SocketClient> pSocketClient(new SocketClient(INTERFACE_NAME));
  35         m_pSocketClient = std::move(pSocketClient);
  36 }
  37
  38 PrivacyManagerClient*
  39 PrivacyManagerClient::getInstance(void)
  40 {
  41         std::lock_guard<std::mutex> guard(m_singletonMutex);
  42         if (m_pInstance == NULL)
  43                 m_pInstance = new PrivacyManagerClient();
  44         return m_pInstance;
  45 }
  46
  47 int
  48 PrivacyManagerClient::addAppPackagePrivacyInfo(const std::string pkgId, const std::list < std::string >& list, bool privacyPopupRequired, bool isServerOperation)
  49 {
  50
  51         std::list < std::string > privacyList;
  52
  53         int res = PrivacyIdInfo::getPrivacyIdListFromPrivilegeList(list, privacyList);
  54         if (res != PRIV_MGR_ERROR_SUCCESS )
  55                 return res;
  56
  57         if (privacyList.size() == 0)
  58                 return PRIV_MGR_ERROR_SUCCESS;
  59
  60         if (isServerOperation == true)
  61         {
  62                 int result = PRIV_MGR_ERROR_SUCCESS;
  63                 res = m_pSocketClient->connect();
  64                 TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
  65                 res = m_pSocketClient->call("addPrivacyInfo", pkgId, privacyList, privacyPopupRequired, &result);
  66                 TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
  67                 res = m_pSocketClient->disconnect();
  68                 TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "disconnect : %d", res);
  69
  70                 return result;
  71         }
  72         else
  73         {
  74                 return PrivacyDb::getInstance()->addAppPackagePrivacyInfo(pkgId, privacyList, privacyPopupRequired);
  75         }
  76 }
  77
  78 int
  79 PrivacyManagerClient::removeAppPackagePrivacyInfo(const std::string pkgId, bool isServerOperation)
  80 {
  81         if (isServerOperation == true)
  82         {
  83                 int result = PRIV_MGR_ERROR_SUCCESS;
  84                 int res = m_pSocketClient->connect();
  85                 TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
  86                 result = m_pSocketClient->call("removePrivacyInfo", pkgId, &result);
  87                 TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
  88                 result = m_pSocketClient->disconnect();
  89                 TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "disconnect : %d", res);
  90
  91                 return result;
  92         }
  93         else
  94                 return PrivacyDb::getInstance()->removeAppPackagePrivacyInfo(pkgId);
  95 }
  96
  97 int
  98 PrivacyManagerClient::setPrivacySetting(const std::string pkgId, const std::string privacyId, bool isEnabled)
  99 {
 100         int result = PRIV_MGR_ERROR_SUCCESS;
 101         int res = m_pSocketClient->connect();
 102         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
 103         res = m_pSocketClient->call("setPrivacySetting", pkgId, privacyId, isEnabled, &result);
 104         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 105         res = m_pSocketClient->disconnect();
 106         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
 107
 108         return result;
 109 }
 110
 111 int
 112 PrivacyManagerClient::getPrivacyAppPackages(std::list < std::string >& list) const
 113 {
 114 #ifdef __READ_DB_IPC__
 115
 116         std::unique_ptr <SocketClient> pSocketClient (new SocketClient(INTERFACE_NAME));
 117
 118         int result = PRIV_MGR_ERROR_SUCCESS
 119         int size = 0;
 120
 121         int res = pSocketClient->connect();
 122         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
 123         res = pSocketClient->call("getPrivacyAppPackages", &result, &size, &list);
 124         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 125         res = pSocketClient->disconnect();
 126         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
 127
 128         return result;
 129 #endif
 130
 131         return PrivacyDb::getInstance()->getPrivacyAppPackages(list);
 132 }
 133
 134 int
 135 PrivacyManagerClient::getAppPackagePrivacyInfo(const std::string pkgId, std::list < std::pair <std::string, bool > > & list) const
 136 {
 137 #ifdef __READ_DB_IPC__
 138         std::unique_ptr <SocketClient> pSocketClient (new SocketClient(INTERFACE_NAME));
 139
 140         int result = PRIV_MGR_ERROR_SUCCESS;
 141         int res = pSocketClient->connect();
 142         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
 143         pSocketClient->call("getAppPackagePrivacyInfo", pkgId, &result, &list);
 144         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 145         pSocketClient->disconnect();
 146         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 147
 148         return result;
 149 #endif
 150
 151         return PrivacyDb::getInstance()->getAppPackagePrivacyInfo(pkgId, list);
 152 }
 153
 154 int
 155 PrivacyManagerClient::isUserPrompted(const std::string pkgId, bool& isPrompted) const
 156 {
 157 #ifdef __READ_DB_IPC__
 158         std::unique_ptr <SocketClient> pSocketClient (new SocketClient(INTERFACE_NAME));
 159
 160         int result = PRIV_MGR_ERROR_SUCCESS;
 161         int res = pSocketClient->connect();
 162         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
 163         res = pSocketClient->call("isUserPrompted", pkgId, &result, &isPrompted);
 164         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 165         res = pSocketClient->disconnect();
 166         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 167
 168         return result;
 169 #endif
 170         return PrivacyDb::getInstance()->isUserPrompted(pkgId, isPrompted);
 171 }
 172
 173 int
 174 PrivacyManagerClient::setUserPrompted(const std::string pkgId, bool prompted)
 175 {
 176         std::unique_ptr <SocketClient> pSocketClient (new SocketClient(INTERFACE_NAME));
 177
 178         int result = PRIV_MGR_ERROR_SUCCESS;
 179         int res = pSocketClient->connect();
 180         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "connect : %d", res);
 181         res = pSocketClient->call("setUserPrompted", pkgId, prompted, &result);
 182         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, m_pSocketClient->disconnect(), "call : %d", res);
 183         res = pSocketClient->disconnect();
 184         TryReturn(res == PRIV_MGR_ERROR_SUCCESS, res, , "disconnect : %d", res);
 185
 186         return result;
 187 }
 188
 189 int
 190 PrivacyManagerClient::getAppPackagesbyPrivacyId(const std::string privacyId, std::list < std::pair < std::string, bool > >& list) const
 191 {
 192         return PrivacyDb::getInstance()->getAppPackagesbyPrivacyId(privacyId, list);
 193 }
 194
 195 int
 196 PrivacyManagerClient::getPrivaycDisplayName(const std::string privacyId, std::string& displayName) const
 197 {
 198         return PrivacyIdInfo::getPrivaycDisplayName(privacyId, displayName);
 199 }
 200
 201 int
 202 PrivacyManagerClient::getPrivaycDescription(const std::string privacyId, std::string& description) const
 203 {
 204         return PrivacyIdInfo::getPrivaycDescription(privacyId, description);
 205 }