示例#1
0
// -----------------------------------------------------------------------------
// 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();
	}
示例#22
0
EXPORT_C void T_LbsUtils::ResetAndDestroy_PosInfoArr(RPointerArray<TAny>& aPosInfoArr)
	{
		for (TInt i = 0; i < aPosInfoArr.Count(); ++i)
			delete aPosInfoArr[i];
		aPosInfoArr.Reset();	
	}