86 // ----------------------------------------------------------------------------- |
83 // ----------------------------------------------------------------------------- |
87 // |
84 // |
88 void CPhoneRingingTonePlayerAO::ConstructL() |
85 void CPhoneRingingTonePlayerAO::ConstructL() |
89 { |
86 { |
90 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructL()" ); |
87 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructL()" ); |
91 |
88 |
92 for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ ) |
89 // Connect to the tone server |
93 { |
90 User::LeaveIfError( iToneServer.Connect() ); |
94 User::LeaveIfError( |
|
95 iAsyncDeletePlayers.Append( NULL ) ); |
|
96 } |
|
97 |
91 |
98 // Construct timer. |
92 // Construct timer. |
99 iTimer = CPhoneTimer::NewL(); |
93 iTimer = CPhoneTimer::NewL(); |
100 iTtsDelayTimer = CPhoneTimer::NewL(); |
|
101 |
94 |
102 // Checks if DRM extend security is needed |
95 // Checks if DRM extend security is needed |
103 TInt extSecNeeded = KErrNone; |
96 TInt extSecNeeded = KErrNone; |
104 TInt err = CPhoneCenRepProxy::Instance()->GetInt( |
97 TInt err = CPhoneCenRepProxy::Instance()->GetInt( |
105 KCRUidMusicPlayerFeatures, |
98 KCRUidMusicPlayerFeatures, |
106 KRequireDRMInPlayback, |
99 KRequireDRMInPlayback, |
107 extSecNeeded ); |
100 extSecNeeded ); |
108 |
101 |
109 iExtSecNeeded = ( ( err == KErrNone ) && extSecNeeded ) ? ETrue : EFalse; |
102 iExtSecNeeded = ( ( err == KErrNone ) && extSecNeeded ) ? ETrue : EFalse; |
110 |
103 iToneServer.SetExtendedSecurityNeeded( iExtSecNeeded ); |
111 |
104 |
112 CPhoneCenRepProxy::Instance()->NotifyChangeL( |
105 CPhoneCenRepProxy::Instance()->NotifyChangeL( |
113 KCRUidDRMHelperServer, |
106 KCRUidDRMHelperServer, |
114 KDRMHelperServerNotificationPassive, |
107 KDRMHelperServerNotificationPassive, |
115 this ); |
108 this ); |
116 |
|
117 |
109 |
118 // Check video player configuration. |
110 // Check video player configuration. |
119 iArbitraryVideoScaling = |
111 iArbitraryVideoScaling = |
120 CPhoneCenRepProxy::Instance()->IsTelephonyFeatureSupported( |
112 CPhoneCenRepProxy::Instance()->IsTelephonyFeatureSupported( |
121 KTelephonyLVFlagArbitraryVideoScaling ); |
113 KTelephonyLVFlagArbitraryVideoScaling ); |
122 |
114 |
123 // Construct the default ringing tone |
115 // Construct the default ringing tone |
124 TBuf<KMaxFileName> defaultTone; |
116 TBuf<KMaxFileName> defaultTone; |
125 err = CPhoneCenRepProxy::Instance()->GetString( |
117 err = CPhoneCenRepProxy::Instance()->GetString( |
126 KCRUidProfileEngine, |
118 KCRUidProfileEngine, |
127 KProEngDefaultRingingTone, |
119 KProEngDefaultRingingTone, |
128 defaultTone ); |
120 defaultTone ); |
129 |
121 |
130 if ( err == KErrNone ) |
122 if ( err == KErrNone ) |
131 { |
123 { |
132 iDefaultRingingTone = CPhoneRingingTone::NewL( defaultTone ); |
124 iToneServer.SetDefaultRingingToneL( defaultTone ); |
133 } |
125 } |
134 |
126 |
135 ConstructPlayers(); |
127 // Get maximum tone file size |
136 |
|
137 GetMaxToneFileSizeL( iToneFileSizeLimitKB ); |
128 GetMaxToneFileSizeL( iToneFileSizeLimitKB ); |
|
129 |
|
130 // And set the tone size limit to the tone server too |
|
131 iToneServer.SetToneFileSizeLimit( iToneFileSizeLimitKB ); |
138 } |
132 } |
139 |
133 |
140 // ----------------------------------------------------------------------------- |
134 // ----------------------------------------------------------------------------- |
141 // CPhoneRingingTonePlayerAO::~CPhoneRingingTonePlayerAO |
135 // CPhoneRingingTonePlayerAO::~CPhoneRingingTonePlayerAO |
142 // ----------------------------------------------------------------------------- |
136 // ----------------------------------------------------------------------------- |
143 // |
137 // |
144 CPhoneRingingTonePlayerAO::~CPhoneRingingTonePlayerAO() |
138 CPhoneRingingTonePlayerAO::~CPhoneRingingTonePlayerAO() |
145 { |
139 { |
146 Cancel(); |
140 Cancel(); |
147 |
141 iToneServer.Close(); |
148 iAsyncDeletePlayers.ResetAndDestroy(); |
|
149 iAsyncDeletePlayers.Close(); |
|
150 |
|
151 CleanupPlayers(); |
|
152 |
142 |
153 delete iTimer; |
143 delete iTimer; |
154 delete iTtsDelayTimer; |
|
155 delete iDefaultRingingTone; |
|
156 delete iAudioVideoRingingTone; |
144 delete iAudioVideoRingingTone; |
157 } |
145 } |
158 |
146 |
159 // ----------------------------------------------------------------------------- |
147 // ----------------------------------------------------------------------------- |
160 // CPhoneRingingTonePlayerAO::PlayRingToneL |
148 // CPhoneRingingTonePlayerAO::PlayRingToneL |
233 // |
226 // |
234 void CPhoneRingingTonePlayerAO::PlayAudioRingTone( |
227 void CPhoneRingingTonePlayerAO::PlayAudioRingTone( |
235 TInt aVolume, |
228 TInt aVolume, |
236 TProfileRingingType aRingingType ) |
229 TProfileRingingType aRingingType ) |
237 { |
230 { |
238 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayAudioRingTone()" ); |
231 iToneServer.PlayAudioRingTone( aVolume, aRingingType ); |
239 __PHONELOG2( |
|
240 EBasic, |
|
241 EPhoneUIView, |
|
242 "CPhoneRingingTonePlayerAO::PlayAudioRingTone - aVolume(%d), aRingingType(%d)", |
|
243 aVolume, |
|
244 aRingingType ); |
|
245 |
|
246 if ( !iAudioVideoRingingTone || |
|
247 !CheckAndHandleToneSizeLimit( iAudioVideoRingingTone ) ) |
|
248 { |
|
249 PlayDefaultTone( aVolume, aRingingType ); |
|
250 } |
|
251 else if ( aRingingType == EProfileRingingTypeSilent ) |
|
252 { |
|
253 PlaySilentTone(); |
|
254 } |
|
255 else if ( aRingingType == EProfileRingingTypeBeepOnce ) |
|
256 { |
|
257 BeepOnce( aVolume ); |
|
258 } |
|
259 else |
|
260 { |
|
261 // Construct player for line 1. |
|
262 if ( !iAudioPlayer ) |
|
263 { |
|
264 iAudioPlayer = ConstructTonePlayer( |
|
265 *iAudioVideoRingingTone, |
|
266 EPlayerAudio ); |
|
267 if ( !iTimer->IsActive() ) |
|
268 { |
|
269 // Start timer, since the player is constructed. |
|
270 iTimer->After( KPhoneMaxRingingWaiting, this ); |
|
271 } |
|
272 } |
|
273 |
|
274 // Start playing. |
|
275 if ( !iAudioPlayer ) |
|
276 { |
|
277 iTimer->Cancel(); |
|
278 PlayDefaultTone( aVolume, aRingingType ); |
|
279 } |
|
280 else |
|
281 { |
|
282 __PHONELOG( |
|
283 EBasic, |
|
284 EPhoneUIView, |
|
285 "CPhoneRingingTonePlayerAO::PlayAudioRingTone - Start playing audio" ); |
|
286 iVolume = aVolume; |
|
287 iRingingType = aRingingType; |
|
288 AddTtsPlaybackIfNeeded( aRingingType ); |
|
289 iTonePlayingStatus = EAudioTonePlaying; |
|
290 iAudioPlayer->Play( |
|
291 ConvertRingingType( aRingingType ), |
|
292 aVolume, |
|
293 iTtsToneToBePlayed ); |
|
294 } |
|
295 } |
|
296 } |
232 } |
297 |
233 |
298 // ----------------------------------------------------------------------------- |
234 // ----------------------------------------------------------------------------- |
299 // CPhoneRingingTonePlayerAO::BeepOnce |
235 // CPhoneRingingTonePlayerAO::BeepOnce |
300 // ----------------------------------------------------------------------------- |
236 // ----------------------------------------------------------------------------- |
301 // |
237 // |
302 void CPhoneRingingTonePlayerAO::BeepOnce( TInt aVolume ) |
238 void CPhoneRingingTonePlayerAO::BeepOnce( TInt aVolume ) |
303 { |
239 { |
304 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::BeepOnce()" ); |
240 iToneServer.BeepOnce( aVolume ); |
305 __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::BeepOnce - aVolume(%d)", |
|
306 aVolume ); |
|
307 |
|
308 if ( !iBeepOncePlayer ) |
|
309 { |
|
310 ConstructSequencePlayer( EPlayerBeepOnce ); |
|
311 } |
|
312 |
|
313 if ( iBeepOncePlayer ) |
|
314 { |
|
315 __PHONELOG( |
|
316 EBasic, |
|
317 EPhoneUIView, |
|
318 "CPhoneRingingTonePlayerAO::BeepOnce - Play" ); |
|
319 iTonePlayingStatus = EBeepOnce; |
|
320 iBeepOncePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce, |
|
321 aVolume, EFalse ); |
|
322 } |
|
323 } |
241 } |
324 |
242 |
325 // ----------------------------------------------------------------------------- |
243 // ----------------------------------------------------------------------------- |
326 // CPhoneRingingTonePlayerAO::PlaySilentTone |
244 // CPhoneRingingTonePlayerAO::PlaySilentTone |
327 // ----------------------------------------------------------------------------- |
245 // ----------------------------------------------------------------------------- |
328 // |
246 // |
329 void CPhoneRingingTonePlayerAO::PlaySilentTone() |
247 void CPhoneRingingTonePlayerAO::PlaySilentTone() |
330 { |
248 { |
331 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlaySilentTone()" ); |
249 iToneServer.PlaySilentTone(); |
332 |
|
333 if ( !iSilentPlayer ) |
|
334 { |
|
335 ConstructSequencePlayer( EPlayerSilent ); |
|
336 } |
|
337 |
|
338 __ASSERT_DEBUG( iSilentPlayer, Panic( EPhoneViewGeneralError ) ); |
|
339 |
|
340 if ( iSilentPlayer ) |
|
341 { |
|
342 __PHONELOG( |
|
343 EBasic, |
|
344 EPhoneUIView, |
|
345 "CPhoneRingingTonePlayerAO::PlaySilentTone - play" ); |
|
346 iTonePlayingStatus = ESilentTonePlaying; |
|
347 iSilentPlayer->Play( CPhoneAudioPlayer::ETypeRinging, 0, EFalse ); |
|
348 } |
|
349 } |
250 } |
350 |
251 |
351 // ----------------------------------------------------------------------------- |
252 // ----------------------------------------------------------------------------- |
352 // CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone |
253 // CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone |
353 // ----------------------------------------------------------------------------- |
254 // ----------------------------------------------------------------------------- |
354 // |
255 // |
355 void CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone() |
256 void CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone() |
356 { |
257 { |
357 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayUnsecureVoIPTone()" ); |
258 iToneServer.PlayUnsecureVoIPTone(); |
358 if ( !iUnsecureVoIPTonePlayer ) |
|
359 { |
|
360 ConstructSequencePlayer( EPlayerUnsecureVoIP ); |
|
361 } |
|
362 __ASSERT_DEBUG( iUnsecureVoIPTonePlayer, Panic( EPhoneViewGeneralError ) ); |
|
363 |
|
364 if ( iUnsecureVoIPTonePlayer ) |
|
365 { |
|
366 iTonePlayingStatus = EUnsecureVoIPTonePlaying; |
|
367 iUnsecureVoIPTonePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce, |
|
368 KPhoneDefaultVolume, EFalse ); |
|
369 } |
|
370 } |
259 } |
371 |
260 |
372 // ----------------------------------------------------------------------------- |
261 // ----------------------------------------------------------------------------- |
373 // CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer |
262 // CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer |
374 // ----------------------------------------------------------------------------- |
263 // ----------------------------------------------------------------------------- |
375 // |
264 // |
376 void CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer() |
265 void CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer() |
377 { |
266 { |
378 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer()" ); |
267 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::MuteRingingToneOnAnswer()" ); |
379 |
268 |
380 if ( iVideoPlayer && |
269 if ( iVideoPlayer && |
381 ( iTonePlayingStatus == EVideoTonePlaying || |
270 ( iTonePlayingStatus == EVideoTonePlaying || |
382 iTonePlayingStatus == EPersonalVideoTonePlaying ) ) |
271 iTonePlayingStatus == EPersonalVideoTonePlaying ) ) |
383 { |
272 { |
384 // Mute the video audio |
273 // Mute the video audio |
385 iVideoPlayer->MuteVideoRingTone(); |
274 iVideoPlayer->MuteVideoRingTone(); |
386 iTonePlayingStatus = ESilentVideoTonePlaying; |
275 iTonePlayingStatus = ESilentVideoTonePlaying; |
387 iVolume = 0; |
276 iVolume = 0; |
388 } |
277 } |
389 else |
278 else if ( iTonePlayingStatus != ESilentVideoTonePlaying ) |
390 { |
279 { |
391 DoMuteRingingTone(); |
280 iToneServer.MuteRingingTone(); |
392 } |
281 } |
393 } |
282 } |
394 |
283 |
395 // ----------------------------------------------------------------------------- |
284 // ----------------------------------------------------------------------------- |
396 // CPhoneRingingTonePlayerAO::MuteRingingTone |
285 // CPhoneRingingTonePlayerAO::MuteRingingTone |
397 // ----------------------------------------------------------------------------- |
286 // ----------------------------------------------------------------------------- |
398 // |
287 // |
399 void CPhoneRingingTonePlayerAO::MuteRingingTone() |
288 void CPhoneRingingTonePlayerAO::MuteRingingTone() |
400 { |
289 { |
401 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::MuteRingingTone()" ); |
290 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::MuteRingingTone()" ); |
402 |
291 |
403 if ( iVideoPlayer && |
292 if ( iVideoPlayer && |
404 ( iTonePlayingStatus == EVideoTonePlaying || |
293 ( iTonePlayingStatus == EVideoTonePlaying || |
405 iTonePlayingStatus == EPersonalVideoTonePlaying ) ) |
294 iTonePlayingStatus == EPersonalVideoTonePlaying ) ) |
406 { |
295 { |
407 // Mute the video audio |
296 // Mute the video audio |
408 iVideoPlayer->MuteVideoRingTone(); |
297 iVideoPlayer->MuteVideoRingTone(); |
409 iTonePlayingStatus = ESilentVideoTonePlaying; |
298 iTonePlayingStatus = ESilentVideoTonePlaying; |
410 iVolume = 0; |
299 iVolume = 0; |
411 } |
300 } |
412 else |
301 else if ( iTonePlayingStatus != ESilentVideoTonePlaying ) |
413 { |
302 { |
414 StopPlaying(); |
303 StopPlaying(); |
415 } |
304 } |
416 } |
305 } |
417 |
306 |
421 // |
310 // |
422 void CPhoneRingingTonePlayerAO::StopPlaying() |
311 void CPhoneRingingTonePlayerAO::StopPlaying() |
423 { |
312 { |
424 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::StopPlaying()" ); |
313 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::StopPlaying()" ); |
425 |
314 |
426 iTtsToneToBePlayed = EFalse; |
315 // Stop all playback |
427 iTTsTimeOutCounter = 0; |
316 |
428 iTtsDelayTimer->Cancel(); |
317 iToneServer.StopPlaying(); |
429 if ( iTtsPlayer ) |
318 |
430 { |
319 if ( iVideoPlayer ) |
431 iTtsPlayer->StopPlaying(); |
320 { |
432 delete iTtsPlayer; |
321 iVideoPlayer->StopVideoRingTone(); |
433 iTtsPlayer = NULL; |
322 } |
434 } |
323 |
435 iTimer->Cancel(); |
324 iTimer->Cancel(); |
436 |
|
437 switch( iTonePlayingStatus ) |
|
438 { |
|
439 case EAudioTonePlaying: |
|
440 if( iAudioPlayer ) |
|
441 { |
|
442 // Commented stopping out, since with this, the screen is jammed |
|
443 // when REComSession::FinalClose() is reached in |
|
444 // CPhoneAudioPlayer's destructor. |
|
445 // Audio player is stopped anyway in its destructor. |
|
446 // Fixes EKKI-7WYG2G and JKAN-7XNGQU. |
|
447 // iAudioPlayer->StopPlaying(); |
|
448 delete iAudioPlayer; |
|
449 iAudioPlayer = NULL; |
|
450 } |
|
451 break; |
|
452 case EDefaultTonePlaying: |
|
453 if ( iDefaultPlayer ) |
|
454 { |
|
455 iDefaultPlayer->StopPlaying(); |
|
456 delete iDefaultPlayer; |
|
457 iDefaultPlayer = NULL; |
|
458 } |
|
459 break; |
|
460 case EBeepOnce: |
|
461 if( iBeepOncePlayer ) |
|
462 { |
|
463 iBeepOncePlayer->StopPlaying(); |
|
464 delete iBeepOncePlayer; |
|
465 iBeepOncePlayer = NULL; |
|
466 } |
|
467 break; |
|
468 case EBackupTonePlaying: |
|
469 if( iBackupPlayer ) |
|
470 { |
|
471 iBackupPlayer->StopPlaying(); |
|
472 } |
|
473 break; |
|
474 case ESilentTonePlaying: |
|
475 if( iSilentPlayer ) |
|
476 { |
|
477 iSilentPlayer->StopPlaying(); |
|
478 delete iSilentPlayer; |
|
479 iSilentPlayer = NULL; |
|
480 } |
|
481 break; |
|
482 case EUnsecureVoIPTonePlaying: |
|
483 if( iUnsecureVoIPTonePlayer ) |
|
484 { |
|
485 iUnsecureVoIPTonePlayer->StopPlaying(); |
|
486 delete iUnsecureVoIPTonePlayer; |
|
487 iUnsecureVoIPTonePlayer = NULL; |
|
488 } |
|
489 break; |
|
490 case EVideoTonePlaying: // video ringing tone |
|
491 case EPersonalVideoTonePlaying: |
|
492 case ESilentVideoTonePlaying: |
|
493 if ( iBeepOncePlayer != NULL ) |
|
494 { |
|
495 iBeepOncePlayer->StopPlaying(); |
|
496 delete iBeepOncePlayer; |
|
497 iBeepOncePlayer = NULL; |
|
498 } |
|
499 |
|
500 if ( iSilentPlayer != NULL ) |
|
501 { |
|
502 iSilentPlayer->StopPlaying(); |
|
503 delete iSilentPlayer; |
|
504 iSilentPlayer = NULL; |
|
505 } |
|
506 if ( iVideoPlayer ) |
|
507 { |
|
508 iVideoPlayer->StopVideoRingTone(); |
|
509 } |
|
510 if ( iAudioVideoRingingTone ) |
|
511 { |
|
512 delete iAudioVideoRingingTone; |
|
513 iAudioVideoRingingTone = NULL; |
|
514 } |
|
515 break; |
|
516 case EIdle: |
|
517 // Do nothing here. |
|
518 return; |
|
519 default: |
|
520 Panic( EPhoneViewCaseNotHandled ); |
|
521 break; |
|
522 } |
|
523 |
325 |
524 iTonePlayingStatus = EIdle; |
326 iTonePlayingStatus = EIdle; |
525 } |
327 } |
526 |
328 |
527 // ----------------------------------------------------------------------------- |
329 // ----------------------------------------------------------------------------- |
531 void CPhoneRingingTonePlayerAO::PlayTtsTone( |
333 void CPhoneRingingTonePlayerAO::PlayTtsTone( |
532 const TDesC& aTextToSay, |
334 const TDesC& aTextToSay, |
533 TInt aVolume, |
335 TInt aVolume, |
534 TProfileRingingType aRingingType ) |
336 TProfileRingingType aRingingType ) |
535 { |
337 { |
536 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayTtsTone()" ); |
338 iToneServer.PlayTtsTone( aTextToSay, aVolume, aRingingType ); |
537 __PHONELOG2( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayTtsTone - aVolume(%d), aRingingType(%d)", |
|
538 aVolume, aRingingType ); |
|
539 |
|
540 if ( iTtsPlayer ) |
|
541 { |
|
542 delete iTtsPlayer; |
|
543 iTtsPlayer = NULL; |
|
544 } |
|
545 |
|
546 //Set ringingtype for Tts. |
|
547 iTtsRingingType = aRingingType; |
|
548 iTtsVolume = aVolume; |
|
549 |
|
550 // TTS should be a bit louder, than main component. |
|
551 // No need to check for overflows, they are handled in SET_PHONE_VOLUME macro. |
|
552 |
|
553 TPtrC ttsHeader( KPhoneTtsHeader ); |
|
554 HBufC* preparedString = |
|
555 HBufC::New( aTextToSay.Length() + ttsHeader.Length() ); |
|
556 |
|
557 if ( preparedString ) |
|
558 { |
|
559 TPtr pPreparedString = preparedString->Des(); |
|
560 pPreparedString.Append( ttsHeader ); |
|
561 pPreparedString.Append( aTextToSay ); |
|
562 |
|
563 __PHONELOG1( |
|
564 EBasic, |
|
565 EPhoneUIView, |
|
566 "CPhoneRingingTonePlayerAO::PlayTtsTone - about to say %S", |
|
567 &pPreparedString ); |
|
568 |
|
569 TRAPD( |
|
570 error, |
|
571 iTtsPlayer = CPhoneAudioPlayer::NewTtsL( |
|
572 *preparedString, |
|
573 KAudioPriorityPhoneCall, |
|
574 KAudioPrefTextToSpeechCallHardCoded, |
|
575 *this, |
|
576 EPlayerTts ) ); |
|
577 if( error == KErrNone ) |
|
578 { |
|
579 // To be played when default or personal tone will be played |
|
580 iTtsToneToBePlayed = ETrue; |
|
581 } |
|
582 __PHONELOG2( |
|
583 EBasic, |
|
584 EPhoneUIView, |
|
585 "CPhoneRingingTonePlayerAO::PlayTtsTone - error(%d), iTtsPhoneToBePlayed(%d)", |
|
586 error, |
|
587 iTtsToneToBePlayed ); |
|
588 |
|
589 delete preparedString; |
|
590 } |
|
591 } |
|
592 |
|
593 // ----------------------------------------------------------------------------- |
|
594 // CPhoneRingingTonePlayerAO::HandleAudioPlayerError |
|
595 // ----------------------------------------------------------------------------- |
|
596 // |
|
597 void CPhoneRingingTonePlayerAO::HandleAudioPlayerError( |
|
598 TPhoneAudioPlayerErrorEvent /*aEvent*/, |
|
599 TInt aError, |
|
600 TInt /*aId*/ ) |
|
601 { |
|
602 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleAudioPlayerError()" ); |
|
603 // This is called from CPhoneAudioPlayer - we do not |
|
604 // want to delete instances from which this method |
|
605 // is called. |
|
606 |
|
607 __PHONELOG1( EBasic, |
|
608 EPhoneUIView, |
|
609 "CPhoneRingingTonePlayerAO::HandleAudioPlayerError - error (%d)", |
|
610 aError ); |
|
611 |
|
612 const TBool deleteAll = ( aError == KErrServerTerminated ); |
|
613 |
|
614 if ( deleteAll ) |
|
615 { |
|
616 // KErrServerTerminated is considered as fatal error. So we |
|
617 // need to delete everything. |
|
618 |
|
619 for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ ) |
|
620 { |
|
621 DeletePlayerAsync( static_cast< TPlayerId >( i ) ); |
|
622 } |
|
623 |
|
624 // Now all member audio players point to NULL, except |
|
625 // those players in iAsyncDeletePlayers. Recreate |
|
626 // players. |
|
627 |
|
628 ConstructPlayers(); // Ignore error code. |
|
629 } |
|
630 |
|
631 iTimer->Cancel(); |
|
632 DoHandlePlayerError( !deleteAll, EFalse ); |
|
633 } |
|
634 |
|
635 // ----------------------------------------------------------------------------- |
|
636 // CPhoneRingingTonePlayerAO::HandleAudioPlayerInitComplete |
|
637 // ----------------------------------------------------------------------------- |
|
638 // |
|
639 void CPhoneRingingTonePlayerAO::HandleAudioPlayerInitComplete( TInt aId ) |
|
640 { |
|
641 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleAudioPlayerInitComplete()" ); |
|
642 // This is called from CPhoneAudioPlayer - we do not |
|
643 // want to delete instances from which this method |
|
644 // is called. |
|
645 |
|
646 if ( iTonePlayingStatus == EAudioTonePlaying && aId == EPlayerAudio || |
|
647 iTonePlayingStatus == EDefaultTonePlaying && aId == EPlayerDefault ) |
|
648 { |
|
649 iTimer->Cancel(); |
|
650 } |
|
651 |
|
652 if( iTtsToneToBePlayed && ( aId != EPlayerTts ) ) |
|
653 { |
|
654 // Start TTS timer just before "normal ringtone component" starts |
|
655 // playing, i.e. after init completed. |
|
656 if ( iTtsDelayIndex < iTtsDelaysCount ) |
|
657 { |
|
658 if ( !iTtsDelayTimer->IsActive() ) |
|
659 { |
|
660 // There are TTS iterations to be played yet. |
|
661 iTtsDelayTimer->After( |
|
662 KPhoneTtsDelays[iTtsDelayIndex], |
|
663 TCallBack( HandleTtsDelayTimeout, this ) ); |
|
664 } |
|
665 } |
|
666 } |
|
667 } |
|
668 |
|
669 // ----------------------------------------------------------------------------- |
|
670 // CPhoneRingingTonePlayerAO::HandlePlayingComplete |
|
671 // ----------------------------------------------------------------------------- |
|
672 // |
|
673 void CPhoneRingingTonePlayerAO::HandlePlayingComplete( TInt aId ) |
|
674 { |
|
675 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete()" ); |
|
676 // This is called from CPhoneAudioPlayer - we do not |
|
677 // want to delete instances from which this method |
|
678 // is called. |
|
679 |
|
680 __PHONELOG2( |
|
681 EBasic, |
|
682 EPhoneUIView, |
|
683 "CPhoneRingingTonePlayerAO::HandlePlayingComplete - aId(%d), iRingingType(%d)", |
|
684 aId, |
|
685 iRingingType ); |
|
686 __PHONELOG2( |
|
687 EBasic, |
|
688 EPhoneUIView, |
|
689 "CPhoneRingingTonePlayerAO::HandlePlayingComplete - iTtsToneToBePlayed(%d), iTtsDelayIndex(%d)", |
|
690 iTtsToneToBePlayed, |
|
691 iTtsDelayIndex ); |
|
692 |
|
693 if ( aId == EPlayerTts ) |
|
694 { |
|
695 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - resuming after TTS" ); |
|
696 |
|
697 // TTS playing complete, normal tone player should volume up. |
|
698 if ( ( iTtsToneToBePlayed ) && ( ++iTtsDelayIndex < iTtsDelaysCount ) ) |
|
699 { |
|
700 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - resuming after TTS first time" ); |
|
701 //Callers name is said once. increase tone player volume. |
|
702 SolveNewVolumeAndRamptime( ESaidOnce ); |
|
703 |
|
704 if ( !iTtsDelayTimer->IsActive() ) |
|
705 { |
|
706 // There are TTS iterations to be played yet. |
|
707 iTtsDelayTimer->After( KPhoneTtsDelays[iTtsDelayIndex], |
|
708 TCallBack( HandleTtsDelayTimeout,this ) ); |
|
709 } |
|
710 } |
|
711 else |
|
712 { |
|
713 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - resuming after TTS second time" ); |
|
714 SolveNewVolumeAndRamptime( ESaidTwice ); |
|
715 } |
|
716 |
|
717 // No further processing. All TTS player-related events are not |
|
718 // "real" ringtone playing completions. |
|
719 return; |
|
720 } |
|
721 //Case: RingintonePlayer has completed playing with following set: ring once and |
|
722 // TTS is activated |
|
723 else if ( iRingingType == EProfileRingingTypeRingingOnce && |
|
724 iTtsToneToBePlayed ) |
|
725 { |
|
726 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - ring once and TTS" ); |
|
727 if ( iTtsDelayIndex < iTtsDelaysCount ) |
|
728 { |
|
729 ReStartRingingTonePlayer(); |
|
730 //Do not destroy player yet. Return. |
|
731 return; |
|
732 } |
|
733 } |
|
734 //Case: RingintonePlayer has completed playing with following set: ringing |
|
735 //and TTS is activated. We need to restart ringintoneplayer and new TTS |
|
736 //iterations are required. |
|
737 else if ( iRingingType == EProfileRingingTypeRinging && iTtsToneToBePlayed ) |
|
738 { |
|
739 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - ringing and TTS" ); |
|
740 if ( iTtsDelayIndex == iTtsDelaysCount ) |
|
741 { |
|
742 //Case: Ringingtype is EProfileRingingTypeRinging. New TTS |
|
743 //iterations are required. |
|
744 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - need to restart TTS sequence" ); |
|
745 //TTS has completed its iterations,set index to zero. |
|
746 iTtsDelayIndex = 0; |
|
747 if ( !iTtsDelayTimer->IsActive() ) |
|
748 { |
|
749 //Restart TTS sequence |
|
750 iTtsDelayTimer->After( |
|
751 KPhoneTtsDelays[iTtsDelayIndex], |
|
752 TCallBack( HandleTtsDelayTimeout, this ) ); |
|
753 } |
|
754 } |
|
755 |
|
756 ReStartRingingTonePlayer(); |
|
757 //Do not destroy player yet. Return |
|
758 return; |
|
759 } |
|
760 |
|
761 __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::HandlePlayingComplete - delete player - iTonePlayingStatus(%d)", |
|
762 iTonePlayingStatus ); |
|
763 switch( iTonePlayingStatus ) |
|
764 { |
|
765 case EAudioTonePlaying: |
|
766 DeletePlayerAsync( EPlayerAudio ); |
|
767 iAudioPlayer = NULL; |
|
768 break; |
|
769 |
|
770 case EDefaultTonePlaying: |
|
771 DeletePlayerAsync( EPlayerDefault ); |
|
772 iDefaultPlayer = NULL; |
|
773 break; |
|
774 |
|
775 case ESilentTonePlaying: |
|
776 DeletePlayerAsync( EPlayerSilent ); |
|
777 iSilentPlayer = NULL; |
|
778 break; |
|
779 |
|
780 case EUnsecureVoIPTonePlaying: |
|
781 DeletePlayerAsync( EPlayerUnsecureVoIP ); |
|
782 iUnsecureVoIPTonePlayer = NULL; |
|
783 break; |
|
784 |
|
785 case EBeepOnce: |
|
786 DeletePlayerAsync( EPlayerBeepOnce ); |
|
787 iBeepOncePlayer = NULL; |
|
788 break; |
|
789 |
|
790 case EVideoTonePlaying: |
|
791 case EPersonalVideoTonePlaying: |
|
792 DeletePlayerAsync( EPlayerBeepOnce ); |
|
793 iBeepOncePlayer = NULL; |
|
794 return; // beep once + video |
|
795 |
|
796 case EBackupTonePlaying: |
|
797 break; |
|
798 |
|
799 default: |
|
800 Panic( EPhoneViewCaseNotHandled ); |
|
801 break; |
|
802 } |
|
803 |
|
804 iTonePlayingStatus = EIdle; |
|
805 } |
339 } |
806 |
340 |
807 // ----------------------------------------------------------------------------- |
341 // ----------------------------------------------------------------------------- |
808 // CPhoneRingingTonePlayerAO::HandleTimeOutL |
342 // CPhoneRingingTonePlayerAO::HandleTimeOutL |
809 // ----------------------------------------------------------------------------- |
343 // ----------------------------------------------------------------------------- |
812 { |
346 { |
813 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleTimeOutL()" ); |
347 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleTimeOutL()" ); |
814 |
348 |
815 // Guarding timer for startup has expired |
349 // Guarding timer for startup has expired |
816 if ( iTonePlayingStatus == EVideoTonePlaying || |
350 if ( iTonePlayingStatus == EVideoTonePlaying || |
817 iTonePlayingStatus == ESilentVideoTonePlaying || |
351 iTonePlayingStatus == ESilentVideoTonePlaying || |
818 iTonePlayingStatus == EPersonalVideoTonePlaying ) |
352 iTonePlayingStatus == EPersonalVideoTonePlaying ) |
819 { |
353 { |
820 iVideoPlayer->CancelVideoRingTone(); // close video ringtone display |
354 iVideoPlayer->CancelVideoRingTone(); // close video ringtone display |
821 PlayDefaultTone( iVolume, iRingingType ); |
355 PlayDefaultTone( iVolume, iRingingType ); |
822 } |
|
823 else |
|
824 { |
|
825 // Start new audio player synchronously. |
|
826 DoHandlePlayerError( ETrue, ETrue ); |
|
827 } |
|
828 |
|
829 } |
|
830 |
|
831 // ----------------------------------------------------------------------------- |
|
832 // CPhoneRingingTonePlayerAO::DoHandlePlayerError |
|
833 // ----------------------------------------------------------------------------- |
|
834 // |
|
835 void CPhoneRingingTonePlayerAO::DoHandlePlayerError( |
|
836 TBool aDelete, |
|
837 TBool aSync ) |
|
838 { |
|
839 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandlePlayerError()" ); |
|
840 switch ( iTonePlayingStatus ) |
|
841 { |
|
842 case EAudioTonePlaying: |
|
843 if ( aDelete ) |
|
844 { |
|
845 if ( aSync ) |
|
846 { |
|
847 delete iAudioPlayer; |
|
848 } |
|
849 else |
|
850 { |
|
851 DeletePlayerAsync( EPlayerAudio ); |
|
852 } |
|
853 |
|
854 iAudioPlayer = NULL; |
|
855 } |
|
856 |
|
857 #ifdef __WINS__ |
|
858 PlayAudioRingTone( iVolume, iRingingType ); |
|
859 iTonePlayingStatus = EDefaultTonePlaying; |
|
860 #else |
|
861 PlayDefaultTone( iVolume, iRingingType ); |
|
862 #endif |
|
863 break; |
|
864 case EDefaultTonePlaying: |
|
865 if ( aDelete ) |
|
866 { |
|
867 if ( aSync ) |
|
868 { |
|
869 delete iDefaultPlayer; |
|
870 } |
|
871 else |
|
872 { |
|
873 DeletePlayerAsync( EPlayerDefault ); |
|
874 } |
|
875 |
|
876 iDefaultPlayer = NULL; |
|
877 } |
|
878 |
|
879 PlayBackupTone( iVolume, iRingingType ); |
|
880 break; |
|
881 case ESilentTonePlaying: |
|
882 case EBeepOnce: |
|
883 case EBackupTonePlaying: |
|
884 break; |
|
885 default: |
|
886 break; |
|
887 } |
356 } |
888 } |
357 } |
889 |
358 |
890 // ----------------------------------------------------------------------------- |
359 // ----------------------------------------------------------------------------- |
891 // CPhoneRingingTonePlayerAO::PlayDefaultTone |
360 // CPhoneRingingTonePlayerAO::PlayDefaultTone |
893 // |
362 // |
894 void CPhoneRingingTonePlayerAO::PlayDefaultTone( |
363 void CPhoneRingingTonePlayerAO::PlayDefaultTone( |
895 TInt aVolume, |
364 TInt aVolume, |
896 TProfileRingingType aRingingType ) |
365 TProfileRingingType aRingingType ) |
897 { |
366 { |
898 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone()" ); |
367 iToneServer.PlayDefaultTone( aVolume, aRingingType ); |
899 |
|
900 if( aRingingType == EProfileRingingTypeSilent || |
|
901 aRingingType == EProfileRingingTypeBeepOnce ) |
|
902 { |
|
903 return; |
|
904 } |
|
905 |
|
906 if ( !iDefaultRingingTone ) |
|
907 { |
|
908 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone - default tone does not exist, play backup..." ); |
|
909 PlayBackupTone( aVolume, aRingingType ); |
|
910 return; |
|
911 } |
|
912 |
|
913 // Construct player. |
|
914 if ( !iDefaultPlayer ) |
|
915 { |
|
916 iDefaultPlayer = ConstructTonePlayer( |
|
917 *iDefaultRingingTone, |
|
918 EPlayerDefault ); |
|
919 if ( !iTimer->IsActive() ) |
|
920 { |
|
921 iTimer->After( KPhoneMaxRingingWaiting, this ); |
|
922 } |
|
923 } |
|
924 |
|
925 // Start playing. |
|
926 if ( !iDefaultPlayer ) |
|
927 { |
|
928 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone - player not constructed, play backup..." ); |
|
929 iTimer->Cancel(); |
|
930 PlayBackupTone( aVolume, aRingingType ); |
|
931 } |
|
932 else |
|
933 { |
|
934 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayDefaultTone - play" ); |
|
935 iVolume = aVolume; |
|
936 iRingingType = aRingingType; |
|
937 iTonePlayingStatus = EDefaultTonePlaying; |
|
938 iDefaultPlayer->Play( |
|
939 ConvertRingingType( aRingingType ), aVolume, iTtsToneToBePlayed ); |
|
940 } |
|
941 |
|
942 } |
368 } |
943 |
369 |
944 // ----------------------------------------------------------------------------- |
370 // ----------------------------------------------------------------------------- |
945 // CPhoneRingingTonePlayerAO::PlayBackupTone |
371 // CPhoneRingingTonePlayerAO::PlayBackupTone |
946 // ----------------------------------------------------------------------------- |
372 // ----------------------------------------------------------------------------- |
947 // |
373 // |
948 void CPhoneRingingTonePlayerAO::PlayBackupTone( |
374 void CPhoneRingingTonePlayerAO::PlayBackupTone( |
949 TInt aVolume, |
375 TInt aVolume, |
950 TProfileRingingType aRingingType ) |
376 TProfileRingingType aRingingType ) |
951 { |
377 { |
952 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayBackupTone()" ); |
378 iToneServer.PlayBackupTone( aVolume, aRingingType ); |
953 __ASSERT_DEBUG( iBackupPlayer, Panic( EPhoneViewGeneralError ) ); |
379 } |
954 |
380 |
955 if ( !iBackupPlayer ) |
|
956 { |
|
957 ConstructPlayers(); |
|
958 } |
|
959 |
|
960 if ( iBackupPlayer ) |
|
961 { |
|
962 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::PlayBackupTone - play" ); |
|
963 iTonePlayingStatus = EBackupTonePlaying; |
|
964 |
|
965 // Cease playing text-to-speech, if necessary |
|
966 iTtsToneToBePlayed = EFalse; |
|
967 iTTsTimeOutCounter = 0; |
|
968 iTtsDelayTimer->Cancel(); |
|
969 if ( iTtsPlayer ) |
|
970 { |
|
971 iTtsPlayer->StopPlaying(); |
|
972 delete iTtsPlayer; |
|
973 iTtsPlayer = NULL; |
|
974 } |
|
975 |
|
976 iBackupPlayer->Play( |
|
977 ConvertRingingType( aRingingType ), aVolume, EFalse ); |
|
978 } |
|
979 } |
|
980 |
|
981 // ----------------------------------------------------------------------------- |
|
982 // CPhoneRingingTonePlayerAO::ConstructTonePlayer |
|
983 // ----------------------------------------------------------------------------- |
|
984 // |
|
985 CPhoneAudioPlayer* CPhoneRingingTonePlayerAO::ConstructTonePlayer( |
|
986 const CPhoneRingingTone& aRingingTone, |
|
987 TInt aId ) |
|
988 { |
|
989 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructTonePlayer()" ); |
|
990 return CPhoneAudioPlayer::New( |
|
991 aRingingTone, |
|
992 KAudioPriorityPhoneCall, |
|
993 KAudioPrefIncomingCall, |
|
994 *this, |
|
995 aId, |
|
996 iMdaServer, |
|
997 aId == EPlayerDefault ? EFalse : iExtSecNeeded ); |
|
998 } |
|
999 |
|
1000 // ----------------------------------------------------------------------------- |
|
1001 // CPhoneRingingTonePlayerAO::ConvertRingingType |
|
1002 // ----------------------------------------------------------------------------- |
|
1003 // |
|
1004 CPhoneAudioPlayer::TRingingType CPhoneRingingTonePlayerAO::ConvertRingingType( |
|
1005 TProfileRingingType aRingingType ) |
|
1006 { |
|
1007 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConvertRingingType()" ); |
|
1008 |
|
1009 CPhoneAudioPlayer::TRingingType ringingType = |
|
1010 CPhoneAudioPlayer::ETypeRinging; |
|
1011 switch ( aRingingType ) |
|
1012 { |
|
1013 case EProfileRingingTypeRinging: |
|
1014 ringingType = CPhoneAudioPlayer::ETypeRinging; |
|
1015 break; |
|
1016 |
|
1017 case EProfileRingingTypeAscending: |
|
1018 ringingType = CPhoneAudioPlayer::ETypeAscending; |
|
1019 break; |
|
1020 |
|
1021 case EProfileRingingTypeRingingOnce: |
|
1022 ringingType = CPhoneAudioPlayer::ETypeRingingOnce; |
|
1023 break; |
|
1024 |
|
1025 default: |
|
1026 break; |
|
1027 } |
|
1028 return ringingType; |
|
1029 } |
|
1030 |
381 |
1031 // ----------------------------------------------------------------------------- |
382 // ----------------------------------------------------------------------------- |
1032 // CPhoneRingingTonePlayerAO::ConvertVideoRingingType |
383 // CPhoneRingingTonePlayerAO::ConvertVideoRingingType |
1033 // ----------------------------------------------------------------------------- |
384 // ----------------------------------------------------------------------------- |
1034 // |
385 // |
1035 MPhoneVideoPlayer::TPlayMode CPhoneRingingTonePlayerAO::ConvertVideoRingingType( |
386 MPhoneVideoPlayer::TPlayMode CPhoneRingingTonePlayerAO::ConvertVideoRingingType( |
1036 TProfileRingingType aRingingType ) |
387 TProfileRingingType aRingingType ) |
1037 { |
388 { |
1038 MPhoneVideoPlayer::TPlayMode playMode; |
389 MPhoneVideoPlayer::TPlayMode playMode; |
1039 |
390 |
1040 switch ( aRingingType ) |
391 switch ( aRingingType ) |
1041 { |
392 { |
1042 case EProfileRingingTypeAscending: |
393 case EProfileRingingTypeAscending: |
1043 playMode = MPhoneVideoPlayer::EPlayAscending; |
394 playMode = MPhoneVideoPlayer::EPlayAscending; |
1044 break; |
395 break; |
1048 case EProfileRingingTypeRinging: |
399 case EProfileRingingTypeRinging: |
1049 default: |
400 default: |
1050 playMode = MPhoneVideoPlayer::EPlayInLoop; |
401 playMode = MPhoneVideoPlayer::EPlayInLoop; |
1051 break; |
402 break; |
1052 } |
403 } |
1053 |
404 |
1054 return playMode; |
405 return playMode; |
1055 } |
406 } |
1056 |
407 |
1057 |
|
1058 // ----------------------------------------------------------------------------- |
|
1059 // CPhoneRingingTonePlayerAO::ConstructPlayers |
|
1060 // ----------------------------------------------------------------------------- |
|
1061 // |
|
1062 TInt CPhoneRingingTonePlayerAO::ConstructPlayers() |
|
1063 { |
|
1064 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructPlayers()" ); |
|
1065 TRAPD( err, ConstructPlayersL() ); |
|
1066 return err; |
|
1067 } |
|
1068 |
|
1069 // ----------------------------------------------------------------------------- |
|
1070 // CPhoneRingingTonePlayerAO::ConstructPlayersL |
|
1071 // ----------------------------------------------------------------------------- |
|
1072 // |
|
1073 void CPhoneRingingTonePlayerAO::ConstructPlayersL() |
|
1074 { |
|
1075 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructPlayersL()" ); |
|
1076 |
|
1077 // Construct players. |
|
1078 if ( !iMdaServer ) |
|
1079 { |
|
1080 iMdaServer = CMdaServer::NewL(); |
|
1081 } |
|
1082 |
|
1083 // Construct Backup player. |
|
1084 if ( !iBackupPlayer ) |
|
1085 { |
|
1086 TFileName defaultSoundFile( KDriveZ ); |
|
1087 defaultSoundFile.Append( KPhoneDefaultSoundFile ); |
|
1088 iBackupPlayer = CPhoneAudioPlayer::NewL( |
|
1089 defaultSoundFile, |
|
1090 KAudioPriorityPhoneCall, |
|
1091 KAudioPrefIncomingCall, |
|
1092 *this, |
|
1093 EPlayerBackup, |
|
1094 iMdaServer |
|
1095 ); |
|
1096 } |
|
1097 } |
|
1098 |
|
1099 // ----------------------------------------------------------------------------- |
|
1100 // CPhoneRingingTonePlayerAO::ConstructSequencePlayer |
|
1101 // ----------------------------------------------------------------------------- |
|
1102 // |
|
1103 void CPhoneRingingTonePlayerAO::ConstructSequencePlayer( TPlayerId aId ) |
|
1104 { |
|
1105 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructSequencePlayer()" ); |
|
1106 |
|
1107 // Construct players. |
|
1108 TRAPD( err, ConstructSequencePlayerL( aId ) ); |
|
1109 if ( err ) |
|
1110 { |
|
1111 __PHONELOG1( EBasic, EPhoneUIView, |
|
1112 "CPhoneRingingTonePlayerAO::ConstructSequencePlayer - err(%d)", err ); |
|
1113 } |
|
1114 } |
|
1115 |
|
1116 // ----------------------------------------------------------------------------- |
|
1117 // CPhoneRingingTonePlayerAO::ConstructSequencePlayerL |
|
1118 // ----------------------------------------------------------------------------- |
|
1119 // |
|
1120 void CPhoneRingingTonePlayerAO::ConstructSequencePlayerL( TPlayerId aId ) |
|
1121 { |
|
1122 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ConstructSequencePlayerL()" ); |
|
1123 // Construct beep once player |
|
1124 if ( aId == EPlayerBeepOnce ) |
|
1125 { |
|
1126 #ifdef __WINS__ |
|
1127 TParse* fp = new (ELeave) TParse(); |
|
1128 fp->Set( KPhoneBeepOnceSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); |
|
1129 TFileName fileName( fp->FullName() ); |
|
1130 delete fp; |
|
1131 |
|
1132 iBeepOncePlayer = CPhoneAudioPlayer::NewL( |
|
1133 fileName, |
|
1134 KAudioPriorityPhoneCall, |
|
1135 KAudioPrefIncomingCall, |
|
1136 *this, |
|
1137 EPlayerBeepOnce ); |
|
1138 #else |
|
1139 iBeepOncePlayer = CPhoneAudioPlayer::NewSeqL( |
|
1140 KPhoneBeepSequence(), |
|
1141 KAudioPriorityPhoneCall, |
|
1142 KAudioPrefIncomingCall, |
|
1143 *this, |
|
1144 EPlayerBeepOnce ); |
|
1145 #endif // __WINS__ |
|
1146 } |
|
1147 |
|
1148 // Construct Silent Player. |
|
1149 else if ( aId == EPlayerSilent ) |
|
1150 { |
|
1151 #ifdef __WINS__ |
|
1152 TParse* fp = new (ELeave) TParse(); |
|
1153 fp->Set( KPhoneSilentSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); |
|
1154 TFileName fileName( fp->FullName() ); |
|
1155 delete fp; |
|
1156 |
|
1157 iSilentPlayer = CPhoneAudioPlayer::NewL( |
|
1158 fileName, |
|
1159 KAudioPriorityPhoneCall, |
|
1160 KAudioPrefIncomingCall, |
|
1161 *this, |
|
1162 EPlayerSilent ); |
|
1163 #else |
|
1164 iSilentPlayer = CPhoneAudioPlayer::NewSeqL( |
|
1165 KPhoneNoSoundSequence(), |
|
1166 KAudioPriorityPhoneCall, |
|
1167 KAudioPrefIncomingCall, |
|
1168 *this, |
|
1169 EPlayerSilent ); |
|
1170 #endif // __WINS__ |
|
1171 } |
|
1172 |
|
1173 else if ( aId == EPlayerUnsecureVoIP ) |
|
1174 { |
|
1175 #ifdef __WINS__ |
|
1176 TParse* fp = new (ELeave) TParse(); |
|
1177 fp->Set( KPhoneBeepOnceSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); |
|
1178 TFileName fileName( fp->FullName() ); |
|
1179 delete fp; |
|
1180 |
|
1181 iUnsecureVoIPTonePlayer = CPhoneAudioPlayer::NewL( |
|
1182 fileName, |
|
1183 KAudioPrioritySpecialInformationTone, |
|
1184 KAudioPrefSpecialInformation, |
|
1185 *this, |
|
1186 EPlayerUnsecureVoIP ); |
|
1187 #else |
|
1188 iUnsecureVoIPTonePlayer = CPhoneAudioPlayer::NewSeqL( |
|
1189 KPhoneUnsecureVoIPCall(), |
|
1190 KAudioPrioritySpecialInformationTone, |
|
1191 KAudioPrefSpecialInformation, |
|
1192 *this, |
|
1193 EPlayerUnsecureVoIP ); |
|
1194 #endif // __WINS__ |
|
1195 } |
|
1196 } |
|
1197 |
|
1198 // ----------------------------------------------------------------------------- |
|
1199 // CPhoneRingingTonePlayerAO::CleanupPlayers |
|
1200 // ----------------------------------------------------------------------------- |
|
1201 // |
|
1202 void CPhoneRingingTonePlayerAO::CleanupPlayers() |
|
1203 { |
|
1204 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::CleanupPlayers()" ); |
|
1205 |
|
1206 delete iAudioPlayer; |
|
1207 iAudioPlayer = NULL; |
|
1208 |
|
1209 delete iDefaultPlayer; |
|
1210 iDefaultPlayer = NULL; |
|
1211 |
|
1212 delete iBeepOncePlayer; |
|
1213 iBeepOncePlayer = NULL; |
|
1214 |
|
1215 delete iSilentPlayer; |
|
1216 iSilentPlayer = NULL; |
|
1217 |
|
1218 delete iUnsecureVoIPTonePlayer; |
|
1219 iUnsecureVoIPTonePlayer = NULL; |
|
1220 |
|
1221 delete iBackupPlayer; |
|
1222 iBackupPlayer = NULL; |
|
1223 |
|
1224 delete iMdaServer; |
|
1225 iMdaServer = NULL; |
|
1226 } |
|
1227 |
|
1228 // ----------------------------------------------------------------------------- |
|
1229 // CPhoneRingingTonePlayerAO::DeletePlayerAsync |
|
1230 // ----------------------------------------------------------------------------- |
|
1231 // |
|
1232 void CPhoneRingingTonePlayerAO::DeletePlayerAsync( TPlayerId aPlayer ) |
|
1233 { |
|
1234 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DeletePlayerAsync()" ); |
|
1235 __ASSERT_DEBUG( aPlayer >= EPlayerFirst && aPlayer < iAsyncDeletePlayers.Count(), |
|
1236 Panic( EPhoneViewInvariant ) ); |
|
1237 |
|
1238 // Player is not deleted here, but in RunL. |
|
1239 Cancel(); |
|
1240 |
|
1241 if ( iAsyncDeletePlayers[ aPlayer ] ) |
|
1242 { |
|
1243 delete iAsyncDeletePlayers[ aPlayer ]; |
|
1244 iAsyncDeletePlayers[ aPlayer ] = NULL; |
|
1245 } |
|
1246 |
|
1247 CPhoneAudioPlayer** players[] = |
|
1248 { |
|
1249 &iAudioPlayer, |
|
1250 &iBeepOncePlayer, |
|
1251 &iSilentPlayer, |
|
1252 &iUnsecureVoIPTonePlayer, |
|
1253 &iDefaultPlayer, |
|
1254 &iBackupPlayer, |
|
1255 &iTtsPlayer |
|
1256 }; |
|
1257 |
|
1258 __ASSERT_DEBUG( iAsyncDeletePlayers.Count() > aPlayer, Panic( EPhoneUtilsIndexOutOfBounds ) ); |
|
1259 iAsyncDeletePlayers[ aPlayer ] = |
|
1260 *(players[ aPlayer ]); |
|
1261 *(players[ aPlayer ]) = NULL; |
|
1262 |
|
1263 iState = EDeletingAudioPlayer; |
|
1264 |
|
1265 TRequestStatus* status = &iStatus; |
|
1266 User::RequestComplete( status, KErrNone ); |
|
1267 SetActive(); |
|
1268 } |
|
1269 |
|
1270 // ----------------------------------------------------------------------------- |
408 // ----------------------------------------------------------------------------- |
1271 // CPhoneRingingTonePlayerAO::RunL |
409 // CPhoneRingingTonePlayerAO::RunL |
1272 // ----------------------------------------------------------------------------- |
410 // ----------------------------------------------------------------------------- |
1273 // |
411 // |
1274 void CPhoneRingingTonePlayerAO::RunL() |
412 void CPhoneRingingTonePlayerAO::RunL() |
1275 { |
413 { |
1276 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::RunL()" ); |
414 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::RunL()" ); |
1277 |
415 |
1278 switch ( iState ) |
416 switch ( iState ) |
1279 { |
417 { |
1280 case EDeletingAudioPlayer: |
418 case EPlayingDefaultVideo: |
1281 { |
419 { |
1282 for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ ) |
420 PlayAudioRingTone( iVolume, iRingingType ); |
1283 { |
|
1284 delete iAsyncDeletePlayers[ i ]; |
|
1285 iAsyncDeletePlayers[ i ] = NULL; |
|
1286 } |
|
1287 } |
421 } |
1288 break; |
422 break; |
1289 |
423 |
1290 case EPlayingDefaultVideo: |
424 case EIdleState: |
1291 { |
|
1292 PlayAudioRingTone( iVolume, iRingingType ); |
|
1293 } |
|
1294 break; |
|
1295 |
|
1296 case EIdleState: |
|
1297 default: |
425 default: |
1298 break; |
426 break; |
1299 } // switch iState |
427 } // switch iState |
1300 |
428 |
1301 iState = EIdleState; |
429 iState = EIdleState; |
1302 } |
430 } |
1303 |
431 |
1304 // ----------------------------------------------------------------------------- |
432 // ----------------------------------------------------------------------------- |
1305 // CPhoneRingingTonePlayerAO::DoCancel |
433 // CPhoneRingingTonePlayerAO::DoCancel |
1308 void CPhoneRingingTonePlayerAO::DoCancel() |
436 void CPhoneRingingTonePlayerAO::DoCancel() |
1309 { |
437 { |
1310 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoCancel()" ); |
438 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoCancel()" ); |
1311 // Request is completed immediately before SetActive. |
439 // Request is completed immediately before SetActive. |
1312 } |
440 } |
1313 |
|
1314 // ----------------------------------------------------------------------------- |
|
1315 // CPhoneRingingTonePlayerAO::HandleTtsDelayTimeout |
|
1316 // ----------------------------------------------------------------------------- |
|
1317 // |
|
1318 TInt CPhoneRingingTonePlayerAO::HandleTtsDelayTimeout( TAny* object ) |
|
1319 { |
|
1320 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleTtsDelayTimeout()" ); |
|
1321 static_cast<CPhoneRingingTonePlayerAO*>( object )-> |
|
1322 DoHandleTtsDelayTimeout(); |
|
1323 return KErrNone; |
|
1324 } |
|
1325 |
|
1326 // ----------------------------------------------------------------------------- |
|
1327 // CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout |
|
1328 // ----------------------------------------------------------------------------- |
|
1329 // |
|
1330 void CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout() |
|
1331 { |
|
1332 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout()" ); |
|
1333 __PHONELOG2( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout - iTtsRingingType(%d), iTTsTimeOutCounter(%d)", |
|
1334 iTtsRingingType, iTTsTimeOutCounter ); |
|
1335 |
|
1336 CPhoneAudioPlayer* currPlayer = NULL; |
|
1337 currPlayer = GetCurrentlyActiveAudioPlayerWithTTs(); |
|
1338 |
|
1339 if ( !currPlayer ) |
|
1340 { |
|
1341 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout - null current player" ); |
|
1342 return; |
|
1343 } |
|
1344 TInt volume( 0 ); |
|
1345 //Ascending case. TTs player needs to be ascending. |
|
1346 if ( iTtsRingingType == EProfileRingingTypeAscending ) |
|
1347 { |
|
1348 //Volume needs to be different in different ascending steps |
|
1349 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout - play ascending" ); |
|
1350 if ( !iTTsTimeOutCounter ) |
|
1351 { |
|
1352 //We are saying callers name for the first time in ascending mode. |
|
1353 //Say callers name by volume level KTtsVolumeMin. |
|
1354 volume = KTtsVolumeMin; |
|
1355 |
|
1356 iTtsPlayer->Play( |
|
1357 ConvertRingingType( EProfileRingingTypeRingingOnce ), |
|
1358 volume, |
|
1359 iTtsToneToBePlayed ); |
|
1360 } |
|
1361 else |
|
1362 { |
|
1363 //Checks the case that ringingtone is very quiet. Then do not play |
|
1364 //TTS too loud |
|
1365 volume = iTtsVolume < KTtsVolumeMin ? KTtsVolumeMin : KTtsVolumeAscendingRepeat; |
|
1366 |
|
1367 //We are saying callers name for the second time in ascending mode. |
|
1368 //Say callers name by volume level KTtsVolumeAscendingRepeat and decrease current players volume |
|
1369 //to KPlayerVolumeAscendingRepeat. RampTime is zero |
|
1370 currPlayer->SetNewVolumeAndRamptime( KPlayerVolumeAscendingRepeat, 0 ); |
|
1371 iTtsPlayer->Play( |
|
1372 ConvertRingingType( EProfileRingingTypeRingingOnce ), |
|
1373 volume, |
|
1374 iTtsToneToBePlayed ); |
|
1375 } |
|
1376 |
|
1377 } |
|
1378 else //Normal ringing case. |
|
1379 { |
|
1380 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::DoHandleTtsDelayTimeout - play normal" ); |
|
1381 currPlayer->SetNewVolumeAndRamptime( iTtsVolume-5, 0 ); |
|
1382 iTtsPlayer->Play( |
|
1383 ConvertRingingType( EProfileRingingTypeRingingOnce ), |
|
1384 iTtsVolume, |
|
1385 iTtsToneToBePlayed ); |
|
1386 } |
|
1387 |
|
1388 iTTsTimeOutCounter++; |
|
1389 } |
|
1390 |
|
1391 // ----------------------------------------------------------------------------- |
|
1392 // CPhoneRingingTonePlayerAO::AddTtsPlaybackIfNeeded |
|
1393 // ----------------------------------------------------------------------------- |
|
1394 // |
|
1395 void CPhoneRingingTonePlayerAO::AddTtsPlaybackIfNeeded( |
|
1396 TProfileRingingType /*aRingingType*/ ) |
|
1397 { |
|
1398 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::AddTtsPlaybackIfNeeded()" ); |
|
1399 if ( iTtsToneToBePlayed ) |
|
1400 { |
|
1401 iTtsDelayIndex = 0; |
|
1402 iTtsDelaysCount = KPhoneTtsDelaysCount; |
|
1403 } |
|
1404 } |
|
1405 |
441 |
1406 // ----------------------------------------------------------------------------- |
442 // ----------------------------------------------------------------------------- |
1407 // CPhoneRingingTonePlayerAO::SetVideoPlayer |
443 // CPhoneRingingTonePlayerAO::SetVideoPlayer |
1408 // ----------------------------------------------------------------------------- |
444 // ----------------------------------------------------------------------------- |
1409 // |
445 // |
1410 void CPhoneRingingTonePlayerAO::SetVideoPlayer( |
446 void CPhoneRingingTonePlayerAO::SetVideoPlayer( |
1411 MPhoneVideoPlayer* aVideoPlayer ) |
447 MPhoneVideoPlayer* aVideoPlayer ) |
1412 { |
448 { |
1413 iVideoPlayer = aVideoPlayer; |
449 iVideoPlayer = aVideoPlayer; |
1414 } |
450 } |
1415 |
451 |
1416 // ----------------------------------------------------------------------------- |
452 // ----------------------------------------------------------------------------- |
1417 // CPhoneRingingTonePlayerAO::PlayVideoRingingTone |
453 // CPhoneRingingTonePlayerAO::PlayVideoRingingTone |
1418 // ----------------------------------------------------------------------------- |
454 // ----------------------------------------------------------------------------- |
1586 } |
622 } |
1587 |
623 |
1588 // ----------------------------------------------------------------------------- |
624 // ----------------------------------------------------------------------------- |
1589 // CPhoneRingingTonePlayerAO::ExtendedSecurity |
625 // CPhoneRingingTonePlayerAO::ExtendedSecurity |
1590 // ----------------------------------------------------------------------------- |
626 // ----------------------------------------------------------------------------- |
1591 // |
627 // |
1592 TBool CPhoneRingingTonePlayerAO::ExtendedSecurity() const |
628 TBool CPhoneRingingTonePlayerAO::ExtendedSecurity() const |
1593 { |
629 { |
1594 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ExtendedSecurity()" ); |
630 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ExtendedSecurity()" ); |
1595 return iExtSecNeeded; |
631 return iExtSecNeeded; |
1596 } |
632 } |
1597 |
633 |
1598 // ----------------------------------------------------------------------------- |
|
1599 // CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime |
|
1600 // ----------------------------------------------------------------------------- |
|
1601 // |
|
1602 void CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime( TTtsStatus aStatus ) |
|
1603 { |
|
1604 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime()" ); |
|
1605 |
|
1606 CPhoneAudioPlayer* currPlayer = NULL; |
|
1607 currPlayer = GetCurrentlyActiveAudioPlayerWithTTs(); |
|
1608 if ( !currPlayer ) |
|
1609 { |
|
1610 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - null current player" ); |
|
1611 return; |
|
1612 } |
|
1613 TInt ramptime( 0 ); |
|
1614 //Here is handled the cases when Callers name is said. Sequence is: |
|
1615 //3 sec. tone + name + 4 sec. tone + name +the tone until the end. |
|
1616 switch ( aStatus ) |
|
1617 { |
|
1618 case ESaidOnce: |
|
1619 if ( iTtsRingingType == EProfileRingingTypeAscending ) |
|
1620 { |
|
1621 //The ramptime could be ( 4 )* KPhoneTtsAscendingStep but now |
|
1622 //we are setting this to 0 because when Say callers name is said |
|
1623 //for first time: play ringing tone on level 3 for four secs. |
|
1624 ramptime = 0; |
|
1625 __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - said once ascending - ramptime(%d)", |
|
1626 ramptime ); |
|
1627 currPlayer->SetNewVolumeAndRamptime( KPlayerVolumeAscendingRepeat, ramptime ); |
|
1628 } |
|
1629 else |
|
1630 { |
|
1631 //Normal ringingtone case. Adjust volume back to profile level. |
|
1632 __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - said once normal - ramptime(%d)", |
|
1633 ramptime ); |
|
1634 currPlayer->SetNewVolumeAndRamptime( iTtsVolume, 0 ); |
|
1635 } |
|
1636 break; |
|
1637 |
|
1638 case ESaidTwice: |
|
1639 if ( iTtsRingingType == EProfileRingingTypeAscending ) |
|
1640 { |
|
1641 TInt vol = iTtsVolume; |
|
1642 if ( vol > KPlayerVolumeAscendingRepeat ) |
|
1643 { |
|
1644 vol = vol - KTtsVolumeAscendingDecrease; |
|
1645 } |
|
1646 |
|
1647 //TTS playing complete for second time. increase tone player volume. |
|
1648 ramptime = ( vol )*KPhoneTtsAscendingStep; |
|
1649 __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - said twice ascending - ramptime(%d)", |
|
1650 ramptime ); |
|
1651 currPlayer->SetNewVolumeAndRamptime( iTtsVolume, ramptime ); |
|
1652 } |
|
1653 else |
|
1654 { |
|
1655 //Normal ringingtone case. Adjust volume back to profile level. |
|
1656 __PHONELOG1( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::SolveNewVolumeAndRamptime - said twice normal - ramptime(%d)", |
|
1657 ramptime ); |
|
1658 currPlayer->SetNewVolumeAndRamptime( iTtsVolume, 0 ); |
|
1659 } |
|
1660 break; |
|
1661 |
|
1662 default: |
|
1663 break; |
|
1664 } |
|
1665 } |
|
1666 |
|
1667 |
|
1668 // ----------------------------------------------------------------------------- |
|
1669 // CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs |
|
1670 // ----------------------------------------------------------------------------- |
|
1671 // |
|
1672 CPhoneAudioPlayer* |
|
1673 CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs() |
|
1674 { |
|
1675 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs()" ); |
|
1676 |
|
1677 if( iAudioPlayer ) |
|
1678 { |
|
1679 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - audio player" ); |
|
1680 return iAudioPlayer; |
|
1681 } |
|
1682 else if ( iDefaultPlayer ) |
|
1683 { |
|
1684 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - default player" ); |
|
1685 return iDefaultPlayer; |
|
1686 } |
|
1687 else if( iBackupPlayer ) |
|
1688 { |
|
1689 __PHONELOG( EBasic, EPhoneUIView, "CPhoneRingingTonePlayerAO::GetCurrentlyActiveAudioPlayerWithTTs - backup player" ); |
|
1690 return iBackupPlayer; |
|
1691 } |
|
1692 else |
|
1693 { |
|
1694 return NULL; |
|
1695 } |
|
1696 } |
|
1697 |
|
1698 // ----------------------------------------------------------------------------- |
|
1699 // CPhoneRingingTonePlayerAO::ReStartRingingTonePlayer |
|
1700 // ----------------------------------------------------------------------------- |
|
1701 // |
|
1702 void CPhoneRingingTonePlayerAO::ReStartRingingTonePlayer() |
|
1703 { |
|
1704 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ReStartRingingTonePlayer()" ); |
|
1705 |
|
1706 //First get currently active player which plays among TTS player. |
|
1707 CPhoneAudioPlayer* currPlayer = NULL; |
|
1708 currPlayer = GetCurrentlyActiveAudioPlayerWithTTs(); |
|
1709 if ( currPlayer ) |
|
1710 { |
|
1711 currPlayer->ReStartPlaying(); |
|
1712 } |
|
1713 } |
|
1714 |
634 |
1715 // ----------------------------------------------------------------------------- |
635 // ----------------------------------------------------------------------------- |
1716 // CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit |
636 // CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit |
1717 // ----------------------------------------------------------------------------- |
637 // ----------------------------------------------------------------------------- |
1718 // |
638 // |
1719 TBool CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit( |
639 TBool CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit( |
1720 CPhoneRingingTone* aRingingTone ) |
640 CPhoneRingingTone* aRingingTone ) |
1721 { |
641 { |
1722 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit()" ); |
642 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit()" ); |
1723 |
643 |
1724 TBool bValidSize = ETrue; |
644 TBool bValidSize = ETrue; |
1725 |
645 |
1726 // If user has somehow managed to get a too large file as ringing tone, |
646 // If user has somehow managed to get a too large file as ringing tone, |
1727 // play default tone instead. |
647 // play default tone instead. |
1728 if ( iToneFileSizeLimitKB ) |
648 if ( iToneFileSizeLimitKB ) |
1729 { |
649 { |
1730 if ( CheckToneFileSize( aRingingTone->FileName(), iToneFileSizeLimitKB) != KErrNone ) |
650 if ( CheckToneFileSize( aRingingTone->FileName(), iToneFileSizeLimitKB) != KErrNone ) |
1731 { |
651 { |
1732 bValidSize = EFalse; |
652 bValidSize = EFalse; |
1733 } |
653 } |
1734 } |
654 } |
1735 __PHONELOG1( |
655 __PHONELOG1( |
1736 EBasic, |
656 EBasic, |
1737 EPhoneUIView, |
657 EPhoneUIView, |
1738 "CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit - bValidSize(%d)", |
658 "CPhoneRingingTonePlayerAO::CheckAndHandleToneSizeLimit - bValidSize(%d)", |
1739 bValidSize); |
659 bValidSize); |
1740 |
660 |
1741 return bValidSize; |
661 return bValidSize; |
1742 } |
662 } |
1743 |
663 |
1744 // ----------------------------------------------------------------------------- |
664 // ----------------------------------------------------------------------------- |
1745 // CPhoneRingingTonePlayerAO::CheckToneFileSize |
665 // CPhoneRingingTonePlayerAO::CheckToneFileSize |
1746 // ----------------------------------------------------------------------------- |
666 // ----------------------------------------------------------------------------- |
1747 // |
667 // |
1748 TInt CPhoneRingingTonePlayerAO::CheckToneFileSize( const TDesC& aFile, TInt aSizeLimitKB ) |
668 TInt CPhoneRingingTonePlayerAO::CheckToneFileSize( const TDesC& aFile, TInt aSizeLimitKB ) |
1749 { |
669 { |
1750 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::CheckToneFileSize()" ); |
670 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::CheckToneFileSize()" ); |
1751 |
671 |
1752 // Get file size |
672 // Get file size |
1753 TInt size = 0; |
673 TInt size = 0; |
1754 TInt error = KErrNone; |
674 TInt error = KErrNone; |
1755 RFs& fs = CCoeEnv::Static()->FsSession(); |
675 RFs& fs = CCoeEnv::Static()->FsSession(); |
1756 TEntry entry; |
676 TEntry entry; |
1757 if (KErrNone == fs.Entry( aFile, entry )) |
677 if (KErrNone == fs.Entry( aFile, entry )) |
1758 { |
678 { |
1759 size = entry.iSize; |
679 size = entry.iSize; |
1760 } |
680 } |
1761 |
681 |
1762 // Check |
682 // Check |
1763 aSizeLimitKB *= Kkilo; |
683 aSizeLimitKB *= Kkilo; |
1764 if ( aSizeLimitKB && size > aSizeLimitKB ) |
684 if ( aSizeLimitKB && size > aSizeLimitKB ) |
1765 { |
685 { |
1766 error = KErrTooBig; |
686 error = KErrTooBig; |
1767 } |
687 } |
1768 |
688 |
1769 __PHONELOG1( |
689 __PHONELOG1( |
1770 EBasic, |
690 EBasic, |
1771 EPhoneUIView, |
691 EPhoneUIView, |
1772 "CPhoneRingingTonePlayerAO::CheckToneFileSize - size (%d)", |
692 "CPhoneRingingTonePlayerAO::CheckToneFileSize - size (%d)", |
1773 size ); |
693 size ); |
1774 return error; |
694 return error; |
1775 } |
695 } |
1776 |
696 |
1777 |
697 |
1778 // ----------------------------------------------------------------------------- |
698 // ----------------------------------------------------------------------------- |
1780 // ----------------------------------------------------------------------------- |
700 // ----------------------------------------------------------------------------- |
1781 // |
701 // |
1782 void CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL( TInt& aMaxSizeKB ) const |
702 void CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL( TInt& aMaxSizeKB ) const |
1783 { |
703 { |
1784 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL()" ); |
704 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL()" ); |
1785 |
705 |
1786 const TInt error = CPhoneCenRepProxy::Instance()->GetInt( |
706 const TInt error = CPhoneCenRepProxy::Instance()->GetInt( |
1787 KCRUidProfileEngine, |
707 KCRUidProfileEngine, |
1788 KProEngRingingToneMaxSize, |
708 KProEngRingingToneMaxSize, |
1789 aMaxSizeKB ); |
709 aMaxSizeKB ); |
1790 |
710 |
1791 if ( error != KErrNone ) |
711 if ( error != KErrNone ) |
1792 { |
712 { |
1793 aMaxSizeKB = 0; |
713 aMaxSizeKB = 0; |
1794 } |
714 } |
1795 if ( aMaxSizeKB < 0 ) |
715 if ( aMaxSizeKB < 0 ) |
1796 { |
716 { |
1797 aMaxSizeKB = 0; |
717 aMaxSizeKB = 0; |
1798 } |
718 } |
1799 |
719 |
1800 __PHONELOG2( |
720 __PHONELOG2( |
1801 EBasic, |
721 EBasic, |
1802 EPhoneUIView, |
722 EPhoneUIView, |
1803 "CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL - error (%d), aMaxSizeKB(%d)", |
723 "CPhoneRingingTonePlayerAO::GetMaxToneFileSizeL - error (%d), aMaxSizeKB(%d)", |
1804 error, |
724 error, |
1805 aMaxSizeKB ); |
725 aMaxSizeKB ); |
1806 } |
726 } |
1807 |
|
1808 // ----------------------------------------------------------------------------- |
|
1809 // CPhoneRingingTonePlayerAO::ActiveAudioPlayer |
|
1810 // ----------------------------------------------------------------------------- |
|
1811 // |
|
1812 CPhoneAudioPlayer* CPhoneRingingTonePlayerAO::ActiveAudioPlayer() |
|
1813 { |
|
1814 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::ActiveAudioPlayer()" ); |
|
1815 |
|
1816 switch( iTonePlayingStatus ) |
|
1817 { |
|
1818 case EAudioTonePlaying: |
|
1819 if( iAudioPlayer ) |
|
1820 { |
|
1821 return iAudioPlayer; |
|
1822 } |
|
1823 break; |
|
1824 |
|
1825 case EDefaultTonePlaying: |
|
1826 if ( iDefaultPlayer ) |
|
1827 { |
|
1828 return iDefaultPlayer; |
|
1829 } |
|
1830 break; |
|
1831 |
|
1832 case EBeepOnce: |
|
1833 if( iBeepOncePlayer ) |
|
1834 { |
|
1835 return iBeepOncePlayer; |
|
1836 } |
|
1837 break; |
|
1838 |
|
1839 case EBackupTonePlaying: |
|
1840 if( iBackupPlayer ) |
|
1841 { |
|
1842 return iBackupPlayer; |
|
1843 } |
|
1844 break; |
|
1845 |
|
1846 case ESilentTonePlaying: |
|
1847 if( iSilentPlayer ) |
|
1848 { |
|
1849 return iSilentPlayer; |
|
1850 } |
|
1851 break; |
|
1852 |
|
1853 case EUnsecureVoIPTonePlaying: |
|
1854 if( iUnsecureVoIPTonePlayer ) |
|
1855 { |
|
1856 return iUnsecureVoIPTonePlayer; |
|
1857 } |
|
1858 break; |
|
1859 |
|
1860 case EVideoTonePlaying: // video ringing tone |
|
1861 case EPersonalVideoTonePlaying: |
|
1862 case ESilentVideoTonePlaying: |
|
1863 if ( iBeepOncePlayer ) |
|
1864 { |
|
1865 return iBeepOncePlayer; |
|
1866 } |
|
1867 else if ( iSilentPlayer ) |
|
1868 { |
|
1869 return iSilentPlayer; |
|
1870 } |
|
1871 break; |
|
1872 |
|
1873 default: |
|
1874 break; |
|
1875 } |
|
1876 |
|
1877 return NULL; |
|
1878 } |
|
1879 |
|
1880 // ----------------------------------------------------------------------------- |
|
1881 // CPhoneRingingTonePlayerAO::DoMuteRingingTone |
|
1882 // ----------------------------------------------------------------------------- |
|
1883 // |
|
1884 void CPhoneRingingTonePlayerAO::DoMuteRingingTone() |
|
1885 { |
|
1886 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::DoMuteRingingTone()" ); |
|
1887 |
|
1888 switch( iTonePlayingStatus ) |
|
1889 { |
|
1890 case EVideoTonePlaying: // video ringing tone, fall through |
|
1891 case EPersonalVideoTonePlaying: // fall through |
|
1892 case ESilentVideoTonePlaying: |
|
1893 if ( iVideoPlayer ) |
|
1894 { |
|
1895 iVideoPlayer->MuteVideoRingTone(); |
|
1896 return; |
|
1897 } |
|
1898 break; |
|
1899 |
|
1900 default: |
|
1901 break; |
|
1902 } |
|
1903 |
|
1904 CPhoneAudioPlayer* activePlayer = ActiveAudioPlayer(); |
|
1905 if( activePlayer ) |
|
1906 { |
|
1907 activePlayer->MutePlaying(); |
|
1908 } |
|
1909 } |
|
1910 |
727 |
1911 // ----------------------------------------------------------- |
728 // ----------------------------------------------------------- |
1912 // CPhoneRingingTonePlayerAO::HandleCenRepChangeL |
729 // CPhoneRingingTonePlayerAO::HandleCenRepChangeL |
1913 // ----------------------------------------------------------- |
730 // ----------------------------------------------------------- |
1914 // |
731 // |
1915 void CPhoneRingingTonePlayerAO::HandleCenRepChangeL( |
732 void CPhoneRingingTonePlayerAO::HandleCenRepChangeL( |
1916 const TUid& aUid, |
733 const TUid& aUid, |
1917 const TUint /*aId*/ ) |
734 const TUint /*aId*/ ) |
1918 { |
735 { |
1919 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleCenRepChangeL()"); |
736 __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneRingingTonePlayerAO::HandleCenRepChangeL()"); |
1920 |
737 |
1921 if ( aUid == KCRUidDRMHelperServer ) |
738 if ( aUid == KCRUidDRMHelperServer ) |
1922 { |
739 { |
1923 TBuf<256> tempBuf16( KNullDesC ); |
740 TBuf<256> tempBuf16( KNullDesC ); |
1924 |
741 |
1925 User::LeaveIfError( CPhoneCenRepProxy::Instance()->GetString( |
742 User::LeaveIfError( CPhoneCenRepProxy::Instance()->GetString( |
1926 KCRUidDRMHelperServer, |
743 KCRUidDRMHelperServer, |
1927 KDRMHelperServerNotificationPassive, |
744 KDRMHelperServerNotificationPassive, |
1928 tempBuf16 ) ); |
745 tempBuf16 ) ); |
1929 |
746 |
1930 const TBool idleIsTopApp = CPhonePubSubProxy::Instance()->Value( |
747 const TBool idleIsTopApp = CPhonePubSubProxy::Instance()->Value( |
1931 KPSUidAiInformation, KActiveIdleState ) == EPSAiForeground; |
748 KPSUidAiInformation, KActiveIdleState ) == EPSAiForeground; |
1932 |
749 |
1933 // Quick validity check and |
750 // Quick validity check and |
1934 // The first Tuint8 is the times the content has been informed. |
751 // The first Tuint8 is the times the content has been informed. |
1935 // Note should not shown until Idle. |
752 // Note should not shown until Idle. |
1936 if ( idleIsTopApp && tempBuf16.Length() >= KPhoneMinDRMTextLength ) |
753 if ( idleIsTopApp && tempBuf16.Length() >= KPhoneMinDRMTextLength ) |
1937 { |
754 { |
1938 TBuf8<256> tempBuf8; |
755 TBuf8<256> tempBuf8; |
1939 TPtrC8 ptr((TUint8*)tempBuf16.Ptr(), tempBuf16.Size()); |
756 TPtrC8 ptr((TUint8*)tempBuf16.Ptr(), tempBuf16.Size()); |
1940 HBufC8* buf8 = HBufC8::NewLC( 256 ); |
757 HBufC8* buf8 = HBufC8::NewLC( 256 ); |
1941 buf8->Des().Copy(ptr); |
758 buf8->Des().Copy(ptr); |
1942 // Extract URI etc. |
759 // Extract URI etc. |
1943 // buf8 format: |
760 // buf8 format: |
1944 //<TUint8 aTimes><TUint8 aExpirationMark> |
761 //<TUint8 aTimes><TUint8 aExpirationMark> |
1945 //<TUint8 aPermissionType> |
762 //<TUint8 aPermissionType> |
1946 //<TUint8 aAutomatedContentType><TDesC8 aContentID> |
763 //<TUint8 aAutomatedContentType><TDesC8 aContentID> |
1947 TInt8 count = (TInt8)(*(buf8->Ptr())); |
764 TInt8 count = (TInt8)(*(buf8->Ptr())); |
1948 TChar mark = (TChar)(*(buf8->Ptr()+1)); |
765 TChar mark = (TChar)(*(buf8->Ptr()+1)); |
1949 TInt8 permtype = (TChar)(*(buf8->Ptr()+2)); |
766 TInt8 permtype = (TChar)(*(buf8->Ptr()+2)); |
1950 TInt8 automcontenttype = (TChar)(*(buf8->Ptr()+3)); |
767 TInt8 automcontenttype = (TChar)(*(buf8->Ptr()+3)); |
1951 TBuf8<256> curi = buf8->Right( buf8->Length()-4); |
768 TBuf8<256> curi = buf8->Right( buf8->Length()-4); |
1952 |
769 |
1953 if (curi.Ptr()[curi.Size()-1] == 0) |
770 if ( curi.Ptr()[curi.Size()-1] == 0 ) |
1954 { |
771 { |
1955 // The last character in the descriptor is 0, which means |
772 // The last character in the descriptor is 0, which means |
1956 // that the original 16-bit desc was padded so |
773 // that the original 16-bit desc was padded so |
1957 // remove the last char... |
774 // remove the last char... |
1958 curi.SetLength(curi.Size()-1); |
775 curi.SetLength(curi.Size()-1); |
1959 } |
776 } |
1960 |
777 |
1961 // Create DRM helper. |
778 // Create DRM helper. |
1962 CDRMHelper* drmHelper = CDRMHelper::NewLC(); |
779 CDRMHelper* drmHelper = CDRMHelper::NewLC(); |
1963 // Show notification. |
780 // Show notification. |
1964 drmHelper->SetAutomatedType( (CDRMHelper::TDRMHelperAutomatedType)automcontenttype ); |
781 drmHelper->SetAutomatedType( (CDRMHelper::TDRMHelperAutomatedType)automcontenttype ); |
1965 TInt error = drmHelper->CheckRightsAmountL( curi ); |
782 TInt error = drmHelper->CheckRightsAmountL( curi ); |
1966 |
783 |
1967 __PHONELOG1( EBasic, EPhoneUIView, |
784 __PHONELOG1( EBasic, EPhoneUIView, |
1968 "CPhoneRingingTonePlayerAO::HandleCenRepChangeL > CheckRightsAmountL, error: %d" |
785 "CPhoneRingingTonePlayerAO::HandleCenRepChangeL > CheckRightsAmountL, error: %d" |
1969 , error ); |
786 , error ); |
1970 |
787 |
1971 CleanupStack::PopAndDestroy( drmHelper ); |
788 CleanupStack::PopAndDestroy( drmHelper ); |
1972 CleanupStack::PopAndDestroy( buf8 ); |
789 CleanupStack::PopAndDestroy( buf8 ); |
1973 } |
790 } |
1974 } |
791 } |
1975 } |
792 } |
1976 |
793 |
1977 // End of File |
794 // End of File |