|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * |
|
5 * This program is free software: you can redistribute it and/or modify |
|
6 * it under the terms of the GNU Lesser General Public License as published by |
|
7 * the Free Software Foundation, version 2.1 of the License. |
|
8 * |
|
9 * This program is distributed in the hope that it will be useful, |
|
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 * GNU Lesser General Public License for more details. |
|
13 * |
|
14 * You should have received a copy of the GNU Lesser General Public License |
|
15 * along with this program. If not, |
|
16 * see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/". |
|
17 * |
|
18 * Description: |
|
19 * |
|
20 */ |
|
21 |
|
22 #include "cpublishandsubscribehandler.h" |
|
23 #include <e32property.h> |
|
24 |
|
25 #include "xqsettingskey.h" |
|
26 |
|
27 CPublishAndSubscribeHandler* CPublishAndSubscribeHandler::NewL(TUid aUid) |
|
28 { |
|
29 CPublishAndSubscribeHandler* self = new (ELeave) CPublishAndSubscribeHandler(aUid); |
|
30 CleanupStack::PushL(self); |
|
31 self->ConstructL(); |
|
32 CleanupStack::Pop(self); |
|
33 return self; |
|
34 } |
|
35 |
|
36 void CPublishAndSubscribeHandler::ConstructL() |
|
37 { |
|
38 } |
|
39 |
|
40 CPublishAndSubscribeHandler::CPublishAndSubscribeHandler(TUid aUid) |
|
41 : m_uid(aUid) |
|
42 { |
|
43 } |
|
44 |
|
45 CPublishAndSubscribeHandler::~CPublishAndSubscribeHandler() |
|
46 { |
|
47 } |
|
48 |
|
49 void CPublishAndSubscribeHandler::setObserver(MSettingsHandlerObserver* observer) |
|
50 { |
|
51 m_observer = observer; |
|
52 } |
|
53 |
|
54 TInt CPublishAndSubscribeHandler::getValue(unsigned long key, TInt& value) |
|
55 { |
|
56 return RProperty::Get(m_uid, key, value); |
|
57 } |
|
58 |
|
59 TInt CPublishAndSubscribeHandler::getValue(unsigned long /*key*/, TReal& /*value*/) |
|
60 { |
|
61 return KErrArgument; |
|
62 } |
|
63 |
|
64 void CPublishAndSubscribeHandler::getValueL(unsigned long key, RBuf8& value) |
|
65 { |
|
66 TInt err = RProperty::Get(m_uid, key, value); |
|
67 if (err == KErrOverflow) |
|
68 { |
|
69 value.ReAllocL(RProperty::KMaxPropertySize); |
|
70 err = RProperty::Get(m_uid, key, value); |
|
71 if (err == KErrOverflow) |
|
72 { |
|
73 value.ReAllocL(RProperty::KMaxLargePropertySize); |
|
74 err = RProperty::Get(m_uid, key, value); |
|
75 } |
|
76 } |
|
77 User::LeaveIfError(err); |
|
78 } |
|
79 |
|
80 void CPublishAndSubscribeHandler::getValueL(unsigned long key, RBuf16& value) |
|
81 { |
|
82 TInt err = RProperty::Get(m_uid, key, value); |
|
83 if (err == KErrOverflow) |
|
84 { |
|
85 value.ReAllocL(RProperty::KMaxPropertySize); |
|
86 err = RProperty::Get(m_uid, key, value); |
|
87 if (err == KErrOverflow) |
|
88 { |
|
89 value.ReAllocL(RProperty::KMaxLargePropertySize); |
|
90 err = RProperty::Get(m_uid, key, value); |
|
91 } |
|
92 } |
|
93 User::LeaveIfError(err); |
|
94 } |
|
95 |
|
96 TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TInt& value) |
|
97 { |
|
98 return RProperty::Set(m_uid, key, value); |
|
99 } |
|
100 |
|
101 TInt CPublishAndSubscribeHandler::setValue(unsigned long /*key*/, const TReal& /*value*/) |
|
102 { |
|
103 return KErrArgument; |
|
104 } |
|
105 |
|
106 TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TDesC8& value) |
|
107 { |
|
108 return RProperty::Set(m_uid, key, value); |
|
109 } |
|
110 |
|
111 TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TDesC16& value) |
|
112 { |
|
113 return RProperty::Set(m_uid, key, value); |
|
114 } |
|
115 |
|
116 TInt CPublishAndSubscribeHandler::defineProperty(unsigned long key, XQSettingsManager::Type type) |
|
117 { |
|
118 switch (type) |
|
119 { |
|
120 case XQSettingsManager::TypeInt: |
|
121 { |
|
122 return RProperty::Define(m_uid, key, RProperty::EInt); |
|
123 } |
|
124 case XQSettingsManager::TypeString: |
|
125 { |
|
126 return RProperty::Define(m_uid, key, RProperty::EText); |
|
127 } |
|
128 case XQSettingsManager::TypeByteArray: |
|
129 { |
|
130 return RProperty::Define(m_uid, key, RProperty::EByteArray); |
|
131 } |
|
132 case XQSettingsManager::TypeDouble: |
|
133 default: |
|
134 { |
|
135 return KErrArgument; |
|
136 } |
|
137 } |
|
138 } |
|
139 |
|
140 TInt CPublishAndSubscribeHandler::defineProperty(unsigned long key, XQSettingsManager::Type type, |
|
141 const XQPublishAndSubscribeSecurityPolicy& readPolicy, const XQPublishAndSubscribeSecurityPolicy& writePolicy) |
|
142 { |
|
143 switch (type) |
|
144 { |
|
145 case XQSettingsManager::TypeInt: |
|
146 { |
|
147 return RProperty::Define(m_uid, key, RProperty::EInt, symbianPolicy(readPolicy), symbianPolicy(writePolicy)); |
|
148 } |
|
149 case XQSettingsManager::TypeString: |
|
150 { |
|
151 return RProperty::Define(m_uid, key, RProperty::EText, symbianPolicy(readPolicy), symbianPolicy(writePolicy)); |
|
152 } |
|
153 case XQSettingsManager::TypeByteArray: |
|
154 { |
|
155 return RProperty::Define(m_uid, key, RProperty::EByteArray, symbianPolicy(readPolicy), symbianPolicy(writePolicy)); |
|
156 } |
|
157 case XQSettingsManager::TypeDouble: |
|
158 default: |
|
159 { |
|
160 return KErrArgument; |
|
161 } |
|
162 } |
|
163 } |
|
164 |
|
165 TSecurityPolicy CPublishAndSubscribeHandler::symbianPolicy(const XQPublishAndSubscribeSecurityPolicy& policy) |
|
166 { |
|
167 //Use constructor for EAlwaysFail or EAlwaysPass |
|
168 switch (policy.secPolicyType()) |
|
169 { |
|
170 case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysFail: |
|
171 { |
|
172 return TSecurityPolicy(TSecurityPolicy::EAlwaysFail); |
|
173 } |
|
174 case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysPass: |
|
175 { |
|
176 return TSecurityPolicy(TSecurityPolicy::EAlwaysPass); |
|
177 } |
|
178 default: |
|
179 { |
|
180 break; |
|
181 } |
|
182 } |
|
183 |
|
184 TCapability capability1 = ECapability_None; |
|
185 TCapability capability2 = ECapability_None; |
|
186 TCapability capability3 = ECapability_None; |
|
187 TCapability capability4 = ECapability_None; |
|
188 TCapability capability5 = ECapability_None; |
|
189 TCapability capability6 = ECapability_None; |
|
190 TCapability capability7 = ECapability_None; |
|
191 |
|
192 const QList<XQPublishAndSubscribeSecurityPolicy::Capability>& capabilities = policy.capabilities(); |
|
193 |
|
194 if (capabilities.count() > 0) capability1 = symbianCapability(capabilities[0]); |
|
195 if (capabilities.count() > 1) capability2 = symbianCapability(capabilities[1]); |
|
196 if (capabilities.count() > 2) capability3 = symbianCapability(capabilities[2]); |
|
197 if (capabilities.count() > 3) capability4 = symbianCapability(capabilities[3]); |
|
198 if (capabilities.count() > 4) capability5 = symbianCapability(capabilities[4]); |
|
199 if (capabilities.count() > 5) capability6 = symbianCapability(capabilities[5]); |
|
200 if (capabilities.count() > 6) capability7 = symbianCapability(capabilities[6]); |
|
201 |
|
202 long int secureId = policy.secureId().uid(); |
|
203 if (secureId != -1) |
|
204 { |
|
205 //Use constructor for TSecureId + max 3 capabilities |
|
206 return TSecurityPolicy(TSecureId(secureId), capability1, capability2, capability3); |
|
207 } |
|
208 |
|
209 long int vendorId = policy.vendorId().uid(); |
|
210 if (vendorId != -1) |
|
211 { |
|
212 //Use constructor for TVendorId + max 3 capabilities |
|
213 return TSecurityPolicy(TVendorId(vendorId), capability1, capability2, capability3); |
|
214 } |
|
215 |
|
216 if (capabilities.count() < 4) |
|
217 { |
|
218 //Use constructor for max 3 capabilities |
|
219 return TSecurityPolicy(capability1, capability2, capability3); |
|
220 } |
|
221 else |
|
222 { |
|
223 //Use constructor for max 7 capabilities |
|
224 return TSecurityPolicy(capability1, capability2, capability3, capability4, capability5, capability6, capability7); |
|
225 } |
|
226 } |
|
227 |
|
228 TCapability CPublishAndSubscribeHandler::symbianCapability(const XQPublishAndSubscribeSecurityPolicy::Capability& capability) |
|
229 { |
|
230 switch (capability) |
|
231 { |
|
232 case XQPublishAndSubscribeSecurityPolicy::CapabilityTCB: return ECapabilityTCB; |
|
233 case XQPublishAndSubscribeSecurityPolicy::CapabilityCommDD: return ECapabilityCommDD; |
|
234 case XQPublishAndSubscribeSecurityPolicy::CapabilityPowerMgmt: return ECapabilityPowerMgmt; |
|
235 case XQPublishAndSubscribeSecurityPolicy::CapabilityMultimediaDD: return ECapabilityMultimediaDD; |
|
236 case XQPublishAndSubscribeSecurityPolicy::CapabilityReadDeviceData: return ECapabilityReadDeviceData; |
|
237 case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteDeviceData: return ECapabilityWriteDeviceData; |
|
238 case XQPublishAndSubscribeSecurityPolicy::CapabilityDRM: return ECapabilityDRM; |
|
239 case XQPublishAndSubscribeSecurityPolicy::CapabilityTrustedUI: return ECapabilityTrustedUI; |
|
240 case XQPublishAndSubscribeSecurityPolicy::CapabilityProtServ: return ECapabilityProtServ; |
|
241 case XQPublishAndSubscribeSecurityPolicy::CapabilityDiskAdmin: return ECapabilityDiskAdmin; |
|
242 case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkControl: return ECapabilityNetworkControl; |
|
243 case XQPublishAndSubscribeSecurityPolicy::CapabilityAllFiles: return ECapabilityAllFiles; |
|
244 case XQPublishAndSubscribeSecurityPolicy::CapabilitySwEvent: return ECapabilitySwEvent; |
|
245 case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkServices: return ECapabilityNetworkServices; |
|
246 case XQPublishAndSubscribeSecurityPolicy::CapabilityLocalServices: return ECapabilityLocalServices; |
|
247 case XQPublishAndSubscribeSecurityPolicy::CapabilityReadUserData: return ECapabilityReadUserData; |
|
248 case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteUserData: return ECapabilityWriteUserData; |
|
249 case XQPublishAndSubscribeSecurityPolicy::CapabilityLocation: return ECapabilityLocation; |
|
250 case XQPublishAndSubscribeSecurityPolicy::CapabilitySurroundingsDD: return ECapabilitySurroundingsDD; |
|
251 case XQPublishAndSubscribeSecurityPolicy::CapabilityUserEnvironment: return ECapabilityUserEnvironment; |
|
252 default: |
|
253 { |
|
254 break; |
|
255 } |
|
256 } |
|
257 return TCapability(); |
|
258 } |
|
259 |
|
260 TInt CPublishAndSubscribeHandler::deleteProperty(unsigned long key) |
|
261 { |
|
262 return RProperty::Delete(m_uid, key); |
|
263 } |
|
264 |
|
265 bool CPublishAndSubscribeHandler::handleStartMonitoring(const XQSettingsKey& key, XQSettingsManager::Type type, MSettingsHandlerObserver& observer, TInt& error) |
|
266 { |
|
267 if (m_monitors.contains(key.key())) |
|
268 { |
|
269 error = KErrAlreadyExists; |
|
270 return false; |
|
271 } |
|
272 CPubSubMonitor* newMonitor = new CPubSubMonitor(key, type, observer); |
|
273 if (newMonitor) |
|
274 { |
|
275 m_monitors[key.key()] = newMonitor; |
|
276 error = newMonitor->StartMonitoring(); |
|
277 return error == KErrNone; |
|
278 } |
|
279 error = KErrNoMemory; |
|
280 return false; |
|
281 } |
|
282 |
|
283 bool CPublishAndSubscribeHandler::handleStopMonitoring(const XQSettingsKey& key, TInt& error) |
|
284 { |
|
285 if (!m_monitors.contains(key.key())) |
|
286 { |
|
287 error = KErrNotFound; |
|
288 return false; |
|
289 } |
|
290 const long int itemKey = key.key(); |
|
291 CPubSubMonitor* monitor = m_monitors[itemKey]; |
|
292 m_monitors.remove(itemKey); |
|
293 delete monitor; |
|
294 |
|
295 return error == KErrNone; |
|
296 } |