// -----------------------------------------------------------------------------
// CSIPMessage::ReplaceHeadersL
// -----------------------------------------------------------------------------
//
EXPORT_C void
CSIPMessage::ReplaceHeadersL (RPointerArray<CSIPHeaderBase>& aNewHeaders)
{
__ASSERT_ALWAYS (aNewHeaders.Count() > 0, User::Leave(KErrArgument));
__ASSERT_ALWAYS (aNewHeaders[0] != 0, User::Leave(KErrArgument));
RStringF name = aNewHeaders[0]->Name();
for (TInt i=1; i < aNewHeaders.Count(); i++)
{
__ASSERT_ALWAYS (aNewHeaders[i] != 0, User::Leave(KErrArgument));
__ASSERT_ALWAYS (name == aNewHeaders[i]->Name(),
User::Leave(KErrArgument));
}
TInt headerListIndex = FindHeaderListIndex (name);
__ASSERT_ALWAYS (headerListIndex >= 0, User::Leave(KErrArgument));
// Remove old headers
TSglQueIter<CSIPHeaderBase> iter(iSIPHeaderListArray[headerListIndex]);
while (iter)
{
CSIPHeaderBase* header = iter++;
delete header;
}
iSIPHeaderListArray[headerListIndex].Reset();
// Add new headers
for (TInt j=0; j < aNewHeaders.Count(); j++)
{
iSIPHeaderListArray[headerListIndex].AddLast(*aNewHeaders[j]);
}
aNewHeaders.Reset();
}
// -----------------------------------------------------------------------------
// CMCETestUIEngineProfileContainer::ConstructL
// -----------------------------------------------------------------------------
//
void CMCETestUIEngineProfileContainer::ConstructL()
{
iProfileRegistry = CSIPProfileRegistry::NewL( iSip, *this );
// Instantiate and store all profiles
RPointerArray<CSIPProfile> profiles;
iProfileRegistry->ProfilesL( profiles );
for ( TInt i = 0; i < profiles.Count(); ++i )
{
CMCETestUIEngineProfile* item =
CMCETestUIEngineProfile::NewL( profiles[i], iEngine );
CleanupStack::PushL( item );
User::LeaveIfError( iProfiles.Append( item ) );
CleanupStack::Pop( item );
}
profiles.Reset();
if ( MCETestUIEngineDefaultValues::TakeDefaultProfileIntoUse() )
{
TakeProfileIntoUseL( GetDefaultProfileL() );
}
}
// -----------------------------------------------------------------------------
// CCLFDefaultOperation::SortItemsL
// -----------------------------------------------------------------------------
//
void CCLFDefaultOperation::SortItemsL( RPointerArray<MCLFItem>& aItemArray )
{
if( iSortingStyle )
{
RPointerArray<MCLFItem> array;
CleanupClosePushL( array );
RPointerArray<MCLFItem> array1;
CleanupClosePushL( array1 );
RPointerArray<MCLFItem>* undefinedItemArray = &array;
RPointerArray<MCLFItem>* newUndefinedItemArray = &array1;
SortItemsBySortingStyleL( aItemArray,
*iSortingStyle,
*undefinedItemArray );
TInt lastAddedItemCount( aItemArray.Count() );
TInt nextItemIndex( lastAddedItemCount );
TCLFUndefinedItemPosition position(
iSortingStyle->UndefinedItemPosition() );
const TInt secondarySorterCount( iSortingStyleArray.Count() );
for( TInt i = 0 ; i < secondarySorterCount ; ++i )
{
MCLFSortingStyle& sortingStyle = *iSortingStyleArray[i];
newUndefinedItemArray->Reset();
// sort undefined items
SortItemsBySortingStyleL( *undefinedItemArray,
sortingStyle,
*newUndefinedItemArray );
// append sorted items to aItemArray
AppendItemsToArrayL( undefinedItemArray->Array(),
aItemArray,
position,
nextItemIndex,
lastAddedItemCount );
position = sortingStyle.UndefinedItemPosition();
// change pointers
RPointerArray<MCLFItem>* tmp = undefinedItemArray;
undefinedItemArray = newUndefinedItemArray;
newUndefinedItemArray = tmp;
}
// copy rest undefined items to correct position
AppendItemsToArrayL( undefinedItemArray->Array(),
aItemArray,
position,
nextItemIndex,
lastAddedItemCount );
// close undefined arrays
CleanupStack::PopAndDestroy( 2, &array );
}
// else no sorting
}
// ----------------------------------------------------------
// CSimplePresenceList::GetDocuments
// ----------------------------------------------------------
//
void CSimplePresenceList::GetDocuments( RPointerArray<MSimpleDocument>& aDocs )
{
aDocs.Reset();
TInt size = iDocuments.Count();
for ( TInt i = 0; i<size ; i++ )
{
(void)aDocs.Append( iDocuments[i] );
}
}
// ----------------------------------------------------------
// CSimplePresenceList::GetSubLists
// ----------------------------------------------------------
//
void CSimplePresenceList::GetSubLists( RPointerArray<MSimplePresenceList>& aLists )
{
aLists.Reset();
TInt size = iPresList.Count();
for ( TInt i = 0; i<size ; i++ )
{
(void)aLists.Append( iPresList[i] );
}
}
// -----------------------------------------------------------------------------
// CSvgTimeContainer::UserPlay
// Called to handle user/client generated play event
// -----------------------------------------------------------------------------
//
void CSvgTimeContainer::UserPlay()
{
if ( !iTimer )
{
// Check whether this time container has a parent
// then we do not have to create the timer
if ( !iIsParentTcPresent )
{
// Obtain the post order list of media elements
RPointerArray<CSvgElementImpl> lMediaEleList;
lMediaEleList.Reset();
CSvgElementImpl *handle = (CSvgElementImpl *)(iOwnerDoc->RootElement());
//Parse postorderr only if there are media elements
if(iTcTimedEntities.Count() > 1 )
{
iOwnerDoc->ParsePostOrderMediaElements( handle, lMediaEleList );
}
// Rearrange as per Post order
RearrangeTimedEntityList( lMediaEleList );
// Done with the list
lMediaEleList.Close();
TRAPD( lTimerCreateErr, iTimer = CSvgTimer::NewL( this ) );
if ( lTimerCreateErr != KErrNone )
{
// Error Processing
return;
}
iTimer->SetStartTime();
// the current home time needs to be updated.
if ( iOwnerDoc && iCurrentTime != 0 )
{
iCurrentTime = 0;
iCurrentTick.iParentTcTick = 0;
iCurrentTick.iRealTimeTick = 0;
TSvgTimerEvent timeEvent( iCurrentTime );
iOwnerDoc->Reset( &timeEvent );
}
if ( !iTimer->IsActive() )
{
iTimer->After( 1000 );
}
}
}
}
void CRecognizerContainer::StopDisplay()
{
CALLSTACKITEM_N(_CL("CRecognizerContainer"), _CL("StopDisplay"));
if (owns_bitmap) delete iBitmap; iBitmap=0;
delete iVCS; iVCS=0;
delete iCurrentCodeInfo; iCurrentCodeInfo=0;
iCurrentCodeArray->Reset();
iStandByLabel->MakeVisible(ETrue);
DrawDeferred();
}
// -----------------------------------------------------------------------------
// CSIPProfileRegistryBase::StoreProfileL
// -----------------------------------------------------------------------------
//
void CSIPProfileRegistryBase::StoreArrayL(
RPointerArray<CSIPConcreteProfile>& aProfiles,
RPointerArray<CSIPProfile>& aRetProfiles)
{
int count = aProfiles.Count();
for (TInt i = 0; i < count; i++)
{
TUint profileId = (aProfiles[0])->Id();
TInt index = ProfileIndex(profileId);
CSIPProfileCleanupItem* cleanupItem = new (ELeave) CSIPProfileCleanupItem(iITC);
CleanupStack::PushL(cleanupItem);
if(index == KErrNotFound)
{
CleanupStack::PushL(TCleanupItem(CrashRevert, cleanupItem));
cleanupItem->iProfileId = (aProfiles[0])->Id();
cleanupItem->iConcreteProfile = aProfiles[0];
aProfiles.Remove(0);
StoreProfileL(cleanupItem);
User::LeaveIfError(aRetProfiles.Append(cleanupItem->iManagedProfile));
}
else
{
CleanupStack::PushL(TCleanupItem(LocalCrashRevert, cleanupItem));
CSIPProfileItem* item = ProfileItemL(profileId);
CSIPProfile* managed = NewInstanceL();
cleanupItem->iManagedProfile = managed;
managed->SetConcreteProfile(&(item->ConcreteProfile()));
managed->SetEnabled(item->IsEnabled());
item->IncrementReferenceCountL(*managed);
User::LeaveIfError(aRetProfiles.Append(managed));
CSIPConcreteProfile* profileNotUsed = aProfiles[0];
aProfiles.Remove(0);
delete profileNotUsed;
}
}
aProfiles.Reset();
for (TInt j = 0; j < count; j++)
{
CleanupStack::Pop(); //TCleanupItem
CleanupStack::PopAndDestroy(); //cleanupItem
}
}
/**
Returns an array containing the MetaDataEntry for the given audio clip
@param aMetaArray
The meta data Array
@leave Leaves with KErrNotFound if the meta data entry does not exist or
KErrNotSupported if the controller does not support meta data
information for this format. Other errors indicate more general system
failure.
*/
EXPORT_C void CMVSAudioPlayAgent::GetMetaArrayL(RPointerArray<CMMFMetaDataEntry>& aMetaArray)
{
//Reset the meta array
aMetaArray.Reset();
//Find how many elements there are to obtain
TInt noMetaEntries = 0;
TInt err = iPlayer->GetNumberOfMetaDataEntries(noMetaEntries);
if(err == KErrNone)
{
//Add the elements, one at a time.
for(TInt counter = 0; counter < noMetaEntries; ++counter)
{
aMetaArray.Append(iPlayer->GetMetaDataEntryL(counter));
}
}
User::LeaveIfError(err);
}
void CDummyCalendarApp::ExtractNonExistentEntryL()
{
RPointerArray<CCalEntry> entryArray;
CleanupStack::PushL(TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray));
// Passing string type UID parameter and expecting entryArray to be empty
iEntryView->FetchL( _L8("myuid"), entryArray);
test(entryArray.Count() == 0);
entryArray.Reset();
// Passing integer type UID parameter and expecting entryArray to be empty
iEntryView->FetchL( _L8("10"), entryArray);
test(entryArray.Count() == 0);
CleanupStack::Pop(); // TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray)
entryArray.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
// CSvgTimeContainer::AddTimedEntityL
// Add a timed entity to the time container.
// -----------------------------------------------------------------------------
//
void CSvgTimeContainer::AddTimedEntityL(
MSvgTimedEntityInterface* aTimedEntity )
{
if ( !aTimedEntity )
{
User::Leave( KErrArgument );
}
// check to see if entity is already in list and simply return
TInt lTimedEntityListCnt = iTcTimedEntities.Count();
for ( TInt lItemIndex = lTimedEntityListCnt - 1; lItemIndex >= 0 ; lItemIndex-- )
{
if ( (iTcTimedEntities[ lItemIndex ]).iTimedEntity == aTimedEntity )
{
return;
}
}
TSvgTimedEntityListItem lListItem;
lListItem.iTimedEntity = aTimedEntity;
//Media State initially Idle
lListItem.iMediaState = ESvgMediaIdle;
//User state initially is running
lListItem.iUserState =ESvgUserRunning ;
// Sync State is Playing
lListItem.iIsSyncPaused = EFalse;
// Append to Timed Entity List
iTcTimedEntities.AppendL( lListItem );
// Obtain the post order list of media elements
RPointerArray<CSvgElementImpl> lMediaEleList;
lMediaEleList.Reset();
CSvgElementImpl *handle = (CSvgElementImpl *)(iOwnerDoc->RootElement());
iOwnerDoc->ParsePostOrderMediaElements( handle, lMediaEleList );
// Rearrange as per Post order
RearrangeTimedEntityList( lMediaEleList );
// Done with the list
lMediaEleList.Close();
}
/**
* Parse a file with base64 encoding.
*
* @param aFile filename to be read in.
* @param aUrl ??? //DEBUG
* @param aOutput name out output file.
*/
void CMultipartTestContainer::ParseFileL( const TDesC& aFile,
const TDesC& aUrl,
const TDesC& aOutput )
{
// body
HBufC8* data = ReadFileLC( aFile );
// content type
_LIT8(KMultipartMixed, "multipart/mixed");
// boundary
_LIT8(KBoundary1, "KBoundary");
// body part array
RPointerArray<CBodyPart> bodyPartArray;
// parse
TInt err;
if( aUrl.Ptr() )
{
TRAP( err, MultipartParser::ParseL( *data, KMultipartMixed, KBoundary1, aUrl, bodyPartArray ) );
}
else
{
TRAP( err, MultipartParser::ParseL( *data, KMultipartMixed, KBoundary1, aFile, bodyPartArray ) );
}
if (err != KErrNone)
{
INFO_PRINTF1(_L("Error parsing file."));
}
// output
WriteFileL( aOutput, bodyPartArray);
// clean up memory
CleanupStack::PopAndDestroy(); // data
// clean up body part array and its content
TInt size = bodyPartArray.Count();
TInt i;
for (i = 0; i < size; i++)
{
delete bodyPartArray[i];
}
bodyPartArray.Reset();
}
/**
* Update entries
* Care is taken to ensure that updateL is not performed on the Child Entries
*/
void CTestCalInterimApiModifier::UpdateEntriesL()
{
RPointerArray<CCalEntry> updatedEntries;
CleanupStack::PushL(TCleanupItem(ResetAndDestroyEntryArray, &updatedEntries));
const TInt KUidCount(iModifier->iEntryArray.Count());
for (TInt j(0) ; j < KUidCount ; ++j)
{
RPointerArray<CCalEntry> calEntries;
CleanupStack::PushL(TCleanupItem(ResetAndDestroyEntryArray, &calEntries));
TCalTime recurrenceId = iModifier->iEntryArray[j]->RecurrenceIdL();
TTime recurrenceIdInTTime = recurrenceId.TimeUtcL();
TTime recurNullTime = Time::NullTTime();
if(recurrenceIdInTTime != recurNullTime)
{
continue;
}
TPtrC8 desiredGuid(iModifier->iEntryArray[j]->UidL());
iEntryView->FetchL(desiredGuid, calEntries);
// update of entries can be performed only on the parent entry
calEntries[0]->SetLastModifiedDateL();
updatedEntries.Append(calEntries[0]);
calEntries.Reset();
CleanupStack::Pop(&calEntries);
}
TInt numSuccessful(0);
iTestStep->INFO_PRINTF1(KModifyOperation);
TRAPD(err, iEntryView->UpdateL(updatedEntries, numSuccessful));
TESTL( numSuccessful == updatedEntries.Count() );
if(err != KErrNone)
{
iTestStep->ERR_PRINTF2(KErrUpdateOperation,err);
iTestStep->SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(); //UpdateEntries
}
void CSCOMOAdapterDb::GetEntryForServerIDL(RPointerArray<CAMDbItem>& aItemArray,
TDesC8& aValue)
{
aItemArray.Reset();// first reset the array
_LIT(KEqualToString,"='%S'");
_LIT(KQuery, "SELECT * FROM %S WHERE %S");
TBuf<256> serverid;
serverid.Copy(aValue);
TBuf<100> bufsql;
bufsql.Append(KQuery);
bufsql.Append(KEqualToString);
TBuf<100> bufsql1;
bufsql1.Format(bufsql, &KTableAMMgmtObject, &NCol4, &serverid);
ReadItemsL(aItemArray, bufsql1);
}
// ==========================================================================
// FUNCTION: InitializeL
// ==========================================================================
void CContainerStoreSearchHandler::InitializeL( TMsgStoreSearchCmdParams& aCmdParams,
RArray<TContainerId>& aFolderIds,
RPointerArray<HBufC8>& aPropertyNames )
{
iSearchParams = aCmdParams;
iFolderIds.Reset();
for( TInt i = 0 ; i < aFolderIds.Count() ; i++ )
{
iFolderIds.AppendL( aFolderIds[i] );
}
iPropertyNames.ResetAndDestroy();
for ( TInt i = 0 ; i < aPropertyNames.Count() ; i++ )
{
iPropertyNames.AppendL( aPropertyNames[i] );
}
aPropertyNames.Reset();
delete iSortResultSet;
iSortResultSet = NULL;
}
// -----------------------------------------------------------------------------
// SortItemsBySortingStyleL
// sort aItemArray with aSortingStyle
// add undefined items to aUndefinedItemArray
// -----------------------------------------------------------------------------
//
void SortItemsBySortingStyleL( RPointerArray<MCLFItem>& aItemArray,
MCLFSortingStyle& aSortingStyle,
RPointerArray<MCLFItem>& aUndefinedItemArray )
{
RArray<TCLFFieldId> sortingFields;
CleanupClosePushL( sortingFields );
aSortingStyle.GetFieldsL( sortingFields );
const TInt sortingFieldsCount( sortingFields.Count() );
if( sortingFieldsCount ) // sort only if there are sorting fields
{
TCLFItemDataType sortingDataType( aSortingStyle.SortingDataType() );
RArray<TCLFSortingItem> sortingArray;
CleanupClosePushL( sortingArray );
MakeSortingItemsL( sortingArray,
aUndefinedItemArray,
aItemArray.Array(),
sortingFields.Array(),
sortingDataType );
SortSortingItemsL( sortingArray, sortingDataType );
aItemArray.Reset();
if( aSortingStyle.Ordering() == ECLFOrderingAscending )
{
AppendSortingItemsToArrayL( sortingArray.Array(),
aItemArray );
}
else
{
AppendSortingItemsToArrayReverseL( sortingArray.Array(),
aItemArray );
}
CleanupStack::PopAndDestroy( &sortingArray ); // sortingArray.Close
}
CleanupStack::PopAndDestroy( &sortingFields ); // sortingFields.Close
}
//----------------------------------------------------------------
// CLbsLocMonitorConversionHandler::CacheLookupL
// (other items were commented in a header).
//----------------------------------------------------------------
TBool CLbsLocMonitorConversionHandler::CacheLookupL()
{
iCachePartialResults.Reset();
// Does NOT own contents
iSubsetLocationInfoArray.Reset();
TInt infoCount = iLocationInfoArray.Count();
// We only do lookups if the client wants a position
if(iRequestedInfo != ELbsConversionOutputPosition)
{
// copy all into subset array, the cache has solved nothing
for(TInt i = 0; i < infoCount; i++)
{
iSubsetLocationInfoArray.AppendL(iLocationInfoArray[i]);
}
return EFalse;
}
TInt cacheLoads = 0;
TBool resolved = EFalse;
for(TInt i=0; i < infoCount; i++)
{
CLbsLocationInfo* locationInfo = static_cast<CLbsLocationInfo*>(iLocationInfoArray[i]);
RLbsAreaInfoBaseArray areaArray;
CleanupStack::PushL(TCleanupItem(*CleanUpResetAndDestroy, &areaArray));
// NOTE! When locmonitor is expanded to cache wlan etc. this call must be changed!
// Currently we know about GSM and 3g (WCDMA).
locationInfo->GetAreaInfoL(areaArray, CLbsLocationInfo::ELbsGsmInfo|CLbsLocationInfo::ELbsWcdmaInfo);
TInt areaCount = areaArray.Count();
TBool saved = EFalse;
TRealX nan;
nan.SetNaN();
TLocality partialLocality;
partialLocality.SetCoordinate(nan, nan, nan);
partialLocality.SetAccuracy(nan, nan);
for (TInt j = 0; j < areaCount; j++)
{
resolved = EFalse;
TLbsAreaInfoClassType type = areaArray[j]->Type();
TLbsLocMonitorAreaInfoGci areaInfoGci;
switch(type)
{
case ELbsAreaGsmCellInfoClass:
{
CLbsGsmCellInfo* area = static_cast<CLbsGsmCellInfo*>(areaArray[j]);
areaInfoGci.iMcc = area->MobileCountryCode();
areaInfoGci.iMnc = area->MobileNetworkCode();
areaInfoGci.iLac = area->LocationAreaCode();
areaInfoGci.iCid = area->CellId();
areaInfoGci.iValidity = ETrue;
areaInfoGci.iIs3gNetworkMode = EFalse;
resolved = ETrue;
break;
}
case ELbsAreaWcmdaCellInfoClass :
{
CLbsWcdmaCellInfo* area = static_cast<CLbsWcdmaCellInfo*>(areaArray[j]);
areaInfoGci.iMcc = area->MobileCountryCode();
areaInfoGci.iMnc = area->MobileNetworkCode();
areaInfoGci.iLac = area->LocalAreaCode();
areaInfoGci.iCid = area->UniqueCellId();
areaInfoGci.iValidity = ETrue;
areaInfoGci.iIs3gNetworkMode = ETrue;
resolved = ETrue;
break;
}
default:
{
resolved = EFalse;
break;
}
}
if(resolved && !saved)
{
TPosition position;
RPointerArray<TLbsLocMonitorAreaInfoBase> outArray;
outArray.Append(&areaInfoGci);
TPositionAreaExtendedInfo matchLevel;
matchLevel.SetArea(TPositionAreaInfo::EAreaUnknown);
TRequestStatus status;
// Cache gets are fast and not really asynch, so no harm in blocking here
TInt ret = iCache.GetPosition(position,outArray,matchLevel,status);
if((ret == KErrNone) || (ret == KErrNotFound))
{
User::WaitForRequest(status);
}
outArray.Reset();
if((ret == KErrNone) && (matchLevel.Area() >= TPositionAreaExtendedInfo::EAreaCity))
{
TLocality locality;
locality.SetCoordinate(position.Latitude(), position.Longitude(),
position.Altitude());
TRealX nan;
nan.SetNaN();
locality.SetAccuracy(AccuracyFromMatchLevel(matchLevel.Area()), nan);
CLbsPositionInfo* positionInfo = CLbsPositionInfo::NewL(locality);
CleanupStack::PushL(positionInfo);
iLocationInfoArray[i]->AddAreaInfoL(positionInfo);
CleanupStack::Pop(positionInfo);
saved = ETrue;
cacheLoads++;
}
else if ((ret == KErrNone) && (matchLevel.Area() > TPositionAreaExtendedInfo::EAreaUnknown))
{
// we also store partial matches in case they are better than the plugin response
partialLocality.SetCoordinate(position.Latitude(), position.Longitude(),
position.Altitude());
TRealX nan;
nan.SetNaN();
partialLocality.SetAccuracy(AccuracyFromMatchLevel(matchLevel.Area()), nan);
}
}
}
if(!saved)
{
//copy into subset array, we couldn't solve this from cache
iSubsetLocationInfoArray.AppendL(iLocationInfoArray[i]);
iCachePartialResults.AppendL(partialLocality);
}
CleanupStack::PopAndDestroy(&areaArray);
}
// If we've loaded as many results from the cache as there are requests
// then we have fully satisfied the query
return cacheLoads == infoCount;
}
//----------------------------------------------------------------
// CLbsLocMonitorConversionHandler::CacheSaveL
// (other items were commented in a header).
//----------------------------------------------------------------
TBool CLbsLocMonitorConversionHandler::CacheSaveL()
{
iState = EStateCacheSave;
TBool saveRequested = EFalse;
TInt infoCount = iSubsetLocationInfoArray.Count();
while((iSavedToCacheCount < infoCount) && !saveRequested)
{
CLbsLocationInfo* locationInfo = static_cast<CLbsLocationInfo*>(iSubsetLocationInfoArray[iSavedToCacheCount]);
RLbsAreaInfoBaseArray cellArray;
CleanupStack::PushL(TCleanupItem(*CleanUpResetAndDestroy, &cellArray));
locationInfo->GetAreaInfoL(cellArray, CLbsLocationInfo::ELbsGsmInfo | CLbsLocationInfo::ELbsWcdmaInfo);
RLbsAreaInfoBaseArray locationArray;
CleanupStack::PushL(TCleanupItem(*CleanUpResetAndDestroy, &locationArray));
locationInfo->GetAreaInfoL(locationArray, CLbsLocationInfo::ELbsPosInfo);
// We should get only 1 pos back but may have passed in multiple cells
// We want to save that pos against all cells
if((locationArray.Count() > 0) && (cellArray.Count() > 0))
{
CLbsPositionInfo* location = static_cast<CLbsPositionInfo*>(locationArray[0]);
TLocality locality;
location->GetLocality(locality);
// Only locations that have an accuracy that is better than a cell
// location code will be saved in the cache
if(locality.HorizontalAccuracy() < KCellLocationAccuracy)
{
for(TInt i = 0; i < cellArray.Count(); i++)
{
TLbsLocMonitorAreaInfoGci areaInfoGci;
if (cellArray[i]->Type() == ELbsAreaGsmCellInfoClass)
{
CLbsGsmCellInfo* cell = static_cast<CLbsGsmCellInfo*>(cellArray[i]);
areaInfoGci.iMcc = cell->MobileCountryCode();
areaInfoGci.iMnc = cell->MobileNetworkCode();
areaInfoGci.iLac = cell->LocationAreaCode();
areaInfoGci.iCid = cell->CellId();
areaInfoGci.iValidity = ETrue;
areaInfoGci.iIs3gNetworkMode = EFalse;
}
else
{
// by elimination type must be ELbsAreaWcmdaCellInfoClass!
CLbsWcdmaCellInfo* cell = static_cast<CLbsWcdmaCellInfo*>(cellArray[i]);
// If we don't have a valid LAC (which may happen with WCDMA) then we cannot
// save to the cache and we should go to the next cell immediately.
if (cell->LocalAreaCode() == -1)
continue;
areaInfoGci.iMcc = cell->MobileCountryCode();
areaInfoGci.iMnc = cell->MobileNetworkCode();
areaInfoGci.iLac = cell->LocalAreaCode();
areaInfoGci.iCid = cell->UniqueCellId();
areaInfoGci.iValidity = ETrue;
areaInfoGci.iIs3gNetworkMode = ETrue;
}
RPointerArray<TLbsLocMonitorAreaInfoBase> areaArray;
areaArray.Append(&areaInfoGci);
TTime now;
now.HomeTime();
TPosition pos(locality, now);
TInt ret = iCache.SavePosition(pos, areaArray, EFalse, iStatus);
if(ret != KErrNone)
{
saveRequested = EFalse;
}
else
{
saveRequested = ETrue;
SetActive();
}
areaArray.Reset();
}
}
}
CleanupStack::PopAndDestroy(&locationArray);
CleanupStack::PopAndDestroy(&cellArray);
iSavedToCacheCount++;
}
if((iSavedToCacheCount >= infoCount) && !saveRequested)
{
return ETrue;
}
return EFalse;
}
void CRecognizerContainer::ShowCodes(const TRect& aDrawRect, const TSize& aBmpSize) const
{
CALLSTACKITEM_N(_CL("CRecognizerContainer"), _CL("ShowCodes"));
RPointerArray<CCodeInfo>* Codes=0;
TInt CurrentCode; bool draw_rect=true;
if (!iVCS || iVCS->GetCodes() == NULL || iVCS->GetCodes()->Count()==0 || iInvalid) {
if (!iCurrentCodeInfo) return;
iCurrentCodeArray->Reset();
User::LeaveIfError(iCurrentCodeArray->Append(iCurrentCodeInfo));
Codes=iCurrentCodeArray;
CurrentCode=0;
if (iVCS || iInvalid) draw_rect=false;
} else {
Codes=iVCS->GetCodes();
CurrentCode=iCurrentCode;
}
TInt xd = aDrawRect.iTl.iX;
TInt yd = aDrawRect.iTl.iY;
TInt hd = aDrawRect.Height();
TInt wd = aDrawRect.Width();
TInt hi = aBmpSize.iHeight;
TInt wi = aBmpSize.iWidth;
CWindowGc& gc = SystemGc();
gc.SetPenStyle(CGraphicsContext::ESolidPen);
TInt n = Codes->Count();
// draw frames around the codes
if (draw_rect) {
for (TInt i = 0; i < n; i++) {
CCodeInfo* ci = (*Codes)[i];
gc.SetPenColor(ci->IsCodeValid() ? KRgbYellow : KRgbRed);
gc.SetPenSize(i != CurrentCode ? TSize(1,1) : TSize(2,2));
TPoint rb = ci->GetImageCoordinates(TPoint(10,10));
gc.DrawLine(TPoint(xd + rb.iX*wd/wi, yd + rb.iY*hd/hi),
TPoint(xd + ci->x2*wd/wi, yd + ci->y2*hd/hi));
gc.DrawLine(TPoint(xd + rb.iX*wd/wi, yd + rb.iY*hd/hi),
TPoint(xd + ci->x4*wd/wi, yd + ci->y4*hd/hi));
gc.DrawLine(TPoint(xd + ci->x1*wd/wi, yd + ci->y1*hd/hi),
TPoint(xd + ci->x2*wd/wi, yd + ci->y2*hd/hi));
gc.DrawLine(TPoint(xd + ci->x4*wd/wi, yd + ci->y4*hd/hi),
TPoint(xd + ci->x1*wd/wi, yd + ci->y1*hd/hi));
}
}
gc.SetPenSize(TSize(1,1));
// display value of current code
if (CurrentCode >= 0 && CurrentCode < Codes->Count()) {
CCodeInfo* ci = (*Codes)[CurrentCode];
TBuf<64> info;
// code value
ci->code->AppendToString(info);
gc.SetPenColor(KRgbYellow);
gc.SetBrushStyle(CGraphicsContext::ENullBrush);
const CFont* fontUsed = iEikonEnv->DenseFont();
gc.UseFont(fontUsed);
TInt baseline = aDrawRect.Height() - 2 * fontUsed->AscentInPixels();
info.Copy(*iScreenMsgBuf);
gc.DrawText(info, aDrawRect, baseline, CGraphicsContext::ECenter);
}
}
void CTestCalIndexFileModifyEntryStep::ModifyEntryL()
{
TPtrC entryString;
TBool readRes = EFalse;
readRes = GetStringFromConfig(ConfigSection(), KModifyEntry, entryString);
if (!readRes)
{
INFO_PRINTF1(_L("Error in CTestCalIndexFileModifyEntryStep::ModifyEntryL - entrytomodify not found in config file"));
User::Leave(KErrNotFound);
}
CConfigTestEntryInfo* inf = new(ELeave)CConfigTestEntryInfo();
CleanupStack::PushL(inf);
ParseEntryStringL(*inf, entryString);
// see if we can find a match in the database using an instance view
CCalProgress* progress = new(ELeave)CCalProgress;
CleanupStack::PushL(progress);
CCalInstanceView* view = CCalInstanceView::NewL(*iSession, *progress);
CleanupStack::PushL(view);
CActiveScheduler::Start();
CalCommon::TCalViewFilter filter = CalCommon::EIncludeAppts;
switch (inf->iType)
{
case (CCalEntry::EAppt):
filter = CalCommon::EIncludeAppts;
break;
case (CCalEntry::ETodo):
filter = CalCommon::EIncludeCompletedTodos | CalCommon::EIncludeIncompletedTodos;
break;
case (CCalEntry::EEvent):
filter = CalCommon::EIncludeEvents;
break;
case (CCalEntry::EReminder):
filter = CalCommon::EIncludeReminder;
break;
case (CCalEntry::EAnniv):
filter = CalCommon::EIncludeAnnivs;
break;
default:
User::Leave(KErrCorrupt);
break;
}
RPointerArray<CCalInstance> instances;
CleanupClosePushL(instances);
// look for instances between (startdate -1 day) and
// (enddate + 1 day)
TTimeIntervalDays oneDay(1);
TTime beginTTime = (inf->iStartTime) - oneDay;
TTime endTTime = (inf->iEndTime) + oneDay;
TCalTime begin;
begin.SetTimeUtcL(beginTTime);
TCalTime end;
end.SetTimeUtcL(endTTime);
CalCommon::TCalTimeRange timerange(begin, end);
view->FindInstanceL(instances, filter, timerange);
TInt counter = 0;
TInt max = instances.Count();
INFO_PRINTF2(_L("%d instances to compare against"),max);
TBool found = EFalse;
while ((found == EFalse) && (counter < max))
{
INFO_PRINTF2(_L("compare modify info to entry %d"), (counter+1));
if (inf->CompareToEntryL((instances[counter])->Entry()))
{
INFO_PRINTF2(_L("Entry info matched instance %d"), (counter+1));
found = ETrue;
CCalProgress* progress1 = new(ELeave)CCalProgress;
CleanupStack::PushL(progress1);
CCalEntryView* eView = CCalEntryView::NewL(*iSession, *progress);
CleanupStack::PushL(eView);
CActiveScheduler::Start();
CCalEntry* eEntry = &((instances[counter])->Entry());
eEntry->SetDescriptionL(KTCIModifiedText());
RPointerArray<CCalEntry> eList;
CleanupResetAndDestroyPushL(eList);
eList.Reset();
TInt numChanged = 0;
eList.Append(eEntry);
eView->UpdateL(eList, numChanged);
if (numChanged != 1)
{
INFO_PRINTF1(_L("Error modifiying entry"));
User::Leave(KErrGeneral);
}
CleanupStack::PopAndDestroy(&eList);
CleanupStack::PopAndDestroy(2);
}
else
{
counter++;
}
}
CleanupStack::PopAndDestroy(&instances);
CleanupStack::PopAndDestroy(view);
CleanupStack::PopAndDestroy(progress);
CleanupStack::PopAndDestroy(inf);
if (!found)
{
INFO_PRINTF1(_L("Could not find entrytomodify in database"));
User::Leave(KErrNotFound);
}
}
TVerdict CTestCalInterimApiRichAlarmFormatStep::doTestStepL()
{
CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;
CleanupStack::PushL(scheduler);
CActiveScheduler::Install(scheduler);
iSession = CCalSession::NewL();
CTestCalInterimApiCallbackForRichAlarms* alarmCallback = CTestCalInterimApiCallbackForRichAlarms::NewL(this);
CleanupStack::PushL(alarmCallback);
OpenSessionFileL();
iEntryView = CCalEntryView::NewL(*iSession,*alarmCallback);
CActiveScheduler::Add(alarmCallback);
CActiveScheduler::Start();
//build the CCalDataExchange object and import
CCalDataExchange* dataExchange = CCalDataExchange::NewL(*iSession);
CleanupStack::PushL(dataExchange);
//IMPORT the calendar info from a known file
RFs fs;
fs.Connect();
CleanupClosePushL(fs);
RFile inFile;
CleanupClosePushL(inFile);
TInt errR = inFile.Open(fs, GetFullFileName(KEntryImportFile), EFileRead);
RFileReadStream readStream(inFile);
CleanupClosePushL(readStream);
RPointerArray<CCalEntry> secondEntryArray;
CleanupStack::PushL(TCleanupItem(CloseAndDeleteRPtrArrayEntries, &secondEntryArray));
secondEntryArray.Reset();
INFO_PRINTF1(KImporting);
TInt index = 0;
for (index = 0; index < KNumEntriesInFile; index++)
{
dataExchange->ImportL(KUidVCalendar, readStream, secondEntryArray);
}
CleanupStack::Pop(&secondEntryArray);
CleanupStack::PopAndDestroy(&readStream);
CleanupStack::PopAndDestroy(&inFile);
CleanupStack::PushL(TCleanupItem(CloseAndDeleteRPtrArrayEntries, &secondEntryArray));
SetTestStepResult(CompareAlarmDataL(&secondEntryArray));
//Test for importing from a badly formatted file
RFile badInFile;
CleanupClosePushL(badInFile);
TInt baddErr = badInFile.Open(fs, GetFullFileName(KEntryBadImportFile), EFileRead);
RFileReadStream badStream(badInFile);
CleanupClosePushL(badStream);
RPointerArray<CCalEntry> badEntryArray;
CleanupStack::PushL(TCleanupItem(CloseAndDeleteRPtrArrayEntries, &badEntryArray));
badEntryArray.Reset();
INFO_PRINTF1(KImporting);
TInt i = 0;
for (i = 0; i < 1; i++)
{
dataExchange->ImportL(KUidVCalendar, badStream, badEntryArray);
}
CCalEntry* pEntry = badEntryArray[0];
CCalAlarm* pAlarm = pEntry->AlarmL();
if (pAlarm)
{
CleanupStack::PushL(pAlarm);
CCalContent* pContent = pAlarm->AlarmAction();
if (pContent != NULL)
{
ERR_PRINTF1(KUnexpectedAlarmAction);
SetTestStepResult(EFail);
}
delete pContent;
CleanupStack::PopAndDestroy(pAlarm);
}
CleanupStack::PopAndDestroy(&badEntryArray);
CleanupStack::PopAndDestroy(&badStream);
CleanupStack::PopAndDestroy(&badInFile);
CleanupStack::PopAndDestroy(5 , scheduler);
return TestStepResult();
}
EXPORT_C void T_LbsUtils::ResetAndDestroy_PosInfoArr(RPointerArray<TAny>& aPosInfoArr)
{
for (TInt i = 0; i < aPosInfoArr.Count(); ++i)
delete aPosInfoArr[i];
aPosInfoArr.Reset();
}