void CPolicyStore::ConnectionMethodsLC(
RArray<TUint32>& aVpnConnections,
RCmManager& aCmManager,
const TVpnPolicyId& aPolicyId,
TBool& aPolicyActive)
{
using namespace CMManager;
LOG_1("CPolicyStore::ConnectionMethodsLC : %S", &aPolicyId);
CleanupClosePushL( aVpnConnections );
aCmManager.ConnectionMethodL(
aVpnConnections,
ETrue,
EFalse,
EFalse );
LOG_1("CPolicyStore::ConnectionMethodsLC cnt: %d",
aVpnConnections.Count());
TInt index(aVpnConnections.Count());
while( index )
{
--index;
LOG_1("CPolicyStore::ConnectionMethodsLC at: %d", index);
TUint32 id(aVpnConnections[index]);
RCmConnectionMethod connectioMethod =
aCmManager.ConnectionMethodL( id );
CleanupClosePushL( connectioMethod );
if( connectioMethod.GetIntAttributeL(ECmBearerType) !=
KPluginVPNBearerTypeUid )
{
aVpnConnections.Remove( index );
}
else
{
HBufC* policyId = connectioMethod.GetStringAttributeL(
EVpnServicePolicy);
if( aPolicyId.Compare( *policyId ) )
{
aVpnConnections.Remove( index );
}
else
{
if( connectioMethod.GetBoolAttributeL(ECmConnected) )
{
LOG_1("PolicyActiveL:%d", index);
aPolicyActive = ETrue;
}
}
delete policyId;
}
CleanupStack::PopAndDestroy(); // connectioMethod
}
}
/**
Setup dir structure for testing and verifying functional results
@param datastr data structure to setup directory
@param iOperation Operation to be performed
@param SrcDrive Source drive
@param Targetdrive Target drive input
@panic if data structure definition is incorrect
*/
void SetupDirFiles(const TDesC& aPath, const TDirSetupFiles& aDirFiles)
{
TFileName path = aPath;
if (path.Length() == 0)
{
test.Printf(_L("ERROR<SetupDirFiles()>: Zero length src path!\n"));
test(EFalse);
}
MakeDir(path);
RArray<TInt> addBlockDataArray;
RArray<TInt> deductBlockDataArray;
ParsingDirDataBlock(aDirFiles.iAddingBlock, addBlockDataArray);
ParsingDirDataBlock(aDirFiles.iDeductBlock, deductBlockDataArray);
if (addBlockDataArray.Count() == 0)
// empty dir setup
{
return;
}
for (TInt i = 0; i < deductBlockDataArray.Count(); ++i)
{
TInt idxToDelete = addBlockDataArray.FindInOrder(deductBlockDataArray[i]);
if (idxToDelete >= 0)
{
addBlockDataArray.Remove(idxToDelete);
}
else if (idxToDelete == KErrNotFound)
{
continue;
}
else
{
test.Printf(_L("ERROR<<SetupDir>>: wrong dir data setup! err=%d\n"), idxToDelete);
test(EFalse);
}
}
if (addBlockDataArray.Count() > 0)
{
for (TInt i = 0; i < addBlockDataArray.Count(); ++i)
{
TInt idx = addBlockDataArray[i];
path = aPath;
path += gDirPatterns[idx];
if (path[path.Length() - 1] == '\\')
{
MakeDir(path);
}
else
{
MakeFile(path, _L8("blahblah"));
}
}
}
addBlockDataArray.Reset();
deductBlockDataArray.Reset();
}
void UT_CIceValidList::UT_CICEValidList_HasPairForComponentsL()
{
RArray<TUint> components;
CleanupClosePushL( components );
components.AppendL( 5 );
EUNIT_ASSERT(
EFalse == iValidList->HasPairForComponents( components ) );
UT_CICEValidList_AddValidPairLL();
EUNIT_ASSERT(
EFalse == iValidList->HasPairForComponents( components ) );
components.AppendL( KComponentIdRtp );
EUNIT_ASSERT(
EFalse == iValidList->HasPairForComponents( components ) );
components.Remove( 0 );
EUNIT_ASSERT(
ETrue == iValidList->HasPairForComponents( components ) );
components.Reset();
EUNIT_ASSERT_PANIC(
iValidList->HasPairForComponents( components ), "USER", 0 );
CleanupStack::PopAndDestroy( &components );
}
// ---------------------------------------------------------------------------
// Find entry ids of given properties.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CCenRepDatabaseUtil::FindEntryIdsFromPropertiesL(
const RIpAppPropArray& aPropertyArray,
RArray<TInt>& aEntryIds )
{
//CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryIdsFromPropertiesL - IN" );
TInt err = FindEntryIdsL( aEntryIds );
if( err == KErrNone )
{
TInt count = aEntryIds.Count();
TInt removed = 0;
for( TInt i = 0; i < count; i++ )
{
TBool ok = EFalse;
TUint32 entryId = aEntryIds[ i - removed ];
CheckEntryHasPropertiesL( entryId, aPropertyArray, ok );
if( !ok )
{
aEntryIds.Remove( i - removed );
removed++;
}
}
}
//CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryIdsFromPropertiesL - OUT" );
return err;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
void PosLmLandmarkHandler::RemoveNonExistingCategoriesL(
CPosLmLocalDbAccess& aDbAccess,
RArray<TPosLmItemId>& aCategoryIdArray)
{
RArray<TPosLmItemId> categoriesInDatabase;
CleanupClosePushL(categoriesInDatabase);
PosLmCategoryHandler::GetAllCategoryIdsL(aDbAccess,
CPosLmCategoryManager::ECategorySortOrderNone, categoriesInDatabase);
if (categoriesInDatabase.Count() == 0)
{
aCategoryIdArray.Reset();
}
for (TInt i = 0; i < aCategoryIdArray.Count();)
{
if (categoriesInDatabase.Find(aCategoryIdArray[i]) == KErrNotFound)
{
aCategoryIdArray.Remove(i);
}
else
{
i++;
}
}
CleanupStack::PopAndDestroy(&categoriesInDatabase);
}
void CMemoryView::HandleDeletedChunk(TUint32 aAddress)
{
TChunkInfo chunkInfo(aAddress);
TInt pos = iChunkList.Find(chunkInfo, TChunkInfo::Match);
if (pos < 0)
{
PrintWarning(_L("Couldn't handle deletion of chunk 0x%08x: %d"), aAddress, pos);
}
else
{
TChunkInfo& c = iChunkList[pos];
// Rejuvenate chunks that haven't been updated since this one last was.
const TInt numChunks = iChunkList.Count();
for (TInt i = 0; i < numChunks; ++i)
{
TChunkInfo& d = iChunkList[i];
if (d.iUpdateCount > c.iUpdateCount)
{
--d.iUpdateCount;
}
}
iChunkList.Remove(pos);
if (iChunkList.Count() <= iNumConsoleLines)
{
iVerticalOffset = 0;
}
}
}
void CResponseHandler::RunL()
{
// if any existing -> Send response
if (iResponseArray.Count()) {
CompleteAnyKey(iResponseArray[0]);
// Remove already completed key
iResponseArray.Remove(0);
iResponseArray.Compress();
}
}
// -----------------------------------------------------------------------------
// CTCStateTiltListenData::PrepareArray
// -----------------------------------------------------------------------------
//
// Prepares array for item insertion
static void PrepareArray( RArray<TTiltXYZValue>& aArray, TInt aItemsToInsert, TInt aMaxItems )
{
FUNC_LOG;
TInt count = aArray.Count();
TInt i = count + aItemsToInsert;
while( i-- > aMaxItems ) // Delete old items from end
{
aArray.Remove( --count );
}
}
// NB: this test suite needs each test run to start with keyspaces with values from
// the initialization files in ROM dir. The best way to archive this is to send the
// EGetSetParameters IPC to centrep server to flush cache and then delete
// the .cre files. This option requires the CENTREP_SERVER_CACHETEST macro
// which is not available in release ONB. The second choice is to wait enough
// time for centrep server to flush out cache, then delete the .cre files from
// persists dir. This approach does not work well on the emulator because centrep
// server's cache timer sometimes is late by as much as a few seconds.
// Hence instead of wait and delete the .cre files, this RTest uses the ResetAll
// API. This trick works for the use case of this RTest but may not work in other
// situations. E.g., in this RTest centrep server always open repositories
// from cache. This changes the timing pattern and does not exercise the
// cache eviction code path.
LOCAL_C void ResetModifiedRepsL()
{
for (TInt i = RepsToReset.Count() - 1; i >= 0; i--)
{
CRepository* rep;
User::LeaveIfNull( rep = CRepository::NewL(RepsToReset[i]) );
rep->Reset();
delete rep;
RepsToReset.Remove(i);
}
}
void CHuiFxEffectCache::Remove(RArray<IDNode> &aMap, MHuiFxEffectCacheNode *aNode)
{
TInt size = aMap.Count();
for(TInt i=0;i<size;i++)
{
const IDNode &n = aMap[i];
if (n.iNode == aNode)
{
aMap.Remove(i);
return;
}
}
}
// ----------------------------------------------------------------------------
// CSipHeaderStrategyBase::EliminateClientsL
// ----------------------------------------------------------------------------
//
void CSipHeaderStrategyBase::EliminateClientsL(
CSIPRequest& aRequest,
RArray<TUid>& aUids )
{
for ( TInt i=0; i < aUids.Count();i++ )
{
MSipClient* client = iSipClients.GetByUID( aUids[i] );
if ( client && !CompareHeaders( aRequest,*client) )
{
aUids.Remove( i );
i--;
}
}
}
// ---------------------------------------------------------------------------
// CSdpMediaField::RemoveFormatL
// ---------------------------------------------------------------------------
//
EXPORT_C void CSdpMediaField::RemoveFormatL(const TDesC8& aFormat)
{
if ( !iFormatList || iFormatList->Des().Length() == 0 )
{
User::Leave( KErrSdpCodecMediaField );
}
TLex8 lexer( *iFormatList );
TBool tokenRemoved( EFalse );
while ( !tokenRemoved && !lexer.Eos() )
{
lexer.SkipSpaceAndMark();
lexer.SkipCharacters();
if ( lexer.TokenLength() > 0 )
{
if ( aFormat.CompareF(lexer.MarkedToken()) == 0)
{
RArray<TInt> removedObjs;
CleanupClosePushL( removedObjs );
for ( TInt i( 0 ); i < iFmtAttrFields->Count(); i++ )
{
if (aFormat.CompareF((*iFmtAttrFields)[i]->Format()) == 0)
{
User::LeaveIfError( removedObjs.Append(i) );
}
}
// Remove all format attributes of type format
TInt removedCount( 0 );
while ( removedObjs.Count() > 0 )
{
CSdpFmtAttributeField* obj =
(*iFmtAttrFields)[removedObjs[0] - removedCount];
delete obj;
obj = 0;
iFmtAttrFields->Remove( removedObjs[0] - removedCount);
removedObjs.Remove(0);
removedCount++;
}
CleanupStack::PopAndDestroy(); // removedObjs
// Remove format from format list
iFormatList->Des().Delete( lexer.MarkedOffset(),
lexer.Offset() - lexer.MarkedOffset());
iFormatList->Des().TrimAll();
tokenRemoved = ETrue;
}
}
}
}
inline void RemoveAndCompress(RArray<T>& aContainer, TInt aIndex)
/**
Remove the indexed item from the supplied array and compress
the array.
Without compression, the memory at the end of the array will
not be freed. Unless the memory is freed, memory leak testing
will fail.
@param aContainer Array from which item must be removed.
@param aIndex Item to remove from array.
*/
{
aContainer.Remove(aIndex);
aContainer.Compress();
}
// ---------------------------------------------------------------------------
// CSdpMediaField::KeepFormatL
// ---------------------------------------------------------------------------
//
EXPORT_C void CSdpMediaField::KeepFormatL(const TDesC8& aFormat)
{
if ( !iFormatList )
{
User::Leave( KErrSdpCodecMediaField );
}
// Empty set will continue to be empty
if ( iFormatList->Des().Length() > 0 )
{
HBufC8* formatList = aFormat.AllocLC();
// Mark all format attributes not aFormat so that they will be deleted
RArray<TInt> removedObjs;
CleanupClosePushL( removedObjs );
for ( TInt i( 0 ); i < iFmtAttrFields->Count(); i++ )
{
if (aFormat.CompareF((*iFmtAttrFields)[i]->Format()) != 0)
{
User::LeaveIfError( removedObjs.Append( i ) );
}
}
// Delete attribute fields
TInt removedCount( 0 );
while ( removedObjs.Count() > 0 )
{
CSdpFmtAttributeField* obj =
(*iFmtAttrFields)[removedObjs[0] - removedCount];
delete obj;
iFmtAttrFields->Remove( removedObjs[0] - removedCount );
removedObjs.Remove( 0 );
removedCount++;
}
CleanupStack::PopAndDestroy(); // removedObjs
// Change format list
delete iFormatList;
iFormatList = formatList;
CleanupStack::Pop(); // formatList
}
}
/** Get the sequence of all active transforms, ordered in order of execution.
@param aTransformSequence
an empty array to be populated with sequence of transform UIDs,
where transform entries with smaller index are executed earlier.
@leave KErrNoMemory Out of memory.
*/
EXPORT_C void CCamera::CCameraImageProcessing::GetActiveTransformSequenceL(RArray<TUid>& aTransformSequence) const
{
iImpl->GetActiveTransformSequenceL(aTransformSequence);
/* if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that
application is not prepared to receive extra added uid values (new settings added). So, any extra uid value passed
from the implementation will be filtered at this point.
To receive extra added uid values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L()
to create camera object. In this case, application is assumed to be prepared to receive unrecognised uid values */
if(iOwner.CameraVersion() == KCameraDefaultVersion)
{
for(TInt index =0; index < aTransformSequence.Count(); index++)
{
/** KBaselinedImageProcessing is the baseline. Any image processing attribute with greater uid value means that
it has been added in later versions */
if(aTransformSequence[index].iUid > KBaselinedImageProcessing)
{
aTransformSequence.Remove(index);
index--;
}
}
}
}
//takes away from aOidsToCheckAgainst
void CValidateCertChainStep::CheckCriticalExtsPresentAndRemoveL(const RPointerArray<TDesC>& aOidsToLookFor, RArray<TPtrC>& aOidsToCheckAgainst)
{
TBool found;
for (TInt oid_index=0; oid_index < aOidsToLookFor.Count(); ++oid_index)
{
found = EFalse;
for (TInt k=0; k < aOidsToCheckAgainst.Count(); ++k)
{
if ((*aOidsToLookFor[oid_index])==(aOidsToCheckAgainst[k]))
{
found = ETrue;
aOidsToCheckAgainst.Remove(k);
break;
}
}
if (!found)
{
ERR_PRINTF2(_L("ERROR: Critical extension OID not present: %S"), aOidsToLookFor[oid_index]);
User::Leave(KErrGeneral);
}
}
}
void CValidateCertChainStep::CheckWarningsPresentAndRemoveL(const RArray<TValidationStatus>& aWarningsToCheckFor, RArray<TValidationStatus>& aWarningsToCheckIn)
{
TBool found;
for (TInt warnings_index=0; warnings_index < aWarningsToCheckFor.Count(); ++warnings_index)
{
found = EFalse;
for (TInt k=0; k < aWarningsToCheckIn.Count(); ++k)
{
if (ValidationStatusEqual(aWarningsToCheckFor[warnings_index], aWarningsToCheckIn[k]))
{
found = ETrue;
aWarningsToCheckIn.Remove(k);
break;
}
}
if (!found)
{
ERR_PRINTF2(_L("ERROR: Warning not present: %d"), aWarningsToCheckFor[warnings_index].iReason);
User::Leave(KErrGeneral);
}
}
}
/**
GetObjectHandles request handler
*/
void CMTPGetObjectHandles::ServiceL()
{
OstTraceFunctionEntry0( CMTPGETOBJECTHANDLES_SERVICEL_ENTRY );
if(iSingletons.DpController().EnumerateState() != CMTPDataProviderController::EEnumeratedFulllyCompleted)
{
TUint storageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
TUint handle = Request().Uint32(TMTPTypeRequest::ERequestParameter3);
TUint enumerateState = iSingletons.DpController().StorageEnumerateState(storageId);
if ( (enumerateState < CMTPDataProviderController::EEnumeratingPhaseOneDone)
|| (enumerateState != CMTPDataProviderController::EEnumeratedFulllyCompleted && handle != KMTPHandleAll))
{
if (iTimeoutCount++ >= KMTPGetObjectHandlesTimeOut)
{
OstTrace0( TRACE_NORMAL, CMTPGETOBJECTHANDLES_SERVICEL,
"Wait for enumeration time out, return busy." );
SendResponseL(EMTPRespCodeDeviceBusy);
iTimeoutCount = 0;
OstTraceFunctionExit0( CMTPGETOBJECTHANDLES_SERVICEL_EXIT );
return;
}
else
{
OstTrace0( TRACE_NORMAL, DUP1_CMTPGETOBJECTHANDLES_SERVICEL,
"Enumeration not completed, suspend request." );
RegisterPendingRequest(20);
OstTraceFunctionExit0( DUP1_CMTPGETOBJECTHANDLES_SERVICEL_EXIT );
return;
}
}
}
iTimeoutCount = 0;
delete iHandles;
iHandles = NULL;
iHandles = CMTPTypeArray::NewL(EMTPTypeAUINT32);
OstTraceExt2( TRACE_NORMAL, DUP2_CMTPGETOBJECTHANDLES_SERVICEL,
"IsConnectMac = %d; ERequestParameter2 = %d", iDevDpSingletons.DeviceDataStore().IsConnectMac(), Request().Uint32(TMTPTypeRequest::ERequestParameter2));
if(iDevDpSingletons.DeviceDataStore().IsConnectMac()
&&(KMTPFormatsAll == Request().Uint32(TMTPTypeRequest::ERequestParameter2)))
{
OstTrace0( TRACE_NORMAL, DUP3_CMTPGETOBJECTHANDLES_SERVICEL, "ConnectMac and Fetch all." );
HandleObjectHandlesUnderMacL(*iHandles);
}
else
{
RMTPObjectMgrQueryContext context;
RArray<TUint> handles;
CleanupClosePushL(context);
CleanupClosePushL(handles);
TMTPObjectMgrQueryParams params(Request().Uint32(TMTPTypeRequest::ERequestParameter1), Request().Uint32(TMTPTypeRequest::ERequestParameter2), Request().Uint32(TMTPTypeRequest::ERequestParameter3));
do
{
iFramework.ObjectMgr().GetObjectHandlesL(params, context, handles);
TUint32 storageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
TUint32 parentHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter3);
if ( storageId != KMTPStorageAll && parentHandle == KMTPHandleNoParent )
{
const CMTPStorageMetaData& storage(iFramework.StorageMgr().StorageL(storageId));
HBufC* StorageSuid = storage.DesC(CMTPStorageMetaData::EStorageSuid).AllocL();
RBuf suid;
suid.CleanupClosePushL();
suid.CreateL(KMaxFileName);
suid = *StorageSuid;
_LIT(WMPInfoXml,"WMPInfo.xml");
suid.Append(WMPInfoXml);
TUint32 handle = iFramework.ObjectMgr().HandleL(suid);
if ( handle != KMTPHandleNone )
{
TInt index = handles.Find(handle);
if ( index != KErrNotFound )
{
handles.Remove(index);
handles.InsertL(handle,0);
}
}
delete StorageSuid;
StorageSuid = NULL;
CleanupStack::PopAndDestroy();
}
iHandles->AppendL(handles);
}
while (!context.QueryComplete());
CleanupStack::PopAndDestroy(&handles);
CleanupStack::PopAndDestroy(&context);
}
SendDataL(*iHandles);
OstTraceFunctionExit0( DUP2_CMTPGETOBJECTHANDLES_SERVICEL_EXIT );
}
// ---------------------------------------------------------------------------
// CAtPhbkStoreRead::ParseResponseL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CAtPhbkStoreRead::ParseResponseL(const TDesC8& /*aResponseBuf*/)
{
if( iState == ESetStoreNameComplete )
{
if (CurrentLine().Match(KLtsyOkString) == 0)
{
iError = KErrNone;
}
else
{
iError = KErrGeneral;
}
}
else if( iState == EReadEntryComplete )
{
/**
* +CPBR = <index>,<number>,<129/145>,<text>
* OK
*/
RArray<TPtrC8> array;
CleanupClosePushL(array);
iParser->ParseRespondedBuffer(array,Buffer());
// remove the string of AT+CPBR=..
if(array[0].MatchF(KAnyATCommand) != KErrNotFound)
{
array.Remove(0);
}
TInt count = array.Count();
#ifdef _DEBUG
for( TInt i=0;i<count;i++ )
{
LOGTEXT3(_L8("CAtPhbkStoreRead::ParseResponseL\tarray[%d]=%S"),i,&array[i]);
}
#endif
if((array[1].Match(KLtsyOkString) == KErrNone))
{
CleanupStack::PopAndDestroy();
iError = KErrNone;
iEndFlag = ETrue;
return;
}
else if((array[1].Match(KLtsyErrorString) == KErrNone))
{
CleanupStack::PopAndDestroy();
iError = KErrGeneral;
iEndFlag = ETrue;
return;
}
iError = KErrNone;
//remove number line if it has
if( array[0].MatchF(KCPBRSResponseString) == KErrNotFound )
{
array.Remove(0);
}
if( array[0].MatchF(KCPBRSResponseString) == KErrNotFound )
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
//parse index
TLex8 lex(array[1]);
TUint16 val;
TInt ret = lex.Val(val,EDecimal);
if(ret != KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
//Index
iReadEntry.iIndex = val;
iReadEntry.iNumber.Copy(array[2]);
//Parse TON/NPI
TLex8 lex1(array[3]);
TUint16 val1;
ret = lex1.Val(val1,EDecimal);
if(ret != KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
//TON/NPI
iReadEntry.iTon = (TUint8)val1;
iReadEntry.iText.Copy(array[4]);
CleanupStack::PopAndDestroy();
}
}
/**
Does comm_addr updating on an address-by-address basis.
Takes 3 lists of new addresses and a list of free comm_addr_ids.
*/
void CPplCommAddrTable::DoUpdateCommAddrsL(RArray<TMatch>& aNewPhones, RArray<TPtrC>& aNewEmails, RArray<TPtrC>& aNewSips,
RArray<TInt>& aFreeCommAddrIds, const TInt aItemId, CPplCommAddrTable::TCommAddrExtraInfoType
aExtraInfoType)
{
// if we have free ids to recycle and new comm_addrs, insert them by UPDATE
const TInt KFirstElementId(0);
while (aFreeCommAddrIds.Count() && (aNewPhones.Count() || aNewEmails.Count() || aNewSips.Count() ) )
{
if(aNewPhones.Count() )
{
DoPhoneNumWriteOpL(aNewPhones[KFirstElementId], EUpdate, aItemId, aFreeCommAddrIds[KFirstElementId],aExtraInfoType);
aNewPhones.Remove(KFirstElementId);
aFreeCommAddrIds.Remove(KFirstElementId);
}
else if(aNewEmails.Count() )
{
DoNonPhoneWriteOpL(aNewEmails[KFirstElementId], EUpdate, aItemId, EEmailAddress,
aFreeCommAddrIds[KFirstElementId]);
aNewEmails.Remove(KFirstElementId);
aFreeCommAddrIds.Remove(KFirstElementId);
}
else if(aNewSips.Count() )
{
DoNonPhoneWriteOpL(aNewSips[KFirstElementId], EUpdate, aItemId, ESipAddress,
aFreeCommAddrIds[KFirstElementId]);
aNewSips.Remove(KFirstElementId);
aFreeCommAddrIds.Remove(KFirstElementId);
}
}
// if we still have free ids to recycle but no new comm_addrs,
// delete the existing comm_addrs for these ids
const TInt KNumFreeIds(aFreeCommAddrIds.Count() );
for (TInt i = 0; i < KNumFreeIds; ++i)
{
TBool lowDiskErr(EFalse);
DeleteSingleCommAddrL(aFreeCommAddrIds[i], lowDiskErr);
if (lowDiskErr)
{
User::Leave(KErrDiskFull);
}
}
// if we still have new comm_addrs but no free ids to recycle,
// put them in the database using INSERT
const TInt KNumNewPhones(aNewPhones.Count() );
const TInt KNumNewEmails(aNewEmails.Count() );
const TInt KNumNewSips(aNewSips.Count() );
for (TInt i = 0; i < KNumNewPhones; ++i)
{
DoPhoneNumWriteOpL(aNewPhones[i], EInsert, aItemId, EPhoneNumber, aExtraInfoType);
}
for (TInt i = 0; i < KNumNewEmails; ++i)
{
DoNonPhoneWriteOpL(aNewEmails[i], EInsert, aItemId, EEmailAddress);
}
for (TInt i = 0; i < KNumNewSips; ++i)
{
DoNonPhoneWriteOpL(aNewSips[i], EInsert, aItemId, ESipAddress);
}
}
//-----------------------------------------------------------------------------
//Function Name : void* DlSymByDependencyOrdering(const void* aHandle,
// const char* aName)
//Description : To search for symbol named name in statically dependent dll
// on aSymInfoHeader, is dependencies, also dependencies of
// dependencies using Dependency-ordering.
//Return Value : Valid address if name found otherwise NULL
//-----------------------------------------------------------------------------
void* DlSymByDependencyOrdering(const void* aHandle,const char* aName)
{
//Get 0th ordinal datastructure of dll denoted by handle.
LoadedDlls()->Lock();
TInt idx = LoadedDlls()->Find(aHandle);
//check if handle not found
if ( KErrNotFound == idx )
{
LoadedDlls()->UnLock();
SetError(KDlSymErrBadHandle);
return NULL;
}
TDllEntry& dllEntry = LoadedDlls()->At(idx);
// The below 'if' condition prevents the symbol lookup on non-STDDLL
// Check for the symbol information, if not found
// return with KDlSymErrNoSupport
if( !dllEntry.iSymbolHeader )
{
LoadedDlls()->UnLock();
SetError(KDlSymErrNoSupport);
return NULL;
}
TBuf8<KMaxFileName> fileName;
if(CnvUtfConverter::ConvertFromUnicodeToUtf8(fileName,dllEntry.iLibrary.FileName()) != 0)
{
LoadedDlls()->UnLock();
return NULL;
}
TE32ExpSymInfoHdr* symInfoHeader = dllEntry.iSymbolHeader;
//Queue for using Breadthfirst search / Dependency ordering.
RArray<TImageData> dependentDllQue;
TImageData imageData((char*)fileName.PtrZ(), symInfoHeader);
//add first item in queue
TInt err = dependentDllQue.Append(imageData);
if ( KErrNone != err )
{
LoadedDlls()->UnLock();
dependentDllQue.Close();
SetError(KDlSymErrNoMemory);
return NULL;
}
char* curDll = NULL;
char* dependentDll = NULL;
HMODULE handleToDll = NULL;
TBuf<KMaxFileName> dependentfileName;
TE32ExpSymInfoHdr* tempSymInfoHeader = NULL;
void* symAddr = NULL;
TPtrC8 tempPtr;
//Array of searched dlls. Used to check circular dependency
//this is array of pointer to name of dll in image
RPointerArray<TE32ExpSymInfoHdr> searchedDlls;
//Breath First search for Dependancy ordering.
while(dependentDllQue.Count())
{
imageData = dependentDllQue[0];
curDll = imageData.iFileName;
symInfoHeader = imageData.iSymInfoHeader;
dependentDllQue.Remove(0);
// The below 'if' condition prevents the symbol lookup on dependent non-STDDLL
if(!symInfoHeader)
{
continue;
}
tempPtr.Set((unsigned char*)curDll, strlen(curDll));
dependentfileName.Copy(tempPtr);
TParsePtr pParser(dependentfileName);
dependentfileName = pParser.NameAndExt();
//Search in this dll's symbol table
handleToDll = Emulator::GetModuleHandle(dependentfileName.PtrZ());
symAddr = Emulator::GetProcAddress(handleToDll,aName);
//check if symbol is found
if( symAddr )
{
LoadedDlls()->UnLock();
dependentDllQue.Close();
searchedDlls.Close();
return symAddr;
}
//Insert this to searched list
err = searchedDlls.Append(symInfoHeader);
if ( KErrNone != err )
{
LoadedDlls()->UnLock();
dependentDllQue.Close();
searchedDlls.Close();
SetError(KDlSymErrNoMemory);
return NULL;
}
//Add list of dependencies
dependentDll = (char*) symInfoHeader + sizeof(TE32ExpSymInfoHdr);
//Add at last to make it Queue, needed for Dependency ordering
for (TInt i = 0; i < symInfoHeader->iDllCount; i++)
{
tempPtr.Set((unsigned char*)dependentDll, strlen(dependentDll));
dependentfileName.Copy(tempPtr);
//get i'th dependency
handleToDll = Emulator::GetModuleHandle(dependentfileName.PtrZ());
Emulator::TModule aModule((HINSTANCE)handleToDll);
tempSymInfoHeader = (TE32ExpSymInfoHdr*)aModule.Section(KWin32SectionName_NmdExpData);
//check i'th dependency is OE dll e.i. equal to zero or not
//and also its not already searched
if ( tempSymInfoHeader && searchedDlls.Find(tempSymInfoHeader) == KErrNotFound )
{
imageData.iFileName = dependentDll;
imageData.iSymInfoHeader = tempSymInfoHeader;
err = dependentDllQue.Append(imageData);
if ( KErrNone != err )
{
LoadedDlls()->UnLock();
dependentDllQue.Close();
searchedDlls.Close();
SetError(KDlSymErrNoMemory);
return NULL;
}
}
//advance to next dependent dll
dependentDll += tempPtr.Length() + 1;
}
}
LoadedDlls()->UnLock();
dependentDllQue.Close();
searchedDlls.Close();
//Symbol not found return NULL
SetError(KDlSymErrNotFound);
return NULL;
}
/**
Removes comm addresses from the 3 lists that are already in the database and have been updated.
It takes the 3 lists in as parameters and modifies them accordingly. It also populates the list
of comm address ids that are free to be recycled during updating.
*/
void CPplCommAddrTable::RemoveNonUpdatedAddrsL(RArray<TMatch>& aNewPhones, RArray<TPtrC>& aNewEmails, RArray<TPtrC>& aNewSips,
RArray<TInt>& aFreeCommAddrIds, const TInt aItemId,CPplCommAddrTable::TCommAddrExtraInfoType
aExtraInfoType )
{
// build the RSqlStatement
RSqlStatement stmnt;
CleanupClosePushL(stmnt);
stmnt.PrepareL(iDatabase, iWholeSelectStmnt->SqlStringL() );
const TInt KContactIdParamIndex(KFirstIndex); // first and only parameter in the query
User::LeaveIfError(stmnt.BindInt(KContactIdParamIndex, aItemId) ) ;
// fetch the results from the query and compare them with the new comm_addrs we have
TInt err(KErrNone);
while ((err = stmnt.Next() ) == KSqlAtRow)
{
const TInt KType(stmnt.ColumnInt(iWholeSelectStmnt->ParameterIndex(KCommAddrType() ) ) );
if (KType == EPhoneNumber)
{
TMatch phoneNumber;
TPtrC valString = stmnt.ColumnTextL(iWholeSelectStmnt->ParameterIndex(KCommAddrValue() ) );
TPtrC extValString = stmnt.ColumnTextL(iWholeSelectStmnt->ParameterIndex(KCommAddrExtraValue() ) );
TInt extTypeInfoString = stmnt.ColumnInt(iWholeSelectStmnt->ParameterIndex(KCommAddrExtraTypeInfo() ) );
User::LeaveIfError(TLex(valString).Val(phoneNumber.iLowerSevenDigits) );
User::LeaveIfError(TLex(extValString).Val(phoneNumber.iUpperDigits) );
TInt matchIndex(aNewPhones.Find(phoneNumber, TIdentityRelation<TMatch>(&TMatch::Equals) ) );
// remove any phone numbers from the new list if we already
// have them in the db and they haven't changed...
if (matchIndex != KErrNotFound && (extTypeInfoString == aExtraInfoType))
{
aNewPhones.Remove(matchIndex);
}
// ...and add any spare ids to the recycle list
else
{
aFreeCommAddrIds.AppendL(
stmnt.ColumnInt(iWholeSelectStmnt->ParameterIndex(KCommAddrId() ) ) );
}
}
else // is Email or SIP
{
TPtrC valString = stmnt.ColumnTextL(iWholeSelectStmnt->ParameterIndex(KCommAddrValue() ) );
TInt matchIndex(0);
// remove any email and sip addresses from the new list if
// we already have them in the db and they haven't changed...
if (KType == EEmailAddress)
{
matchIndex = aNewEmails.Find(valString);
if (matchIndex != KErrNotFound)
{
aNewEmails.Remove(matchIndex);
}
}
else // SIP
{
matchIndex = aNewSips.Find(valString);
if (matchIndex != KErrNotFound)
{
aNewSips.Remove(matchIndex);
}
}
// ...and add any spare ids to the recycle list
if (matchIndex == KErrNotFound)
{
aFreeCommAddrIds.AppendL(
stmnt.ColumnInt(iWholeSelectStmnt->ParameterIndex(KCommAddrId() ) ) );
}
}
}
// leave if we didn't complete going through the results properly
if(err != KSqlAtEnd)
{
User::Leave(err);
}
CleanupStack::PopAndDestroy(&stmnt);
}
// -----------------------------------------------------------------------------
// CDRMHelperServer::CheckExpirationL().
// This function check the time for rights to expire
// -----------------------------------------------------------------------------
//
void CDRMHelperServer::CheckExpirationL(
const TDesC8& aUri ,
const TUint8& aPermType ,
const TUint8& aRegType ,
TTime& aEndTime )
{
#ifdef _DRM_TESTING
WriteL(_L8("CheckExpiration"));
#endif
RPointerArray<CDRMPermission> rights;
RArray<TTimeBased> timeList;
TBool stop = EFalse;
TInt i = 0;
TInt err = 0;
TTimeIntervalYears years(KTimeIntervalYears);
TTime time = Time::MinTTime();
TTimeBased item;
TTimeIntervalSeconds interval = 0;
RPointerArray<HBufC8> imsi;
aEndTime = Time::MinTTime();
TRAP( err , iDrm.GetDBEntriesL(aUri, rights) );
CleanupClosePushL(rights);
if ( err == KErrCANoRights || err == KErrCANoPermission )
{
aEndTime = Time::MinTTime();
err = KErrNone;
stop = ETrue;
}
User::LeaveIfError(err);
TRAP( err, iDrm.GetSupportedIndividualsL( imsi ) );
if ( err )
{
imsi.ResetAndDestroy();
}
time.HomeTime();
// Goes through all the rights associated to this specific URI
CleanupClosePushL(timeList);
for (i = 0; i < rights.Count() && !stop; i++)
{
CheckPermission( rights[i], aPermType, item, interval ,imsi );
if (interval.Int()>0 ||
(item.StartTime()==Time::MinTTime()&&item.EndTime()==Time::MaxTTime()))
{
stop = ETrue;
aEndTime = Time::MaxTTime();
}
else
{
if (aRegType == CDRMHelperServer::EActive && item.StartTime()>time)
{
// dont count future time for active usage
}
else
{
err = timeList.Append( item );
if ( err )
{
rights.ResetAndDestroy();
imsi.ResetAndDestroy();
}
User::LeaveIfError(err);
}
}
}
rights.ResetAndDestroy();
imsi.ResetAndDestroy();
// if there were no inactivated interval- or full-rights then calculate the expiration date
// based on what we stored to timeList
if( !stop )
{
time.HomeTime(); // preset time to current time. This is what we compare against.
TTime temp;
TTime pastTime;
temp = time;
pastTime = Time::MinTTime();
TBool action = ETrue;
// Loop while there are still items in the list and we have done something
while( action && timeList.Count() > 0 )
{
action = EFalse;
for ( i = 0 ; i < timeList.Count() ; i++ ) // go through the whole timeList
{
#ifdef _DRM_TESTING
_LIT8(KCount , "time list count: %d");
TBuf8<40> buf;
buf.Format( KCount , timeList.Count());
WriteL( buf );
#endif
if ( timeList[i].StartTime() <= time && timeList[i].EndTime() > time )
{
// Case1: valid rights
time = timeList[i].EndTime();
timeList.Remove(i);
action = ETrue;
#ifdef _DRM_TESTING
WriteL(_L8("case 1:"));
WriteTimeL( time );
#endif
}
else if ( timeList[i].StartTime() <= time && timeList[i].EndTime() <= time )
{
// Case2: expired rights
if (timeList[i].EndTime()>pastTime) // just in case there is no valid rights
{
pastTime = timeList[i].EndTime(); // save the latest end time from the expired rights
}
timeList.Remove(i);
action = ETrue;
#ifdef _DRM_TESTING
WriteL(_L8("case 2:"));
#endif
}
else if ( timeList[i].StartTime() > time && timeList[i].EndTime() <= time )
{
// Case3: Illegal case. Start time after end-time.
timeList.Remove(i);
action = ETrue;
#ifdef _DRM_TESTING
WriteL(_L8("case 3:"));
#endif
}
else
{
// Case4: Only thing left is the not yet valid -rights
#ifdef _DRM_TESTING
WriteL(_L8("case 4:"));
#endif
}
}
}
if (temp<time)
{
aEndTime = time; // time has been changed, so we use it, otherwise it means there is no valid rights
}
else
{
aEndTime = pastTime;
}
#ifdef _DRM_TESTING
WriteL(_L8("expiration date:"));
WriteTimeL( aEndTime );
#endif
}
#ifdef _DRM_TESTING
WriteL(_L8("Endtime calculation is done:"));
WriteTimeL( aEndTime );
#endif
timeList.Reset();
CleanupStack::PopAndDestroy(&timeList); // timeList
CleanupStack::PopAndDestroy(&rights); // rights
}
EXPORT_C void CMMFDevVideoPlay::FindDecodersL(const TDesC8& aMimeType, TUint32 aPostProcType, RArray<TUid>& aDecoders, TBool aExactMatch)
{
#ifdef SYMBIAN_MULTIMEDIA_CODEC_API
// find PU based plugins
RImplInfoPtrArray codecPlugins;
CleanupResetAndDestroyPushL(codecPlugins);
DevVideoUtilities::FindVideoDecoderPluginsL(aMimeType, codecPlugins);
aDecoders.Reset();
for (TInt i = 0; i < codecPlugins.Count();i++)
{
aDecoders.AppendL(codecPlugins[i]->ImplementationUid());
}
CleanupStack::PopAndDestroy(&codecPlugins);
#endif // SYMBIAN_MULTIMEDIA_CODEC_API
RImplInfoPtrArray plugins;
CleanupResetAndDestroyPushL(plugins);
MmPluginUtils::FindImplementationsL(KUidDevVideoDecoderHwDevice, plugins);
DevVideoUtilities::SelectPluginBasedOnMatchType(aMimeType, plugins);
DevVideoUtilities::MatchPrePostProcessorCapabilitiesL(plugins, aPostProcType, aDecoders);
// Perform the extra processing required if an exact match was requested
if (aExactMatch)
{
// We now need to go through each of the plugins returned (which may have been matched using
// a wildcard), instantiate each one, and perform an exact mime-type match.
// Any plugins that don't support the desired mime type exactly will be removed from aDecoders.
CCompressedVideoFormat* format = CCompressedVideoFormat::NewL(aMimeType);
CleanupStack::PushL(format);
for (TInt i=aDecoders.Count()-1; i>=0; i--)
{
TUid pluginUid = aDecoders[i];
CVideoDecoderInfo* info = NULL;
TRAPD(err, info = VideoDecoderInfoLC(pluginUid); CleanupStack::Pop(info););
if (err == KErrNone)
{
if (!info->SupportsFormat(*format))
{
// The decoder doesn't support the format, so remove it from the list
aDecoders.Remove(i);
}
delete info;
}
else if (err==KErrNotFound)
{
// we have a bogus UID so remove it from the list
aDecoders.Remove(i);
}
else
{
User::Leave(err);
}
}
CleanupStack::PopAndDestroy(format);
}
// ---------------------------------------------------------------------------
// CAtPhbkEnGetInfo::ParseResponseL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CAtPhbkEnGetInfo::ParseResponseL(const TDesC8& /*aResponseBuf*/)
{
if( iState==ESetEnStoreComplete )
{
if (CurrentLine().Match(KLtsyOkString) == 0)
{
iError = KErrNone;
}
else
{
iError = KErrGeneral;
}
}
else if( iState==EGetEnStoreInfoComplete )
{
/**
* Here is an Example
* +CPBS: "EN",2,16
* phonebooken is selected,2 locations are used and
* total 16 locations are available
*/
iError = KErrNone;
RArray<TPtrC8> array;
CleanupClosePushL(array);
iParser->ParseRespondedBuffer(array,Buffer());
//remove AT+CPBS
if(array[0].MatchF(KAnyATCommand)!=KErrNotFound)
{
array.Remove(0);
}
TInt count = array.Count();
#ifdef _DEBUG
for( TInt i=0;i<count;i++ )
{
LOGTEXT3(_L8("CAtPhbkEnGetInfo::ParseResponseL\tarray[%d]=%S"),
i,&array[i]);
}
#endif
if (count <= 1)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
if(array[0].MatchF(KCPBSResponseString)==KErrNotFound)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
//parse used
TLex8 lex(array[2]);
TUint16 val;
TInt ret=lex.Val(val,EDecimal);
if(ret!=KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iUsed = val;
//parse total
TLex8 lex1(array[3]);
ret=lex1.Val(val,EDecimal);
if(ret!=KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iTotal = val;
LOGTEXT3(_L8("CAtPhbkEnGetInfo::ParseResponseL\tPreferred store used=%d, total=%d"),
iUsed,iTotal);
CleanupStack::PopAndDestroy(&array);
}
}
//-----------------------------------------------------------------------------
//Function Name : TInt SearchSymbolByLoadordering(TE32ExpSymInfoHdr* symInfoHeader
// , char* aFileName, const char* aName,
// RPointerArray<TE32ExpSymInfoHdr>& aSearchedDlls,
// void*& aSymAddress)
//Description : To search for symbol named name in statically dependent dll
// on aSymInfoHeader, it may be belonging to EXE or a DLL, also
// dependencies of dependencies using Load-ordering. It also sets
// valid address in aSymAddress if name found, and all sll it searched in
// aSearchedDlls param.
//Return Value : KErrNone if symbol found otherwise system wide error codes.
//-----------------------------------------------------------------------------
TInt SearchSymbolByLoadordering(const TE32ExpSymInfoHdr* symInfoHeader, const char* aFileName,
const char* aName,
RPointerArray<TE32ExpSymInfoHdr>& aSearchedDlls,
void*& aSymAddress)
{
//This is used as stack for Load-ordering or Depthfirst search.
RArray<TImageData> dependentDllStack;
//here on emulator we need two things one is Name to find symbol in that list,
//second is TE32ExpSymInfoHdr to find dependencies
TImageData imageData((char*)aFileName, (TE32ExpSymInfoHdr*)symInfoHeader);
aSymAddress = NULL;
//Add exe on the stack
TInt err = dependentDllStack.Append(imageData);
if ( KErrNone != err )
{
dependentDllStack.Close();
return KErrNoMemory;
}
TE32ExpSymInfoHdr* tempSymInfoHeader = NULL;
TInt lastIdx = 0;
char* curDll = NULL;
char* dependentDll = NULL;
HMODULE handleToDll = NULL;
TPtrC8 tempPtr;
TBuf<KMaxFileName> dependentfileName;
//Retunn address would be stored in this
void* symAddr = NULL;
//user to maintain load ordering
RArray<TImageData> curDependentDll;
TImageData tempImageData;
//Depth First search for Load-ordering.
while ( lastIdx >= 0 )
{
//Take first dll on the stack i.e. topmost
imageData = dependentDllStack[lastIdx];
symInfoHeader = imageData.iSymInfoHeader;
//Remove from stack
dependentDllStack.Remove(lastIdx);
if(!symInfoHeader)
{
//skip non-std binaries...
lastIdx = dependentDllStack.Count() - 1;
continue;
}
curDll = imageData.iFileName;
tempPtr.Set((unsigned char*)curDll, strlen(curDll));
dependentfileName.Copy(tempPtr);
TParsePtr pParser(dependentfileName);
dependentfileName = pParser.NameAndExt();
//Search in this dll's symbol table
handleToDll = Emulator::GetModuleHandle(dependentfileName.PtrZ());
symAddr = Emulator::GetProcAddress(handleToDll,aName);
//Check if Symbol is found
if( symAddr )
{
dependentDllStack.Close();
aSymAddress = symAddr;
return KErrNone;
}
//Add this dll to list of searched dlls
err = aSearchedDlls.Append(symInfoHeader);
if ( KErrNone != err )
{
dependentDllStack.Close();
return KErrNoMemory;
}
dependentDll = (char*) symInfoHeader + sizeof(TE32ExpSymInfoHdr);
//if this image is an exe - the these would be some symbols
if ( symInfoHeader->iSymCount )
{//skip all symbol addresse
char* curSymbolStr = dependentDll + (KFourByteOffset * symInfoHeader->iSymCount);
//skip all symbol names
for (TInt i = 0; i < symInfoHeader->iSymCount; ++i )
{
curSymbolStr += strlen(curSymbolStr) + 1;
}
//initialise first dependent dll name
dependentDll = curSymbolStr;
}
//Store names of all dependent dlls of current dll/exe store there name in
//curDependentDll. This is done to maintain load ordering.
for (TInt i = 0; i < symInfoHeader->iDllCount; ++i)
{
tempPtr.Set((unsigned char*)dependentDll, strlen(dependentDll));
dependentfileName.Copy(tempPtr);
handleToDll = Emulator::GetModuleHandle(dependentfileName.PtrZ());
Emulator::TModule aModule((HINSTANCE)handleToDll);
tempSymInfoHeader = (TE32ExpSymInfoHdr*)aModule.Section(KWin32SectionName_NmdExpData);
if ( tempSymInfoHeader && aSearchedDlls.Find(tempSymInfoHeader) == KErrNotFound )
{
tempImageData.iFileName = dependentDll;
tempImageData.iSymInfoHeader = tempSymInfoHeader;
err = curDependentDll.Append(tempImageData);
if ( KErrNone != err )
{
dependentDllStack.Close();
curDependentDll.Close();
return KErrNoMemory;
}
}
//advance to next dependent dll
dependentDll += tempPtr.Length() + 1;
}
//add in load order to dependentDllStack
for (TInt i = curDependentDll.Count() - 1; i >= 0; --i)
{
err = dependentDllStack.Append(curDependentDll[i]);
if ( KErrNone != err )
{
dependentDllStack.Close();
curDependentDll.Close();
return KErrNoMemory;
}
}
curDependentDll.Close();
lastIdx = dependentDllStack.Count() - 1;
}
dependentDllStack.Close();
return KErrNotFound;
}
// ---------------------------------------------------------------------------
// CAtPhbkGetPhoneStoreInfo::ParseResponseL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CAtPhbkGetPhoneStoreInfo::ParseResponseL(const TDesC8& /*aResponseBuf*/)
{
if( iState == ESetPhoneStoreComplete )
{
if (CurrentLine().Match(KLtsyOkString) == 0)
{
iError = KErrNone;
}
else
{
iError = KErrGeneral;
}
}
else if( iState == EGetPhoneStoreInfoComplete )
{
/**
* Here is an Example
* +CPBS: "SM",6,250
* ADN phonebook is selected,6 locations are used and
* total 250 locations are available
*/
iError = KErrNone;
RArray<TPtrC8> array;
CleanupClosePushL(array);
iParser->ParseRespondedBuffer(array,Buffer());
//remove AT+CPBS
if(array[0].MatchF(KAnyATCommand) != KErrNotFound)
{
array.Remove(0);
}
TInt count = array.Count();
#ifdef _DEBUG
for( TInt i=0;i<count;i++ )
{
LOGTEXT3(_L8("CAtPhbkGetPhoneStoreInfo::ParseResponseL\tarray[%d]=%S"),
i,&array[i]);
}
#endif
if (count <= 1)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
if(array[0].MatchF(KCPBSResponseString) == KErrNotFound)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
//parse used
TLex8 lex(array[2]);
TUint16 val;
TInt ret = lex.Val(val,EDecimal);
if(ret != KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iPhoneStoreInfo.iUsedEntries = val;
//parse total
TLex8 lex1(array[3]);
ret = lex1.Val(val,EDecimal);
if(ret != KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iPhoneStoreInfo.iTotalEntries = val;
iPhoneStoreInfo.iType = RMobilePhoneStore::EPhoneBookStore;
LOGTEXT3(_L8("CAtPhbkGetPhoneStoreInfo::ParseResponseL\tPreferred store used=%d, total=%d"),
iPhoneStoreInfo.iUsedEntries,iPhoneStoreInfo.iTotalEntries);
CleanupStack::PopAndDestroy(&array);
}
else
{
/**
* Parse result of AT+CPMS?
* Response:+CPMS:<mem1>,<used1>,<total1>,<mem2>,<used2>,<total2>
* Here only the first mem is used. mem1 is SM
*/
iError = KErrNone;
RArray<TPtrC8> array;
CleanupClosePushL(array);
iParser->ParseRespondedBuffer(array,Buffer());
if(array[0].MatchF(KAnyATCommand) != KErrNotFound)
{
array.Remove(0);
}
TInt Count = array.Count();
if (Count <= 1)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
if(array[0].MatchF(KCPMSResponseString) == KErrNotFound)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
//parse name
TPtrC8 name(array[1]);
//parse used
TLex8 lex(array[2]);
TUint16 val;
TInt ret = lex.Val(val,EDecimal);
if(ret != KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iPhoneStoreInfo.iUsedEntries = val;
//parse total
TLex8 lex1(array[3]);
ret = lex1.Val(val,EDecimal);
if(ret != KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iPhoneStoreInfo.iTotalEntries = val;
iPhoneStoreInfo.iType = RMobilePhoneStore::EShortMessageStore;
LOGTEXT3(_L8("CAtPhbkGetPhoneStoreInfo::ParseResponseL\tPreferred store used=%d, total=%d"),
iPhoneStoreInfo.iUsedEntries,iPhoneStoreInfo.iTotalEntries);
CleanupStack::PopAndDestroy(&array);
}
}
// ---------------------------------------------------------
// CPosTp29::DoOutOfDiskTestL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp29::DoOutOfDiskTestL(TBool aSync)
{
TVolumeInfo volumeInfo;
TBuf<200> buf;
CPosLmOperation* op = NULL;
_LIT(KUID,"Unique ID: %08x\r\n");
_LIT(KSize,"Size: %d bytes\r\n");
_LIT(KFree,"Free space: %d bytes\r\n");
//_LIT(KVolName,"Volume name: %S\r\n");
TInt err=iFileServer.Volume(volumeInfo, EDriveC);
if (err != KErrNone) iLog->Put(_L("Error from iFileServer"));
buf.AppendFormat(KUID, volumeInfo.iUniqueID);
buf.AppendFormat(KSize, volumeInfo.iSize);
buf.AppendFormat(KFree, volumeInfo.iFree);
//buf.AppendFormat(KVolName, &volumeInfo.iName);
iLog->Put(buf);
TTime startTime;
TTime stopTime;
// Just in case
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
RArray<TPosLmItemId> lmIdArray;
CleanupClosePushL(lmIdArray);
// 1) Create a low disc space situation
startTime.UniversalTime();
ConsumeDiscSpace1L(iCriticalLevel + KSizeLimitOffset1);
ConsumeDiscSpace2L(iCriticalLevel + KSizeLimitOffset2);
err=iFileServer.Volume(volumeInfo, EDriveC);
if (err != KErrNone) iLog->Put(_L("Error from iFileServer"));
buf.AppendFormat(KUID, volumeInfo.iUniqueID);
buf.AppendFormat(KSize, volumeInfo.iSize);
buf.AppendFormat(KFree, volumeInfo.iFree);
iLog->Put(buf);
stopTime.UniversalTime();
TTimeIntervalMicroSeconds executionTime =
stopTime.MicroSecondsFrom(startTime);
TInt resse = executionTime.Int64()/1000000;
buf.Zero();
buf.Format(_L("ConsumeDiscSpaceL took %d seconds"), resse);
iLog->Put(buf);
// 2) Add Landmarks until "disk full" error occur
if (iLandmarksDb->IsInitializingNeeded())
{
iLog->Put(_L("InitializeL"));
// Synchronous
ExecuteAndDeleteLD(iLandmarksDb->InitializeL());
}
CPosLandmark* landmark = CPosLandmark::NewLC();
landmark->SetLandmarkNameL(_L("LandMarkName1"));
iLog->Put(_L("Adding landmark1"));
lmIdArray.Append(iLandmarksDb->AddLandmarkL(*landmark));
CleanupStack::Pop(landmark);
landmark = CPosLandmark::NewLC();
landmark->SetLandmarkNameL(_L("LandMarkName2"));
iLog->Put(_L("Adding landmark2"));
lmIdArray.Append(iLandmarksDb->AddLandmarkL(*landmark));
CleanupStack::Pop(landmark);
err = KErrNone;
TPosLmItemId idde;
TInt i=0;
startTime.UniversalTime();
iLog->Put(_L("Adding landmark until KErrDiskFull.....1"));
// some while loop adding landmarks here until "disk full" error occur!!!
while (err != KErrDiskFull)
{
buf.Zero();
buf.Format(_L("Land Mark___________%d"), i++);
landmark = CPosLandmark::NewLC();
landmark->SetLandmarkNameL(buf);
TRAP(err, idde = iLandmarksDb->AddLandmarkL(*landmark));
if (err == KErrNone)
{
lmIdArray.Append(idde);
}
else if (err == KErrLocked)
{
iLog->Put(_L("KErrLocked when adding 1"));
User::After(100000);
}
CleanupStack::Pop(landmark);
}
stopTime.UniversalTime();
executionTime = stopTime.MicroSecondsFrom(startTime);
resse = executionTime.Int64()/1000000;
buf.Zero();
buf.Format(_L("Added %d nr of landmarks, took %d seconds"), i, resse);
iLog->Put(buf);
// Check that the filesize limit has not been exceeded
err=iFileServer.Volume(volumeInfo, EDriveC);
buf.Zero();
buf.AppendFormat(KFree, volumeInfo.iFree);
iLog->Put(buf);
if (volumeInfo.iFree < iCriticalLevel)
{
LogErrorAndLeave(_L("The max size limit has been exceeded!!!"));
}
//Check that the added landmarks can be read
iLog->Put(_L("Check that it is possible to read landmark"));
TInt nrOfLandmarks = lmIdArray.Count();
TInt p=0;
for (p=0;p<nrOfLandmarks;p++)
{
landmark = iLandmarksDb->ReadLandmarkLC(lmIdArray[p]);
CleanupStack::Pop(landmark);
}
// 3) Remove two landmarks and compress landmarks db
TInt nr = lmIdArray.Count()-1;
TPosLmItemId id = lmIdArray[nr];
iLog->Put(_L("Removing landmark1"));
lmIdArray.Remove(nr);
TRAP(err, iLandmarksDb->RemoveLandmarkL(id));
if (err == KErrDiskFull)
{
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
iLandmarksDb->RemoveLandmarkL(id);
iLog->Put(_L("DiskFull when removing1"));
}
nr = lmIdArray.Count() - 1;
id = lmIdArray[nr];
iLog->Put(_L("Removing landmark2"));
lmIdArray.Remove(nr);
iLandmarksDb->RemoveLandmarkL(id);
TRAP(err, iLandmarksDb->RemoveLandmarkL(id));
if (err == KErrDiskFull)
{
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
iLandmarksDb->RemoveLandmarkL(id);
iLog->Put(_L("DiskFull when removing2"));
}
err = KErrNone;
iLog->Put(_L("Compacting"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
startTime.UniversalTime();
iLog->Put(_L("Adding landmark until KErrDiskFull.....2"));
// 4) Add landmarks until "disk full" error occur!!!
while (err != KErrDiskFull)
{
buf.Zero();
buf.Format(_L("Land Mark___________%d"), i++);
landmark = CPosLandmark::NewLC();
landmark->SetLandmarkNameL(buf);
//iLog->Put(_L("Adding landmark id to idArray"));
TRAP(err, idde = iLandmarksDb->AddLandmarkL(*landmark));
if (err == KErrNone)
{
lmIdArray.Append(idde);
}
else if (err == KErrLocked)
{
iLog->Put(_L("KErrLocked when adding 2"));
User::After(100000);
}
CleanupStack::Pop(landmark);
}
stopTime.UniversalTime();
executionTime = stopTime.MicroSecondsFrom(startTime);
resse = executionTime.Int64()/1000000;
buf.Zero();
buf.Format(_L("Added %d nr of landmarks, took %d seconds"), i, resse);
iLog->Put(buf);
iLog->Put(_L("Check that it is possible to read landmark"));
//Check that the added landmarks can be read
nrOfLandmarks = lmIdArray.Count();
for (p=0;p<nrOfLandmarks;p++)
{
landmark = iLandmarksDb->ReadLandmarkLC(lmIdArray[p]);
CleanupStack::Pop(landmark);
}
iLog->Put(_L("Remove all landmarks"));
err = KErrNone;
// 5) Remove all landmarks and compact database
if (!aSync)
{
TRAP(err, op = iLandmarksDb->RemoveAllLandmarksL());
if (err == KErrNone)
{
ExecuteAndDeleteLD(op);
}
else if (err == KErrDiskFull)
{
iLog->Put(_L("KErrDiskFull when removing all landmarks"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
// Delete KFile2 to free more space on disc, method also open connection to iFile2 again
DeleteFile2L();
iLog->Put(_L("Removing after Compact sync"));
TRAP(err, op = iLandmarksDb->RemoveAllLandmarksL());
if (err == KErrDiskFull)
{
iLog->Put(_L("KErrDiskFull when Removing all landmarks after compact1"));
RemoveAllLandmarksL();
}
else
{
ExecuteAndDeleteLD(op);
}
}
}
else
{
iLog->Put(_L("Before RemoveAllLandmarksL(this)"));
TRAP(err, op = iLandmarksDb->RemoveAllLandmarksL());
if (err == KErrNone)
{
//***iActiveSchedulerWait->Start();
//***delete op; op=NULL;
RunAsyncOperationLD(op);
}
else if (err == KErrDiskFull)
{
iLog->Put(_L("KErrDiskFull when removing all landmarks"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
// Delete KFile2 to free more space on disc, method also open connection to iFile2 again
DeleteFile2L();
iLog->Put(_L("Removing after Compact async"));
TRAP(err, op = iLandmarksDb->RemoveAllLandmarksL());
if (err == KErrDiskFull)
{
iLog->Put(_L("KErrDiskFull when removing all landmarks after compact2"));
RemoveAllLandmarksL();
}
else
{
//***iActiveSchedulerWait->Start();
//***delete op; op=NULL;
RunAsyncOperationLD(op);
}
}
iLog->Put(_L("After RemoveAllLandmarksL(this)"));
}
ConsumeDiscSpace2L(iCriticalLevel + KSizeLimitOffset2);
if (err == KErrDiskFull) iLog->Put(_L("KErrDiskFull when RemoveAllLandmarksL"));
iLog->Put(_L("Compacting"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
lmIdArray.Reset();
i=0;
err = KErrNone;
startTime.UniversalTime();
iLog->Put(_L("Adding landmarkcategories until KErrDiskFull....."));
// 6) Add LandmarkCategories until "disk full" error occur
while (err != KErrDiskFull)
{
buf.Zero();
buf.Format(_L("Landmark Category _________ %d"), i++);
CPosLandmarkCategory* lmc = CPosLandmarkCategory::NewLC();
lmc->SetCategoryNameL(buf);
lmc->SetIconL(_L("Pelles Icon"), 111, KPosLmIconMaskNotUsed);
TRAP(err, idde = iCategoryManager->AddCategoryL(*lmc));
if (err == KErrNone)
{
lmIdArray.Append(idde);
}
else if (err== KErrLocked)
{
iLog->Put(_L("KErrLocked when adding category"));
User::After(100000);
}
CleanupStack::PopAndDestroy(lmc);
}
stopTime.UniversalTime();
executionTime = stopTime.MicroSecondsFrom(startTime);
resse = executionTime.Int64()/1000000;
buf.Zero();
buf.Format(_L("Added %d nr of landmarkcategories, took %d seconds"), i, resse);
iLog->Put(buf);
//Check that the added landmarkcategories can be read
TInt nrOfCategories = lmIdArray.Count();
for (p=0;p<nrOfCategories;p++)
{
CPosLandmarkCategory* lmc = iCategoryManager->ReadCategoryLC(lmIdArray[p]);
CleanupStack::Pop(lmc);
}
// 7) Remove two categories and compress landmarks db
nr = lmIdArray.Count()-1;
id = lmIdArray[nr];
iLog->Put(_L("Removing landmarkcategory1"));
lmIdArray.Remove(nr);
op=NULL;
TRAP(err, op = iCategoryManager->RemoveCategoryL(id));
if (err == KErrDiskFull)
{
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
ExecuteAndDeleteLD(iCategoryManager->RemoveCategoryL(id));
iLog->Put(_L("KErrDiskFull when removing landmarkcategory1"));
}
if (err == KErrNone)
{
ExecuteAndDeleteLD(op);
}
else
{
delete op;
op = NULL;
}
TBuf<50> buffe;
buffe.Format(_L("1) Err after RemoveCategoryL: %d"), err);
iLog->Put(buffe);
nr = lmIdArray.Count()-1;
id = lmIdArray[nr];
iLog->Put(_L("Removing landmarkcategory2"));
lmIdArray.Remove(nr);
if (!aSync)
{
TRAP(err, op = iCategoryManager->RemoveCategoryL(id));
if (err == KErrDiskFull)
{
delete op;
op = NULL;
iLog->Put(_L("KErrDiskFull when removing landmarkcategory2"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
iLog->Put(_L("After compact before removing landmarkcategory2"));
ExecuteAndDeleteLD(iCategoryManager->RemoveCategoryL(id));
}
else if (err == KErrNone)
{
ExecuteAndDeleteLD(op);
}
else if (err == KErrLocked)
{
iLog->Put(_L("KErrLocked returned from iCategoryManager->RemoveCategoryL"));
delete op;
op = NULL;
}
}
else
{
TRAP(err, op = iCategoryManager->RemoveCategoryL(id));
if (err == KErrNone)
{
//***iActiveSchedulerWait->Start();
//***delete op;
RunAsyncOperationLD(op);
}
else if (err == KErrDiskFull)
{
delete op;
op = NULL;
iLog->Put(_L("KErrDiskFull when removing landmarkcategory2 async"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
iLog->Put(_L("After compact before removing landmarkcategory2 async"));
op = iCategoryManager->RemoveCategoryL(id);
//***iActiveSchedulerWait->Start();
//***delete op;
RunAsyncOperationLD(op);
}
else if (err == KErrLocked)
{
delete op;
op = NULL;
iLog->Put(_L("KErrLocked returned from iCategoryManager->RemoveCategoryL"));
}
}
buffe.Zero();
buffe.Format(_L("2) Err after RemoveCategoryL: %d"), err);
iLog->Put(buffe);
iLog->Put(_L("Compacting"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
iLog->Put(_L("After Compacting"));
lmIdArray.Reset();
i=0;
err = KErrNone;
startTime.UniversalTime();
// 8) Add LandmarkCategories until "disk full" error occur
while (err != KErrDiskFull)
{
buf.Zero();
buf.Format(_L("LandmarkCategory %d"), i++);
CPosLandmarkCategory* lmc = CPosLandmarkCategory::NewLC();
lmc->SetCategoryNameL(buf);
lmc->SetIconL(_L("PellesIcon"), 111, KPosLmIconMaskNotUsed);
iLog->Put(buf);
TRAP(err, idde = iCategoryManager->AddCategoryL(*lmc));
if (err == KErrNone)
{
lmIdArray.Append(idde);
}
else if (err == KErrLocked)
{
iLog->Put(_L("KerrLocked when addCategory"));
User::After(100000);
}
CleanupStack::PopAndDestroy(lmc);
}
stopTime.UniversalTime();
executionTime = stopTime.MicroSecondsFrom(startTime);
resse = executionTime.Int64()/1000000;
buf.Zero();
buf.Format(_L("Added %d nr of landmarkcategories, took %d seconds"), i, resse);
iLog->Put(buf);
// 9) Remove all categories and compact db
// sync method
// XXXX add async check here
iLog->Put(_L("Removing all categories"));
TRAP(err, iCategoryManager->RemoveCategoriesL(lmIdArray));
if (err == KErrDiskFull) iLog->Put(_L("KErrDiskFull when RemoveCategoriesL"));
iLog->Put(_L("Compacting"));
ExecuteAndDeleteLD(iLandmarksDb->CompactL());
// 10) Consume more space then the limit specified in resource file
ConsumeDiscSpace1L(iCriticalLevel - KSizeLimitOffset2);
// 11) Try to add a landmark
buf.Zero();
buf.Format(_L("LandMark%d"), i++);
landmark = CPosLandmark::NewLC();
landmark->SetLandmarkNameL(buf);
TRAP(err, idde = iLandmarksDb->AddLandmarkL(*landmark));
if (err != KErrDiskFull)
{
buf.Zero();
buf.Format(_L("Should leave with KErrDiskFull instead %d"), err);
//LogErrorAndLeave(buf);
LogErrorAndLeave(buf);
}
CleanupStack::PopAndDestroy(landmark);
CleanupStack::PopAndDestroy(&lmIdArray);
}
/**
Called when async child completes with >=KErrNone
*/
void CImapOpSyncSubs::DoRunL()
{
// Finish if any server errors.
if (iStatus.Int()!=KErrNone)
{
Complete(iStatus.Int());
}
switch(iNextSyncAction)
{
case CImapSyncManager::EProcessRemoteSubscription:
{
// Call returned from the LSUB command. Now process the list.
// Update folder tree
TInt folderscount = iImapListFolderInfo.Count();
CImapListFolderInfo* folder;
for(TInt loop = 0;loop < folderscount; ++loop)
{
folder = iImapListFolderInfo[loop];
iSyncMan.AddSubscribedFolderFromInfoL(folder, iSession.LogId());
}
iSyncMan.CreateLocalFolderListL();
// Now do the remote subscription
iNextSyncAction = CImapSyncManager::EUpdateRemoteSubscription;
CompleteSelf();
SetActive();
}
break;
case CImapSyncManager::EUpdateRemoteSubscription:
{
// Process the subscribed and unsubscribed list from the SyncManager.
// This should be done after checking the online subscription list.
RArray<TUint>* unsubscribeList = iSyncMan.GetUnSubscribedFolderToDoList();
RArray<TUint>* subscribeList = iSyncMan.GetSubscribedFolderToDoList();
// Any subscription to do?
if (subscribeList->Count())
{
// Take it off the head
TMsvId folderid = (*subscribeList)[0];
subscribeList->Remove(0);
// Subscribe to it
CImapFolder* tempfolder = iSyncMan.GetTempFolderL(folderid);
CleanupStack::PushL(tempfolder);
iSession.SubscribeL(iStatus, tempfolder->FullFolderPathL());
CleanupStack::PopAndDestroy(tempfolder);
// set the subscribed flag for the folder.
SetEntryL(folderid);
TMsvEmailEntry entry = iServerEntry.Entry();
entry.SetSubscribed(ETrue);
ChangeEntryL(entry);
SetActive();
}
// ...or unsubscription?
else if (unsubscribeList->Count())
{
// Take it off the head
TMsvId folderid = (*unsubscribeList)[0];
unsubscribeList->Remove(0);
// Unsubscribe from it
CImapFolder* tempfolder = iSyncMan.GetTempFolderL(folderid);
CleanupStack::PushL(tempfolder);
iSession.UnsubscribeL(iStatus, tempfolder->FullFolderPathL());
CleanupStack::PopAndDestroy(tempfolder);
// clear the subscribed flag for the folder.
SetEntryL(folderid);
TMsvEmailEntry entry = iServerEntry.Entry();
entry.SetSubscribed(EFalse);
ChangeEntryL(entry);
SetActive();
}
else
{
// All done.
iNextSyncAction = CImapSyncManager::ENotSyncing;
Complete(iStatus.Int());
}
}
break;
default:
break;
}
}
// ---------------------------------------------------------------------------
// CAtSmsStoreReadAll::ParseResponseL
// other items were commented in a header
// ---------------------------------------------------------------------------
void CAtSmsStoreReadAll::ParseResponseL(const TDesC8& /*aResponseBuf*/)
{
/**
* Response:+CMGR:<stat>,[<alpha>],<length><CR><LF><pdu>
*/
iError = KErrNone;
RArray<TPtrC8> array;
CleanupClosePushL(array);
iParser->ParseRespondedBuffer(array,Buffer());
if(array[0].MatchF(KAnyATCommand)!=KErrNotFound)
{
array.Remove(0);
}
TInt count = array.Count();
#ifdef _DEBUG
for( TInt i=0;i<count;i++ )
{
LOGTEXT3(_L8("CAtSmsStoreReadAll::ParseResponseL\tarray[%d]=%S"),i,&array[i]);
}
#endif
if (count <= 1)
{
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
if(array[0].MatchF(KCMGRResponseString)==KErrNotFound)
{
LOGTEXT(_L8("CAtSmsStoreReadAll::ParseResponseL\tFound +CMGR String!"));
CleanupStack::PopAndDestroy();
iError = KErrNotFound;
return;
}
// parse the message status
TLex8 lex(array[1]);
TUint16 val;
TInt ret=lex.Val(val,EDecimal);
if(ret!=KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
iSmsData.iMessageStatus = val;
//parse the message length
TLex8 lex1(array[3]);
TUint msgLength;
ret=lex1.Val(msgLength,EDecimal);
if(ret!=KErrNone)
{
CleanupStack::PopAndDestroy();
iError = ret;
return;
}
LOGTEXT2(_L8("CAtSmsStoreReadAll::ParseResponseL\tMessage Length=%d"),msgLength);
TBuf8<KMaxAsciiPduLength> pdu; //Binary Message pdu
SmsAtUtil::ConvertAsciiToBinary(array[4],pdu);
TPtrC8 pduPtr(pdu);
RMobilePhone::TMobileAddress gsmServiceCentre; //messages's SCA
if (msgLength*2 < array[4].Length())
{
// There is an SCA prepended so remove this and store it in iGsmServiceCentre
SmsAtUtil::ReadAndRemoveAddressFromPdu(pduPtr,gsmServiceCentre);
}
iSmsData.iSmsMsg = pduPtr;
iSmsData.iServiceCentre = gsmServiceCentre.iTelNumber;
iSmsData.iMobileScNPI = gsmServiceCentre.iNumberPlan;
iSmsData.iMobileScTON = gsmServiceCentre.iTypeOfNumber;
LOGTEXT2(_L8("CAtSmsStoreReadAll::ParseResponseL\tMessage Status=%d"),
iSmsData.iMessageStatus);
LOGTEXT3(_L8("CAtSmsStoreReadAll::ParseResponseL\tSmsMsg=%S, ServiceCentre=%S"),
&iSmsData.iSmsMsg, &iSmsData.iServiceCentre);
CleanupStack::PopAndDestroy(&array);
}
