|
1 /* |
|
2 * Copyright (c) 2006-2007 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: The ECOM interface implementation. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 #include "musaiwprovider.h" |
|
22 #include "musaiwprovider.hrh" |
|
23 #include "muslogger.h" |
|
24 #include "musmanagercommon.h" |
|
25 #include "musmanager.h" |
|
26 #include "musuid.hrh" |
|
27 #include "musresourcefinderutil.h" |
|
28 #include "mussettings.h" |
|
29 #include "mussesseioninformationapi.h" |
|
30 #include "musindicatorapi.h" |
|
31 |
|
32 #include <musresourceproperties.h> |
|
33 |
|
34 #include <featmgr.h> |
|
35 #include <e32property.h> |
|
36 #include <AiwCommon.h> // AIW classes and definitions |
|
37 #include <AiwCommon.hrh> // AIW constants |
|
38 #include <AiwMenu.h> // AIW Menu pane |
|
39 #include <aknnotewrappers.h> // CAknInformationNote |
|
40 #include <avkon.rsg> // Resources |
|
41 #include <apacmdln.h> |
|
42 #include <apgtask.h> |
|
43 #include <bautils.h> |
|
44 #include <charconv.h> |
|
45 #include <eikenv.h> |
|
46 #include <musaiwproviderui.rsg> |
|
47 #include <StringLoader.h> |
|
48 #include <AknGlobalNote.h> |
|
49 #include <utf.h> |
|
50 #include <features.hrh> |
|
51 #include <aknenv.h> |
|
52 |
|
53 //////// public -- constructor and destructor //////// |
|
54 |
|
55 _LIT( KMusAiwProviderResource, "musaiwproviderui.rsc" ); |
|
56 |
|
57 // ----------------------------------------------------------------------------- |
|
58 // Two-phased constructor. |
|
59 // ----------------------------------------------------------------------------- |
|
60 // |
|
61 CMusAiwProvider* CMusAiwProvider::NewL() |
|
62 { |
|
63 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::NewL" ) |
|
64 CMusAiwProvider* self = new( ELeave ) CMusAiwProvider; |
|
65 CleanupStack::PushL( self ); |
|
66 self->ConstructL(); |
|
67 CleanupStack::Pop( self ); |
|
68 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::NewL" ) |
|
69 return self; |
|
70 } |
|
71 |
|
72 |
|
73 // ----------------------------------------------------------------------------- |
|
74 // C++ destructor. |
|
75 // ----------------------------------------------------------------------------- |
|
76 // |
|
77 CMusAiwProvider::~CMusAiwProvider() |
|
78 { |
|
79 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::~CMusAiwProvider" ) |
|
80 delete iResourceFileName ; |
|
81 iResourceFileName = NULL ; |
|
82 delete iIndicator; |
|
83 iIndicator = NULL ; |
|
84 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::~CMusAiwProvider" ) |
|
85 } |
|
86 |
|
87 |
|
88 //////// private -- constructors //////// |
|
89 |
|
90 // ----------------------------------------------------------------------------- |
|
91 // C++ constructor. |
|
92 // ----------------------------------------------------------------------------- |
|
93 // |
|
94 CMusAiwProvider::CMusAiwProvider() |
|
95 : iIsWarning( ETrue ) |
|
96 { |
|
97 } |
|
98 |
|
99 |
|
100 // ----------------------------------------------------------------------------- |
|
101 // Symbian second-phase constructor. |
|
102 // ----------------------------------------------------------------------------- |
|
103 // |
|
104 void CMusAiwProvider::ConstructL() |
|
105 { |
|
106 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::ConstructL" ) |
|
107 iResourceFileName = MusResourceFinderUtil::ResourcePathL( |
|
108 KMusAiwProviderResource ); |
|
109 |
|
110 DoInitialiseL(); |
|
111 |
|
112 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::ConstructL" ) |
|
113 } |
|
114 |
|
115 |
|
116 |
|
117 //////// public -- from CAiwServiceIfBase //////// |
|
118 |
|
119 // ----------------------------------------------------------------------------- |
|
120 // Called by the AIW framework to initialize the provider with necessary |
|
121 // information. |
|
122 // ----------------------------------------------------------------------------- |
|
123 // |
|
124 void CMusAiwProvider::InitialiseL( |
|
125 MAiwNotifyCallback& /* aFrameworkCallback*/, |
|
126 const RCriteriaArray& /* aInterest */ ) |
|
127 { |
|
128 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::InitialiseL") |
|
129 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::InitialiseL") |
|
130 } |
|
131 |
|
132 |
|
133 |
|
134 |
|
135 |
|
136 //////// public -- from CAiwServiceIfMenu //////// |
|
137 |
|
138 // ----------------------------------------------------------------------------- |
|
139 // Initializes menu pane by adding provider-specific menu items. |
|
140 // ----------------------------------------------------------------------------- |
|
141 // |
|
142 void CMusAiwProvider::InitializeMenuPaneL( |
|
143 CAiwMenuPane& aMenuPane, |
|
144 TInt aIndex, |
|
145 TInt /* aCascadeId */, |
|
146 const CAiwGenericParamList& /* aInParamList */ ) |
|
147 { |
|
148 FeatureManager::InitializeLibL(); |
|
149 TBool support = FeatureManager::FeatureSupported( KFeatureIdMultimediaSharing ); |
|
150 FeatureManager::UnInitializeLib(); |
|
151 if( support ) |
|
152 { |
|
153 DoInitializeMenuPaneL( aMenuPane, aIndex ); |
|
154 } |
|
155 } |
|
156 |
|
157 |
|
158 // ----------------------------------------------------------------------------- |
|
159 // Initializes menu pane by adding provider-specific menu items. |
|
160 // ----------------------------------------------------------------------------- |
|
161 // |
|
162 void CMusAiwProvider::DoInitializeMenuPaneL( |
|
163 CAiwMenuPane& aMenuPane, |
|
164 TInt aIndex) |
|
165 { |
|
166 MUS_LOG1( "mus: [AIWPRO] -> CMusAiwProvider::DoInitializeMenuPaneL( %d )", |
|
167 aIndex ) |
|
168 |
|
169 if( iResourceFileName == NULL ) |
|
170 { |
|
171 iResourceFileName = MusResourceFinderUtil::ResourcePathL( |
|
172 KMusAiwProviderResource ); |
|
173 } |
|
174 TFileName filename ( *iResourceFileName ); |
|
175 MUS_LOG_TDESC( "mus: [AIWPRO] Resource filename: ", filename ) |
|
176 |
|
177 if( ApplicationRunningL() ) |
|
178 { |
|
179 MUS_LOG( "mus: [AIWPRO] Application already running:\ |
|
180 giving _continue sharing_ menu command" ) |
|
181 // Application is already started. Add resources to menu items. |
|
182 aMenuPane.AddMenuItemsL( filename, |
|
183 R_MUSAIWPROVIDER_RUNNING_CASCADED_SUBMENU, |
|
184 KMusAiwProviderUid, |
|
185 aIndex ); |
|
186 |
|
187 } |
|
188 else |
|
189 { |
|
190 // check for variant |
|
191 if ( MultimediaSharingSettings::OperatorVariantSettingL() |
|
192 == MusSettingsKeys::EOperatorSpecific ) |
|
193 { |
|
194 OperatorVariantStartUpL( filename, aMenuPane, aIndex ); |
|
195 } |
|
196 else |
|
197 { |
|
198 NoVariationStartUpL( filename, aMenuPane, aIndex ); |
|
199 } |
|
200 } |
|
201 |
|
202 |
|
203 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::DoInitializeMenuPaneL" ) |
|
204 } |
|
205 |
|
206 // ----------------------------------------------------------------------------- |
|
207 // |
|
208 // |
|
209 // ----------------------------------------------------------------------------- |
|
210 // |
|
211 void CMusAiwProvider::DoInitialiseL() |
|
212 { |
|
213 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::DoInitialiseL") |
|
214 |
|
215 if ( !iIndicator ) |
|
216 { |
|
217 MUS_LOG( "mus: [AIWPRO] : creating indicator") |
|
218 iIndicator = CMusIndicatorApi::NewL(); |
|
219 } |
|
220 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::DoInitialiseL") |
|
221 } |
|
222 |
|
223 |
|
224 // ----------------------------------------------------------------------------- |
|
225 // |
|
226 // ----------------------------------------------------------------------------- |
|
227 // |
|
228 TBool CMusAiwProvider::ApplicationRunningL() |
|
229 { |
|
230 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::ApplicationRunningL" ) |
|
231 RWsSession wsSession; |
|
232 User::LeaveIfError( wsSession.Connect() ); |
|
233 CleanupClosePushL( wsSession ); |
|
234 TApaTaskList taskList( wsSession ); |
|
235 TUid appUid; |
|
236 appUid.iUid = KMusUiUid; |
|
237 TApaTask task = taskList.FindApp( appUid ); |
|
238 TBool running = task.Exists(); |
|
239 CleanupStack::PopAndDestroy( &wsSession ); |
|
240 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::ApplicationRunningL" ) |
|
241 return running; |
|
242 } |
|
243 // ----------------------------------------------------------------------------- |
|
244 // |
|
245 // ----------------------------------------------------------------------------- |
|
246 // |
|
247 void CMusAiwProvider::NoVariationStartUpL( TFileName& aFileName, |
|
248 CAiwMenuPane& aMenuPane, |
|
249 TInt aIndex ) |
|
250 { |
|
251 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::NoVariationStartUpL" ) |
|
252 CMusManager* manager = CMusManager::NewLC(); |
|
253 iAvailability = manager->AvailabilityL(); |
|
254 |
|
255 /* Multimediasharing Menu items should be shown in call menu when |
|
256 1.SIP Registration is still ongoing or it has failed for some reason. |
|
257 2.Regardless of Options execution ( All options are just informative. |
|
258 Cant be considered as Error situation.) |
|
259 3.When iAvailability plugin says OK ( Based on call,network,settingui item) |
|
260 4.Also in confrence and hold cases |
|
261 */ |
|
262 if ( iAvailability == MultimediaSharing::ESipRegistrationPending || |
|
263 iAvailability == MultimediaSharing::ESipOptionsSent || |
|
264 iAvailability == MultimediaSharing::EMultimediaSharingAvailable || |
|
265 iAvailability == MultimediaSharing::EErrCallOnHold || |
|
266 iAvailability == MultimediaSharing::EErrConferenceCall || |
|
267 iAvailability == MultimediaSharing::ESipOptionsNotCapable || |
|
268 iAvailability == MultimediaSharing::ESipOptionsNotSent || |
|
269 iAvailability == MultimediaSharing::EErrNetwork || |
|
270 iAvailability == MultimediaSharing::EManualActivation || |
|
271 iAvailability == MultimediaSharing::EErrConnection || |
|
272 iAvailability == MultimediaSharing::EErrSipRegistration ) |
|
273 { |
|
274 MUS_LOG1( "mus: [AIWPRO] Showing AIW Menu -> iAvailability = %d ",iAvailability ) |
|
275 TInt resourceID = R_MUSAIWPROVIDER_BASIC_CASCADED_SUBMENU ; |
|
276 if ( !FeatureManager::FeatureSupported( KFeatureIdCamera ) ) |
|
277 { |
|
278 MUS_LOG( "mus: [AIWPRO] Camera Not Available" ) |
|
279 resourceID = R_MUSAIWPROVIDER_NOCAMERA_CASCADED_SUBMENU ; |
|
280 } |
|
281 aMenuPane.AddMenuItemsL( aFileName, |
|
282 resourceID, |
|
283 KMusAiwProviderUid, |
|
284 aIndex ); |
|
285 } |
|
286 else |
|
287 { |
|
288 MUS_LOG1( "mus: [AIWPRO] Not Showing AIW Menu -> iAvailability = %d ",iAvailability ) |
|
289 } |
|
290 CleanupStack::PopAndDestroy( manager ); |
|
291 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::NoVariationStartUpL" ) |
|
292 } |
|
293 // ----------------------------------------------------------------------------- |
|
294 // |
|
295 // ----------------------------------------------------------------------------- |
|
296 // |
|
297 void CMusAiwProvider::OperatorVariantStartUpL( TFileName& aFileName, |
|
298 CAiwMenuPane& aMenuPane, |
|
299 TInt aIndex ) |
|
300 { |
|
301 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::OperatorVariantStartUpL" ) |
|
302 |
|
303 CMusManager* manager = CMusManager::NewLC(); |
|
304 iAvailability = manager->AvailabilityL(); |
|
305 |
|
306 // In operator specific mode Multimediasharing Menu items |
|
307 // should be shown in call menu only if iAvailability plugin returns OK |
|
308 if ( iAvailability == MultimediaSharing::EMultimediaSharingAvailable ) |
|
309 { |
|
310 MUS_LOG1( "mus: [AIWPRO] Showing AIW Menu -> iAvailability = %d ", iAvailability ) |
|
311 TInt resourceID = R_MUSAIWPROVIDER_BASIC_CASCADED_SUBMENU ; |
|
312 if ( !FeatureManager::FeatureSupported( KFeatureIdCamera ) ) |
|
313 { |
|
314 MUS_LOG( "mus: [AIWPRO] Camera Not Available" ) |
|
315 resourceID = R_MUSAIWPROVIDER_NOCAMERA_CASCADED_SUBMENU ; |
|
316 } |
|
317 aMenuPane.AddMenuItemsL( aFileName, |
|
318 resourceID, |
|
319 KMusAiwProviderUid, |
|
320 aIndex ); |
|
321 } |
|
322 else |
|
323 { |
|
324 MUS_LOG1( "mus: [AIWPRO] Not Showing AIW Menu -> iAvailability = %d ",iAvailability ) |
|
325 } |
|
326 |
|
327 CleanupStack::PopAndDestroy( manager ); |
|
328 |
|
329 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::OperatorVariantStartUpL" ) |
|
330 } |
|
331 |
|
332 // ----------------------------------------------------------------------------- |
|
333 // |
|
334 // ----------------------------------------------------------------------------- |
|
335 // |
|
336 HBufC* CMusAiwProvider::ErrorNoteTextLC( TInt aError ) |
|
337 { |
|
338 MUS_LOG1( "mus: [AIWPRO] -> CMusAiwProvider::ErrorNoteTextLC( %d )", |
|
339 aError ) |
|
340 |
|
341 TFileName filename( *iResourceFileName ); |
|
342 RFs fs; |
|
343 User::LeaveIfError( fs.Connect() ); |
|
344 CleanupClosePushL( fs ); |
|
345 |
|
346 RResourceFile resourceFile; |
|
347 resourceFile.OpenL( fs, filename ); |
|
348 CleanupClosePushL( resourceFile ); |
|
349 |
|
350 // Fetch error text |
|
351 HBufC8* dlgPrompt8 = ErrorNoteText8L( aError, resourceFile ); |
|
352 CleanupStack::PushL( dlgPrompt8 ); |
|
353 const TUint8* ptr8 = dlgPrompt8->Des().Ptr(); |
|
354 TPtrC ptr16( ( TUint16* ) ptr8, dlgPrompt8->Length()/2 ); |
|
355 HBufC* dlgPrompt = ptr16.AllocL(); |
|
356 |
|
357 // CnvUtfConverter::ConvertToUnicodeFromUtf8L( *dlgPrompt8 ); |
|
358 CleanupStack::PopAndDestroy( dlgPrompt8 ); |
|
359 |
|
360 CleanupStack::PopAndDestroy( &resourceFile ); |
|
361 CleanupStack::PopAndDestroy( &fs ); |
|
362 CleanupStack::PushL( dlgPrompt ); |
|
363 |
|
364 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::ErrorNoteTextLC" ) |
|
365 return dlgPrompt; |
|
366 } |
|
367 |
|
368 |
|
369 // ----------------------------------------------------------------------------- |
|
370 // |
|
371 // ----------------------------------------------------------------------------- |
|
372 // |
|
373 HBufC8* CMusAiwProvider::ErrorNoteText8L( TInt aError, |
|
374 RResourceFile& aResourceFile ) |
|
375 { |
|
376 MUS_LOG1( "mus: [AIWPRO] -> CMusAiwProvider::ErrorNoteTextL( %d )", |
|
377 aError ) |
|
378 |
|
379 HBufC8* errorText = NULL; |
|
380 |
|
381 switch( aError ) |
|
382 { |
|
383 case MultimediaSharing::EErrCallOnHold: |
|
384 { |
|
385 errorText = aResourceFile.AllocReadL( R_MUSAIWPROVIDER_ON_HOLD ); |
|
386 iIsWarning = ETrue ; |
|
387 break; |
|
388 } |
|
389 case MultimediaSharing::EErrNetwork: |
|
390 { |
|
391 errorText = aResourceFile.AllocReadL( |
|
392 R_MUSAIWPROVIDER_NETWORK_INCOMPATIBLE ); |
|
393 iIsWarning = ETrue ; |
|
394 break; |
|
395 } |
|
396 case MultimediaSharing::EErrConferenceCall: |
|
397 { |
|
398 errorText = aResourceFile.AllocReadL( |
|
399 R_MUSAIWPROVIDER_CONFERENCE_CALL ); |
|
400 iIsWarning = ETrue ; |
|
401 break; |
|
402 } |
|
403 case MultimediaSharing::ESipOptionsNotCapable: |
|
404 { |
|
405 errorText = aResourceFile.AllocReadL( |
|
406 R_MUSAIWPROVIDER_RECIPIENT_INCAPABLE ); |
|
407 iIsWarning = ETrue ; |
|
408 break; |
|
409 } |
|
410 case MultimediaSharing::EErrSipRegistration: |
|
411 { |
|
412 errorText = aResourceFile.AllocReadL( R_MUSAIWPROVIDER_NO_REG ); |
|
413 iIsWarning = ETrue ; |
|
414 break; |
|
415 } |
|
416 case MultimediaSharing::EErrConnection: |
|
417 { |
|
418 errorText = aResourceFile.AllocReadL( R_MUSAIWPROVIDER_NO_REG ); |
|
419 iIsWarning = ETrue ; |
|
420 break; |
|
421 } |
|
422 default: |
|
423 { |
|
424 errorText = aResourceFile.AllocReadL( R_MUSAIWPROVIDER_APP_GENERAL ); |
|
425 iIsWarning = EFalse ; |
|
426 break; |
|
427 } |
|
428 } |
|
429 |
|
430 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::ErrorNoteTextL" ) |
|
431 return errorText; |
|
432 } |
|
433 |
|
434 |
|
435 // ----------------------------------------------------------------------------- |
|
436 // Handles a service command invoked by the Handler. |
|
437 // ----------------------------------------------------------------------------- |
|
438 // |
|
439 void CMusAiwProvider::HandleServiceCmdL( |
|
440 const TInt& aCmdId, |
|
441 const CAiwGenericParamList& aInParamList, |
|
442 CAiwGenericParamList& aOutParamList, |
|
443 TUint aCmdOptions, |
|
444 const MAiwNotifyCallback* aCallback ) |
|
445 { |
|
446 HandleMenuCmdL( aCmdId, |
|
447 aInParamList, |
|
448 aOutParamList, |
|
449 aCmdOptions, |
|
450 aCallback ); |
|
451 } |
|
452 |
|
453 |
|
454 // ----------------------------------------------------------------------------- |
|
455 // |
|
456 // ----------------------------------------------------------------------------- |
|
457 // |
|
458 void CMusAiwProvider::ShowErrorNoteL( TInt aError ) |
|
459 { |
|
460 MUS_LOG1( "mus: [AIWPRO] -> CMusAiwProvider::ShowErrorNote( %d )", |
|
461 aError ) |
|
462 HBufC* dlgPrompt = ErrorNoteTextLC( aError ); |
|
463 MUS_LOG_TDESC( "mus: [AIWPRO] Error : ", ( *dlgPrompt ) ) |
|
464 CAknGlobalNote* note = CAknGlobalNote::NewLC(); |
|
465 TRequestStatus status; |
|
466 if( iIsWarning ) |
|
467 { |
|
468 note->ShowNoteL( status,EAknGlobalInformationNote,*dlgPrompt ); |
|
469 } |
|
470 else |
|
471 { |
|
472 note->ShowNoteL( status,EAknGlobalErrorNote,*dlgPrompt ); |
|
473 } |
|
474 User::WaitForRequest( status ); |
|
475 CleanupStack::PopAndDestroy( note ); |
|
476 CleanupStack::PopAndDestroy( dlgPrompt ); |
|
477 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::ShowErrorNote" ) |
|
478 } |
|
479 |
|
480 |
|
481 // ----------------------------------------------------------------------------- |
|
482 // Handles a menu command invoked by the Handler. |
|
483 // ----------------------------------------------------------------------------- |
|
484 // |
|
485 void CMusAiwProvider::HandleMenuCmdL( |
|
486 TInt aMenuCmdId, |
|
487 const CAiwGenericParamList& /*aInParamList*/, |
|
488 CAiwGenericParamList& /*aOutParamList*/, |
|
489 TUint /*aCmdOptions*/, |
|
490 const MAiwNotifyCallback* /*aCallback*/ ) |
|
491 { |
|
492 MUS_LOG( "mus: [AIWPRO] -> CMusAiwProvider::HandleMenuCmdL" ) |
|
493 |
|
494 TInt error( KErrNone ); |
|
495 |
|
496 CMusManager* manager = CMusManager::NewLC(); |
|
497 |
|
498 if ( iAvailability == MultimediaSharing::EManualActivation ) |
|
499 { |
|
500 MUS_LOG( "mus: [AIWPRO] Manual activation" ) |
|
501 TRAP( error, manager->HandleCommandL( MultimediaSharing::ECommandManualActivation )); |
|
502 iAvailability = manager->AvailabilityL(); |
|
503 } |
|
504 |
|
505 switch ( aMenuCmdId ) |
|
506 { |
|
507 case EMusCommandLiveShare: |
|
508 { |
|
509 MUS_LOG( "mus: [AIWPRO] \ |
|
510 EMusCommandLiveShare: Will now attempt to start Mus." ) |
|
511 TRAP( error, manager->StartApplicationL( |
|
512 MultimediaSharing::EMusLiveVideo ) ); |
|
513 break; |
|
514 } |
|
515 case EMusCommandClipShare: |
|
516 { |
|
517 MUS_LOG( "mus: [AIWPRO] \ |
|
518 EMusCommandClipShare: Will now attempt to start Mus." ) |
|
519 TRAP( error, manager->StartApplicationL( |
|
520 MultimediaSharing::EMusClipVideo ) ); |
|
521 break; |
|
522 } |
|
523 case EMusCommandImageShare: |
|
524 { |
|
525 MUS_LOG( "mus: [AIWPRO] \ |
|
526 EMusCommandImageShare: Will now attempt to start Mus." ) |
|
527 TRAP( error, manager->StartApplicationL( |
|
528 MultimediaSharing::EMusStillImage ) ); |
|
529 break; |
|
530 } |
|
531 case EMusCommandContinue: |
|
532 { |
|
533 MUS_LOG( "mus: [AIWPRO] \ |
|
534 EMusCommandContinue: Will now attempt to start/continue Mus." ) |
|
535 TRAP( error, manager->StartApplicationL( |
|
536 MultimediaSharing::EMusContinue ) ); |
|
537 break; |
|
538 } |
|
539 default: |
|
540 { |
|
541 MUS_LOG( "mus: [AIWPRO] \ |
|
542 Unknown command. Leave with KErrArgument" ) |
|
543 User::Leave( KErrArgument ); |
|
544 break; |
|
545 } |
|
546 } |
|
547 |
|
548 CleanupStack::PopAndDestroy( manager ); |
|
549 |
|
550 if( error != KErrNone ) |
|
551 { |
|
552 ShowErrorNoteL( error ); |
|
553 } |
|
554 |
|
555 MUS_LOG( "mus: [AIWPRO] <- CMusAiwProvider::HandleMenuCmdL" ) |
|
556 } |
|
557 |
|
558 // end of file |