|
1 /* |
|
2 * Copyright (c) 2006 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: RLS and Presence XDM, This is primary class for Presence XDM |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 // Includes |
|
22 #include <XdmProtocolInfo.h> |
|
23 #include <XdmEngine.h> |
|
24 #include <XdmDocument.h> |
|
25 #include <XdmDocumentNode.h> |
|
26 #include <XdmNodeAttribute.h> |
|
27 #include <e32math.h> |
|
28 #include <xcapappusagedef.h> |
|
29 |
|
30 #include "cpresencexdm.h" |
|
31 #include "mrlspresxdmasynchandler.h" |
|
32 #include "rlspresxdmlogger.h" |
|
33 #include "rlspresxdmconstsint.h" |
|
34 |
|
35 // --------------------------------------------------------------------------- |
|
36 // CPresenceXDM::NewL() |
|
37 // --------------------------------------------------------------------------- |
|
38 // |
|
39 EXPORT_C CPresenceXDM* CPresenceXDM::NewL( const TInt aSettingId ) |
|
40 { |
|
41 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::NewL" ) ); |
|
42 CPresenceXDM* self = CPresenceXDM::NewLC(aSettingId); |
|
43 CleanupStack::Pop(self); |
|
44 return self; |
|
45 } |
|
46 |
|
47 // --------------------------------------------------------------------------- |
|
48 // CPresenceXDM::NewLC() |
|
49 // --------------------------------------------------------------------------- |
|
50 // |
|
51 EXPORT_C CPresenceXDM* CPresenceXDM::NewLC( const TInt aSettingId ) |
|
52 { |
|
53 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::NewLC" ) ); |
|
54 CPresenceXDM* self = new (ELeave) CPresenceXDM(); |
|
55 CleanupStack::PushL( self ); |
|
56 self->ConstructL( aSettingId ); |
|
57 return self; |
|
58 } |
|
59 |
|
60 // --------------------------------------------------------------------------- |
|
61 // CPresenceXDM::ConstructL() |
|
62 // --------------------------------------------------------------------------- |
|
63 // |
|
64 void CPresenceXDM::ConstructL(const TInt aSettingId ) |
|
65 { |
|
66 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::ConstructL" ) ); |
|
67 iXDMProtocolInfo = CXdmProtocolInfo::NewL(aSettingId); |
|
68 iXDMEngine = CXdmEngine::NewL( *iXDMProtocolInfo); |
|
69 iPresDocument = iXDMEngine->CreateDocumentModelL(KPresDocumentName, |
|
70 EXdmOmaPresenceRules); |
|
71 |
|
72 // put this to some other function |
|
73 CreateRootIfNeededL(); |
|
74 |
|
75 CActiveScheduler::Add( this ); |
|
76 } |
|
77 |
|
78 // --------------------------------------------------------------------------- |
|
79 // CPresenceXDM::CPresenceXDM() |
|
80 // --------------------------------------------------------------------------- |
|
81 // |
|
82 CPresenceXDM::CPresenceXDM() : CActive( EPriorityStandard ), |
|
83 iAsyncReq(EPresXDMNoRequestMade) |
|
84 { |
|
85 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::CPresenceXDM" ) ); |
|
86 } |
|
87 |
|
88 // --------------------------------------------------------------------------- |
|
89 // CPresenceXDM::~CPresenceXDM() |
|
90 // --------------------------------------------------------------------------- |
|
91 // |
|
92 CPresenceXDM::~CPresenceXDM() |
|
93 { |
|
94 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::~CPresenceXDM" ) ); |
|
95 if(IsActive()) |
|
96 Cancel(); |
|
97 delete iPresDocument; |
|
98 delete iXDMEngine; |
|
99 delete iXDMProtocolInfo; |
|
100 iPresDocument = NULL; |
|
101 } |
|
102 |
|
103 |
|
104 // --------------------------------------------------------------------------- |
|
105 // CPresenceXDM::CreateRootIfNeededL() |
|
106 // --------------------------------------------------------------------------- |
|
107 // |
|
108 void CPresenceXDM::CreateRootIfNeededL() |
|
109 { |
|
110 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::CreateRootIfNeededL" ) ); |
|
111 CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot(); |
|
112 if (myRootNode) |
|
113 { |
|
114 myRootNode->SetEmptyNode(EFalse);// allow new data to be created, for xdmengine bug |
|
115 return; |
|
116 } |
|
117 myRootNode = iPresDocument->CreateRootL(); |
|
118 myRootNode->SetNameL( KXdmRuleset ); |
|
119 } |
|
120 |
|
121 // --------------------------------------------------------------------------- |
|
122 // CPresenceXDM::UpdateToServerL() |
|
123 // --------------------------------------------------------------------------- |
|
124 // |
|
125 EXPORT_C TInt CPresenceXDM::UpdateToServerL |
|
126 (MRLSPresXDMAsyncHandler* const aHandler) |
|
127 { |
|
128 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::UpdateToServerL(%d)" ),aHandler ); |
|
129 __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); |
|
130 if (IsActive()) |
|
131 return KErrAlreadyExists; |
|
132 iAsyncReq = EPresXDMUpdateToServer; |
|
133 iAsyncHandler = aHandler; |
|
134 |
|
135 iPresDocument->AppendL(); |
|
136 iXDMEngine->UpdateL(iPresDocument, iStatus); |
|
137 SetActive(); |
|
138 return KErrNone; |
|
139 } |
|
140 |
|
141 // --------------------------------------------------------------------------- |
|
142 // CPresenceXDM::UpdateAllFromServerL() |
|
143 // --------------------------------------------------------------------------- |
|
144 // |
|
145 EXPORT_C TInt CPresenceXDM::UpdateAllFromServerL |
|
146 (MRLSPresXDMAsyncHandler* const aHandler) |
|
147 { |
|
148 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::UpdateAllFromServerL(%d)" ),aHandler ); |
|
149 __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); |
|
150 if (IsActive()) |
|
151 return KErrAlreadyExists; |
|
152 iPresDocument->ResetContents(); |
|
153 iPresDocument->FetchDataL(); |
|
154 iAsyncReq = EPresXDMUpdateFromServer; |
|
155 iAsyncHandler = aHandler; |
|
156 iXDMEngine->UpdateL(iPresDocument, iStatus); |
|
157 SetActive(); |
|
158 return KErrNone; |
|
159 } |
|
160 |
|
161 // --------------------------------------------------------------------------- |
|
162 // CPresenceXDM::CancelUpdateL() |
|
163 // --------------------------------------------------------------------------- |
|
164 // |
|
165 EXPORT_C void CPresenceXDM::CancelUpdateL() |
|
166 { |
|
167 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::CancelUpdateL" )); |
|
168 if (IsActive()) |
|
169 { |
|
170 DoCancel(); |
|
171 } |
|
172 } |
|
173 |
|
174 // --------------------------------------------------------------------------- |
|
175 // CPresenceXDM::GetAllRulesL() |
|
176 // --------------------------------------------------------------------------- |
|
177 // |
|
178 EXPORT_C void CPresenceXDM::GetAllRulesL(CDesCArray& aRuleIds) |
|
179 { |
|
180 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::GetAllRulesL" ) ); |
|
181 CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot(); |
|
182 if (!myRootNode) |
|
183 return; |
|
184 |
|
185 RPointerArray<CXdmDocumentNode> nodes; |
|
186 CXdmNodeAttribute* idAttribute(NULL); |
|
187 |
|
188 // Find all rules under root |
|
189 if ((myRootNode->Find(KXdmRule, nodes)) == KErrNone) |
|
190 { // go through all found rules |
|
191 TInt ruleCountInNode = nodes.Count(); |
|
192 OPENG_DP(D_OPENG_LIT( " ruleCountInNode = %d" ),ruleCountInNode ); |
|
193 for (TInt i=0;i<ruleCountInNode;i++) |
|
194 { // get the id attribute |
|
195 idAttribute = (nodes[i])->Attribute(KXdmId); |
|
196 // push it to given discriptor array |
|
197 aRuleIds.AppendL(idAttribute->AttributeValue()); |
|
198 } |
|
199 } |
|
200 nodes.Close(); |
|
201 return; |
|
202 } |
|
203 |
|
204 // --------------------------------------------------------------------------- |
|
205 // CPresenceXDM::DeleteRuleL() |
|
206 // --------------------------------------------------------------------------- |
|
207 // |
|
208 EXPORT_C TInt CPresenceXDM::DeleteRuleL(const TDesC& aRuleId) |
|
209 { |
|
210 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::DeleteRuleL(%S)" ),&aRuleId ); |
|
211 CXdmDocumentNode* ruleNode = IsRuleExistInt(aRuleId); |
|
212 if (ruleNode) |
|
213 { |
|
214 iPresDocument->RemoveFromModelL(ruleNode); |
|
215 OPENG_DP(D_OPENG_LIT( " removed" ) ); |
|
216 return KErrNone; |
|
217 } |
|
218 return KErrNotFound; |
|
219 } |
|
220 |
|
221 // --------------------------------------------------------------------------- |
|
222 // CPresenceXDM::CreateNewRuleL() |
|
223 // --------------------------------------------------------------------------- |
|
224 // |
|
225 EXPORT_C TInt CPresenceXDM::CreateNewRuleL(TDes& aRuleId) |
|
226 { |
|
227 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::CreateNewRuleL(%S)" ),&aRuleId ); |
|
228 CreateRootIfNeededL(); |
|
229 |
|
230 if(aRuleId==KNullDesC) // create rule id if needed |
|
231 GetUniqueRuleId(aRuleId); |
|
232 else if(IsRuleExist(aRuleId)) // if rule id already exist, check it |
|
233 return KErrAlreadyExists; |
|
234 |
|
235 CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot(); |
|
236 if (myRootNode) |
|
237 { |
|
238 CXdmDocumentNode* ruleNode = myRootNode->CreateChileNodeL(KXdmRule); |
|
239 CXdmNodeAttribute* attributeRuleId = ruleNode->CreateAttributeL(KXdmId); |
|
240 attributeRuleId->SetAttributeValueL(aRuleId); |
|
241 return KErrNone; |
|
242 } |
|
243 return KErrNotFound; |
|
244 } |
|
245 |
|
246 // --------------------------------------------------------------------------- |
|
247 // CPresenceXDM::IsRuleExist() |
|
248 // --------------------------------------------------------------------------- |
|
249 // |
|
250 EXPORT_C TBool CPresenceXDM::IsRuleExist(const TDesC& aRuleId) |
|
251 { |
|
252 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::IsRuleExist(%S)" ),&aRuleId ); |
|
253 CXdmDocumentNode* ruleNode = IsRuleExistInt(aRuleId); |
|
254 if(ruleNode) |
|
255 { |
|
256 OPENG_DP(D_OPENG_LIT( " True")); |
|
257 return ETrue; |
|
258 } |
|
259 return EFalse; |
|
260 } |
|
261 |
|
262 // --------------------------------------------------------------------------- |
|
263 // CPresenceXDM::DeleteAllRules() |
|
264 // --------------------------------------------------------------------------- |
|
265 // |
|
266 EXPORT_C void CPresenceXDM::DeleteAllRules() |
|
267 { |
|
268 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::DeleteAllRules" )); |
|
269 CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot(); |
|
270 if (!myRootNode) |
|
271 return; // return if no rule exists |
|
272 |
|
273 myRootNode->SetEmptyNode(ETrue); // delete all data |
|
274 myRootNode->SetEmptyNode(EFalse);// allow new data to be created |
|
275 |
|
276 } |
|
277 |
|
278 // --------------------------------------------------------------------------- |
|
279 // CPresenceXDM::DeleteEmptyRules() |
|
280 // --------------------------------------------------------------------------- |
|
281 // |
|
282 EXPORT_C void CPresenceXDM::DeleteEmptyRulesL() |
|
283 { |
|
284 OPENG_DP(D_OPENG_LIT( "CPresenceXDM::DeleteEmptyRules" )); |
|
285 CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot(); |
|
286 if (!myRootNode) |
|
287 return; // return if no rule exists |
|
288 |
|
289 RPointerArray<CXdmDocumentNode> nodes; |
|
290 |
|
291 // Find all rules under root Node |
|
292 if ((myRootNode->Find(KXdmRule, nodes)) == KErrNone) |
|
293 { // go through all found rules |
|
294 TInt ruleCountInNode = nodes.Count(); |
|
295 OPENG_DP(D_OPENG_LIT( " ruleCountInNode = %d" ),ruleCountInNode ); |
|
296 |
|
297 for (TInt i=0;i<ruleCountInNode;i++) |
|
298 { |
|
299 if ( ((nodes[i])->NodeCount()) == 0)// if rule is empty |
|
300 { |
|
301 iPresDocument->RemoveFromModelL(nodes[i]); |
|
302 OPENG_DP(D_OPENG_LIT( " delete at i = %d" ), i); |
|
303 } |
|
304 } |
|
305 } |
|
306 nodes.Close(); |
|
307 } |
|
308 |
|
309 // --------------------------------------------------------------------------- |
|
310 // CPresenceXDM::IsRuleExistInt() |
|
311 // --------------------------------------------------------------------------- |
|
312 // |
|
313 CXdmDocumentNode* CPresenceXDM::IsRuleExistInt(const TDesC& aRuleId) |
|
314 { |
|
315 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::IsRuleExistInt(%S)" ),&aRuleId ); |
|
316 CXdmDocumentNode* myRootNode = iPresDocument->DocumentRoot(); |
|
317 if (!myRootNode) |
|
318 return NULL; |
|
319 |
|
320 RPointerArray<CXdmDocumentNode> nodes; |
|
321 CXdmDocumentNode* desiredNode(NULL); |
|
322 CXdmNodeAttribute* idAttribute(NULL); |
|
323 |
|
324 // Find all rules under root Node |
|
325 if ((myRootNode->Find(KXdmRule, nodes)) == KErrNone) |
|
326 { // go through all found rules |
|
327 TInt ruleCountInNode = nodes.Count(); |
|
328 OPENG_DP(D_OPENG_LIT( " ruleCountInNode = %d" ),ruleCountInNode ); |
|
329 for (TInt k=0;k<ruleCountInNode;k++) |
|
330 { // get the id attribute |
|
331 idAttribute = (nodes[k])->Attribute(KXdmId); |
|
332 // match it with given attr |
|
333 if (idAttribute->AttributeValue() == aRuleId) |
|
334 { |
|
335 desiredNode = nodes[k]; |
|
336 break; |
|
337 } |
|
338 } |
|
339 } |
|
340 nodes.Close(); |
|
341 return desiredNode; |
|
342 } |
|
343 |
|
344 // --------------------------------------------------------------------------- |
|
345 // CPresenceXDM::GetRuleChildNodeL() |
|
346 // --------------------------------------------------------------------------- |
|
347 // |
|
348 CXdmDocumentNode* CPresenceXDM::GetRuleChildNodeL(const TDesC& aRuleId, |
|
349 const TDesC& aRuleChild, TBool aCreate) |
|
350 { |
|
351 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::GetRuleChildNodeL()" ) ); |
|
352 OPENG_DP(D_OPENG_LIT( " aRuleId = %S, aRuleChild = %S, aCreate = %d"), |
|
353 &aRuleId, &aRuleChild, aCreate); |
|
354 |
|
355 CXdmDocumentNode* myRuleNode = IsRuleExistInt(aRuleId); |
|
356 if (!myRuleNode) |
|
357 return NULL; |
|
358 |
|
359 RPointerArray<CXdmDocumentNode> nodes; |
|
360 CXdmDocumentNode* ruleChildNode(NULL); |
|
361 |
|
362 // Finding rule child node |
|
363 myRuleNode->Find(aRuleChild, nodes); |
|
364 TInt childCount = myRuleNode->NodeCount(); |
|
365 TInt position; |
|
366 OPENG_DP(D_OPENG_LIT( " GetruleChildNodeL nodeCount = %d"),nodes.Count()); |
|
367 if(nodes.Count()) // if rule child node exist |
|
368 { |
|
369 ruleChildNode = nodes[0]; // only one rule child node can exist |
|
370 } |
|
371 else if (aCreate) // if asked to create |
|
372 { |
|
373 ruleChildNode = iXDMEngine->CreateDocumentNodeL(); |
|
374 ruleChildNode->SetNameL(aRuleChild); |
|
375 |
|
376 if(aRuleChild==KXdmConditions) // if we need to add conditions |
|
377 { // add always to the first position |
|
378 myRuleNode->InsertChileNodeL(0, ruleChildNode); |
|
379 position = 0; |
|
380 } |
|
381 |
|
382 else if(aRuleChild==KXdmActions) // if we need to add actions |
|
383 { |
|
384 myRuleNode->Find(KXdmConditions, nodes); |
|
385 if (nodes.Count()) |
|
386 { |
|
387 myRuleNode->InsertChileNodeL(1, ruleChildNode);//if conditions exists add after it |
|
388 position = 1; |
|
389 } |
|
390 else |
|
391 { |
|
392 myRuleNode->InsertChileNodeL(0, ruleChildNode); |
|
393 position = 0; |
|
394 } |
|
395 } |
|
396 |
|
397 else // to add transformations |
|
398 { |
|
399 myRuleNode->InsertChileNodeL(childCount, ruleChildNode); |
|
400 position = childCount; |
|
401 } |
|
402 delete ruleChildNode; |
|
403 ruleChildNode = myRuleNode->ChileNode(position); |
|
404 OPENG_DP(D_OPENG_LIT( " position = %d"),position); |
|
405 } |
|
406 |
|
407 nodes.Close(); |
|
408 return ruleChildNode; |
|
409 } |
|
410 |
|
411 // --------------------------------------------------------------------------- |
|
412 // CPresenceXDM::GetConditionChildNodeL() |
|
413 // --------------------------------------------------------------------------- |
|
414 // |
|
415 CXdmDocumentNode* CPresenceXDM::GetConditionChildNodeL(const TDesC& aRuleId, |
|
416 const TDesC& aCondChild, TBool aCreate) |
|
417 { |
|
418 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::GetConditionChildNodeL()" ) ); |
|
419 OPENG_DP(D_OPENG_LIT( " aRuleId = %S, aCondChild = %S, aCreate = %d"), |
|
420 &aRuleId, &aCondChild, aCreate); |
|
421 |
|
422 CXdmDocumentNode* conditionNode = GetRuleChildNodeL(aRuleId, KXdmConditions, |
|
423 aCreate); |
|
424 if (!conditionNode) |
|
425 return NULL; |
|
426 |
|
427 RPointerArray<CXdmDocumentNode> nodes; |
|
428 CXdmDocumentNode* condChildNode(NULL); |
|
429 |
|
430 |
|
431 // Finding condition child node |
|
432 conditionNode->Find(aCondChild, nodes); |
|
433 OPENG_DP(D_OPENG_LIT( " GetcondChildNodeL nodeCount = %d"),nodes.Count()); |
|
434 if(nodes.Count()) // if condition child node exist |
|
435 { |
|
436 condChildNode = nodes[0]; // only one condition child node can exist |
|
437 } |
|
438 else if (aCreate) // if asked to create |
|
439 { |
|
440 condChildNode = conditionNode->CreateChileNodeL(aCondChild); |
|
441 } |
|
442 |
|
443 nodes.Close(); |
|
444 return condChildNode; |
|
445 } |
|
446 |
|
447 // --------------------------------------------------------------------------- |
|
448 // CPresenceXDM::GetUniqueRuleId() |
|
449 // --------------------------------------------------------------------------- |
|
450 // |
|
451 void CPresenceXDM::GetUniqueRuleId(TDes& aRuleId) |
|
452 { |
|
453 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::GetUniqueRuleId" )); |
|
454 aRuleId.Copy(KPresRuleIDPrefix); |
|
455 TInt myNumber; |
|
456 |
|
457 // make sure that newly created rule id doesnt exist in the document |
|
458 while (IsRuleExist(aRuleId)) |
|
459 { |
|
460 aRuleId.Delete(KPresRuleIDPrefixLength, KPresRuleIDNumLength); |
|
461 myNumber = Math::Random() - KPresRuleIdCalc; |
|
462 aRuleId.AppendNumFixedWidth(myNumber,EDecimal,KPresRuleIDNumLength); |
|
463 } |
|
464 OPENG_DP(D_OPENG_LIT( " aRuleId = %S" ), &aRuleId); |
|
465 } |
|
466 |
|
467 |
|
468 // --------------------------------------------------------------------------- |
|
469 // CPresenceXDM::DoCancel() |
|
470 // --------------------------------------------------------------------------- |
|
471 // |
|
472 void CPresenceXDM::DoCancel() |
|
473 { |
|
474 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::DoCancel" )); |
|
475 iXDMEngine->CancelUpdate(iPresDocument); |
|
476 iAsyncReq = EPresXDMRequestCancelling; |
|
477 } |
|
478 |
|
479 // --------------------------------------------------------------------------- |
|
480 // CPresenceXDM::RunL() |
|
481 // --------------------------------------------------------------------------- |
|
482 // |
|
483 void CPresenceXDM::RunL() |
|
484 { |
|
485 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::RunL" )); |
|
486 OPENG_DP(D_OPENG_LIT( " iAsyncReq = %d, iStatus.Int() = %d" ), |
|
487 iAsyncReq,iStatus.Int()); |
|
488 TInt orig = iAsyncReq; |
|
489 iAsyncReq = EPresXDMNoRequestMade; |
|
490 |
|
491 switch (orig) |
|
492 { |
|
493 case EPresXDMUpdateToServer: |
|
494 iAsyncHandler->HandlePresUpdateDocumentL(iStatus.Int()); |
|
495 break; |
|
496 case EPresXDMUpdateFromServer: |
|
497 CreateRootIfNeededL(); |
|
498 iAsyncHandler->HandlePresUpdateDocumentL(iStatus.Int()); |
|
499 break; |
|
500 case EPresXDMRequestCancelling: |
|
501 iAsyncHandler->HandlePresUpdateCancelL(iStatus.Int()); |
|
502 break; |
|
503 case EPresXDMNoRequestMade: |
|
504 default: |
|
505 break; |
|
506 } |
|
507 } |
|
508 |
|
509 // --------------------------------------------------------------------------- |
|
510 // CPresenceXDM::RunError() |
|
511 // --------------------------------------------------------------------------- |
|
512 // |
|
513 TInt CPresenceXDM::RunError(TInt aError) |
|
514 { |
|
515 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::RunError" )); |
|
516 OPENG_DP(D_OPENG_LIT( " RunError iAsyncReq(%d), aError(%d)" ),iAsyncReq, |
|
517 aError); |
|
518 return KErrNone; |
|
519 } |
|
520 |
|
521 // --------------------------------------------------------------------------- |
|
522 // CPresenceXDM::RemoveFromModelL() |
|
523 // --------------------------------------------------------------------------- |
|
524 // |
|
525 void CPresenceXDM::RemoveFromModelL( CXdmDocumentNode* aNode ) |
|
526 { |
|
527 OPENG_DP(D_OPENG_LIT( " CPresenceXDM::RemoveFromModelL(%d)" ),aNode); |
|
528 iPresDocument->RemoveFromModelL(aNode); |
|
529 } |
|
530 |
|
531 // end of file |