1 /*

     2 * Copyright (c) 2008 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 the License "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 

    19 #include <S32STRM.H>

    20 #include <S32MEM.H>

    21 

    22 #include "VCXTestLog.h"

    23 #include "CIptvTestActiveWait.h"

    24 #include "VCXTestCommon.h"

    25 

    26 #include "FusionMpxPlayerTester.h"

    27 #include "FusionMpxPlayerTestCommon.h"

    28 

    29 #include <mpxplaybackutility.h>

    30 #include <mpxplaybackmessage.h>

    31 #include <mpxmessagegeneraldefs.h>

    32 #include <mpxcommandgeneraldefs.h>

    33 #include <mpxplaybackframeworkdefs.h>

    34 #include <mpxviewutility.h>

    35 #include <mpxmediabase.h>

    36 #include <mpxcommandgeneraldefs.h>

    37 #include <mpxcollectionutility.h>

    38 #include <mpxmediacontainerdefs.h>

    39 #include <mpxmediageneraldefs.h>

    40 #include <mpxcollectionplaylist.h>

    41 

    42 #include <mpxvideoplaybackdefs.h>

    43 #include <vcxmyvideosuids.h>

    44 #include <vcxmyvideosdefs.h>

    45 

    46 // CONSTANTS

    47 // From mpxvideoplayerconstants.h

    48 const TUid KVideoPlaybackViewUid = { 0x200159AD };

    49 _LIT8( KDATATYPEVIDEOHELIX, "video/videohelix" );

    50 

    51 // -----------------------------------------------------------------------------

    52 // CFusionMpxPlayerTester::NewL

    53 // -----------------------------------------------------------------------------

    54 //

    55 CFusionMpxPlayerTester* CFusionMpxPlayerTester::NewL( MFusionMpxPlayerTesterObserver* aObserver )

    56     {

    57     VCXLOGLO1(">>>CFusionMpxPlayerTester::NewL");

    58     CFusionMpxPlayerTester* self = new (ELeave) CFusionMpxPlayerTester();

    59     CleanupStack::PushL(self);

    60     self->ConstructL( aObserver );

    61     CleanupStack::Pop(self);

    62     VCXLOGLO1("<<<CFusionMpxPlayerTester::NewL");

    63     return self;

    64     }

    65 

    66 // -----------------------------------------------------------------------------

    67 // CFusionMpxPlayerTester::CFusionMpxPlayerTester

    68 // -----------------------------------------------------------------------------

    69 //

    70 CFusionMpxPlayerTester::CFusionMpxPlayerTester()

    71     {

    72     }

    73 

    74 // -----------------------------------------------------------------------------

    75 // CFusionMpxPlayerTester::ConstructL

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

    77 //

    78 void CFusionMpxPlayerTester::ConstructL( MFusionMpxPlayerTesterObserver* aObserver )

    79     {

    80     VCXLOGLO1(">>>CFusionMpxPlayerTester::ConstructL");

    81 

    82     iWait = CIptvTestActiveWait::NewL();

    83     

    84     iObserver = aObserver;

    85     

    86     iViewUtility = MMPXViewUtility::UtilityL();

    87     iViewUtility->AddObserverL( this );

    88     iViewUtility->ConstructDefaultViewHistoryL();

    89 

    90     VCXLOGLO1("<<<CFusionMpxPlayerTester::ConstructL");

    91     }

    92 

    93 // -----------------------------------------------------------------------------

    94 // CFusionMpxPlayerTester::~CFusionMpxPlayerTester

    95 // -----------------------------------------------------------------------------

    96 //

    97 CFusionMpxPlayerTester::~CFusionMpxPlayerTester()

    98     {

    99     VCXLOGLO1(">>>CFusionMpxPlayerTester::~CFusionMpxPlayerTester");

   100 

   101     if ( iViewUtility )

   102         {

   103         iViewUtility->RemoveObserver( this );

   104         iViewUtility->Close();

   105         VCXLOGLO1("CFusionMpxPlayerTester::~CFusionMpxPlayerTester - viewUtility destroyed.");

   106         }

   107     

   108     if( iPlaybackUtility )

   109         {

   110         TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) ); 

   111         iPlaybackUtility->Close();

   112         VCXLOGLO1("CFusionMpxPlayerTester::~CFusionMpxPlayerTester - playbackutility destroyed.");

   113         }

   114 

   115     iExpectedGeneralMessages.Reset();

   116     

   117     delete iWait;

   118     iWait = NULL;    

   119     

   120     VCXLOGLO1("<<<CFusionMpxPlayerTester::~CFusionMpxPlayerTester");

   121     }

   122 

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

   124 // CFusionMpxPlayerTester::OpenLocalFile

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

   126 //

   127 TInt CFusionMpxPlayerTester::OpenLocalFile( const TDesC& aFileName )

   128     {

   129     VCXLOGLO1(">>>CFusionMpxPlayerTester::OpenLocalFile");

   130     

   131     VCXLOGLO2("CFusionMpxPlayerTester::OpenLocalFileL: aFileName: %S", &aFileName);

   132   

   133     iExpectedGeneralMessages.Append( 

   134             TExpectedGeneralMessage( TMPXPlaybackMessage::EPlayerChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

   135     iExpectedGeneralMessages.Append( 

   136             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialising, KFusionTestMsgNone ) );

   137     iExpectedGeneralMessages.Append( 

   138             TExpectedGeneralMessage( TMPXPlaybackMessage::EMediaChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

   139     // Start playback is always true

   140     iExpectedGeneralMessages.Append( 

   141             TExpectedGeneralMessage( TMPXPlaybackMessage::EInitializeComplete, KFusionTestMsgNone, 1 ) );

   142     iExpectedGeneralMessages.Append( 

   143             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialised, KFusionTestMsgNone ) );

   144     iExpectedGeneralMessages.Append( 

   145             TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyPosition, 0 ) );

   146     iExpectedGeneralMessages.Append( 

   147             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateBuffering, KFusionTestMsgNone ) );

   148     iExpectedGeneralMessages.Append( 

   149             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

   150 

   151     if( !iPlaybackUtility )

   152         {

   153         iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer );

   154         iPlaybackUtility->AddObserverL( *this );

   155         iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse );

   156         }

   157     

   158     TInt err( KErrNone );

   159     

   160     TRAP( err, iViewUtility->PreLoadViewL( KVideoPlaybackViewUid ) );

   161     if( err == KErrNone ) 

   162         {       

   163         TRAP( err, iPlaybackUtility->InitL( aFileName ) );

   164         }

   165     else

   166         {

   167         VCXLOGLO2("CFusionMpxPlayerTester:: PreLoadViewL left: %d", err);

   168         }

   169 

   170     VCXLOGLO1("<<<CFusionMpxPlayerTester::OpenLocalFile");

   171     return err;

   172     }

   173 

   174 // -----------------------------------------------------------------------------

   175 // CFusionMpxPlayerTester::OpenUrlL

   176 // -----------------------------------------------------------------------------

   177 //

   178 void CFusionMpxPlayerTester::OpenUrlL( const TDesC& aUrl, TInt aIapId )

   179     {

   180     VCXLOGLO1(">>>CFusionMpxPlayerTester::OpenUrlL");

   181     

   182     VCXLOGLO2("CFusionMpxPlayerTester::OpenUrlL: aUrl: %S", &aUrl);

   183     VCXLOGLO2("CFusionMpxPlayerTester::OpenUrlL: aIapId: %d", aIapId);

   184     

   185     iExpectedGeneralMessages.Append( 

   186             TExpectedGeneralMessage( TMPXPlaybackMessage::EPlayerChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

   187     iExpectedGeneralMessages.Append( 

   188             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialising, KFusionTestMsgNone ) );

   189     iExpectedGeneralMessages.Append( 

   190             TExpectedGeneralMessage( TMPXPlaybackMessage::EMediaChanged, KFusionTestMsgNone, KFusionTestMsgNone ) );

   191     // Start playback is always true

   192     iExpectedGeneralMessages.Append( 

   193             TExpectedGeneralMessage( TMPXPlaybackMessage::EInitializeComplete, KFusionTestMsgNone, 1 ) );

   194     iExpectedGeneralMessages.Append( 

   195             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateInitialised, KFusionTestMsgNone ) );

   196     iExpectedGeneralMessages.Append( 

   197             TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyPosition, 0 ) );

   198     iExpectedGeneralMessages.Append( 

   199             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateBuffering, KFusionTestMsgNone ) );

   200     iExpectedGeneralMessages.Append( 

   201             TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

   202     

   203     if( !iPlaybackUtility )

   204         {

   205         iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer );

   206         iPlaybackUtility->AddObserverL( *this );

   207         iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse );

   208         }

   209     

   210     TInt err( KErrNone );

   211     

   212     TRAP( err, iViewUtility->PreLoadViewL( KVideoPlaybackViewUid ) );

   213     if( err == KErrNone ) 

   214         {       

   215         iPlaybackUtility->InitStreamingL( aUrl,

   216                                       (TDesC8*)(&KDATATYPEVIDEOHELIX),

   217                                       aIapId );

   218         }

   219     else

   220         {

   221         VCXLOGLO2("CFusionMpxPlayerTester:: PreLoadViewL left: %d", err);

   222         }    

   223 

   224     VCXLOGLO1("<<<CFusionMpxPlayerTester::OpenUrlL");

   225     }

   226 

   227 // -------------------------------------------------------------------------------------------------

   228 //   CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL()

   229 // -------------------------------------------------------------------------------------------------

   230 //

   231 void CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL( TMPXPlaybackCommand aCmd, TInt aData )

   232     {

   233     VCXLOGLO1(">>>CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL");

   234     

   235     TBuf<256> cmdName;

   236     GetGeneralPlaybackCommandDes( aCmd, cmdName );

   237     VCXLOGLO2(">>>CFusionMpxPlayerTester:: cmd: %S", &cmdName);

   238 

   239     CMPXCommand* cmd = CMPXCommand::NewL();

   240     CleanupStack::PushL( cmd );

   241 

   242     cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

   243     cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );

   244     cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );

   245     cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, aCmd );

   246     

   247     AddExpectedGeneralPlaybackCommandMessages( aCmd, aData );

   248     

   249     if( aData != KTestUndefined )

   250         {

   251         cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralData, aData );

   252         }

   253 

   254     iPlaybackUtility->CommandL( *cmd );

   255 

   256     CleanupStack::PopAndDestroy( cmd );

   257     

   258     if( iExpectedGeneralMessages.Count() == 0 )

   259         {

   260         iObserver->TesterCommandComplete();

   261         }

   262 

   263     VCXLOGLO2("<<<CFusionMpxPlayerTester::CreateGeneralPlaybackCommandL (%d)", aCmd );

   264     }

   265 

   266 // -------------------------------------------------------------------------------------------------

   267 // CFusionMpxPlayerTester::CreateVideoPlaybackCommandL

   268 // -------------------------------------------------------------------------------------------------

   269 //

   270 void CFusionMpxPlayerTester::CreateVideoPlaybackCommandL( TMPXVideoPlaybackCommand aCmd )

   271     {

   272     VCXLOGLO1(">>>CFusionMpxPlayerTester::CreateVideoPlaybackCommandL");

   273 

   274     TBuf<256> cmdName;

   275     GetVideoPlaybackCommandDes( aCmd, cmdName );

   276     VCXLOGLO2(">>>CFusionMpxPlayerTester:: cmd: %S", &cmdName);

   277 

   278     CMPXCommand* cmd = CMPXCommand::NewL();

   279     CleanupStack::PushL( cmd );

   280 

   281     cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

   282     cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback );

   283     cmd->SetTObjectValueL<TMPXVideoPlaybackCommand>(KMPXMediaVideoPlaybackCommand, aCmd );

   284     

   285     AddExpectedVideoPlaybackCommandMessages( aCmd );

   286     

   287     iPlaybackUtility->CommandL( *cmd );

   288 

   289     CleanupStack::PopAndDestroy( cmd );

   290     

   291     if( iExpectedGeneralMessages.Count() == 0 )

   292         {

   293         iObserver->TesterCommandComplete();

   294         }

   295 

   296     VCXLOGLO1("<<<CFusionMpxPlayerTester::CreateVideoPlaybackCommandL");

   297     }

   298 

   299 // -------------------------------------------------------------------------------------------------

   300 // CFusionMpxPlayerTester::CheckExpectedMessages

   301 // -------------------------------------------------------------------------------------------------

   302 //

   303 TInt CFusionMpxPlayerTester::CheckExpectedMessages()

   304     {

   305     VCXLOGLO1(">>>CFusionMpxPlayerTester::CheckExpectedMessages");

   306     

   307     TInt err( KErrNone );

   308     

   309     if( iExpectedGeneralMessages.Count() > 0 )

   310         {

   311         err = KErrCorrupt;

   312         VCXLOGLO1("CFusionMpxPlayerTester:: Did not get all expected general messages, error!");

   313         

   314         for( TInt i=0; i<iExpectedGeneralMessages.Count(); i++ )

   315             {

   316             TBuf<256> eventBuff( _L("") );

   317             TBuf<256> typeBuff( _L("") );

   318             TBuf<64> dataBuff( _L("") );

   319             

   320             TInt event = iExpectedGeneralMessages[i].iEvent;

   321             

   322             GetGeneralPlaybackEventDes( event, eventBuff );

   323 

   324             if( iExpectedGeneralMessages[i].iData != KFusionTestMsgNone )

   325                 {

   326                 dataBuff.AppendNum( iExpectedGeneralMessages[i].iData );

   327                 }

   328             

   329             if( event == TMPXPlaybackMessage::EStateChanged )

   330                 {

   331                 GetStateDes( static_cast<TMPXPlaybackState>(iExpectedGeneralMessages[i].iType), typeBuff );

   332                 }

   333             

   334             if( event == TMPXPlaybackMessage::EPropertyChanged )

   335                 {

   336                 GetPropertyDes( static_cast<TMPXPlaybackProperty>(iExpectedGeneralMessages[i].iType), typeBuff );

   337                 }

   338             

   339             VCXLOGLO4("CFusionMpxPlayerTester:: event %S = %S ( %S )", &eventBuff, &typeBuff, &dataBuff);

   340             }

   341         }

   342     

   343     VCXLOGLO1("<<<CFusionMpxPlayerTester::CheckExpectedMessages");

   344     return err;

   345     }

   346 

   347 // -------------------------------------------------------------------------------------------------

   348 // CFusionMpxPlayerTester::AddExpectedGeneralPlaybackCommandMessages

   349 // -------------------------------------------------------------------------------------------------

   350 //

   351 void CFusionMpxPlayerTester::AddExpectedGeneralPlaybackCommandMessages( TMPXPlaybackCommand aCmd, TInt &aData )

   352     {

   353     switch( aCmd )

   354         {

   355         case EPbCmdPlay: // 0 Play which ever track is currently stopped, paused etc.

   356             {

   357             iExpectedGeneralMessages.Append( 

   358                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

   359             }

   360             break;

   361         case EPbCmdPlayWithFadeIn: // 1 uses KPbFadeInDuration

   362             {

   363             

   364             }

   365             break;

   366         case EPbCmdPause:    // 2

   367             {

   368             iExpectedGeneralMessages.Append( 

   369                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePaused, KFusionTestMsgNone ) );

   370             }

   371             break;

   372         case EPbCmdStop:     // 3

   373             {

   374             iExpectedGeneralMessages.Append( 

   375                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateStopped, KFusionTestMsgNone ) );

   376             }

   377             break;

   378         case EPbCmdNext:     // 4 No effect if no next track

   379             {

   380             

   381             }

   382             break;

   383         case EPbCmdPrevious: // 5 No effect if no previous track;

   384                         //   if pos>KPbReplayThreshold, replays current track

   385             {

   386             

   387             }

   388             break;

   389         case EPbCmdReplay:   // 6 Restart current track at beginning

   390             {

   391             iExpectedGeneralMessages.Append( 

   392                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyPosition, 0 ) );           

   393             iExpectedGeneralMessages.Append( 

   394                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

   395             }

   396             break;

   397         case EPbCmdStartSeekForward:  // 7

   398             {

   399             iExpectedGeneralMessages.Append( 

   400                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateSeekingForward, KFusionTestMsgNone ) );

   401             

   402             }

   403             break;

   404         case EPbCmdStartSeekBackward: // 8

   405             {

   406             iExpectedGeneralMessages.Append( 

   407                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateSeekingBackward, KFusionTestMsgNone ) );

   408             }

   409             break;

   410         case EPbCmdStopSeeking:       // 9

   411             {

   412             iExpectedGeneralMessages.Append( 

   413                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

   414             }

   415             break;

   416         case EPbCmdIncreaseVolume:    // 10

   417             {

   418             VCXLOGLO1("CFusionMpxPlayerTester:: Getting volume.");

   419             // Get volume.

   420             iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

   421             iWait->Start();

   422             

   423             TInt vol = iVolume + 10;

   424             if( vol > 100 ) vol = 100;

   425                         

   426             iExpectedGeneralMessages.Append( 

   427                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, vol ) );           

   428             }

   429             break;

   430         case EPbCmdDecreaseVolume:    // 11

   431             {

   432             // Get volume.

   433             iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

   434             iWait->Start();

   435             

   436             TInt vol = iVolume - 10;

   437             if( vol < 0 ) 

   438                 {

   439                 vol = 0;

   440                 }

   441 

   442             iExpectedGeneralMessages.Append( 

   443                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, vol ) );           

   444             }

   445             break;

   446         case EPbCmdMuteVolume:        // 12

   447             {

   448             // Get volume.

   449             iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

   450             iWait->Start();

   451             

   452             iExpectedGeneralMessages.Append( 

   453                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, 0 ) );

   454             iExpectedGeneralMessages.Append( 

   455                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyMute, 1 ) );

   456             

   457             iVolumeBeforeMute = iVolume;

   458             }

   459             break;

   460         case EPbCmdUnMuteVolume:      // 13

   461             {

   462             iExpectedGeneralMessages.Append( 

   463                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, iVolumeBeforeMute ) );

   464             iExpectedGeneralMessages.Append( 

   465                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyMute, 0 ) );

   466             }

   467             break;

   468         case EPbCmdClose:             // 14

   469             {

   470             iExpectedGeneralMessages.Append( 

   471                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateStopped, KFusionTestMsgNone ) );

   472             }

   473             break;

   474         case EPbApplyEffect:          // 15 Apply an effect to the current playback,

   475                                  //    aData used to identify effect

   476             {

   477             

   478             }

   479             break;

   480         case EPbCmdPreservePosition:  // 16 Preserve playback position

   481             {

   482             

   483             }

   484             break;

   485         case EPbCmdPreserveState:     // 17 Preserve playback state

   486             {

   487             

   488             }

   489             break;

   490         case EPbCmdCloseItem:         // 18 Request to close the file handle

   491             {

   492             

   493             }

   494             break;

   495         case EPbCmdPlayPause:         // 19 Play/Pause toggle command

   496             {

   497             if( iState == EPbStatePlaying )

   498                 {

   499                 iExpectedGeneralMessages.Append( 

   500                         TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePaused, KFusionTestMsgNone ) );

   501                 }

   502             else

   503             if( iState == EPbStatePaused )

   504                 {

   505                 iExpectedGeneralMessages.Append( 

   506                         TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );

   507                 }

   508             }

   509             break;

   510         case EPbCmdCancelInit:         // 20

   511             {

   512             if( !iInitComplete )

   513                 {

   514                 iExpectedGeneralMessages.Reset();

   515                 iExpectedGeneralMessages.Append( 

   516                         TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStateStopped, KFusionTestMsgNone ) );

   517                 }

   518             }

   519             break;

   520         case EPbCmdResetPreserveState: // 21

   521             {

   522             

   523             }

   524             break;

   525         case EPbCmdUnloadNonActivePlugin: // 22 KMPXCommandPlaybackGeneralData is TUid.iUid

   526             {

   527             

   528             }

   529             break;

   530         case EPbCmdClearKeyBuffer:        // 23 Clear all media key commands

   531             {

   532             

   533             }

   534             break;

   535         case EPbCmdDisableEffect:

   536             {

   537             

   538             }

   539             break;

   540         case EPbCmdSetVolume:             // 25 Set volume to the value specified by aData

   541             {

   542             // Get volume.

   543             iPlaybackUtility->PropertyL( *this, EPbPropertyVolume );

   544             iWait->Start();

   545             // Make sure volume changes.

   546             if( aData == iVolume ) 

   547                 {

   548                 aData += 10;

   549                 if( aData > 100 ) aData -= 20;

   550                 }

   551             VCXLOGLO3("CFusionMpxPlayerTester:: volume before: %d, set to: %d", iVolume, aData );

   552             iExpectedGeneralMessages.Append( 

   553                     TExpectedGeneralMessage( TMPXPlaybackMessage::EPropertyChanged, EPbPropertyVolume, aData ) );           

   554             }

   555             break;

   556         default:

   557             break;

   558         }

   559     }

   560 

   561 // -------------------------------------------------------------------------------------------------

   562 // CFusionMpxPlayerTester::AddExpectedVideoPlaybackCommandMessages

   563 // -------------------------------------------------------------------------------------------------

   564 //

   565 void CFusionMpxPlayerTester::AddExpectedVideoPlaybackCommandMessages( TMPXVideoPlaybackCommand aCmd )

   566     {

   567     switch( aCmd )

   568         {

   569         case EPbCmdInitView:

   570             {

   571             

   572             }

   573             break;

   574         case EPbCmdAbortDSA:

   575             {

   576             

   577             }

   578             break;

   579         case EPbCmdRestartDSA:

   580             {

   581             

   582             }

   583             break;

   584         case EPbCmdSetDisplayWindow:

   585             {

   586             

   587             }

   588             break;

   589         case EPbCmdStartVideoSeekingForward:

   590             {

   591             iExpectedGeneralMessages.Append( 

   592                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePluginSeeking, KFusionTestMsgNone ) );

   593             }

   594             break;

   595         case EPbCmdStartVideoSeekingBackward:

   596             {

   597             iExpectedGeneralMessages.Append( 

   598                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePluginSeeking, KFusionTestMsgNone ) );

   599             }

   600             break;

   601         case EPbCmdStopVideoSeeking:

   602             {

   603             iExpectedGeneralMessages.Append( 

   604                     TExpectedGeneralMessage( TMPXPlaybackMessage::EStateChanged, EPbStatePlaying, KFusionTestMsgNone ) );            

   605             }

   606             break;

   607         case EPbCmdHandleForeground:

   608             {

   609             

   610             }

   611             break;

   612         case EPbCmdHandleBackground:

   613             {

   614             

   615             }

   616             break;

   617         case EPbCmdNaturalAspectRatio:

   618             {

   619             

   620             }

   621             break;

   622         case EPbCmdZoomAspectRatio:

   623             {

   624             

   625             }

   626             break;

   627         case EPbCmdStretchAspectRatio:

   628             {

   629             

   630             }

   631             break;

   632         case EPbCmdSetDefaultAspectRatio:

   633             {

   634             

   635             }

   636             break;        

   637         default:

   638             break;

   639         }

   640     }

   641 

   642 // -----------------------------------------------------------------------------

   643 // CFusionMpxPlayerTester::PrepareCloseL

   644 // -----------------------------------------------------------------------------

   645 //

   646 void CFusionMpxPlayerTester::PrepareCloseL()

   647     {

   648     if( iPlaybackUtility )

   649         {

   650         MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager();

   651         TRAP_IGNORE( manager.ClearSelectPlayersL() );

   652         iPlaybackUtility->CommandL( EPbCmdClose );

   653         }

   654     }

   655 

   656 // -----------------------------------------------------------------------------

   657 // CFusionMpxPlayerTester::HandlePlaybackMessage

   658 // -----------------------------------------------------------------------------

   659 //

   660 void CFusionMpxPlayerTester::HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError )

   661     {

   662     VCXLOGLO1(">>>CFusionMpxPlayerTester::HandlePlaybackMessage");

   663     if( aError == KErrNone && aMessage )

   664         {

   665         TMPXMessageId id( *aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ) );    

   666 

   667         if ( id == KMPXMessageGeneral )

   668             {

   669             TRAP_IGNORE( DoHandleGeneralPlaybackMessageL( *aMessage ) );

   670             }

   671         else

   672         if( id == KMPXMediaIdVideoPlayback )

   673             {

   674             TRAP_IGNORE( DoHandleVideoPlaybackMessageL( *aMessage ) );

   675             }

   676         }

   677     VCXLOGLO1("<<<CFusionMpxPlayerTester::HandlePlaybackMessage");

   678     }

   679 

   680 // -----------------------------------------------------------------------------

   681 // CFusionMpxPlayerTester::DoHandleGeneralPlaybackMessageL

   682 // -----------------------------------------------------------------------------

   683 //

   684 void CFusionMpxPlayerTester::DoHandleGeneralPlaybackMessageL( const CMPXMessage& aMessage )

   685     {

   686     VCXLOGLO1("CFusionMpxPlayerTester:: ----------------------------");

   687     VCXLOGLO1("CFusionMpxPlayerTester::  KMPXMessageGeneral message ");

   688     VCXLOGLO1("CFusionMpxPlayerTester:: ----------------------------");

   689     

   690     TInt event = *aMessage.Value<TInt>( KMPXMessageGeneralEvent );

   691     TInt type = *aMessage.Value<TInt>( KMPXMessageGeneralType );

   692     TInt data = *aMessage.Value<TInt>( KMPXMessageGeneralData );

   693     

   694     for( TInt i=0; i<iExpectedGeneralMessages.Count(); i++ )

   695         {

   696         if( iExpectedGeneralMessages[i].iEvent == event && 

   697             ( iExpectedGeneralMessages[i].iType == type || iExpectedGeneralMessages[i].iType == KFusionTestMsgNone ) &&  

   698             ( iExpectedGeneralMessages[i].iData == data || iExpectedGeneralMessages[i].iData == KFusionTestMsgNone ) )

   699             {

   700             iExpectedGeneralMessages.Remove( i );

   701             

   702             if( iExpectedGeneralMessages.Count() == 0 && iObserver )

   703                 {

   704                 iObserver->TesterCommandComplete();

   705                 }

   706             break;

   707             }

   708         }

   709     

   710     switch ( event )

   711         {

   712         case TMPXPlaybackMessage::ENoEvent:

   713             {

   714             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ENoEvent");

   715             break;

   716             }

   717         case TMPXPlaybackMessage::EError: // EError must be 1. iData is error originating from player: iType=event type

   718             {

   719             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EError ------>");

   720             VCXLOGLO2("CFusionMpxPlayerTester:: type: %d", type);

   721             VCXLOGLO2("CFusionMpxPlayerTester:: data: %d", data);

   722             break;

   723             }

   724         case TMPXPlaybackMessage::ECommandReceived: // iType=TMPXPlaybackCommand

   725             {

   726             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ECommandReceived");

   727             break;

   728             }

   729         case TMPXPlaybackMessage::ECommandComplete: // iType=TMPXPlaybackCommand

   730             {

   731             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ECommandComplete ------>");

   732             break;

   733             }

   734         case TMPXPlaybackMessage::EPropertyChanged: // iType=TMPXPlaybackProperty; iData=new value

   735             {

   736             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EPropertyChanged ------>");

   737             DoHandlePropertyChangeL( type, data );

   738             break;

   739             }

   740         case TMPXPlaybackMessage::EStateChanged: // iType=TMPXPlaybackState

   741             {

   742             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EStateChanged ------>");

   743             DoHandleStateChangeL( static_cast<TMPXPlaybackState>( type ) );

   744             break;

   745             }

   746         case TMPXPlaybackMessage::ESongCorrupt:

   747             {

   748             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ESongCorrupt");

   749             break;

   750             }

   751         case TMPXPlaybackMessage::ESongContainerChanged: // Need to call MMPXMedia::CollectionPathL() to get new path

   752             {

   753             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ESongContainerChanged");

   754             break;

   755             }

   756         case TMPXPlaybackMessage::EInitializeComplete: // iData = ETrue if init was to start playback: else EFalse.

   757             {

   758             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EInitializeComplete ------>");

   759             VCXLOGLO2("CFusionMpxPlayerTester:: data (start playback): %d", data);                

   760             break;

   761             }

   762         case TMPXPlaybackMessage::ESongChanged: // iData=new index; need to query to get new properties (e.g. duration: title etc.)

   763             {

   764             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ESongChanged ------>");

   765             VCXLOGLO2("CFusionMpxPlayerTester:: data: %d", data);

   766             break;

   767             }

   768         case TMPXPlaybackMessage::EPlayerChanged:

   769             {

   770             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EPlayerChanged ------>");

   771             

   772             MMPXPlayer* player = iPlaybackUtility->PlayerManager().CurrentPlayer();

   773 

   774             TUid pluginUid( KNullUid );

   775             RArray<TUid> array;

   776 

   777             CleanupClosePushL( array );

   778 

   779             if ( player )

   780                 {

   781                 pluginUid = player->UidL();

   782                 array.AppendL( pluginUid );

   783                 VCXLOGLO1("CFusionMpxPlayerTester:: UID added for ActivateViewL");

   784                 }

   785             

   786             TRAPD( err, iViewUtility->ActivateViewL( array ) );

   787             if( err != KErrNone )

   788                 {

   789                 VCXLOGLO2("CFusionMpxPlayerTester:: ActivateViewL left: %d", err);

   790                 }

   791             

   792             CleanupStack::PopAndDestroy( &array );            

   793             break;

   794             }

   795         case TMPXPlaybackMessage::EActivePlayerChanged: // iData=active/inactive (ETrue/EFalse); iType (ETrue:rebind to  ActivePlayerMode)

   796             {

   797             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EActivePlayerChanged ------>");

   798             VCXLOGLO2("CFusionMpxPlayerTester:: type (rebind): %d", type);

   799             VCXLOGLO2("CFusionMpxPlayerTester:: data (active): %d", data);                

   800             break;

   801             }

   802         case TMPXPlaybackMessage::ESubPlayersChanged: // Need to query to get new list of sub players

   803             {

   804             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ESubPlayersChanged");

   805             break;

   806             }

   807         case TMPXPlaybackMessage::EPlayerSelectionChanged: // Need to query MMPXPlayerManager::GetSelectionL()

   808             {

   809             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EPlayerSelectionChanged");

   810             break;

   811             }

   812         case TMPXPlaybackMessage::EDownloadStarted: // iData=total expected bytes

   813             {

   814             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadStarted ------>");

   815             VCXLOGLO2("CFusionMpxPlayerTester:: data (expected bytes): %d", data);                

   816             break;

   817             }

   818         case TMPXPlaybackMessage::EDownloadUpdated: // iData=total bytes so far

   819             {

   820             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadUpdated ------>");

   821             VCXLOGLO2("CFusionMpxPlayerTester:: type (rebind): %d", type);

   822             VCXLOGLO2("CFusionMpxPlayerTester:: data (bytes downloaded): %d", data);                

   823             break;

   824             }

   825         case TMPXPlaybackMessage::EDownloadComplete: // iData=total bytes downloaded

   826             {

   827             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadComplete ------>");

   828             VCXLOGLO2("CFusionMpxPlayerTester:: data (bytes downloaded): %d", data);                

   829             break;

   830             }

   831         case TMPXPlaybackMessage::EDownloadPositionChanged: // iData=total bytes so far

   832             {

   833             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadPositionChanged ------>");

   834             VCXLOGLO2("CFusionMpxPlayerTester:: data (bytes downloaded): %d", data);                

   835             break;

   836             }

   837         case TMPXPlaybackMessage::EDownloadStateChanged: // iData=TMPXPlaybackPdDownloadState

   838             {

   839             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadStateChanged ------>");

   840             VCXLOGLO2("CFusionMpxPlayerTester:: data (download state): %d", data);                

   841             break;

   842             }

   843         case TMPXPlaybackMessage::EDownloadCmdPauseDownload: // iData=transaction ID

   844             {

   845             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadCmdPauseDownload ------>");

   846             VCXLOGLO2("CFusionMpxPlayerTester:: data (id): %d", data);                

   847             break;

   848             }

   849         case TMPXPlaybackMessage::EDownloadCmdResumeDownload: // iData=transaction ID

   850             {

   851             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadCmdResumeDownload ------>");

   852             VCXLOGLO2("CFusionMpxPlayerTester:: data (id): %d", data);                

   853             break;

   854             }

   855         case TMPXPlaybackMessage::EDownloadCmdCancelDownload: // iData=transaction ID

   856             {

   857             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EDownloadCmdCancelDownload ------>");

   858             VCXLOGLO2("CFusionMpxPlayerTester:: data (id): %d", data);                

   859             break;

   860             }

   861         case TMPXPlaybackMessage::EAccessoryChanged: // iType=TAccessoryMode

   862             {

   863             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EAccessoryChanged ------>");

   864             VCXLOGLO2("CFusionMpxPlayerTester:: type (accessory type): %d", type);

   865             break;

   866             }

   867         case TMPXPlaybackMessage::EMediaChanged: // When the song/playlist hasn't: but data may become available

   868             {

   869             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EMediaChanged ------>");

   870             break;

   871             }

   872         case TMPXPlaybackMessage::ESkipping: //skipping event: iData=+1: skipping forward: -1: skipping backward

   873             {

   874             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ESkipping");

   875             VCXLOGLO2("CFusionMpxPlayerTester:: data (skipping): %d", data);                

   876             break;

   877             }

   878         case TMPXPlaybackMessage::ESkipEnd: //skipping end

   879             {

   880             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: ESkipEnd");

   881             break;

   882             }

   883         case TMPXPlaybackMessage::EPlayerUnavailable:

   884             {

   885             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EPlayerUnavailable");

   886             break;

   887             }

   888         case TMPXPlaybackMessage::EPlaylistUpdated: // playlist updated

   889             {

   890             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EPlaylistUpdated");

   891             break;

   892             }

   893         case TMPXPlaybackMessage::EReachedEndOfPlaylist: // playback or skipping forward has reached end of playlist

   894             {

   895             VCXLOGLO1("CFusionMpxPlayerTester::DoHandlePlaybackMessageL: EReachedEndOfPlaylist");

   896             break;

   897             }

   898 

   899         default:

   900             {

   901             break;

   902             }

   903         }

   904     }

   905 

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

   907 // CFusionMpxPlayerTester::DoHandleVideoPlaybackMessageL

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

   909 //

   910 void CFusionMpxPlayerTester::DoHandleVideoPlaybackMessageL( const CMPXMessage& aMessage )

   911     {

   912     VCXLOGLO1("CFusionMpxPlayerTester:: ----------------------------------");

   913     VCXLOGLO1("CFusionMpxPlayerTester::  KMPXMediaIdVideoPlayback message ");

   914     VCXLOGLO1("CFusionMpxPlayerTester:: ----------------------------------");

   915     

   916     TMPXVideoPlaybackCommand message =

   917         ( *(aMessage.Value<TMPXVideoPlaybackCommand>(KMPXMediaVideoPlaybackCommand)) );

   918     

   919     switch ( message )

   920         {

   921         case EPbCmdPluginError:

   922             {

   923             TInt error( *aMessage.Value<TInt>( KMPXMediaVideoError ) );

   924             VCXLOGLO2("CFusionMpxPlayerTester:: EPbCmdPluginError: %d", error);

   925             }

   926             break;

   927             

   928         case EPbCmdTvOutEvent:

   929             {

   930             TBool connected( *aMessage.Value<TInt>( KMPXMediaVideoTvOutConnected ) );

   931             TBool playbackAllowed( EFalse );

   932             if( connected )

   933                 {

   934                 TBool playbackAllowed = *aMessage.Value<TInt>( KMPXMediaVideoTvOutPlayAllowed );

   935                 }

   936             VCXLOGLO3("CFusionMpxPlayerTester:: EPbCmdTvOutEvent: connected: %d, playback allowed: %d", connected, playbackAllowed);

   937             }

   938             break;

   939         }

   940     }

   941 

   942 // -----------------------------------------------------------------------------

   943 // CFusionMpxPlayerTester::DoHandleStateChangeL

   944 // -----------------------------------------------------------------------------

   945 //

   946 void CFusionMpxPlayerTester::DoHandleStateChangeL( TMPXPlaybackState aState )

   947     {

   948     iState = aState;

   949     

   950     switch ( aState )

   951         {

   952         case EPbStateNotInitialised:

   953             {

   954             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateNotInitialised ------>");            

   955             }

   956             break;            

   957         case EPbStateInitialising:   

   958             {

   959             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateInitialising ------>");

   960             }

   961             break;

   962         case EPbStatePlaying:        

   963             {

   964             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStatePlaying ------>");

   965             }

   966             break;

   967         case EPbStatePaused:         

   968             {

   969             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStatePaused ------>");

   970             }

   971             break;

   972         case EPbStateStopped:        

   973             {

   974             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateStopped ------>");

   975             }

   976             break;

   977         case EPbStateSeekingForward: 

   978             {

   979             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateSeekingForward ------>");

   980             }

   981             break;

   982         case EPbStateSeekingBackward:

   983             {

   984             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateSeekingBackward ------>");

   985             }

   986             break;

   987         case EPbStateShuttingDown:   

   988             {

   989             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateShuttingDown ------>");

   990             }

   991             break;

   992         case EPbStateBuffering:      

   993             {

   994             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateBuffering ------>");

   995             }

   996             break;

   997         case EPbStateDownloading:    

   998             {

   999             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateDownloading ------>");

  1000             }

  1001             break;

  1002         case EPbStateInitialised:        

  1003             {

  1004             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStateInitialised ------>");

  1005             iInitComplete = ETrue;

  1006             }

  1007             break;

  1008         case EPbStatePluginSeeking:   

  1009             {

  1010             VCXLOGLO1("CFusionMpxPlayerTester:: state: EPbStatePluginSeeking ------>");

  1011             }

  1012             break;

  1013         default:

  1014             {

  1015             VCXLOGLO1("CFusionMpxPlayerTester:: state: UKNOWN! ------>");

  1016             }

  1017             break;

  1018         }    

  1019     }

  1020 

  1021 // -----------------------------------------------------------------------------

  1022 // CFusionMpxPlayerTester::DoHandlePropertyChangeL

  1023 // -----------------------------------------------------------------------------

  1024 //

  1025 void CFusionMpxPlayerTester::DoHandlePropertyChangeL( TInt aProperty, TInt aValue )

  1026     {

  1027     switch( static_cast<TMPXPlaybackProperty>( aProperty ) )

  1028         {

  1029         case EPbPropertyVolume:    // 0 volume level values 0-KPbPlaybackVolumeLevelMax

  1030             {

  1031             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyVolume: %d ------>", aValue);

  1032             iVolume = aValue;

  1033             }

  1034             break;

  1035         case EPbPropertyMaxVolume: // 1 read only, KPbPlaybackVolumeLevelMax

  1036             {

  1037             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyMaxVolume: %d ------>", aValue);

  1038             }

  1039             break;

  1040         case EPbPropertyVolumeRamp:// 2

  1041             {

  1042             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyVolumeRamp: %d ------>", aValue);

  1043             }

  1044             break;

  1045         case EPbPropertyMute:      // 3 values 0(normal), 1(muted)

  1046             {

  1047             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyMute: %d ------>", aValue);

  1048             }

  1049             break;

  1050         case EPbPropertyBalance:   // 4 values -100(left) - 0 - +100(right)

  1051             {

  1052             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyBalance: %d ------>", aValue);

  1053             }

  1054             break;

  1055         case EPbPropertyEmbeddedMode:// 5

  1056             {

  1057             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyEmbeddedMode: %d ------>", aValue);

  1058             }

  1059             break;

  1060         case EPbPropertyCrossFade:   // 6

  1061             {

  1062             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyCrossFade: %d ------>", aValue);

  1063             }

  1064             break;

  1065         case EPbPropertyRandomMode:  // 7

  1066             {

  1067             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyRandomMode: %d ------>", aValue);

  1068             }

  1069             break;

  1070         case EPbPropertyRepeatMode:  // 8

  1071             {

  1072             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyRepeatMode: %d ------>", aValue);

  1073             }

  1074             break;

  1075         case EPbPropertyAccessPoint: // 9

  1076             {

  1077             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyAccessPoint: %d ------>", aValue);

  1078             }

  1079             break;

  1080         case EPbPropertyPosition:    // 10 depends on the plugin, it's safer to pause

  1081                                 // the playing item before setting position

  1082             {

  1083             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyPosition: %d ------>", aValue);

  1084             }

  1085             break;

  1086         case EPbPropertyDuration:    // 11 read only, millisecond

  1087             {

  1088             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyDuration: %d ------>", aValue);

  1089             }

  1090             break;

  1091         case EPbPropertySongValid:   // 12

  1092             {

  1093             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertySongValid: %d ------>", aValue);

  1094             }

  1095             break;

  1096         case EPbPropertyRemote:      // 13

  1097             {

  1098             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyRemote: %d ------>", aValue);

  1099             }

  1100             break;

  1101         case EPbPropertySupportedFeatures:// 14 read only

  1102             {

  1103             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertySupportedFeatures: %d ------>", aValue);

  1104             }

  1105             break;

  1106         case EPbPropertyNum:               // 15 Last

  1107             {

  1108             VCXLOGLO2("CFusionMpxPlayerTester:: property: EPbPropertyNum: %d ------>", aValue);

  1109             }

  1110             break;

  1111         

  1112         default:

  1113             {

  1114             VCXLOGLO1("CFusionMpxPlayerTester:: property: UNKNOWN! ------>");

  1115             }

  1116             break;

  1117         }

  1118     }

  1119 

  1120 // -----------------------------------------------------------------------------

  1121 // CFusionMpxPlayerTester::HandleViewActivation

  1122 // -----------------------------------------------------------------------------

  1123 //

  1124 void CFusionMpxPlayerTester::HandleViewActivation( const TUid& /* aCurrentViewType */, const TUid& /* aPreviousViewType */ )

  1125     {

  1126     VCXLOGLO1(">>>CFusionMpxPlayerTester::HandleViewActivation ------>");

  1127     VCXLOGLO1("<<<CFusionMpxPlayerTester::HandleViewActivation <------");

  1128     }

  1129 

  1130 // -----------------------------------------------------------------------------

  1131 // CFusionMpxPlayerTester::HandleViewUpdate

  1132 // -----------------------------------------------------------------------------

  1133 //

  1134 void CFusionMpxPlayerTester::HandleViewUpdate( TUid /* aViewUid */, TViewUpdateEvent /* aUpdateEvent */,