void CPostProcessorInfo::ConstructL(const TDesC& aManufacturer,
const TDesC& aIdentifier,
const TArray<TUncompressedVideoFormat>& aSupportedFormats,
const TArray<TUint32>& aSupportedCombinations,
const TArray<TScaleFactor>& aSupportedScaleFactors,
const TDesC8& aImplementationSpecificInfo)
{
iManufacturer = aManufacturer.AllocL();
iIdentifier = aIdentifier.AllocL();
iImplementationSpecificInfo = aImplementationSpecificInfo.AllocL();
TInt i=0;
TInt supportedFormatsCount = aSupportedFormats.Count();
for (i=0; i<supportedFormatsCount; i++)
{
User::LeaveIfError(iSupportedFormats.Append(aSupportedFormats[i]));
}
TInt supportedCombinationsCount = aSupportedCombinations.Count();
for (i=0; i<supportedCombinationsCount; i++)
{
User::LeaveIfError(iSupportedCombinations.Append(aSupportedCombinations[i]));
}
TInt supportedScaleFactors = aSupportedScaleFactors.Count();
for (i=0; i<supportedScaleFactors; i++)
{
User::LeaveIfError(iSupportedScaleFactors.Append(aSupportedScaleFactors[i]));
}
}
void CVideoDecoderInfo::ConstructL(const TDesC& aManufacturer,
const TDesC& aIdentifier,
const TArray<CCompressedVideoFormat*>& aSupportedFormats,
const TArray<TPictureRateAndSize>& aMaxPictureRates,
const TDesC8& aCodingStandardSpecificInfo,
const TDesC8& aImplementationSpecificInfo)
{
iManufacturer = aManufacturer.AllocL();
iIdentifier = aIdentifier.AllocL();
iCodingStandardSpecificInfo = aCodingStandardSpecificInfo.AllocL();
iImplementationSpecificInfo = aImplementationSpecificInfo.AllocL();
TInt i=0;
TInt count = aSupportedFormats.Count();
for (i=0; i<count; i++)
{
CCompressedVideoFormat* f = CCompressedVideoFormat::NewL(*(aSupportedFormats[i]));
CleanupStack::PushL(f);
User::LeaveIfError(iSupportedFormats.Append(f));
CleanupStack::Pop(f);
}
count = aMaxPictureRates.Count();
for (i=0; i<count; i++)
{
User::LeaveIfError(iMaxPictureRates.Append(aMaxPictureRates[i]));
}
}
// ----------------------------------------------------------------------------------------------------------
// Find the items matching the media specifications
// ----------------------------------------------------------------------------------------------------------
//
void CTestCollectionPlugin::FindAllL(const CMPXMedia& aCriteria, const TArray<TMPXAttribute>& aAttrs)
{
LOG1(_L("CTestCollectionPlugin::FindAllL"));
const TDesC& title = aCriteria.ValueText( KMPXMediaGeneralTitle );
if(title == _L("CollectionPluginTest0128") ||
title == _L("CollectionPluginTest0129") )
{
// Return exact copy
CMPXMedia* media = CMPXMedia::NewL();
(*media) = aCriteria;
CleanupStack::PushL( media );
media->SetTObjectValueL<TInt>(KMPXMediaGeneralSize, aAttrs.Count());
iObs->HandleFindAll(media, KErrNone);
CleanupStack::PopAndDestroy( media );
}
else if(title == _L("CollectionPluginTest0130") )
{
// Return error
CMPXMedia* media = CMPXMedia::NewL();
(*media) = aCriteria;
CleanupStack::PushL( media );
media->SetTObjectValueL<TInt>(KMPXMediaGeneralSize, aAttrs.Count());
iObs->HandleFindAll(media, KErrArgument);
CleanupStack::PopAndDestroy( media );
}
else
{
User::Panic(_L("CTestCollectionPlugin::FindAllL panic"), 1); // magic number
}
}
// -----------------------------------------------------------------------------
// MakeSortingItemsL
// Add/Make items to sorting item array and undefined items to
// undefined item array
// -----------------------------------------------------------------------------
//
void MakeSortingItemsL( RArray<TCLFSortingItem>& aSortingItemArray,
RPointerArray<MCLFItem>& aUndefinedItemArray,
const TArray<MCLFItem*>& aItemArray,
const TArray<TCLFFieldId> aSortFields,
TCLFItemDataType aSortingDataType )
{
const TInt sortingFieldsCount( aSortFields.Count() );
const TInt count( aItemArray.Count() );
for( TInt i = 0 ; i < count ; ++i )
{
MCLFItem* seItem = aItemArray[i];
TCLFSortingItem sortingItem;
TInt fieldIdIndex( -1 );
TInt error( KErrNone );
do
{
++fieldIdIndex;
TCLFFieldId fieldId( aSortFields[fieldIdIndex] );
switch( aSortingDataType )
{
case ECLFItemDataTypeDesC:
{
error = seItem->GetField( fieldId, sortingItem.iData );
break;
}
case ECLFItemDataTypeTInt32:
{
error = seItem->GetField( fieldId, sortingItem.iIntData );
break;
}
case ECLFItemDataTypeTTime:
default:
{
error = seItem->GetField( fieldId, sortingItem.iTimeData );
break;
}
}
} while( ( error != KErrNone ) &&
( fieldIdIndex < ( sortingFieldsCount - 1 ) ) );
if( error == KErrNone )
{
sortingItem.iItem = seItem;
aSortingItemArray.AppendL( sortingItem );
}
else
{ // field not found -> undefined item
aUndefinedItemArray.AppendL( seItem );
}
}
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void CMnrpNaviControl::HandleModelUpdateL()
{
TArray< CMnrpNaviModel::CListItem* > items = iModel->ListItemsL();
const TInt KGranularity = 8;
CDesCArraySeg* array = new (ELeave) CDesCArraySeg( KGranularity );
CleanupStack::PushL( array );
_LIT( KItemFormat, "%S\t%S\t\t" );
for ( TInt i = 0; i < items.Count(); i++ )
{
CMnrpNaviModel::CListItem* item = items[i];
const TInt KNumTabsAndOther = 10;
HBufC* text = HBufC::NewLC(
item->Header().Length() + item->Value().Length() + KNumTabsAndOther);
text->Des().Format( KItemFormat, &(item->Header()), &(item->Value()) );
array->AppendL( *text );
CleanupStack::PopAndDestroy( text );
}
CleanupStack::Pop( array );
CTextListBoxModel* model = iListBox->Model();
model->SetItemTextArray( array );
model->SetOwnershipType( ELbmOwnsItemArray );
iListBox->HandleItemAdditionL();
}
// ---------------------------------------------------------------------------
// CXIMPContextEventFilter::CombineFilterL()
// ---------------------------------------------------------------------------
//
void CXIMPContextEventFilter::CombineFilterL(
const TArray< CXIMPContextEventFilter* >& aFilters )
{
const TInt filterCount = aFilters.Count();
CArrayFix< TInt32 >* combinedEvents = new (ELeave) CArrayFixFlat< TInt32 >( KXIMPEventListGranurality );
CleanupStack::PushL( combinedEvents );
for( TInt ix = 0; ix < filterCount; ix++ )
{
const CXIMPContextEventFilter* sourceFilter = aFilters[ ix ];
if( sourceFilter->iAcceptedEvents )
{
CopyUniqueEventsL( sourceFilter->iAcceptedEvents->Array(),
*combinedEvents );
}
else
{
//Set all accepted
delete combinedEvents;
combinedEvents = NULL;
break;
}
}
delete iAcceptedEvents;
iAcceptedEvents = combinedEvents;
CleanupStack::Pop(); //combinedEvents
}
// -----------------------------------------------------------------------------
// CTelephonyAudioRoutingProxy::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CTelephonyAudioRoutingProxy::ConstructL()
{
TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingProxy[%x]::ConstructL"),this);
User::LeaveIfError(iSession.ConnectL(*this, iObserver));
// Make sure session is set up with default values from server for its local variables:
iSession.GetDefaultValuesL();
CTelephonyAudioRouting::TAudioOutput audioOutput = Output();
// Get stored values for audio output and array and store values in local variables:
TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingProxy::ConstructL, current iAudioOutput retrieved from server: %d"), audioOutput);
TArray<CTelephonyAudioRouting::TAudioOutput> availableOutputArray = AvailableOutputs();
TInt count = availableOutputArray.Count();
TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t ConstructL: Count = %d "), count);
for(TInt i = 0; i < count; i++)
{
TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t ConstructL: availableOutputs[i] = %d "),availableOutputArray[i]);
}
iSession.NotifyIfOutputChanged();
iSession.NotifyIfAvailableOutputsChanged();
}
// ----------------------------------------------------------------------------------------------------------
// Add specify attribute to Media
// ----------------------------------------------------------------------------------------------------------
//
void CTestCollectionPlugin::AddAttrbuteL(CMPXMedia& aMedia,
const TInt aId,
const TDesC& aTitle,
const TDesC& aUri,
const TArray<TMPXAttribute>& aAttrs)
{
TInt attrCnt = aAttrs.Count();
for(TInt i = 0; i < attrCnt; i++)
{
if(aAttrs[i].ContentId() == KMPXMediaIdGeneral)
{
TInt attrId = aAttrs[i].AttributeId();
if(attrId & EMPXMediaGeneralId)
{
aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, aId);
}
if(attrId & EMPXMediaGeneralTitle)
{
aMedia.SetTextValueL(KMPXMediaGeneralTitle, aTitle);
}
if(attrId & EMPXMediaGeneralUri)
{
aMedia.SetTextValueL(KMPXMediaGeneralUri, aUri);
}
}
}
}
void T_MProfile::GetAlertForTestL()
{
__UHEAP_MARK;
TArray<TContactItemId> array = iProfile->AlertForL();
__UHEAP_MARKEND;
EUNIT_ASSERT( array.Count() == 0 );
}
// -----------------------------------------------------------------------------
// AppendItemsArrayL
// -----------------------------------------------------------------------------
//
void AppendItemsToArrayL( const TArray<MCLFItem*>& aSourceArray,
RPointerArray<MCLFItem>& aDestArray )
{
for( TInt i = aSourceArray.Count() - 1; i >=0; i--)
{
aDestArray.AppendL( aSourceArray[ i ] );
}
}
// -----------------------------------------------------------------------------
// AppendSortingItemsArrayReverseL
// -----------------------------------------------------------------------------
//
void AppendSortingItemsToArrayReverseL(
const TArray<TCLFSortingItem>& aSourceArray,
RPointerArray<MCLFItem>& aDestArray )
{
for( TInt i = aSourceArray.Count() - 1 ; i > -1 ; --i )
{
aDestArray.AppendL( aSourceArray[i].iItem );
}
}
// -----------------------------------------------------------------------------
// AppendSortingItemsArrayL
// -----------------------------------------------------------------------------
//
void AppendSortingItemsToArrayL( const TArray<TCLFSortingItem>& aSourceArray,
RPointerArray<MCLFItem>& aDestArray )
{
const TInt count( aSourceArray.Count() );
for( TInt i = 0 ; i < count ; ++i )
{
aDestArray.AppendL( aSourceArray[i].iItem );
}
}
// ----------------------------------------------------------------------------
// Externalize an array of itemids to stream
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::ExternalizeL(const TArray<TMPXItemId>& aArray, RWriteStream& aStream)
{
TInt n=aArray.Count();
aStream.WriteInt32L(n);
for (TInt i=0;i<n;++i)
{
aStream.WriteUint32L(aArray[i].iId1);
aStream.WriteUint32L(aArray[i].iId2);
}
}
LOCAL_C void testReadAny(const TArray<TBufC<0x20> > anArray)
//
// Test with fixed length arrays.
//
{
test(anArray.Count()==KMaxStrings);
for (TInt i=0;i<KMaxStrings;i++)
test(anArray[i]==(*strSorted[i]));
}
// -----------------------------------------------------------------------------
// CAMMSEMCReverbEnvironmentalPresetUtility::GetPresetNamesL
// Gets list of preset names available.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
void CAMMSEMCReverbEnvironmentalPresetUtility::GetPresetNamesL(
CDesCArray& aPresetNames)
{
LOG( EJavaAMMS, EInfo, "AMMS::CAMMSEMCReverbEnvironmentalPresetUtility::GetPresetNamesL +");
TArray< TEfEnvironmentalReverbUtilityPreset > presetNames =
iEmptyEnvironmentalReverbUtility->Presets();
TInt presetCount = presetNames.Count();
for (TInt i = 0; i < presetCount; i++)
{
aPresetNames.AppendL(presetNames[ i ].iPresetName);
}
LOG( EJavaAMMS, EInfo, "AMMS::CAMMSEMCReverbEnvironmentalPresetUtility::GetPresetNamesL -");
}
// ----------------------------------------------------------------------------------------------------------
// Add specify attribute to Media specific for Playback framework
// test cases
// ----------------------------------------------------------------------------------------------------------
//
void CTestCollectionPlugin::AddAttributePlaybackFwTestL(CMPXMedia& aMedia,
const TInt aId,
const TArray<TMPXAttribute>& aAttrs)
{
TInt attrCnt = aAttrs.Count();
for(TInt i = 0; i < attrCnt; i++)
{
TInt attrId = aAttrs[i].AttributeId();
if(aAttrs[i].ContentId() == KMPXMediaIdGeneral)
{
if(attrId & EMPXMediaGeneralType)
{
AddAttributeGeneralTypeL(aMedia, aId);
}
if(attrId & EMPXMediaGeneralCategory)
{
AddAttributeGeneralCategoryL(aMedia, aId);
}
if(attrId & EMPXMediaGeneralDuration)
{
AddAttributeGeneralDurationL(aMedia, aId);
}
if(attrId & EMPXMediaGeneralLastPlaybackPosition)
{
AddAttributeGeneralLastPlaybackPositionL(aMedia, aId);
}
}
else if(aAttrs[i].ContentId() == KMPXMediaIdMusic)
{
if(attrId & EMPXMediaMusicArtist)
{
AddAttributeMusicArtistL(aMedia, aId);
}
}
else if(aAttrs[i].ContentId() == KMPXMediaIdDrm)
{
if(attrId & EMPXMediaDrmType)
{
AddAttributeDrmTypeL(aMedia, aId);
}
if(attrId & EMPXMediaDrmProtected)
{
AddAttributeDrmProtectedL(aMedia, aId);
}
if(attrId & EMPXMediaDrmRightsStatus)
{
AddAttributeDrmRightsStatusL(aMedia, aId);
}
}
}
}
// ----------------------------------------------------------------------------
// Compare two sorted arrays of uids
// ----------------------------------------------------------------------------
//
EXPORT_C TInt MPXUser::CompareOrderedUidArrays(
const TArray<TUid>& aArray1,
const TArray<TUid>& aArray2)
{
TInt ret(-1);
TInt count1 = aArray1.Count();
TInt count2 = aArray2.Count();
if (count1 >= count2)
{
TInt s1(0); // start point of array 1
TBool found(ETrue);
for (TInt i=0; i<count2 && found; ++i)
{
found = EFalse;
for (TInt j=s1; j<count1; ++j)
{
if (aArray1[j].iUid == aArray2[i].iUid)
{
s1=j+1; // compare from next item
found = ETrue;
break;
}
}
}
if (found)
{
if (count1==count2)
{
ret=0;
}
else
{
ret=1;
}
}
}
return ret;
}
// -----------------------------------------------------------------------------
// CAMMSEqualizerControl::PresetNamesL
// Gets the available preset names.
// -----------------------------------------------------------------------------
//
const CDesCArray& CAMMSEqualizerControl::PresetNamesL()
{
// Returns an array of all preset names (pre-defined and user-defined).
// The pre-defined presets are in the beginning of the list.
TArray< TEfAudioEqualizerUtilityPreset > presetNames =
iEqualizerUtility->Presets();
// Before appending the preset names, reset the member array
iPresetNames->Reset();
for (TInt i = 0; i < presetNames.Count(); i++)
{
iPresetNames->AppendL(presetNames[ i ].iPresetName);
}
return *iPresetNames;
}
// ---------------------------------------------------------------------------
// CXIMPContextEventFilter::CopyUniqueEventsL()
// ---------------------------------------------------------------------------
//
void CXIMPContextEventFilter::CopyUniqueEventsL(
const TArray< TInt32 >& aSource,
CArrayFix< TInt32 >& aTarget )
{
const TInt eventCount = aSource.Count();
for( TInt ix = 0; ix < eventCount; ix++ )
{
const TInt32 event = aSource[ ix ];
TInt pos;
if( !FindEventPosition( event, aTarget, pos ) )
{
aTarget.InsertL( pos, event );
}
}
}
// -----------------------------------------------------------------------------
// CCLFDefaultOperation::DoMusicAlbumGroupingL
// -----------------------------------------------------------------------------
//
void CCLFDefaultOperation::DoMusicAlbumGroupingL(
const TArray<MCLFItem*>& aSourceList,
RPointerArray<MCLFItem>& aGroupedList )
{
CleanupResetAndDestroyPushL( aGroupedList );
CDesCArray* tempAlbumNameArray =
new (ELeave) CDesCArraySeg( KCLFGroupedItemArrayGranularity );
CleanupStack::PushL( tempAlbumNameArray );
const TInt count( aSourceList.Count() );
for( TInt i = 0 ; i < count ; ++i )
{
const MCLFItem* item = aSourceList[i];
TPtrC albumName;
if( item->GetField( ECLFFieldIdAlbum, albumName ) == KErrNone )
{
TInt pos( 0 );
if( tempAlbumNameArray->FindIsq( albumName, pos ) )
{
// not found
tempAlbumNameArray->InsertIsqL( albumName );
// make new item
MCLFModifiableItem* newItem =
ContentListingFactory::NewModifiableItemLC();
newItem->AddFieldL( ECLFFieldIdAlbum, albumName );
iGroupedItemList.AppendL( newItem ); // takes ownership
CleanupStack::Pop(); // newItem
TPtrC artistName;
if( item->GetField( ECLFFieldIdArtist, artistName ) == KErrNone )
{
newItem->AddFieldL( ECLFFieldIdArtist, artistName );
}
// add new item to grouper list
aGroupedList.AppendL( newItem );
}
}
}
CleanupStack::PopAndDestroy( tempAlbumNameArray );
CleanupStack::Pop( &aGroupedList );
}
// -----------------------------------------------------------------------------
// AppendItemsToArrayL
// append aSourceArray items to aDestArray
// -----------------------------------------------------------------------------
//
void AppendItemsToArrayL( const TArray<MCLFItem*>& aSourceArray,
RPointerArray<MCLFItem>& aDestArray,
TCLFUndefinedItemPosition aPosition,
TInt& aItemIndex,
TInt& aLastAddedItemCount )
{
if( aPosition == ECLFSortingStyleUndefinedFirst )
{
aItemIndex = aItemIndex - aLastAddedItemCount;
}
aLastAddedItemCount = aSourceArray.Count();
for( TInt i = 0 ; i < aLastAddedItemCount ; ++i )
{
aDestArray.InsertL( aSourceArray[i], aItemIndex );
++aItemIndex;
}
}
void CGlxCollectionPluginAlbums::HandleCpiAttributeResponseL(CMPXMedia* aResponse, TArray<TMPXAttribute> aCpiAttributes, TArray<TGlxMediaId> aMediaIds)
{
TRACER("CGlxCollectionPluginAlbums::HandleCpiAttributeResponseL");
const TInt mediaIdCount = aMediaIds.Count();
switch (mediaIdCount)
{
case 0:
User::Leave(KErrNotSupported);
break;
case 1:
HandleCpiAttributeResponseL(aResponse, aCpiAttributes, aMediaIds[0]);
break;
default:
{
// We have an array of CMPXMedia items
if (TGlxMediaId(KGlxCollectionRootId) == aMediaIds[0])
{
User::Leave(KErrNotSupported);
}
CMPXMediaArray* mediaArray = aResponse->ValueCObjectL<CMPXMediaArray>(KMPXMediaArrayContents);
CleanupStack::PushL(mediaArray);
const TInt arrayCount = mediaArray->Count();
// Sanity check
if (arrayCount != mediaIdCount)
{
User::Leave(KErrArgument);
}
for (TInt index = 0; index < arrayCount; index++)
{
HandleCpiAttributeResponseL((*mediaArray)[index], aCpiAttributes, aMediaIds[index]);
}
aResponse->SetCObjectValueL(KMPXMediaArrayContents, mediaArray);
CleanupStack::PopAndDestroy(mediaArray);
}
break;
}
}
TBool CTelephonyAudioRoutingProxy::ValidateOutputRequest(TAudioOutput aOutput)
{
TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingProxy[%x]::ValidateOutputRequest"),this);
TELAUDRTNG_RDEBUG1(_L("[TELAUDRTNG]\t CTelephonyAudioRoutingProxy::ValidateOutputRequest for: %d"),aOutput);
TArray<CTelephonyAudioRouting::TAudioOutput> availableOutputs = (iSession.AvailableOutputs()).Array();
TBool found = EFalse;
TInt count = availableOutputs.Count();
for(TInt i = 0; i < count; i++)
{
if (aOutput == availableOutputs[i])
{
found = ETrue;
break;
}
}
return found;
}
// -----------------------------------------------------------------------------
TInt TsEntryKeyGeneraror::Generate(TTsEntryKey& returnKey, TInt windowGroupId,
const TArray<RWsSession::TWindowGroupChainInfo>& groupChain)
{
for (TInt iter(0); iter < groupChain.Count(); ++iter) {
if (groupChain[iter].iId == windowGroupId) {
returnKey = TTsEntryKey(windowGroupId);
if (groupChain[iter].iId == groupChain[iter].iParentId) {
return KErrBadHandle;
}
else if (0 >= groupChain[iter].iParentId) {
return KErrNone;
}
else {
return TsEntryKeyGeneraror::Generate(returnKey, groupChain[iter].iParentId, groupChain);
}
}
}
return KErrNotFound;
}
/**
Helper function to run a command and test the expected results
*/
void CCmdTestMultipleWait::CreateCmdAndExecuteL(TArray<TDeferredCmdConfiguration> aDeferredCmds, TInt aExpectedErr, TBool aCancel, TInt32 aMultipleWaitTimeout)
{
iTestList = CCmdTestList::NewL(StopSchedulerCallBack, this);
// add all deferred commands
TInt count = aDeferredCmds.Count();
for (TInt i = 0; i < count; i++)
{
AddDeferredCommandsInListL(aDeferredCmds[i]);
}
iTestList->AddMultipleWaitCommandL(aMultipleWaitTimeout);
if (aCancel)
{
CreateCancelOnCommands(iTestList);
}
StartScheduler();
TInt err = iTestList->Errorcode();
INFO_PRINTF3(_L("Test completed with err : %d. expected err : %d"), err, aExpectedErr);
TEST(err == aExpectedErr);
Reset();
}
// -----------------------------------------------------------------------------
// PopulateMediaWithItemL
// -----------------------------------------------------------------------------
TInt CGlxMediaListsTestCollectionPlugin::PopulateMediaWithItemL(CMPXMedia*& aMedia, const CItem* aItem, const TArray<TMPXAttribute>& aAttrs)
{
TInt bitmapHandle(0);
if ( aItem )
{
for ( TInt i = 0; i < aAttrs.Count(); i++ )
{
if ( aAttrs[i] == KMPXMediaGeneralId )
{
aMedia->SetTObjectValueL(KMPXMediaGeneralId, aItem->iId);
}
else if ( aAttrs[i] == KMPXMediaGeneralUri )
{
aMedia->SetTextValueL(KMPXMediaGeneralUri, *aItem->iFilename);
}
else if ( aAttrs[i] == KMPXMediaGeneralTitle )
{
aMedia->SetTextValueL(KMPXMediaGeneralTitle, *aItem->iTitle);
}
else if ( aAttrs[i] == KMPXMediaGeneralDate )
{
aMedia->SetTObjectValueL(KMPXMediaGeneralDate, aItem->iDateTime);
}
else if ( aAttrs[i] == KMPXMediaGeneralSize )
{
aMedia->SetTObjectValueL(KMPXMediaGeneralSize, aItem->iFileSize);
}
else if ( aAttrs[i] == KMPXMediaGeneralDrive )
{
aMedia->SetTextValueL(KMPXMediaGeneralDrive, *aItem->iDrive);
}
else if ( KGlxMediaIdBitmapHandle == aAttrs[i].ContentId() )
{
bitmapHandle = aAttrs[i].AttributeId();
}
}
}
return bitmapHandle;
}
// ----------------------------------------------------------------------------------------------------------
// Filter out media in aMediaArray which match aFilter
// ----------------------------------------------------------------------------------------------------------
//
void CTestCollectionPlugin::FilterMediaArray(CMPXMediaArray& aMediaArray, CMPXFilter* aFilter)
{
if(aFilter )
{
TArray<TMPXAttribute> filterAttr = aFilter->Attributes();
TInt arrCnt = aMediaArray.Count();
for(TInt i = arrCnt-1; i >= 0; i--) // Remove from the back
{
CMPXMedia* media = aMediaArray[i];
for(TInt ii = 0; ii < filterAttr.Count(); ii++)
{
TMPXAttribute attr = filterAttr[ii];
if( media->IsSupported( attr ) )
{
TBool match = EFalse;
if(attr == KMPXMediaGeneralId)
{
TInt filterId = *aFilter->Value<TInt>( attr );
TInt mediaId = *media->Value<TInt>( attr );
if(filterId == mediaId)
match = ETrue;
}
else if(attr == KMPXMediaGeneralTitle || attr == KMPXMediaGeneralUri)
{
const TDesC& filterText = aFilter->ValueText( attr );
const TDesC& mediaText = media->ValueText( attr );
if(filterText == mediaText)
match = ETrue;
}
if( match )
{
aMediaArray.Remove( i );
break;
}
}
}
}
}
}
// ----------------------------------------------------------------------------
// Group attributes belonging to one content into an item in the array
// ----------------------------------------------------------------------------
//
EXPORT_C void MPXUser::MergeAttributeL(
const TArray<TMPXAttribute>& aSrc,
RArray<TMPXAttribute>& aDest)
{
CleanupClosePushL(aDest);
aDest.Reset();
for (TInt i = 0; i < aSrc.Count(); i++)
{
const TMPXAttribute& s = aSrc[i];
TInt index = aDest.Find(s, TMPXAttribute::MatchContentId);
if ( KErrNotFound == index )
{
aDest.AppendL(s);
}
else
{
TMPXAttribute& d = aDest[index];
d = TMPXAttribute(d.ContentId(), d.AttributeId() | s.AttributeId());
}
}
CleanupStack::Pop();
}
// -----------------------------------------------------------------------------
// CMPXClientList::IsMsgSubscribedL
// -----------------------------------------------------------------------------
//
TBool CMPXClientList::IsMsgSubscribedL(TInt aIndex, const CMPXMessage* aMsg)
{
// check the subscriptions
TBool IsSubScribed(EFalse);
TInt subCount(iClients[aIndex]->iSubscriptions.Count());
if (subCount)
{
const CMPXMediaArray* subscriptionItems =
iClients[aIndex]->iSubscriptions[0]->ItemsL();
if (1==subCount && (0== subscriptionItems->Count()))
{// one empty subscription - send everything
IsSubScribed = ETrue;
}
else
{// have to check the message against the subscriptions.
MPX_ASSERT(aMsg);
const TArray<TMPXAttribute> msgAttrs = aMsg->Attributes();
TInt msgAttrCount(msgAttrs.Count());
// iterate subscriptions
for (TInt subIndex = 0; subIndex<subCount && !IsSubScribed; ++subIndex)
{
// iterate items for the current subscription
subscriptionItems =
iClients[aIndex]->iSubscriptions[subIndex]->ItemsL();
TInt itemCount(subscriptionItems->Count());
for (TInt itemIndex = 0; itemIndex < itemCount; ++itemIndex)
{
// check the message attributes for the current subscription item
TBool subMatch(ETrue);
TInt attrMatchCount(0);
CMPXSubscriptionItem* subItem(subscriptionItems->AtL(itemIndex));
for (TInt msgAttrIndex = 0; msgAttrIndex < msgAttrCount; ++msgAttrIndex)
{
TBool attrExists(EFalse);
TBool attrMatch(EFalse);
const TMPXAttribute& msgAttr( msgAttrs[msgAttrIndex] );
if ( subItem->IsSupported(msgAttr))
{
attrExists = ETrue;
if ( subItem->Match( *aMsg, msgAttr ))
{
attrMatch = ETrue;
attrMatchCount++;
}
}
if (attrExists && !attrMatch)
{
subMatch = EFalse;
break;
}
}
// send the message if all attributes that exist in both the message and the subscription
// have the same values and all subscription attributes match
if ( subMatch && ( attrMatchCount == subItem->Count()) )
{
IsSubScribed = ETrue;
break;
}
}
}
}
} // else subCount = 0, IsSubScribed = EFalse (default)
return IsSubScribed;
}
// ----------------------------------------------------------------------------
// Extended properties of the current file (async)
// ----------------------------------------------------------------------------
//
void CGlxMediaListsTestCollectionPlugin::MediaL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& aAttrs,
const TArray<TCapability>& /*aCaps*/,
CMPXAttributeSpecs* /*aSpecs*/)
{
__ASSERT_ALWAYS(!iMedia, Panic(EGlxPanicIllegalState));
TInt error = KErrNone;
CItem* item = NULL;
TInt bitmapHandle = 0;
RArray<TInt> supportedIds;
CleanupClosePushL(supportedIds);
iMedia = CMPXMedia::NewL(supportedIds.Array());
CleanupStack::PopAndDestroy(&supportedIds);
TArray<TInt> selection = aPath.Selection();
TInt selectionCount = selection.Count();
if (selectionCount > 1)
{
CMPXMediaArray* mediaArray = CMPXMediaArray::NewL();
CleanupStack::PushL(mediaArray);
for (TInt count = 0; count < selectionCount; ++count)
{
item = ItemL(aPath, selection[count]);
if (item)
{
RArray<TInt> supportedIds;
CleanupClosePushL(supportedIds);
CMPXMedia* media = CMPXMedia::NewL(supportedIds.Array());
CleanupStack::PopAndDestroy(&supportedIds);
CleanupStack::PushL(media);
(void)PopulateMediaWithItemL(media, item, aAttrs);
mediaArray->AppendL(*media);
CleanupStack::PopAndDestroy(media);
}
else
{
error = KErrNotFound;
break;
}
}
PopulateMediaWithArrayL(iMedia, mediaArray);
CleanupStack::PopAndDestroy(mediaArray);
}
else
{
item = ItemL(aPath, aPath.Index());
if (item)
{
bitmapHandle = PopulateMediaWithItemL(iMedia, item, aAttrs);
}
else
{
error = KErrNotFound;
}
}
if ( (KErrNone == error) && bitmapHandle )
{
// Get thumbnail for the item
TGlxThumbnailRequest request;
request.iId = item->iId;
request.iSizeClass = TSize(60, 45);
request.iPriorityMode = TGlxThumbnailRequest::EPrioritizeSpeed;
request.iBitmapHandle = bitmapHandle;
iThumbnailCreator->FetchThumbnailL(request, *this);
}
else
{
/*****************************************************
* Old synchronous code
******************************************************/
// No thumbnail requested - send response now
//iObs->HandleMedia(*iMedia, error);
//delete iMedia;
//iMedia = NULL;
/*****************************************************
* New Async Code. Instantiate callback mechanism
******************************************************/
AsyncNotifyL(iMedia, error, CGlxAsyncNotifier::EMedia);
}
}
