1 /* |
|
2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Encapsulates hsps liw service |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 #include <liwservicehandler.h> |
|
21 #include <liwvariant.h> |
|
22 #include <bamdesca.h> |
|
23 |
|
24 #include <hspluginsettings.h> |
|
25 #include "hspsconfiguration.h" |
|
26 //#include "pluginmap.h" |
|
27 #include "itemmap.h" |
|
28 #include "propertymap.h" |
|
29 //#include "objectmap.h" |
|
30 //#include "plugininfo.h" |
|
31 #include <mhomescreensettingsif.h> |
|
32 #include <mhomescreensettingsobserver.h> |
|
33 |
|
34 _LIT8( KHSPS, "Service.HSPS" ); |
|
35 _LIT8( KHSPSConfigurationIf, "IConfiguration" ); |
|
36 |
|
37 |
|
38 |
|
39 _LIT8( KHSPSCommandGetPluginConf, "GetPluginConf" ); |
|
40 _LIT8( KHSPSSetPluginSettings, "SetPluginSettings" ); |
|
41 _LIT8( KPluginConfKey, "pluginConf" ); |
|
42 |
|
43 _LIT8( KOutKeyStatus ,"status"); |
|
44 _LIT8( KHspsAppUid, "appUid" ); |
|
45 _LIT8( KKeyPluginId, "pluginId" ); |
|
46 |
|
47 _LIT8( KKeyStoringParams, "storingParams" ); |
|
48 |
|
49 |
|
50 _LIT8( KKeyStorePluginRefence, "storePluginConf" ); |
|
51 _LIT8( KKeyStoreAppConf, "storeAppConf" ); |
|
52 |
|
53 _LIT8( KKeyItemId, "itemId" ); |
|
54 _LIT8( KKeyName, "name" ); |
|
55 _LIT8( KKeyValue, "value" ); |
|
56 _LIT8( KKeyProperties, "properties" ); |
|
57 _LIT8( KKeySettings, "settings" ); |
|
58 |
|
59 _LIT8( KRequestNotification, "RequestNotification" ); |
|
60 |
|
61 |
|
62 _LIT8( KSettingsChanged, "PluginSettingsChanged" ); |
|
63 namespace HSPluginSettingsIf{ |
|
64 |
|
65 |
|
66 |
|
67 // --------------------------------------------------------------------------- |
|
68 // --------------------------------------------------------------------------- |
|
69 // |
|
70 CHomescreenSettings::CHomescreenSettings(MHomeScreenSettingsObserver* aObserver, const TDesC8& aPluginId ) |
|
71 : iObserver( aObserver ), iPluginId( aPluginId ) |
|
72 { |
|
73 } |
|
74 |
|
75 // --------------------------------------------------------------------------- |
|
76 // --------------------------------------------------------------------------- |
|
77 // |
|
78 void CHomescreenSettings::ConstructL( const TDesC8& aAppUid ) |
|
79 { |
|
80 // Attach to HSPS: |
|
81 iServiceHandler = CLiwServiceHandler::NewL(); |
|
82 |
|
83 iHspsService = CLiwCriteriaItem::NewL( 1, KHSPSConfigurationIf, KHSPS ); |
|
84 iHspsService->SetServiceClass( TUid::Uid( KLiwClassBase ) ); |
|
85 |
|
86 RCriteriaArray interestList; |
|
87 interestList.AppendL( iHspsService ); |
|
88 iServiceHandler->AttachL( interestList ); |
|
89 interestList.Reset(); |
|
90 |
|
91 CLiwGenericParamList& inParamList = iServiceHandler->InParamListL(); |
|
92 CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL(); |
|
93 |
|
94 TLiwGenericParam appUid; |
|
95 TLiwVariant uidVar; |
|
96 uidVar.Set( aAppUid ); |
|
97 appUid.SetNameAndValueL( KHspsAppUid, uidVar ); |
|
98 appUid.PushL(); |
|
99 inParamList.AppendL( appUid ); |
|
100 CleanupStack::Pop(); |
|
101 appUid.Reset(); |
|
102 |
|
103 iServiceHandler->ExecuteServiceCmdL( *iHspsService,inParamList,outParamList ); |
|
104 inParamList.Reset(); |
|
105 TInt pos = 0; |
|
106 outParamList.FindFirst( pos, KHSPSConfigurationIf ); |
|
107 if( pos != KErrNotFound ) |
|
108 { |
|
109 iHspsInterface = outParamList[ pos ].Value().AsInterface(); |
|
110 outParamList.Reset(); |
|
111 } |
|
112 else |
|
113 { |
|
114 outParamList.Reset(); |
|
115 User::Leave( KErrNotFound ); |
|
116 } |
|
117 |
|
118 inParamList.Reset(); |
|
119 outParamList.Reset(); |
|
120 |
|
121 if( iObserver ) |
|
122 { |
|
123 iTransactionId = -1; |
|
124 iHspsInterface->ExecuteCmdL( KRequestNotification, |
|
125 inParamList, |
|
126 outParamList, |
|
127 KLiwOptASyncronous, |
|
128 this ); |
|
129 const TLiwGenericParam* outParam( NULL ); |
|
130 |
|
131 TInt pos( 0 ); |
|
132 outParam = outParamList.FindFirst( pos, _L8("status") ); |
|
133 |
|
134 if ( outParam ) |
|
135 { |
|
136 TInt retval; |
|
137 retval = outParam->Value().AsTInt32(); |
|
138 if(retval == KErrNone ) |
|
139 { |
|
140 pos = 0; |
|
141 outParam = outParamList.FindFirst( pos, _L8("TransactionID") ); |
|
142 if( outParam ) |
|
143 { |
|
144 retval = outParam->Value().AsTInt32(); |
|
145 iTransactionId = retval; |
|
146 } |
|
147 } |
|
148 |
|
149 } |
|
150 |
|
151 } |
|
152 } |
|
153 |
|
154 // --------------------------------------------------------------------------- |
|
155 // --------------------------------------------------------------------------- |
|
156 // |
|
157 EXPORT_C CHomescreenSettings* CHomescreenSettings::NewL( |
|
158 const TDesC8& aAppUid, |
|
159 const TDesC8& aPluginId, |
|
160 MHomeScreenSettingsObserver* aObserver) |
|
161 { |
|
162 CHomescreenSettings* self = CHomescreenSettings::NewLC(aAppUid, aPluginId, aObserver); |
|
163 CleanupStack::Pop( self ); |
|
164 return self; |
|
165 } |
|
166 |
|
167 // --------------------------------------------------------------------------- |
|
168 // --------------------------------------------------------------------------- |
|
169 // |
|
170 EXPORT_C CHomescreenSettings* CHomescreenSettings::NewLC( |
|
171 const TDesC8& aAppUid, |
|
172 const TDesC8& aPluginId, |
|
173 MHomeScreenSettingsObserver* aObserver) |
|
174 { |
|
175 CHomescreenSettings* self = new( ELeave ) CHomescreenSettings( aObserver, aPluginId ); |
|
176 CleanupStack::PushL( self ); |
|
177 self->ConstructL(aAppUid); |
|
178 return self; |
|
179 } |
|
180 |
|
181 // --------------------------------------------------------------------------- |
|
182 // --------------------------------------------------------------------------- |
|
183 // |
|
184 EXPORT_C CHomescreenSettings::~CHomescreenSettings() |
|
185 { |
|
186 if( iHspsInterface ) |
|
187 { |
|
188 // Close interface |
|
189 iHspsInterface->Close(); |
|
190 } |
|
191 |
|
192 if( iServiceHandler && iHspsService ) |
|
193 { |
|
194 // Detach services from the handler |
|
195 RCriteriaArray interestList; |
|
196 TRAP_IGNORE( interestList.AppendL( iHspsService ) ); |
|
197 TRAP_IGNORE( iServiceHandler->DetachL( interestList ) ); |
|
198 interestList.Reset(); |
|
199 } |
|
200 |
|
201 delete iHspsService; |
|
202 delete iServiceHandler; |
|
203 } |
|
204 |
|
205 |
|
206 |
|
207 |
|
208 |
|
209 // --------------------------------------------------------------------------- |
|
210 // --------------------------------------------------------------------------- |
|
211 // |
|
212 TInt CHomescreenSettings::SetPluginSettingsL( |
|
213 const TDesC8& aPluginId, |
|
214 const RPointerArray<CItemMap>& aSettings, |
|
215 const TDesC8& aStoringParam ) |
|
216 { |
|
217 // Compose AddPlugin hsps LIW message to Service.HomeScreenPluginConfiguration |
|
218 CLiwGenericParamList& inParamList = iServiceHandler->InParamListL(); |
|
219 CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL(); |
|
220 |
|
221 TLiwGenericParam pluginIdParam; |
|
222 pluginIdParam.SetNameAndValueL( KKeyPluginId, TLiwVariant(aPluginId) ); |
|
223 pluginIdParam.PushL(); |
|
224 inParamList.AppendL( pluginIdParam ); |
|
225 CleanupStack::Pop( &pluginIdParam ); |
|
226 pluginIdParam.Reset(); |
|
227 |
|
228 CLiwDefaultList* itemMapList = CLiwDefaultList::NewLC(); |
|
229 for( int i = 0; i < aSettings.Count(); i++ ) |
|
230 { |
|
231 CItemMap* itemMap = aSettings[i]; |
|
232 |
|
233 CLiwDefaultMap* inItemMap = CLiwDefaultMap::NewLC(); |
|
234 FillMapFromItemL(*inItemMap,*itemMap); |
|
235 itemMapList->AppendL( TLiwVariant(inItemMap) ); |
|
236 CleanupStack::Pop(inItemMap); |
|
237 inItemMap->Close(); |
|
238 } |
|
239 |
|
240 TLiwGenericParam settingsParam; |
|
241 settingsParam.SetNameAndValueL( KKeySettings, TLiwVariant(itemMapList) ); |
|
242 settingsParam.PushL(); |
|
243 inParamList.AppendL( settingsParam ); |
|
244 CleanupStack::Pop( &settingsParam ); |
|
245 settingsParam.Reset(); |
|
246 |
|
247 TLiwGenericParam storingParams; |
|
248 storingParams.SetNameAndValueL( KKeyStoringParams, TLiwVariant(aStoringParam) ); |
|
249 storingParams.PushL(); |
|
250 inParamList.AppendL( storingParams ); |
|
251 CleanupStack::Pop( &storingParams ); |
|
252 storingParams.Reset(); |
|
253 |
|
254 iHspsInterface->ExecuteCmdL( KHSPSSetPluginSettings, |
|
255 inParamList, |
|
256 outParamList ); |
|
257 |
|
258 CleanupStack::PopAndDestroy( itemMapList ); |
|
259 |
|
260 inParamList.Reset(); |
|
261 |
|
262 |
|
263 // check success |
|
264 const TLiwGenericParam* outParam = NULL; |
|
265 TInt pos(0); |
|
266 outParam = outParamList.FindFirst( pos, KOutKeyStatus ); |
|
267 TInt status(KErrGeneral); |
|
268 |
|
269 if ( outParam ) |
|
270 { |
|
271 status = outParam->Value().AsTInt32(); |
|
272 } |
|
273 outParamList.Reset(); |
|
274 return status; |
|
275 } |
|
276 // --------------------------------------------------------------------------- |
|
277 // --------------------------------------------------------------------------- |
|
278 // |
|
279 EXPORT_C TInt CHomescreenSettings::SetSettingsL( |
|
280 const TDesC8& aPluginId, |
|
281 const RPointerArray<CItemMap>& aSettings, |
|
282 const TBool aStoringParams) |
|
283 { |
|
284 TInt error = KErrNone; |
|
285 |
|
286 if( aStoringParams ) |
|
287 { |
|
288 error = SetPluginSettingsL(aPluginId, aSettings, KKeyStorePluginRefence()); |
|
289 } |
|
290 else |
|
291 { |
|
292 error = SetPluginSettingsL(aPluginId, aSettings, KKeyStoreAppConf()); |
|
293 } |
|
294 |
|
295 return error; |
|
296 } |
|
297 // --------------------------------------------------------------------------- |
|
298 // --------------------------------------------------------------------------- |
|
299 // |
|
300 EXPORT_C TInt CHomescreenSettings::GetSettingsL( |
|
301 const TDesC8& aPluginId, |
|
302 RPointerArray<CItemMap>& aSettings) |
|
303 { |
|
304 TInt error = KErrNone; |
|
305 CHspsConfiguration* configuration = CHspsConfiguration::NewLC(); |
|
306 |
|
307 // Compose AddPlugin hsps LIW message to Service.HomeScreenPluginConfiguration |
|
308 CLiwGenericParamList& inParamList = iServiceHandler->InParamListL(); |
|
309 CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL(); |
|
310 |
|
311 TLiwGenericParam pluginIdParam; |
|
312 pluginIdParam.SetNameAndValueL( KKeyPluginId, TLiwVariant(aPluginId) ); |
|
313 pluginIdParam.PushL(); |
|
314 inParamList.AppendL( pluginIdParam ); |
|
315 CleanupStack::Pop( &pluginIdParam ); |
|
316 pluginIdParam.Reset(); |
|
317 |
|
318 |
|
319 iHspsInterface->ExecuteCmdL( KHSPSCommandGetPluginConf, |
|
320 inParamList, |
|
321 outParamList ); |
|
322 |
|
323 inParamList.Reset(); |
|
324 |
|
325 TInt index(0); |
|
326 const TLiwGenericParam* conf = outParamList.FindFirst(index,KPluginConfKey); |
|
327 |
|
328 if(conf) |
|
329 { |
|
330 const CLiwMap* confMap = conf->Value().AsMap(); |
|
331 // 2: Process Configuration map |
|
332 if(confMap) |
|
333 { |
|
334 TLiwVariant tempVariant; |
|
335 tempVariant.PushL(); |
|
336 |
|
337 if( confMap->FindL( _L8("settings"), tempVariant )) |
|
338 { |
|
339 const CLiwList* settings_list( tempVariant.AsList() ); |
|
340 if( settings_list ) |
|
341 { |
|
342 aSettings.Reset(); |
|
343 ProcessConfigurationSettingsL(*settings_list,*configuration); |
|
344 RPointerArray<CItemMap>& settings = configuration->Settings(); |
|
345 CItemMap* itemMapIn(0); |
|
346 CPropertyMap* readProperty(0); |
|
347 CPropertyMap* propertyIn(0); |
|
348 |
|
349 for( TInt i = 0; i < settings.Count(); i++ ) |
|
350 { |
|
351 CItemMap* readItem = settings[i]; |
|
352 itemMapIn = CItemMap::NewLC(); |
|
353 itemMapIn->SetItemIdL(readItem->ItemId()); |
|
354 const TDesC8& itemName = readItem->ItemName(); |
|
355 itemMapIn->SetItemNameL(itemName); |
|
356 |
|
357 RPointerArray<CPropertyMap>& readProperties = readItem->Properties(); |
|
358 |
|
359 for( TInt j=0; j < readProperties.Count(); j++ ) |
|
360 { |
|
361 readProperty = readProperties[j]; |
|
362 propertyIn = CPropertyMap::NewLC(); |
|
363 propertyIn->SetNameL(readProperty->Name()); |
|
364 propertyIn->SetValueL(readProperty->Value()); |
|
365 // Dispatching is based on item name |
|
366 itemMapIn->AddPropertyMapL(propertyIn); |
|
367 CleanupStack::Pop(propertyIn); |
|
368 } |
|
369 |
|
370 aSettings.AppendL(itemMapIn); |
|
371 |
|
372 CleanupStack::Pop(itemMapIn); |
|
373 } |
|
374 } |
|
375 else |
|
376 { |
|
377 error=KErrNotFound; |
|
378 } |
|
379 } |
|
380 else |
|
381 { |
|
382 error= KErrNotFound; |
|
383 } |
|
384 |
|
385 |
|
386 CleanupStack::Pop(&tempVariant); |
|
387 tempVariant.Reset(); |
|
388 } |
|
389 } |
|
390 |
|
391 outParamList.Reset(); |
|
392 CleanupStack::PopAndDestroy(configuration); |
|
393 |
|
394 return error; |
|
395 } |
|
396 |
|
397 |
|
398 |
|
399 // --------------------------------------------------------------------------- |
|
400 // --------------------------------------------------------------------------- |
|
401 // |
|
402 void CHomescreenSettings::ProcessConfigurationSettingsL( |
|
403 const CLiwList& aItemList, |
|
404 CHspsConfiguration& aTarget) |
|
405 { |
|
406 TLiwVariant itemMapVariant; |
|
407 itemMapVariant.PushL(); |
|
408 for( int i=0;i<aItemList.Count();++i ) |
|
409 { |
|
410 if( aItemList.AtL(i,itemMapVariant) ) |
|
411 { |
|
412 const CLiwMap* itemMap( itemMapVariant.AsMap() ); |
|
413 TLiwVariant itemVariant; |
|
414 itemVariant.PushL(); |
|
415 if( itemMap ) |
|
416 { |
|
417 CItemMap* item = CItemMap::NewLC(); |
|
418 if( itemMap->FindL( _L8("itemId"),itemVariant) ) |
|
419 { |
|
420 item->SetItemIdL( itemVariant.AsData() ); |
|
421 } |
|
422 if( itemMap->FindL( _L8("name"),itemVariant) ) |
|
423 { |
|
424 item->SetItemNameL( itemVariant.AsData() ); |
|
425 } |
|
426 if( itemMap->FindL( _L8("properties"),itemVariant) ) |
|
427 { |
|
428 const CLiwList* properties( itemVariant.AsList() ); |
|
429 if(properties) |
|
430 { |
|
431 ProcessConfItemPropertiesL(*properties,*item); |
|
432 } |
|
433 } |
|
434 |
|
435 aTarget.AddItemMapL(item); |
|
436 CleanupStack::Pop(item); |
|
437 } |
|
438 CleanupStack::Pop(&itemVariant); |
|
439 itemVariant.Reset(); |
|
440 } |
|
441 |
|
442 } |
|
443 CleanupStack::Pop(&itemMapVariant); |
|
444 itemMapVariant.Reset(); |
|
445 } |
|
446 |
|
447 |
|
448 // --------------------------------------------------------------------------- |
|
449 // --------------------------------------------------------------------------- |
|
450 // |
|
451 void CHomescreenSettings::ProcessConfItemPropertiesL( |
|
452 const CLiwList& aPropertyMapList, |
|
453 CItemMap& aItemMap) |
|
454 { |
|
455 TLiwVariant propertyMapVariant; |
|
456 propertyMapVariant.PushL(); |
|
457 for( int i=0;i<aPropertyMapList.Count();++i ) |
|
458 { |
|
459 if( aPropertyMapList.AtL(i,propertyMapVariant) ) |
|
460 { |
|
461 const CLiwMap* propertyMap( propertyMapVariant.AsMap() ); |
|
462 TLiwVariant propertyVariant; |
|
463 propertyVariant.PushL(); |
|
464 if( propertyMap ) |
|
465 { |
|
466 CPropertyMap* property = CPropertyMap::NewLC(); |
|
467 if( propertyMap->FindL( _L8("name"),propertyVariant ) ) |
|
468 { |
|
469 property->SetNameL( propertyVariant.AsData() ); |
|
470 } |
|
471 if( propertyMap->FindL( _L8("value"),propertyVariant ) ) |
|
472 { |
|
473 property->SetValueL( propertyVariant.AsData() ); |
|
474 } |
|
475 aItemMap.AddPropertyMapL(property); |
|
476 CleanupStack::Pop(property); |
|
477 } |
|
478 CleanupStack::Pop(&propertyVariant); |
|
479 propertyVariant.Reset(); |
|
480 } |
|
481 |
|
482 } |
|
483 CleanupStack::Pop(&propertyMapVariant); |
|
484 propertyMapVariant.Reset(); |
|
485 } |
|
486 |
|
487 |
|
488 |
|
489 // --------------------------------------------------------------------------- |
|
490 // --------------------------------------------------------------------------- |
|
491 // |
|
492 void CHomescreenSettings::FillMapFromItemL( CLiwDefaultMap& aMap, const CItemMap& aItemMap ) |
|
493 { |
|
494 aMap.InsertL( KKeyItemId, TLiwVariant(aItemMap.ItemId()) ); |
|
495 aMap.InsertL( KKeyName, TLiwVariant(aItemMap.ItemName()) ); |
|
496 |
|
497 CLiwDefaultList* inPropertyMapList = CLiwDefaultList::NewLC(); |
|
498 FillMapFromPropertiesL(*inPropertyMapList,aItemMap.Properties()); |
|
499 aMap.InsertL( KKeyProperties, TLiwVariant(inPropertyMapList) ); |
|
500 CleanupStack::Pop(inPropertyMapList); |
|
501 inPropertyMapList->Close(); |
|
502 } |
|
503 |
|
504 // --------------------------------------------------------------------------- |
|
505 // --------------------------------------------------------------------------- |
|
506 // |
|
507 void CHomescreenSettings::FillMapFromPropertiesL( |
|
508 CLiwDefaultList& aInPropertyMapList, |
|
509 const RPointerArray<CPropertyMap>& aProperties ) |
|
510 { |
|
511 |
|
512 for(int i=0; i<aProperties.Count(); ++i) |
|
513 { |
|
514 CLiwDefaultMap* inPropertyMap = CLiwDefaultMap::NewLC(); |
|
515 inPropertyMap->InsertL( KKeyName, TLiwVariant(aProperties[i]->Name()) ); |
|
516 inPropertyMap->InsertL( KKeyValue, TLiwVariant(aProperties[i]->Value()) ); |
|
517 aInPropertyMapList.AppendL(inPropertyMap); |
|
518 CleanupStack::Pop(inPropertyMap); |
|
519 inPropertyMap->Close(); |
|
520 } |
|
521 } |
|
522 |
|
523 // --------------------------------------------------------------------------- |
|
524 // --------------------------------------------------------------------------- |
|
525 // |
|
526 TInt CHomescreenSettings::HandleNotifyL( TInt aCmdId, TInt aEventId, |
|
527 CLiwGenericParamList& aEventParamList, |
|
528 const CLiwGenericParamList& /*aInParamList*/ ) |
|
529 { |
|
530 TInt retval( KErrNone ); |
|
531 |
|
532 if( iObserver && iTransactionId == aCmdId ) |
|
533 { |
|
534 const TLiwGenericParam* outParam( NULL ); |
|
535 |
|
536 TInt pos( 0 ); |
|
537 outParam = aEventParamList.FindFirst( pos, _L8("status") ); |
|
538 |
|
539 if ( outParam ) |
|
540 { |
|
541 retval = outParam->Value().AsTInt32(); |
|
542 } |
|
543 else |
|
544 { |
|
545 pos = 0; |
|
546 |
|
547 retval = KErrNotFound; |
|
548 |
|
549 outParam = aEventParamList.FindFirst( pos, _L8("notification") ); |
|
550 |
|
551 if( !outParam ) |
|
552 { |
|
553 // should never happen, but change status back to KErrNotFound |
|
554 return retval; |
|
555 } |
|
556 |
|
557 HBufC8* event( NULL ); |
|
558 HBufC8* pluginUid( NULL ); |
|
559 HBufC8* pluginName( NULL ); |
|
560 TInt pushCount( 0 ); |
|
561 |
|
562 TLiwVariant variant; |
|
563 variant.PushL(); |
|
564 pushCount++; |
|
565 |
|
566 variant = outParam->Value(); |
|
567 |
|
568 const CLiwMap* notifMap( variant.AsMap() ); |
|
569 |
|
570 if ( notifMap->FindL( _L8("event"), variant ) ) |
|
571 { |
|
572 event = variant.AsData().AllocLC(); |
|
573 pushCount++; |
|
574 } |
|
575 |
|
576 variant.Reset(); |
|
577 |
|
578 if ( event->Des().Compare( KSettingsChanged ) == 0 ) |
|
579 { |
|
580 if( notifMap->FindL( _L8("name"), variant ) ) |
|
581 { |
|
582 pluginName = variant.AsData().AllocLC(); |
|
583 pushCount++; |
|
584 } |
|
585 |
|
586 variant.Reset(); |
|
587 |
|
588 if( notifMap->FindL( _L8("pluginUid"), variant ) ) |
|
589 { |
|
590 pluginUid = variant.AsData().AllocLC(); |
|
591 pushCount++; |
|
592 } |
|
593 |
|
594 |
|
595 variant.Reset(); |
|
596 |
|
597 if( notifMap->FindL( _L8("pluginIds"), variant ) ) |
|
598 { |
|
599 const CLiwList* pluginIdList( variant.AsList() ); |
|
600 |
|
601 variant.Reset(); |
|
602 |
|
603 TInt count( pluginIdList->Count() ); |
|
604 |
|
605 retval = KErrNone; |
|
606 |
|
607 for( TInt i = 0; i < count && retval == KErrNone; i++ ) |
|
608 { |
|
609 pluginIdList->AtL( i, variant ); |
|
610 HBufC8* pluginId( NULL ); |
|
611 pluginId = variant.AsData().AllocLC(); |
|
612 |
|
613 if( pluginId->Des().Compare(iPluginId)== 0 ) |
|
614 { |
|
615 retval = iObserver->SettingsChangedL( |
|
616 ( event ) ? *event : KNullDesC8(), |
|
617 ( pluginName ) ? *pluginName : KNullDesC8(), |
|
618 ( pluginUid ) ? *pluginUid : KNullDesC8(), |
|
619 ( pluginId ) ? * pluginId : KNullDesC8() ); |
|
620 } |
|
621 CleanupStack::PopAndDestroy( pluginId ); |
|
622 |
|
623 variant.Reset(); |
|
624 |
|
625 } |
|
626 |
|
627 } |
|
628 |
|
629 } |
|
630 |
|
631 CleanupStack::PopAndDestroy( pushCount ); |
|
632 } |
|
633 } |
|
634 |
|
635 if( retval != KErrNone && aEventId != KLiwEventInProgress) |
|
636 { |
|
637 CLiwGenericParamList& inParamList = iServiceHandler->InParamListL(); |
|
638 CLiwGenericParamList& outParamList = iServiceHandler->OutParamListL(); |
|
639 |
|
640 inParamList.Reset(); |
|
641 outParamList.Reset(); |
|
642 //cancel old notification request |
|
643 iHspsInterface->ExecuteCmdL( KRequestNotification, |
|
644 inParamList, |
|
645 outParamList, |
|
646 KLiwOptCancel, |
|
647 this ); |
|
648 |
|
649 inParamList.Reset(); |
|
650 outParamList.Reset(); |
|
651 //request notification again |
|
652 iTransactionId = -1; |
|
653 iHspsInterface->ExecuteCmdL( KRequestNotification, |
|
654 inParamList, |
|
655 outParamList, |
|
656 KLiwOptASyncronous, |
|
657 this ); |
|
658 |
|
659 const TLiwGenericParam* outParam( NULL ); |
|
660 |
|
661 TInt pos( 0 ); |
|
662 outParam = outParamList.FindFirst( pos, _L8("status") ); |
|
663 |
|
664 if ( outParam ) |
|
665 { |
|
666 TInt retval; |
|
667 retval = outParam->Value().AsTInt32(); |
|
668 |
|
669 if(retval == KErrNone ) |
|
670 { |
|
671 pos = 0; |
|
672 outParam = outParamList.FindFirst( pos, _L8("TransactionID") ); |
|
673 |
|
674 if( outParam ) |
|
675 { |
|
676 retval = outParam->Value().AsTInt32(); |
|
677 iTransactionId = retval; |
|
678 } |
|
679 } |
|
680 } |
|
681 |
|
682 } |
|
683 |
|
684 |
|
685 return retval; |
|
686 } |
|
687 |
|
688 } |
|
689 //End of file |
|