1 /*

     2 * Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Audio, MIDI and Video client utility functions.

    15 *

    16 */

    17  

    18 

    19 #include <e32std.h>

    20 #include <f32file.h>

    21 #include <bautils.h>

    22 #include <caf/caf.h>

    23 #include <caf/content.h>

    24 #include <caf/data.h>

    25 using namespace ContentAccess;

    26 

    27 #include "S60AudioUtility.h"

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

    29 

    30 const TInt KMaxMimeLength = 256;

    31 const TInt KMaxHeaderSize = 256;

    32 

    33 void CUPanic(TInt aCUPanicCode)

    34 	{

    35 	_LIT(KMMFMediaClientUtilityPaanicCategory, "S60AudioUtility");

    36 	User::Panic(KMMFMediaClientUtilityPaanicCategory, aCUPanicCode);

    37 	}

    38 

    39 /**

    40  * @internalComponent

    41  */

    42 EXPORT_C TUid CMMFClientUtility::ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid)

    43 	{

    44 	TUid ECOMUid = KNullUid;

    45 	if (aMdaFormatUid == KUidMdaClipFormatWav)

    46 		ECOMUid = TUid::Uid(KMmfUidFormatWAVWrite);

    47 	else if (aMdaFormatUid == KUidMdaClipFormatAu)

    48 		ECOMUid = TUid::Uid(KMmfUidFormatAUWrite);

    49 	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)

    50 		ECOMUid = TUid::Uid(KMmfUidFormatRAWWrite);

    51 	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)

    52 		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRWrite);

    53 

    54 	return ECOMUid;

    55 	}

    56 

    57 /**

    58  * @internalComponent

    59  */

    60 EXPORT_C TUid CMMFClientUtility::ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid)

    61 	{

    62 	TUid ECOMUid = KNullUid;

    63 	if (aMdaFormatUid == KUidMdaClipFormatWav)

    64 		ECOMUid = TUid::Uid(KMmfUidFormatWAVRead);

    65 	else if (aMdaFormatUid == KUidMdaClipFormatAu)

    66 		ECOMUid = TUid::Uid(KMmfUidFormatAURead);

    67 	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)

    68 		ECOMUid = TUid::Uid(KMmfUidFormatRAWRead);

    69 	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)

    70 		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRRead);

    71 

    72 	return ECOMUid;

    73 	}

    74 

    75 /**

    76  * @internalComponent

    77  */

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

    79 	{

    80 	RFs fsSession;

    81 	RFile file;

    82 	TInt error = KErrNone;

    83 

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

    85 		{

    86 		if ((error = file.Open(fsSession, aFileName, EFileShareReadersOnly)) == KErrNone)

    87 			{

    88 			TInt size = 0;

    89 

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

    91 				{

    92 				if (size > 0)

    93 					{

    94 					if (size > aMaxLength)

    95 						size = aMaxLength;

    96 

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

    98 					}

    99 				}

   100 			file.Close();

   101 			}

   102 		fsSession.Close();

   103 		}

   104 

   105 	return error;

   106 	}

   107 

   108 /**

   109  * @internalComponent

   110  */

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

   112 	{

   113 	TFourCC dataType = KMMFFourCCCodeNULL;

   114 	switch (aCodec.Uid().iUid)

   115 		{

   116 		case KUidMdaWavPcmCodecDefine:

   117 			{

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

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

   120 				dataType = KMMFFourCCCodePCMU8; //8 bit PCM

   121 			else

   122 				dataType = KMMFFourCCCodePCM16; //16 bit PCM

   123 			break;

   124 			}

   125 		case KUidMdaAu8PcmCodecDefine:

   126 			dataType = KMMFFourCCCodePCM8;

   127 			break;

   128 		case KUidMdaAuCodecDefine:

   129 		case KUidMdaAu16PcmCodecDefine:

   130 			dataType = KMMFFourCCCodePCM16B;

   131 			break;

   132 

   133 		case KUidMdaAuMulawCodecDefine:

   134 		case KUidMdaWavMulawCodecDefine:

   135 		case KUidMdaRawAudioMulawCodecDefine:  //uLAW

   136 			dataType = KMMFFourCCCodeMuLAW;

   137 			break;

   138 		case KUidMdaAuAlawCodecDefine:

   139 		case KUidMdaWavAlawCodecDefine:

   140 		case KUidMdaRawAudioAlawCodecDefine:	 //ALAW

   141 			dataType = KMMFFourCCCodeALAW;

   142 			break;

   143 		case KUidMdaRawAudioS8PcmCodecDefine:	 //  P8

   144 			dataType = KMMFFourCCCodePCM8;

   145 			break;

   146 		case KUidMdaRawAudioU8PcmCodecDefine:	  // PU8

   147 			dataType = KMMFFourCCCodePCMU8;

   148 			break;

   149 		case KUidMdaRawAudioSL16PcmCodecDefine: // P16

   150 			dataType = KMMFFourCCCodePCM16;

   151 			break;

   152 		case KUidMdaRawAudioSB16PcmCodecDefine: //P16B

   153 			dataType = KMMFFourCCCodePCM16B;

   154 			break;

   155 		case KUidMdaRawAudioUL16PcmCodecDefine: //PU16

   156 			dataType = KMMFFourCCCodePCMU16;

   157 			break;

   158 		case KUidMdaRawAudioUB16PcmCodecDefine: //PU6B

   159 			dataType = KMMFFourCCCodePCMU16B;

   160 			break;

   161 		case KUidMdaGsmWavCodecDefine: //GSM6

   162 			dataType = KMMFFourCCCodeGSM610;

   163 			break;

   164 		case KUidMdaWavImaAdpcmCodecDefine:

   165 			dataType = KMMFFourCCCodeIMAD;

   166 			break;

   167 		case KUidMdaRawAmrCodecDefine:

   168 			dataType = KMMFFourCCCodeAMR;

   169 			break;

   170 		default:	// Not a Uid we recognise

   171 			dataType = KMMFFourCCCodeNULL;

   172 			break;

   173 		}

   174 	return dataType;

   175 	}

   176 

   177 

   178 CMMFUtilityFileInfo* CMMFUtilityFileInfo::NewL(TMMSource& aSource)

   179 	{

   180 	CMMFUtilityFileInfo* self = CMMFUtilityFileInfo::NewLC(aSource);

   181 	CleanupStack::Pop(self);

   182 	return self;

   183 	}

   184 

   185 

   186 CMMFUtilityFileInfo* CMMFUtilityFileInfo::NewLC(TMMSource& aSource)

   187 	{

   188 	CMMFUtilityFileInfo* self = new (ELeave) CMMFUtilityFileInfo;

   189 	CleanupStack::PushL(self);

   190 	self->ConstructL(aSource);

   191 	return self;

   192 	}

   193 

   194 

   195 

   196 void CMMFUtilityFileInfo::ConstructL(const TMMSource& aSource)

   197 	{

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

   199 		{

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

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

   202 							EContentShareReadOnly);

   203 		}

   204 

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

   206 		{

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

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

   209 		}

   210 

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

   212 

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

   214 		{

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

   216 		User::Leave(err);

   217 		}

   218 

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

   220 	User::LeaveIfError(err);

   221 	}

   222 

   223 TInt CMMFUtilityFileInfo::EvaluateIntent(TIntent aIntent)

   224 	{

   225 	return iData->EvaluateIntent(aIntent);

   226 	}

   227 /**

   228  * @internalComponent

   229  */

   230 TBool CMMFUtilityFileInfo::GetFileMimeTypeL(TDes8& aMimeType)

   231 	{

   232 	return iData->GetMimeTypeL(aMimeType);

   233 	}

   234 

   235 /**

   236  * @internalComponent

   237  */

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

   239 	{

   240 	TInt size = 0;

   241 	iData->DataSizeL(size);

   242 	if (size > 0)

   243 		{

   244 		if (size > aMaxLength)

   245 			size = aMaxLength;

   246 		TInt pos = 0;

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

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

   249 		}

   250 	}

   251 

   252 /**

   253  * @internalComponent

   254  */

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

   256 	{

   257 	TParse fileName;

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

   259 	HBufC8* fileSuffix = NULL;

   260 	if(fileName.ExtPresent())

   261 		{

   262 		TPtrC fileSuffixPtr(fileName.Ext());

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

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

   265 		}

   266 	else

   267 		{

   268 		fileSuffix = KNullDesC8().AllocL();

   269 		}

   270 	return fileSuffix;

   271 	}

   272 

   273 

   274 /**

   275  * @internalComponent

   276  */

   277 CMMFUtilityFileInfo::~CMMFUtilityFileInfo()

   278 	{

   279 	delete iData;

   280 	}

   281 

   282 /*

   283  * @internalComponent

   284  *

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

   286  * the header data and file extension supplied.

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

   288  * 2 brownie points awarded for data match alone.

   289  * 1 brownie point awarded for suffix match alone.

   290  */

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

   292 	{

   293 	TInt browniePoints = 0;

   294 

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

   296 		{

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

   298 			{

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

   300 				format->SupportsFileExtension(aFileExtension))

   301 				{

   302 				browniePoints = 3;

   303 				}

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

   305 				{

   306 				browniePoints = 2;

   307 				}

   308 			else

   309 				{

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

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

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

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

   314 

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

   316 					{

   317 					// No header data indicated.

   318 					if (format->SupportsFileExtension(aFileExtension))

   319 						{

   320 							browniePoints = 1;

   321 						}

   322 					}

   323 				else

   324 					{

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

   326 						{

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

   328 							format->SupportsFileExtension(aFileExtension))

   329 							{

   330 							browniePoints = 1;

   331 							}

   332 						}

   333 					}

   334 				}

   335 			}

   336 		else

   337 			{

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

   339 			if (format->SupportsHeaderDataL(aHeaderData))

   340 				{

   341 				browniePoints = 2;

   342 				}

   343 			}

   344 		}

   345 	else // Empty File

   346 		{

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

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

   349 			{

   350 			browniePoints = 1;

   351 			}

   352 		}

   353 

   354 	return browniePoints;

   355 }

   356 

   357 /**

   358  * @internalComponent

   359  *

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

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

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

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

   364  *

   365  * @param	"aControllers"

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

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

   368  * @param	"aHeaderDataPlayback"

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

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

   371  * @param	"aFileExtensionPlayback"

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

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

   374  * @param	"aHeaderDataRecord"

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

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

   377  * @param	"aFileExtensionRecord"

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

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

   380  * @param	"aPrioritisedControllers"

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

   382  *			prioritised controllers will be returned.

   383  * @since	7.0s

   384  * @lib	"MediaClientUtility.lib"

   385  */

   386 void CMMFClientUtility::PrioritiseControllersL(

   387 	const RMMFControllerImplInfoArray& aControllers,

   388 	const TDesC8& aHeaderDataPlayback,

   389 	const TDesC8& aFileExtensionPlayback,

   390 	const TDesC8& aHeaderDataRecord,

   391 	const TDesC8& aFileExtensionRecord,

   392 	RMMFControllerImplInfoArray& prioritisedControllers)

   393 	{

   394 	RMMFControllerImplInfoArray fullMatchControllers; // data AND suffix

   395 	CleanupClosePushL(fullMatchControllers);

   396 	RMMFControllerImplInfoArray partMatchControllers; // data OR suffix

   397 	CleanupClosePushL(partMatchControllers);

   398 

   399 	TBool checkingPlaybackFormats = EFalse;

   400 	TBool checkingRecordFormats = EFalse;

   401 

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

   403 		checkingPlaybackFormats = ETrue;

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

   405 		checkingRecordFormats = ETrue;

   406 

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

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

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

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

   411 		{

   412 		const CMMFControllerImplementationInformation* controller = aControllers[i];

   413 		TInt savedBrowniePointsPlayback = 0;

   414 		TInt savedBrowniePointsRecord = 0;

   415 

   416 		if (checkingPlaybackFormats)

   417 			{

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

   419 				{

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

   421 

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

   423 

   424 				if (browniePoints >= savedBrowniePointsPlayback)

   425 					savedBrowniePointsPlayback = browniePoints;

   426 				}

   427 			}

   428 

   429 		if (checkingRecordFormats)

   430 			{

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

   432 				{

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

   434 

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

   436 

   437 				if (browniePoints >= savedBrowniePointsRecord)

   438 					savedBrowniePointsRecord = browniePoints;

   439 				}

   440 			}

   441 

   442 		TInt savedBrowniePoints = 0;

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

   444 		// make sure we've found both

   445 		if (checkingPlaybackFormats && checkingRecordFormats)

   446 			{

   447 			savedBrowniePoints = Min(savedBrowniePointsPlayback, savedBrowniePointsRecord);

   448 			}

   449 		else if (checkingPlaybackFormats)

   450 			{

   451 			savedBrowniePoints = savedBrowniePointsPlayback;

   452 			}

   453 		else if (checkingRecordFormats)

   454 			{

   455 			savedBrowniePoints = savedBrowniePointsRecord;

   456 			}

   457 

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

   459 		switch (savedBrowniePoints)

   460 			{

   461 			case 3:

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

   463 				break;

   464 			case 2:

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

   466 				break;

   467 			case 1:

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

   469 				break;

   470 			default:

   471 				break;

   472 			}

   473 		}

   474 

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

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

   477 		{

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

   479 			{

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

   481 			}

   482 		}

   483 

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

   485 		{

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

   487 			{

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

   489 			}

   490 		}

   491 

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

   493 	}

   494 

   495 /**

   496  * @internalComponent

   497  */

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

   499 	{

   500 	return new(ELeave) CMMFMdaObjectStateChangeObserverCallback(aCallback);

   501 	}

   502 

   503 /**

   504  * @internalComponent

   505  */

   506 CMMFMdaObjectStateChangeObserverCallback::~CMMFMdaObjectStateChangeObserverCallback()

   507 	{

   508 	Cancel();

   509 	}

   510 

   511 /**

   512  * @internalComponent

   513  */

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

   515 	{

   516 	iObject = aObject;

   517 	iPreviousState = aPreviousState;

   518 	iCurrentState = aCurrentState;

   519 	iErrorCode = aErrorCode;

   520 	if (!IsActive())

   521 		{

   522 		TRequestStatus* s = &iStatus;

   523 		SetActive();

   524 		User::RequestComplete(s, KErrNone);

   525 		}

   526 	}

   527 

   528 CMMFMdaObjectStateChangeObserverCallback::CMMFMdaObjectStateChangeObserverCallback(MMdaObjectStateChangeObserver& aCallback) :

   529 	CActive(CActive::EPriorityHigh),

   530 	iCallback(aCallback)

   531 	{

   532 	CActiveScheduler::Add(this);

   533 	}

   534 

   535 void CMMFMdaObjectStateChangeObserverCallback::RunL()

   536 	{

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

   538 	}

   539 

   540 void CMMFMdaObjectStateChangeObserverCallback::DoCancel()

   541 	{

   542 	//nothing to cancel

   543 	}

   544 

   545 

   546 //****************************************

   547 // CMMFFindAndOpenController

   548 //****************************************

   549 

   550 /**

   551  * Factory function to create a CMMFFindAndOpenController class

   552  *

   553  * @internalComponent

   554  */

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

   556 	{

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

   558 	CleanupStack::PushL(self);

   559 	self->ConstructL();

   560 	CleanupStack::Pop(self);

   561 	return self;

   562 	}

   563 

   564 CMMFFindAndOpenController::~CMMFFindAndOpenController()

   565 	{

   566 	Cancel();

   567 

   568 	// delete temporary variables

   569 	Close();

   570 

   571 	// this should cancel the AO

   572 	delete iAddDataSourceSinkAsync;

   573 

   574 	delete iPrimaryConfig;

   575 	delete iSecondaryConfig;

   576 	REComSession::FinalClose();

   577 	}

   578 

   579 /**

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

   581  * Useful to allow a alloc testing to work.

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

   583  *

   584  * @internalComponent

   585  */

   586 EXPORT_C void CMMFFindAndOpenController::Close()

   587 	{

   588 

   589 	Cancel();

   590 

   591 	if(iAddDataSourceSinkAsync)

   592 		{

   593 		iAddDataSourceSinkAsync->Cancel();

   594 		}

   595 	if (iPrimaryConfig)

   596 		iPrimaryConfig->Close();

   597 	if (iSecondaryConfig)

   598 		iSecondaryConfig->Close();

   599 

   600 	iPrioritisedControllers.Close();

   601 	iControllers.ResetAndDestroy();

   602 	iControllers.Close();

   603 

   604 	iFileName.SetLength(0);

   605 	iFileNameSecondary.SetLength(0);

   606 

   607 	delete iUrl;

   608 	iUrl = NULL;

   609 

   610 	delete iMimeType;

   611 	iMimeType = NULL;

   612 

   613 	delete iUniqueId;

   614 	iUniqueId = NULL;

   615 

   616 	iFileHandle.Close();

   617 	iUseFileHandle = EFalse;

   618 	}

   619 

   620 CMMFFindAndOpenController::CMMFFindAndOpenController(MMMFFindAndOpenControllerObserver& aObserver) :

   621 	CActive(EPriorityStandard),

   622 	iObserver(aObserver),

   623 	iDescriptor(NULL, 0)

   624 	{

   625 	CActiveScheduler::Add(this);

   626 	}

   627 

   628 void CMMFFindAndOpenController::ConstructL()

   629 	{

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

   631 	iPrimaryConfig = new (ELeave)  CConfig();

   632 	iSecondaryConfig =  new (ELeave) CConfig;

   633 	iCurrentConfig =  iPrimaryConfig;

   634 	}

   635 

   636 void CMMFFindAndOpenController::RunL()

   637 	{

   638 	Process();

   639 	}

   640 

   641 void CMMFFindAndOpenController::DoCancel()

   642 	{

   643 	iAddDataSourceSinkAsync->Cancel();

   644 	}

   645 

   646 /**

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

   648  * Normally called once only after class has been constructed

   649  *

   650  * @param	aMediaId

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

   652  *			e.g. KUidMediaTypeAudio

   653  * @param	aPrioritySettings

   654  *			the priority settings to use when opening a controller

   655  * @param	aMediaIdMatchType

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

   657  *			returned from the ECOM registry.

   658  * @leave	can leave with KErrNoMemory

   659 

   660  * @internalComponent

   661  */

   662 EXPORT_C void CMMFFindAndOpenController::Configure(

   663 	TUid aMediaId,

   664 	TMMFPrioritySettings aPrioritySettings,

   665 	CMMFPluginSelectionParameters::TMediaIdMatchType aMediaIdMatchType)

   666 	{

   667 	iPrioritySettings = aPrioritySettings;

   668 

   669 	iMediaIdMatchType = aMediaIdMatchType;

   670 

   671 	iMediaId = aMediaId;

   672 	}

   673 

   674 void CMMFFindAndOpenController::ConfigureController(

   675 	CConfig& config,

   676 	RMMFController& aController,

   677 	CMMFControllerEventMonitor& aEventMonitor,

   678 	TControllerMode aControllerMode)

   679 	{

   680 	config.iController = &aController;

   681 	config.iEventMonitor = &aEventMonitor;

   682 	config.iControllerMode = aControllerMode;

   683 	}

   684 

   685 /**

   686  * Configures the primary controller

   687  *

   688  * @param	aController

   689  *			a reference to the client controller object to use

   690  * @param	aEventMonitor

   691  *			a reference to an event monitor object for receiving

   692  *			events from the controller

   693  * @param	aControllerMode

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

   695  *          or playback

   696  *

   697  * @internalComponent

   698  */

   699 EXPORT_C void CMMFFindAndOpenController::ConfigureController(

   700 	RMMFController& aController,

   701 	CMMFControllerEventMonitor& aEventMonitor,

   702 	TControllerMode aControllerMode)

   703 	{

   704 	ConfigureController(

   705 		*iPrimaryConfig,

   706 		aController,

   707 		aEventMonitor,

   708 		aControllerMode);

   709 	}

   710 

   711 /**

   712  * Configures the secondary controller

   713  *

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

   715  * one controller for playback and another for recording

   716  *

   717  * @param	aController

   718  *			a reference to the client controller object to use

   719  * @param	aEventMonitor

   720  *			a reference to an event monitor object for receiving

   721  *			events from the controller

   722  * @param	aControllerMode

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

   724  *          or playback or converting

   725  *

   726  * @internalComponent

   727  */

   728 EXPORT_C void CMMFFindAndOpenController::ConfigureSecondaryController(

   729 	RMMFController& aController,

   730 	CMMFControllerEventMonitor& aEventMonitor,

   731 	TControllerMode aControllerMode)

   732 	{

   733 	ConfigureController(

   734 		*iSecondaryConfig,

   735 		aController,

   736 		aEventMonitor,

   737 		aControllerMode);

   738 	}

   739 

   740 void CMMFFindAndOpenController::Init()

   741 	{

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

   743 	iError = KErrNone;

   744 	iSourceSinkConfigured = EFalse;

   745 	iControllerCount = 0;

   746 	}

   747 

   748 void CMMFFindAndOpenController::ConfigureSourceSink(

   749 	CConfig& config,

   750 	TSourceSink aSource,

   751 	TSourceSink aSink)

   752 	{

   753 	TInt err;

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

   755 	if (err != KErrNone)

   756 		{

   757 		iError = err;

   758 		return;

   759 		}

   760 

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

   762 	if (err != KErrNone)

   763 		{

   764 		iError = err;

   765 		return;

   766 		}

   767 	}

   768 

   769 

   770 void CMMFFindAndOpenController::ConfigureSourceSink(

   771 	CConfig& config,

   772 	const TMMSource& aSource,

   773 	TSourceSink aSink)

   774 	{

   775 	TInt err;

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

   777 	if (err != KErrNone)

   778 		{

   779 		iError = err;

   780 		return;

   781 		}

   782 

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

   784 	if (err != KErrNone)

   785 		{

   786 		iError = err;

   787 		return;

   788 		}

   789 	}

   790 

   791 

   792 

   793 /**

   794  * Configure the primary controller's source and sink

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

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

   797  * a subsequent call to OpenByXXX()

   798  *

   799  * @param	aSourceUid

   800  *			the UID of the data source

   801  * @param	aSourceData

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

   803  * @param	aSinkUid

   804  *			the UID of the data sink

   805  * @param	aSinkData

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

   807  *

   808  * @internalComponent

   809  */

   810 EXPORT_C void CMMFFindAndOpenController::ConfigureSourceSink(

   811 	TSourceSink aSource,

   812 	TSourceSink aSink)

   813 	{

   814 

   815 	CConfig* config = NULL;

   816 

   817 	Init();

   818 	config = iPrimaryConfig;

   819 

   820 

   821 	// must have already called ConfigureController()

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

   823 

   824 	ConfigureSourceSink(

   825 		*config,

   826 		aSource,

   827 		aSink);

   828 	iCurrentConfig = config;

   829 

   830 	iSourceSinkConfigured = ETrue;

   831 	}

   832 

   833 

   834 /**

   835  * Configure the primary controller's source and sink

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

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

   838  * a subsequent call to OpenByXXX()

   839  *

   840  * @param	aSourceUid

   841  *			the UID of the data source

   842  * @param	aSourceData

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

   844  * @param	aSinkUid

   845  *			the UID of the data sink

   846  * @param	aSinkData

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

   848  *

   849  * @internalComponent

   850  */

   851 EXPORT_C void CMMFFindAndOpenController::ConfigureSecondarySourceSink(

   852 	TSourceSink aSource,

   853 	TSourceSink aSink)

   854 	{

   855 	if (iError != KErrNone)

   856 		{

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

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

   859 		return;

   860 		}

   861 

   862 	CConfig* config = NULL;

   863 

   864 	config = iSecondaryConfig;

   865 

   866 	// must have already configured the primary controller

   867 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

   868 	config = iSecondaryConfig;

   869 

   870 	// must have already called ConfigureController()

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

   872 

   873 	ConfigureSourceSink(

   874 		*config,

   875 		aSource,

   876 		aSink);

   877 	iCurrentConfig = config;

   878 

   879 	iSourceSinkConfigured = ETrue;

   880 	}

   881 

   882 

   883 

   884 #ifdef SYMBIAN_CAF_V2

   885 EXPORT_C void CMMFFindAndOpenController::ConfigureSourceSink(

   886 	const TMMSource& aSource,

   887 	TSourceSink aSink)

   888 	{

   889 	Init();

   890 	CConfig* config = iPrimaryConfig;

   891 

   892 	// must have already called ConfigureController()

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

   894 

   895 	ConfigureSourceSink(

   896 		*config,

   897 		aSource,

   898 		aSink);

   899 	iCurrentConfig = config;

   900 

   901 	iSourceSinkConfigured = ETrue;

   902 	}

   903 #endif

   904 

   905 

   906 

   907 /**

   908  * Opens a controller using the supplied controller UID

   909  * and adds the source & sink

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

   911  *

   912  * @param	aControllerUid

   913  *			the UID of the primary controller

   914  * @param	aControllerUid

   915  *			the UID of the secondary controller

   916  *

   917  * @internalComponent

   918  */

   919 EXPORT_C void CMMFFindAndOpenController::OpenByControllerUid(

   920 		TUid aControllerUid,

   921 		TUid aSecondaryControllerUid)

   922 	{

   923 	// must have already called ConfigureSourceSink()

   924 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

   925 

   926 	// Have there been any errors so far ?

   927 	if (iError != KErrNone)

   928 		{

   929 	    SchedSendError();

   930 		return;

   931 		}

   932 

   933 	if (iCurrentConfig == iPrimaryConfig)

   934 		{

   935 		// only do this for the playback controller

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

   937 

   938 		if (iError != KErrNone)

   939 			{

   940 	    	SchedSendError();

   941 			return;

   942 			}

   943 		}

   944 

   945 	iPrimaryConfig->iControllerUid = aControllerUid;

   946 	if (iCurrentConfig == iSecondaryConfig)

   947 		{

   948 		if (aSecondaryControllerUid == KNullUid)

   949 			iSecondaryConfig->iControllerUid = aControllerUid;

   950 		else

   951 			iSecondaryConfig->iControllerUid = aSecondaryControllerUid;

   952 		}

   953 

   954 	iMode = EOpenByControllerUid;

   955 	iControllerImplInfo = NULL;

   956 	iState = EOpenController;

   957 	KickState();

   958 	}

   959 

   960 /**

   961  * Opens a controller using the supplied file name

   962  * and adds the source & sink

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

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

   965  *

   966  * @param	aSource

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

   968  *          for a controller

   969  * @param	aFileNameSecondary

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

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

   972  *			between two files.

   973  *

   974  * @internalComponent

   975  */

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

   977 	{

   978 	// must have already called ConfigureSourceSink()

   979 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

   980 

   981 	TInt err;

   982 	// Have there been any errors so far ?

   983 	if (iError != KErrNone)

   984 		{

   985 		SchedSendError();

   986 		return;

   987 		}

   988 

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

   990 		{

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

   992 		iFileName = fileSource.Name();

   993 		}

   994 

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

   996 		{

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

   998 		err = iFileHandle.Duplicate(fileHandleSource.Handle());

   999 		if (err != KErrNone)

  1000 			{

  1001 			SchedSendError(err);

  1002 			return;

  1003 			}

  1004 		iFileHandle.Name(iFileName); //ignore error return since we'll just do without the filename if not available

  1005 		iUseFileHandle = ETrue;

  1006 		}

  1007 

  1008 	TRAP(err, iUniqueId = aSource.UniqueId().AllocL());

  1009 	iIntent = aSource.Intent();

  1010 	if (err != KErrNone)

  1011 		{

  1012 		SchedSendError(err);

  1013 		return;

  1014 		}

  1015 

  1016 

  1017 	// take a copy of the secondary file name

  1018 	iFileNameSecondary = aFileNameSecondary;

  1019 

  1020 	iMode = EOpenByFileName;

  1021 	iState = EBuildControllerList;

  1022 	KickState();

  1023 	}

  1024 

  1025 /**

  1026  * Opens a controller using the supplied format UID

  1027  * and adds the source & sink

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

  1029  *

  1030  * @param	aFormatUid

  1031  *			the UID of a format that must be supported by the controller

  1032  * @param	aFormatUidSecondary

  1033  *			the UID of a secondary format that must be supported by the controller

  1034  *			This need only be supplied when converting between two differnet formats.

  1035  *

  1036  * @internalComponent

  1037  */

  1038 EXPORT_C void CMMFFindAndOpenController::OpenByFormatUid(TUid aFormatUid, TUid aFormatUidSecondary)

  1039 	{

  1040 	// must have already called ConfigureSourceSink()

  1041 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1042 

  1043 	// Have there been any errors so far ?

  1044 	if (iError != KErrNone)

  1045 		{

  1046 		SchedSendError();

  1047 		return;

  1048 		}

  1049 

  1050 	iFormatUid = aFormatUid;

  1051 	iFormatUidSecondary = aFormatUidSecondary;

  1052 

  1053 	iMode = EOpenByFormatUid;

  1054 	iState = EBuildControllerList;

  1055 	KickState();

  1056 	}

  1057 

  1058 /**

  1059  * Opens a controller using the supplied descriptor

  1060  * and adds the source & sink

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

  1062  *

  1063  * @param	aDescriptor

  1064  *			a reference to the descriptor to be used when searching

  1065  *          for a controller

  1066  *

  1067  * @internalComponent

  1068  */

  1069 EXPORT_C void  CMMFFindAndOpenController::OpenByDescriptor(const TDesC8& aDescriptor)

  1070 	{

  1071 	// must have already called ConfigureSourceSink()

  1072 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1073 

  1074 	// Have there been any errors so far ?

  1075 	if (iError != KErrNone)

  1076 		{

  1077 		SchedSendError();

  1078 		return;

  1079 		}

  1080 

  1081 	// take a copy of the descriptor

  1082 	TUint8* desBufferPtr = const_cast<TUint8*> (aDescriptor.Ptr());

  1083 	iDescriptor.Set( desBufferPtr,aDescriptor.Length(),aDescriptor.Length());

  1084 

  1085 	iMode = EOpenByDescriptor;

  1086 	iState = EBuildControllerList;

  1087 	KickState();

  1088 	}

  1089 

  1090 /**

  1091  * Opens a controller using the supplied URL

  1092  * and adds the source & sink

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

  1094  *

  1095  * @param	aUrl

  1096  *			a reference to the URL to be used when searching for a controller

  1097  * @param	aIapId

  1098  *          the IAP ID to be used when searching for a controller

  1099  * @param	aMimeType

  1100  *          the MIME type of the data to be used when searching for a controller

  1101  *

  1102  * @internalComponent

  1103  */

  1104 EXPORT_C void CMMFFindAndOpenController::OpenByUrl(const TDesC& aUrl, TInt aIapId, const TDesC8& aMimeType)

  1105 	{

  1106 	// must have already called ConfigureSourceSink()

  1107 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1108 

  1109 	// Have there been any errors so far ?

  1110 	if (iError != KErrNone)

  1111 		{

  1112 		SchedSendError();

  1113 		return;

  1114 		}

  1115 

  1116 	// take a copy of the Url

  1117 	delete iUrl;

  1118 	iUrl = NULL;

  1119 	iUrl = aUrl.Alloc();

  1120 	if (iUrl == NULL)

  1121 		{

  1122 		SchedSendError(KErrNoMemory);

  1123 		return;

  1124 		}

  1125 

  1126 	// take a copy of the IapId

  1127 	iIapId = aIapId;

  1128 

  1129 	// take a copy of the mime type

  1130 	delete iMimeType;

  1131 	iMimeType = NULL;

  1132 	iMimeType = aMimeType.Alloc();

  1133 	if (iMimeType == NULL)

  1134 		{

  1135 		SchedSendError(KErrNoMemory);