Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer

     1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include "testvideoplayer_secdisp.h"

    18 //

    19 // RTestVclntSetScrIdAndPlayBase

    20 //

    22 /**

    23  * RTestVclntSetScrIdAndPlayBase::Constructor

    24  */

    25 RTestVclntSetScrIdAndPlayBase::RTestVclntSetScrIdAndPlayBase(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

    26     : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)

    27     {

    28     iHeapSize = 1000000; //1MB

    29     iScreenNumber = aScreenNumber;

    30     iCurrentScreenNumber = 0;

    31     }

    33 /**

    34  *

    35  * Finished()

    36  *

    37  */

    38 void RTestVclntSetScrIdAndPlayBase::FinishedL()

    39     {

    40     INFO_PRINTF1(_L("RTestVclntSetScrIdAndPlayBase::FinishedL"));

    41     //overridden in play/stop and play/pause tests.

    42     }

    44 /**

    45  * RTestVclntAviPlayerStep::MvpuoOpenComplete

    46  * Callback function for CVideoPlayerUtility

    47  */

    48 void RTestVclntSetScrIdAndPlayBase::MvpuoOpenComplete(TInt aError)

    49     {

    50     iError = aError;

    51     INFO_PRINTF2(_L("iVideoPlayer - Open Complete callback returned with error %d"), iError);

    52 #ifdef SYMBIAN_VARIABLE_BITRATE_CODEC

    53 #if defined (__EABI__) || defined(__X86GCC__) // secondary screen is not supported in HW.

    54     if ((iCurrentScreenNumber != 0) && (iError == KErrNotSupported))

    55         {

    56         iTestStepResult = EKnownFailure;

    57         INFO_PRINTF1(_L("The secondary screen is not supported in HW"));

    58         CActiveScheduler::Stop();

    59         }

    60     else if((iCurrentScreenNumber == 0) && (iError == KErrNone))

    61         {

    62         TRAPD(err, FsmL(EVPOpenComplete));

    63         if (err != KErrNone)

    64             {

    65             iError = err;

    66             }

    67         }

    68     else

    69         {

    70         iTestStepResult = EFail;

    71         ERR_PRINTF2(_L("Unexpected error in MvpuoOpenComplete %d"), iError);

    72         CActiveScheduler::Stop();

    73         }

    74 #else

    75     TRAPD(err, FsmL(EVPOpenComplete));

    76     if (err != KErrNone)

    77         {

    78         iError = err;

    79         CActiveScheduler::Stop();

    80         }

    81 #endif  // __EABI__

    82 #else

    83     if(iError == KErrNotSupported)

    84         {

    85         iTestStepResult = EKnownFailure;

    86         INFO_PRINTF1(_L("The AVI Play Controller is not available in this OS version, hence KNOWN FAILURE"));

    87         }

    88     else

    89         {

    90         iTestStepResult = EFail;

    91         ERR_PRINTF2(_L("Unexpected error in MvpuoOpenComplete %d"), iError);

    92         }

    93     CActiveScheduler::Stop();

    94 #endif // SYMBIAN_VARIABLE_BITRATE_CODEC

    95     }

    96 //

    97 // RTestVclntSetScrIdAndPlayAviFile

    98 //

   100 /**

   101  * RTestVclntSetScrIdAndPlayAviFile::Constructor

   102  */

   103 RTestVclntSetScrIdAndPlayAviFile::RTestVclntSetScrIdAndPlayAviFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   104     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

   105     {

   106     }

   108 /**

   109  * RTestVclntSetScrIdAndPlayAviFile::NewL

   110  */

   111 RTestVclntSetScrIdAndPlayAviFile* RTestVclntSetScrIdAndPlayAviFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   112     {

   113     RTestVclntSetScrIdAndPlayAviFile* self = new (ELeave) RTestVclntSetScrIdAndPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber);

   114     return self;

   115     }

   117 /**

   118  * RTestVclntSetScrIdAndPlayAviFile::DoTestStepL

   119  */

   120 TVerdict RTestVclntSetScrIdAndPlayAviFile::DoTestStepL()

   121     {

   122     iTestStepResult = EFail;

   123     // Call the state handler from IDLE state

   124     TRAPD(err, FsmL(EVPIdle));

   125     if (err == KErrNone)

   126         {

   127         // Start the scheduler - Done only once !

   128         CActiveScheduler::Start();

   129         }

   130     return iTestStepResult;

   131     }

   133 /**

   134  * RTestVclntSetScrIdAndPlayAviFile::FsmL

   135  */

   136 void RTestVclntSetScrIdAndPlayAviFile::FsmL(TVclntTestPlayEvents aEventCode)

   137     {

   138     if (FsmCheck(aEventCode))

   139         {

   140         switch (aEventCode)

   141             {

   142             case EVPIdle:

   143                 {

   144                 // Set iScreenNumber

   145                 iCurrentScreenNumber = iScreenNumber;

   146                 INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

   147                 TInt err = KErrNone;

   148                 err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

   149             #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   150                 if (err != KErrNone)

   151                     {

   152                     ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   153                     User::Leave(err);

   154                     }

   155             #else

   156                 if (err == KErrNotSupported)

   157                     {

   158                     iTestStepResult = EKnownFailure;

   159                     INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   160                     }

   161                 else

   162                     {

   163                     iTestStepResult = EFail;

   164                     ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

   165                     }

   166                 User::Leave(err);

   167             #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   168                 // Open iVideoPlayer

   169                 INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

   170                 if (iBinaryCompatibility)

   171                 	{

   172                 	iVideoPlayer->OpenFileL(iFilename, ControllerUid());

   173                 	}

   174                 else

   175                 	{

   176                 	iVideoPlayer->OpenFileL(iFilename);

   177                 	}

   179                 PrepareState(EVPOpenComplete, KErrNone);

   180                 break;

   181                 }

   182             case EVPOpenComplete:

   183                 {

   184                 // Prepare iVideoPlayer

   185                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

   186                 iVideoPlayer->Prepare();

   187                 PrepareState(EVPPrepareComplete, KErrNone);

   188                 break;

   189                 }

   190             case EVPPrepareComplete:

   191                 {

   192                 iError = KErrTimedOut;

   193                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

   194                 iVideoPlayer->Play();

   195                 PrepareState(EVPPlayComplete, KErrNone);

   196                 break;

   197                 }

   198             case EVPPlayComplete:

   199                 {

   200                 iTestStepResult = EPass;

   201                 CActiveScheduler::Stop();

   202                 break;

   203                 }

   204             }

   205         }

   206     }

   208 //

   209 // RTestVclntSetScrIdAndPlayAviDes

   210 //

   212 /**

   213  * RTestVclntSetScrIdAndPlayAviDes::Constructor

   214  */

   215 RTestVclntSetScrIdAndPlayAviDes::RTestVclntSetScrIdAndPlayAviDes(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   216     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

   217     {

   218     iHeapSize = 500000;

   219     }

   221 /**

   222  * RTestVclntSetScrIdAndPlayAviDes::NewL

   223  */

   224 RTestVclntSetScrIdAndPlayAviDes* RTestVclntSetScrIdAndPlayAviDes::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   225     {

   226     RTestVclntSetScrIdAndPlayAviDes* self = new (ELeave) RTestVclntSetScrIdAndPlayAviDes(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber);

   227     return self;

   228     }

   230 /**

   231  * RTestVclntSetScrIdAndPlayAviDes::DoTestStepPreambleL

   232  */

   233 TVerdict  RTestVclntSetScrIdAndPlayAviDes::DoTestStepPreambleL()

   234     {

   235     TVerdict preamRes = EPass;

   237     // Base DoTestStepPreambleL

   238     preamRes = RTestVclntAviPlayerStep::DoTestStepPreambleL();

   239     if (preamRes != EPass)

   240         {

   241         return preamRes;

   242         }

   244     RFs fs;

   245     RFile file;

   246     TInt size = 0;

   248     // connect to file system and open file

   249     User::LeaveIfError(fs.Connect());

   250     CleanupClosePushL(fs);

   251     User::LeaveIfError(file.Open(fs,iFilename,EFileRead));

   252     CleanupClosePushL(file);

   254     // Set HBuf size

   255     User::LeaveIfError(file.Size(size));

   256     INFO_PRINTF2(_L("size of file = %d\n"),size);//Statement Changed under DEF105143

   258     iVideo = HBufC8::NewMaxL(size);

   260     // read data into Hbuf

   261     TPtr8 bufferDes(iVideo->Des());

   262     User::LeaveIfError(file.Read(bufferDes));

   264     CleanupStack::PopAndDestroy(2, &fs); //fs, file

   266     return preamRes;

   267     }

   269 /**

   270  * RTestVclntSetScrIdAndPlayAviDes::DoTestStepPostambleL

   271  */

   272 TVerdict RTestVclntSetScrIdAndPlayAviDes::DoTestStepPostambleL()

   273     {

   274     delete iVideo;

   275     iVideo = NULL;

   276     return RTestVclntAviPlayerStep::DoTestStepPostambleL();

   277     }

   279 /**

   280  * Load and initialise an video descriptor.

   281  */

   282 TVerdict RTestVclntSetScrIdAndPlayAviDes::DoTestStepL()

   283     {

   284     iTestStepResult = EFail;

   285     // Call the state handler from IDLE state

   286     TRAPD(err, FsmL(EVPIdle));

   287     if (err == KErrNone)

   288         {

   289         // Start the scheduler - Done only once !

   290         CActiveScheduler::Start();

   291         }

   292     return iTestStepResult;

   293     }

   295 /**

   296  * RTestVclntSetScrIdAndPlayAviDes::FsmL

   297  */

   298 void RTestVclntSetScrIdAndPlayAviDes::FsmL(TVclntTestPlayEvents aEventCode)

   299     {

   300     if (FsmCheck(aEventCode))

   301         {

   302         switch (aEventCode)

   303             {

   304             case EVPIdle:

   305                 {

   306                 // Set iScreenNumber

   307                 iCurrentScreenNumber = iScreenNumber;

   308                 INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

   309                 TInt err = KErrNone;

   310                 err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

   311             #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   312                 if (err != KErrNone)

   313                     {

   314                     ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   315                     User::Leave(err);

   316                     }

   317             #else

   318                 if (err == KErrNotSupported)

   319                     {

   320                     iTestStepResult = EKnownFailure;

   321                     INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   322                     }

   323                 else

   324                     {

   325                     iTestStepResult = EFail;

   326                     ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

   327                     }

   328                 User::Leave(err);

   329             #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   330                 // Open iVideoPlayer

   331                 INFO_PRINTF2(_L("iVideoPlayer->OpenDesL() %S"), &iFilename);

   332                 iVideoPlayer->OpenDesL(iVideo->Des());

   333                 PrepareState(EVPOpenComplete, KErrNone);

   334                 break;

   335                 }

   336             case EVPOpenComplete:

   337                 {

   338                 // Prepare iVideoPlayer

   339                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

   340                 iVideoPlayer->Prepare();

   341                 PrepareState(EVPPrepareComplete, KErrNone);

   342                 break;

   343                 }

   344             case EVPPrepareComplete:

   345                 {

   346                 iError = KErrTimedOut;

   347                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

   348                 iVideoPlayer->Play();

   349                 PrepareState(EVPPlayComplete, KErrNone);

   350                 break;

   351                 }

   352             case EVPPlayComplete:

   353                 {

   354                 iTestStepResult = EPass;

   355                 CActiveScheduler::Stop();

   356                 break;

   357                 }

   358             }

   359         }

   360     }

   362 //

   363 // RTestVclntSetScrIdAndPlayAviUrl

   364 //

   366 /**

   367  * RTestVclntSetScrIdAndPlayAviUrl::Constructor

   368  */

   370 RTestVclntSetScrIdAndPlayAviUrl::RTestVclntSetScrIdAndPlayAviUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   371     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

   372     {

   373     }

   375 /**

   376  * RTestVclntSetScrIdAndPlayAviUrl::NewL

   377  */

   379 RTestVclntSetScrIdAndPlayAviUrl* RTestVclntSetScrIdAndPlayAviUrl::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   380     {

   381     RTestVclntSetScrIdAndPlayAviUrl* self = new (ELeave) RTestVclntSetScrIdAndPlayAviUrl(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber);

   382     return self;

   383     }

   385 /**

   386  * RTestVclntSetScrIdAndPlayAviUrl::Constructor

   387  */

   389 TVerdict RTestVclntSetScrIdAndPlayAviUrl::DoTestStepL()

   390     {

   391     iTestStepResult = EFail;

   392     // Call the state handler from IDLE state

   393     TRAPD(err, FsmL(EVPIdle));

   394     if (err == KErrNone)

   395         {

   396         // Start the scheduler - Done only once !

   397         CActiveScheduler::Start();

   398         }

   399     return iTestStepResult;

   400     }

   402 /**

   403  * RTestVclntSetScrIdAndPlayAviUrl::FsmL

   404  */

   406 void RTestVclntSetScrIdAndPlayAviUrl::FsmL(TVclntTestPlayEvents aEventCode)

   407     {

   408     if (FsmCheck(aEventCode))

   409         {

   410         switch (aEventCode)

   411             {

   412             case EVPIdle:

   413                 {

   414                 // Set iScreenNumber

   415                 iCurrentScreenNumber = iScreenNumber;

   416                 INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

   417                 TInt err = KErrNone;

   418                 err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

   419             #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   420                 if (err != KErrNone)

   421                     {

   422                     ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   423                     User::Leave(err);

   424                     }

   425             #else

   426                 if (err == KErrNotSupported)

   427                     {

   428                     iTestStepResult = EKnownFailure;

   429                     INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   430                     }

   431                 else

   432                     {

   433                     iTestStepResult = EFail;

   434                     ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

   435                     }

   436                 User::Leave(err);

   437             #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   438                 // Open iVideoPlayer

   439                 INFO_PRINTF2(_L("iVideoPlayer->OpenUrlL() %S"), &iFilename);

   440                 iVideoPlayer->OpenUrlL(iFilename);

   441                 PrepareState(EVPOpenComplete, KErrNone);

   442                 break;

   443                 }

   444             case EVPOpenComplete:

   445                 {

   446                 // Prepare iVideoPlayer

   447                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

   448                 iVideoPlayer->Prepare();

   449                 PrepareState(EVPPrepareComplete, KErrNone);

   450                 break;

   451                 }

   452             case EVPPrepareComplete:

   453                 {

   454                 iError = KErrTimedOut;

   455                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

   456                 iVideoPlayer->Play();

   457                 PrepareState(EVPPlayComplete, KErrNone);

   458                 break;

   459                 }

   460             case EVPPlayComplete:

   461                 {

   462                 CActiveScheduler::Stop();

   463                 iTestStepResult = EPass;

   464                 break;

   465                 }

   466             }

   467         }

   468     }

   470 //

   471 // RTestVclntSetScrIdAndPlayStopAviFile

   472 //

   474 /**

   475  * RTestVclntSetScrIdAndPlayStopAviFile::Constructor

   476  */

   477 RTestVclntSetScrIdAndPlayStopAviFile::RTestVclntSetScrIdAndPlayStopAviFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber, TInt aScreenNumber2)

   478     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

   479     {

   480     iScreenNumber2 = aScreenNumber2;

   481     iPlayTimer = NULL;

   482     iRestarted = EFalse;

   483     }

   485 /**

   486  * RTestVclntSetScrIdAndPlayStopAviFile::NewL

   487  */

   488 RTestVclntSetScrIdAndPlayStopAviFile* RTestVclntSetScrIdAndPlayStopAviFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber, TInt aScreenNumber2)

   489     {

   490     RTestVclntSetScrIdAndPlayStopAviFile* self = new (ELeave) RTestVclntSetScrIdAndPlayStopAviFile(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber, aScreenNumber2);

   491     return self;

   492     }

   494 /**

   495  * set finished on callback from a timer

   496  */

   497 void RTestVclntSetScrIdAndPlayStopAviFile::FinishedL()

   498     {

   499     INFO_PRINTF1(_L("-- iVideoPlayer->Stop();"));

   500     iVideoPlayer->Stop();

   501     iRestarted = EFalse;

   502     FsmL(EVPPlayStopped);

   503     }

   505 /**

   506  * RTestVclntSetScrIdAndPlayStopAviFile::DoTestStepL

   507  */

   508 TVerdict RTestVclntSetScrIdAndPlayStopAviFile::DoTestStepL()

   509     {

   510     iTestStepResult = EFail;

   511     iCountNumber = 0;

   512     iError = 0;

   513     // Get the filename

   514     TPtrC tmpFilename;

   515     if(!GetStringFromConfig(iSectName, _L("filename2"), tmpFilename))

   516         {

   517         ERR_PRINTF1(_L("ERROR : Cannot Get value from Config."));

   518         return EInconclusive;

   519         }

   520     GetDriveName(iFilename2);

   521     iFilename2.Append(tmpFilename);

   522     // Call the state handler from IDLE state

   523     TRAPD(err, FsmL(EVPIdle));

   524     if (err == KErrNone)

   525         {

   526         // Start the scheduler - Done only once !

   527         CActiveScheduler::Start();

   528         }

   529     return iTestStepResult;

   530     }

   532 /**

   533  * RTestVclntSetScrIdAndPlayStopAviFile::FsmL

   534  */

   535 void RTestVclntSetScrIdAndPlayStopAviFile::FsmL(TVclntTestPlayEvents aEventCode)

   536     {

   537     if (FsmCheck(aEventCode))

   538         {

   539         switch (aEventCode)

   540             {

   541             case EVPIdle:

   542                 {

   543                 // Set iScreenNumber

   544                 iCurrentScreenNumber = iScreenNumber;

   545                 INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

   546                 TInt err = KErrNone;

   547                 err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

   548             #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   549                 if (err != KErrNone)

   550                     {

   551                     ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   552                     User::Leave(err);

   553                     }

   554             #else

   555                 if (err == KErrNotSupported)

   556                     {

   557                     iTestStepResult = EKnownFailure;

   558                     INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   559                     }

   560                 else

   561                     {

   562                     iTestStepResult = EFail;

   563                     ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

   564                     }

   565                 User::Leave(err);

   566             #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   567                 // Open iVideoPlayer

   568                 INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

   569                 if (iBinaryCompatibility)

   570                 	{

   571                 	iVideoPlayer->OpenFileL(iFilename, ControllerUid());

   572                 	}

   573                 else

   574                 	{

   575                 	iVideoPlayer->OpenFileL(iFilename);

   576                 	}

   578                 PrepareState(EVPOpenComplete, KErrNone);

   579                 break;

   580                 }

   581             case EVPOpenComplete:

   582                 {

   583                 // Prepare iVideoPlayer

   584                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

   585                 iVideoPlayer->Prepare();

   586                 PrepareState(EVPPrepareComplete, KErrNone);

   587                 break;

   588                 }

   589             case EVPPrepareComplete:

   590                 {

   591                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

   592                 iVideoPlayer->Play();

   593                 if (iCountNumber == 0)

   594                     {

   595                     // initialise and start the timer.  the file is short and so decode occur rapidly

   596                     // hence the short time passed to After()

   597                     TRAPD(err, iPlayTimer = CTestVclntAviPlayTimer::NewL(this, 2000000));

   598                     if (err != KErrNone)

   599                         {

   600                         ERR_PRINTF2(_L("CTestVclntAviPlayTimer::NewL left with error = %d"), err);

   601                         CActiveScheduler::Stop();

   602                         break;

   603                         }

   604                     iPlayTimer->Start();

   605                     // For first time we are expecting to stop the play after some second,

   606                     // and second time it should play till the end of file.

   607                     PrepareState(EVPPlayStopped, KErrNone);

   608                     }

   609                 else

   610                     {

   611                     PrepareState(EVPPlayComplete, KErrNone);

   612                     }

   613                 break;

   614                 }

   615            case EVPPlayStopped:

   616             {

   617             // Cancel the timer

   618             iPlayTimer->Cancel();

   619             delete iPlayTimer;

   620             iPlayTimer = NULL;

   621             // Set iScreenNumber

   622             iCurrentScreenNumber = iScreenNumber2;

   623             INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber2);

   624             TInt err = KErrNone;

   625             err = iVideoPlayer->SetInitScreenNumber(iScreenNumber2);

   626         #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   627             if (err != KErrNone)

   628                 {

   629                 ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   630                 CActiveScheduler::Stop();

   631                 User::Leave(err);

   632                 }

   633         #else

   634             if (err == KErrNotSupported)

   635                 {

   636                 iTestStepResult = EKnownFailure;

   637                 INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   638                 }

   639             else

   640                 {

   641                 iTestStepResult = EFail;

   642                 ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

   643                 }

   644             CActiveScheduler::Stop();

   645             User::Leave(err);

   646         #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   647             iCountNumber++;

   648             // Open iVideoPlayer

   649             INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename2);

   650             if (iBinaryCompatibility)

   651             	{

   652             	TRAP(iError, iVideoPlayer->OpenFileL(iFilename2, ControllerUid()));

   653             	}

   654             else

   655             	{

   656             	TRAP(iError, iVideoPlayer->OpenFileL(iFilename2));

   657             	}

   659             if (iError != KErrNone)

   660                 {

   661                 ERR_PRINTF2(_L("iVideoPlayer->OpenFileL() left with error = %d"), iError);

   662                 CActiveScheduler::Stop();

   663                 }

   664             else

   665                 {

   666                 PrepareState(EVPOpenComplete, KErrNone);

   667                 }

   668             break;

   669             }

   670            case EVPPlayComplete:

   671                 {

   672                 iTestStepResult = EPass;

   673                 CActiveScheduler::Stop();

   674                 break;

   675                 }

   676             }

   677         }

   678     }

   680 //

   681 // RTestVclntSetScrIdAndPlayPauseAviFile

   682 //

   684 /**

   685  * RTestVclntSetScrIdAndPlayPauseAviFile::Constructor

   686  */

   687 RTestVclntSetScrIdAndPlayPauseAviFile::RTestVclntSetScrIdAndPlayPauseAviFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber, TInt aScreenNumber2)

   688     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

   689     {

   690     iScreenNumber2 = aScreenNumber2;

   691     }

   693 /**

   694  * RTestVclntSetScrIdAndPlayPauseAviFile::NewL

   695  */

   696 RTestVclntSetScrIdAndPlayPauseAviFile* RTestVclntSetScrIdAndPlayPauseAviFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber, TInt aScreenNumber2)

   697     {

   698     RTestVclntSetScrIdAndPlayPauseAviFile* self = new (ELeave) RTestVclntSetScrIdAndPlayPauseAviFile(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber, aScreenNumber2);

   699     return self;

   700     }

   702 /**

   703  * set finished on callback from a timer

   704  */

   705 void RTestVclntSetScrIdAndPlayPauseAviFile::FinishedL()

   706     {

   707     // We cannot use the logger until after OpenL is called again in EVPPlayPaused because

   708     // of the way the scheduler works.  The current thread is suspended until the video is

   709     // finished playing if a synchronous call is made in WINSCW.

   710     TRAPD(err,iVideoPlayer->PauseL());

   711     if (err != KErrNotSupported)

   712         {

   713         INFO_PRINTF2(_L("Pause() returns with error :  %d"),err);

   714         iTestStepResult = EFail;

   715         CActiveScheduler::Stop();

   716         }

   717     iRestarted = EFalse;

   718     FsmL(EVPPlayPaused);

   719     }

   721 /**

   722  * RTestVclntSetScrIdAndPlayPauseAviFile::DoTestStepL

   723  */

   724 TVerdict RTestVclntSetScrIdAndPlayPauseAviFile::DoTestStepL()

   725     {

   726     iTestStepResult = EFail;

   727     iCountNumber = 0;

   728     iError = 0;

   729     // Get the filename

   730     TPtrC tmpFilename;

   731     if(!GetStringFromConfig(iSectName, _L("filename2"), tmpFilename))

   732         {

   733         ERR_PRINTF1(_L("ERROR : Cannot Get value from Config."));

   734         return EInconclusive;

   735         }

   736     GetDriveName(iFilename2);

   737     iFilename2.Append(tmpFilename);

   738     // Call the state handler from IDLE state

   739     TRAPD(err, FsmL(EVPIdle));

   740     if (err == KErrNone)

   741         {

   742         // Start the scheduler - Done only once !

   743         CActiveScheduler::Start();

   744         }

   745     return iTestStepResult;

   746     }

   748 /**

   749  * RTestVclntSetScrIdAndPlayPauseAviFile::FsmL

   750  */

   751 void RTestVclntSetScrIdAndPlayPauseAviFile::FsmL(TVclntTestPlayEvents aEventCode)

   752     {

   753     if (FsmCheck(aEventCode))

   754         {

   755         switch (aEventCode)

   756             {

   757             case EVPIdle:

   758                 {

   759                 // Set iScreenNumber

   760                 iCurrentScreenNumber = iScreenNumber;

   761                 INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

   762                 TInt err = KErrNone;

   763                 err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

   764             #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   765                 if (err != KErrNone)

   766                     {

   767                     ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   768                     User::Leave(err);

   769                     }

   770             #else

   771                 if (err == KErrNotSupported)

   772                     {

   773                     iTestStepResult = EKnownFailure;

   774                     INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   775                     }

   776                 else

   777                     {

   778                     iTestStepResult = EFail;

   779                     ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

   780                     }

   781                 User::Leave(err);

   782             #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   783                 // Open iVideoPlayer

   784                 INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

   785                 if (iBinaryCompatibility)

   786                 	{

   787                 	iVideoPlayer->OpenFileL(iFilename, ControllerUid());

   788                 	}

   789                 else

   790                 	{

   791                 	iVideoPlayer->OpenFileL(iFilename);

   792                 	}

   794                 PrepareState(EVPOpenComplete, KErrNone);

   795                 break;

   796                 }

   797             case EVPOpenComplete:

   798                 {

   799                 // Prepare iVideoPlayer

   800                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

   801                 iVideoPlayer->Prepare();

   802                 PrepareState(EVPPrepareComplete, KErrNone);

   803                 break;

   804                 }

   805             case EVPPrepareComplete:

   806                 {

   807                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

   808                 // We cannot use the logger until after OpenL is called again in EVPPlayPaused because

   809                 // of the way the scheduler works.  The current thread is suspended until the video is

   810                 // finished playing if a synchronous call is made in WINSCW.

   811                 iVideoPlayer->Play();

   812                 if (iCountNumber == 0)

   813                     {

   814                     // initialise and start the timer.  the file is short and so decode occur rapidly

   815                     // hence the short time passed to After()

   816                     TRAPD(err, iPlayTimer = CTestVclntAviPlayTimer::NewL(this, 1000000));

   817                     if (err != KErrNone)

   818                         {

   819                         ERR_PRINTF2(_L("CTestVclntAviPlayTimer::NewL left with error = %d"), err);

   820                         CActiveScheduler::Stop();

   821                         break;

   822                         }

   824                     iPlayTimer->Start();

   825                     PrepareState(EVPPlayPaused, KErrNone);

   826                     }

   827                 else

   828                     {

   829                     PrepareState(EVPPlayComplete, KErrNone);

   830                     }

   831                 break;

   832                 }

   833             case EVPPlayPaused:

   834                 {

   835                 // Cancel the timer

   836                 iPlayTimer->Cancel();

   837                 delete iPlayTimer;

   838                 iPlayTimer = NULL;

   840                 // Set iScreenNumber

   841                 iCurrentScreenNumber = iScreenNumber2;

   842                 TInt err = iVideoPlayer->SetInitScreenNumber(iScreenNumber2);

   843             #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   844                 if (err != KErrNone)

   845                     {

   846                     ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   847                     CActiveScheduler::Stop();

   848                     User::Leave(err);

   849                     }

   850             #else

   851                 if (err == KErrNotSupported)

   852                     {

   853                     iTestStepResult = EKnownFailure;

   854                     INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   855                     }

   856                 else

   857                     {

   858                     iTestStepResult = EFail;

   859                     ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

   860                     }

   861                 CActiveScheduler::Stop();

   862                 User::Leave(err);

   863             #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   864                 iCountNumber++;

   865                 // Open iVideoPlayer

   866                 if (iBinaryCompatibility)

   867 	            	{

   868 	            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename2, ControllerUid()));

   869 	            	}

   870 	            else

   871 	            	{

   872 	            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename2));

   873 	            	}

   875 	            INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename2);

   877                 if (iError != KErrNone)

   878                     {

   879                     ERR_PRINTF2(_L("iVideoPlayer->OpenFileL() left with error = %d"), iError);

   880                     CActiveScheduler::Stop();

   881                     }

   882                 else

   883                     {

   884                     PrepareState(EVPOpenComplete, KErrNone);

   885                     }

   886                 break;

   887                 }

   888             case EVPPlayComplete:

   889                 {

   890                 iTestStepResult = EPass;

   891                 CActiveScheduler::Stop();

   892                 break;

   893                 }

   894             }

   895         }

   896     }

   898 //

   899 // RTestVclntSetScrIdAfterPlayAndPlayAviFile

   900 //

   902 /**

   903  * RTestVclntSetScrIdAfterPlayAndPlayAviFile::Constructor

   904  */

   905 RTestVclntSetScrIdAfterPlayAndPlayAviFile::RTestVclntSetScrIdAfterPlayAndPlayAviFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   906     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

   907     {

   908     }

   910 /**

   911  * RTestVclntSetScrIdAfterPlayAndPlayAviFile::NewL

   912  */

   913 RTestVclntSetScrIdAfterPlayAndPlayAviFile* RTestVclntSetScrIdAfterPlayAndPlayAviFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

   914     {

   915     RTestVclntSetScrIdAfterPlayAndPlayAviFile* self = new (ELeave) RTestVclntSetScrIdAfterPlayAndPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber);

   916     return self;

   917     }

   919 /**

   920  * RTestVclntSetScrIdAfterPlayAndPlayAviFile::DoTestStepL

   921  */

   922 TVerdict RTestVclntSetScrIdAfterPlayAndPlayAviFile::DoTestStepL()

   923     {

   924     iTestStepResult = EFail;

   925     iCountNumber = 0;

   926     iError = 0;

   927     // Call the state handler from IDLE state

   928     TRAPD(err, FsmL(EVPIdle));

   929     if (err == KErrNone)

   930         {

   931         // Start the scheduler - Done only once !

   932         CActiveScheduler::Start();

   933         }

   934     return iTestStepResult;

   935     }

   937 /**

   938  * RTestVclntSetScrIdAfterPlayAndPlayAviFile::FsmL

   939  */

   940 void RTestVclntSetScrIdAfterPlayAndPlayAviFile::FsmL(TVclntTestPlayEvents aEventCode)

   941     {

   942     if (FsmCheck(aEventCode))

   943         {

   944         switch (aEventCode)

   945             {

   946             case EVPIdle:

   947                 {

   948                 // Open iVideoPlayer

   949                 INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

   950                 if (iBinaryCompatibility)

   951 	            	{

   952 	            	iVideoPlayer->OpenFileL(iFilename, ControllerUid());

   953 	            	}

   954 	            else

   955 	            	{

   956 	            	iVideoPlayer->OpenFileL(iFilename);

   957 	            	}

   959                 PrepareState(EVPOpenComplete, KErrNone);

   960                 break;

   961                 }

   962             case EVPOpenComplete:

   963                 {

   964                 // Prepare iVideoPlayer

   965                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

   966                 iVideoPlayer->Prepare();

   967                 PrepareState(EVPPrepareComplete, KErrNone);

   968                 break;

   969                 }

   970             case EVPPrepareComplete:

   971                 {

   972                 iError = KErrTimedOut;

   973                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

   974                 iVideoPlayer->Play();

   975                 PrepareState(EVPPlayComplete, KErrNone);

   976                 break;

   977                 }

   978             case EVPPlayComplete:

   979                 {

   980                 if (iCountNumber == 0)

   981                     {

   982                     // Set iScreenNumber

   983                     iCurrentScreenNumber = iScreenNumber;

   984                     INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

   985                     TInt err = KErrNone;

   986                     err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

   987                 #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

   988                     if (err != KErrNone)

   989                         {

   990                         ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

   991                         CActiveScheduler::Stop();

   992                         User::Leave(err);

   993                         }

   994                 #else

   995                     if (err == KErrNotSupported)

   996                         {

   997                         iTestStepResult = EKnownFailure;

   998                         INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

   999                         }

  1000                     else

  1001                         {

  1002                         iTestStepResult = EFail;

  1003                         ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

  1004                         }

  1005                     CActiveScheduler::Stop();

  1006                     User::Leave(err);

  1007                 #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

  1008                     iCountNumber++;

  1009                     // Open iVideoPlayer

  1010                     INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

  1011                     if (iBinaryCompatibility)

  1012 		            	{

  1013 		            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename, ControllerUid()));

  1014 		            	}

  1015 		            else

  1016 		            	{

  1017 		            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename));

  1018 		            	}

  1020                     if (iError != KErrNone)

  1021                         {

  1022                         ERR_PRINTF2(_L("iVideoPlayer->OpenFileL() left with error = %d"), iError);

  1023                         CActiveScheduler::Stop();

  1024                         }

  1025                     else

  1026                         {

  1027                         PrepareState(EVPOpenComplete, KErrNone);

  1028                         }

  1029                     break;

  1030                     }

  1031                 else

  1032                     {

  1033                     iTestStepResult = EPass;

  1034                     CActiveScheduler::Stop();

  1035                     }

  1036                 break;

  1037                 }

  1038             }

  1039         }

  1040     }

  1042 //

  1043 // RTestVclntSetScrIdAfterOpenAndPlayAviFile

  1044 //

  1046 /**

  1047  * RTestVclntSetScrIdAfterOpenAndPlayAviFile::Constructor

  1048  */

  1049 RTestVclntSetScrIdAfterOpenAndPlayAviFile::RTestVclntSetScrIdAfterOpenAndPlayAviFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

  1050     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

  1051     {

  1052     }

  1054 /**

  1055  * RTestVclntSetScrIdAfterOpenAndPlayAviFile::NewL

  1056  */

  1057 RTestVclntSetScrIdAfterOpenAndPlayAviFile* RTestVclntSetScrIdAfterOpenAndPlayAviFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

  1058     {

  1059     RTestVclntSetScrIdAfterOpenAndPlayAviFile* self = new (ELeave) RTestVclntSetScrIdAfterOpenAndPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber);

  1060     return self;

  1061     }

  1063 /**

  1064  * RTestVclntSetScrIdAfterOpenAndPlayAviFile::DoTestStepL

  1065  */

  1066 TVerdict RTestVclntSetScrIdAfterOpenAndPlayAviFile::DoTestStepL()

  1067     {

  1068     iTestStepResult = EFail;

  1069     iCountNumber = 0;

  1070     iError = 0;

  1071     // Call the state handler from IDLE state

  1072     TRAPD(err, FsmL(EVPIdle));

  1073     if (err == KErrNone)

  1074         {

  1075         // Start the scheduler - Done only once !

  1076         CActiveScheduler::Start();

  1077         }

  1078     return iTestStepResult;

  1079     }

  1081 /**

  1082  * RTestVclntSetScrIdAfterOpenAndPlayAviFile::FsmL

  1083  */

  1084 void RTestVclntSetScrIdAfterOpenAndPlayAviFile::FsmL(TVclntTestPlayEvents aEventCode)

  1085     {

  1086     if (FsmCheck(aEventCode))

  1087         {

  1088         switch (aEventCode)

  1089             {

  1090             case EVPIdle:

  1091                 {

  1092                 // Open iVideoPlayer

  1093                 INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

  1094                 if (iBinaryCompatibility)

  1095 	            	{

  1096 	            	iVideoPlayer->OpenFileL(iFilename, ControllerUid());

  1097 	            	}

  1098 	            else

  1099 	            	{

  1100 	            	iVideoPlayer->OpenFileL(iFilename);

  1101 	            	}

  1103                 PrepareState(EVPOpenComplete, KErrNone);

  1104                 break;

  1105                 }

  1106             case EVPOpenComplete:

  1107                 {

  1108                 if (iCountNumber == 0)

  1109                     {

  1110                     // Set iScreenNumber

  1111                     iCurrentScreenNumber = iScreenNumber;

  1112                     INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

  1113                     TInt err = 0;

  1114                     err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

  1115                 #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

  1116                     if (err != KErrNone)

  1117                         {

  1118                         ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

  1119                         CActiveScheduler::Stop();

  1120                         User::Leave(err);

  1121                         }

  1122                 #else

  1123                     if (err == KErrNotSupported)

  1124                         {

  1125                         iTestStepResult = EKnownFailure;

  1126                         INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

  1127                         }

  1128                     else

  1129                         {

  1130                         iTestStepResult = EFail;

  1131                         ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

  1132                         }

  1133                     CActiveScheduler::Stop();

  1134                     User::Leave(err);

  1135                 #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

  1136                     }

  1137                 // Prepare iVideoPlayer

  1138                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

  1139                 iVideoPlayer->Prepare();

  1140                 PrepareState(EVPPrepareComplete, KErrNone);

  1141                 break;

  1142                 }

  1143             case EVPPrepareComplete:

  1144                 {

  1145                 iError = KErrTimedOut;

  1146                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

  1147                 iVideoPlayer->Play();

  1148                 // When playing for the first time open the file again else play till the end.

  1149                 if (iCountNumber == 0)

  1150                     {

  1151                     iCountNumber++;

  1152                     // Open iVideoPlayer

  1153                     INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

  1154                     if (iBinaryCompatibility)

  1155 		            	{

  1156 		            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename, ControllerUid()));

  1157 		            	}

  1158 		            else

  1159 		            	{

  1160 		            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename));

  1161 		            	}

  1163                     if (iError != KErrNone)

  1164                         {

  1165                         ERR_PRINTF2(_L("iVideoPlayer->OpenFileL() left with error = %d"), iError);

  1166                         CActiveScheduler::Stop();

  1167                         }

  1168                     else

  1169                         {

  1170                         PrepareState(EVPOpenComplete, KErrNone);

  1171                         }

  1172                     break;

  1173                     }

  1174                 else

  1175                     {

  1176                     PrepareState(EVPPlayComplete, KErrNone);

  1177                     }

  1178                 break;

  1179                 }

  1180             case EVPPlayComplete:

  1181                 {

  1182                 iTestStepResult = EPass;

  1183                 CActiveScheduler::Stop();

  1184                 break;

  1185                 }

  1186             }

  1187         }

  1188     }

  1190 //

  1191 // RTestVclntSetScrIdDuringPlayAndPlayAviFile

  1192 //

  1194 /**

  1195  * RTestVclntSetScrIdDuringPlayAndPlayAviFile::Constructor

  1196  */

  1197 RTestVclntSetScrIdDuringPlayAndPlayAviFile::RTestVclntSetScrIdDuringPlayAndPlayAviFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

  1198     : RTestVclntSetScrIdAndPlayBase(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber)

  1199     {

  1200     }

  1202 /**

  1203  * RTestVclntSetScrIdDuringPlayAndPlayAviFile::NewL

  1204  */

  1205 RTestVclntSetScrIdDuringPlayAndPlayAviFile* RTestVclntSetScrIdDuringPlayAndPlayAviFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TInt aScreenNumber)

  1206     {

  1207     RTestVclntSetScrIdDuringPlayAndPlayAviFile* self = new (ELeave) RTestVclntSetScrIdDuringPlayAndPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, aScreenNumber);

  1208     return self;

  1209     }

  1211 /**

  1212  * RTestVclntSetScrIdDuringPlayAndPlayAviFile::DoTestStepL

  1213  */

  1214 TVerdict RTestVclntSetScrIdDuringPlayAndPlayAviFile::DoTestStepL()

  1215     {

  1216     iTestStepResult = EFail;

  1217     iCountNumber = 0;

  1218     iError = 0;

  1219     // Call the state handler from IDLE state

  1220     TRAPD(err, FsmL(EVPIdle));

  1221     if (err == KErrNone)

  1222         {

  1223         // Start the scheduler - Done only once !

  1224         CActiveScheduler::Start();

  1225         }

  1226     return iTestStepResult;

  1227     }

  1229 /**

  1230  * RTestVclntSetScrIdDuringPlayAndPlayAviFile::FsmL

  1231  */

  1232 void RTestVclntSetScrIdDuringPlayAndPlayAviFile::FsmL(TVclntTestPlayEvents aEventCode)

  1233     {

  1234     if (FsmCheck(aEventCode))

  1235         {

  1236         switch (aEventCode)

  1237             {

  1238             case EVPIdle:

  1239                 {

  1240                 // Open iVideoPlayer

  1241                 INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

  1242                 if (iBinaryCompatibility)

  1243 	            	{

  1244 	            	iVideoPlayer->OpenFileL(iFilename, ControllerUid());

  1245 	            	}

  1246 	            else

  1247 	            	{

  1248 	            	iVideoPlayer->OpenFileL(iFilename);

  1249 	            	}

  1251                 PrepareState(EVPOpenComplete, KErrNone);

  1252                 break;

  1253                 }

  1254             case EVPOpenComplete:

  1255                 {

  1256                 // Prepare iVideoPlayer

  1257                 INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));

  1258                 iVideoPlayer->Prepare();

  1259                 PrepareState(EVPPrepareComplete, KErrNone);

  1260                 break;

  1261                 }

  1262             case EVPPrepareComplete:

  1263                 {

  1264                 iError = KErrTimedOut;

  1265                 INFO_PRINTF1(_L("iVideoPlayer->Play()"));

  1266                 iVideoPlayer->Play();

  1267                 if (iCountNumber == 0)

  1268                     {

  1269                     // Set iScreenNumber

  1270                     iCurrentScreenNumber = iScreenNumber;

  1271                     INFO_PRINTF2(_L("iVideoPlayer->SetInitScreenNumber(%d)"), iScreenNumber);

  1272                     TInt err = KErrNone;

  1273                     err = iVideoPlayer->SetInitScreenNumber(iScreenNumber);

  1274                 #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

  1275                     if (err != KErrNone)

  1276                         {

  1277                         ERR_PRINTF2(_L("ScreenNumber failed with error : %d"), err);

  1278                         CActiveScheduler::Stop();

  1279                         User::Leave(err);

  1280                         }

  1281                 #else

  1282                     if (err == KErrNotSupported)

  1283                         {

  1284                         iTestStepResult = EKnownFailure;

  1285                         INFO_PRINTF2(_L("SetInitScreenNumber() is not supported in this OS, returned %d"), err);

  1286                         }

  1287                     else

  1288                         {

  1289                         iTestStepResult = EFail;

  1290                         ERR_PRINTF2(_L("SetInitScreenNumber() failed with error : %d"), err);

  1291                         }

  1292                     CActiveScheduler::Stop();

  1293                     User::Leave(err);

  1294                 #endif // SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

  1295                     iCountNumber++;

  1296                     // Open iVideoPlayer

  1297                     INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);

  1298                     if (iBinaryCompatibility)

  1299 		            	{

  1300 		            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename, ControllerUid()));

  1301 		            	}

  1302 		            else

  1303 		            	{

  1304 		            	TRAP(iError, iVideoPlayer->OpenFileL(iFilename));

  1305 		            	}

  1307                     if (iError != KErrNone)

  1308                         {

  1309                         ERR_PRINTF2(_L("iVideoPlayer->OpenFileL() left with error = %d"), iError);

  1310                         CActiveScheduler::Stop();

  1311                         }

  1312                     else

  1313                         {

  1314                         PrepareState(EVPOpenComplete, KErrNone);

  1315                         }

  1316                     break;

  1317                     }

  1318                 else

  1319                     {

  1320                     PrepareState(EVPPlayComplete, KErrNone);

  1321                     }

  1322                 break;

  1323                 }

  1324             case EVPPlayComplete:

  1325                 {

  1326                 iTestStepResult = EPass;

  1327                 CActiveScheduler::Stop();

  1328                 break;

  1329                 }

  1330             }

  1331         }

  1332     }

  1334 //

  1335 // CTestVclntAviPlayTimer

  1336 //

  1338 /**

  1339  * NewL

  1340  */

  1341 CTestVclntAviPlayTimer* CTestVclntAviPlayTimer::NewL(RTestVclntSetScrIdAndPlayBase* aParent, TTimeIntervalMicroSeconds32 aWaitTime)

  1342     {

  1343     CTestVclntAviPlayTimer* self = new (ELeave) CTestVclntAviPlayTimer(aParent, aWaitTime);

  1344     CleanupStack::PushL(self);

  1345     self->ConstructL();

  1346     CleanupStack::Pop(self);

  1347     return self;

  1348     }

  1350 /**

  1351  * Constructor

  1352  */

  1353 CTestVclntAviPlayTimer::CTestVclntAviPlayTimer(RTestVclntSetScrIdAndPlayBase* aParent, TTimeIntervalMicroSeconds32 aWaitTime)

  1354     : CTimer(EPriorityHigh), iParent(aParent), iWaitTime(aWaitTime)

  1355     {

  1356     CActiveScheduler::Add(this);

  1357     }

  1359 /**

  1360  * Start() - Start the timer

  1361  */

  1362 void CTestVclntAviPlayTimer::Start()

  1363     {

  1364     After(iWaitTime);

  1365     }

  1367 /**

  1368  * RunL() - see CActive class for more info

  1369  */

  1370 void CTestVclntAviPlayTimer::RunL()

  1371     {

  1372     // (iParent->Finished() should call Stop() or not, as we decide)

  1373     iParent->FinishedL();

  1374     }

  1376 /**

  1377  * RunError() - see CActive class for more info

  1378  */

  1379 TInt CTestVclntAviPlayTimer::RunError(TInt aError)

  1380     {

  1381     CActiveScheduler::Stop();

  1382     return aError;

  1383     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--