void CMTPGetDevicePropDesc::RunL()
{
OstTraceFunctionEntry0( CMTPGETDEVICEPROPDESC_RUNL_ENTRY );
if (iPropCode == EMTPDevicePropCodeBatteryLevel)
{
ServiceBatteryLevelL();
}
else
{
__DEBUG_ONLY(Panic(EMTPDevDpUnknownDeviceProperty));
}
OstTraceFunctionExit0( CMTPGETDEVICEPROPDESC_RUNL_EXIT );
}
// -----------------------------------------------------------------------------
// ItemL
// -----------------------------------------------------------------------------
CGlxMediaListsTestCollectionPlugin::CItem* CGlxMediaListsTestCollectionPlugin::ItemL(const CMPXCollectionPath& aPath, TInt aIndex) const
{
CItem* item = NULL;
TIdentityRelation<CItem> match(&MatchById);
if (aPath.Levels() == 3)
{
// Find item
CItem* mediaToCompare = new (ELeave) CItem();
CleanupStack::PushL(mediaToCompare);
mediaToCompare->iId = TGlxMediaId(aPath.IdOfIndex(aIndex));
TInt index = _iItemDBHackContent.Find(mediaToCompare, match);
CleanupStack::PopAndDestroy(mediaToCompare);
if (index != KErrNotFound)
{
item = _iItemDBHackContent[index];
__ASSERT_DEBUG(item != NULL, Panic(EGlxPanicLogicError));
}
}
else if (aPath.Levels() == 2)
{
// Find item
CItem* mediaToCompare = new (ELeave) CItem();
CleanupStack::PushL(mediaToCompare);
mediaToCompare->iId = TGlxMediaId(aPath.IdOfIndex(aIndex));
TInt index = _iItemDBHackAlbums.Find(mediaToCompare, match);
CleanupStack::PopAndDestroy(mediaToCompare);
if (index != KErrNotFound)
{
item = _iItemDBHackAlbums[index];
__ASSERT_DEBUG(item != NULL, Panic(EGlxPanicLogicError));
}
}
else if (aPath.Levels() == 1)
{
item = iSelf;
}
else
{
__DEBUG_ONLY(Panic(EGlxPanicDebugUnexpectedError));
User::Leave(KErrNotSupported);
}
return item;
}
// ----------------------------------------------------------------------------
// Navigates to the given path
// ----------------------------------------------------------------------------
//
void CGlxMediaListsTestCollectionPlugin::OpenL(const CMPXCollectionPath& aPath,
const TArray<TMPXAttribute>& /*aAttrs*/,
CMPXFilter* /*aFilter*/)
{
RArray<TInt> supportedIds;
CleanupClosePushL(supportedIds);
supportedIds.AppendL(KMPXMediaIdContainer);
supportedIds.AppendL(KMPXMediaIdGeneral);
iOpenEntries = CMPXMedia::NewL(supportedIds.Array());
CMPXMediaArray* array = CMPXMediaArray::NewL();
CleanupStack::PushL(array);
if ( aPath.Levels() == 1 )
{
TInt count = _iItemDBHackAlbums.Count();
for ( TInt i = 0; i < count; i++ )
{
AppendL(_iItemDBHackAlbums[i]->iId, *_iItemDBHackAlbums[i]->iTitle, *array, EMPXGroup, EMPXAlbum);
}
}
else if ( aPath.Levels() == 2 )
{
TInt count = _iItemDBHackContent.Count();
for ( TInt i = 0; i < count; i++ )
{
AppendL(_iItemDBHackContent[i]->iId, *_iItemDBHackContent[i]->iTitle, *array, EMPXItem, EMPXImage);
}
StartEvents();
}
else
{
__DEBUG_ONLY(Panic(EGlxPanicDebugUnexpectedError));
}
iOpenEntries->SetCObjectValueL(KMPXMediaArrayContents, array);
iOpenEntries->SetTObjectValueL(KMPXMediaArrayCount, array->Count());
CleanupStack::PopAndDestroy(array);
//iObs->HandleOpen(*iOpenEntries, KErrNone);
AsyncNotifyL(iOpenEntries, KErrNone, CGlxAsyncNotifier::EOpen);
CleanupStack::PopAndDestroy(&supportedIds);
}
void CMTPUsbEpControl::ReceiveDataCompleteL(TInt aError, MMTPType& aSink)
{
OstTraceFunctionEntry0( CMTPUSBEPCONTROL_RECEIVEDATACOMPLETEL_ENTRY );
OstTrace1( TRACE_NORMAL, CMTPUSBEPCONTROL_RECEIVEDATACOMPLETEL,
"CMTPUsbEpControl state on entry = %d", iState );
switch (iState)
{
case EControlRequestSetupPending:
SetState(EControlRequestSetupComplete);
Connection().ReceiveControlRequestSetupCompleteL(aError, aSink);
break;
case EControlRequestDataReceive:
SetState(EControlRequestStatusSend);
Connection().ReceiveControlRequestDataCompleteL(aError, aSink);
break;
case EIdle:
// State will be EIdle if CancelReceive is called
break;
case EControlRequestSetupComplete:
case EControlRequestDataSend:
case EControlRequestStatusSend:
default:
__DEBUG_ONLY(Panic(EMTPUsbBadState));
break;
}
if(aError != KErrNone)
{
// Reset the internal state to idle.
SetState(EIdle);
}
OstTrace1( TRACE_NORMAL, DUP1_CMTPUSBEPCONTROL_RECEIVEDATACOMPLETEL,
"CMTPUsbEpControl state on exit = %d", iState );
OstTraceFunctionExit0( CMTPUSBEPCONTROL_RECEIVEDATACOMPLETEL_EXIT );
}
void CMTPDeviceDataProvider::NotifyEnumerationCompleteL(TUint32 aStorageId, TInt /*aError*/)
{
OstTraceFunctionEntry0( CMTPDEVICEDATAPROVIDER_NOTIFYENUMERATIONCOMPLETEL_ENTRY );
__ASSERT_DEBUG((aStorageId == iPendingEnumerations[KMTPDeviceDpActiveEnumeration]), User::Invariant());
if (iPendingEnumerations.Count() > 0)
{
iPendingEnumerations.Remove(KMTPDeviceDpActiveEnumeration);
}
switch(iEnumeratingState)
{
case EEnumeratingDeviceDataStore:
case EEnumeratingFolders:
iEnumeratingState = EEnumerationComplete;
Framework().ObjectEnumerationCompleteL(aStorageId);
//iEnumerator->StartL(iPendingEnumerations[KMTPDeviceDpActiveEnumeration]);
break;
case EEnumerationComplete:
default:
__DEBUG_ONLY(User::Invariant());
break;
}
OstTraceFunctionExit0( CMTPDEVICEDATAPROVIDER_NOTIFYENUMERATIONCOMPLETEL_EXIT );
}
TInt RHybridHeap::DebugFunction(TInt aFunc, TAny* a1, TAny* a2)
{
TInt r = KErrNone;
switch(aFunc)
{
case RAllocator::ECount:
struct HeapInfo info;
Lock();
GetInfo(&info, NULL);
*(unsigned*)a1 = info.iFreeN;
r = info.iAllocN;
Unlock();
break;
case RAllocator::EMarkStart:
__DEBUG_ONLY(DoMarkStart());
break;
case RAllocator::EMarkEnd:
__DEBUG_ONLY( r = DoMarkEnd((TInt)a1) );
break;
case RAllocator::ECheck:
r = DoCheckHeap((SCheckInfo*)a1);
break;
case RAllocator::ESetFail:
__DEBUG_ONLY(DoSetAllocFail((TAllocFail)(TInt)a1, (TInt)a2));
break;
case RHybridHeap::EGetFail:
__DEBUG_ONLY(r = iFailType);
break;
case RHybridHeap::ESetBurstFail:
#if _DEBUG
{
SRAllocatorBurstFail* fail = (SRAllocatorBurstFail*) a2;
DoSetAllocFail((TAllocFail)(TInt)a1, fail->iRate, fail->iBurst);
}
#endif
break;
case RHybridHeap::ECheckFailure:
// iRand will be incremented for each EFailNext, EBurstFailNext,
// EDeterministic and EBurstDeterministic failure.
r = iRand;
break;
case RAllocator::ECopyDebugInfo:
{
TInt nestingLevel = ((SDebugCell*)a1)[-1].nestingLevel;
((SDebugCell*)a2)[-1].nestingLevel = nestingLevel;
break;
}
case RHybridHeap::EGetSize:
{
r = iChunkSize - sizeof(RHybridHeap);
break;
}
case RHybridHeap::EGetMaxLength:
{
r = iMaxLength;
break;
}
case RHybridHeap::EGetBase:
{
*(TAny**)a1 = iBase;
break;
}
case RHybridHeap::EAlignInteger:
{
r = _ALIGN_UP((TInt)a1, iAlign);
break;
}
case RHybridHeap::EAlignAddr:
{
*(TAny**)a2 = (TAny*)_ALIGN_UP((TLinAddr)a1, iAlign);
break;
}
case RHybridHeap::EWalk:
struct HeapInfo hinfo;
SWalkInfo winfo;
Lock();
winfo.iFunction = (TWalkFunc)a1;
winfo.iParam = a2;
winfo.iHeap = (RHybridHeap*)this;
GetInfo(&hinfo, &winfo);
Unlock();
break;
#ifndef __KERNEL_MODE__
case RHybridHeap::EHybridHeap:
{
if ( !a1 )
return KErrGeneral;
STestCommand* cmd = (STestCommand*)a1;
switch ( cmd->iCommand )
{
case EGetConfig:
cmd->iConfig.iSlabBits = iSlabConfigBits;
cmd->iConfig.iDelayedSlabThreshold = iPageThreshold;
cmd->iConfig.iPagePower = iPageThreshold;
break;
case ESetConfig:
//
// New configuration data for slab and page allocator.
// Reset heap to get data into use
//
#if USE_HYBRID_HEAP
iSlabConfigBits = cmd->iConfig.iSlabBits & 0x3fff;
iSlabInitThreshold = cmd->iConfig.iDelayedSlabThreshold;
iPageThreshold = (cmd->iConfig.iPagePower & 0x1f);
Reset();
#endif
break;
case EHeapMetaData:
cmd->iData = this;
break;
case ETestData:
iTestData = cmd->iData;
break;
default:
return KErrNotSupported;
}
break;
}
#endif // __KERNEL_MODE
default:
return KErrNotSupported;
}
return r;
}
void CPlayerWatcherBase::ReceiveCommandL(const TDesC8& /*aMessageInformation*/, SymbianAvctp::TTransactionLabel /*aTransLabel*/, const TBTDevAddr& /*aAddr*/)
{
LOG_FUNC;
__DEBUG_ONLY(AVRCP_PANIC(ELowerInterfaceUsedOnInternalHandler));
}
void CPlayerWatcherBase::MaxPacketSize(TInt /*aMtu*/)
{
LOG_FUNC;
__DEBUG_ONLY(AVRCP_PANIC(ELowerInterfaceUsedOnInternalHandler));
}
void CPlayerWatcherBase::MessageSent(CAvrcpCommand& /*aCommand*/, TInt /*aSendResult*/)
{
LOG_FUNC;
__DEBUG_ONLY(AVRCP_PANIC(ELowerInterfaceUsedOnInternalHandler));
}
/**
Second phase constructor.
@leave One of the system wide error code, if a processing failure occurs.
*/
void CMTPMetaData::ConstructL()
{
const TUint KCount(iElements.Count());
for (TUint i(0); (i < KCount); i++)
{
const TElementMetaData& KElement(iElements[i]);
switch (KElement.iType)
{
case EDesC:
__ASSERT_DEBUG((iElementsDesC.Count() == KElement.iOffset), Panic(EPanicBadLayout));
iElementsDesC.AppendL(KNullDesC().AllocLC());
CleanupStack::Pop();
break;
case EDesCArray:
{
__ASSERT_DEBUG((iElementsDesCArray.Count() == KElement.iOffset), Panic(EPanicBadLayout));
CDesCArrayFlat* desarray = new(ELeave) CDesCArrayFlat(KGranularity);
CleanupStack::PushL(desarray);
iElementsDesCArray.AppendL(desarray);
CleanupStack::Pop(desarray);
iElementsDesCArrayType.AppendL(EDesCArrayFlat);
break;
}
case EInt:
__ASSERT_DEBUG((iElementsInt.Count() == KElement.iOffset), Panic(EPanicBadLayout));
iElementsInt.AppendL(0);
break;
case EIntArray:
{
__ASSERT_DEBUG((iElementsIntArray.Count() == KElement.iOffset), Panic(EPanicBadLayout));
RArray<TInt>* intarray = new(ELeave) RArray<TInt>;
CleanupStack::PushL(intarray);
iElementsIntArray.AppendL(intarray);
CleanupStack::Pop(intarray);
break;
}
case EUint:
__ASSERT_DEBUG((iElementsUint.Count() == KElement.iOffset), Panic(EPanicBadLayout));
iElementsUint.AppendL(0);
break;
case EUintArray:
{
__ASSERT_DEBUG((iElementsUintArray.Count() == KElement.iOffset), Panic(EPanicBadLayout));
RArray<TUint>* uintarray = new(ELeave) RArray<TUint>;
CleanupStack::PushL(uintarray);
iElementsUintArray.AppendL(uintarray);
CleanupStack::Pop(uintarray);
break;
}
default:
__DEBUG_ONLY(Panic(EPanicTypeUnknown));
break;
}
}
}