|
1 /* |
|
2 * Copyright (c) 2002-2005 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: |
|
15 * handler class for imps group feature. |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 #include <e32std.h> |
|
22 |
|
23 #include "impsgroupcli.h" |
|
24 #include "impsgrouphandler.h" |
|
25 #include "impsgrouppropsint.h" |
|
26 #include "impsfields.h" |
|
27 #include "impserrors.h" |
|
28 #include "impsservercommon.h" |
|
29 #include "impsdataaccessor.h" |
|
30 #include "impscdatautils.h" |
|
31 #include "impsutils.h" |
|
32 #include "impserrors.h" |
|
33 #include "WVEngineInternalCRKeys.h" |
|
34 |
|
35 // CONSTANTS |
|
36 const TInt KArraySize = 4; |
|
37 |
|
38 // MACROS |
|
39 #ifndef _DEBUG |
|
40 #define _NO_IMPS_LOGGING_ |
|
41 #endif |
|
42 |
|
43 // ================= MEMBER FUNCTIONS ======================= |
|
44 |
|
45 // ---------------------------------------------------------------------------- |
|
46 // CImpsGroupHandler2::CImpsGroupHandler2 |
|
47 // ---------------------------------------------------------------------------- |
|
48 CImpsGroupHandler2::CImpsGroupHandler2( |
|
49 TInt aPriority, |
|
50 RImpsGroupClient2& aClient ) : |
|
51 // The base class adds this to the scheduler |
|
52 CImpsHandler2( aPriority, aClient ) |
|
53 { |
|
54 } |
|
55 |
|
56 // ---------------------------------------------------------------------------- |
|
57 // CImpsGroupHandler2::NewL |
|
58 // ---------------------------------------------------------------------------- |
|
59 CImpsGroupHandler2* CImpsGroupHandler2::NewL( |
|
60 RImpsGroupClient2& aClient, |
|
61 TInt aPriority ) |
|
62 { |
|
63 |
|
64 // Perform the construction. |
|
65 CImpsGroupHandler2* self = new (ELeave) |
|
66 CImpsGroupHandler2( aPriority, aClient); |
|
67 |
|
68 CleanupStack::PushL( self ); |
|
69 self->CImpsHandler2::ConstructL(); |
|
70 CleanupStack::Pop( self ); |
|
71 |
|
72 return self; |
|
73 } |
|
74 |
|
75 // ---------------------------------------------------------------------------- |
|
76 // CImpsGroupHandler2::~CImpsGroupHandler2() |
|
77 // ---------------------------------------------------------------------------- |
|
78 CImpsGroupHandler2::~CImpsGroupHandler2() |
|
79 { |
|
80 } |
|
81 |
|
82 |
|
83 // ---------------------------------------------------------------------------- |
|
84 // CImpsGroupHandler2::HandleEventL() |
|
85 // ---------------------------------------------------------------------------- |
|
86 void CImpsGroupHandler2::HandleEventL( CImpsFields* aErrorFields ) |
|
87 { |
|
88 SImpsEventData* event = (SImpsEventData*)iEventData.Ptr(); |
|
89 |
|
90 #ifndef _NO_IMPS_LOGGING_ |
|
91 CImpsClientLogger::Log(_L("CImpsGroupHandler2::HandleEventL opid=%d cli=%d"), |
|
92 event->iOpCode, (TInt)&iClient ); |
|
93 #endif |
|
94 |
|
95 // LeaveGroupResponse is a special case because of it can contain |
|
96 // reasonable data although having status code unequal 200. |
|
97 // First one is SAP initiated leavegroup response |
|
98 if ( event->iReqMesType == EImpsMessageNone && |
|
99 event->iMessageType == EImpsLeaveGroupRes ) |
|
100 { |
|
101 TInt error = Imps_ERROR_BASE - event->iStatus ; |
|
102 if( error >= 800 && error < 900 |
|
103 || event->iStatus == KErrNone || error == 200 ) |
|
104 { |
|
105 // NOTE |
|
106 // in case of sap initiated LeaveGroupResponse |
|
107 // the client needs the error code, so we need to |
|
108 // deliver it by calling also the error handler |
|
109 HandleErrorEventL( event->iOpCode, event->iStatus, aErrorFields ); |
|
110 // call now the reqular handler |
|
111 HandleGroupEventL( ); |
|
112 } |
|
113 else |
|
114 { |
|
115 // If it is some other error code that 800-900 |
|
116 // then handle it as an error |
|
117 HandleErrorEventL( event->iOpCode, event->iStatus, aErrorFields ); |
|
118 } |
|
119 } |
|
120 |
|
121 else |
|
122 { |
|
123 if ( event->iStatus != ( Imps_ERROR_BASE - 200 ) && |
|
124 event->iStatus != KErrNone ) |
|
125 { |
|
126 #ifndef _NO_IMPS_LOGGING_ |
|
127 CImpsClientLogger::Log( |
|
128 _L("CImpsGroupHandler2: error event-iStatus=%d"), |
|
129 event->iStatus); |
|
130 #endif |
|
131 HandleErrorEventL( event->iOpCode, event->iStatus, aErrorFields ); |
|
132 } |
|
133 // Call regular observer |
|
134 // iStatus is error code or message size |
|
135 else if ( iStatus >= 0 ) |
|
136 { |
|
137 HandleGroupEventL( ); |
|
138 } |
|
139 } |
|
140 } |
|
141 |
|
142 // ---------------------------------------------------------------------------- |
|
143 // CImpsGroupHandler2::HandleGroupEventL() |
|
144 // ---------------------------------------------------------------------------- |
|
145 void CImpsGroupHandler2::HandleGroupEventL( ) |
|
146 { |
|
147 |
|
148 #ifndef _NO_IMPS_LOGGING_ |
|
149 CImpsClientLogger::Log(_L("CImpsGroupHandler2::HandleGroupEventL begins")); |
|
150 #endif |
|
151 |
|
152 SImpsEventData* event = (SImpsEventData*)iEventData.Ptr(); |
|
153 RImpsGroupClient2& client = (RImpsGroupClient2&)iClient; |
|
154 MImpsGroupHandler2* handler = client.Handler(); |
|
155 |
|
156 TInt err( KErrNone ); |
|
157 |
|
158 #ifndef _NO_IMPS_LOGGING_ |
|
159 CImpsClientLogger::Log(_L("CImpsGroupHandler2: msgType= %x opId= %d"),event->iMessageType, event->iOpCode ); |
|
160 #endif |
|
161 // We are not interested in if the message is response or push message |
|
162 // Just worry about message type from now on. |
|
163 |
|
164 CImpsDataAccessor* myAccessor = CImpsDataAccessor::NewLC( iFields ); // << |
|
165 |
|
166 // call appropriate observer method |
|
167 switch ( event->iMessageType ) |
|
168 { |
|
169 case EImpsStatus: |
|
170 { |
|
171 TRAP( err, handler->HandleCompleteL( |
|
172 event->iOpCode, |
|
173 *client.CspIdentifier() )); |
|
174 }; |
|
175 break; |
|
176 case EImpsJoinGroupRes: |
|
177 { |
|
178 CDesCArrayFlat* users = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
179 CleanupStack::PushL( users ); |
|
180 CDesCArrayFlat* screenNames = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
181 CleanupStack::PushL( screenNames ); |
|
182 TPtrC welcomeText; |
|
183 welcomeText.Set( KNullDesC ); |
|
184 |
|
185 CImpsKey* myKey = CImpsKey::NewLC(); |
|
186 TImpsCDataUtils::AddValuesFromArrayL( |
|
187 myKey, |
|
188 KJoinGroupResponseElements, |
|
189 sizeof( KJoinGroupResponseElements ) / |
|
190 sizeof( KJoinGroupResponseElements[0] ) ); |
|
191 |
|
192 // Get CSP version |
|
193 TReal version (0); |
|
194 TRAPD( err, version = TImpsDataUtils::GetCenRepRealValueL( |
|
195 KCRUIDWVEngineVariation, KWVEngineCspVersion ) ); |
|
196 // CSP 1.2 UserMapList |
|
197 if ( !err && version == 1.2 ) |
|
198 { |
|
199 #ifndef _NO_IMPS_LOGGING_ |
|
200 CImpsClientLogger::Log(_L("CImpsGroupHandler2::JoinGroupResponse version 1.2") ); |
|
201 #endif |
|
202 myKey->AddL( CREATEKEY( EImpsKeyUserMapList, 0 ) ); |
|
203 TImpsCDataUtils::GetUserMapListL( myKey, |
|
204 myAccessor, users, screenNames ); |
|
205 myKey->PopL( ); // Pop out the UserMapList |
|
206 } |
|
207 // CSP 1.1 UserList |
|
208 else |
|
209 { |
|
210 #ifndef _NO_IMPS_LOGGING_ |
|
211 CImpsClientLogger::Log(_L("CImpsGroupHandler2::JoinGroupResponse version 1.1") ); |
|
212 #endif |
|
213 myKey->AddL( CREATEKEY( EImpsKeyUserList, 0 ) ); |
|
214 TImpsCDataUtils::GetUserListL( myKey, |
|
215 myAccessor, users, screenNames ); |
|
216 myKey->PopL( ); // Pop out the UserList |
|
217 } |
|
218 myKey->AddL( CREATEKEY( EImpsKeyWelcomeNote, 0 ) ); |
|
219 myKey->AddL( CREATEKEY( EImpsKeyContentData, 0 ) ); |
|
220 TDesC* temp = NULL; |
|
221 if( myAccessor->RestoreDescL( myKey, temp ) ) |
|
222 welcomeText.Set( *temp ); |
|
223 #ifndef _NO_IMPS_LOGGING_ |
|
224 CImpsClientLogger::Log(_L("CImpsGroupHandler2::calls HandleJoinL")); |
|
225 #endif |
|
226 TRAP( err, handler->HandleJoinL( |
|
227 event->iOpCode, |
|
228 *users, |
|
229 *screenNames, |
|
230 welcomeText, |
|
231 *iClient.CspIdentifier() )); |
|
232 CleanupStack::PopAndDestroy( 3 ); // users, screennames, myKey |
|
233 }; |
|
234 break; |
|
235 case EImpsLeaveGroupRes: |
|
236 { |
|
237 TPtrC groupId; |
|
238 groupId.Set( KNullDesC ); |
|
239 TPtrC description; |
|
240 description.Set( KNullDesC ); |
|
241 |
|
242 CImpsKey* myKey = CImpsKey::NewLC(); |
|
243 TImpsCDataUtils::AddValuesFromArrayL( |
|
244 myKey, |
|
245 KLeaveGroupGroupIdElements, |
|
246 sizeof( KLeaveGroupGroupIdElements ) / |
|
247 sizeof( KLeaveGroupGroupIdElements[0] ) ); |
|
248 myKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) ); |
|
249 TDesC* temp = NULL; |
|
250 if( myAccessor->RestoreDescL( myKey, temp ) ) |
|
251 groupId.Set( *temp ); |
|
252 |
|
253 myKey->PopL( ); |
|
254 myKey->AddL( CREATEKEY( EImpsKeyResult, 0 ) ); |
|
255 myKey->AddL( CREATEKEY( EImpsKeyDescription, 0 ) ); |
|
256 TDesC* temp2 = NULL; |
|
257 if( myAccessor->RestoreDescL( myKey, temp2 ) ) |
|
258 description.Set( *temp2 ); |
|
259 #ifndef _NO_IMPS_LOGGING_ |
|
260 CImpsClientLogger::Log(_L("CImpsGroupHandler2::calls HandleLeaveL")); |
|
261 #endif |
|
262 TRAP( err, handler->HandleLeaveL( |
|
263 event->iOpCode, |
|
264 groupId, |
|
265 description, |
|
266 *iClient.CspIdentifier() )); |
|
267 CleanupStack::PopAndDestroy( 1 ); // mykey |
|
268 } |
|
269 break; |
|
270 case EImpsGroupMembersRes: |
|
271 { |
|
272 CDesCArrayFlat* users = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
273 CleanupStack::PushL( users ); |
|
274 CDesCArrayFlat* screenNames = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
275 CleanupStack::PushL( screenNames ); |
|
276 CDesCArrayFlat* groupModerators = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
277 CleanupStack::PushL( groupModerators ); |
|
278 CDesCArrayFlat* groupAdmins = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
279 CleanupStack::PushL( groupAdmins ); |
|
280 |
|
281 CImpsKey* myKey = CImpsKey::NewLC(); |
|
282 TImpsCDataUtils::AddValuesFromArrayL( |
|
283 myKey, |
|
284 KGroupMembersUserListElements, |
|
285 sizeof( KGroupMembersUserListElements ) / |
|
286 sizeof( KGroupMembersUserListElements[0] ) ); |
|
287 myKey->AddL( CREATEKEY( EImpsKeyUserList, 0 ) ); |
|
288 TImpsCDataUtils::GetUserListL( myKey, myAccessor, users, screenNames ); |
|
289 myKey->PopL( 2 ); // Pop out the Users and userList |
|
290 TImpsCDataUtils::GetModAndAdmL( myKey, myAccessor, |
|
291 groupModerators, groupAdmins ); |
|
292 #ifndef _NO_IMPS_LOGGING_ |
|
293 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: calls HandleGroupMembersL")); |
|
294 #endif |
|
295 TRAP( err, handler->HandleGroupMembersL( |
|
296 event->iOpCode, |
|
297 *users, |
|
298 *screenNames, |
|
299 *groupModerators, |
|
300 *groupAdmins, |
|
301 *iClient.CspIdentifier() )); |
|
302 // users, screennames, group moderators, group admins, mykey |
|
303 CleanupStack::PopAndDestroy( 5 ); |
|
304 } |
|
305 break; |
|
306 case EImpsGroupPropertiesRes: |
|
307 { |
|
308 CImpsCommonGroupPropsInt* comP = CImpsCommonGroupPropsInt::NewL( ); |
|
309 CleanupStack::PushL( comP ); |
|
310 CImpsPrivateGroupPropsInt* priP = CImpsPrivateGroupPropsInt::NewL( ); |
|
311 CleanupStack::PushL( priP ); |
|
312 |
|
313 CImpsKey* myKey = CImpsKey::NewLC(); |
|
314 TImpsCDataUtils::AddValuesFromArrayL( |
|
315 myKey, |
|
316 KGroupPropElements, |
|
317 sizeof( KGroupPropElements ) / |
|
318 sizeof( KGroupPropElements[0] ) ); |
|
319 TImpsCDataUtils::GetGroupPropertiesL( myKey, myAccessor, comP, priP ); |
|
320 #ifndef _NO_IMPS_LOGGING_ |
|
321 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: calls HandleGroupPropertiesL(GroupProperties)")); |
|
322 #endif |
|
323 TRAP( err, handler->HandleGroupPropertiesL( |
|
324 event->iOpCode, |
|
325 KNullDesC, |
|
326 *comP, |
|
327 *priP, |
|
328 *iClient.CspIdentifier() )); |
|
329 CleanupStack::PopAndDestroy( 3 ); // comP, pri, myKey |
|
330 } |
|
331 break; |
|
332 case EImpsGroupChangeNotice: |
|
333 { |
|
334 CImpsCommonGroupPropsInt* comP = CImpsCommonGroupPropsInt::NewL( ); |
|
335 CleanupStack::PushL( comP ); |
|
336 CImpsPrivateGroupPropsInt* priP = CImpsPrivateGroupPropsInt::NewL( ); |
|
337 CleanupStack::PushL( priP ); |
|
338 TPtrC groupId; |
|
339 groupId.Set( KNullDesC ); |
|
340 |
|
341 CImpsKey* myKey = CImpsKey::NewLC(); |
|
342 TImpsCDataUtils::AddValuesFromArrayL( |
|
343 myKey, |
|
344 KGroupChangeNoticeElements, |
|
345 sizeof( KGroupChangeNoticeElements ) / |
|
346 sizeof( KGroupChangeNoticeElements[0] ) ); |
|
347 myKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) ); |
|
348 TDesC* temp = NULL; |
|
349 if( myAccessor->RestoreDescL( myKey, temp ) ) |
|
350 groupId.Set( *temp ); |
|
351 |
|
352 myKey->PopL( ); |
|
353 TImpsCDataUtils::GetGroupPropertiesL( myKey, myAccessor, comP, priP ); |
|
354 #ifndef _NO_IMPS_LOGGING_ |
|
355 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: calls HandleGroupPropertiesL(GroupChange)")); |
|
356 #endif |
|
357 TRAP( err, handler->HandleGroupPropertiesL( |
|
358 event->iOpCode, |
|
359 groupId, |
|
360 *comP, |
|
361 *priP, |
|
362 *iClient.CspIdentifier())); |
|
363 CleanupStack::PopAndDestroy( 3 ); // comP, pri, myKey |
|
364 } |
|
365 break; |
|
366 case EImpsGroupRejectListRes: |
|
367 { |
|
368 CDesCArrayFlat* users = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
369 CleanupStack::PushL( users ); |
|
370 |
|
371 CImpsKey* myKey = CImpsKey::NewLC(); |
|
372 TImpsCDataUtils::AddValuesFromArrayL( |
|
373 myKey, |
|
374 KGroupRejectUserListElements, |
|
375 sizeof( KGroupRejectUserListElements ) / |
|
376 sizeof( KGroupRejectUserListElements[0] ) ); |
|
377 TImpsCDataUtils::GetUsersL( myKey, myAccessor, users ); |
|
378 #ifndef _NO_IMPS_LOGGING_ |
|
379 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: calls HandleRejectListL")); |
|
380 #endif |
|
381 TRAP( err, handler->HandleRejectListL( |
|
382 event->iOpCode, |
|
383 *users, |
|
384 *iClient.CspIdentifier())); |
|
385 CleanupStack::PopAndDestroy( 2 ); // users myKey |
|
386 } |
|
387 break; |
|
388 case EImpsSubsGroupNoticeRes: |
|
389 { |
|
390 #ifndef _NO_IMPS_LOGGING_ |
|
391 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: calls HandleSubscriptionL")); |
|
392 #endif |
|
393 TRAP( err, handler->HandleSubscriptionL( |
|
394 event->iOpCode, |
|
395 event->iAux, |
|
396 *iClient.CspIdentifier() )); |
|
397 } |
|
398 break; |
|
399 |
|
400 case EImpsNewUsers: |
|
401 { |
|
402 CDesCArrayFlat* users = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
403 CleanupStack::PushL( users ); |
|
404 CDesCArrayFlat* screenNames = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
405 CleanupStack::PushL( screenNames ); |
|
406 TPtrC groupId; |
|
407 groupId.Set( KNullDesC ); |
|
408 |
|
409 CImpsKey* myKey = CImpsKey::NewLC(); |
|
410 TImpsCDataUtils::AddValuesFromArrayL( |
|
411 myKey, |
|
412 KGroupChangeNoticeJoinedElements, |
|
413 sizeof( KGroupChangeNoticeJoinedElements ) / |
|
414 sizeof( KGroupChangeNoticeJoinedElements[0] ) ); |
|
415 // Get CSP version |
|
416 TReal version (0); |
|
417 TRAPD( err, version = TImpsDataUtils::GetCenRepRealValueL( |
|
418 KCRUIDWVEngineVariation, KWVEngineCspVersion ) ); |
|
419 // CSP 1.2 UserMapList |
|
420 if ( !err && version == 1.2 ) |
|
421 { |
|
422 #ifndef _NO_IMPS_LOGGING_ |
|
423 CImpsClientLogger::Log(_L("CImpsGroupHandler2::Handle new users version 1.2") ); |
|
424 #endif |
|
425 myKey->AddL( CREATEKEY( EImpsKeyUserMapList, 0 ) ); |
|
426 TImpsCDataUtils::GetUserMapListL( myKey, |
|
427 myAccessor, users, screenNames ); |
|
428 myKey->PopL( ); // Pop out the UserMapList |
|
429 } |
|
430 // CSP 1.1 UserList |
|
431 else |
|
432 { |
|
433 #ifndef _NO_IMPS_LOGGING_ |
|
434 CImpsClientLogger::Log(_L("CImpsGroupHandler2::Handle new users version 1.1") ); |
|
435 #endif |
|
436 myKey->AddL( CREATEKEY( EImpsKeyUserList, 0 ) ); |
|
437 TImpsCDataUtils::GetUserListL( myKey, |
|
438 myAccessor, users, screenNames ); |
|
439 myKey->PopL( ); // Pop out the UserList |
|
440 } |
|
441 |
|
442 myKey->PopL( 1 ); // Pop out Joined |
|
443 myKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) ); |
|
444 TDesC* temp = NULL; |
|
445 if( myAccessor->RestoreDescL( myKey, temp ) ) |
|
446 groupId.Set( *temp ); |
|
447 #ifndef _NO_IMPS_LOGGING_ |
|
448 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: calls HandleNewUsersL")); |
|
449 #endif |
|
450 TRAP( err, handler->HandleNewUsersL( |
|
451 groupId, |
|
452 *users, |
|
453 *screenNames, |
|
454 *iClient.CspIdentifier() )); |
|
455 CleanupStack::PopAndDestroy( 3 ); // users, screenNames, myKey |
|
456 } |
|
457 break; |
|
458 |
|
459 case EImpsLeftUsers: |
|
460 { |
|
461 CDesCArrayFlat* users = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
462 CleanupStack::PushL( users ); |
|
463 CDesCArrayFlat* screenNames = new ( ELeave )CDesCArrayFlat( KArraySize ); |
|
464 CleanupStack::PushL( screenNames ); |
|
465 TPtrC groupId; |
|
466 groupId.Set( KNullDesC ); |
|
467 |
|
468 CImpsKey* myKey = CImpsKey::NewLC(); |
|
469 TImpsCDataUtils::AddValuesFromArrayL( |
|
470 myKey, |
|
471 KGroupChangeNoticeLeftElements, |
|
472 sizeof( KGroupChangeNoticeLeftElements ) / |
|
473 sizeof( KGroupChangeNoticeLeftElements[0] ) ); |
|
474 TImpsCDataUtils::GetUserListL( myKey, myAccessor, users, screenNames ); |
|
475 myKey->PopL( 2 ); // Pop out Left and UserList |
|
476 myKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) ); |
|
477 TDesC* temp = NULL; |
|
478 if( myAccessor->RestoreDescL( myKey, temp ) ) |
|
479 groupId.Set( *temp ); |
|
480 #ifndef _NO_IMPS_LOGGING_ |
|
481 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: calls HandleLeftUsersL")); |
|
482 #endif |
|
483 TRAP( err, handler->HandleLeftUsersL( |
|
484 groupId, |
|
485 *users, |
|
486 *screenNames, |
|
487 *iClient.CspIdentifier() )); |
|
488 CleanupStack::PopAndDestroy( 3 ); // myKey, users, screenNames |
|
489 } |
|
490 break; |
|
491 |
|
492 default: |
|
493 #ifndef _NO_IMPS_LOGGING_ |
|
494 CImpsClientLogger::Log(_L("CImpsGroupHandler2:: default branch")); |
|
495 #endif |
|
496 __ASSERT_DEBUG( 0 == 1, |
|
497 User::Panic( KImpsPanicCategory, |
|
498 EImpsCorrupted ) ); |
|
499 User::Leave( KErrNotSupported ); |
|
500 break; |
|
501 } |
|
502 CleanupStack::PopAndDestroy( 1 ); // >>> data accessor |
|
503 |
|
504 } |
|
505 |
|
506 |
|
507 // End of File |