1 /*

     2 * Copyright (c) 2009 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 *

    16 */

    17 

    18 #include <cntdef.h>

    19 #include <f32file.h>

    20 #include <featmgr.h>

    21 #include <utility.h>

    22 #include <AudioPreference.h>

    23 #include <ProfileEngineDomainCRKeys.h>

    24 #include <DRMHelperServerInternalCRKeys.h>

    25 #include <DRMHelper.h>

    26 #include <data_caging_path_literals.hrh>

    27 #include "cphoneringingtoneplayer.h"

    28 #include "cphoneaudioplayer.h"

    29 #include "cphoneringingtone.h"

    30 #include "phonelogger.h"

    31 #include "cphonecenrepproxy.h"

    32 #include "cphonepubsubproxy.h"

    33 #include "cphonetimer.h"

    34 #include "phoneconstants.h"

    35 #include "phoneui.pan"

    36 

    37 CPhoneRingingtonePlayer::CPhoneRingingtonePlayer():

    38 CActive( CActive::EPriorityStandard ), iAsyncDeletePlayers( EPlayerCount )

    39 {

    40     CActiveScheduler::Add( this );

    41 }

    42 

    43 CPhoneRingingtonePlayer::~CPhoneRingingtonePlayer()

    44     {

    45     iAsyncDeletePlayers.ResetAndDestroy();

    46     iAsyncDeletePlayers.Close();

    47         

    48     delete iTimer;

    49     

    50     CleanupPlayers();

    51     

    52     Cancel();

    53     }

    54 

    55 // -----------------------------------------------------------------------------

    56 // 

    57 // -----------------------------------------------------------------------------

    58 //

    59 void CPhoneRingingtonePlayer::CleanupPlayers()

    60     {

    61     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::CleanupPlayers()" );

    62     

    63     delete iAudioPlayer;

    64     iAudioPlayer = NULL;

    65     delete iDefaultPlayer;

    66     iDefaultPlayer = NULL;

    67     delete iBeepOncePlayer;

    68     iBeepOncePlayer = NULL;

    69     delete iSilentPlayer;

    70     iSilentPlayer = NULL;

    71     delete iBackupPlayer;

    72     iBackupPlayer = NULL;

    73     delete iMdaServer;

    74     iMdaServer = NULL;

    75     }

    76 // -----------------------------------------------------------------------------

    77 // 

    78 // -----------------------------------------------------------------------------

    79 //

    80 CPhoneRingingtonePlayer* CPhoneRingingtonePlayer::NewL()

    81     {

    82     CPhoneRingingtonePlayer* self = 

    83         new ( ELeave ) CPhoneRingingtonePlayer();

    84     

    85     CleanupStack::PushL( self );

    86     self->ConstructL();

    87     CleanupStack::Pop( self );

    88 

    89     return self;

    90     }

    91 

    92 // -----------------------------------------------------------------------------

    93 // 

    94 // -----------------------------------------------------------------------------

    95 //

    96 void CPhoneRingingtonePlayer::ConstructL()

    97     {

    98     

    99     // Construct timer.

   100     iTimer = CPhoneTimer::NewL();

   101     

   102     for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ )

   103         {

   104         User::LeaveIfError( 

   105             iAsyncDeletePlayers.Append( NULL ) );

   106         }

   107     

   108     //disabling the DRM for the TB10.1wk46 release. Lets see if need to put it back and how.

   109     //iExtSecNeeded = ( ( err == KErrNone ) && extSecNeeded ) ? ETrue : EFalse;

   110     iExtSecNeeded = EFalse; 

   111         

   112     // Construct players.

   113     if ( !iMdaServer )

   114         {

   115         iMdaServer = CMdaServer::NewL();

   116         }

   117     

   118     // Backup player. 

   119     ConstructBackupPlayer();

   120     ConstructDefaultPlayerL();

   121     }

   122 

   123 // -----------------------------------------------------------------------------

   124 // 

   125 // -----------------------------------------------------------------------------

   126 //

   127 void CPhoneRingingtonePlayer::PlayProfileBasedTone( CPhoneRingingTone* aAudioVideoRingingTone )

   128     {

   129     iAudioVideoRingingTone = aAudioVideoRingingTone;

   130     // Construct player for line 1.

   131      if ( !iAudioPlayer )

   132          {

   133          iAudioPlayer = ConstructTonePlayer( 

   134              *iAudioVideoRingingTone, 

   135              EPlayerAudio );

   136          if ( !iTimer->IsActive() )

   137              {

   138              // Start timer, since the player is constructed.

   139              iTimer->After( KPhoneMaxRingingWaiting, this );

   140              }

   141          }

   142 

   143      // Start playing.

   144      if ( !iAudioPlayer )

   145          {

   146          iTimer->Cancel();

   147          PlayDefaultTone( aAudioVideoRingingTone->Volume(), 

   148                           aAudioVideoRingingTone->RingingType() );

   149          }

   150      else

   151          {

   152          __PHONELOG( 

   153              EBasic, 

   154              EPhoneControl, 

   155              "CPhoneRingingtonePlayer::PlayAudioRingTone - Start playing audio" );

   156          iVolume = aAudioVideoRingingTone->Volume();

   157          iRingingType = aAudioVideoRingingTone->RingingType();

   158          //AddTtsPlaybackIfNeeded( aRingingType );

   159          iTonePlayingStatus = EAudioTonePlaying;

   160          iAudioPlayer->Play( 

   161              ConvertRingingType( aAudioVideoRingingTone->RingingType() ),

   162              aAudioVideoRingingTone->Volume(),

   163              aAudioVideoRingingTone->TtsToneToBePlayed());

   164          }

   165     }

   166 // -----------------------------------------------------------------------------

   167 // 

   168 // -----------------------------------------------------------------------------

   169 //

   170 void CPhoneRingingtonePlayer::PlayBeepOnce( TInt aVolume )

   171     {

   172     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::BeepOnce()" );

   173     __PHONELOG1( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::BeepOnce - aVolume(%d)",

   174         aVolume );

   175 

   176     if ( !iBeepOncePlayer )

   177         {

   178         ConstructSequencePlayer( EPlayerBeepOnce );

   179         }

   180 

   181     if ( iBeepOncePlayer )

   182         {

   183         __PHONELOG( 

   184             EBasic, 

   185             EPhoneControl, 

   186             "CPhoneRingingtonePlayer::BeepOnce - Play" );

   187         iTonePlayingStatus = EBeepOnce;

   188         iBeepOncePlayer->Play( CPhoneAudioPlayer::ETypeRingingOnce, 

   189             aVolume, EFalse );        

   190         }

   191     }

   192 

   193 // -----------------------------------------------------------------------------

   194 //

   195 // -----------------------------------------------------------------------------

   196 //

   197 void CPhoneRingingtonePlayer::PlaySilentTone()

   198     {

   199     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::PlaySilentTone()" );

   200 

   201     if ( !iSilentPlayer )

   202         {

   203         ConstructSequencePlayer( EPlayerSilent );

   204         }

   205 

   206     if ( iSilentPlayer )

   207         {

   208         __PHONELOG( 

   209             EBasic, 

   210             EPhoneControl, 

   211             "CPhoneRingingtonePlayer::PlaySilentTone - play" );

   212         iTonePlayingStatus = ESilentTonePlaying;

   213         iSilentPlayer->Play( CPhoneAudioPlayer::ETypeRinging, 0, EFalse );        

   214         }

   215     }

   216 

   217 // -----------------------------------------------------------------------------

   218 // 

   219 // -----------------------------------------------------------------------------

   220 //

   221 void CPhoneRingingtonePlayer::PlayDefaultTone( 

   222     TInt aVolume, 

   223     TProfileRingingType aRingingType )

   224     {

   225     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone()" );

   226 

   227     if( aRingingType == EProfileRingingTypeSilent ||

   228         aRingingType == EProfileRingingTypeBeepOnce )

   229         {

   230         return;

   231         }

   232         

   233     if ( !iDefaultRingingTone )

   234         {

   235         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone - default tone does not exist, play backup..." );

   236         PlayBackupTone( aVolume, aRingingType );

   237         return;    

   238         }

   239 

   240     // Construct player.

   241     if ( !iDefaultPlayer )

   242         {

   243         iDefaultPlayer = ConstructTonePlayer( 

   244             *iDefaultRingingTone, 

   245             EPlayerDefault );

   246         if ( !iTimer->IsActive() )

   247             {

   248             iTimer->After( KPhoneMaxRingingWaiting, this );

   249             }

   250         }

   251 

   252     // Start playing backup.

   253     if ( !iDefaultPlayer )

   254         {

   255         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone - player not constructed, play backup..." );

   256         iTimer->Cancel();

   257         PlayBackupTone( aVolume, aRingingType );

   258         }

   259     else

   260         {

   261         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayDefaultTone - play" );

   262         iVolume = aVolume;

   263         iRingingType = aRingingType;

   264         iTonePlayingStatus = EDefaultTonePlaying;

   265         iDefaultPlayer->Play( 

   266             ConvertRingingType( aRingingType ), aVolume,

   267             iAudioVideoRingingTone->TtsToneToBePlayed());

   268         }

   269 

   270     }

   271 

   272 // -----------------------------------------------------------------------------

   273 // CPhoneRingingtonePlayer::PlayBackupTone

   274 // -----------------------------------------------------------------------------

   275 //

   276 void CPhoneRingingtonePlayer::PlayBackupTone( 

   277     TInt aVolume, 

   278     TProfileRingingType aRingingType )

   279     {

   280     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::PlayBackupTone()" );

   281     __ASSERT_DEBUG( iBackupPlayer, Panic( EPhoneViewGeneralError ) );

   282 

   283     if ( !iBackupPlayer )

   284         {

   285         ConstructBackupPlayer();

   286         }

   287 

   288     if ( iBackupPlayer )

   289         {

   290         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::PlayBackupTone - play" );

   291         iTonePlayingStatus = EBackupTonePlaying;

   292 /*

   293         // playing text-to-speech, if necessary

   294         iTtsToneToBePlayed = EFalse;

   295         iTTsTimeOutCounter = 0;

   296         iTtsDelayTimer->Cancel();

   297         if ( iTtsPlayer )

   298             {

   299             iTtsPlayer->StopPlaying();

   300             delete iTtsPlayer;

   301             iTtsPlayer = NULL;

   302             }*/

   303 

   304         iBackupPlayer->Play( 

   305             ConvertRingingType( aRingingType ), aVolume, EFalse );        

   306         }

   307     }

   308 

   309 

   310 // -----------------------------------------------------------------------------

   311 // 

   312 // -----------------------------------------------------------------------------

   313 //

   314 void CPhoneRingingtonePlayer::StopPlaying()

   315     {

   316     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::StopPlaying()" );

   317 

   318     iTimer->Cancel();

   319 

   320     switch( iTonePlayingStatus )

   321         {

   322         case EAudioTonePlaying:

   323             if( iAudioPlayer )

   324                 {

   325                 iAudioPlayer->StopPlaying();

   326                 delete iAudioPlayer;

   327                 iAudioPlayer = NULL;

   328                 }

   329             break;

   330         case EDefaultTonePlaying:

   331             if ( iDefaultPlayer )

   332                 {

   333                 iDefaultPlayer->StopPlaying();

   334                 delete iDefaultPlayer;

   335                 iDefaultPlayer = NULL;

   336                 }

   337             break;

   338         case EBeepOnce:

   339             if( iBeepOncePlayer )

   340                 {

   341                 iBeepOncePlayer->StopPlaying();

   342                 delete iBeepOncePlayer;

   343                 iBeepOncePlayer = NULL;

   344                 }

   345             break;

   346         case EBackupTonePlaying:

   347             if( iBackupPlayer )

   348                 {

   349                 iBackupPlayer->StopPlaying();

   350                 }

   351             break;

   352         case ESilentTonePlaying:

   353             if( iSilentPlayer )

   354                 {

   355                 iSilentPlayer->StopPlaying();

   356                 delete iSilentPlayer;

   357                 iSilentPlayer = NULL;

   358                 }

   359             break;

   360         case EVideoTonePlaying: // video ringing tone

   361         case EPersonalVideoTonePlaying:

   362         case ESilentVideoTonePlaying:

   363             if ( iBeepOncePlayer )

   364                 {

   365                 iBeepOncePlayer->StopPlaying();

   366                 delete iBeepOncePlayer;

   367                 iBeepOncePlayer = NULL;                    

   368                 }

   369                 

   370             if ( iSilentPlayer )

   371                 {

   372                 iSilentPlayer->StopPlaying();

   373                 delete iSilentPlayer;

   374                 iSilentPlayer = NULL;                    

   375                 }    

   376             /*if ( iVideoPlayer )

   377                 {

   378                 iVideoPlayer->StopVideoRingTone();

   379                 }*/

   380             if ( iAudioVideoRingingTone )

   381                 {

   382                 delete iAudioVideoRingingTone;

   383                 iAudioVideoRingingTone = NULL;    

   384                 }

   385             break;

   386         case EIdle:

   387             // Do nothing here.

   388             return;

   389         default:

   390             Panic( EPhoneViewCaseNotHandled );

   391             break;

   392         }

   393 

   394     iTonePlayingStatus = EIdle;

   395     }

   396 // -----------------------------------------------------------------------------

   397 // 

   398 // -----------------------------------------------------------------------------

   399 //

   400 CPhoneAudioPlayer* CPhoneRingingtonePlayer::ConstructTonePlayer( 

   401     const CPhoneRingingTone& aRingingTone,

   402     TInt aId )

   403     {

   404     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructTonePlayer()" );

   405     return CPhoneAudioPlayer::New(

   406         aRingingTone, 

   407         KAudioPriorityPhoneCall, 

   408         KAudioPrefIncomingCall,

   409         *this, 

   410         aId,

   411         iMdaServer,

   412         aId == EPlayerDefault ? EFalse : iExtSecNeeded );

   413     }

   414 

   415 // -----------------------------------------------------------------------------

   416 // 

   417 // -----------------------------------------------------------------------------

   418 //

   419 TInt CPhoneRingingtonePlayer::ConstructBackupPlayer()

   420     {

   421     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructBackupPlayer()" );

   422     TRAPD( err, ConstructBackupPlayerL() );

   423     return err;

   424     }

   425 // -----------------------------------------------------------------------------

   426 //

   427 // -----------------------------------------------------------------------------

   428 //

   429 void CPhoneRingingtonePlayer::ConstructBackupPlayerL()

   430     {

   431     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructBackupPlayerL()" );

   432 

   433     // Construct Backup player.

   434     if ( !iBackupPlayer )

   435         {

   436         TFileName defaultSoundFile( KDriveZ );

   437         defaultSoundFile.Append( KPhoneDefaultSoundFile );

   438         iBackupPlayer = CPhoneAudioPlayer::NewL( 

   439             defaultSoundFile,

   440             KAudioPriorityPhoneCall,

   441             KAudioPrefIncomingCall,

   442             *this,

   443             EPlayerBackup,

   444             iMdaServer 

   445             );

   446         }

   447     }

   448 

   449 // -----------------------------------------------------------------------------

   450 // 

   451 // -----------------------------------------------------------------------------

   452 //

   453 void CPhoneRingingtonePlayer::ConstructDefaultPlayerL()

   454     {

   455     // Construct the default ringing tone

   456     TBuf<KMaxFileName> defaultTone;

   457     defaultTone = _L("z:\\data\\sounds\\digital\\Nokia tune.aac");        

   458     TInt err(KErrNone);

   459     

   460     if ( err == KErrNone )

   461         {

   462         iDefaultRingingTone = CPhoneRingingTone::NewL( defaultTone );

   463         }

   464     }

   465 // -----------------------------------------------------------------------------

   466 // 

   467 // -----------------------------------------------------------------------------

   468 //

   469 void CPhoneRingingtonePlayer::ConstructSequencePlayer( TPlayerId aId )

   470     {

   471     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructSequencePlayer()" );

   472 

   473     // Construct players.

   474     TRAPD( err, ConstructSequencePlayerL( aId ) );

   475     if ( err )

   476         {

   477         __PHONELOG1( EBasic, EPhoneControl, 

   478         "CPhoneRingingtonePlayer::ConstructSequencePlayer - err(%d)", err );    

   479         }

   480     }

   481 // -----------------------------------------------------------------------------

   482 //

   483 // -----------------------------------------------------------------------------

   484 //

   485 void CPhoneRingingtonePlayer::ConstructSequencePlayerL( TPlayerId aId )

   486     {

   487     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConstructSequencePlayerL()" );

   488     // Construct beep once player

   489     if ( aId == EPlayerBeepOnce )

   490         {

   491 #ifdef __WINS__    

   492         TParse* fp = new (ELeave) TParse();

   493         fp->Set( KPhoneBeepOnceSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); 

   494         TFileName fileName( fp->FullName() );

   495         delete fp;

   496 

   497         iBeepOncePlayer = CPhoneAudioPlayer::NewL(

   498             fileName, 

   499             KAudioPriorityPhoneCall,

   500             KAudioPrefIncomingCall,

   501             *this, 

   502             EPlayerBeepOnce );

   503 #else

   504         iBeepOncePlayer = CPhoneAudioPlayer::NewSeqL(

   505             KPhoneBeepSequence(),

   506             KAudioPriorityPhoneCall,

   507             KAudioPrefIncomingCall,

   508             *this, 

   509             EPlayerBeepOnce );

   510 #endif // __WINS__

   511         }

   512 

   513     // Construct Silent Player.

   514     else if ( aId == EPlayerSilent )

   515         {

   516 #ifdef __WINS__

   517         TParse* fp = new (ELeave) TParse();

   518         fp->Set( KPhoneSilentSoundFile, &KDC_RESOURCE_FILES_DIR, NULL ); 

   519         TFileName fileName( fp->FullName() );

   520         delete fp;

   521 

   522         iSilentPlayer = CPhoneAudioPlayer::NewL( 

   523             fileName, 

   524             KAudioPriorityPhoneCall,

   525             KAudioPrefIncomingCall,

   526             *this, 

   527             EPlayerSilent );

   528 #else

   529         iSilentPlayer = CPhoneAudioPlayer::NewSeqL(

   530             KPhoneNoSoundSequence(),

   531             KAudioPriorityPhoneCall,

   532             KAudioPrefIncomingCall,

   533             *this,

   534             EPlayerSilent );

   535 #endif // __WINS__

   536         }        

   537     }

   538 

   539 // -----------------------------------------------------------------------------

   540 // 

   541 // -----------------------------------------------------------------------------

   542 //

   543 void CPhoneRingingtonePlayer::HandleAudioPlayerError( 

   544     TPhoneAudioPlayerErrorEvent /*aEvent*/, 

   545     TInt aError, 

   546     TInt /*aId*/ )

   547     {

   548     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::HandleAudioPlayerError()" );

   549     // This is called from CPhoneAudioPlayer - we do not 

   550     // want to delete instances from which this method

   551     // is called.

   552     

   553      __PHONELOG1( EBasic, 

   554                  EPhoneControl, 

   555                  "CPhoneRingingtonePlayer::HandleAudioPlayerError - error (%d)",

   556                  aError ); 

   557 

   558     const TBool deleteAll = ( aError == KErrServerTerminated );

   559 

   560     if ( deleteAll )

   561         {

   562         // KErrServerTerminated is considered as fatal error. So we

   563         // need to delete everything.

   564 

   565         for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ )

   566             {

   567             DeletePlayerAsync( static_cast< TPlayerId >( i ) );

   568             }

   569 

   570         // Now all member audio players point to NULL, except

   571         // those players in iAsyncDeletePlayers. Recreate 

   572         // players.

   573 

   574         ConstructBackupPlayer(); // Ignore error code.

   575         }

   576 

   577     iTimer->Cancel();

   578     DoHandlePlayerError( !deleteAll, EFalse );

   579     }

   580 

   581 // -----------------------------------------------------------------------------

   582 // 

   583 // -----------------------------------------------------------------------------

   584 //

   585 void CPhoneRingingtonePlayer::HandleAudioPlayerInitComplete( TInt aId )

   586     {

   587     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::HandleAudioPlayerInitComplete()" );

   588     // This is called from CPhoneAudioPlayer - we do not 

   589     // want to delete instances from which this method

   590     // is called. 

   591 

   592     if ( iTonePlayingStatus == EAudioTonePlaying && aId == EPlayerAudio ||

   593         iTonePlayingStatus == EDefaultTonePlaying && aId == EPlayerDefault )

   594         {

   595         iTimer->Cancel();

   596         }

   597     }

   598 

   599 // -----------------------------------------------------------------------------

   600 // CPhoneRingingtonePlayer::HandlePlayingComplete

   601 // -----------------------------------------------------------------------------

   602 //

   603 void CPhoneRingingtonePlayer::HandlePlayingComplete( TInt /*aId*/ )

   604     {

   605     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::HandlePlayingComplete()" );

   606     // This is called from CPhoneAudioPlayer - we do not 

   607     // want to delete instances from which this method

   608     // is called. 

   609 

   610 

   611     __PHONELOG1( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::HandlePlayingComplete - delete player - iTonePlayingStatus(%d)",

   612         iTonePlayingStatus ); 

   613 /*    if (iAudioVideoRingingTone->TtsToneToBePlayed() &&

   614         iAudioVideoRingingTone->RingingType() == EProfileRingingTypeRinging )

   615         {

   616         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::HandlePlayingComplete - return" ); 

   617         return;

   618         }*/

   619     

   620     switch( iTonePlayingStatus )

   621         {

   622         case EAudioTonePlaying:

   623             DeletePlayerAsync( EPlayerAudio );

   624             iAudioPlayer = NULL;

   625             break;

   626             

   627         case EDefaultTonePlaying:

   628             DeletePlayerAsync( EPlayerDefault );

   629             iDefaultPlayer = NULL;

   630             break;

   631             

   632         case ESilentTonePlaying:

   633             DeletePlayerAsync( EPlayerSilent );

   634             iSilentPlayer = NULL;

   635             break;

   636             

   637         case EBeepOnce:

   638             DeletePlayerAsync( EPlayerBeepOnce );

   639             iBeepOncePlayer = NULL;

   640             break;

   641             

   642         case EVideoTonePlaying:

   643         case EPersonalVideoTonePlaying:

   644             DeletePlayerAsync( EPlayerBeepOnce );

   645             iBeepOncePlayer = NULL;

   646             return; // beep once + video

   647             

   648         case EBackupTonePlaying:

   649             break;

   650             

   651         default:

   652             Panic( EPhoneViewCaseNotHandled );

   653             break;

   654         }

   655 

   656     iTonePlayingStatus = EIdle;

   657     }

   658 

   659 // -----------------------------------------------------------------------------

   660 // 

   661 // -----------------------------------------------------------------------------

   662 //

   663 void CPhoneRingingtonePlayer::DeletePlayerAsync( TPlayerId aPlayer )

   664     {

   665     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::DeletePlayerAsync()" );

   666     __ASSERT_DEBUG( aPlayer >= EPlayerFirst && aPlayer < iAsyncDeletePlayers.Count(),

   667         Panic( EPhoneViewInvariant ) );

   668         

   669     // Player is not deleted here, but in RunL.

   670     Cancel();

   671 

   672     if ( iAsyncDeletePlayers[ aPlayer ] ) 

   673         {

   674         delete iAsyncDeletePlayers[ aPlayer ];

   675         iAsyncDeletePlayers[ aPlayer ] = NULL;

   676         }

   677 

   678     CPhoneAudioPlayer** players[] =

   679         {

   680         &iAudioPlayer,

   681         &iBeepOncePlayer,

   682         &iSilentPlayer,

   683         &iDefaultPlayer,

   684         &iBackupPlayer,

   685         &iTtsPlayer

   686         };

   687 

   688     __ASSERT_DEBUG( iAsyncDeletePlayers.Count() > aPlayer, Panic( EPhoneUtilsIndexOutOfBounds ) );

   689     iAsyncDeletePlayers[ aPlayer ] = 

   690         *(players[ aPlayer ]);

   691     *(players[ aPlayer ]) = NULL;

   692 

   693     iState = EDeletingAudioPlayer;

   694 

   695     TRequestStatus* status = &iStatus;

   696     User::RequestComplete( status, KErrNone );

   697     SetActive();

   698     }

   699 

   700 // -----------------------------------------------------------------------------

   701 //

   702 // -----------------------------------------------------------------------------

   703 //

   704 void CPhoneRingingtonePlayer::RunL()

   705     {

   706     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::RunL()" );

   707 

   708     switch ( iState )

   709         {

   710         case EDeletingAudioPlayer:

   711             {

   712             for ( TInt i = EPlayerFirst; i <= EPlayerLast; i++ )

   713                 {

   714                 delete iAsyncDeletePlayers[ i ];

   715                 iAsyncDeletePlayers[ i ] = NULL;

   716                 }

   717             }

   718             break;

   719 

   720       case EPlayingDefaultVideo:

   721             {

   722             //PlayAudioRingTone( iVolume, iRingingType );

   723             }

   724             break;

   725 

   726         case EIdleState:  

   727         default:

   728             break;

   729         } // switch iState

   730     

   731     iState = EIdleState;

   732     }

   733 // -----------------------------------------------------------------------------

   734 // 

   735 // -----------------------------------------------------------------------------

   736 //

   737 void CPhoneRingingtonePlayer::DoCancel()

   738     {

   739     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::DoCancel()" );

   740     // Request is completed immediately before SetActive.

   741     }

   742 

   743 

   744 // -----------------------------------------------------------

   745 // CPhoneRingingtonePlayer::HandleCenRepChangeL

   746 // -----------------------------------------------------------

   747 //

   748 void CPhoneRingingtonePlayer::HandleCenRepChangeL( 

   749     const TUid& aUid,

   750     const TUint /*aId*/ )

   751     {

   752     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::HandleCenRepChangeL()");

   753     

   754     if ( aUid == KCRUidDRMHelperServer )

   755         {

   756         }

   757     }

   758 

   759 // -----------------------------------------------------------------------------

   760 // 

   761 // -----------------------------------------------------------------------------

   762 //

   763 void CPhoneRingingtonePlayer::HandleTimeOutL()

   764     {

   765     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::HandleTimeOutL()" );

   766    /* if( iActiveCoverUICommand )

   767         {

   768         iMediatorSender->CancelCommand( 

   769             EPhoneCmdCoverUiShowMultimediaRingingTone );

   770         PlayDefaultTone( iVolume, iRingingType );

   771         iActiveCoverUICommand = EFalse;

   772         }*/

   773 

   774     // Guarding timer for startup has expired

   775     if ( iTonePlayingStatus == EVideoTonePlaying ||

   776          iTonePlayingStatus == ESilentVideoTonePlaying ||   

   777          iTonePlayingStatus == EPersonalVideoTonePlaying )

   778         {

   779         //iVideoPlayer->CancelVideoRingTone(); // close video ringtone display

   780         PlayDefaultTone( iVolume, iRingingType );

   781         }

   782     else

   783         {

   784         // Start new audio player synchronously.

   785         DoHandlePlayerError( ETrue, ETrue );

   786         }           

   787     

   788     }

   789 // -----------------------------------------------------------------------------

   790 // 

   791 // -----------------------------------------------------------------------------

   792 //

   793 void CPhoneRingingtonePlayer::DoHandlePlayerError(TBool aDelete, TBool aSync )

   794     {

   795     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::DoHandlePlayerError()" );

   796     switch ( iTonePlayingStatus )

   797         {

   798         case EAudioTonePlaying:

   799             if ( aDelete )

   800                 {

   801                 if ( aSync )

   802                     {

   803                     delete iAudioPlayer;

   804                     }

   805                 else

   806                     {

   807                     DeletePlayerAsync( EPlayerAudio );

   808                     }

   809 

   810                 iAudioPlayer = NULL;

   811                 }

   812 

   813 #ifdef __WINS__

   814             //PlayAudioRingTone( iVolume, iRingingType );

   815             iTonePlayingStatus = EDefaultTonePlaying;

   816 #else

   817             PlayDefaultTone( iVolume, iRingingType );

   818 #endif

   819             break;

   820         case EDefaultTonePlaying:

   821             if ( aDelete )

   822                 {

   823                 if ( aSync )

   824                     {

   825                     delete iDefaultPlayer;

   826                     }

   827                 else

   828                     {

   829                     DeletePlayerAsync( EPlayerDefault );

   830                     }

   831 

   832                 iDefaultPlayer = NULL;

   833                 }

   834 

   835             PlayBackupTone( iVolume, iRingingType );

   836             break;

   837         case ESilentTonePlaying:

   838         case EBeepOnce:

   839         case EBackupTonePlaying:

   840             break;

   841         default:

   842             break;

   843         }

   844     }

   845 // -----------------------------------------------------------------------------

   846 // 

   847 // -----------------------------------------------------------------------------

   848 //

   849 CPhoneAudioPlayer::TRingingType CPhoneRingingtonePlayer::ConvertRingingType(

   850     TProfileRingingType aRingingType )

   851     {

   852     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ConvertRingingType()" );

   853 

   854     CPhoneAudioPlayer::TRingingType ringingType = 

   855         CPhoneAudioPlayer::ETypeRinging;

   856     switch ( aRingingType )

   857         {

   858         case EProfileRingingTypeRinging:

   859             ringingType = CPhoneAudioPlayer::ETypeRinging;

   860             break;

   861 

   862         case EProfileRingingTypeAscending:

   863             ringingType = CPhoneAudioPlayer::ETypeAscending;

   864             break;

   865 

   866         case EProfileRingingTypeRingingOnce:

   867             ringingType = CPhoneAudioPlayer::ETypeRingingOnce;

   868             break;

   869 

   870         default:

   871             break;

   872         }

   873     return ringingType;

   874     }

   875 

   876 // -----------------------------------------------------------------------------

   877 // 

   878 // -----------------------------------------------------------------------------

   879 //    

   880 CPhoneAudioPlayer* 

   881 CPhoneRingingtonePlayer::GetCurrentlyActiveAudioPlayer()

   882     {    

   883     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::GetCurrentlyActiveAudioPlayerWithTTs()" );

   884 

   885     if( iAudioPlayer )

   886         {

   887         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::GetCurrentlyActiveAudioPlayerWithTTs - audio player" ); 

   888         return iAudioPlayer;         

   889         }

   890     else if ( iDefaultPlayer )

   891         {

   892         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::GetCurrentlyActiveAudioPlayerWithTTs - default player" ); 

   893         return iDefaultPlayer;     

   894         }

   895     else if( iBackupPlayer )

   896         {

   897         __PHONELOG( EBasic, EPhoneControl, "CPhoneRingingtonePlayer::GetCurrentlyActiveAudioPlayerWithTTs - backup player" ); 

   898         return iBackupPlayer;

   899         }

   900     else

   901         {

   902         return NULL;

   903         }

   904     }

   905 

   906 // -----------------------------------------------------------------------------

   907 // 

   908 // -----------------------------------------------------------------------------

   909 //

   910 void CPhoneRingingtonePlayer::MuteActiveAudioPlayer()

   911     {

   912     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneRingingtonePlayer::ActiveAudioPlayer()" );

   913 

   914     switch( iTonePlayingStatus )

   915         {

   916         case EAudioTonePlaying:

   917             if( iAudioPlayer )

   918                 {

   919                 iAudioPlayer->MutePlaying();

   920                 }

   921             break;

   922             

   923         case EDefaultTonePlaying:

   924             if ( iDefaultPlayer )

   925                 {

   926                 return iDefaultPlayer->MutePlaying();

   927                 }

   928             break;

   929             

   930         case EBeepOnce:

   931             if( iBeepOncePlayer )

   932                 {

   933                 return iBeepOncePlayer->MutePlaying();

   934                 }

   935             break;

   936             

   937         case EBackupTonePlaying:

   938             if( iBackupPlayer )

   939                 {

   940                 return iBackupPlayer->MutePlaying();

   941                 }

   942             break;

   943             

   944         case ESilentTonePlaying:

   945             if( iSilentPlayer )

   946                 {

   947                 return iSilentPlayer->MutePlaying();

   948                 }

   949             break;

   950             

   951         case EVideoTonePlaying: // video ringing tone

   952         case EPersonalVideoTonePlaying:

   953         case ESilentVideoTonePlaying:

   954             if ( iBeepOncePlayer )

   955                 {

   956                 return iBeepOncePlayer->MutePlaying();                    

   957                 }    

   958             else if ( iSilentPlayer )

   959                 {

   960                 return iSilentPlayer->MutePlaying();                    

   961                 }    

   962             break;

   963             

   964         default:

   965             break;

   966         }      

   967     }