|
1 /* |
|
2 * Copyright (c) 2007-2010 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: IETF SIMPLE Protocol implementation for XIMP Framework |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <e32std.h> |
|
20 #include <e32base.h> |
|
21 #include <s32strm.h> |
|
22 #include <e32def.h> |
|
23 #include <e32svr.h> |
|
24 #include <e32math.h> |
|
25 #include <utf.h> |
|
26 #include <ximpbase.h> |
|
27 #include <ximpobjectfactory.h> |
|
28 #include <ximpobjectcollection.h> |
|
29 #include <presenceobjectfactory.h> |
|
30 #include <presenceinfo.h> |
|
31 #include <personpresenceinfo.h> |
|
32 #include <presenceinfofieldcollection.h> |
|
33 #include <presenceinfofield.h> |
|
34 #include <presenceinfofieldvaluetext.h> |
|
35 #include <presenceinfofieldvalueenum.h> |
|
36 #include <ximpidentity.h> |
|
37 #include <msimpledocument.h> |
|
38 #include <msimpleelement.h> |
|
39 #include <msimplepresencelist.h> |
|
40 #include <msimplemeta.h> |
|
41 #include <simpleutils.h> |
|
42 #include <presencecachewriter2.h> |
|
43 #include <presencecachereader2.h> |
|
44 #include <presencebuddyinfo.h> |
|
45 #include <spsettings.h> |
|
46 #include <spentry.h> |
|
47 #include <spproperty.h> |
|
48 #include <spdefinitions.h> |
|
49 #include <avabilitytext.h> |
|
50 #include <cvimpstsettingsstore.h> |
|
51 |
|
52 |
|
53 #include "presenceplugindata.h" |
|
54 #include "presenceplugincommon.h" |
|
55 #include "presencepluginvirtualgroup.h" |
|
56 #include "presencepluginlanguagecodes.h" |
|
57 |
|
58 // --------------------------------------------------------------------------- |
|
59 // CPresencePluginData::CPresencePluginData |
|
60 // --------------------------------------------------------------------------- |
|
61 // |
|
62 CPresencePluginData::CPresencePluginData( |
|
63 MPresencePluginConnectionObs& aObs, |
|
64 TInt aServiceId ): |
|
65 iConnObs( aObs ), |
|
66 iServiceId( aServiceId ), |
|
67 iPresenceCacheWriter( NULL ), |
|
68 iPresenceCacheReader( NULL ) |
|
69 { |
|
70 } |
|
71 |
|
72 // --------------------------------------------------------------------------- |
|
73 // CPresencePluginData::~CPresencePluginData |
|
74 // --------------------------------------------------------------------------- |
|
75 // |
|
76 CPresencePluginData::~CPresencePluginData() |
|
77 { |
|
78 DP_SDA("CPresencePluginData::~CPresencePluginData"); |
|
79 delete iPresenceCacheWriter; |
|
80 delete iPresenceCacheReader; |
|
81 } |
|
82 |
|
83 // --------------------------------------------------------------------------- |
|
84 // CPresencePluginData::NewL |
|
85 // --------------------------------------------------------------------------- |
|
86 // |
|
87 CPresencePluginData* CPresencePluginData::NewL( |
|
88 MPresencePluginConnectionObs& aObs, TInt aServiceId ) |
|
89 { |
|
90 CPresencePluginData* self = CPresencePluginData::NewLC( |
|
91 aObs, |
|
92 aServiceId ); |
|
93 CleanupStack::Pop( self ); |
|
94 return self; |
|
95 } |
|
96 |
|
97 |
|
98 // --------------------------------------------------------------------------- |
|
99 // CPresencePluginData::ConstructL |
|
100 // --------------------------------------------------------------------------- |
|
101 // |
|
102 void CPresencePluginData::ConstructL() |
|
103 { |
|
104 DP_SDA("CPresencePluginData::ConstructL"); |
|
105 iPresenceCacheWriter = MPresenceCacheWriter2::CreateWriterL(); |
|
106 iPresenceCacheReader = MPresenceCacheReader2::CreateReaderL(); |
|
107 } |
|
108 |
|
109 // --------------------------------------------------------------------------- |
|
110 // CPresencePluginData::NewLC |
|
111 // --------------------------------------------------------------------------- |
|
112 // |
|
113 CPresencePluginData* CPresencePluginData::NewLC( |
|
114 MPresencePluginConnectionObs& aObs, TInt aServiceId ) |
|
115 { |
|
116 CPresencePluginData* self = |
|
117 new( ELeave ) CPresencePluginData( aObs, aServiceId ); |
|
118 CleanupStack::PushL( self ); |
|
119 self->ConstructL(); |
|
120 return self; |
|
121 } |
|
122 |
|
123 // --------------------------------------------------------------------------- |
|
124 // CPresencePluginData::NotifyToBlockedToXIMPL |
|
125 // --------------------------------------------------------------------------- |
|
126 // |
|
127 void CPresencePluginData::NotifyToBlockedToXIMPL( |
|
128 MPresenceObjectFactory& aPresenceFactory, |
|
129 MPresenceInfo& aPrInfo, |
|
130 const TDesC& aUnicodeNoteContent ) |
|
131 { |
|
132 DP_SDA("CPresencePluginData::NotifyToBlockedToXIMPL"); |
|
133 MPersonPresenceInfo* persInfo = |
|
134 aPresenceFactory.NewPersonPresenceInfoLC(); |
|
135 MPresenceInfoFieldCollection& coll = persInfo->Fields(); |
|
136 |
|
137 //Set pending |
|
138 using namespace NPresenceInfo::NFieldType; |
|
139 using namespace NPresencePlugin::NPresenceStates; |
|
140 |
|
141 MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC(); |
|
142 field->SetFieldTypeL( KAvailabilityEnum ); |
|
143 |
|
144 // use mapped enums to pass status |
|
145 MPresenceInfoFieldValueEnum* enumField = |
|
146 aPresenceFactory.NewEnumInfoFieldLC(); |
|
147 |
|
148 // HOX: BLOCKED ENUM NEEDED TO XIMP |
|
149 enumField->SetValueL( NPresenceInfo::ENotAvailable ); |
|
150 field->SetFieldValue( enumField ); |
|
151 |
|
152 coll.AddOrReplaceFieldL( field ); |
|
153 CleanupStack::Pop( 2 ); // >> field, enumField |
|
154 |
|
155 // Add status msg field |
|
156 MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC(); |
|
157 noteField->SetFieldTypeL( KStatusMessage ); |
|
158 |
|
159 MPresenceInfoFieldValueText* textField = |
|
160 aPresenceFactory.NewTextInfoFieldLC(); |
|
161 textField->SetTextValueL( aUnicodeNoteContent ); |
|
162 |
|
163 noteField->SetFieldValue( textField ); |
|
164 |
|
165 coll.AddOrReplaceFieldL( noteField ); |
|
166 CleanupStack::Pop( 2 ); // >> noteField, enumField |
|
167 |
|
168 aPrInfo.SetPersonPresenceL( persInfo ); |
|
169 CleanupStack::Pop(); // >> persInfo |
|
170 DP_SDA("CPresencePluginData::NotifyToBlockedToXIMPL end"); |
|
171 } |
|
172 |
|
173 // --------------------------------------------------------------------------- |
|
174 // CPresencePluginData::NotifyToPendingToXIMPL |
|
175 // --------------------------------------------------------------------------- |
|
176 // |
|
177 void CPresencePluginData::NotifyToPendingToXIMPL( |
|
178 MPresenceObjectFactory& aPresenceFactory, |
|
179 MPresenceInfo& aPrInfo, |
|
180 const TDesC& aUnicodeNoteContent ) |
|
181 { |
|
182 DP_SDA("CPresencePluginData::NotifyToPendingToXIMP"); |
|
183 MPersonPresenceInfo* persInfo = |
|
184 aPresenceFactory.NewPersonPresenceInfoLC(); |
|
185 MPresenceInfoFieldCollection& coll = persInfo->Fields(); |
|
186 |
|
187 //Set pending |
|
188 using namespace NPresenceInfo::NFieldType; |
|
189 using namespace NPresencePlugin::NPresenceStates; |
|
190 |
|
191 MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC(); |
|
192 field->SetFieldTypeL( KAvailabilityEnum ); |
|
193 |
|
194 // use mapped enums to pass status |
|
195 MPresenceInfoFieldValueEnum* enumField = |
|
196 aPresenceFactory.NewEnumInfoFieldLC(); |
|
197 enumField->SetValueL( NPresenceInfo::ERemotePending ); |
|
198 field->SetFieldValue( enumField ); |
|
199 |
|
200 coll.AddOrReplaceFieldL( field ); |
|
201 CleanupStack::Pop( 2 ); // >> field, enumField |
|
202 |
|
203 // Add status msg field |
|
204 MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC(); |
|
205 noteField->SetFieldTypeL( KStatusMessage ); |
|
206 |
|
207 MPresenceInfoFieldValueText* textField = |
|
208 aPresenceFactory.NewTextInfoFieldLC(); |
|
209 textField->SetTextValueL( aUnicodeNoteContent ); |
|
210 |
|
211 noteField->SetFieldValue( textField ); |
|
212 |
|
213 coll.AddOrReplaceFieldL( noteField ); |
|
214 CleanupStack::Pop( 2 ); // >> noteField, enumField |
|
215 |
|
216 aPrInfo.SetPersonPresenceL( persInfo ); |
|
217 CleanupStack::Pop(); // >> persInfo |
|
218 DP_SDA("CPresencePluginData::NotifyToPendingToXIMP end"); |
|
219 } |
|
220 |
|
221 // --------------------------------------------------------------------------- |
|
222 // CPresencePluginData::NotifyActiveToPrInfoL |
|
223 // --------------------------------------------------------------------------- |
|
224 // |
|
225 void CPresencePluginData::NotifyToActiveToXIMPL( |
|
226 MPresenceObjectFactory& aPresenceFactory, |
|
227 MPresenceInfo& aPrInfo, |
|
228 const TDesC& aUnicodeNoteContent, |
|
229 NPresenceInfo::TAvailabilityValues aAvailability ) |
|
230 { |
|
231 DP_SDA("CPresencePluginData::NotifyToActiveToXIMPL"); |
|
232 MPersonPresenceInfo* persInfo = |
|
233 aPresenceFactory.NewPersonPresenceInfoLC(); |
|
234 MPresenceInfoFieldCollection& coll = persInfo->Fields(); |
|
235 |
|
236 //Set pending |
|
237 using namespace NPresenceInfo::NFieldType; |
|
238 using namespace NPresencePlugin::NPresenceStates; |
|
239 |
|
240 MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC(); |
|
241 field->SetFieldTypeL( KAvailabilityEnum ); |
|
242 |
|
243 // use mapped enums to pass status |
|
244 MPresenceInfoFieldValueEnum* enumField = |
|
245 aPresenceFactory.NewEnumInfoFieldLC(); |
|
246 enumField->SetValueL( aAvailability ); |
|
247 field->SetFieldValue( enumField ); |
|
248 |
|
249 coll.AddOrReplaceFieldL( field ); |
|
250 CleanupStack::Pop( 2 ); // >> field, enumField |
|
251 |
|
252 // Add status msg field |
|
253 MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC(); |
|
254 noteField->SetFieldTypeL( KStatusMessage ); |
|
255 |
|
256 MPresenceInfoFieldValueText* textField = |
|
257 aPresenceFactory.NewTextInfoFieldLC(); |
|
258 textField->SetTextValueL( aUnicodeNoteContent ); |
|
259 |
|
260 noteField->SetFieldValue( textField ); |
|
261 |
|
262 coll.AddOrReplaceFieldL( noteField ); |
|
263 CleanupStack::Pop( 2 ); // >> noteField, enumField |
|
264 |
|
265 aPrInfo.SetPersonPresenceL( persInfo ); |
|
266 CleanupStack::Pop(); // >> persInfo |
|
267 DP_SDA("CPresencePluginData::NotifyToActiveToXIMPL end"); |
|
268 } |
|
269 |
|
270 // --------------------------------------------------------------------------- |
|
271 // CPresencePluginData::NotifyTerminatedToPrInfoL |
|
272 // --------------------------------------------------------------------------- |
|
273 // |
|
274 void CPresencePluginData::NotifyTerminatedToXIMPL( |
|
275 MPresenceObjectFactory& aPresenceFactory, |
|
276 MPresenceInfo& aPrInfo, |
|
277 const TDesC& aUnicodeNoteContent ) |
|
278 { |
|
279 DP_SDA("CPresencePluginData::NotifyTerminatedToXIMPL"); |
|
280 MPersonPresenceInfo* persInfo = |
|
281 aPresenceFactory.NewPersonPresenceInfoLC(); |
|
282 MPresenceInfoFieldCollection& coll = persInfo->Fields(); |
|
283 |
|
284 //Set pending |
|
285 using namespace NPresenceInfo::NFieldType; |
|
286 using namespace NPresencePlugin::NPresenceStates; |
|
287 |
|
288 MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC(); |
|
289 field->SetFieldTypeL( KAvailabilityEnum ); |
|
290 |
|
291 // use mapped enums to pass status |
|
292 MPresenceInfoFieldValueEnum* enumField = |
|
293 aPresenceFactory.NewEnumInfoFieldLC(); |
|
294 enumField->SetValueL( NPresenceInfo::EOffline ); |
|
295 field->SetFieldValue( enumField ); |
|
296 |
|
297 coll.AddOrReplaceFieldL( field ); |
|
298 CleanupStack::Pop( 2 ); // >> field, enumField |
|
299 |
|
300 // Add status msg field |
|
301 MPresenceInfoField* noteField = aPresenceFactory.NewInfoFieldLC(); |
|
302 noteField->SetFieldTypeL( KStatusMessage ); |
|
303 |
|
304 MPresenceInfoFieldValueText* textField = |
|
305 aPresenceFactory.NewTextInfoFieldLC(); |
|
306 textField->SetTextValueL( aUnicodeNoteContent ); |
|
307 |
|
308 noteField->SetFieldValue( textField ); |
|
309 |
|
310 coll.AddOrReplaceFieldL( noteField ); |
|
311 CleanupStack::Pop( 2 ); // >> noteField, enumField |
|
312 |
|
313 aPrInfo.SetPersonPresenceL( persInfo ); |
|
314 CleanupStack::Pop(); // >> persInfo |
|
315 DP_SDA("CPresencePluginData::NotifyTerminatedToXIMPL end"); |
|
316 } |
|
317 |
|
318 // --------------------------------------------------------------------------- |
|
319 // CPresencePluginData::NotifyToPrInfoL |
|
320 // --------------------------------------------------------------------------- |
|
321 // |
|
322 void CPresencePluginData::NotifyToPrInfoL( |
|
323 MXIMPObjectFactory& /*aFactory*/, |
|
324 MPresenceObjectFactory& aPresenceFactory, |
|
325 MSimpleDocument& aDocument, |
|
326 MPresenceInfo& aPrInfo ) |
|
327 { |
|
328 DP_SDA("CPresencePluginData::NotifyToPrInfoL"); |
|
329 MPersonPresenceInfo* persInfo = |
|
330 aPresenceFactory.NewPersonPresenceInfoLC(); |
|
331 DP_SDA("CPresencePluginData::NotifyToPrInfoL persInfo"); |
|
332 |
|
333 if( !aDocument.EntityURI() ) |
|
334 { |
|
335 DP_SDA("CPresencePluginData::NotifyToPrInfoL entity URL not valid"); |
|
336 User::Leave( KErrCancel ); |
|
337 } |
|
338 |
|
339 MPresenceInfoFieldCollection& coll = persInfo->Fields(); |
|
340 |
|
341 DP_SDA("CPresencePluginData::NotifyToPrInfoL collection"); |
|
342 // Search own person info. Notice: Extend supported attributes later |
|
343 TBool basicElementFound = EFalse; |
|
344 TBool activitiesElementFound = EFalse; |
|
345 TBool noteElemFound = EFalse; |
|
346 |
|
347 DP_SDA("CPresencePluginData::NotifyToPrInfoL RPointerArray"); |
|
348 RPointerArray<MSimpleElement> elems; |
|
349 DP_SDA("CPresencePluginData::NotifyToPrInfoL Push elems"); |
|
350 CleanupClosePushL( elems ); |
|
351 DP_SDA("CPresencePluginData::NotifyToPrInfoL aDocument"); |
|
352 TInt err = aDocument.SimpleElementsL( elems ); |
|
353 |
|
354 DP_SDA2("CPresencePluginData::NotifyToPrInfoL err %d", err); |
|
355 |
|
356 RPointerArray<MSimpleElement> basicElems; |
|
357 CleanupClosePushL( basicElems ); |
|
358 MSimpleElement* basicSimpleElem(NULL); |
|
359 |
|
360 RPointerArray<MSimpleElement> activitiesElems; |
|
361 CleanupClosePushL( activitiesElems ); |
|
362 MSimpleElement* activitiesSimpleElem(NULL); |
|
363 MSimpleElement* noteSimpleElem(NULL); |
|
364 |
|
365 if ( !err ) |
|
366 { |
|
367 DP_SDA("CPresencePluginData::NotifyToPrInfoL, elements ok"); |
|
368 TInt count = elems.Count(); |
|
369 DP_SDA2("CPresencePluginData::NotifyToPrInfoL, element count: %d", count ); |
|
370 |
|
371 using namespace NPresencePlugin::NPresence; |
|
372 |
|
373 MSimpleElement* elem = NULL; |
|
374 TPtrC8 p8; |
|
375 |
|
376 for ( TInt i = 0; i < count; i++ ) |
|
377 { |
|
378 DP_SDA2("CPresencePluginData::NotifyToPrInfoL, handling elem[%d]", i ); |
|
379 |
|
380 elem = elems[i]; |
|
381 p8.Set( elem->LocalName()); |
|
382 if (!( p8.CompareF( KPresencePerson8 )) || |
|
383 !( p8.CompareF( KPresenceTuple8 )) ) |
|
384 { |
|
385 // person element found |
|
386 RPointerArray<MSimpleElement> elems2; |
|
387 CleanupClosePushL( elems2 ); |
|
388 elem->SimpleElementsL( elems2 ); |
|
389 TInt count2 = elems2.Count(); |
|
390 DP_SDA2("CPresencePluginData::NotifyToPrInfoL count2 %d", count2); |
|
391 for ( TInt j = 0; j < count2; j++ ) |
|
392 { |
|
393 DP_SDA("CPresencePluginData::NotifyToPrInfoL 4"); |
|
394 // |
|
395 MSimpleElement* elem2 = elems2[j]; |
|
396 |
|
397 //FIND BASIC/ACTIVITIES ELEMENT |
|
398 if ( !elem2->LocalName().CompareF( KPresenceStatus8 ) && |
|
399 !basicElementFound ) |
|
400 { |
|
401 DP_SDA("NotifyToPrInfoL PresenceStatus"); |
|
402 //Get elem2 childs |
|
403 elem2->SimpleElementsL( basicElems ); |
|
404 TInt count3 = basicElems.Count(); //Child count |
|
405 for ( TInt k = 0; k < count3; k++ ) |
|
406 { |
|
407 MSimpleElement* tempElem = basicElems[k]; |
|
408 if ( !tempElem->LocalName().CompareF( |
|
409 KPresenceBasic8 )) |
|
410 { |
|
411 DP_SDA("NotifyToPrInfoL basic elem true"); |
|
412 basicSimpleElem = basicElems[k]; |
|
413 basicElementFound = ETrue; |
|
414 } |
|
415 else if( !tempElem->LocalName().CompareF( |
|
416 KPresenceActivities8 )) |
|
417 { |
|
418 DP_SDA("NotifyToPrInfoL activities under basic"); |
|
419 activitiesSimpleElem = basicElems[k]; |
|
420 activitiesElementFound = ETrue; |
|
421 } |
|
422 } |
|
423 } |
|
424 |
|
425 //FIND ACTIVITIES ELEMENT |
|
426 if ( basicElementFound && !activitiesElementFound && |
|
427 !elem2->LocalName().CompareF( KPresenceActivities8 ) ) |
|
428 { |
|
429 DP_SDA("NotifyToPrInfoL activities found outside basic"); |
|
430 elem2->SimpleElementsL( activitiesElems ); |
|
431 TInt count4 = activitiesElems.Count(); |
|
432 for ( TInt l = 0; l < count4; l++ ) |
|
433 { |
|
434 activitiesSimpleElem = activitiesElems[l]; |
|
435 activitiesElementFound = ETrue; |
|
436 DP_SDA("CPresencePluginData::NotifyToPrInfoL 6"); |
|
437 } |
|
438 } |
|
439 } |
|
440 |
|
441 if ( basicElementFound && !noteSimpleElem ) |
|
442 { |
|
443 noteSimpleElem = ResolveNoteElementL( elems2 ); |
|
444 } |
|
445 |
|
446 DP_SDA("NotifyToPrInfoL ALL DONE"); |
|
447 CleanupStack::PopAndDestroy( &elems2 ); |
|
448 |
|
449 if ( basicElementFound && activitiesElementFound && noteElemFound ) |
|
450 { |
|
451 DP_SDA("NotifyToPrInfoL ALL DONE break out"); |
|
452 //Just handle first status information from document |
|
453 // In future server should support <timestamp> |
|
454 //Also client should be can handle timestaps if there are present |
|
455 break; |
|
456 } |
|
457 } |
|
458 // Check note field |
|
459 else if ( basicElementFound && !( p8.CompareF( KPresenceNote8 )) && |
|
460 !noteSimpleElem ) |
|
461 { |
|
462 DP_SDA("NotifyToPrInfoL note field found outside tuple"); |
|
463 noteSimpleElem = elem; |
|
464 } |
|
465 } |
|
466 } |
|
467 |
|
468 if ( basicElementFound ) |
|
469 { |
|
470 DP_SDA("NotifyToPrInfoL basic proceed to handling"); |
|
471 SingleUserStatusToXIMPL( |
|
472 aPresenceFactory, basicSimpleElem, |
|
473 activitiesSimpleElem, noteSimpleElem, coll ); |
|
474 } |
|
475 CleanupStack::PopAndDestroy( &activitiesElems ); |
|
476 CleanupStack::PopAndDestroy( &basicElems ); |
|
477 CleanupStack::PopAndDestroy( &elems ); |
|
478 |
|
479 aPrInfo.SetPersonPresenceL( persInfo ); |
|
480 CleanupStack::Pop(); // >> persInfo |
|
481 |
|
482 // TODO2: Notice: the following crashes in old PrFW version |
|
483 /* |
|
484 aPrInfo.AddDevicePresenceL ( NULL ); |
|
485 aPrInfo.AddServicePresenceL( NULL ); |
|
486 */ |
|
487 DP_SDA("CPresencePluginData::NotifyToPrInfoL end"); |
|
488 } |
|
489 |
|
490 |
|
491 // --------------------------------------------------------------------------- |
|
492 // CPresencePluginData::CacheEntriesFromPrInfo |
|
493 // --------------------------------------------------------------------------- |
|
494 // |
|
495 void CPresencePluginData::CacheEntriesFromPrInfo( |
|
496 MPresenceInfo& aPrInfo, |
|
497 MPresenceBuddyInfo2::TAvailabilityValues& aAvailability, |
|
498 TPtr& aExtendedAvailability, |
|
499 TPtr& aStatusMessage ) |
|
500 { |
|
501 DP_SDA("CPresencePluginData::CacheEntriesFromPrInfoL"); |
|
502 |
|
503 DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status enum field"); |
|
504 MPresenceInfoField* statusEnumInfoField = NULL; |
|
505 MPersonPresenceInfo* presInfo = aPrInfo.PersonPresence(); |
|
506 if ( presInfo ) |
|
507 { |
|
508 DP_SDA(" -> CacheEntriesFromPrInfoL, has person presence, get field"); |
|
509 presInfo->Fields().LookupFieldByFieldType( |
|
510 statusEnumInfoField, |
|
511 NPresenceInfo::NFieldType::KAvailabilityEnum ); |
|
512 DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status enum field done, check item"); |
|
513 if ( statusEnumInfoField ) |
|
514 { |
|
515 DP_SDA(" -> status enum field found"); |
|
516 const MPresenceInfoFieldValueEnum* availability = |
|
517 TXIMPGetInterface< const MPresenceInfoFieldValueEnum >::From( |
|
518 statusEnumInfoField->FieldValue(), MXIMPBase::EPanicIfUnknown ); |
|
519 switch( availability->Value() ) |
|
520 { |
|
521 case NPresenceInfo::EAvailable: |
|
522 { |
|
523 DP_SDA(" -> status enum field => available"); |
|
524 aAvailability = MPresenceBuddyInfo2::EAvailable; |
|
525 aExtendedAvailability.Copy( KDefaultAvailableStatus() ); |
|
526 } |
|
527 break; |
|
528 |
|
529 case NPresenceInfo::EBusy: |
|
530 { |
|
531 DP_SDA(" -> status enum field => busy"); |
|
532 aAvailability = MPresenceBuddyInfo2::EBusy; |
|
533 aExtendedAvailability.Copy( KDndState() ); |
|
534 } |
|
535 break; |
|
536 |
|
537 case NPresenceInfo::EOnPhone: |
|
538 { |
|
539 DP_SDA(" -> status enum field => on phone"); |
|
540 aAvailability = MPresenceBuddyInfo2::EBusy; |
|
541 aExtendedAvailability.Copy( KOnPhoneState() ); |
|
542 } |
|
543 break; |
|
544 |
|
545 case NPresenceInfo::EAway: |
|
546 { |
|
547 DP_SDA(" -> status enum field => away"); |
|
548 aAvailability = MPresenceBuddyInfo2::EBusy; |
|
549 aExtendedAvailability.Copy( KAwayState() ); |
|
550 } |
|
551 break; |
|
552 |
|
553 case NPresenceInfo::EDoNotDisturb: |
|
554 { |
|
555 DP_SDA(" -> status enum field => dnd"); |
|
556 aAvailability = MPresenceBuddyInfo2::EBusy; |
|
557 aExtendedAvailability.Copy( KDndState() ); |
|
558 } |
|
559 break; |
|
560 |
|
561 case NPresenceInfo::EOffline: |
|
562 case NPresenceInfo::ENotAvailable: |
|
563 default: |
|
564 { |
|
565 DP_SDA(" -> status enum field => offline/not available/default"); |
|
566 aAvailability = MPresenceBuddyInfo2::ENotAvailable; |
|
567 aExtendedAvailability.Copy( KInvisibleState() ); |
|
568 } |
|
569 break; |
|
570 } |
|
571 } |
|
572 else |
|
573 { |
|
574 DP_SDA(" -> status enum not found => set unknown"); |
|
575 aAvailability = MPresenceBuddyInfo2::EUnknownAvailability; |
|
576 aExtendedAvailability.Copy( KNullDesC() ); |
|
577 } |
|
578 DP_SDA(" -> fetch status message field"); |
|
579 MPresenceInfoField* statusMsgInfoField = NULL; |
|
580 presInfo->Fields().LookupFieldByFieldType( |
|
581 statusMsgInfoField, |
|
582 NPresenceInfo::NFieldType::KStatusMessage ); |
|
583 DP_SDA(" -> CacheEntriesFromPrInfoL, fetch status message field done, check item"); |
|
584 if ( statusMsgInfoField ) |
|
585 { |
|
586 DP_SDA(" -> status msg field found"); |
|
587 const MPresenceInfoFieldValueText* statusMsg = |
|
588 TXIMPGetInterface< const MPresenceInfoFieldValueText >::From( |
|
589 statusMsgInfoField->FieldValue(), MXIMPBase::EPanicIfUnknown ); |
|
590 if ( statusMsg && statusMsg->TextValue().Length() ) |
|
591 { |
|
592 DP_SDA(" -> status msg field found, copy content"); |
|
593 aStatusMessage.Copy( statusMsg->TextValue() ); |
|
594 } |
|
595 } |
|
596 else |
|
597 { |
|
598 DP_SDA(" -> status msg field not found, set empty"); |
|
599 aStatusMessage.Copy( KNullDesC() ); |
|
600 } |
|
601 } |
|
602 |
|
603 DP_SDA("CPresencePluginData::CacheEntriesFromPrInfoL out"); |
|
604 } |
|
605 |
|
606 // --------------------------------------------------------------------------- |
|
607 // CPresencePluginData::SingleUserStatusToXIMPL |
|
608 // --------------------------------------------------------------------------- |
|
609 // |
|
610 void CPresencePluginData::SingleUserStatusToXIMPL( |
|
611 MPresenceObjectFactory& aPresenceFactory, |
|
612 MSimpleElement* aBasicElement, |
|
613 MSimpleElement* aActivitiesElement, |
|
614 MSimpleElement* aNoteElement, |
|
615 MPresenceInfoFieldCollection& aCollection ) |
|
616 { |
|
617 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL"); |
|
618 |
|
619 using namespace NPresenceInfo::NFieldType; |
|
620 using namespace NPresencePlugin::NPresenceStates; |
|
621 |
|
622 //Get aBasicElem content |
|
623 HBufC* nodeContent = aBasicElement->ContentUnicodeL(); |
|
624 CleanupStack::PushL( nodeContent ); |
|
625 |
|
626 TBuf<KBufSize100> basicContentBuf; |
|
627 basicContentBuf.Copy( *nodeContent ); |
|
628 DP_SDA2("SingleUserStatusToXIMPL basicContent %S", &basicContentBuf); |
|
629 |
|
630 TBuf<KBufSize100> activitiesContentBuf; |
|
631 |
|
632 if ( !aActivitiesElement ) |
|
633 { |
|
634 activitiesContentBuf.Copy( KPresenceUnknow ); |
|
635 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL activities NULL"); |
|
636 } |
|
637 else |
|
638 { |
|
639 activitiesContentBuf.Copy( aActivitiesElement->LocalName() ); |
|
640 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL else"); |
|
641 } |
|
642 |
|
643 if ( nodeContent ) |
|
644 { |
|
645 using namespace NPresenceInfo::NFieldType; |
|
646 MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC(); |
|
647 field->SetFieldTypeL( KAvailabilityEnum ); |
|
648 |
|
649 // use mapped enums to pass status |
|
650 MPresenceInfoFieldValueEnum* enumField = |
|
651 aPresenceFactory.NewEnumInfoFieldLC(); |
|
652 |
|
653 // Busy case |
|
654 if ( !nodeContent->Des().CompareF( KPresenceOpen ) && |
|
655 !activitiesContentBuf.CompareF ( KPresenceBusy ) ) |
|
656 { |
|
657 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/busy"); |
|
658 enumField->SetValueL( NPresenceInfo::EBusy ); |
|
659 } |
|
660 // On-The-Phone case |
|
661 else if ( !nodeContent->Des().CompareF( KPresenceOpen ) && |
|
662 !activitiesContentBuf.CompareF ( KPresenceOnThePhone ) ) |
|
663 { |
|
664 DP_SDA("CPresencePluginData::SingleUserStatusToXIMPL open/on-the-phone"); |
|
665 enumField->SetValueL( NPresenceInfo::EOnPhone ); |
|
666 } |
|
667 //Away case |
|
668 else if ( !nodeContent->Des().CompareF( KPresenceOpen ) && |
|
669 !activitiesContentBuf.CompareF ( KPresenceAway ) ) |
|
670 { |
|
671 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/away"); |
|
672 enumField->SetValueL( NPresenceInfo::EAway ); |
|
673 } |
|
674 //Dnd case |
|
675 else if ( !nodeContent->Des().CompareF( KPresenceOpen ) && |
|
676 !activitiesContentBuf.CompareF ( KPresenceDoNotDisturb ) ) |
|
677 { |
|
678 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/dnd"); |
|
679 enumField->SetValueL( NPresenceInfo::EDoNotDisturb ); |
|
680 } |
|
681 // Unknown open |
|
682 else if ( !nodeContent->Des().CompareF( KPresenceOpen ) && |
|
683 !activitiesContentBuf.CompareF ( KPresenceUnknow ) ) |
|
684 { |
|
685 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/unknown"); |
|
686 enumField->SetValueL( NPresenceInfo::EAvailable ); |
|
687 } |
|
688 // availale open |
|
689 else if ( !nodeContent->Des().CompareF( KPresenceOpen ) && |
|
690 !activitiesContentBuf.CompareF ( KPresenceAvailable ) ) |
|
691 { |
|
692 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL open/available"); |
|
693 enumField->SetValueL( NPresenceInfo::EAvailable ); |
|
694 } |
|
695 //Unknown closed |
|
696 else if ( !nodeContent->Des().CompareF( KPresenceClosed ) && |
|
697 !activitiesContentBuf.CompareF ( KPresenceUnknow ) ) |
|
698 { |
|
699 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL closed/unknown"); |
|
700 enumField->SetValueL( NPresenceInfo::EOffline ); |
|
701 } |
|
702 //Else set status according to basic status |
|
703 else |
|
704 { |
|
705 if ( !nodeContent->Des().CompareF( KPresenceOpen ) ) |
|
706 { |
|
707 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL else open"); |
|
708 enumField->SetValueL( NPresenceInfo::EAvailable ); |
|
709 } |
|
710 else |
|
711 { |
|
712 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL else closed"); |
|
713 enumField->SetValueL( NPresenceInfo::ENotAvailable ); |
|
714 } |
|
715 } |
|
716 |
|
717 field->SetFieldValue( enumField ); |
|
718 aCollection.AddOrReplaceFieldL( field ); |
|
719 |
|
720 CleanupStack::Pop( 2 ); // >> field, enumField |
|
721 |
|
722 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL check for note"); |
|
723 |
|
724 // Handle note field if found and buddy is "available". |
|
725 if ( aNoteElement && |
|
726 NPresenceInfo::EOffline != enumField->Value() && |
|
727 NPresenceInfo::ENotAvailable != enumField->Value() ) |
|
728 { |
|
729 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL note elems found"); |
|
730 // consider mapping note text to enum value if value not mapped |
|
731 UserNoteToXIMPL( aPresenceFactory, aNoteElement, aCollection ); |
|
732 } |
|
733 } |
|
734 CleanupStack::PopAndDestroy( nodeContent ); |
|
735 DP_SDA(" CPresencePluginData::SingleUserStatusToXIMPL end"); |
|
736 } |
|
737 |
|
738 // --------------------------------------------------------------------------- |
|
739 // CPresencePluginData::UserNoteToXIMPL |
|
740 // --------------------------------------------------------------------------- |
|
741 // |
|
742 void CPresencePluginData::UserNoteToXIMPL( |
|
743 MPresenceObjectFactory& aPresenceFactory, |
|
744 MSimpleElement* aElement, |
|
745 MPresenceInfoFieldCollection& aCollection ) |
|
746 { |
|
747 DP_SDA(" CPresencePluginData::UserNoteToXIMPL IN"); |
|
748 HBufC* nodeContent = aElement->ContentUnicodeL(); |
|
749 CleanupStack::PushL( nodeContent ); |
|
750 if ( nodeContent ) |
|
751 { |
|
752 DP_SDA(" CPresencePluginData::UserNoteToXIMPL - content found"); |
|
753 // Save note, convert from unicode |
|
754 // notice: consider xml::lang-attribute |
|
755 // note <-> KStatusMessage |
|
756 // notice: no need to consider namespaces in XML? |
|
757 using namespace NPresenceInfo::NFieldType; |
|
758 |
|
759 DP_SDA(" CPresencePluginData::UserNoteToXIMPL - create fields"); |
|
760 MPresenceInfoField* field = aPresenceFactory.NewInfoFieldLC(); |
|
761 field->SetFieldTypeL( KStatusMessage ); |
|
762 MPresenceInfoFieldValueText* text = |
|
763 aPresenceFactory.NewTextInfoFieldLC(); |
|
764 text->SetTextValueL( nodeContent->Des() ); |
|
765 field->SetFieldValue( text ); |
|
766 CleanupStack::Pop(); // >> text |
|
767 aCollection.AddOrReplaceFieldL( field ); |
|
768 CleanupStack::Pop(); // >> field |
|
769 DP_SDA(" -> fields added to collection"); |
|
770 } |
|
771 CleanupStack::PopAndDestroy( nodeContent ); |
|
772 DP_SDA(" CPresencePluginData::UserNoteToXIMPL OUT"); |
|
773 } |
|
774 |
|
775 // --------------------------------------------------------------------------- |
|
776 // CPresencePluginData::NotifyListToPrInfoL |
|
777 // --------------------------------------------------------------------------- |
|
778 // |
|
779 void CPresencePluginData::NotifyListToPrInfoL( |
|
780 MXIMPObjectFactory& aFactory, |
|
781 MPresenceObjectFactory& aPresenceFactory, |
|
782 MSimplePresenceList& aList, |
|
783 RPointerArray<MPresenceInfo>& aEntities, |
|
784 RPointerArray<MXIMPIdentity>& aActives, |
|
785 RPointerArray<MXIMPIdentity>& aTerminated ) |
|
786 { |
|
787 DP_SDA(" CPresencePluginData::NotifyListToPrInfoL"); |
|
788 // Split array into individual prInfos |
|
789 |
|
790 aEntities.Reset(); |
|
791 RPointerArray<MSimpleDocument> docs; |
|
792 CleanupClosePushL( docs ); |
|
793 // get documents, ownership is not transferred. |
|
794 aList.GetDocuments( docs ); |
|
795 |
|
796 TInt count = docs.Count(); |
|
797 |
|
798 // active presentities |
|
799 for ( TInt i = 0; i < count; i++ ) |
|
800 { |
|
801 MPresenceInfo* info = |
|
802 aPresenceFactory.NewPresenceInfoLC();//<< info |
|
803 aEntities.Append( info ); |
|
804 // aEntities may contain entries even this method leaves |
|
805 CleanupStack::Pop();// >> info |
|
806 |
|
807 NotifyToPrInfoL( aFactory, aPresenceFactory, *docs[i], *info ); |
|
808 // Add SIp identity to active users list |
|
809 MXIMPIdentity* active = aFactory.NewIdentityLC();// << active |
|
810 aActives.Append( active ); |
|
811 CleanupStack::Pop();// >> active |
|
812 |
|
813 // Convert SIP entity URI from UTF to Unicode. |
|
814 const TDesC8* pUri8 = (docs[i])->EntityURI(); |
|
815 HBufC16* uri16 = NULL; |
|
816 uri16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L( *pUri8 ); |
|
817 CleanupStack::PushL( uri16 ); // << uri16 |
|
818 active->SetIdentityL( uri16->Des() ); |
|
819 CleanupStack::PopAndDestroy( uri16 );// >> uri16 |
|
820 } |
|
821 |
|
822 using namespace NPresencePlugin::NPresence; |
|
823 |
|
824 // Search "terminated" presentities |
|
825 MSimpleMeta* meta = aList.MetaData(); |
|
826 // ownership in not transferred |
|
827 if ( meta && !meta->LocalName().CompareF( KPresenceList8 )) |
|
828 { |
|
829 // list element found |
|
830 RPointerArray<MSimpleElement> elems2; |
|
831 CleanupClosePushL( elems2 ); |
|
832 meta->SimpleElementsL( elems2); |
|
833 TInt count2 = elems2.Count(); |
|
834 |
|
835 for ( TInt i = 0; i < count2; i++ ) |
|
836 { |
|
837 MSimpleElement* elem2 = elems2[i]; |
|
838 if ( !elem2->LocalName().CompareF( KPresenceResource8 )) |
|
839 { |
|
840 // resource element |
|
841 RPointerArray<MSimpleElement> elems3; |
|
842 CleanupClosePushL( elems3 ); |
|
843 meta->SimpleElementsL( elems3 ); |
|
844 TInt count3 = elems3.Count(); |
|
845 |
|
846 for ( TInt j=0; j < count3; j++ ) |
|
847 { |
|
848 MSimpleElement* elem3 = elems3[i]; |
|
849 |
|
850 if ( !elem3->LocalName().CompareF( KPresenceInstance8 )) |
|
851 { |
|
852 // instance element |
|
853 const TDesC8* stateVal = |
|
854 elem3->AttrValue( KPresenceState8 ); |
|
855 if ( stateVal && stateVal-> |
|
856 CompareF( KPresenceTerminated8 )) |
|
857 { |
|
858 // get next entity if this is not state="terminated" |
|
859 break; |
|
860 } |
|
861 // Save resource element URI into list of |
|
862 // "terminated" users. |
|
863 const TDesC8* uri8 = elem2->AttrValue( KPresenceUri8 ); |
|
864 MXIMPIdentity* terminated = |
|
865 aFactory.NewIdentityLC();// << terminated |
|
866 aTerminated.Append( terminated ); |
|
867 CleanupStack::Pop(); // >> terminated |
|
868 |
|
869 // Convert SIP entity URI from UTF to Unicode. |
|
870 HBufC16* uri16 = NULL; |
|
871 uri16 = |
|
872 CnvUtfConverter::ConvertToUnicodeFromUtf8L( *uri8 ); |
|
873 CleanupStack::PushL( uri16 ); // << uri16 |
|
874 terminated->SetIdentityL( uri16->Des() ); |
|
875 CleanupStack::PopAndDestroy( uri16 ); // >> uri16 |
|
876 } |
|
877 } |
|
878 CleanupStack::PopAndDestroy( &elems3 ); |
|
879 } // resource element |
|
880 }// for (i); list element subelement |
|
881 CleanupStack::PopAndDestroy( &elems2 ); |
|
882 } |
|
883 |
|
884 CleanupStack::PopAndDestroy( &docs ); |
|
885 DP_SDA(" CPresencePluginData::NotifyListToPrInfoL end"); |
|
886 } |
|
887 |
|
888 // --------------------------------------------------------------------------- |
|
889 // CPresencePluginData::AddPrPersToSimpleDocumentL |
|
890 // --------------------------------------------------------------------------- |
|
891 // |
|
892 void CPresencePluginData::AddPrPersToSimpleDocumentL( |
|
893 const MPersonPresenceInfo* aInfo, |
|
894 MSimpleDocument& aDocument, |
|
895 const TDesC8& aSipId, TInt aTupleId ) |
|
896 { |
|
897 DP_SDA("CPresencePluginData::AddPrPersToSimpleDocumentL start"); |
|
898 iNumBuf = aTupleId; |
|
899 // notice: later: generate random id. |
|
900 |
|
901 using namespace NPresencePlugin::NPresence; |
|
902 using namespace NPresenceInfo::NFieldType; |
|
903 |
|
904 const MPresenceInfoFieldCollection& coll = aInfo->Fields(); |
|
905 |
|
906 const MPresenceInfoField* statusEmumField = NULL; |
|
907 const MPresenceInfoField* messageField = NULL; |
|
908 |
|
909 TInt myCount = coll.FieldCount(); |
|
910 for ( TInt i = 0; i < myCount; i++ ) |
|
911 { |
|
912 DP_SDA("CPresencePluginData::AddPrPersToSimpleDocumentL 1"); |
|
913 |
|
914 const MPresenceInfoField& field = coll.FieldAt( i ); |
|
915 const TDesC8& fieldType = field.FieldType(); |
|
916 TBuf<KBufSize100> printBuf; |
|
917 printBuf.Copy( fieldType ); |
|
918 |
|
919 if ( !fieldType.Compare( KAvatar ) ) |
|
920 { |
|
921 // Do nothing in sawfis, maybe later? |
|
922 } |
|
923 else if ( !fieldType.Compare( KAvailabilityEnum ) ) |
|
924 { |
|
925 DP_SDA("AddPrPersToSimpleDocumentL Avaibility"); |
|
926 statusEmumField = &field; |
|
927 DP_SDA("AddPrPersToSimpleDocumentL Avaibility done"); |
|
928 } |
|
929 else if ( !fieldType.Compare( KStatusMessage ) ) |
|
930 { |
|
931 DP_SDA("AddPrPersToSimpleDocumentL statusmessage"); |
|
932 messageField = &field; |
|
933 } |
|
934 } |
|
935 if ( statusEmumField ) |
|
936 { |
|
937 DoCreateDocumentL( aDocument, aSipId, |
|
938 statusEmumField, messageField ); |
|
939 } |
|
940 |
|
941 |
|
942 DP_SDA("CPresencePluginData::AddPrPersToSimpleDocumentL end"); |
|
943 } |
|
944 |
|
945 |
|
946 // --------------------------------------------------------------------------- |
|
947 // CPresencePluginData::CreatePresenceUri8LC |
|
948 // --------------------------------------------------------------------------- |
|
949 // |
|
950 HBufC8* CPresencePluginData::CreatePresenceUri8LC( |
|
951 const TDesC8& aPresentityUri ) |
|
952 { |
|
953 DP_SDA("CPresencePluginData::CreatePresenceUri8LC "); |
|
954 const TInt KMyLenSipPrefix = 4; |
|
955 const TInt KMyLenSipsPrefix = 5; |
|
956 _LIT8( KMySip8, "sip:" ); |
|
957 _LIT8( KMySips8, "sips:" ); |
|
958 TInt uriLen = aPresentityUri.Length(); |
|
959 DP_SDA2( "CPresencePluginData::CreatePresenceUri8LC - param length: %d ", uriLen ); |
|
960 |
|
961 //For debugging purposes |
|
962 //TBuf<256> tmpPresentityUri; |
|
963 //tmpPresentityUri.Copy( aPresentityUri ); |
|
964 //DP_SDA2( "CPresencePluginData::CreatePresenceUri8LC - URI: %S ", &tmpPresentityUri ); |
|
965 |
|
966 HBufC8* buf = HBufC8::NewLC( uriLen ); |
|
967 TPtr8 pBuf( buf->Des() ); |
|
968 |
|
969 //SIP uri check |
|
970 if ( !aPresentityUri.Left( KMyLenSipPrefix ).CompareF( KMySip8 ) ) |
|
971 { |
|
972 DP_SDA("CPresencePluginData::CreatePresenceUri8LC (sip:) prefix in SIP URI "); |
|
973 pBuf.Append( aPresentityUri ); |
|
974 } |
|
975 else if ( !aPresentityUri.Left( KMyLenSipsPrefix ).CompareF( KMySips8 ) ) |
|
976 { |
|
977 DP_SDA( "CPresencePluginData::CreatePresenceUri8LC (sips:) prefix in SIP URI " ); |
|
978 pBuf.Append( aPresentityUri ); |
|
979 } |
|
980 else // No prefix, strange ... |
|
981 { |
|
982 DP_SDA( "CPresencePluginData::CreatePresenceUri8LC NO prefix in SIP URI, adding... " ); |
|
983 // Maybe should check which prefix to use, |
|
984 // but assume that no secure is used if prefix missing |
|
985 TInt len = aPresentityUri.Length() + KMyLenSipPrefix; |
|
986 buf = buf->ReAllocL( len ); |
|
987 //update pointer after realloc |
|
988 CleanupStack::Pop( 1 ); |
|
989 CleanupStack::PushL( buf ); |
|
990 // Since realloc may have changed the location in memory |
|
991 // we must also reset ptr |
|
992 pBuf.Set( buf->Des() ); |
|
993 pBuf.Append( KMySip8 ); |
|
994 pBuf.Append( aPresentityUri ); |
|
995 } |
|
996 return buf; |
|
997 } |
|
998 |
|
999 // --------------------------------------------------------------------------- |
|
1000 // CPresencePluginData::RemovePrefixLC |
|
1001 // --------------------------------------------------------------------------- |
|
1002 // |
|
1003 HBufC16* CPresencePluginData::RemovePrefixLC( |
|
1004 const TDesC& aPresentityUri ) |
|
1005 { |
|
1006 DP_SDA2("CPresencePluginData::RemovePrefixLC, uri: %S", &aPresentityUri ); |
|
1007 |
|
1008 HBufC* withouPrefix = HBufC::NewLC( KBufSize255 ); |
|
1009 TPtr withouPrefixPtr( withouPrefix->Des() ); |
|
1010 |
|
1011 TInt prefixLocation = aPresentityUri.Locate( ':' ); |
|
1012 DP_SDA2("CPresencePluginData::RemovePrefixLC, prefix pos: %d", prefixLocation ); |
|
1013 if ( KErrNotFound != prefixLocation ) |
|
1014 { |
|
1015 DP_SDA("CPresencePluginData::RemovePrefixLC - has prefix"); |
|
1016 withouPrefixPtr.Copy( aPresentityUri.Mid( prefixLocation+1 ) ); |
|
1017 DP_SDA("CPresencePluginData::RemovePrefixLC - copy ok"); |
|
1018 } |
|
1019 else |
|
1020 { |
|
1021 DP_SDA("CPresencePluginData::RemovePrefixLC - has no prefix"); |
|
1022 withouPrefixPtr.Copy( aPresentityUri ); |
|
1023 } |
|
1024 |
|
1025 //DP_SDA2("CPresencePluginData::RemovePrefixLC - returns %S", *withouPrefix ); |
|
1026 return withouPrefix; |
|
1027 } |
|
1028 |
|
1029 // --------------------------------------------------------------------------- |
|
1030 // CPresencePluginData::DoCreateDocumentL() |
|
1031 // --------------------------------------------------------------------------- |
|
1032 // |
|
1033 void CPresencePluginData::DoCreateDocumentL( |
|
1034 MSimpleDocument& aDocument, |
|
1035 const TDesC8& aSipId, |
|
1036 const MPresenceInfoField* aStatusField, |
|
1037 const MPresenceInfoField* aMessageField ) |
|
1038 { |
|
1039 DP_SDA("CPresencePluginData::DoCreateDocumentL "); |
|
1040 const TInt KNumBuf = 20; |
|
1041 const TInt KTupleBuf = 10; |
|
1042 |
|
1043 using namespace NPresencePlugin::NPresence; |
|
1044 using namespace NPresencePlugin::NPresenceStates; |
|
1045 using namespace NPresenceInfo::NFieldType; |
|
1046 |
|
1047 TBuf<KNumBuf> numBuf; |
|
1048 TBuf<KTupleBuf> tupleBuf; |
|
1049 |
|
1050 tupleBuf.Copy( KIndent ); |
|
1051 numBuf.Num( iNumBuf ); |
|
1052 tupleBuf.Append( numBuf ); |
|
1053 DP_SDA2("CPresencePluginData::DoCreateDocumentL id %d", iNumBuf); |
|
1054 DP_SDA("CPresencePluginData::DoCreateDocumentL 2"); |
|
1055 |
|
1056 //Add tuple id to document |
|
1057 MSimpleElement* tuple = aDocument.AddSimpleElementL( KPresenceTuple8 ); |
|
1058 CleanupClosePushL( *tuple ); |
|
1059 tuple->AddAttrL( KPresenceId8, tupleBuf); |
|
1060 |
|
1061 //Presence status field |
|
1062 MSimpleElement* status = tuple->AddSimpleElementL( KPresenceStatus8 ); |
|
1063 CleanupClosePushL( *status ); |
|
1064 |
|
1065 //basic field |
|
1066 MSimpleElement* basic = status->AddSimpleElementL( KPresenceBasic8 ); |
|
1067 CleanupClosePushL( *basic ); |
|
1068 |
|
1069 basic->SetContentUnicodeL( DoCheckBasicStatusValueL( *aStatusField ) ); |
|
1070 |
|
1071 DP_SDA("CPresencePluginData::DoCreateDocumentL Basic ok, check msg"); |
|
1072 |
|
1073 if ( aMessageField ) |
|
1074 { |
|
1075 DP_SDA("CPresencePluginData::DoCreateDocumentL message field"); |
|
1076 //Creating note |
|
1077 MSimpleElement* note = |
|
1078 aDocument.AddSimpleElementL( KPresenceNote8 ); |
|
1079 CleanupClosePushL( *note ); |
|
1080 |
|
1081 // Get status msg field from info field |
|
1082 const MPresenceInfoFieldValueText* textField = |
|
1083 TXIMPGetInterface< |
|
1084 const MPresenceInfoFieldValueText >::From( |
|
1085 aMessageField->FieldValue(), |
|
1086 MXIMPBase::EPanicIfUnknown ); |
|
1087 note->SetContentUnicodeL( textField->TextValue() ); |
|
1088 CleanupStack::PopAndDestroy( note ); |
|
1089 } |
|
1090 |
|
1091 /* Basic model example |
|
1092 <tuple id="c8dqui"> |
|
1093 <status> |
|
1094 <basic>open</basic> |
|
1095 </status> |
|
1096 <ts:basic>closed</ts:basic> |
|
1097 </ts:timed-status> |
|
1098 <contact>sip:someone@example.com</contact> |
|
1099 </tuple> |
|
1100 <note>sleeping</note> |
|
1101 </presence> |
|
1102 */ |
|
1103 |
|
1104 DP_SDA("CPresencePluginData::DoCreateDocumentL Rich presence person"); |
|
1105 //Creatin person presence field |
|
1106 MSimpleElement* pers = |
|
1107 aDocument.AddSimpleElementL( KSimpleNsPDM, KPresencePerson8 ); |
|
1108 CleanupClosePushL( *pers ); |
|
1109 TBuf<KBufSize10> buf; |
|
1110 TBuf<KBufSize20> personId; |
|
1111 personId.Copy( KPersonId ); |
|
1112 buf.Num( iNumBuf ); |
|
1113 personId.Append( buf ); |
|
1114 pers->AddAttrL( KPresenceId8, personId ); |
|
1115 DP_SDA("CPresencePluginData::DoCreateDocumentL Rich presence person ok"); |
|
1116 |
|
1117 HBufC8* urlBuf = CreatePresenceUri8LC( aSipId ); |
|
1118 DP_SDA("CPresencePluginData::DoCreateDocumentL Push urlBuf"); |
|
1119 |
|
1120 aDocument.SetEntityURIL( urlBuf->Des() ); |
|
1121 DP_SDA("CPresencePluginData::DoCreateDocumentL 2"); |
|
1122 |
|
1123 DP_SDA("CPresencePluginData::DoCreateDocumentLC Rich presence activities"); |
|
1124 MSimpleElement* activ = pers->AddSimpleElementL( |
|
1125 KSimpleNsRPID, KPresenceActivities8 ); |
|
1126 CleanupClosePushL( *activ ); |
|
1127 |
|
1128 //unknown used if person presence is just open or closed |
|
1129 MSimpleElement* unknown = activ->AddSimpleElementL( |
|
1130 KSimpleNsRPID, DoCheckActivitiesValueL( *aStatusField ) ); |
|
1131 DP_SDA("CPresencePluginData::DoCreateDocumentL, unknown/status element created"); |
|
1132 CleanupClosePushL( *unknown ); |
|
1133 |
|
1134 DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy unknown"); |
|
1135 CleanupStack::PopAndDestroy( unknown ); |
|
1136 DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy activ"); |
|
1137 CleanupStack::PopAndDestroy( activ ); |
|
1138 |
|
1139 DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy urlBuf"); |
|
1140 CleanupStack::PopAndDestroy( urlBuf ); |
|
1141 |
|
1142 DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy pers"); |
|
1143 CleanupStack::PopAndDestroy( pers ); |
|
1144 DP_SDA("CPresencePluginData::DoCreateDocumentL Rich presence activities ok"); |
|
1145 |
|
1146 DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy basic"); |
|
1147 CleanupStack::PopAndDestroy( basic ); |
|
1148 |
|
1149 DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy status"); |
|
1150 CleanupStack::PopAndDestroy( status ); |
|
1151 |
|
1152 DP_SDA("CPresencePluginData::DoCreateDocumentL Destroy tuple"); |
|
1153 CleanupStack::PopAndDestroy( tuple ); |
|
1154 DP_SDA("CPresencePluginData::DoCreateDocumentL end"); |
|
1155 } |
|
1156 |
|
1157 // --------------------------------------------------------------------------- |
|
1158 // CPresencePluginData::DoCheckBasicStatusValueL() |
|
1159 // --------------------------------------------------------------------------- |
|
1160 // |
|
1161 TPtrC CPresencePluginData::DoCheckBasicStatusValueL( |
|
1162 const MPresenceInfoField& aField ) |
|
1163 { |
|
1164 using namespace NPresencePlugin::NPresence; |
|
1165 using namespace NPresencePlugin::NPresenceStates; |
|
1166 using namespace NPresenceInfo::NFieldType; |
|
1167 |
|
1168 TPtrC basicStatus( KPresenceOpen ); //default status open |
|
1169 //First check what is person status value |
|
1170 const MXIMPBase& storage = aField.FieldValue(); |
|
1171 const MPresenceInfoFieldValueEnum* enumObject = |
|
1172 TXIMPGetInterface< const MPresenceInfoFieldValueEnum >:: |
|
1173 From( storage,MXIMPBase::EReturnNullIfUnknown ); |
|
1174 |
|
1175 __ASSERT_ALWAYS( NULL != enumObject, User::Leave( KErrArgument ) ); |
|
1176 |
|
1177 DP_SDA2(" DoCheckBasicStatusValueL - enumValue: %d", enumObject->Value() ); |
|
1178 switch ( enumObject->Value() ) |
|
1179 { |
|
1180 case NPresenceInfo::EAvailable: |
|
1181 { |
|
1182 DP_SDA("DoCheckBasicStatusValueL stopPublish false status open"); |
|
1183 iConnObs.SetStopPublishState( EFalse ); |
|
1184 basicStatus.Set( KPresenceOpen ); |
|
1185 } |
|
1186 break; |
|
1187 |
|
1188 case NPresenceInfo::EOffline: |
|
1189 case NPresenceInfo::EHidden: |
|
1190 case NPresenceInfo::ENotAvailable: |
|
1191 { |
|
1192 //If state is closed we can stop publish |
|
1193 //if client is going to offline |
|
1194 DP_SDA("DoCheckBasicStatusValueL stopPublish true status Closed"); |
|
1195 iConnObs.SetStopPublishState( ETrue ); |
|
1196 basicStatus.Set( KPresenceClosed ); |
|
1197 } |
|
1198 break; |
|
1199 |
|
1200 default: |
|
1201 { |
|
1202 DP_SDA("DoCheckBasicStatusValueL stopPublish false else open"); |
|
1203 iConnObs.SetStopPublishState( EFalse ); |
|
1204 basicStatus.Set( KPresenceOpen ); |
|
1205 } |
|
1206 break; |
|
1207 } |
|
1208 return basicStatus; |
|
1209 } |
|
1210 |
|
1211 // --------------------------------------------------------------------------- |
|
1212 // CPresencePluginData::DoCheckActivitiesValueL() |
|
1213 // --------------------------------------------------------------------------- |
|
1214 // |
|
1215 TPtrC8 CPresencePluginData::DoCheckActivitiesValueL( |
|
1216 const MPresenceInfoField& aField ) |
|
1217 { |
|
1218 using namespace NPresencePlugin::NPresence; |
|
1219 using namespace NPresencePlugin::NPresenceStates; |
|
1220 using namespace NPresenceInfo::NFieldType; |
|
1221 |
|
1222 TPtrC8 activities( KPresenceUnknow8 ); //default activities unknown |
|
1223 |
|
1224 const MXIMPBase& storage = aField.FieldValue(); |
|
1225 const MPresenceInfoFieldValueEnum* enumObject = |
|
1226 TXIMPGetInterface< const MPresenceInfoFieldValueEnum >:: |
|
1227 From( storage,MXIMPBase::EReturnNullIfUnknown ); |
|
1228 |
|
1229 __ASSERT_ALWAYS( NULL != enumObject, User::Leave( KErrArgument ) ); |
|
1230 |
|
1231 DP_SDA2(" DoCheckActivitiesValueL - enumValue: %d", enumObject->Value() ); |
|
1232 switch ( enumObject->Value() ) |
|
1233 { |
|
1234 case NPresenceInfo::EAvailable: |
|
1235 { |
|
1236 DP_SDA("DoCheckActivitiesValueL - available, set publish"); |
|
1237 iConnObs.SetStopPublishState( EFalse ); |
|
1238 DP_SDA("DoCheckActivitiesValueL - available, set value"); |
|
1239 activities.Set( KPresenceUnknow8 ); |
|
1240 DP_SDA("DoCheckActivitiesValueL - available, ok"); |
|
1241 } |
|
1242 break; |
|
1243 |
|
1244 case NPresenceInfo::EOffline: |
|
1245 case NPresenceInfo::ENotAvailable: |
|
1246 { |
|
1247 DP_SDA("DoCheckActivitiesValueL - offline/not available"); |
|
1248 iConnObs.SetStopPublishState( ETrue ); |
|
1249 activities.Set( KPresenceUnknow8 ); |
|
1250 } |
|
1251 break; |
|
1252 |
|
1253 case NPresenceInfo::EBusy: |
|
1254 { |
|
1255 DP_SDA("DoCheckActivitiesValueL - busy"); |
|
1256 iConnObs.SetStopPublishState( EFalse ); |
|
1257 activities.Set( KPresenceBusy8 ); |
|
1258 } |
|
1259 break; |
|
1260 |
|
1261 case NPresenceInfo::EExtAway: |
|
1262 case NPresenceInfo::EAway: |
|
1263 { |
|
1264 DP_SDA("DoCheckActivitiesValueL - away"); |
|
1265 iConnObs.SetStopPublishState( EFalse ); |
|
1266 activities.Set( KPresenceAway8 ); |
|
1267 } |
|
1268 break; |
|
1269 |
|
1270 case NPresenceInfo::EOnPhone: |
|
1271 { |
|
1272 DP_SDA("DoCheckActivitiesValueL - on phone"); |
|
1273 iConnObs.SetStopPublishState( EFalse ); |
|
1274 activities.Set( KPresenceOnThePhone8 ); |
|
1275 } |
|
1276 break; |
|
1277 |
|
1278 |
|
1279 case NPresenceInfo::EDoNotDisturb: |
|
1280 { |
|
1281 DP_SDA("DoCheckActivitiesValueL - dnd"); |
|
1282 iConnObs.SetStopPublishState( EFalse ); |
|
1283 activities.Set( KPresenceDoNotDisturb8 ); |
|
1284 } |
|
1285 break; |
|
1286 |
|
1287 default: |
|
1288 { |
|
1289 DP_SDA("DoCheckActivitiesValueL default => unknown"); |
|
1290 iConnObs.SetStopPublishState( EFalse ); |
|
1291 activities.Set( KPresenceUnknow8 ); |
|
1292 } |
|
1293 break; |
|
1294 } |
|
1295 DP_SDA("DoCheckActivitiesValueL - done and return"); |
|
1296 return activities; |
|
1297 } |
|
1298 |
|
1299 // --------------------------------------------------------------------------- |
|
1300 // CPresencePluginData::DoCheckNoteValueL() |
|
1301 // --------------------------------------------------------------------------- |
|
1302 // |
|
1303 TPtrC CPresencePluginData::DoCheckNoteValueL( |
|
1304 const MPresenceInfoField& aField ) |
|
1305 { |
|
1306 using namespace NPresencePlugin::NPresence; |
|
1307 using namespace NPresencePlugin::NPresenceStates; |
|
1308 using namespace NPresenceInfo::NFieldType; |
|
1309 |
|
1310 TPtrC note( KPresenceUnknow ); //default activities unknown |
|
1311 //First check what is person status value |
|
1312 const MXIMPBase& storage = aField.FieldValue(); |
|
1313 const MPresenceInfoFieldValueText* text = |
|
1314 TXIMPGetInterface< const MPresenceInfoFieldValueText >:: |
|
1315 From( storage,MXIMPBase::EReturnNullIfUnknown ); |
|
1316 |
|
1317 __ASSERT_ALWAYS( NULL != text, User::Leave( KErrArgument ) ); |
|
1318 |
|
1319 TBuf<KBufSize200> buffer; |
|
1320 buffer.Copy( text->TextValue() ); |
|
1321 |
|
1322 //Check if status is closed |
|
1323 if( !buffer.CompareF( KPresenceClosed ) ) |
|
1324 { |
|
1325 //If state is closed we can stop publish |
|
1326 //if client is going to offline |
|
1327 DP_SDA("DoCheckNoteValueL stopPublish true closed"); |
|
1328 iConnObs.SetStopPublishState( ETrue ); |
|
1329 note.Set( KPresenceOffline ); |
|
1330 } |
|
1331 else if( !buffer.CompareF( KPresenceOpen ) ) |
|
1332 { |
|
1333 DP_SDA("DoCheckNoteValueL stopPublish false open"); |
|
1334 iConnObs.SetStopPublishState( EFalse ); |
|
1335 note.Set( KPresenceAvailable ); |
|
1336 } |
|
1337 else if( !buffer.CompareF( KPresenceBusy ) ) |
|
1338 { |
|
1339 DP_SDA("DoCheckNoteValueL activities BUSY"); |
|
1340 iConnObs.SetStopPublishState( EFalse ); |
|
1341 note.Set( KPresenceBusy ); |
|
1342 } |
|
1343 else if( !buffer.CompareF( KPresenceOnThePhone ) ) |
|
1344 { |
|
1345 DP_SDA("DoCheckNoteValueL activities OnThePhone"); |
|
1346 iConnObs.SetStopPublishState( EFalse ); |
|
1347 note.Set( KPresenceOnThePhone ); |
|
1348 } |
|
1349 else if( !buffer.CompareF( KPresenceAway ) ) |
|
1350 { |
|
1351 DP_SDA("DoCheckNoteValueL activities OnThePhone"); |
|
1352 iConnObs.SetStopPublishState( EFalse ); |
|
1353 note.Set( KPresenceAway ); |
|
1354 } |
|
1355 else |
|
1356 { |
|
1357 DP_SDA("DoCheckNoteValueL stopPublish false"); |
|
1358 iConnObs.SetStopPublishState( EFalse ); |
|
1359 note.Set( KPresenceUnknow ); |
|
1360 } |
|
1361 return note; |
|
1362 } |
|
1363 |
|
1364 |
|
1365 // --------------------------------------------------------------------------- |
|
1366 // CPresencePluginData::GenerateTupleId() |
|
1367 // --------------------------------------------------------------------------- |
|
1368 // |
|
1369 TInt CPresencePluginData::GenerateTupleId() |
|
1370 { |
|
1371 // Generate unique session tuple id |
|
1372 DP_SDA("CPresencePluginData::GenerateTupleId start"); |
|
1373 const TInt KMaxRand = KMaxNumber; |
|
1374 TInt64 seed; |
|
1375 TTime time; |
|
1376 time.HomeTime(); |
|
1377 seed = time.Int64(); |
|
1378 TInt random = Math::Rand( seed ) % KMaxRand; |
|
1379 DP_SDA("CPresencePluginData::GenerateTupleId 1"); |
|
1380 return random; |
|
1381 } |
|
1382 |
|
1383 // --------------------------------------------------------------------------- |
|
1384 // CPresencePluginData::ServiceId() |
|
1385 // --------------------------------------------------------------------------- |
|
1386 // |
|
1387 TInt CPresencePluginData::ServiceId() |
|
1388 { |
|
1389 return iServiceId; |
|
1390 } |
|
1391 |
|
1392 // --------------------------------------------------------------------------- |
|
1393 // CPresencePluginData::ServiceNameLC() |
|
1394 // --------------------------------------------------------------------------- |
|
1395 // |
|
1396 HBufC* CPresencePluginData::ServiceNameLC( TInt aServiceId ) const |
|
1397 { |
|
1398 CSPSettings* spSettings = CSPSettings::NewLC(); |
|
1399 CSPEntry* entry = CSPEntry::NewLC(); |
|
1400 HBufC* serviceName = NULL; |
|
1401 |
|
1402 User::LeaveIfError( spSettings->FindEntryL( aServiceId, *entry ) ); |
|
1403 |
|
1404 serviceName = entry->GetServiceName().AllocL(); |
|
1405 |
|
1406 CleanupStack::PopAndDestroy( entry ); |
|
1407 CleanupStack::PopAndDestroy( spSettings ); |
|
1408 CleanupStack::PushL( serviceName ); |
|
1409 return serviceName; |
|
1410 } |
|
1411 |
|
1412 // --------------------------------------------------------------------------- |
|
1413 // CPresencePluginData::ResolveCacheXspIdentifierL() |
|
1414 // --------------------------------------------------------------------------- |
|
1415 // |
|
1416 HBufC* CPresencePluginData::ResolveCacheXspIdentifierL( |
|
1417 const TDesC& aIdentity ) const |
|
1418 { |
|
1419 DP_SDA( "CPresencePluginData::ResolveCacheXspIdentifierL" ); |
|
1420 |
|
1421 CSPSettings* spSettings = CSPSettings::NewLC(); |
|
1422 CSPEntry* entry = CSPEntry::NewLC(); |
|
1423 |
|
1424 User::LeaveIfError( spSettings->FindEntryL( iServiceId, *entry ) ); |
|
1425 |
|
1426 TInt cacheUriLength = ( entry->GetServiceName().Length() + |
|
1427 aIdentity.Length() + 1 ); |
|
1428 |
|
1429 HBufC* cacheUri = HBufC::NewL( cacheUriLength ); |
|
1430 TPtr cacheUriPtr( cacheUri->Des() ); |
|
1431 |
|
1432 cacheUriPtr.Append( entry->GetServiceName() ); |
|
1433 cacheUriPtr.Append( ':' ); |
|
1434 cacheUriPtr.Append( aIdentity ); |
|
1435 |
|
1436 CleanupStack::PopAndDestroy( entry ); |
|
1437 CleanupStack::PopAndDestroy( spSettings ); |
|
1438 |
|
1439 DP_SDA2( "CPresencePluginData::ResolveCacheXspIdentifierL returns: %S", cacheUri ); |
|
1440 return cacheUri; |
|
1441 } |
|
1442 |
|
1443 // --------------------------------------------------------------------------- |
|
1444 // CPresencePluginData::WriteBlockItemsToCacheL() |
|
1445 // --------------------------------------------------------------------------- |
|
1446 // |
|
1447 void CPresencePluginData::WriteStatusToCacheL( |
|
1448 const TDesC& aPresentityId, |
|
1449 MPresenceBuddyInfo2::TAvailabilityValues aAvailability, |
|
1450 const TDesC& aAvailabilityText, |
|
1451 const TDesC& aStatusMessage ) |
|
1452 { |
|
1453 DP_SDA( "CPresencePluginData::WriteStatusToCacheL start" ); |
|
1454 DP_SDA2( "CPresencePluginData::WriteStatusToCacheL, aStatus: %d", |
|
1455 aAvailability ); |
|
1456 DP_SDA2( "CPresencePluginData::WriteStatusToCacheL, availabilityText: %S", |
|
1457 &aAvailabilityText ); |
|
1458 DP_SDA2( "CPresencePluginData::WriteStatusToCacheL, statusMessage: %S", |
|
1459 &aStatusMessage ); |
|
1460 |
|
1461 TBool updateCache( ETrue ); |
|
1462 |
|
1463 HBufC* cacheUri = ResolveCacheXspIdentifierL( aPresentityId ); |
|
1464 CleanupStack::PushL( cacheUri ); |
|
1465 |
|
1466 DP_SDA(" -> WriteStatusToCacheL - read previous values from cache"); |
|
1467 |
|
1468 // Read previous values from cache |
|
1469 MPresenceBuddyInfo2* previousPresInfo = |
|
1470 iPresenceCacheReader->PresenceInfoLC( *cacheUri ); |
|
1471 |
|
1472 if ( previousPresInfo ) |
|
1473 { |
|
1474 DP_SDA(" -> WriteStatusToCacheL - get availability value"); |
|
1475 |
|
1476 MPresenceBuddyInfo2::TAvailabilityValues availability = |
|
1477 previousPresInfo->Availability(); |
|
1478 |
|
1479 DP_SDA(" -> WriteStatusToCacheL - get availability text"); |
|
1480 |
|
1481 TPtrC availabilityText = previousPresInfo->AvailabilityText(); |
|
1482 |
|
1483 DP_SDA(" -> WriteStatusToCacheL - get status message"); |
|
1484 |
|
1485 TPtrC statusMessage = previousPresInfo->StatusMessage(); |
|
1486 CleanupStack::PopAndDestroy(); //previousPresInfo |
|
1487 |
|
1488 DP_SDA2( "CPresencePluginData::WriteStatusToCacheL, OLD STATUS: %d", |
|
1489 availability ); |
|
1490 DP_SDA2( "CPresencePluginData::WriteStatusToCacheL, OLD AVAILABILITY TEXT: %S", |
|
1491 &availabilityText ); |
|
1492 DP_SDA2( "CPresencePluginData::WriteStatusToCacheL, OLD STATUS MESSAGE: %S", |
|
1493 &statusMessage ); |
|
1494 |
|
1495 if ( ( aAvailability == availability ) && |
|
1496 ( aAvailabilityText.Compare( availabilityText ) == 0 ) && |
|
1497 ( aStatusMessage.Compare( statusMessage ) == 0 )) |
|
1498 { |
|
1499 DP_SDA(" -> WriteStatusToCacheL - no need to update cache"); |
|
1500 updateCache = EFalse; |
|
1501 } |
|
1502 } |
|
1503 |
|
1504 if ( updateCache ) |
|
1505 { |
|
1506 MPresenceBuddyInfo2* newPresInfo = MPresenceBuddyInfo2::NewLC(); |
|
1507 newPresInfo->SetIdentityL( *cacheUri ); |
|
1508 |
|
1509 DP_SDA(" -> WriteStatusToCacheL - update cache"); |
|
1510 |
|
1511 TBuf<KBufSize20> buf; |
|
1512 TBool handled = EFalse; |
|
1513 |
|
1514 buf.Copy( KBlockedExtensionValue ); |
|
1515 |
|
1516 if( aAvailabilityText.Compare( buf ) == 0 ) |
|
1517 { |
|
1518 DP_SDA( " -> WriteStatusToCacheL - set Blocked" ); |
|
1519 newPresInfo->SetAnyFieldL( KExtensionKey, KBlockedExtensionValue ); |
|
1520 handled = ETrue; |
|
1521 } |
|
1522 |
|
1523 buf.Copy( KPendingRequestExtensionValue ); |
|
1524 |
|
1525 if ( aAvailabilityText.Compare( buf ) == 0 ) |
|
1526 { |
|
1527 DP_SDA( " -> WriteStatusToCacheL - set Pending request" ); |
|
1528 newPresInfo->SetAnyFieldL( KExtensionKey, KPendingRequestExtensionValue ); |
|
1529 handled = ETrue; |
|
1530 } |
|
1531 |
|
1532 if ( !handled ) |
|
1533 { |
|
1534 DP_SDA2( " -> WriteStatusToCacheL - set availability text: %S", &aAvailabilityText ); |
|
1535 newPresInfo->SetAvailabilityL( aAvailability, aAvailabilityText ); |
|
1536 } |
|
1537 |
|
1538 if ( aStatusMessage.Length() ) |
|
1539 { |
|
1540 DP_SDA2( " -> WriteStatusToCacheL - set status message: %S", &aStatusMessage ); |
|
1541 newPresInfo->SetStatusMessageL( aStatusMessage ); |
|
1542 } |
|
1543 |
|
1544 DP_SDA( " -> WriteStatusToCacheL - write presence to cache" ); |
|
1545 TInt cacheError = iPresenceCacheWriter->WritePresenceL( newPresInfo ); |
|
1546 DP_SDA2( "CPresencePluginEntityWatcher::WriteStatusToCacheL error: %d", |
|
1547 cacheError ); |
|
1548 |
|
1549 DP_SDA( " -> destroy buddy info" ); |
|
1550 CleanupStack::PopAndDestroy(); // newPresInfo |
|
1551 } |
|
1552 |
|
1553 DP_SDA(" -> destroy uri"); |
|
1554 CleanupStack::PopAndDestroy( cacheUri ); |
|
1555 |
|
1556 DP_SDA("CPresencePluginData::WriteStatusToCacheL end"); |
|
1557 } |
|
1558 |
|
1559 // --------------------------------------------------------------------------- |
|
1560 // CPresencePluginData::RemoveCacheL() |
|
1561 // --------------------------------------------------------------------------- |
|
1562 // |
|
1563 void CPresencePluginData::RemoveCacheL() |
|
1564 { |
|
1565 DP_SDA("CPresencePluginData::RemoveCacheL"); |
|
1566 |
|
1567 // Resolve service name (cache xsp identifier) |
|
1568 CSPSettings* spSettings = CSPSettings::NewL(); |
|
1569 CleanupStack::PushL( spSettings ); |
|
1570 |
|
1571 CSPEntry* entry = CSPEntry::NewLC(); |
|
1572 DP_SDA2(" -> RemoveCacheL look for service: %d", ServiceId() ); |
|
1573 spSettings->FindEntryL( ServiceId(), *entry ); |
|
1574 |
|
1575 DP_SDA(" -> RemoveCacheL cache xsp identifier found"); |
|
1576 TInt cacheUriLength = entry->GetServiceName().Length(); |
|
1577 DP_SDA2(" -> cache uri length: %d", cacheUriLength ); |
|
1578 |
|
1579 HBufC* cacheUri = HBufC::NewLC( cacheUriLength ); |
|
1580 TPtr cacheUriPtr( cacheUri->Des() ); |
|
1581 |
|
1582 DP_SDA(" -> RemoveCacheL - form cache entry"); |
|
1583 cacheUriPtr.Append( entry->GetServiceName() ); |
|
1584 |
|
1585 DP_SDA(" -> RemoveCacheL - delete cache entries"); |
|
1586 TInt error = iPresenceCacheWriter->DeleteService( cacheUriPtr ); |
|
1587 DP_SDA2(" -> RemoveCacheL - delete error: %d", error ); |
|
1588 CleanupStack::PopAndDestroy( cacheUri ); |
|
1589 |
|
1590 DP_SDA(" -> destroy sp entry"); |
|
1591 CleanupStack::PopAndDestroy( entry ); |
|
1592 DP_SDA(" -> destroy sp"); |
|
1593 CleanupStack::PopAndDestroy( spSettings ); |
|
1594 DP_SDA("CPresencePluginData::RemoveCacheL out"); |
|
1595 } |
|
1596 |
|
1597 // --------------------------------------------------------------------------- |
|
1598 // CPresencePluginData::DeletePresenceL() |
|
1599 // --------------------------------------------------------------------------- |
|
1600 // |
|
1601 void CPresencePluginData::DeletePresenceL( const TDesC& aIdentity ) |
|
1602 { |
|
1603 DP_SDA("CPresencePluginData::DeletePresenceL"); |
|
1604 |
|
1605 // Resolve service name (cache xsp identifier) |
|
1606 CSPSettings* spSettings = CSPSettings::NewL(); |
|
1607 CleanupStack::PushL( spSettings ); |
|
1608 CSPEntry* entry = CSPEntry::NewLC(); |
|
1609 DP_SDA2(" -> DeletePresenceL look for service: %d", ServiceId() ); |
|
1610 spSettings->FindEntryL( ServiceId(), *entry ); |
|
1611 |
|
1612 DP_SDA(" -> DeletePresenceL cache xsp identifier found"); |
|
1613 TInt cacheUriLength = ( entry->GetServiceName().Length() + |
|
1614 aIdentity.Length() + 1 ); |
|
1615 DP_SDA2(" -> cache uri length: %d", cacheUriLength ); |
|
1616 |
|
1617 HBufC* cacheUri = HBufC::NewLC( cacheUriLength ); |
|
1618 TPtr cacheUriPtr( cacheUri->Des() ); |
|
1619 |
|
1620 DP_SDA(" -> DeletePresenceL - form cache entry"); |
|
1621 cacheUriPtr.Append( entry->GetServiceName() ); |
|
1622 cacheUriPtr.Append( ':' ); |
|
1623 cacheUriPtr.Append( aIdentity ); |
|
1624 |
|
1625 iPresenceCacheWriter->DeletePresenceL( cacheUriPtr ); |
|
1626 |
|
1627 CleanupStack::PopAndDestroy( cacheUri ); |
|
1628 CleanupStack::PopAndDestroy( entry ); |
|
1629 DP_SDA(" -> destroy sp"); |
|
1630 CleanupStack::PopAndDestroy( spSettings ); |
|
1631 DP_SDA("CPresencePluginData::DeletePresenceL out"); |
|
1632 } |
|
1633 |
|
1634 |
|
1635 // --------------------------------------------------------------------------- |
|
1636 // CPresencePluginData::StorePresenceOwnPresenceL() |
|
1637 // --------------------------------------------------------------------------- |
|
1638 // |
|
1639 void CPresencePluginData::StorePresenceOwnPresenceL( |
|
1640 const TUint aServiceId, |
|
1641 NPresenceInfo::TAvailabilityValues aAvailability, |
|
1642 const TDesC& aStatusMessage ) |
|
1643 { |
|
1644 DP_SDA("CPresencePluginData::StorePresenceOwnPresenceL IN"); |
|
1645 DP_SDA2(" -> aServiceId: %d", aServiceId ); |
|
1646 |
|
1647 DP_SDA2(" -> SAVE AVAILABILITY VALUE: %d", aAvailability ); |
|
1648 DP_SDA2(" -> SAVE STATUS MESSAGE: %S", &aStatusMessage ); |
|
1649 |
|
1650 MVIMPSTSettingsStore* settings = CVIMPSTSettingsStore::NewLC(); |
|
1651 |
|
1652 DP_SDA("CPresencePluginData::StorePresenceOwnPresenceL 1"); |
|
1653 |
|
1654 // Store availability value to uiservicetabsettings |
|
1655 TInt availabilityInt = ( ( TInt ) aAvailability ); |
|
1656 User::LeaveIfError( settings->SetL( |
|
1657 aServiceId, EServicePresenceAvailablilityValue, availabilityInt ) ); |
|
1658 |
|
1659 DP_SDA("CPresencePluginData::StorePresenceOwnPresenceL 2"); |
|
1660 |
|
1661 // Store custom status message to uiservicetabsettings |
|
1662 User::LeaveIfError( settings->SetL( |
|
1663 aServiceId, EServiceCustomStatusMessage, aStatusMessage ) ); |
|
1664 |
|
1665 CleanupStack::PopAndDestroy(); //settings |
|
1666 |
|
1667 DP_SDA("CPresencePluginData::StorePresenceOwnPresenceL OUT"); |
|
1668 } |
|
1669 |
|
1670 // --------------------------------------------------------------------------- |
|
1671 // CPresencePluginData::ReadDocumentIdL() |
|
1672 // --------------------------------------------------------------------------- |
|
1673 // |
|
1674 void CPresencePluginData::ReadDocumentIdL( |
|
1675 const TInt aServiceId, |
|
1676 TDes8& aDocumentId ) |
|
1677 { |
|
1678 DP_SDA("CPresencePluginData::ReadDocumentIdL IN"); |
|
1679 |
|
1680 DP_SDA2(" -> aServiceId: %d", aServiceId ); |
|
1681 |
|
1682 MVIMPSTSettingsStore* settings = CVIMPSTSettingsStore::NewLC(); |
|
1683 |
|
1684 RBuf8 documentId; |
|
1685 CleanupClosePushL( documentId ); |
|
1686 documentId.CreateL( KBufSize255 ); |
|
1687 |
|
1688 TInt error = settings->GetL( |
|
1689 aServiceId, EServicePresenceSessionIdentifier, documentId ); |
|
1690 |
|
1691 DP_SDA2(" -> ERROR: %d", error ); |
|
1692 DP_SDA2(" -> DOCUMENT ID LENGTH: %d", documentId.Length() ); |
|
1693 |
|
1694 if ( !error && documentId.Length() ) |
|
1695 { |
|
1696 aDocumentId.Copy( documentId ); |
|
1697 |
|
1698 TBuf<KBufSize255> printDocumentId; |
|
1699 printDocumentId.Copy( aDocumentId ); |
|
1700 DP_SDA("CPresencePluginData::ReadDocumentIdL - 1"); |
|
1701 DP_SDA2(" -> READ DOCUMENT ID: %S", &printDocumentId ); |
|
1702 } |
|
1703 else if ( KErrNotFound == error || !documentId.Length() ) |
|
1704 { |
|
1705 DP_SDA("CPresencePluginData::ReadDocumentIdL - 2"); |
|
1706 // If document id lenght is zero (KNullDesC8) or error |
|
1707 // is KErrNotFound leave with KErrNotFound |
|
1708 User::Leave( KErrNotFound ); |
|
1709 } |
|
1710 else |
|
1711 { |
|
1712 User::Leave( error ); |
|
1713 } |
|
1714 |
|
1715 CleanupStack::PopAndDestroy( &documentId ); |
|
1716 CleanupStack::PopAndDestroy(); //settings |
|
1717 |
|
1718 DP_SDA("CPresencePluginData::ReadDocumentIdL OUT"); |
|
1719 } |
|
1720 |
|
1721 // --------------------------------------------------------------------------- |
|
1722 // CPresencePluginData::DeletePresenceVariablesL() |
|
1723 // --------------------------------------------------------------------------- |
|
1724 // |
|
1725 void CPresencePluginData::DeletePresenceVariablesL( const TInt aServiceId ) |
|
1726 { |
|
1727 DP_SDA("CPresencePluginData::DeletePresenceVariablesL IN"); |
|
1728 DP_SDA2(" -> aServiceId: %d", aServiceId ); |
|
1729 |
|
1730 MVIMPSTSettingsStore* settings = CVIMPSTSettingsStore::NewLC(); |
|
1731 |
|
1732 // Reset availability value in uiservicetabsettings |
|
1733 User::LeaveIfError( settings->SetL( |
|
1734 aServiceId, EServicePresenceAvailablilityValue, KErrNotFound ) ); |
|
1735 |
|
1736 // Reset status message in uiservicetabsettings |
|
1737 User::LeaveIfError( settings->SetL( |
|
1738 aServiceId, EServiceCustomStatusMessage, KNullDesC ) ); |
|
1739 |
|
1740 // Reset document id value in uiservicetabsettings |
|
1741 User::LeaveIfError( settings->SetL( |
|
1742 aServiceId, EServicePresenceSessionIdentifier, KNullDesC8 ) ); |
|
1743 |
|
1744 CleanupStack::PopAndDestroy(); // settings |
|
1745 |
|
1746 DP_SDA("CPresencePluginData::DeletePresenceVariablesL OUT"); |
|
1747 } |
|
1748 |
|
1749 |
|
1750 // --------------------------------------------------------------------------- |
|
1751 // CPresencePluginData::ResolveNoteElementL |
|
1752 // Returns <note> element corresponding current locale or first <note> |
|
1753 // element if better match is not found. |
|
1754 // --------------------------------------------------------------------------- |
|
1755 // |
|
1756 MSimpleElement* CPresencePluginData::ResolveNoteElementL( |
|
1757 const RPointerArray<MSimpleElement>& aElements ) const |
|
1758 { |
|
1759 DP_SDA("CPresencePluginData::ResolveNoteElementL" ) |
|
1760 |
|
1761 MSimpleElement* bestMatch = NULL; |
|
1762 MSimpleElement* secondBestMatch = NULL; |
|
1763 |
|
1764 for ( TInt i = aElements.Count() - 1; i >= 0 && NULL == bestMatch; i-- ) |
|
1765 { |
|
1766 MSimpleElement* element = aElements[i]; |
|
1767 |
|
1768 using namespace NPresencePlugin::NPresence; |
|
1769 if ( 0 == element->LocalName().CompareF( KPresenceNote8 ) ) |
|
1770 { |
|
1771 if ( IsElementLanguageValidForCurrentLocaleL( *element ) ) |
|
1772 { |
|
1773 DP_SDA("CPresencePluginData::ResolveNoteElementL, BEST MATCH.") |
|
1774 bestMatch = element; |
|
1775 } |
|
1776 else |
|
1777 { |
|
1778 secondBestMatch = element; |
|
1779 } |
|
1780 } |
|
1781 } |
|
1782 |
|
1783 return ( bestMatch ? bestMatch : secondBestMatch ); |
|
1784 } |
|
1785 |
|
1786 |
|
1787 // --------------------------------------------------------------------------- |
|
1788 // CPresencePluginData::IsElementLanguageValidForCurrentLocaleL |
|
1789 // --------------------------------------------------------------------------- |
|
1790 // |
|
1791 TBool CPresencePluginData::IsElementLanguageValidForCurrentLocaleL( |
|
1792 MSimpleElement& aElement ) const |
|
1793 { |
|
1794 DP_SDA( "CPresencePluginData::IsElementLanguageValidForCurrentLocaleL" ) |
|
1795 |
|
1796 TBool isLanguageResolved = EFalse; |
|
1797 _LIT8( KLanguageAttribute, "xml:lang" ); |
|
1798 |
|
1799 TLanguage language = User::Language(); |
|
1800 RPointerArray<MSimpleAttribute> attributes; |
|
1801 CleanupClosePushL( attributes ); |
|
1802 aElement.SimpleAttributesL( attributes ); |
|
1803 for ( TInt i = attributes.Count() - 1; i >= 0 && !isLanguageResolved; i-- ) |
|
1804 { |
|
1805 if ( 0 == KLanguageAttribute().CompareF( attributes[i]->Name() ) ) |
|
1806 { |
|
1807 const TDesC8& attributeValue = attributes[i]->Value(); |
|
1808 for ( TInt index = 0; index < KLanguageCodeMappingsCount; index++ ) |
|
1809 { |
|
1810 if ( language == KLanguageCodeMappings[index].SymbianLanguageCode() && |
|
1811 0 == attributeValue.CompareF( |
|
1812 KLanguageCodeMappings[index].IsoLanguageCode() ) ) |
|
1813 { |
|
1814 isLanguageResolved = ETrue; |
|
1815 } |
|
1816 } |
|
1817 } |
|
1818 } |
|
1819 CleanupStack::Pop( &attributes ); |
|
1820 |
|
1821 return isLanguageResolved; |
|
1822 } |
|
1823 |
|
1824 // End of file |