1 // Copyright (c) 2004-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 // REQ1952

    15 // 

    16 //

    17 

    18 #include <caf/caf.h>

    19 #include <e32math.h>

    20 

    21 

    22 #include "DRMTestVidPlayer.h"

    23 #include "rightsdatabase.h"

    24 

    25 using namespace ContentAccess;

    26 

    27 const TInt KFrameWidth = 100;

    28 const TInt KFrameHeight = 50;

    29 const TInt KDefaultRightsID = 1;

    30 const TInt KDefaultRightsCount = 2;

    31 const TInt KZeroRightsCount = 0;

    32 

    33 TAny	GetDriveName(TDes& aFileName)

    34 {

    35 #ifdef __WINS__

    36 	aFileName = _L("c:");	

    37 #elif defined(__MARM__) || defined(__X86GCC__)

    38 	#ifdef __TEST_FILES_ON_C_DRIVE__

    39 		aFileName = _L("c:");

    40 	#else

    41 		aFileName = _L("z:");	

    42 	#endif // __TEST_FILES_ON_C_DRIVE__

    43 #endif

    44 }

    45 

    46 /**

    47  *

    48  * Static constructor for CTestStepVidPlayerDRMGetFrame.

    49  *

    50  *

    51  * @return	"CTestStepVidPlayerDRMGetFrame*"

    52  *			The constructed CTestStepVidPlayerDRMGetFrame

    53  *

    54  * @xxxx

    55  * 

    56  */

    57 

    58 CTestStepVidPlayerDRMGetFrame::CTestStepVidPlayerDRMGetFrame(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

    59 	: CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)

    60 	{}

    61 

    62 CTestStepVidPlayerDRMGetFrame* CTestStepVidPlayerDRMGetFrame::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

    63 	{

    64 	CTestStepVidPlayerDRMGetFrame* self = new (ELeave) CTestStepVidPlayerDRMGetFrame(aTestName,aSectName,aKeyName);

    65 	return self;

    66 	}

    67 

    68 

    69 void CTestStepVidPlayerDRMGetFrame::MvpuoFrameReady(CFbsBitmap& aFrame, TInt aError)

    70 	{

    71 	iError = aError;

    72 	if (aError==KErrNone)

    73 		{

    74 		if (aFrame.Handle() == NULL || aFrame.SizeInPixels() != TSize(KFrameWidth,KFrameHeight) )

    75 			iError = KErrArgument;

    76 		else

    77 			{

    78 				iError = KErrNone;

    79 				INFO_PRINTF1(_L("MvpuoFrameReady: GetFrameL() COMPLETED OK"));

    80 			}

    81 		}

    82 	CActiveScheduler::Stop();

    83 	}

    84 

    85 /**

    86  * Load and initialise an audio file.

    87  */

    88 TVerdict CTestStepVidPlayerDRMGetFrame::DoTestStepL()

    89 	{

    90 	TVerdict ret = EFail;

    91 	iError = KErrTimedOut;

    92 

    93 	INFO_PRINTF1(_L("Test : Video Player DRM GetFrame"));

    94 	

    95 	

    96 	TPtrC			filename;

    97 	if(!GetStringFromConfig(iSectName,iKeyName,filename))

    98 		return EInconclusive;

    99 	

   100 	InitWservL();

   101 

   102 	//setup DRM rights

   103 	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

   104 	delete rights; // the database will now be reset and have no entries in it

   105 

   106 	TRect rect, clipRect;

   107 	CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,

   108 															EMdaPriorityPreferenceTimeAndQuality,

   109 															iWs, *iScreen, *iWindow, rect, clipRect);

   110 	CleanupStack::PushL(player);

   111 	

   112 	TRAP(iError,player->OpenFileL(filename));

   113 	

   114 	if(iError == KErrNone)

   115 		{

   116 		// Wait for initialisation callback

   117 		INFO_PRINTF1(_L("CVideoPlayerUtility: Opening file"));

   118 		CActiveScheduler::Start();

   119 		}

   120 	// Check for errors.

   121 	if (iError == KErrNone && player != NULL)

   122 		{

   123 		player->Prepare();

   124 		CActiveScheduler::Start();

   125 		}

   126 

   127 	// Check for errors.

   128 	if (iError == KErrNone && player != NULL)

   129 		ret = DoTestL(player);

   130 		

   131 	INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying"));

   132 	CleanupStack::PopAndDestroy(player);

   133 	if(iError != KErrNone)

   134 		ERR_PRINTF2( _L("CVideoPlayerUtility failed with error %d"),iError );

   135 	return	ret;

   136 	}

   137 

   138 TVerdict CTestStepVidPlayerDRMGetFrame::DoTestL(CVideoPlayerUtility* aPlayer)

   139 	{

   140 	TVerdict ret = EFail;

   141 

   142 		iError = KErrTimedOut;

   143 		aPlayer->GetFrameL(EColor16M, EView);

   144 		INFO_PRINTF1(_L("CVideoPlayerUtility: Getting Frame from file"));

   145 		// Wait for init callback

   146 		CActiveScheduler::Start();

   147 		if(iError == KErrNone)

   148 			ret = EPass;

   149 		else

   150 			ret = EFail;

   151 

   152 

   153 	return ret;

   154 	}

   155 

   156 //

   157 /**

   158  *

   159  * Static constructor for CTestStepVidPlayerDRMGetFrameProtected.

   160  *

   161  *

   162  * @return	"CTestStepVidPlayerDRMGetFrameProtected*"

   163  *			The constructed CTestStepVidPlayerDRMGetFrameProtected

   164  *

   165  * @xxxx

   166  * 

   167  */

   168 

   169 CTestStepVidPlayerDRMGetFrameProtected::CTestStepVidPlayerDRMGetFrameProtected(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

   170 	: CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)

   171 	{}

   172 

   173 CTestStepVidPlayerDRMGetFrameProtected* CTestStepVidPlayerDRMGetFrameProtected::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

   174 	{

   175 	CTestStepVidPlayerDRMGetFrameProtected* self = new (ELeave) CTestStepVidPlayerDRMGetFrameProtected(aTestName,aSectName,aKeyName);

   176 	return self;

   177 	}

   178 

   179 

   180 void CTestStepVidPlayerDRMGetFrameProtected::MvpuoFrameReady(CFbsBitmap& aFrame, TInt aError)

   181 	{

   182 	iError = aError;

   183 	if (iError == KErrNone)

   184 		{

   185 		if (aFrame.Handle() == NULL || aFrame.SizeInPixels() != TSize(KFrameWidth,KFrameHeight) )	

   186 			iError = KErrArgument;

   187 		else

   188 			{

   189 				iError = KErrNone;

   190 				INFO_PRINTF1(_L("MvpuoFrameReady: GetFrameL() COMPLETED OK"));

   191 			}

   192 		}

   193 	CActiveScheduler::Stop();

   194 	}

   195 

   196 /**

   197  * Load and initialise an audio file.

   198  */

   199 TVerdict CTestStepVidPlayerDRMGetFrameProtected::DoTestStepL()

   200 	{

   201 TVerdict ret = EFail;

   202 	iError = KErrTimedOut;

   203 

   204 	INFO_PRINTF1(_L("Test : Video Player DRM GetFrame"));

   205 	

   206 	

   207 	TPtrC			filename;

   208 	if(!GetStringFromConfig(iSectName,iKeyName,filename))

   209 		return EInconclusive;

   210 	

   211 	InitWservL();

   212 

   213 	//setup DRM rights

   214 	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

   215 	CleanupStack::PushL(rights);

   216 	rights->AddRightsL(KDefaultRightsID,KZeroRightsCount); // add rights count 

   217 	CleanupStack::PopAndDestroy(rights); // cleanup rights object

   218 

   219 

   220 	TRect rect, clipRect;

   221 	CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,

   222 															EMdaPriorityPreferenceTimeAndQuality,

   223 															iWs, *iScreen, *iWindow, rect, clipRect);

   224 	CleanupStack::PushL(player);

   225 	TMMFileSource fs(filename, KDefaultContentObject, EPeek);

   226 	TRAP(iError,player->OpenFileL(fs));

   227 	

   228 	if(iError == KErrNone)

   229 		{

   230 		// Wait for initialisation callback

   231 		INFO_PRINTF1(_L("CVideoPlayerUtility: Opening file"));

   232 		CActiveScheduler::Start();

   233 		}

   234 	// Check for errors.

   235 	if (iError == KErrNone && player != NULL)

   236 		{

   237 		player->Prepare();

   238 		CActiveScheduler::Start();

   239 		}

   240 

   241 	// Check for errors.

   242 	if (iError == KErrNone && player != NULL)

   243 		ret = DoTestL(player);

   244 		

   245 	INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying"));

   246 	CleanupStack::PopAndDestroy(player);

   247 	if(iError != KErrNone)

   248 		ERR_PRINTF2( _L("CVideoPlayerUtility failed with error %d"),iError );

   249 	return	ret;

   250 	}

   251 

   252 TVerdict CTestStepVidPlayerDRMGetFrameProtected::DoTestL(CVideoPlayerUtility* aPlayer)

   253 	{

   254 	TVerdict ret = EFail;

   255 

   256 		iError = KErrTimedOut;

   257 		//set rights count to zero

   258 		aPlayer->GetFrameL(EColor16M, EView);

   259 		INFO_PRINTF1(_L("CVideoPlayerUtility: Getting Frame from file"));

   260 		// Wait for init callback

   261 		CActiveScheduler::Start();

   262 		if(iError == KErrCANoPermission)

   263 			ret = EPass;

   264 		else

   265 			ret = EFail;

   266 

   267 	return ret;

   268 	}

   269 

   270 //

   271 /**

   272  *

   273  * Static constructor for CTestStepVidPlayerDRMPlayNoRights.

   274  *

   275  *

   276  * @return	"CTestStepVidPlayerDRMPlayNoRights*"

   277  *			The constructed CTestStepVidPlayerDRMPlayNoRights

   278  *

   279  * @xxxx

   280  * 

   281  */

   282 

   283 CTestStepVidPlayerDRMPlayNoRights::CTestStepVidPlayerDRMPlayNoRights(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

   284 	: CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)

   285 	{}

   286 

   287 CTestStepVidPlayerDRMPlayNoRights* CTestStepVidPlayerDRMPlayNoRights::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

   288 	{

   289 	CTestStepVidPlayerDRMPlayNoRights* self = new (ELeave) CTestStepVidPlayerDRMPlayNoRights(aTestName,aSectName,aKeyName);

   290 	return self;

   291 	}

   292 

   293 /**

   294  * Load and initialise an audio file.

   295  */

   296 TVerdict CTestStepVidPlayerDRMPlayNoRights::DoTestStepL()

   297 	{

   298 	TVerdict ret = EFail;

   299 	iError = KErrTimedOut;

   300 

   301 	INFO_PRINTF1(_L("Test : Video Player - Open File with no rights"));

   302 

   303 	TPtrC filename;

   304 	if(!GetStringFromConfig(iSectName,iKeyName,filename))

   305 		return EInconclusive;

   306 

   307 	

   308 	InitWservL();

   309 

   310 	//setup DRM rights

   311 	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

   312 	delete rights; // the database will now be reset and have no entries in it

   313 

   314 	TRect rect, clipRect;

   315 	CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,

   316 															EMdaPriorityPreferenceTimeAndQuality,

   317 															iWs, *iScreen, *iWindow, rect, clipRect);

   318 	CleanupStack::PushL(player);

   319 	TRAP(iError,player->OpenFileL(filename));

   320 	if (iError != KErrNone)

   321 		{

   322 		ERR_PRINTF2( _L("OpenFileL() left with %d, expecting"),iError);

   323 		CleanupStack::PopAndDestroy(player);

   324 		return	ret;

   325 		}

   326 	CActiveScheduler::Start();

   327 	

   328 	if(iError == KErrCANoRights)

   329 		{

   330 		ret = EPass;

   331 		INFO_PRINTF1(_L("Expected failure with KErrCANoRights"));

   332 		}

   333 	else

   334 		ERR_PRINTF3( _L("CVideoPlayerUtility received error %d, expecting"),iError, KErrCANoRights );

   335 	INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying"));

   336 

   337 	CleanupStack::PopAndDestroy(player);

   338 	return	ret;

   339 	}

   340 

   341 TVerdict CTestStepVidPlayerDRMPlayNoRights::DoTestL(CVideoPlayerUtility* aPlayer)

   342 	{

   343 	TVerdict ret = EFail;

   344 	

   345 	iError = KErrTimedOut;

   346 	aPlayer->Play();

   347 	INFO_PRINTF1(_L("CVideoPlayerUtility: Playing file"));

   348 	// Wait for init callback

   349 	CActiveScheduler::Start();

   350 	if(iError == KErrNone)

   351 		ret = EPass;

   352 	else

   353 		ret = EFail;

   354 	

   355 	return ret;

   356 	}

   357 

   358 //

   359 /**

   360  *

   361  * Static constructor for CTestStepVidPlayerDRMPlayRights.

   362  *

   363  *

   364  * @return	"CTestStepVidPlayerDRMPlayRights*"

   365  *			The constructed CTestStepVidPlayerDRMPlayRights

   366  *

   367  * @xxxx

   368  * 

   369  */

   370 

   371 CTestStepVidPlayerDRMPlayRights::CTestStepVidPlayerDRMPlayRights(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

   372 	: CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)

   373 	{}

   374 

   375 CTestStepVidPlayerDRMPlayRights* CTestStepVidPlayerDRMPlayRights::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)

   376 	{

   377 	CTestStepVidPlayerDRMPlayRights* self = new (ELeave) CTestStepVidPlayerDRMPlayRights(aTestName,aSectName,aKeyName);

   378 	return self;

   379 	}

   380 

   381 /**

   382  * Load and initialise an audio file.

   383  */

   384 TVerdict CTestStepVidPlayerDRMPlayRights::DoTestStepL()

   385 	{

   386 	TVerdict ret = EFail;

   387 	iError = KErrTimedOut;

   388 

   389 	INFO_PRINTF1(_L("Test : Video Player - File"));

   390 

   391 	TPtrC filename;

   392 	if(!GetStringFromConfig(iSectName,iKeyName,filename))

   393 		return EInconclusive;

   394 

   395 	

   396 	InitWservL();

   397 

   398 	//setup DRM rights

   399 	CRightsDatabase* rights = CRightsDatabase::NewL(EFalse); // create new database overwriting current one

   400 	CleanupStack::PushL(rights);

   401 	rights->AddRightsL(KDefaultRightsID,KDefaultRightsCount); // add rights count 

   402 	CleanupStack::PopAndDestroy(rights); // cleanup rights object

   403 

   404 	TRect rect, clipRect;

   405 	CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,

   406 															EMdaPriorityPreferenceTimeAndQuality,

   407 															iWs, *iScreen, *iWindow, rect, clipRect);

   408 	CleanupStack::PushL(player);

   409 	TRAP(iError,player->OpenFileL(filename));

   410 	

   411 	if(iError == KErrNone)

   412 		{

   413 		// Wait for initialisation callback

   414 		INFO_PRINTF1(_L("CVideoPlayerUtility: Opening file"));

   415 		CActiveScheduler::Start();

   416 		}

   417 	// Check for errors.

   418 	if (iError == KErrNone && player != NULL)

   419 		{

   420 		player->Prepare();

   421 		CActiveScheduler::Start();

   422 		}

   423 

   424 	// Check for errors.

   425 	if (iError == KErrNone && player != NULL)

   426 		ret = DoTestL(player);

   427 		

   428 	INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying"));

   429 	CleanupStack::PopAndDestroy(player);

   430 	if(iError != KErrNone)

   431 		ERR_PRINTF2( _L("CVideoPlayerUtility failed with error %d"),iError );

   432 	return	ret;

   433 	}

   434 

   435 TVerdict CTestStepVidPlayerDRMPlayRights::DoTestL(CVideoPlayerUtility* aPlayer)

   436 	{

   437 	TVerdict ret = EFail;

   438 	

   439 	iError = KErrTimedOut;

   440 	aPlayer->Play();

   441 	INFO_PRINTF1(_L("CVideoPlayerUtility: Playing file"));

   442 	// Wait for init callback

   443 	CActiveScheduler::Start();

   444 	if(iError == KErrNone)

   445 		ret = EPass;

   446 	else

   447 		ret = EFail;

   448 	

   449 	return ret;

   450 	}