1 /*

     2 * Copyright (c) 2004 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:  Progressive Download Utility  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/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 #ifdef __WINDOWS_MEDIA

    32 _LIT8(KWMAMimeType,"audio/x-ms-wma");

    33 #endif

    34 

    35 void CUPanic(TInt aCUPanicCode)

    36 	{

    37 	_LIT(KMMFMediaClientUtilityPaanicCategory, "MMFClientUtility");

    38 	User::Panic(KMMFMediaClientUtilityPaanicCategory, aCUPanicCode);

    39 	}

    40 

    41 /**

    42  * @internalComponent

    43  */

    44  TUid CMMFClientUtility::ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid)

    45 	{

    46     #if _DEBUG

    47       RDebug::Print(_L("CMMFClientUtility::ConvertMdaFormatUidToECOMWrite\n"));

    48     #endif

    49 	TUid ECOMUid = KNullUid;

    50 	if (aMdaFormatUid == KUidMdaClipFormatWav)

    51 		ECOMUid = TUid::Uid(KMmfUidFormatWAVWrite);

    52 	else if (aMdaFormatUid == KUidMdaClipFormatAu)

    53 		ECOMUid = TUid::Uid(KMmfUidFormatAUWrite);

    54 	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)

    55 		ECOMUid = TUid::Uid(KMmfUidFormatRAWWrite);

    56 	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)

    57 		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRWrite);

    58 

    59 	return ECOMUid;

    60 	}

    61 

    62 /**

    63  * @internalComponent

    64  */

    65  TUid CMMFClientUtility::ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid)

    66 	{

    67     #if _DEBUG

    68       RDebug::Print(_L("CMMFClientUtility::ConvertMdaFormatUidToECOMRead\n"));

    69     #endif

    70 	TUid ECOMUid = KNullUid;

    71 	if (aMdaFormatUid == KUidMdaClipFormatWav)

    72 		ECOMUid = TUid::Uid(KMmfUidFormatWAVRead);

    73 	else if (aMdaFormatUid == KUidMdaClipFormatAu)

    74 		ECOMUid = TUid::Uid(KMmfUidFormatAURead);

    75 	else if (aMdaFormatUid == KUidMdaClipFormatRawAudio)

    76 		ECOMUid = TUid::Uid(KMmfUidFormatRAWRead);

    77 	else if (aMdaFormatUid == KUidMdaClipFormatRawAmr)

    78 		ECOMUid = TUid::Uid(KAdvancedUidFormatAMRRead);

    79 

    80 	return ECOMUid;

    81 	}

    82 

    83 /**

    84  * @internalComponent

    85  */

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

    87 	{

    88     #if _DEBUG

    89       RDebug::Print(_L("CMMFClientUtility::GetFileHeaderData***\n"));

    90     #endif

    91 	RFs fsSession;

    92 	RFile file;

    93 	TInt error = KErrNone;

    94 	TInt size = 0;

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

    96 		{

    97 		//rj  if ((error = file.Open(fsSession, aFileName, EFileShareReadersOnly)) == KErrNone)

    98         if ((error = file.Open(fsSession, aFileName, EFileShareAny)) == KErrNone)

    99 			{

   100 

   101 

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

   103 				{

   104 				if (size > 0)

   105 					{

   106     #if _DEBUG

   107       RDebug::Print(_L("CMMFClientUtility::GetFileHeaderData actual size= %d  \n"),size);

   108     #endif

   109 					if (size > aMaxLength)

   110 						size = aMaxLength;

   111 

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

   113 					}

   114 				}

   115 			file.Close();

   116 			}

   117 		fsSession.Close();

   118 

   119 

   120 		}

   121 

   122 	#if _DEBUG

   123       RDebug::Print(_L("CMMFClientUtility::GetFileHeaderData err %d  header %d\n"),error,size);

   124     #endif

   125 

   126 	return error;

   127 	}

   128 

   129 /**

   130  * @internalComponent

   131  */

   132  TFourCC CMMFClientUtility::ConvertMdaCodecToFourCC(TMdaPackage& aCodec)

   133 	{

   134     #if _DEBUG

   135       RDebug::Print(_L("CMMFClientUtility::ConvertMdaCodecToFourCC\n"));

   136     #endif

   137 	TFourCC dataType = KMMFFourCCCodeNULL;

   138 	switch (aCodec.Uid().iUid)

   139 		{

   140 		case KUidMdaWavPcmCodecDefine:

   141 			{

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

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

   144 				dataType = KMMFFourCCCodePCMU8; //8 bit PCM

   145 			else

   146 				dataType = KMMFFourCCCodePCM16; //16 bit PCM

   147 			break;

   148 			}

   149 		case KUidMdaAu8PcmCodecDefine:

   150 			dataType = KMMFFourCCCodePCM8;

   151 			break;

   152 		case KUidMdaAuCodecDefine:

   153 		case KUidMdaAu16PcmCodecDefine:

   154 			dataType = KMMFFourCCCodePCM16B;

   155 			break;

   156 

   157 		case KUidMdaAuMulawCodecDefine:

   158 		case KUidMdaWavMulawCodecDefine:

   159 		case KUidMdaRawAudioMulawCodecDefine:  //uLAW

   160 			dataType = KMMFFourCCCodeMuLAW;

   161 			break;

   162 		case KUidMdaAuAlawCodecDefine:

   163 		case KUidMdaWavAlawCodecDefine:

   164 		case KUidMdaRawAudioAlawCodecDefine:	 //ALAW

   165 			dataType = KMMFFourCCCodeALAW;

   166 			break;

   167 		case KUidMdaRawAudioS8PcmCodecDefine:	 //  P8

   168 			dataType = KMMFFourCCCodePCM8;

   169 			break;

   170 		case KUidMdaRawAudioU8PcmCodecDefine:	  // PU8

   171 			dataType = KMMFFourCCCodePCMU8;

   172 			break;

   173 		case KUidMdaRawAudioSL16PcmCodecDefine: // P16

   174 			dataType = KMMFFourCCCodePCM16;

   175 			break;

   176 		case KUidMdaRawAudioSB16PcmCodecDefine: //P16B

   177 			dataType = KMMFFourCCCodePCM16B;

   178 			break;

   179 		case KUidMdaRawAudioUL16PcmCodecDefine: //PU16

   180 			dataType = KMMFFourCCCodePCMU16;

   181 			break;

   182 		case KUidMdaRawAudioUB16PcmCodecDefine: //PU6B

   183 			dataType = KMMFFourCCCodePCMU16B;

   184 			break;

   185 		case KUidMdaGsmWavCodecDefine: //GSM6

   186 			dataType = KMMFFourCCCodeGSM610;

   187 			break;

   188 		case KUidMdaWavImaAdpcmCodecDefine:

   189 			dataType = KMMFFourCCCodeIMAD;

   190 			break;

   191 		case KUidMdaRawAmrCodecDefine:

   192 			dataType = KMMFFourCCCodeAMR;

   193 			break;

   194 		default:	// Not a Uid we recognise

   195 			dataType = KMMFFourCCCodeNULL;

   196 			break;

   197 		}

   198 	return dataType;

   199 	}

   200 

   201 

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

   203 	{

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

   205 	CleanupStack::Pop(self);

   206 	return self;

   207 	}

   208 

   209 

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

   211 	{

   212 	CMMFUtilityFileInfo* self = new (ELeave) CMMFUtilityFileInfo;

   213 	CleanupStack::PushL(self);

   214 	self->ConstructL(aSource);

   215 	return self;

   216 	}

   217 

   218 

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

   220 	{

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

   222 		{

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

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

   225 							EContentShareReadWrite/*EContentShareReadOnly*/);

   226 		}

   227 

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

   229 		{

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

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

   232 		}

   233 

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

   235 

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

   237 		{

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

   239 		User::Leave(err);

   240 		}

   241 

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

   243 	User::LeaveIfError(err);

   244 	}

   245 

   246 TInt CMMFUtilityFileInfo::EvaluateIntent(TIntent aIntent)

   247 	{

   248 	return iData->EvaluateIntent(aIntent);

   249 	}

   250 /**

   251  * @internalComponent

   252  */

   253 TBool CMMFUtilityFileInfo::GetFileMimeTypeL(TDes8& aMimeType)

   254 	{

   255     #if _DEBUG

   256       RDebug::Print(_L("CMMFUtilityFileInfo::GetFileMimeTypeL\n"));

   257     #endif

   258 	return iData->GetMimeTypeL(aMimeType);

   259 	}

   260 

   261 /**

   262  * @internalComponent

   263  */

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

   265 	{

   266     #if _DEBUG

   267       RDebug::Print(_L("CMMFUtilityFileInfo::GetFileHeaderDataL\n"));

   268     #endif

   269 	TInt size = 0;

   270 	iData->DataSizeL(size);

   271 	if (size > 0)

   272 		{

   273 		if (size > aMaxLength)

   274 			size = aMaxLength;

   275 		TInt pos = 0;

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

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

   278 		}

   279 	}

   280 

   281 /**

   282  * @internalComponent

   283  */

   284  HBufC8* CMMFClientUtility::GetFileExtensionL(const TDesC& aFileName)

   285 	{

   286     #if _DEBUG

   287       RDebug::Print(_L("CMMFClientUtility::GetFileExtensionL\n"));

   288     #endif

   289 	TParse fileName;

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

   291 	HBufC8* fileSuffix = NULL;

   292 	if(fileName.ExtPresent())

   293 		{

   294 		TPtrC fileSuffixPtr(fileName.Ext());

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

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

   297 		}

   298 	else

   299 		{

   300 		fileSuffix = KNullDesC8().AllocL();

   301 		}

   302 	return fileSuffix;

   303 	}

   304 

   305 

   306 /**

   307  * @internalComponent

   308  */

   309 CMMFUtilityFileInfo::~CMMFUtilityFileInfo()

   310 	{

   311     #if _DEBUG

   312       RDebug::Print(_L("CMMFClientUtility::~CMMFUtilityFileInfo\n"));

   313     #endif

   314 	delete iData;

   315 	}

   316 

   317 /*

   318  * @internalComponent

   319  *

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

   321  * the header data and file extension supplied.

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

   323  * 2 brownie points awarded for data match alone.

   324  * 1 brownie point awarded for suffix match alone.

   325  */

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

   327 	{

   328     #if _DEBUG

   329       RDebug::Print(_L("CMMFClientUtility::GetBestMatchL\n"));

   330     #endif

   331 	TInt browniePoints = 0;

   332 

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

   334 		{

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

   336 			{

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

   338 				format->SupportsFileExtension(aFileExtension))

   339 				{

   340 				browniePoints = 3;

   341 				}

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

   343 				{

   344 				browniePoints = 2;

   345 				}

   346 			else

   347 				{

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

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

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

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

   352 

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

   354 					{

   355 					// No header data indicated.

   356 					if (format->SupportsFileExtension(aFileExtension))

   357 						{

   358 							browniePoints = 1;

   359 						}

   360 					}

   361 				else

   362 					{

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

   364 						{

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

   366 							format->SupportsFileExtension(aFileExtension))

   367 							{

   368 							browniePoints = 1;

   369 							}

   370 						}

   371 					}

   372 				}

   373 			}

   374 		else

   375 			{

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

   377 			if (format->SupportsHeaderDataL(aHeaderData))

   378 				{

   379 				browniePoints = 2;

   380 				}

   381 			}

   382 		}

   383 	else // Empty File

   384 		{

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

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

   387 			{

   388 			browniePoints = 1;

   389 			}

   390 		}

   391 

   392 	return browniePoints;

   393 }

   394 

   395 /**

   396  * @internalComponent

   397  *

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

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

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

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

   402  *

   403  * @param	"aControllers"

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

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

   406  * @param	"aHeaderDataPlayback"

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

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

   409  * @param	"aFileExtensionPlayback"

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

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

   412  * @param	"aHeaderDataRecord"

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

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

   415  * @param	"aFileExtensionRecord"

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

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

   418  * @param	"aPrioritisedControllers"

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

   420  *			prioritised controllers will be returned.

   421  * @since	7.0s

   422  * @lib	"MediaClientUtility.lib"

   423  */

   424 void CMMFClientUtility::PrioritiseControllersL(

   425 	const RMMFControllerImplInfoArray& aControllers,

   426 	const TDesC8& aHeaderDataPlayback,

   427 	const TDesC8& aFileExtensionPlayback,

   428 	const TDesC8& aHeaderDataRecord,

   429 	const TDesC8& aFileExtensionRecord,

   430 	RMMFControllerImplInfoArray& prioritisedControllers)

   431 	{

   432 	RMMFControllerImplInfoArray fullMatchControllers; // data AND suffix

   433 	CleanupClosePushL(fullMatchControllers);

   434 	RMMFControllerImplInfoArray partMatchControllers; // data OR suffix

   435 	CleanupClosePushL(partMatchControllers);

   436 

   437 	TBool checkingPlaybackFormats = EFalse;

   438 	TBool checkingRecordFormats = EFalse;

   439 

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

   441 		checkingPlaybackFormats = ETrue;

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

   443 		checkingRecordFormats = ETrue;

   444 

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

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

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

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

   449 		{

   450 		const CMMFControllerImplementationInformation* controller = aControllers[i];

   451 		TInt savedBrowniePointsPlayback = 0;

   452 		TInt savedBrowniePointsRecord = 0;

   453 

   454 		if (checkingPlaybackFormats)

   455 			{

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

   457 				{

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

   459 

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

   461 

   462 				if (browniePoints >= savedBrowniePointsPlayback)

   463 					savedBrowniePointsPlayback = browniePoints;

   464 				}

   465 			}

   466 

   467 		if (checkingRecordFormats)

   468 			{

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

   470 				{

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

   472 

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

   474 

   475 				if (browniePoints >= savedBrowniePointsRecord)

   476 					savedBrowniePointsRecord = browniePoints;

   477 				}

   478 			}

   479 

   480 		TInt savedBrowniePoints = 0;

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

   482 		// make sure we've found both

   483 		if (checkingPlaybackFormats && checkingRecordFormats)

   484 			{

   485 			savedBrowniePoints = Min(savedBrowniePointsPlayback, savedBrowniePointsRecord);

   486 			}

   487 		else if (checkingPlaybackFormats)

   488 			{

   489 			savedBrowniePoints = savedBrowniePointsPlayback;

   490 			}

   491 		else if (checkingRecordFormats)

   492 			{

   493 			savedBrowniePoints = savedBrowniePointsRecord;

   494 			}

   495 

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

   497 		switch (savedBrowniePoints)

   498 			{

   499 			case 3:

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

   501 				break;

   502 			case 2:

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

   504 				break;

   505 			case 1:

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

   507 				break;

   508 			default:

   509 				break;

   510 			}

   511 		}

   512 

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

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

   515 		{

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

   517 			{

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

   519 			}

   520 		}

   521 

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

   523 		{

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

   525 			{

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

   527 			}

   528 		}

   529 

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

   531 	}

   532 

   533 /**

   534  * @internalComponent

   535  */

   536  CMMFMdaObjectStateChangeObserverCallback* CMMFMdaObjectStateChangeObserverCallback::NewL(MMdaObjectStateChangeObserver& aCallback)

   537 	{

   538 	return new(ELeave) CMMFMdaObjectStateChangeObserverCallback(aCallback);

   539 	}

   540 

   541 /**

   542  * @internalComponent

   543  */

   544 CMMFMdaObjectStateChangeObserverCallback::~CMMFMdaObjectStateChangeObserverCallback()

   545 	{

   546 	Cancel();

   547 	}

   548 

   549 /**

   550  * @internalComponent

   551  */

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

   553 	{

   554 	iObject = aObject;

   555 	iPreviousState = aPreviousState;

   556 	iCurrentState = aCurrentState;

   557 	iErrorCode = aErrorCode;

   558 	if (!IsActive())

   559 		{

   560 		TRequestStatus* s = &iStatus;

   561 		SetActive();

   562 		User::RequestComplete(s, KErrNone);

   563 		}

   564 	}

   565 

   566 CMMFMdaObjectStateChangeObserverCallback::CMMFMdaObjectStateChangeObserverCallback(MMdaObjectStateChangeObserver& aCallback) :

   567 	CActive(CActive::EPriorityHigh),

   568 	iCallback(aCallback)

   569 	{

   570     #if _DEBUG

   571       RDebug::Print(_L("CMMFMdaObjectStateChangeObserverCallback::CMMFMdaObjectStateChangeObserverCallback\n"));

   572     #endif

   573 	CActiveScheduler::Add(this);

   574 	}

   575 

   576 void CMMFMdaObjectStateChangeObserverCallback::RunL()

   577 	{

   578     #if _DEBUG

   579       RDebug::Print(_L("CMMFMdaObjectStateChangeObserverCallback::RunL\n"));

   580     #endif

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

   582 	}

   583 

   584 void CMMFMdaObjectStateChangeObserverCallback::DoCancel()

   585 	{

   586     #if _DEBUG

   587       RDebug::Print(_L("CMMFMdaObjectStateChangeObserverCallback::DoCancel\n"));

   588     #endif

   589 	//nothing to cancel

   590 	}

   591 

   592 

   593 //****************************************

   594 // CMMFFindAndOpenController

   595 //****************************************

   596 

   597 /**

   598  * Factory function to create a CMMFFindAndOpenController class

   599  *

   600  * @internalComponent

   601  */

   602  CMMFFindAndOpenController* CMMFFindAndOpenController::NewL(MMMFFindAndOpenControllerObserver& aObserver)

   603 	{

   604     #if _DEBUG

   605       RDebug::Print(_L("CMMFFindAndOpenController::NewL\n"));

   606     #endif

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

   608 	CleanupStack::PushL(self);

   609 	self->ConstructL();

   610 	CleanupStack::Pop(self);

   611 	return self;

   612 	}

   613 

   614 CMMFFindAndOpenController::~CMMFFindAndOpenController()

   615 	{

   616     #if _DEBUG

   617       RDebug::Print(_L("CMMFFindAndOpenController::~CMMFFindAndOpenController\n"));

   618     #endif

   619 	Cancel();

   620 

   621 	// delete temporary variables

   622 	Close();

   623 

   624 	// this should cancel the AO

   625 	delete iAddDataSourceSinkAsync;

   626 

   627 	delete iPrimaryConfig;

   628 	delete iSecondaryConfig;

   629 	}

   630 

   631 /**

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

   633  * Useful to allow a alloc testing to work.

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

   635  *

   636  * @internalComponent

   637  */

   638  void CMMFFindAndOpenController::Close()

   639 	{

   640 

   641 	Cancel();

   642 

   643 	if(iAddDataSourceSinkAsync)

   644 		{

   645 		iAddDataSourceSinkAsync->Cancel();

   646 		}

   647 

   648 	if (iPrimaryConfig)

   649 		iPrimaryConfig->Close();

   650 	if (iSecondaryConfig)

   651 		iSecondaryConfig->Close();

   652 

   653 	iPrioritisedControllers.Close();

   654 	iControllers.ResetAndDestroy();

   655 	iControllers.Close();

   656 

   657 	iFileName.SetLength(0);

   658 	iFileNameSecondary.SetLength(0);

   659 

   660 	delete iUrl;

   661 	iUrl = NULL;

   662 

   663 	delete iMimeType;

   664 	iMimeType = NULL;

   665 

   666 	delete iUniqueId;

   667 	iUniqueId = NULL;

   668 

   669 	iFileHandle.Close();

   670 	iUseFileHandle = EFalse;

   671 	}

   672 

   673 CMMFFindAndOpenController::CMMFFindAndOpenController(MMMFFindAndOpenControllerObserver& aObserver) :

   674 	CActive(EPriorityStandard),

   675 	iObserver(aObserver),

   676 	iDescriptor(NULL, 0)

   677 	{

   678     #if _DEBUG

   679       RDebug::Print(_L("CMMFFindAndOpenController::CMMFFindAndOpenController\n"));

   680     #endif

   681 	CActiveScheduler::Add(this);

   682 	}

   683 

   684 void CMMFFindAndOpenController::ConstructL()

   685 	{

   686     #if _DEBUG

   687       RDebug::Print(_L("CMMFFindAndOpenController::ConstructL\n"));

   688     #endif

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

   690 	iPrimaryConfig = new (ELeave)  CConfig();

   691 	iSecondaryConfig =  new (ELeave) CConfig;

   692 	iCurrentConfig =  iPrimaryConfig;

   693 	}

   694 

   695 void CMMFFindAndOpenController::RunL()

   696 	{

   697     #if _DEBUG

   698       RDebug::Print(_L("CMMFFindAndOpenController::RunL\n"));

   699     #endif

   700 	Process();

   701 	}

   702 

   703 void CMMFFindAndOpenController::DoCancel()

   704 	{

   705     #if _DEBUG

   706       RDebug::Print(_L("CMMFFindAndOpenController::DoCancel\n"));

   707     #endif

   708 	iAddDataSourceSinkAsync->Cancel();

   709 	}

   710 

   711 /**

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

   713  * Normally called once only after class has been constructed

   714  *

   715  * @param	aMediaId

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

   717  *			e.g. KUidMediaTypeAudio

   718  * @param	aPrioritySettings

   719  *			the priority settings to use when opening a controller

   720  * @param	aMediaIdMatchType

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

   722  *			returned from the ECOM registry.

   723  * @leave	can leave with KErrNoMemory

   724 

   725  * @internalComponent

   726  */

   727  void CMMFFindAndOpenController::Configure(

   728 	TUid aMediaId,

   729 	TMMFPrioritySettings aPrioritySettings,

   730 	CMMFPluginSelectionParameters::TMediaIdMatchType aMediaIdMatchType)

   731 	{

   732     #if _DEBUG

   733       RDebug::Print(_L("CMMFFindAndOpenController::Configure\n"));

   734     #endif

   735 	iPrioritySettings = aPrioritySettings;

   736 

   737 	iMediaIdMatchType = aMediaIdMatchType;

   738 

   739 	iMediaId = aMediaId;

   740 	}

   741 

   742 void CMMFFindAndOpenController::ConfigureController(

   743 	CConfig& config,

   744 	RMMFController& aController,

   745 	CMMFControllerEventMonitor& aEventMonitor,

   746 	TControllerMode aControllerMode)

   747 	{

   748     #if _DEBUG

   749       RDebug::Print(_L("CMMFFindAndOpenController::ConfigureController\n"));

   750     #endif

   751 	config.iController = &aController;

   752 	config.iEventMonitor = &aEventMonitor;

   753 	config.iControllerMode = aControllerMode;

   754 	}

   755 

   756 /**

   757  * Configures the primary controller

   758  *

   759  * @param	aController

   760  *			a reference to the client controller object to use

   761  * @param	aEventMonitor

   762  *			a reference to an event monitor object for receiving

   763  *			events from the controller

   764  * @param	aControllerMode

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

   766  *          or playback

   767  *

   768  * @internalComponent

   769  */

   770  void CMMFFindAndOpenController::ConfigureController(

   771 	RMMFController& aController,

   772 	CMMFControllerEventMonitor& aEventMonitor,

   773 	TControllerMode aControllerMode)

   774 	{

   775     #if _DEBUG

   776       RDebug::Print(_L("CMMFFindAndOpenController::ConfigureController2\n"));

   777     #endif

   778 	ConfigureController(

   779 		*iPrimaryConfig,

   780 		aController,

   781 		aEventMonitor,

   782 		aControllerMode);

   783 	}

   784 

   785 /**

   786  * Configures the secondary controller

   787  *

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

   789  * one controller for playback and another for recording

   790  *

   791  * @param	aController

   792  *			a reference to the client controller object to use

   793  * @param	aEventMonitor

   794  *			a reference to an event monitor object for receiving

   795  *			events from the controller

   796  * @param	aControllerMode

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

   798  *          or playback or converting

   799  *

   800  * @internalComponent

   801  */

   802  void CMMFFindAndOpenController::ConfigureSecondaryController(

   803 	RMMFController& aController,

   804 	CMMFControllerEventMonitor& aEventMonitor,

   805 	TControllerMode aControllerMode)

   806 	{

   807     #if _DEBUG

   808       RDebug::Print(_L("CMMFFindAndOpenController::ConfigureSecondaryController\n"));

   809     #endif

   810 	ConfigureController(

   811 		*iSecondaryConfig,

   812 		aController,

   813 		aEventMonitor,

   814 		aControllerMode);

   815 	}

   816 

   817 void CMMFFindAndOpenController::Init()

   818 	{

   819     #if _DEBUG

   820       RDebug::Print(_L("CMMFFindAndOpenController::Init\n"));

   821     #endif

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

   823 	iError = KErrNone;

   824 	iSourceSinkConfigured = EFalse;

   825 	iControllerCount = 0;

   826 	}

   827 

   828 void CMMFFindAndOpenController::ConfigureSourceSink(

   829 	CConfig& config,

   830 	TSourceSink aSource,

   831 	TSourceSink aSink)

   832 	{

   833 	TInt err;

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

   835 	if (err != KErrNone)

   836 		{

   837 		iError = err;

   838 		return;

   839 		}

   840 

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

   842 	if (err != KErrNone)

   843 		{

   844 		iError = err;

   845 		return;

   846 		}

   847 	}

   848 

   849 

   850 void CMMFFindAndOpenController::ConfigureSourceSink(

   851 	CConfig& config,

   852 	const TMMSource& aSource,

   853 	TSourceSink aSink)

   854 	{

   855 	TInt err;

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

   857 	if (err != KErrNone)

   858 		{

   859 		iError = err;

   860 		return;

   861 		}

   862 

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

   864 	if (err != KErrNone)

   865 		{

   866 		iError = err;

   867 		return;

   868 		}

   869 	}

   870 

   871 

   872 

   873 /**

   874  * Configure the primary controller's source and sink

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

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

   877  * a subsequent call to OpenByXXX()

   878  *

   879  * @param	aSourceUid

   880  *			the UID of the data source

   881  * @param	aSourceData

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

   883  * @param	aSinkUid

   884  *			the UID of the data sink

   885  * @param	aSinkData

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

   887  *

   888  * @internalComponent

   889  */

   890  void CMMFFindAndOpenController::ConfigureSourceSink(

   891 	TSourceSink aSource,

   892 	TSourceSink aSink)

   893 	{

   894 

   895 	CConfig* config = NULL;

   896 

   897 	Init();

   898 	config = iPrimaryConfig;

   899 

   900 

   901 	// must have already called ConfigureController()

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

   903 

   904 	ConfigureSourceSink(

   905 		*config,

   906 		aSource,

   907 		aSink);

   908 	iCurrentConfig = config;

   909 

   910 	iSourceSinkConfigured = ETrue;

   911 	}

   912 

   913 

   914 /**

   915  * Configure the primary controller's source and sink

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

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

   918  * a subsequent call to OpenByXXX()

   919  *

   920  * @param	aSourceUid

   921  *			the UID of the data source

   922  * @param	aSourceData

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

   924  * @param	aSinkUid

   925  *			the UID of the data sink

   926  * @param	aSinkData

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

   928  *

   929  * @internalComponent

   930  */

   931  void CMMFFindAndOpenController::ConfigureSecondarySourceSink(

   932 	TSourceSink aSource,

   933 	TSourceSink aSink)

   934 	{

   935 	if (iError != KErrNone)

   936 		{

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

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

   939 		return;

   940 		}

   941 

   942 	CConfig* config = NULL;

   943 

   944 	config = iSecondaryConfig;

   945 

   946 	// must have already configured the primary controller

   947 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

   948 	config = iSecondaryConfig;

   949 

   950 	// must have already called ConfigureController()

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

   952 

   953 	ConfigureSourceSink(

   954 		*config,

   955 		aSource,

   956 		aSink);

   957 	iCurrentConfig = config;

   958 

   959 	iSourceSinkConfigured = ETrue;

   960 	}

   961 

   962 

   963 

   964 

   965  void CMMFFindAndOpenController::ConfigureSourceSink(

   966 	const TMMSource& aSource,

   967 	TSourceSink aSink)

   968 	{

   969 	Init();

   970 	CConfig* config = iPrimaryConfig;

   971 

   972 	// must have already called ConfigureController()

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

   974 

   975 	ConfigureSourceSink(

   976 		*config,

   977 		aSource,

   978 		aSink);

   979 	iCurrentConfig = config;

   980 

   981 	iSourceSinkConfigured = ETrue;

   982 	}

   983 

   984 

   985 

   986 

   987 /**

   988  * Opens a controller using the supplied controller UID

   989  * and adds the source & sink

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

   991  *

   992  * @param	aControllerUid

   993  *			the UID of the primary controller

   994  * @param	aControllerUid

   995  *			the UID of the secondary controller

   996  *

   997  * @internalComponent

   998  */

   999  void CMMFFindAndOpenController::OpenByControllerUid(

  1000 		TUid aControllerUid,

  1001 		TUid aSecondaryControllerUid)

  1002 	{

  1003     #if _DEBUG

  1004       RDebug::Print(_L("CMMFFindAndOpenController::OpenByControllerUid\n"));

  1005     #endif

  1006 	// must have already called ConfigureSourceSink()

  1007 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1008 

  1009 	// Have there been any errors so far ?

  1010 	if (iError != KErrNone)

  1011 		{

  1012 	    SchedSendError();

  1013 		return;

  1014 		}

  1015 

  1016 	if (iCurrentConfig == iPrimaryConfig)

  1017 		{

  1018 		// only do this for the playback controller

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

  1020 

  1021 		if (iError != KErrNone)

  1022 			{

  1023 	    	SchedSendError();

  1024 			return;

  1025 			}

  1026 		}

  1027 

  1028 	iPrimaryConfig->iControllerUid = aControllerUid;

  1029 	if (iCurrentConfig == iSecondaryConfig)

  1030 		{

  1031 		if (aSecondaryControllerUid == KNullUid)

  1032 			iSecondaryConfig->iControllerUid = aControllerUid;

  1033 		else

  1034 			iSecondaryConfig->iControllerUid = aSecondaryControllerUid;

  1035 		}

  1036 

  1037 	iMode = EOpenByControllerUid;

  1038 	iControllerImplInfo = NULL;

  1039 	iState = EOpenController;

  1040 	KickState();

  1041 	}

  1042 

  1043 /**

  1044  * Opens a controller using the supplied file name

  1045  * and adds the source & sink

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

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

  1048  *

  1049  * @param	aSource

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

  1051  *          for a controller

  1052  * @param	aFileNameSecondary

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

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

  1055  *			between two files.

  1056  *

  1057  * @internalComponent

  1058  */

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

  1060 	{

  1061 	// must have already called ConfigureSourceSink()

  1062 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1063 

  1064 	TInt err;

  1065 	// Have there been any errors so far ?

  1066 	if (iError != KErrNone)

  1067 		{

  1068 		SchedSendError();

  1069 		return;

  1070 		}

  1071 

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

  1073 		{

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

  1075 		iFileName = fileSource.Name();

  1076 		}

  1077 

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

  1079 		{

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

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

  1082 

  1083 

  1084 		if (err != KErrNone)

  1085 			{

  1086 			SchedSendError(err);

  1087 			return;

  1088 			}

  1089 

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

  1091 

  1092 

  1093 		iUseFileHandle = ETrue;

  1094 		}

  1095 

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

  1097 	iIntent = aSource.Intent();

  1098 	if (err != KErrNone)

  1099 		{

  1100 		SchedSendError(err);

  1101 		return;

  1102 		}

  1103 

  1104 

  1105 	// take a copy of the secondary file name

  1106 	iFileNameSecondary = aFileNameSecondary;

  1107 

  1108 	iMode = EOpenByFileName;

  1109 	iState = EBuildControllerList;

  1110 	KickState();

  1111 	}

  1112 

  1113 /**

  1114  * Opens a controller using the supplied format UID

  1115  * and adds the source & sink

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

  1117  *

  1118  * @param	aFormatUid

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

  1120  * @param	aFormatUidSecondary

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

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

  1123  *

  1124  * @internalComponent

  1125  */

  1126  void CMMFFindAndOpenController::OpenByFormatUid(TUid aFormatUid, TUid aFormatUidSecondary)

  1127 	{

  1128     #if _DEBUG

  1129       RDebug::Print(_L("CMMFFindAndOpenController::OpenByFormatUid\n"));

  1130     #endif

  1131 	// must have already called ConfigureSourceSink()

  1132 	__ASSERT_ALWAYS(iSourceSinkConfigured, CUPanic(EMMFMediaClientUtilityBadState));

  1133 

  1134 	// Have there been any errors so far ?