1 // Copyright (c) 2002-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 // Audio, MIDI and Video client utility functions.

    15 // 

    16 //

    17 

    18 #include <e32std.h>

    19 #include <f32file.h>

    20 #include <bautils.h>

    21 #include <mmf/server/mmfdrmpluginserverproxy.h>

    22 #include <caf/content.h>

    23 #include <caf/data.h>

    24 using namespace ContentAccess;

    25 

    26 #include "mmfclientutility.h"

    27 #include <mmf/common/mmfpaniccodes.h>

    28 

    29 const TInt KMaxMimeLength = 256;

    30 const TInt KMaxHeaderSize = 256;

    31 const TInt KExpandSize = 100;

    32 

    33 #ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT

    34 	const TInt KDefaultScreenNo = 0;

    35 #endif

    36 

    37 void CUPanic(TInt aCUPanicCode)

    38 	{

    39 	_LIT(KMMFMediaClientUtilityPaanicCategory, "MMFClientUtility");

    40 	User::Panic(KMMFMediaClientUtilityPaanicCategory, aCUPanicCode);

    41 	}

    42 

    43 /**

    44  * @internalComponent

    45  */

    46 EXPORT_C TUid CMMFClientUtility::ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid)

    47 	{

    48 	TUid ECOMUid = KNullUid;

    49 	if (aMdaFormatUid == KUidMdaClipFormatWav)	

    50 		ECOMUid = TUid::Uid(KMmfUidFormatWAVWrite);

    51 	else if (aMdaFormatUid == KUidMdaClipFormatAu)	

    52 		ECOMUid = TUid::Uid(KMmfUidFormatAUWrite);

    53 	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)	

    54 		ECOMUid = TUid::Uid(KMmfUidFormatRAWWrite);

    55 	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)	

    56 		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRWrite);

    57 

    58 	return ECOMUid;

    59 	}

    60 

    61 /**

    62  * @internalComponent

    63  */

    64 EXPORT_C TUid CMMFClientUtility::ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid)

    65 	{

    66 	TUid ECOMUid = KNullUid;

    67 	if (aMdaFormatUid == KUidMdaClipFormatWav)	

    68 		ECOMUid = TUid::Uid(KMmfUidFormatWAVRead);

    69 	else if (aMdaFormatUid == KUidMdaClipFormatAu)	

    70 		ECOMUid = TUid::Uid(KMmfUidFormatAURead);

    71 	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)	

    72 		ECOMUid = TUid::Uid(KMmfUidFormatRAWRead);

    73 	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)	

    74 		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRRead);

    75 

    76 	return ECOMUid;

    77 	}

    78 

    79 /**

    80  * @internalComponent

    81  */

    82 EXPORT_C TInt CMMFClientUtility::GetFileHeaderData(const TDesC& aFileName, TDes8& aHeaderData, TInt aMaxLength)

    83 	{

    84 	RFs fsSession;

    85 	RFile file;

    86 	TInt error = KErrNone;

    87 

    88 	if ((error = fsSession.Connect()) == KErrNone)

    89 		{

    90 		if ((error = file.Open(fsSession, aFileName, EFileShareReadersOrWriters)) == KErrNone)

    91 			{

    92 			TInt size = 0;

    93 

    94 			if ((error = file.Size(size)) == KErrNone)

    95 				{

    96 				if (size > 0)

    97 					{

    98 					if (size > aMaxLength) 

    99 						size = aMaxLength;

   100 

   101 					error = file.Read(aHeaderData, size);

   102 					}

   103 				}

   104 			file.Close();

   105 			}

   106 		fsSession.Close();

   107 		}

   108 

   109 	return error;

   110 	}

   111 

   112 /**

   113  * @internalComponent

   114  */

   115 EXPORT_C TFourCC CMMFClientUtility::ConvertMdaCodecToFourCC(TMdaPackage& aCodec)

   116 	{

   117 	TFourCC dataType = KMMFFourCCCodeNULL;	

   118 	switch (aCodec.Uid().iUid)

   119 		{

   120 		case KUidMdaWavPcmCodecDefine: 

   121 			{

   122 			TMdaPcmWavCodec* pcmWavCodec = (TMdaPcmWavCodec*)&aCodec;

   123 			if (pcmWavCodec->iBits == TMdaPcmWavCodec::E8BitPcm)

   124 				dataType = KMMFFourCCCodePCMU8; //8 bit PCM

   125 			else 

   126 				dataType = KMMFFourCCCodePCM16; //16 bit PCM

   127 			break;

   128 			}

   129 		case KUidMdaAu8PcmCodecDefine:

   130 			dataType = KMMFFourCCCodePCM8;

   131 			break;

   132 		case KUidMdaAuCodecDefine:

   133 		case KUidMdaAu16PcmCodecDefine:

   134 			dataType = KMMFFourCCCodePCM16B;

   135 			break;

   136 

   137 		case KUidMdaAuMulawCodecDefine:

   138 		case KUidMdaWavMulawCodecDefine:

   139 		case KUidMdaRawAudioMulawCodecDefine:  //uLAW

   140 			dataType = KMMFFourCCCodeMuLAW;

   141 			break;

   142 		case KUidMdaAuAlawCodecDefine:

   143 		case KUidMdaWavAlawCodecDefine:

   144 		case KUidMdaRawAudioAlawCodecDefine:	 //ALAW

   145 			dataType = KMMFFourCCCodeALAW;

   146 			break;

   147 		case KUidMdaRawAudioS8PcmCodecDefine:	 //  P8

   148 			dataType = KMMFFourCCCodePCM8;

   149 			break;

   150 		case KUidMdaRawAudioU8PcmCodecDefine:	  // PU8

   151 			dataType = KMMFFourCCCodePCMU8;

   152 			break;

   153 		case KUidMdaRawAudioSL16PcmCodecDefine: // P16

   154 			dataType = KMMFFourCCCodePCM16;

   155 			break;

   156 		case KUidMdaRawAudioSB16PcmCodecDefine: //P16B

   157 			dataType = KMMFFourCCCodePCM16B;

   158 			break;

   159 		case KUidMdaRawAudioUL16PcmCodecDefine: //PU16

   160 			dataType = KMMFFourCCCodePCMU16;

   161 			break;

   162 		case KUidMdaRawAudioUB16PcmCodecDefine: //PU6B

   163 			dataType = KMMFFourCCCodePCMU16B; 

   164 			break;

   165 		case KUidMdaGsmWavCodecDefine: //GSM6 

   166 			dataType = KMMFFourCCCodeGSM610;

   167 			break;

   168 		case KUidMdaWavImaAdpcmCodecDefine:

   169 			dataType = KMMFFourCCCodeIMAD;

   170 			break;

   171 		case KUidMdaRawAmrCodecDefine:

   172 			dataType = KMMFFourCCCodeAMR;

   173 			break;

   174 		default:	// Not a Uid we recognise

   175 			dataType = KMMFFourCCCodeNULL;

   176 			break;

   177 		}

   178 	return dataType;

   179 	}

   180 

   181 

   182 CMMFUtilityFileInfo* CMMFUtilityFileInfo::NewL(TMMSource& aSource, TBool aSecureDRMMode)

   183 	{

   184 	CMMFUtilityFileInfo* self = CMMFUtilityFileInfo::NewLC(aSource, aSecureDRMMode);

   185 	CleanupStack::Pop(self);

   186 	return self;

   187 	}

   188 

   189 

   190 CMMFUtilityFileInfo* CMMFUtilityFileInfo::NewLC(TMMSource& aSource, TBool aSecureDRMMode)

   191 	{

   192 	CMMFUtilityFileInfo* self = new (ELeave) CMMFUtilityFileInfo;

   193 	CleanupStack::PushL(self);

   194 	self->ConstructL(aSource, aSecureDRMMode);

   195 	return self;

   196 	}

   197 

   198 

   199 void CMMFUtilityFileInfo::ConstructL(const TMMSource& aSource, TBool aSecureDRMMode)

   200 	{

   201 	if (!aSecureDRMMode)

   202 		{

   203 		if (aSource.SourceType()==KUidMMFileSource)

   204 			{

   205 			const TMMFileSource& fileSource = static_cast<const TMMFileSource&>(aSource);

   206 			iData = CData::NewL(TVirtualPathPtr(fileSource.Name(), fileSource.UniqueId()),

   207 								EContentShareReadWrite);

   208 			}

   209 

   210 		if (aSource.SourceType()==KUidMMFileHandleSource)

   211 			{

   212 			const TMMFileHandleSource& fileHandleSource = static_cast<const TMMFileHandleSource&>(aSource);

   213 			iData = CData::NewL(fileHandleSource.Handle(), fileHandleSource.UniqueId());

   214 			}

   215 		

   216 		TInt err = iData->SetProperty(EAgentPropertyAgentUI, aSource.IsUIEnabled());		

   217 		if (err != KErrNone && err != KErrCANotSupported)

   218 			{

   219 			// KErrCANotSupported isn't a problem for us so eat the error code.

   220 			User::Leave(err);

   221 			}

   222 

   223 		err = iData->EvaluateIntent(aSource.Intent());

   224 		User::LeaveIfError(err);

   225 		}

   226 	else

   227 		{

   228 		// Use RMMFDRMPluginServerProxy as medium

   229 		iDrmPluginServer = new (ELeave) RMMFDRMPluginServerProxy;

   230 		User::LeaveIfError(iDrmPluginServer->Open());

   231 		

   232 		CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);

   233 		CleanupStack::PushL(dataBuffer);

   234 		RBufWriteStream stream;

   235 		stream.Open(*dataBuffer);

   236 		CleanupClosePushL(stream);

   237 		

   238 		stream.WriteInt32L(aSource.UniqueId().Length());

   239 		stream.WriteL(aSource.UniqueId());

   240 		stream.WriteInt32L(aSource.IsUIEnabled());

   241 		TPckgBuf<ContentAccess::TIntent> intentPckg(aSource.Intent());

   242 		stream.WriteL(intentPckg);

   243 		stream.CommitL();

   244 	

   245 		CleanupStack::PopAndDestroy(&stream);

   246 		if (aSource.SourceType()==KUidMMFileSource)

   247 			{

   248 			const TMMFileSource& fileSource = static_cast<const TMMFileSource&>(aSource);

   249 			iDrmPluginServer->OpenDataContentL(fileSource.Name(), dataBuffer->Ptr(0));

   250 			}

   251 		if (aSource.SourceType()==KUidMMFileHandleSource)

   252 			{

   253 			const TMMFileHandleSource& fileHandleSource = static_cast<const TMMFileHandleSource&>(aSource);

   254 			iDrmPluginServer->OpenDataContentL(fileHandleSource.Handle(), dataBuffer->Ptr(0));

   255 			}

   256 		CleanupStack::PopAndDestroy(dataBuffer);

   257 		}

   258 	}

   259 

   260 TInt CMMFUtilityFileInfo::EvaluateIntent(TIntent aIntent)

   261 	{

   262 	if (iData)

   263 		{

   264 		return iData->EvaluateIntent(aIntent);

   265 		}

   266 	else

   267 		{

   268 		ASSERT(iDrmPluginServer);

   269 		return iDrmPluginServer->EvaluateDataContentIntent(aIntent);

   270 		}

   271 	}

   272 /**

   273  * @internalComponent

   274  */

   275 TBool CMMFUtilityFileInfo::GetFileMimeTypeL(TDes8& aMimeType)

   276 	{

   277 	if (iData)

   278 		{

   279 		return iData->GetMimeTypeL(aMimeType);

   280 		}

   281 	else

   282 		{

   283 		ASSERT(iDrmPluginServer);

   284 		return iDrmPluginServer->GetDataContentMimeTypeL(aMimeType);

   285 		}

   286 	}

   287 

   288 /**

   289  * @internalComponent

   290  */

   291 void CMMFUtilityFileInfo::GetFileHeaderDataL(TDes8& aHeaderData, TInt aMaxLength)

   292 	{

   293 	if (iData)

   294 		{

   295 		TInt size = 0;

   296 		iData->DataSizeL(size);

   297 		if (size > 0)

   298 			{

   299 			if (size > aMaxLength) 

   300 				size = aMaxLength;

   301 			TInt pos = 0;

   302 			User::LeaveIfError(iData->Seek(ESeekStart, pos));

   303 			User::LeaveIfError(iData->Read(aHeaderData, size));

   304 			}

   305 		}

   306 	else

   307 		{

   308 		ASSERT(iDrmPluginServer);

   309 		iDrmPluginServer->GetDataContentFileHeaderL(aHeaderData, aMaxLength);

   310 		}

   311 	}

   312 

   313 /**

   314  * @internalComponent

   315  */

   316 EXPORT_C HBufC8* CMMFClientUtility::GetFileExtensionL(const TDesC& aFileName)

   317 	{

   318 	TParse fileName;

   319 	fileName.Set(aFileName,NULL,NULL);

   320 	HBufC8* fileSuffix = NULL;

   321 	if(fileName.ExtPresent())

   322 		{

   323 		TPtrC fileSuffixPtr(fileName.Ext());

   324 		fileSuffix = HBufC8::NewL(fileSuffixPtr.Length());

   325 		fileSuffix->Des().Copy(fileSuffixPtr);

   326 		}

   327 	else

   328 		{

   329 		fileSuffix = KNullDesC8().AllocL();

   330 		}

   331 	return fileSuffix;

   332 	}

   333 

   334 

   335 /**

   336  * @internalComponent

   337  */

   338 CMMFUtilityFileInfo::~CMMFUtilityFileInfo()

   339 	{

   340 	if (iData)

   341 		{

   342 		delete iData;

   343 		}

   344 	if (iDrmPluginServer)

   345 		{

   346 		iDrmPluginServer->Close();

   347 		delete iDrmPluginServer;

   348 		}

   349 	}

   350 

   351 /*

   352  * @internalComponent

   353  *

   354  * Returns an integer rating indicating how well the supplied format matches

   355  * the header data and file extension supplied.

   356  * 3 brownie points awarded for data & suffix match.

   357  * 2 brownie points awarded for data match alone.

   358  * 1 brownie point awarded for suffix match alone.

   359  */

   360 TInt CMMFClientUtility::GetBestMatchL(const CMMFFormatImplementationInformation* format, const TDesC8& aHeaderData, const TDesC8& aFileExtension)

   361 	{

   362 	TInt browniePoints = 0;

   363 

   364 	if (aHeaderData.Length() > 0) // Non empty file

   365 		{

   366 		if (aFileExtension.Length() > 0) // With a file extension

   367 			{

   368 			if (format->SupportsHeaderDataL(aHeaderData) && 

   369 				format->SupportsFileExtension(aFileExtension))

   370 				{

   371 				browniePoints = 3;

   372 				}

   373 			else if (format->SupportsHeaderDataL(aHeaderData))

   374 				{

   375 				browniePoints = 2;

   376 				}

   377 			else

   378 				{

   379 				// See if this format has any 'empty' match data or no match data, indicating 

   380 				// that this format will match extension alone even if data present.

   381 				// (A format may have more than one match data string.)

   382 				const CDesC8Array& supportedHeaderData = format->SupportedHeaderData();

   383 

   384 				if (supportedHeaderData.Count() == 0)

   385 					{

   386 					// No header data indicated.

   387 					if (format->SupportsFileExtension(aFileExtension))

   388 						{

   389 							browniePoints = 1;

   390 						}

   391 					}

   392 				else

   393 					{

   394 					for (register TInt i = 0; i < supportedHeaderData.Count(); i++)

   395 						{

   396 						if ((supportedHeaderData[i].Length() == 0) && 

   397 							format->SupportsFileExtension(aFileExtension))

   398 							{

   399 							browniePoints = 1;

   400 							}

   401 						}

   402 					}

   403 				}

   404 			}

   405 		else

   406 			{

   407 			// No file suffix, so must match header data alone.

   408 			if (format->SupportsHeaderDataL(aHeaderData))

   409 				{

   410 				browniePoints = 2;

   411 				}

   412 			}

   413 		}

   414 	else // Empty File

   415 		{

   416 		// We have no choice but to match extension, if there is one.

   417 		if ((aFileExtension.Length() > 0) && format->SupportsFileExtension(aFileExtension))

   418 			{

   419 			browniePoints = 1;

   420 			}

   421 		}

   422 

   423 	return browniePoints;

   424 }

   425 

   426 /**

   427  * @internalComponent

   428  *

   429  * This function parses all the play & record formats in the given list of controllers,

   430  * looking for controllers & formats that best match the requirements. 

   431  * Play controllers will be returned before record controllers, and

   432  * in cases of equal priority between formats, ECom order will be maintained.

   433  *

   434  * @param	"aControllers"	

   435  *			A reference to a user supplied list of controllers retrieved from ECom.

   436  *			This list may be have been filtered for audio/video/play/record.

   437  * @param	"aHeaderDataPlayback"

   438  *			A descriptor reference containing the file's header data.

   439  *          for matching against a controller's play formats. May be KNullDesC8

   440  * @param	"aFileExtensionPlayback"

   441  *			A descriptor reference containing the filename's extension.

   442  *          for matching against a controller's play formats. May be KNullDesC8

   443  * @param	"aHeaderDataRecord"

   444  *			A descriptor reference containing the file's header data.

   445  *          for matching against a controller's record formats. May be KNullDesC8

   446  * @param	"aFileExtensionRecord"

   447  *			A descriptor reference containing the filename's extension.

   448  *          for matching against a controller's record formats. May be KNullDesC8

   449  * @param	"aPrioritisedControllers"

   450  *			A reference to a user supplied list through which the list of

   451  *			prioritised controllers will be returned.

   452  * @since	7.0s

   453  */

   454 void CMMFClientUtility::PrioritiseControllersL(

   455 	const RMMFControllerImplInfoArray& aControllers, 

   456 	const TDesC8& aHeaderDataPlayback, 

   457 	const TDesC8& aFileExtensionPlayback, 

   458 	const TDesC8& aHeaderDataRecord, 

   459 	const TDesC8& aFileExtensionRecord, 

   460 	RMMFControllerImplInfoArray& prioritisedControllers)

   461 	{

   462 	RMMFControllerImplInfoArray fullMatchControllers; // data AND suffix

   463 	CleanupClosePushL(fullMatchControllers);

   464 	RMMFControllerImplInfoArray partMatchControllers; // data OR suffix

   465 	CleanupClosePushL(partMatchControllers);

   466 

   467 	TBool checkingPlaybackFormats = EFalse;

   468 	TBool checkingRecordFormats = EFalse;

   469 

   470 	if (aHeaderDataPlayback != KNullDesC8 || aFileExtensionPlayback != KNullDesC8)

   471 		checkingPlaybackFormats = ETrue;

   472 	if (aHeaderDataRecord != KNullDesC8 || aFileExtensionRecord != KNullDesC8)

   473 		checkingRecordFormats = ETrue;

   474 

   475 	// Examine each format for each controller. We only want to know at this stage

   476 	// if the controller has suitable formats, so as soon as we know it has, we can

   477 	// add it to out list, ranked by how well it matched.

   478 	for (register TInt i = 0; i < aControllers.Count(); i++)

   479 		{

   480 		const CMMFControllerImplementationInformation* controller = aControllers[i];

   481 		TInt savedBrowniePointsPlayback = 0;

   482 		TInt savedBrowniePointsRecord = 0;

   483 

   484 		if (checkingPlaybackFormats)

   485 			{

   486 			for (register TInt p = 0; p < controller->PlayFormats().Count(); p++)

   487 				{

   488 				const CMMFFormatImplementationInformation* format = controller->PlayFormats()[p];

   489 

   490 				TInt browniePoints = GetBestMatchL(format, aHeaderDataPlayback, aFileExtensionPlayback);

   491 

   492 				if (browniePoints >= savedBrowniePointsPlayback)

   493 					savedBrowniePointsPlayback = browniePoints;

   494 				}

   495 			}

   496 

   497 		if (checkingRecordFormats)

   498 			{

   499 			for (register TInt r = 0; r < controller->RecordFormats().Count(); r++)

   500 				{

   501 				const CMMFFormatImplementationInformation* format = controller->RecordFormats()[r];

   502 

   503 				TInt browniePoints = GetBestMatchL(format, aHeaderDataRecord, aFileExtensionRecord);

   504 

   505 				if (browniePoints >= savedBrowniePointsRecord)

   506 					savedBrowniePointsRecord = browniePoints;

   507 				}

   508 			}

   509 

   510 		TInt savedBrowniePoints = 0;

   511 		// if we're checking both playback & record formats

   512 		// make sure we've found both

   513 		if (checkingPlaybackFormats && checkingRecordFormats)

   514 			{

   515 			savedBrowniePoints = Min(savedBrowniePointsPlayback, savedBrowniePointsRecord);

   516 			}

   517 		else if (checkingPlaybackFormats)

   518 			{

   519 			savedBrowniePoints = savedBrowniePointsPlayback;

   520 			}

   521 		else if (checkingRecordFormats)

   522 			{

   523 			savedBrowniePoints = savedBrowniePointsRecord;

   524 			}

   525 

   526 		// Checked all formats for this controller, now count our brownie points.

   527 		switch (savedBrowniePoints)

   528 			{

   529 			case 3:

   530 				User::LeaveIfError(fullMatchControllers.Append(controller));

   531 				break;

   532 			case 2:

   533 				User::LeaveIfError(partMatchControllers.Insert(controller, 0));

   534 				break;

   535 			case 1:

   536 				User::LeaveIfError(partMatchControllers.Append(controller));

   537 				break;

   538 			default:

   539 				break;

   540 			}

   541 		}

   542 

   543 	// The better the controller matches, the earlier it will be in the final list.

   544 	for (register TInt x = 0; x < fullMatchControllers.Count(); x++)

   545 		{

   546 		if (prioritisedControllers.Find(fullMatchControllers[x]) == KErrNotFound)

   547 			{

   548 			User::LeaveIfError(prioritisedControllers.Append(fullMatchControllers[x]));

   549 			}

   550 		}

   551 

   552 	for (register TInt y = 0; y < partMatchControllers.Count(); y++)

   553 		{

   554 		if (prioritisedControllers.Find(partMatchControllers[y]) == KErrNotFound)

   555 			{

   556 			User::LeaveIfError(prioritisedControllers.Append(partMatchControllers[y]));

   557 			}

   558 		}

   559 

   560 	CleanupStack::PopAndDestroy(2, &fullMatchControllers); // fullMatchControllers, partMatchControllers

   561 	}

   562 

   563 /**

   564  * @internalComponent

   565  */

   566 EXPORT_C CMMFMdaObjectStateChangeObserverCallback* CMMFMdaObjectStateChangeObserverCallback::NewL(MMdaObjectStateChangeObserver& aCallback)

   567 	{

   568 	return new(ELeave) CMMFMdaObjectStateChangeObserverCallback(aCallback);

   569 	}

   570 

   571 /**

   572  * @internalComponent

   573  */

   574 CMMFMdaObjectStateChangeObserverCallback::~CMMFMdaObjectStateChangeObserverCallback()

   575 	{

   576 	Cancel();

   577 	}

   578 

   579 /**

   580  * @internalComponent

   581  */

   582 EXPORT_C void CMMFMdaObjectStateChangeObserverCallback::CallBack(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

   583 	{

   584 	iObject = aObject;

   585 	iPreviousState = aPreviousState;

   586 	iCurrentState = aCurrentState;

   587 	iErrorCode = aErrorCode;

   588 	if (!IsActive())

   589 		{

   590 		TRequestStatus* s = &iStatus;

   591 		SetActive();

   592 		User::RequestComplete(s, KErrNone);

   593 		}

   594 	}

   595 

   596 CMMFMdaObjectStateChangeObserverCallback::CMMFMdaObjectStateChangeObserverCallback(MMdaObjectStateChangeObserver& aCallback) :

   597 	CActive(CActive::EPriorityHigh),

   598 	iCallback(aCallback)

   599 	{

   600 	CActiveScheduler::Add(this);

   601 	}

   602 

   603 void CMMFMdaObjectStateChangeObserverCallback::RunL()

   604 	{

   605 	iCallback.MoscoStateChangeEvent(iObject, iPreviousState, iCurrentState, iErrorCode);

   606 	}

   607 

   608 void CMMFMdaObjectStateChangeObserverCallback::DoCancel()

   609 	{

   610 	//nothing to cancel

   611 	}

   612 

   613 

   614 //****************************************

   615 // CMMFFindAndOpenController

   616 //****************************************

   617 

   618 /**

   619  * Factory function to create a CMMFFindAndOpenController class

   620  *

   621  * @internalComponent

   622  */

   623 EXPORT_C CMMFFindAndOpenController* CMMFFindAndOpenController::NewL(MMMFFindAndOpenControllerObserver& aObserver)

   624 	{

   625 	CMMFFindAndOpenController* self = new(ELeave) CMMFFindAndOpenController(aObserver);

   626 	CleanupStack::PushL(self);

   627 	self->ConstructL();

   628 	CleanupStack::Pop(self);

   629 	return self;

   630 	}

   631 

   632 CMMFFindAndOpenController::~CMMFFindAndOpenController()

   633 	{

   634 	Cancel();

   635 

   636 	// delete temporary variables

   637 	Close();

   638 

   639 	// this should cancel the AO

   640 	delete iAddDataSourceSinkAsync;

   641 

   642 	delete iPrimaryConfig;

   643 	delete iSecondaryConfig;

   644 	}

   645 

   646 /**

   647  * Function to free up memory after a successful open has completed

   648  * Useful to allow a alloc testing to work.

   649  * Must not be called if ReOpen() is to be called

   650  *

   651  * @internalComponent

   652  */

   653 EXPORT_C void CMMFFindAndOpenController::Close()

   654 	{

   655 

   656 	Cancel();

   657 	

   658 	if(iAddDataSourceSinkAsync)

   659 		{

   660 		iAddDataSourceSinkAsync->Cancel();

   661 		}

   662 		

   663 	if (iPrimaryConfig)

   664 		iPrimaryConfig->Close();

   665 	if (iSecondaryConfig)

   666 		iSecondaryConfig->Close();

   667 

   668 	iPrioritisedControllers.Close();

   669 	iControllers.ResetAndDestroy();

   670 	iControllers.Close();

   671 	

   672 	iFileName.SetLength(0);

   673 	iFileNameSecondary.SetLength(0);

   674 

   675 	delete iUrl;

   676 	iUrl = NULL;

   677 	

   678 	delete iMimeType;

   679 	iMimeType = NULL;

   680 	

   681 	delete iUniqueId;

   682 	iUniqueId = NULL;

   683 

   684 	if (iOwnFileHandle)

   685 		{

   686 		iFileHandle.Close();

   687 		iOwnFileHandle = EFalse;	

   688 		}

   689 	}

   690 /**

   691  * Function to free up memory of which is not required in ReOpen()

   692  * after a successful open has completed

   693  * Useful to allow a alloc testing to work.

   694  *

   695  * @internalComponent

   696  */

   697 

   698 EXPORT_C void CMMFFindAndOpenController::CloseConfig()

   699 	{

   700 	Cancel();

   701 	if(iAddDataSourceSinkAsync)

   702 		{

   703 		iAddDataSourceSinkAsync->Cancel();

   704 		}

   705 	

   706 	if (iSecondaryConfig)

   707 		{

   708 		iSecondaryConfig->Close();

   709 		}

   710 	

   711 	iPrioritisedControllers.Close();

   712 	iControllers.ResetAndDestroy();

   713 	iControllers.Close();

   714 	

   715 	iFileName.SetLength(0);

   716 	iFileNameSecondary.SetLength(0);

   717 

   718 	delete iUrl;

   719 	iUrl = NULL;

   720 	

   721 	delete iMimeType;

   722 	iMimeType = NULL;

   723 	

   724 	delete iUniqueId;

   725 	iUniqueId = NULL;

   726 

   727 	if (iOwnFileHandle)

   728 		{

   729 		iFileHandle.Close();

   730 		iOwnFileHandle = EFalse;		

   731 		}

   732 	}

   733 

   734 CMMFFindAndOpenController::CMMFFindAndOpenController(MMMFFindAndOpenControllerObserver& aObserver) :

   735 	CActive(EPriorityStandard), 

   736 	iObserver(aObserver),

   737 	iDescriptor(NULL, 0)

   738 	{

   739 	CActiveScheduler::Add(this);

   740 	}

   741 

   742 void CMMFFindAndOpenController::ConstructL()

   743 	{

   744 	iAddDataSourceSinkAsync = CMMFAddDataSourceSinkAsync::NewL(*this);

   745 	iPrimaryConfig = new (ELeave)  CConfig();

   746 	iSecondaryConfig =  new (ELeave) CConfig;

   747 	iCurrentConfig =  iPrimaryConfig;

   748 	

   749 	RProcess thisProcess;

   750 	iHasDrmCapability = thisProcess.HasCapability(ECapabilityDRM, KSuppressPlatSecDiagnostic);

   751 	thisProcess.Close();

   752 	}

   753 

   754 void CMMFFindAndOpenController::RunL()

   755 	{

   756 	Process();

   757 	}

   758 

   759 void CMMFFindAndOpenController::DoCancel()

   760 	{

   761 	iAddDataSourceSinkAsync->Cancel();

   762 	}

   763 

   764 /**

   765  * Defines the media ID & priority to be used when opening a controller

   766  * Normally called once only after class has been constructed

   767  *

   768  * @param	aMediaId

   769  *			the media ID to use when searching for a controller

   770  *			e.g. KUidMediaTypeAudio 

   771  * @param	aPrioritySettings

   772  *			the priority settings to use when opening a controller

   773  * @param	aMediaIdMatchType

   774  *			Defines the type of media id match to be performed on the plugins 

   775  *			returned from the ECOM registry.

   776  * @leave	can leave with KErrNoMemory

   777 

   778  * @internalComponent

   779  */

   780 EXPORT_C void CMMFFindAndOpenController::Configure(

   781 	TUid aMediaId, 

   782 	TMMFPrioritySettings aPrioritySettings,

   783 	CMMFPluginSelectionParameters::TMediaIdMatchType aMediaIdMatchType)

   784 	{

   785 	iPrioritySettings = aPrioritySettings;

   786 

   787 	iMediaIdMatchType = aMediaIdMatchType;

   788 

   789 	iMediaId = aMediaId;

   790 	}

   791 

   792 void CMMFFindAndOpenController::ConfigureController(

   793 	CConfig& config,

   794 	RMMFController& aController, 

   795 	CMMFControllerEventMonitor& aEventMonitor,

   796 	TControllerMode aControllerMode)

   797 	{

   798 	config.iController = &aController;

   799 	config.iEventMonitor = &aEventMonitor;

   800 	config.iControllerMode = aControllerMode;

   801 	}

   802 

   803 /**

   804  * Configures the primary controller

   805  *

   806  * @param	aController

   807  *			a reference to the client controller object to use

   808  * @param	aEventMonitor

   809  *			a reference to an event monitor object for receiving 

   810  *			events from the controller

   811  * @param	aControllerMode

   812  *			indicates whether this controller is to be used for recording

   813  *          or playback

   814  *

   815  * @internalComponent

   816  */

   817 EXPORT_C void CMMFFindAndOpenController::ConfigureController(

   818 	RMMFController& aController, 

   819 	CMMFControllerEventMonitor& aEventMonitor,

   820 	TControllerMode aControllerMode)

   821 	{

   822 	ConfigureController(

   823 		*iPrimaryConfig,

   824 		aController, 

   825 		aEventMonitor,

   826 		aControllerMode);

   827 	}

   828 

   829 /**

   830  * Configures the secondary controller

   831  *

   832  * This is only needed for the audio recorder utility which opens

   833  * one controller for playback and another for recording

   834  *

   835  * @param	aController

   836  *			a reference to the client controller object to use

   837  * @param	aEventMonitor

   838  *			a reference to an event monitor object for receiving 

   839  *			events from the controller

   840  * @param	aControllerMode

   841  *			indicates whether this controller is to be used for recording

   842  *          or playback or converting

   843  *

   844  * @internalComponent

   845  */

   846 EXPORT_C void CMMFFindAndOpenController::ConfigureSecondaryController(

   847 	RMMFController& aController, 

   848 	CMMFControllerEventMonitor& aEventMonitor,

   849 	TControllerMode aControllerMode)

   850 	{

   851 	ConfigureController(

   852 		*iSecondaryConfig,

   853 		aController, 

   854 		aEventMonitor,

   855 		aControllerMode);

   856 	}

   857 

   858 /**

   859  * Makes any controllers that are opened subsequently share a single heap.

   860  * 

   861  * The default behaviour is that each controller is created with its own heap.

   862  * Each heap uses a chunk, so using this function avoids situations where the number

   863  * of chunks per process is limited.

   864  * The default behaviour is generally to be preferred, and should give lower overall

   865  * memory usage. However, if many controllers are to be created for a particular thread,

   866  * then this function should be used to prevent running out of heaps or chunks.

   867  *

   868  * @internalComponent

   869  */

   870 EXPORT_C void CMMFFindAndOpenController::UseSharedHeap()

   871 	{

   872 	iUseSharedHeap = ETrue;

   873 	}

   874 

   875 void CMMFFindAndOpenController::Init()

   876 	{

   877 	// This should be called prior to opening, so reset the error

   878 	iError = KErrNone;

   879 	iSourceSinkConfigured = EFalse;

   880 	iControllerCount = 0;

   881 	}

   882 

   883 void CMMFFindAndOpenController::ConfigureSourceSink(

   884 	CConfig& config,

   885 	TSourceSink aSource, 

   886 	TSourceSink aSink)

   887 	{

   888 	TInt err;

   889 	TRAP(err, config.iSource = CreateSourceSinkL(aSource));

   890 	if (err != KErrNone)

   891 		{

   892 		iError = err;

   893 		return;

   894 		}

   895 		

   896 	TRAP(err, config.iSink = CreateSourceSinkL(aSink));

   897 	if (err != KErrNone)

   898 		{

   899 		iError = err;

   900 		return;

   901 		}

   902 	}

   903 	

   904 

   905 void CMMFFindAndOpenController::ConfigureSourceSink(

   906 	CConfig& config,

   907 	const TMMSource& aSource, 

   908 	TSourceSink aSink)

   909 	{

   910 	TInt err;

   911 	TRAP(err, config.iSource = CreateSourceSinkL(aSource));

   912 	if (err != KErrNone)

   913 		{

   914 		iError = err;

   915 		return;

   916 		}

   917 		

   918 	TRAP(err, config.iSink = CreateSourceSinkL(aSink));

   919 	if (err != KErrNone)

   920 		{

   921 		iError = err;

   922 		return;

   923 		}

   924 	}

   925 

   926 

   927 	

   928 /**

   929  * Configure the primary controller's source and sink

   930  * The descriptors passed to this function are copied so they do not need to be persistent.

   931  * To simplify the API, any errors that occur are reported back asynchronously following

   932  * a subsequent call to OpenByXXX()

   933  *

   934  * @param	aSourceUid

   935  *			the UID of the data source

   936  * @param	aSourceData

   937  *			a reference to a descriptor used to configure the source

   938  * @param	aSinkUid

   939  *			the UID of the data sink

   940  * @param	aSinkData

   941  *			a reference to a descriptor used to configure the sink

   942  *

   943  * @internalComponent

   944  */

   945 EXPORT_C void CMMFFindAndOpenController::ConfigureSourceSink(

   946 	TSourceSink aSource,

   947 	TSourceSink aSink)

   948 	{

   949 

   950 	CConfig* config = NULL;

   951 	

   952 	Init();

   953 	config = iPrimaryConfig;

   954 

   955 

   956 	// must have already called ConfigureController()

   957 	__ASSERT_ALWAYS(config->iController != NULL, CUPanic(EMMFMediaClientUtilityBadState));

   958 

   959 	ConfigureSourceSink(

   960 		*config,

   961 		aSource, 

   962 		aSink);

   963 	iCurrentConfig = config;

   964 

   965 	iSourceSinkConfigured = ETrue;

   966 	}

   967 	

   968 	

   969 /**

   970  * Configure the primary controller's source and sink

   971  * The descriptors passed to this function are copied so they do not need to be persistent.

   972  * To simplify the API, any errors that occur are reported back asynchronously following

   973  * a subsequent call to OpenByXXX()

   974  *

   975  * @param	aSourceUid

   976  *			the UID of the data source

   977  * @param	aSourceData

   978  *			a reference to a descriptor used to configure the source

   979  * @param	aSinkUid

   980  *			the UID of the data sink

   981  * @param	aSinkData

   982  *			a reference to a descriptor used to configure the sink

   983  *

   984  * @internalComponent

   985  */

   986 EXPORT_C void CMMFFindAndOpenController::ConfigureSecondarySourceSink(

   987 	TSourceSink aSource,

   988 	TSourceSink aSink)

   989 	{

   990 	if (iError != KErrNone)

   991 		{

   992 		// if there was an error configuring the primary source/sink, do not try the secondary one

   993 		// Don't return the error, since the stored error will be returned by the OpenBy... method

   994 		return;

   995 		}

   996 

   997 	CConfig* config = NULL;

   998 	

   999 	config = iSecondaryConfig;

  1000 

  1001 	// must have already configured the primary controller

  1002 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1003 	config = iSecondaryConfig;

  1004 			

  1005 	// must have already called ConfigureController()

  1006 	__ASSERT_ALWAYS(config->iController != NULL, CUPanic(EMMFMediaClientUtilityBadState));

  1007 

  1008 	ConfigureSourceSink(

  1009 		*config,

  1010 		aSource, 

  1011 		aSink);

  1012 	iCurrentConfig = config;

  1013 

  1014 	iSourceSinkConfigured = ETrue;

  1015 	}

  1016 	

  1017 

  1018 	

  1019 EXPORT_C void CMMFFindAndOpenController::ConfigureSourceSink(

  1020 	const TMMSource& aSource,

  1021 	TSourceSink aSink)

  1022 	{

  1023 	Init();

  1024 	CConfig* config = iPrimaryConfig;

  1025 			

  1026 	// must have already called ConfigureController()

  1027 	__ASSERT_ALWAYS(config->iController != NULL, CUPanic(EMMFMediaClientUtilityBadState));

  1028 

  1029 	ConfigureSourceSink(

  1030 		*config,

  1031 		aSource, 

  1032 		aSink);

  1033 	iCurrentConfig = config;

  1034 

  1035 	iSourceSinkConfigured = ETrue;

  1036 	}

  1037 

  1038 	

  1039 	

  1040 /**

  1041  * Opens a controller using the supplied controller UID

  1042  * and adds the source & sink

  1043  * Completion is indicated asynchonously by a call to MfaocComplete()

  1044  * 

  1045  * @param	aControllerUid

  1046  *			the UID of the primary controller

  1047  * @param	aControllerUid

  1048  *			the UID of the secondary controller

  1049  *

  1050  * @internalComponent

  1051  */

  1052 EXPORT_C void CMMFFindAndOpenController::OpenByControllerUid(

  1053 		TUid aControllerUid,

  1054 		TUid aSecondaryControllerUid)

  1055 	{

  1056 	// must have already called ConfigureSourceSink()

  1057 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1058 

  1059 	// Have there been any errors so far ?

  1060 	if (iError != KErrNone)

  1061 		{

  1062 	    SchedSendError();

  1063 		return;

  1064 		}

  1065 

  1066 	if (iCurrentConfig == iPrimaryConfig)

  1067 		{

  1068 		// only do this for the playback controller

  1069 		TRAP(iError, iCurrentConfig->iSource->EvaluateIntentL())

  1070 		

  1071 		if (iError != KErrNone && 

  1072 			!(iCurrentConfig->iControllerMode == EPlayback && iError == KErrPermissionDenied && !iHasDrmCapability))

  1073 			{

  1074 			// KErrPermissionDenied error and no DRM capability are not problems in Playback mode

  1075 			// proper action will be performed when controller is loaded

  1076 	    	SchedSendError();

  1077 			return;

  1078 			}

  1079 		}

  1080 

  1081 	iPrimaryConfig->iControllerUid = aControllerUid;

  1082 	if (iCurrentConfig == iSecondaryConfig)

  1083 		{

  1084 		if (aSecondaryControllerUid == KNullUid)

  1085 			iSecondaryConfig->iControllerUid = aControllerUid;

  1086 		else

  1087 			iSecondaryConfig->iControllerUid = aSecondaryControllerUid;

  1088 		}

  1089 		

  1090 	iMode = EOpenByControllerUid;

  1091 	iControllerImplInfo = NULL;

  1092 	iState = EOpenController;

  1093 	KickState();

  1094 	}

  1095 

  1096 /**

  1097  * Opens a controller using the supplied file name

  1098  * and adds the source & sink

  1099  * A copy is made of the filename or file handle so that it need not be persistent

  1100  * Completion is indicated asynchonously by a call to MfaocComplete()

  1101  * 

  1102  * @param	aSource

  1103  *			a reference to a TFileSource object to be used when searching

  1104  *          for a controller

  1105  * @param	aFileNameSecondary

  1106  *			a reference to the seconday filename to be used when searching

  1107  *          for a controller. This need only be supplied when converting 

  1108  *			between two files.

  1109  *

  1110  * @internalComponent

  1111  */

  1112 EXPORT_C void CMMFFindAndOpenController::OpenByFileSource(const TMMSource& aSource, const TDesC& aFileNameSecondary)

  1113 	{

  1114 	// must have already called ConfigureSourceSink()

  1115 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1116 

  1117 	TInt err;

  1118 	// Have there been any errors so far ?

  1119 	if (iError != KErrNone)

  1120 		{

  1121 		SchedSendError();

  1122 		return;

  1123 		}

  1124 		

  1125 	if (iOwnFileHandle)

  1126 		{

  1127 		// in case of error

  1128 		iFileHandle.Close();

  1129 		iOwnFileHandle = EFalse;

  1130 		}

  1131 		

  1132 	iEnableUi = aSource.IsUIEnabled();

  1133 	if (aSource.SourceType()==KUidMMFileSource)

  1134 		{