src/security/ace_settings_logic.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_settings_logic.cpp
  18  * @author      Jaroslaw Osmanski (j.osmanski@samsung.com)
  19  * @author      Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
  20  * @version     1.0
  21  * @brief       This is an implementation of server of ACE user preferences
  22  */
  23 #include <ace_settings_logic.h>
  24 #include <ace_settings_server_factory.h>
  25 #include <dpl/foreach.h>
  26 #include <dpl/assert.h>
  27 #include <dpl/log/log.h>
  28 //#include <widget_controller.h>
  29 #include <dpl/localization/w3c_file_localization.h>
  30 #include <dpl/ace/PolicyEnforcementPoint.h>
  31 #include <dpl/ace/PolicyEvaluator.h>
  32 #include <dpl/ace/Preference.h>
  33 #include <dpl/wrt-dao-rw/feature_dao.h>
  34 #include <dpl/wrt-dao-rw/widget_dao.h>
  35 #include <vector>
  36 #include <map>
  37
  38 #include <dpl/ace-dao-rw/AceDAO.h>
  39 #include <dpl/ace/SettingsLogic.h>
  40 #include <dpl/wrt-dao-rw/global_dao.h>
  41
  42 using namespace WrtDB;
  43
  44 namespace // anonymous
  45 {
  46 struct SubjectResource
  47 {
  48     WidgetHandle subject; // app_id
  49     std::string resource;
  50
  51     SubjectResource(WidgetHandle subjectArg,
  52             const std::string& resourceArg) :
  53         subject(subjectArg),
  54         resource(resourceArg)
  55     {
  56     }
  57
  58     bool operator < (const SubjectResource& subjectResource) const
  59     {
  60         if (subject != subjectResource.subject) {
  61             return subject < subjectResource.subject;
  62         } else {
  63             return resource < subjectResource.resource;
  64         }
  65     }
  66 };
  67
  68 typedef std::map<SubjectResource, Preference> WidgetResourcePreferenceMap;
  69 } // namespace anonymous
  70
  71 AceSettingsLogic::AceSettingsLogic(
  72         PolicyEnforcementPoint *policyEnforcementPoint) :
  73     m_policyEnforcementPoint(policyEnforcementPoint)
  74 {
  75     // Acquire ACE settings server from factory
  76     m_server = AceSettingsServerFactory::Create(this);
  77 }
  78
  79 AceSettings::WidgetsPreferences AceSettingsLogic::getWidgetsPreferences() const
  80 {
  81     AceSettings::WidgetsPreferences widgetsPreferences;
  82     WidgetHandleList widgetHandleList = WidgetDAOReadOnly::getHandleList();
  83
  84     DPL::ScopedPtr<WidgetResourcePreferenceMap> preferenceMap;
  85
  86     PermissionList permissionTriple;
  87     SettingsLogic::getWidgetDevCapSettings(&permissionTriple);
  88
  89     preferenceMap.Reset(new WidgetResourcePreferenceMap());
  90
  91     FOREACH(permission, permissionTriple)
  92     {
  93         LogInfo("In db: " << permission->appId <<
  94                 " " << permission->devCap);
  95         SubjectResource sb(permission->appId,
  96                            permission->devCap);
  97         preferenceMap->insert(std::make_pair(sb, permission->access));
  98     }
  99
 100     LogInfo("Sending Widget Resources");
 101
 102     FOREACH(handle, widgetHandleList)
 103     {
 104         AceSettings::SubjectResourcePreferences subjectResourcePreferences;
 105         WidgetDAOReadOnly widget(*handle);
 106
 107         //This has to be redesigned how to gather localized name of widget
 108 //        auto lang = widget.getDefaultlocale();
 109 //        if (!lang) lang = DPL::FromASCIIString("en");
 110 //        WidgetLocalizedInfo info =
 111 //            widget.getLocalizedInfo(*lang);
 112 //
 113 //        DPL::Optional<DPL::String> optionalName = info.name;
 114 //
 115 //        if (!!optionalName) {
 116 //            LogDebug("optional name: " << (*optionalName));
 117 //            subjectResourcePreferences.subject =
 118 //                    DPL::ToUTF8String(*optionalName);
 119 //        } else {
 120 //            subjectResourcePreferences.subject = "";
 121 //        }
 122
 123         WidgetFeatureSet featureSet = widget.getFeaturesList();
 124         SubjectResource subjectResource(*handle, "");
 125
 126         DeviceCapabilitySet deviceCaps;
 127
 128         FOREACH(feature, featureSet)
 129         {
 130             DeviceCapabilitySet thisFeatureDeviceCaps =
 131                     GlobalDAO::GetDeviceCapability(feature->name);
 132             deviceCaps.insert(thisFeatureDeviceCaps.begin(),
 133                     thisFeatureDeviceCaps.end());
 134         }
 135
 136         FOREACH(deviceCap, deviceCaps)
 137         {
 138             AceSettings::ResourcePreference resourcePreferences;
 139             resourcePreferences.resource = DPL::ToUTF8String(*deviceCap);
 140
 141             subjectResource.resource = resourcePreferences.resource;
 142             LogInfo("Looking for: " << subjectResource.subject <<
 143                     " " << subjectResource.resource);
 144
 145             if (preferenceMap) {
 146                 WidgetResourcePreferenceMap::const_iterator preference =
 147                     preferenceMap->find(subjectResource);
 148
 149                 if (preference != preferenceMap->end()) {
 150                     LogInfo("Found not default preference!!");
 151                     resourcePreferences.preference = preference->second;
 152                 } else {
 153                     resourcePreferences.preference = Preference::PREFERENCE_DEFAULT;
 154                 }
 155             } else {
 156                 resourcePreferences.preference = Preference::PREFERENCE_DEFAULT;
 157             }
 158
 159             LogInfo("Pushing back resource preference");
 160
 161             subjectResourcePreferences.resourcesPreference.
 162                 push_back(resourcePreferences);
 163         }
 164
 165         widgetsPreferences.subjectsResourcePreferences.push_back(
 166             subjectResourcePreferences);
 167     }
 168
 169     return widgetsPreferences;
 170 }
 171
 172 AceSettings::ResourcesPreferences AceSettingsLogic::getResourcesPreferences()
 173 const
 174 {
 175     AceSettings::ResourcesPreferences resourcesPreferences;
 176     PreferenceMap preferenceMap;
 177
 178     SettingsLogic::getDevCapSettings(&preferenceMap);
 179
 180     FeatureHandleList featureList = FeatureDAOReadOnly::GetHandleList();
 181
 182     FOREACH(featureName, featureList)
 183     {
 184         FeatureDAOReadOnly featureDao(*featureName);
 185
 186         AceSettings::ResourcePreference resourcePreference;
 187         resourcePreference.resource = featureDao.GetName();
 188
 189         PreferenceMap::const_iterator preference =
 190             preferenceMap.find(resourcePreference.resource);
 191
 192         if (preference != preferenceMap.end()) {
 193             resourcePreference.preference = preference->second;
 194         } else {
 195             resourcePreference.preference = Preference::PREFERENCE_DEFAULT;
 196         }
 197
 198         resourcesPreferences.resourcesPreference.push_back(resourcePreference);
 199     }
 200
 201     return resourcesPreferences;
 202 }
 203
 204 void AceSettingsLogic::setWidgetPreference(const std::string &resource,
 205         WidgetHandle handler,
 206         const Preference &preference)
 207 {
 208     SettingsLogic::setWidgetDevCapSetting(resource, handler, preference);
 209 }
 210
 211 void AceSettingsLogic::setResourcePreference(const std::string &resource,
 212         const Preference &preference)
 213 {
 214     SettingsLogic::setDevCapSetting(resource, preference);
 215 }
 216
 217 bool AceSettingsLogic::getWidgetsSecure() const
 218 {
 219     return GlobalDAO::GetSecureByDefault();
 220 }
 221
 222 void AceSettingsLogic::setWidgetsSecure(bool widgetSecure)
 223 {
 224     GlobalDAO::SetSecureByDefault(widgetSecure);
 225 }
 226
 227 void AceSettingsLogic::resetWidgetsPreferences()
 228 {
 229     AceDB::AceDAO::clearWidgetDevCapSettings();
 230 }
 231
 232 void AceSettingsLogic::resetResourcesPreferences()
 233 {
 234     AceDB::AceDAO::clearDevCapSettings();
 235 }