2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 * @author Grzegorz Krawczyk (g.krawczyk@samsung.com)
26 #include <sys/types.h>
28 #include <dpl/log/log.h>
29 #include <dpl/scoped_array.h>
30 #include <dpl/scoped_resource.h>
31 #include <dpl/assert.h>
32 #include <Commons/Exception.h>
33 #include "WrtAccess.h"
34 #include <ace_api_client.h>
35 #include <dpl/singleton_safe_impl.h>
37 IMPLEMENT_SAFE_SINGLETON(WrtDeviceApis::Commons::WrtAccess)
42 * Helper class - single parameter and its value
50 name(NULL), value(NULL)
53 AceParam(const char *name, const char *value):
54 name(name), value(value)
59 * Helper class - list of params for single dev cap
71 struct DeviceCapParamPolicy
73 typedef AceParamList* Type;
74 static Type NullValue()
78 static void Destroy(Type ptr)
88 * Helper class - modified ScopedArray for ace_param_list_t
90 class ScopedDeviceCapArray : public DPL::ScopedResource<DeviceCapParamPolicy>
93 explicit ScopedDeviceCapArray(AceParamList *ptr =
94 DeviceCapParamPolicy::NullValue()) :
95 DPL::ScopedResource<DeviceCapParamPolicy>(ptr)
99 AceParamList & operator [](std::ptrdiff_t k) const
101 Assert(this->m_value != DeviceCapParamPolicy::NullValue() &&
102 "Dereference of scoped NULL array!");
103 Assert(k >= 0 && "Negative array index");
105 return this->m_value[k];
110 namespace WrtDeviceApis {
113 WrtAccess::WrtAccess() :
114 m_initialized(false),
115 m_sessionId(GenerateSessionId())
119 WrtAccess::~WrtAccess()
123 WrtAccess::SessionId WrtAccess::GenerateSessionId()
125 const size_t SESSION_ID_LENGTH = 32;
127 std::ostringstream pid;
128 pid << static_cast<int> (getpid());
130 std::string session_id = pid.str();
132 session_id.reserve(session_id.length() + SESSION_ID_LENGTH);
134 for (size_t i = 0; i < SESSION_ID_LENGTH; ++i)
136 int c = random() % 16;
138 session_id += (c < 10 ?
139 static_cast<char>('0' + c) :
140 static_cast<char>('A' + c - 10));
145 void WrtAccess::initialize(int widgetId)
147 LogDebug("initialize");
150 LogDebug("Invalid widget id");
153 // TODO: implement UI handler
154 ace_return_t ret = ace_client_initialize(NULL);
155 // Assert(ACE_OK == ret); // This is commented because UI handler is not
156 // implemented, ace client will work, but initialization will return
157 // ACE_INVALID_ARGUMENTS
158 m_initialized = true;
159 m_widgetId = widgetId;
162 void WrtAccess::deinitialize(int /*widgetId*/)
164 LogDebug("deinitialize");
165 m_initialized = false;
166 ace_return_t ret = ace_client_shutdown();
167 Assert(ACE_OK == ret);
170 int WrtAccess::getWidgetId() const
175 bool WrtAccess::checkAccessControl(const AceFunction& aceFunction) const
177 Assert(m_initialized && "WrtAccessSingleton needs to be initialized with"
178 "WidgetId during on_widget_start_callback in each plugin");
179 size_t deviceCount = aceFunction.deviceCapabilities.size();
181 DPL::ScopedArray <const char *> deviceScopedArray;
182 ScopedDeviceCapArray paramsScopedArray;
185 deviceScopedArray.Reset(new const char*[deviceCount]);
186 paramsScopedArray.Reset(new AceParamList[deviceCount]);
188 for (size_t i = 0; i < deviceCount; ++i) {
189 deviceScopedArray[i] =
190 aceFunction.deviceCapabilities.at(i).devCapName.c_str();
191 paramsScopedArray[i].count =
192 aceFunction.deviceCapabilities.at(i).devCapParams.size();
194 paramsScopedArray[i].param =
195 new AceParam[paramsScopedArray[i].count];
197 for (size_t j = 0; j < paramsScopedArray[i].count; ++j) {
198 paramsScopedArray[i].param[j].name =
199 aceFunction.deviceCapabilities.at(i).
200 devCapParams[j].name.c_str();
201 paramsScopedArray[i].param[j].value =
202 aceFunction.deviceCapabilities.at(i).
203 devCapParams[j].value.c_str();
208 size_t featuresCount = aceFunction.features.size();
210 DPL::ScopedArray <const char*> featureScopedArray;
212 featureScopedArray.Reset(new const char*[featuresCount]);
214 for (size_t i = 0; i < featuresCount; ++i) {
215 featureScopedArray[i] =
216 aceFunction.features.at(i).name.c_str();
220 LogDebug("constructing ACE request");
222 ace_request_t aceRequest;
223 aceRequest.session_id = const_cast<const ace_session_id_t>(m_sessionId.c_str());
224 aceRequest.widget_handle = getWidgetId();
225 aceRequest.feature_list.count = featuresCount;
226 aceRequest.feature_list.items = const_cast<ace_string_t*>(featureScopedArray.Get());
227 aceRequest.dev_cap_list.count = deviceCount;
228 aceRequest.dev_cap_list.items = new ace_dev_cap_t[deviceCount];
230 const char** devCapNames = deviceScopedArray.Get();
231 AceParamList* paramList = paramsScopedArray.Get();
234 for (i = 0; i < deviceCount; ++i) {
235 aceRequest.dev_cap_list.items[i].name =
236 const_cast<const ace_string_t>(devCapNames[i]);
237 aceRequest.dev_cap_list.items[i].param_list.count = paramList[i].count;
238 aceRequest.dev_cap_list.items[i].param_list.items =
239 new ace_param_t[paramList[i].count];
241 for (j = 0; j < paramList[i].count; ++j) {
242 aceRequest.dev_cap_list.items[i].param_list.items[j].name =
243 const_cast<ace_string_t>(paramList[i].param[j].name);
244 aceRequest.dev_cap_list.items[i].param_list.items[j].value =
245 const_cast<ace_string_t>(paramList[i].param[j].value);
249 ace_bool_t aceCheckResult = ACE_FALSE;
250 ace_return_t ret = ace_check_access(&aceRequest, &aceCheckResult);
252 for (i = 0; i < deviceCount; ++i) {
253 delete [] aceRequest.dev_cap_list.items[i].param_list.items;
255 delete [] aceRequest.dev_cap_list.items;
258 LogError("Error in ace check: " << static_cast<int>(ret));
261 return ACE_TRUE == aceCheckResult;
265 } // WrtDeviceApisCommon