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 //

    15 

    16 #include <badesca.h>

    17 #include <utf.h>

    18 #include <uri8.h>

    19 #include <uriutils.h>

    20 #include <mmf/plugin/mmfplugininterfaceuids.hrh>

    21 #include <mmf/common/mmfcontrollerpluginresolver.h>

    22 #include "mmfmatchdata.h"

    23 #include <mmf/server/mmfdatasourcesink.hrh>

    24 #include "MMFFormatImplementationInformationBody.h"

    25 #include <mm/mmpluginutils.h>

    26 

    27 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

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

    29 #endif

    30 

    31 _LIT8(KSupplier, "<s>");

    32 _LIT8(KMediaId, "<i>");

    33 _LIT8(KUriScheme,"<u>");

    34 _LIT8(KNonNetwork,"<n>");

    35 _LIT8(KPlayFormatCollectionUid, "<p>");

    36 _LIT8(KRecordFormatCollectionUid, "<r>");

    37 _LIT8(KFormatFileExtension, "<e>");

    38 _LIT8(KFormatMimeType, "<m>");

    39 _LIT8(KFormatHeaderData, "<h>");

    40 _LIT8(KHeapSize, "<a>");

    41 _LIT8(KCustomInterfaceSupport, "<c>");

    42 _LIT8(KSecureDRMProcessMode, "<d>");

    43 _LIT8(KStackSize, "<t>");

    44 _LIT8(KTagMatch, "*<?>*");

    45 _LIT8(KTagYes,"yes");

    46 

    47 const TInt KTagLength = 3;

    48 

    49 const TInt KMaxExtLen = 5 ;

    50 const TInt KDesCArrayGranularity = 1;

    51 

    52 const TInt KUriPriorityHigh = 3;

    53 const TInt KUriPriorityMedium = 2;

    54 const TInt KUriPriorityLow = 1;

    55 const TInt KUriPriorityNone = 0;

    56 

    57 static const TUid KUidInterfaceFormatDecode = {KMmfUidPluginInterfaceFormatDecode};

    58 static const TUid KUidInterfaceFormatEncode = {KMmfUidPluginInterfaceFormatEncode};

    59 static const TUid KUidInterfaceMMFController = {KMmfUidPluginInterfaceController};

    60 

    61 

    62 EXPORT_C CMMFFormatSelectionParameters* CMMFFormatSelectionParameters::NewL()

    63 	{

    64 	CMMFFormatSelectionParameters* s = CMMFFormatSelectionParameters::NewLC();

    65 	CleanupStack::Pop(s);

    66 	return s;

    67 	}

    68 

    69 EXPORT_C CMMFFormatSelectionParameters* CMMFFormatSelectionParameters::NewLC()

    70 	{

    71 	CMMFFormatSelectionParameters* s = new(ELeave) CMMFFormatSelectionParameters;

    72 	CleanupStack::PushL(s);

    73 	return s;

    74 	}

    75 

    76 CMMFFormatSelectionParameters* CMMFFormatSelectionParameters::NewL(const CMMFFormatSelectionParameters& aParams)

    77 	{

    78 	CMMFFormatSelectionParameters* s = CMMFFormatSelectionParameters::NewLC();

    79 	s->ConstructL(aParams);

    80 	CleanupStack::Pop(s);

    81 	return s;

    82 	}

    83 

    84 void CMMFFormatSelectionParameters::ConstructL(const CMMFFormatSelectionParameters& aParams)

    85 	{

    86 	iMatchReqData = CMatchData::CreateL();

    87 	iMatchReqData->SetMatchDataL(aParams.MatchData());

    88 	iMatchReqData->SetMatchUriSchemeL(aParams.MatchUriScheme());

    89 	iMatchDataType = aParams.MatchDataType();

    90 	}

    91 

    92 CMMFFormatSelectionParameters::~CMMFFormatSelectionParameters()

    93 	{

    94 	delete iMatchReqData;

    95 	iMatchReqData= NULL;

    96 	}

    97 

    98 CMMFFormatSelectionParameters::CMMFFormatSelectionParameters()

    99 	{

   100 	iMatchDataType = EMatchAny;

   101 	}

   102 	

   103 EXPORT_C void CMMFFormatSelectionParameters::SetMatchToFileNameL(const TDesC& aFileName)

   104 	{

   105 	delete iMatchReqData;

   106 	iMatchReqData = NULL;

   107 	iMatchDataType = EMatchAny;	

   108 	// Extract the extension from the data passed in

   109 

   110 	// Parse the path and extract the extension

   111 	_LIT( KDot, "." ) ;

   112 	_LIT8( KDot8, "." );

   113 

   114 	// If there is no dot "." in aFileName then assume that we have been passed the extension only (if KMaxExtLen or less)

   115 	if ( (aFileName.Length() <= KMaxExtLen) && (aFileName.Find( KDot ) == KErrNotFound) )

   116 		{

   117 		RBuf8 temp;

   118 		CleanupClosePushL(temp);

   119 		temp.CreateL(aFileName.Length()+1);

   120 		User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(temp, aFileName));

   121 		temp.Insert(0,KDot8);

   122 		

   123 		iMatchReqData = CMatchData::CreateL();

   124 		iMatchReqData->SetMatchDataL(temp);

   125 		

   126 		CleanupStack::PopAndDestroy(&temp);

   127 		

   128 		}

   129 	else if ( aFileName.Find( KDot ) == 0 )  // the first character is dot so assume extension only

   130 		{

   131 		RBuf8 temp;

   132 		CleanupClosePushL(temp);

   133 		temp.CreateL(aFileName.Length());

   134 		User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(temp, aFileName));

   135 			

   136 		iMatchReqData = CMatchData::CreateL();

   137 		iMatchReqData->SetMatchDataL(temp);

   138 		

   139 		CleanupStack::PopAndDestroy(&temp);

   140 		

   141 		}

   142 	else // We have been given the whole filename.  Use TParse to extract the extension.

   143 		{

   144 		TParse parser ;

   145 		parser.Set( aFileName, NULL, NULL ) ;

   146 		if ( !( parser.NamePresent() ) )

   147 			User::Leave( KErrBadName ) ;

   148 		if ( !( parser.PathPresent() ) )

   149 			{

   150 			RFs fsSession ;

   151 			User::LeaveIfError(fsSession.Connect());

   152 			TInt error = fsSession.Parse(aFileName, parser);

   153 			fsSession.Close();

   154 			User::LeaveIfError(error);

   155 			}

   156 		// Parser should now have the full filename and path

   157 		TPtrC extension = parser.Ext();

   158 		

   159 		RBuf8 temp;

   160 		CleanupClosePushL(temp);

   161 		temp.CreateL(extension.Length());

   162 		User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(temp, extension));

   163 			

   164 		iMatchReqData = CMatchData::CreateL();

   165 		iMatchReqData->SetMatchDataL(temp);

   166 		

   167 		CleanupStack::PopAndDestroy(&temp);

   168 		

   169 		}

   170 

   171 	// If we're here, we must now have the file extension

   172 	iMatchDataType = EMatchFileExtension;

   173 	}

   174 	

   175 EXPORT_C void CMMFFormatSelectionParameters::SetMatchToUriL(const TDesC& aUrl)

   176 	{

   177 	delete iMatchReqData;

   178 	iMatchReqData = NULL;

   179 	iMatchDataType = EMatchAny;	

   180 	

   181 	CUri8* uri = UriUtils::CreateUriL(aUrl); //Converts the TDesC16 aUrl to TDesC8 type

   182    	CleanupStack::PushL(uri);

   183   	const TDesC8& path = uri->Uri().Extract(EUriPath);

   184 	

   185 	// Now parse the file name 

   186    	TInt pos = path.LocateReverse('.');

   187    

   188    	if(pos != KErrNotFound) // if not found, then by default match data is NULL

   189    		{

   190    		TPtrC8 extension(path.Right(path.Length()-pos));

   191    		iMatchReqData = CMatchData::CreateL();

   192    		iMatchReqData->SetMatchDataL(extension);

   193   		}

   194    	CleanupStack::PopAndDestroy(uri);

   195    

   196    	// If we're here, we must now have the file extension

   197    	// Use match file extension, because we are matching to the file extension of the file specified by the URI

   198   	iMatchDataType = EMatchFileExtension;

   199 	}

   200 	

   201 /**

   202 	@publishedPartner

   203 	@prototype

   204 	

   205 	Sets this object to match to uri scheme and file extension specified by a URI.

   206 	

   207 	The Uri scheme and extension are saved in iMatchReqData. Further,iMatchData contains uri extension, 

   208 	iMatchUriScheme contains uri scheme.

   209 

   210 	@param  aUri

   211 	        The URI containing the scheme and uri extension to be matched. 

   212 

   213 */	

   214 EXPORT_C void CMMFFormatSelectionParameters::SetMatchToUriSupportL(const TDesC& aUrl)

   215 	{

   216 	delete iMatchReqData;

   217 	iMatchReqData = NULL;

   218 	iMatchDataType = EMatchAny;	

   219 	

   220 	CUri8* uri = UriUtils::CreateUriL(aUrl); //Converts the TDesC16 aUrl to TDesC8 type

   221 	CleanupStack::PushL(uri);

   222 	

   223 	const TDesC8& scheme = uri->Uri().Extract(EUriScheme);  //get the uri scheme

   224 	iMatchReqData = CMatchData::CreateL();

   225 	iMatchReqData->SetMatchUriSchemeL(scheme);

   226 	

   227 	const TDesC8& path = uri->Uri().Extract(EUriPath); 		

   228 	// Now parse the file name 

   229 	TInt pos = path.LocateReverse('.');

   230 	

   231 	if(pos != KErrNotFound) // if not found, by default match data is NULL

   232 		{

   233 		TPtrC8 extension(path.Right(path.Length()-pos));

   234 		iMatchReqData->SetMatchDataL(extension);

   235  		}

   236 		

   237 	CleanupStack::PopAndDestroy(uri);

   238 	// If we're here, we must now have the uri saved in iMatchData. Now, set match type 

   239 	// to EMatchUri for checking schema and uri extension

   240 	iMatchDataType = EMatchUri;

   241 	}

   242 	

   243 

   244 

   245 EXPORT_C void CMMFFormatSelectionParameters::SetMatchToMimeTypeL(const TDesC8& aMimeType)

   246 	{

   247 	delete iMatchReqData;

   248 	iMatchReqData = NULL;

   249 	iMatchDataType = EMatchAny;	

   250 	

   251 	iMatchReqData = CMatchData::CreateL();

   252 	iMatchReqData->SetMatchDataL(aMimeType);

   253 	iMatchDataType = EMatchMimeType;

   254 	}

   255 

   256 EXPORT_C void CMMFFormatSelectionParameters::SetMatchToHeaderDataL(const TDesC8& aHeaderData)

   257 	{

   258 	delete iMatchReqData;

   259 	iMatchReqData = NULL;

   260 	iMatchDataType = EMatchAny;	

   261 	

   262 	iMatchReqData = CMatchData::CreateL();

   263 	iMatchReqData->SetMatchDataL(aHeaderData);	

   264 	iMatchDataType = EMatchHeaderData;

   265 	}

   266 

   267 EXPORT_C const TDesC8& CMMFFormatSelectionParameters::MatchData() const

   268 	{

   269 	if (iMatchReqData)

   270 		{

   271 		return iMatchReqData->MatchData();

   272 		}

   273 	else

   274 		{

   275 		return KNullDesC8;	

   276 		}

   277 	}

   278 

   279 /**

   280 	@publishedPartner

   281 	@prototype

   282 	

   283 	Returns the uri scheme used to perform the plugin match.

   284 	

   285 	@return The uri scheme.

   286 

   287 */	

   288 EXPORT_C const TDesC8& CMMFFormatSelectionParameters::MatchUriScheme() const

   289 	{

   290 	if (iMatchReqData)

   291 		{

   292 		return iMatchReqData->MatchUriScheme();

   293 		}

   294 	else

   295 		{

   296 		return KNullDesC8;

   297 		}

   298 	}

   299 	

   300 EXPORT_C CMMFFormatSelectionParameters::TMatchDataType CMMFFormatSelectionParameters::MatchDataType() const

   301 	{

   302 	return iMatchDataType;

   303 	}

   304 

   305 CMMFPluginSelectionParameters::CMMFPluginSelectionParameters(TUid aPluginInterfaceUid) :

   306 	iPluginInterfaceUid(aPluginInterfaceUid)

   307 	{

   308 	iPreferredSupplierMatchType = ENoPreferredSupplierMatch;

   309 	iMediaIdMatchType = ENoMediaIdMatch;

   310 	}

   311 

   312 CMMFPluginSelectionParameters::~CMMFPluginSelectionParameters()

   313 	{

   314 	delete iPreferredSupplier;

   315 	iMediaIds.Reset();

   316 	iMediaIds.Close();

   317 	}

   318 

   319 EXPORT_C void CMMFPluginSelectionParameters::SetPreferredSupplierL(const TDesC& aPreferredSupplier, TPreferredSupplierMatchType aMatchType)

   320 	{

   321 	delete iPreferredSupplier;

   322 	iPreferredSupplier = NULL;

   323 	iPreferredSupplier = aPreferredSupplier.AllocL();

   324 	iPreferredSupplierMatchType = aMatchType;

   325 	}

   326 

   327 EXPORT_C void CMMFPluginSelectionParameters::SetMediaIdsL(const RArray<TUid>& aMediaIds, TMediaIdMatchType aMatchType)

   328 	{

   329 	iMediaIds.Reset();

   330 	for (TInt i=0; i<aMediaIds.Count(); i++)

   331 		{

   332 		User::LeaveIfError(iMediaIds.Append(aMediaIds[i]));

   333 		}

   334 	iMediaIdMatchType = aMatchType;

   335 	}

   336 

   337 EXPORT_C const TDesC& CMMFPluginSelectionParameters::PreferredSupplier() const

   338 	{

   339 	if (iPreferredSupplier)

   340 		return *iPreferredSupplier;

   341 	else

   342 		return KNullDesC;

   343 	}

   344 

   345 EXPORT_C CMMFPluginSelectionParameters::TPreferredSupplierMatchType CMMFPluginSelectionParameters::PreferredSupplierMatchType() const

   346 	{

   347 	return iPreferredSupplierMatchType;

   348 	}

   349 

   350 EXPORT_C const RArray<TUid>& CMMFPluginSelectionParameters::MediaIds() const

   351 	{

   352 	return iMediaIds;

   353 	}

   354 

   355 EXPORT_C CMMFPluginSelectionParameters::TMediaIdMatchType CMMFPluginSelectionParameters::MediaIdMatchType() const

   356 	{

   357 	return iMediaIdMatchType;

   358 	}

   359 

   360 EXPORT_C TUid CMMFPluginSelectionParameters::InterfaceUid() const

   361 	{

   362 	return iPluginInterfaceUid;

   363 	}

   364 

   365 

   366 TBool CMMFPluginSelectionParameters::CheckMediaIdSupportL(const CMMFPluginImplementationInformation& aPlugin) const

   367 	{

   368 	TBool ret = EFalse;

   369 	switch (MediaIdMatchType())

   370 		{

   371 	case CMMFPluginSelectionParameters::ENoMediaIdMatch:

   372 		// No match required so suitable

   373 		ret = ETrue;

   374 		break;

   375 	case CMMFPluginSelectionParameters::EAllowOtherMediaIds:

   376 		// Just check that the requested media id is supported by the plugin

   377 		{

   378 		for (TInt i=0; i<MediaIds().Count(); i++)

   379 			{

   380 			if (aPlugin.SupportsMediaId(MediaIds()[i]))

   381 				{

   382 				ret = ETrue;

   383 				break;

   384 				}

   385 			}

   386 		break;

   387 		}

   388 	case CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds:

   389 		// Check the media id counts are the same, and that all requested ones are present

   390 		{

   391 		TInt found=0;

   392 		for (TInt i=0; i<MediaIds().Count(); i++)

   393 			{

   394 			if (aPlugin.SupportsMediaId(MediaIds()[i]))

   395 				found++;

   396 			}

   397 		// Check all request mediaIds are present

   398 		if ((found == MediaIds().Count()) && (found == aPlugin.SupportedMediaIds().Count()))

   399 			ret = ETrue;

   400 		break;

   401 		}

   402 	default:

   403 		User::Leave(KErrNotSupported);

   404 		break;

   405 		}

   406 	return ret;

   407 	}

   408 

   409 

   410 

   411 EXPORT_C CMMFControllerPluginSelectionParameters* CMMFControllerPluginSelectionParameters::NewL()

   412 	{

   413 	CMMFControllerPluginSelectionParameters* s = CMMFControllerPluginSelectionParameters::NewLC();

   414 	CleanupStack::Pop(s);

   415 	return s;	

   416 	}

   417 

   418 EXPORT_C CMMFControllerPluginSelectionParameters* CMMFControllerPluginSelectionParameters::NewLC()

   419 	{

   420 	CMMFControllerPluginSelectionParameters* s = new(ELeave) CMMFControllerPluginSelectionParameters;

   421 	CleanupStack::PushL(s);

   422 	return s;

   423 	}

   424 

   425 CMMFControllerPluginSelectionParameters::CMMFControllerPluginSelectionParameters() :

   426 	CMMFPluginSelectionParameters(KUidInterfaceMMFController)

   427 	{

   428 	}

   429 

   430 CMMFControllerPluginSelectionParameters::~CMMFControllerPluginSelectionParameters()

   431 	{

   432 	delete iRequiredPlayFormatSupport;

   433 	delete iRequiredRecordFormatSupport;

   434 	}

   435 

   436 EXPORT_C void CMMFControllerPluginSelectionParameters::SetRequiredPlayFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport)

   437 	{

   438 	delete iRequiredPlayFormatSupport;

   439 	iRequiredPlayFormatSupport = NULL;

   440 	iRequiredPlayFormatSupport = CMMFFormatSelectionParameters::NewL(aRequiredSupport);

   441 	}

   442 

   443 EXPORT_C void CMMFControllerPluginSelectionParameters::SetRequiredRecordFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport)

   444 	{

   445 	delete iRequiredRecordFormatSupport;

   446 	iRequiredRecordFormatSupport = NULL;

   447 	iRequiredRecordFormatSupport = CMMFFormatSelectionParameters::NewL(aRequiredSupport);

   448 	}

   449 

   450 EXPORT_C void CMMFControllerPluginSelectionParameters::ListImplementationsL(RMMFControllerImplInfoArray& aImplementations) const

   451 	{

   452 	aImplementations.ResetAndDestroy();

   453 

   454 	RImplInfoPtrArray ecomArray;

   455 	CleanupResetAndDestroyPushL(ecomArray);

   456 

   457 	MmPluginUtils::FindImplementationsL(InterfaceUid(), ecomArray);

   458 

   459 	TInt index;

   460 	// Create Controller Implementation Information for each entry

   461 	for (index=0; index<ecomArray.Count(); index++)

   462 		{

   463 		CMMFControllerImplementationInformation* c = NULL;

   464 		if (ecomArray[index] == NULL)

   465 			{

   466 			User::Leave(KErrNoMemory);

   467 			}

   468 		TRAPD(error, c = CMMFControllerImplementationInformation::NewL(*(ecomArray[index])));

   469 

   470 		if (error == KErrNone)

   471 			{

   472 			CleanupStack::PushL(c);

   473 			

   474 		// If required, get the play and record formats for the controller.

   475 			if (iRequiredPlayFormatSupport)

   476 				{

   477 				c->GetPlayFormatsL();

   478 				}

   479 			if (iRequiredRecordFormatSupport)

   480 				{

   481 				c->GetRecordFormatsL();

   482 				}

   483 			

   484 			// Find out whether this controller matches the client's requirements...

   485 			TBool suitable = EFalse;

   486 			TInt arrayPos; 

   487 			suitable = CheckUriSupport(iRequiredPlayFormatSupport, c, c->PlayFormats());

   488 			if(suitable)

   489 				{

   490 				suitable = CheckUriSupport(iRequiredRecordFormatSupport, c, c->RecordFormats());

   491 				}

   492 			if(suitable)

   493 				{

   494 				MatchImplementationToSelectParamsL(aImplementations, *c, arrayPos);

   495 				}

   496 			else

   497 				{

   498 				arrayPos = -1;	

   499 				}

   500 			

   501 			if (arrayPos >=0)

   502 				{

   503 				// This plugin is suitable - insert it into the array at the suggested position

   504 				User::LeaveIfError(aImplementations.Insert(c, arrayPos));

   505 				CleanupStack::Pop(c);

   506 				}

   507 			else

   508 				{

   509 				// This plugin isn't suitable so just destroy it

   510 				CleanupStack::PopAndDestroy(c);

   511 				}

   512 			}

   513 		else if (error != KErrCorrupt)

   514 			{

   515 			// Ignore the plugin if it is corrupt.  Otherwise, leave.

   516 			// if error !=KErrNone, c hasn't been constructed so it is safe to leave

   517 			User::Leave(error);

   518 			}

   519 		}

   520 

   521 	CleanupStack::PopAndDestroy();//ecomArray

   522 	}

   523 

   524 void CMMFControllerPluginSelectionParameters::MatchImplementationToSelectParamsL(RMMFControllerImplInfoArray& aImplementations, const CMMFControllerImplementationInformation& aPlugin, TInt& aArrayPos) const

   525 	{

   526 	TBool suitable = EFalse;

   527 	

   528 	// First, check whether the plugin supports the required play formats

   529 	suitable = CheckFormatSupportL(iRequiredPlayFormatSupport, aPlugin.PlayFormats());

   530 	

   531 	// Next, check the record formats

   532 	if (suitable)

   533 		suitable = CheckFormatSupportL(iRequiredRecordFormatSupport, aPlugin.RecordFormats());

   534 		

   535 	// Next, check for correct media id support

   536 	if (suitable)

   537 		suitable = CheckMediaIdSupportL(aPlugin);

   538 

   539 	// Finally, calculate the position the plugin should take in aImplementations depending on the preferred supplier and version number.

   540 	if (suitable)

   541 		aArrayPos = CheckPreferredSupplierL(aImplementations, aPlugin);

   542 	else

   543 		aArrayPos = -1;

   544 	}

   545 

   546 /**

   547 	Checks the given Controller for uri support. Uri support may be there 

   548 	if either requiredscheme or extension matches with that given controller

   549 	

   550 	@param  aSelectParams 

   551 			Describes the selection parameter which a controller needs to 

   552 			support in order to be selected

   553 			

   554 	@param	aPlugin

   555 			The controller plugin which is checked for uri support 

   556 			

   557 	@param	aFormats

   558 			The play or record formats looked for extension match

   559 */	

   560 TBool CMMFControllerPluginSelectionParameters::CheckUriSupport(CMMFFormatSelectionParameters* aSelectParams, CMMFControllerImplementationInformation* aPlugin, const RMMFFormatImplInfoArray& aFormats) const

   561 	{

   562 	// If aSelectParams are NULL (ie none were set) then the plugin must be suitable!

   563 	if (aSelectParams == NULL)

   564 		return ETrue;

   565 	

   566 	//If EMatchUri not set then the plugin might be suitable!

   567 	if(aSelectParams->MatchDataType() != CMMFFormatSelectionParameters::EMatchUri)

   568 		{

   569 		return ETrue;

   570 		}

   571 		

   572 	TBool suitable = EFalse;

   573 	TInt index;

   574 	

   575 	//If <n>yes is there in the aPlugin's opaque data, 

   576 	//URI support not assumed. So, don't load the controller

   577 	if(!aPlugin->SupportsNetworkCapability())

   578 		{

   579 		return EFalse;	

   580 		}

   581 

   582     //the uri scheme to be matched for

   583 	if (aPlugin->SupportsUriScheme(aSelectParams->MatchUriScheme()))

   584 		{

   585 		aPlugin->SetUriPriority(KUriPriorityMedium);

   586 		suitable = ETrue;

   587 		}

   588 	else

   589 		{

   590 		//if other uri scheme support declared, but not the required one,

   591 		// even then controller not supported

   592 		if(aPlugin->SupportedUriSchemes().Count() > 0)

   593 			{

   594 			return EFalse;		

   595 			}

   596 		}

   597 	

   598 		

   599 	//then match Uri extension. .

   600 	

   601 	//if ctrl has no network capability, then lowest priority given on matching file extension

   602 	for (index=0;index<aFormats.Count();index++)

   603 		{

   604 		if (aFormats[index]-> SupportsFileExtension(aSelectParams->MatchData()))

   605 			{

   606 			if(!suitable)

   607 				{

   608 				aPlugin->SetUriPriority(KUriPriorityLow);	

   609 				}

   610 			else

   611 				{

   612 				aPlugin->SetUriPriority(KUriPriorityHigh);

   613 				}

   614 			

   615 			suitable = ETrue;

   616 			break;

   617 			}

   618 		}

   619 	

   620 	return suitable;

   621 	}

   622 

   623 TInt CMMFControllerPluginSelectionParameters::CheckPreferredSupplierL(RMMFControllerImplInfoArray& aImplementations, const CMMFControllerImplementationInformation& aPlugin) const

   624 	{

   625 	// Set the return value to indicated the plugin is not suitable.

   626 	TBool pluginSuitable = EFalse;

   627 	TBool needToPlaceInVersionOrder = EFalse;

   628 	TBool needToPlaceInUriPriorityOrder = EFalse;

   629 

   630 	if((iRequiredPlayFormatSupport && (iRequiredPlayFormatSupport->MatchDataType() == CMMFFormatSelectionParameters::EMatchUri))

   631 	 || (iRequiredRecordFormatSupport && (iRequiredRecordFormatSupport->MatchDataType() == CMMFFormatSelectionParameters::EMatchUri)))

   632 		{

   633 		needToPlaceInUriPriorityOrder = ETrue;

   634 		}

   635 	

   636 	switch (PreferredSupplierMatchType())

   637 		{

   638 	case ENoPreferredSupplierMatch:

   639 		// No match, so suitable.

   640 		pluginSuitable = ETrue;

   641 	    break;

   642 	case EPreferredSupplierPluginsFirstInList:

   643 		pluginSuitable = ETrue;

   644 		if (aPlugin.SupportsSupplier(PreferredSupplier()))

   645 			needToPlaceInVersionOrder = ETrue;

   646 		break;

   647 	case EOnlyPreferredSupplierPluginsReturned:

   648 		if (aPlugin.SupportsSupplier(PreferredSupplier()))

   649 			{

   650 			pluginSuitable = ETrue;

   651 			needToPlaceInVersionOrder = ETrue;

   652 			}

   653 		break;

   654 	default:

   655 		User::Leave(KErrNotSupported);

   656 		}

   657 

   658 	TInt arrayPos;

   659 			

   660 	if (!pluginSuitable)

   661 		{

   662 		arrayPos = -1;

   663 		}

   664 		

   665 	else

   666 		{

   667 		if(needToPlaceInUriPriorityOrder)

   668 			{

   669 			arrayPos = aImplementations.Count();

   670 			// Cycle through aImplementations to find the first plugin with a uri priority LOWER than aPlugin's

   671 			for (TInt i=0; i<aImplementations.Count(); i++)

   672 				{

   673 				CMMFControllerImplementationInformation* c = aImplementations[i];

   674 				

   675 				if(PreferredSupplierMatchType() == ENoPreferredSupplierMatch) //case 1

   676 					{

   677 					/**

   678 					Place the plugin based on its Uri priority.

   679 					Arrange the plugins in Decreasing order of their priority. In case if two or more plugins 

   680 					have similar priority, append the next one at the end. 

   681 					*/

   682 					if (c->UriPriority() < aPlugin.UriPriority())

   683 						{

   684 						arrayPos = i;//plugin will be inserted before c in the array

   685 						break;

   686 						}

   687 					}

   688 				else

   689 					{

   690 					if(!needToPlaceInVersionOrder)  //case 2

   691 						{

   692 						/**

   693 						This reflects the case EPreferredSupplierPluginsFirstInList and 

   694 						aPlugin supplier not matching.

   695 						Place the plugin based on its Uri Priority after the required suppliers plugin.

   696 						If priority is equal, new plugin will be placed last.

   697 						*/

   698 						if( (c->Supplier() != PreferredSupplier()) && (c->UriPriority() < aPlugin.UriPriority()))

   699 							{

   700 							arrayPos = i;//plugin will be inserted before c in the array

   701 							break;

   702 							}

   703 						}

   704 					else  //case 3

   705 						{

   706 						/** 

   707 						This reflects the case where 

   708 						Supplier matches and EPreferredSupplierPluginsFirstInList is specified.

   709 						OR

   710 						Supplier matches and EOnlyPreferredSupplierPluginsReturned is specified.

   711 						*/

   712 						if(c->Supplier() == PreferredSupplier()) 

   713 							{

   714 							if(c->UriPriority() == aPlugin.UriPriority())

   715 								{

   716 								if(c->Version() <= aPlugin.Version())

   717 									{

   718 									arrayPos = i;//plugin will be inserted before c in the array

   719 									break;

   720 									}

   721 								}

   722 							else 

   723 								{

   724 								if(c->UriPriority() < aPlugin.UriPriority())

   725 									{

   726 									arrayPos = i;//plugin will be inserted before c in the array

   727 									break;

   728 									}

   729 								}

   730 							}

   731 						else

   732 							{

   733 							/**

   734 							This is a case of aImplementations now having unpreferred suppliers 

   735 							when EPreferredSupplierPluginsFirstInList is specified and aPlugin is

   736 							of preferred supplier but least priority.

   737 							*/

   738 							arrayPos = i;//plugin will be inserted before c in the array

   739 							break;

   740 							}

   741 						}

   742 					}

   743 				}

   744 			}

   745 			

   746 		else

   747 			{

   748 			if (!needToPlaceInVersionOrder)  

   749 				{

   750 				/**

   751 				place it at the end.

   752 				*/

   753 				arrayPos = aImplementations.Count();

   754 				}

   755 			else

   756 				{

   757 				// Insert the plugin at the beginning of the array, in version order if possible.

   758 				// Make an assumption: if we've been asked for format support, then only plugins 

   759 				// that support the same format will be in the array - so ordering them by version

   760 				// will be meaningful.  Otherwise, there's no point.

   761 				if ((iRequiredPlayFormatSupport && (iRequiredPlayFormatSupport->MatchDataType() != CMMFFormatSelectionParameters::EMatchAny))

   762 					|| (iRequiredRecordFormatSupport && (iRequiredRecordFormatSupport->MatchDataType() != CMMFFormatSelectionParameters::EMatchAny)))

   763 					{

   764 					// Put the plugin in version order at the beginning of the list

   765 

   766 					// Set aArrayPos to the end of the array in case this plugin has the lowest version number

   767 					arrayPos = aImplementations.Count();

   768 					// Cycle through aImplementations to find the first plugin with a version number LOWER than aPlugin

   769 					for (TInt i=0; i<aImplementations.Count(); i++)

   770 						{

   771 						CMMFControllerImplementationInformation* c = aImplementations[i];

   772 						if (c->Supplier() == aPlugin.Supplier())

   773 							{

   774 							if (c->Version() <= aPlugin.Version())

   775 								{

   776 								arrayPos = i;//plugin will be inserted before c in the array

   777 								break;

   778 								}

   779 							}

   780 						else

   781 							{

   782 							arrayPos = i; //c has wrong supplier so this plugin must go before c

   783 							break;

   784 							}

   785 						}

   786 					}

   787 				else

   788 					{

   789 					// We can't use the version numbers meaningfully, so just put this plugin

   790 					// at the top of the list.

   791 					arrayPos = 0;

   792 					}

   793 				}

   794 			}

   795 		}

   796 	

   797 	return arrayPos;

   798 	}

   799 

   800 TBool CMMFControllerPluginSelectionParameters::CheckFormatSupportL(CMMFFormatSelectionParameters* aSelectParams, const RMMFFormatImplInfoArray& aFormats) const

   801 	{

   802 	// If aSelectParams are NULL (ie none were set) then the plugin must be suitable!

   803 	if (aSelectParams == NULL)

   804 		return ETrue;

   805 

   806 	TBool suitable = EFalse;

   807 

   808 	// Check all the formats in aFormats.  If any support the required data type, return ETrue.

   809 	TInt index;

   810 	switch (aSelectParams->MatchDataType())

   811 		{

   812 	case CMMFFormatSelectionParameters::EMatchAny:

   813 		// All plugins intrinsically match this!

   814 		suitable = ETrue;

   815 		break;

   816 	case CMMFFormatSelectionParameters::EMatchFileExtension:

   817 		for (index=0;index<aFormats.Count();index++)

   818 			{

   819 			if (aFormats[index]->SupportsFileExtension(aSelectParams->MatchData()))

   820 				{

   821 				suitable = ETrue;

   822 				break;

   823 				}

   824 			}

   825 		break;

   826 	case CMMFFormatSelectionParameters::EMatchMimeType:

   827 		for (index=0;index<aFormats.Count();index++)

   828 			{

   829 			if (aFormats[index]->SupportsMimeType(aSelectParams->MatchData()))

   830 				{

   831 				suitable = ETrue;

   832 				break;

   833 				}

   834 			}

   835 		break;

   836 	case CMMFFormatSelectionParameters::EMatchHeaderData:

   837 		for (index=0;index<aFormats.Count();index++)

   838 			{

   839 			if (aFormats[index]->SupportsHeaderDataL(aSelectParams->MatchData()))

   840 				{

   841 				suitable = ETrue;

   842 				break;

   843 				}

   844 			}

   845 		break;

   846 		

   847 	case CMMFFormatSelectionParameters::EMatchUri:

   848 		{

   849 		suitable = ETrue; //if uri match specifically looked , then that has been already matched in a CheckUriSupport()

   850 		break;	

   851 		}

   852 		

   853 

   854 	default:

   855 		User::Leave(KErrNotSupported);

   856 		};

   857 

   858 	return suitable;

   859 	}

   860 

   861 

   862 

   863 EXPORT_C CMMFControllerSecureDrmPluginSelectionParameters* CMMFControllerSecureDrmPluginSelectionParameters::NewL()

   864 	{

   865 	CMMFControllerSecureDrmPluginSelectionParameters* s = CMMFControllerSecureDrmPluginSelectionParameters::NewLC();

   866 	CleanupStack::Pop(s);

   867 	return s;	

   868 	}

   869 

   870 EXPORT_C CMMFControllerSecureDrmPluginSelectionParameters* CMMFControllerSecureDrmPluginSelectionParameters::NewLC()

   871 	{

   872 	CMMFControllerSecureDrmPluginSelectionParameters* s = new(ELeave) CMMFControllerSecureDrmPluginSelectionParameters;

   873 	CleanupStack::PushL(s);

   874 	return s;

   875 	}

   876 

   877 CMMFControllerSecureDrmPluginSelectionParameters::CMMFControllerSecureDrmPluginSelectionParameters() :

   878 	CMMFControllerPluginSelectionParameters()

   879 	{

   880 	}

   881 

   882 EXPORT_C void CMMFControllerSecureDrmPluginSelectionParameters::ListImplementationsL(RMMFControllerImplInfoArray& aImplementations) const

   883 	{

   884 	CMMFControllerPluginSelectionParameters::ListImplementationsL(aImplementations);

   885 	TInt pluginsCount = aImplementations.Count();

   886 	for (TInt i = pluginsCount - 1; i >= 0; i--)

   887 		{

   888 		CMMFControllerImplementationInformation* c = aImplementations[i];

   889 		if (!c->SupportsSecureDRMProcessMode())

   890 			{

   891 			aImplementations.Remove(i);

   892 			delete c;

   893 			}

   894 		}

   895 	aImplementations.Compress();

   896 	}

   897 

   898 

   899 

   900 CMMFFormatPluginSelectionParameters::CMMFFormatPluginSelectionParameters(TUid aInterfaceUid) :

   901 	CMMFPluginSelectionParameters(aInterfaceUid)

   902 	{

   903 	}

   904 

   905 CMMFFormatPluginSelectionParameters::~CMMFFormatPluginSelectionParameters()

   906 	{

   907 	delete iRequiredFormatSupport;

   908 	}

   909 

   910 EXPORT_C void CMMFFormatPluginSelectionParameters::SetRequiredFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport)

   911 	{

   912 	delete iRequiredFormatSupport;

   913 	iRequiredFormatSupport = NULL;

   914 	iRequiredFormatSupport = CMMFFormatSelectionParameters::NewL(aRequiredSupport);

   915 	}

   916 

   917 EXPORT_C void CMMFFormatPluginSelectionParameters::ListImplementationsL(RMMFFormatImplInfoArray& aImplementations) const

   918 	{

   919 	aImplementations.ResetAndDestroy();

   920 

   921 	RImplInfoPtrArray ecomArray;

   922 	CleanupResetAndDestroyPushL(ecomArray);

   923 

   924 	MmPluginUtils::FindImplementationsL(InterfaceUid(), ecomArray);

   925 

   926 

   927 	TInt index;

   928 	// Create Format Implementation Information for each entry

   929 	for (index=0; index<ecomArray.Count(); index++)

   930 		{

   931 		CMMFFormatImplementationInformation* c = NULL;

   932 		TRAPD(error, c = CMMFFormatImplementationInformation::NewL(*(ecomArray[index])));

   933 

   934 		if (error == KErrNone)

   935 			{

   936 			CleanupStack::PushL(c);

   937 			// Find out whether this format matches the client's requirements...

   938 			TInt arrayPos;

   939 			MatchImplementationToSelectParamsL(aImplementations, *c, arrayPos);

   940 			if (arrayPos >=0)

   941 				{

   942 				// This plugin is suitable - insert it into the array at the suggested position

   943 				User::LeaveIfError(aImplementations.Insert(c, arrayPos));

   944 				CleanupStack::Pop(c);

   945 				}

   946 			else

   947 				{

   948 				// This plugin isn't suitable so just destroy it

   949 				CleanupStack::PopAndDestroy(c);

   950 				}

   951 			}

   952 		else if (error != KErrCorrupt)

   953 			{

   954 			// Ignore the plugin if it is corrupt.  Otherwise, leave.

   955 			// if error !=KErrNone, c hasn't been constructed so it is safe to leave

   956 			User::Leave(error);

   957 			}

   958 		}

   959 

   960 	CleanupStack::PopAndDestroy();//ecomArray

   961 	}

   962 

   963 void CMMFFormatPluginSelectionParameters::MatchImplementationToSelectParamsL(RMMFFormatImplInfoArray& aImplementations, const CMMFFormatImplementationInformation& aPlugin, TInt& aArrayPos) const

   964 	{

   965 	TBool suitable = EFalse;

   966 

   967 	// First, check whether the plugin supports the required play formats

   968 	suitable = CheckFormatSupportL(aPlugin);

   969 

   970 	// Next, check for correct media id support

   971 	if (suitable)

   972 		suitable = CheckMediaIdSupportL(aPlugin);

   973 

   974 	// Finally, calculate the position the plugin should take in aImplementations depending on the preferred supplier and version number.

   975 	if (suitable)

   976 		aArrayPos = CheckPreferredSupplierL(aImplementations, aPlugin);

   977 	else

   978 		aArrayPos = -1;

   979 	}

   980 

   981 TInt CMMFFormatPluginSelectionParameters::CheckPreferredSupplierL(RMMFFormatImplInfoArray& aImplementations, const CMMFFormatImplementationInformation& aPlugin) const

   982 	{

   983 	// Set the return value to indicated the plugin is not suitable.

   984 	TBool pluginSuitable = EFalse;

   985 	TBool needToPlaceInVersionOrder = EFalse;

   986 

   987 	switch (PreferredSupplierMatchType())

   988 		{

   989 	case ENoPreferredSupplierMatch:

   990 		// No match, so suitable.

   991 		pluginSuitable = ETrue;

   992 		break;

   993 	case EPreferredSupplierPluginsFirstInList:

   994 		pluginSuitable = ETrue;

   995 		if (aPlugin.SupportsSupplier(PreferredSupplier()))

   996 			needToPlaceInVersionOrder = ETrue;

   997 		break;

   998 	case EOnlyPreferredSupplierPluginsReturned:

   999 		if (aPlugin.SupportsSupplier(PreferredSupplier()))

  1000 			{

  1001 			pluginSuitable = ETrue;

  1002 			needToPlaceInVersionOrder = ETrue;

  1003 			}

  1004 		break;

  1005 	default:

  1006 		User::Leave(KErrNotSupported);

  1007 		}

  1008 

  1009 

  1010 	TInt arrayPos;

  1011 

  1012 	if (!pluginSuitable)

  1013 		{

  1014 		arrayPos = -1;

  1015 		}

  1016 	else

  1017 		{

  1018 		if (!needToPlaceInVersionOrder)

  1019 			{

  1020 			arrayPos = aImplementations.Count();

  1021 			}

  1022 		else

  1023 			{

  1024 			// Insert the plugin at the beginning of the array, in version order if possible.

  1025 			// Make an assumption: if we've been asked for format support, then only plugins 

  1026 			// that support the same format will be in the array - so ordering them by version

  1027 			// will be meaningful.  Otherwise, there's no point.

  1028 			if (iRequiredFormatSupport && (iRequiredFormatSupport->MatchDataType() != CMMFFormatSelectionParameters::EMatchAny))

  1029 				{

  1030 				// Put the plugin in version order at the beginning of the list

  1031 

  1032 				// Set aArrayPos to the end of the array in case this plugin has the lowest version number

  1033 				arrayPos = aImplementations.Count();

  1034 				// Cycle through aImplementations to find the first plugin with a version number LOWER than aPlugin

  1035 				for (TInt i=0; i<aImplementations.Count(); i++)

  1036 					{

  1037 					CMMFFormatImplementationInformation* c = aImplementations[i];

  1038 					if ((c->Supplier() == aPlugin.Supplier())

  1039 						&& (c->Version() <= aPlugin.Version()))

  1040 						{

  1041 						arrayPos = i;//plugin will be inserted before c in the array

  1042 						break;

  1043 						}

  1044 					}

  1045 				}

  1046 			else

  1047 				{

  1048 				// We can't use the version numbers meaningfully, so just put this plugin

  1049 				// at the top of the list.

  1050 				arrayPos = 0;

  1051 				}

  1052 			}

  1053 		}

  1054 	return arrayPos;

  1055 	}

  1056 

  1057 TBool CMMFFormatPluginSelectionParameters::CheckFormatSupportL(const CMMFFormatImplementationInformation& aPlugin) const

  1058 	{

  1059 	// If iRequiredFormatSupport is NULL (ie no requirements set) then the plugin must be suitable!

  1060 	if (iRequiredFormatSupport == NULL)

  1061 		return ETrue;

  1062 

  1063 	TBool suitable = EFalse;

  1064 

  1065 	switch (iRequiredFormatSupport->MatchDataType())

  1066 		{

  1067 	case CMMFFormatSelectionParameters::EMatchAny:

  1068 		suitable = ETrue;

  1069 		break;

  1070 	case CMMFFormatSelectionParameters::EMatchFileExtension:

  1071 		if (aPlugin.SupportsFileExtension(iRequiredFormatSupport->MatchData()))

  1072 			suitable = ETrue;

  1073 		break;

  1074 	case CMMFFormatSelectionParameters::EMatchMimeType:

  1075 		if (aPlugin.SupportsMimeType(iRequiredFormatSupport->MatchData()))

  1076 			suitable = ETrue;

  1077 		break;

  1078 	case CMMFFormatSelectionParameters::EMatchHeaderData:

  1079 		if (aPlugin.SupportsHeaderDataL(iRequiredFormatSupport->MatchData()))

  1080 			suitable = ETrue;

  1081 		break;

  1082 	default:

  1083 		User::Leave(KErrNotSupported);

  1084 		};

  1085 

  1086 	return suitable;

  1087 	}

  1088 

  1089 

  1090 EXPORT_C CMMFFormatEncodePluginSelectionParameters* CMMFFormatEncodePluginSelectionParameters::NewL()

  1091 	{

  1092 	CMMFFormatEncodePluginSelectionParameters* s = CMMFFormatEncodePluginSelectionParameters::NewLC();

  1093 	CleanupStack::Pop(s);

  1094 	return s;

  1095 	}

  1096 

  1097 EXPORT_C CMMFFormatEncodePluginSelectionParameters* CMMFFormatEncodePluginSelectionParameters::NewLC()

  1098 	{

  1099 	CMMFFormatEncodePluginSelectionParameters* s = new(ELeave) CMMFFormatEncodePluginSelectionParameters;

  1100 	CleanupStack::PushL(s);

  1101 	return s;

  1102 	}

  1103 

  1104 CMMFFormatEncodePluginSelectionParameters::CMMFFormatEncodePluginSelectionParameters() :

  1105 	CMMFFormatPluginSelectionParameters(KUidInterfaceFormatEncode)

  1106 	{

  1107 	}

  1108 

  1109 

  1110 EXPORT_C CMMFFormatDecodePluginSelectionParameters* CMMFFormatDecodePluginSelectionParameters::NewL()

  1111 	{

  1112 	CMMFFormatDecodePluginSelectionParameters* s = CMMFFormatDecodePluginSelectionParameters::NewLC();

  1113 	CleanupStack::Pop(s);

  1114 	return s;

  1115 	}

  1116 

  1117 EXPORT_C CMMFFormatDecodePluginSelectionParameters* CMMFFormatDecodePluginSelectionParameters::NewLC()

  1118 	{

  1119 	CMMFFormatDecodePluginSelectionParameters* s = new(ELeave) CMMFFormatDecodePluginSelectionParameters;

  1120 	CleanupStack::PushL(s);

  1121 	return s;

  1122 	}

  1123 

  1124 CMMFFormatDecodePluginSelectionParameters::CMMFFormatDecodePluginSelectionParameters() :

  1125 	CMMFFormatPluginSelectionParameters(KUidInterfaceFormatDecode)

  1126 	{

  1127 	}

  1128 

  1129 

  1130 

  1131 

  1132 

  1133 void TaggedDataParser::ParseTaggedDataL(const TDesC8& aData, MTaggedDataParserClient& aClient)

  1134 	{

  1135 	TPtrC8 data(aData);