void CTzDbRuleSet::FetchRuleDefinitionsL(RArray<TTzRuleDefinition*>& aTzRuleDefinitions, RArray<TTzRuleUse*>& aTzRuleUses, TInt aStartYear, TInt aEndYear) const
	{	
	TInt ruleUseCount = iPersistedEntity.iNumberOfRuleUses;
	TTzRuleUse* truleUse(NULL);
	TTzRuleDefinition* truleDef(NULL);	
	for (TInt i = 0; i < ruleUseCount; i++)
		{
		truleUse = const_cast<TTzRuleUse*>(&iReadOnlyTzDb.GetTRuleUse(iPersistedEntity.iOffsetsToRuleUses[i]));
		
		// intersect rule use with (startYear,endYear) period
		if ( (truleUse->iFromYear <= aEndYear) && (truleUse->iUntilYear >= aStartYear) )
			{
			// Found one rule use valid during the years of interest - fetch rule definition.
			// For every year, check if it occurs within (aStartTime,aEndTime)
			truleDef = const_cast<TTzRuleDefinition*>(&iReadOnlyTzDb.GetTRuleDefinition(truleUse->iOffsetToRuleDefinition));
			// check that the rule definition has valid data. leave if the data is not valid, as it would mean that the database is corrupt
			User::LeaveIfError(CTzHelpers::Validate((const TTzRuleDefinition&)*truleDef));
			
			// Add rule definition ptr to array
			aTzRuleDefinitions.Append(truleDef);
			// Add rule use ptr to array
			aTzRuleUses.Append(truleUse);
			}
		}
	}
// ---------------------------------------------------------------------------
// Get a list of plugins that need to be pre-loaded.
// ---------------------------------------------------------------------------
//
void CMPXViewPluginHandler::GetPreLoadPluginsL( RArray<TUid>& aUids, const TUid& aUid )
    {
    MPX_DEBUG2( "CMPXViewPluginHandler::GetPreLoadPluginsL aUID: 0x%x", aUid );
    RArray<TUid> array;
    CleanupClosePushL( array );
    GetPluginUids( array );

    for ( TInt i = array.Count(); --i >= 0; )
        {
        if ( PluginFlagsL( array[ i ] ) & EMPXPluginFlagPreLoad )
            {
            if ( aUid == KNullUid )
            	{
            MPX_DEBUG2( "CMPXViewPluginHandler::GetPreLoadPluginsL adding UID: 0x%x", array[i] );
            aUids.Append( array[ i ] );
				}
			else
				{
				TUid impUid = SupportedAppUid( array[ i ] );
				MPX_DEBUG2( "APP UID: 0x%x", impUid );
				if ( aUid == impUid )
					{
            		MPX_DEBUG2( "CMPXViewPluginHandler::GetPreLoadPluginsL adding UID: 0x%x", array[i] );
            		aUids.Append( array[ i ] );
					}
				}
            }
        }
    CleanupStack::PopAndDestroy( &array );
    }
Beispiel #3
0
void CMMFTestVideoDecodeHwDevice::GetOutputFormatListL(RArray<TUncompressedVideoFormat>& aFormats)
	{
	// append in order 1, 2, 3
	User::LeaveIfError(aFormats.Append(KTestVidFormat1));
	User::LeaveIfError(aFormats.Append(KTestVidFormat2));
	User::LeaveIfError(aFormats.Append(KTestVidFormat3));
	}
Beispiel #4
0
 // -----------------------------------------------------------------------------
// MceSip::BasicAllowMethods
// -----------------------------------------------------------------------------
//    
void MceSip::BasicAllowMethodsL( RArray<TInt>& aArray )
	{
	User::LeaveIfError( aArray.Append( SipStrConsts::EInvite ));
	User::LeaveIfError( aArray.Append( SipStrConsts::EAck ));
	User::LeaveIfError( aArray.Append( SipStrConsts::ECancel ));
	User::LeaveIfError( aArray.Append( SipStrConsts::EOptions ));
	User::LeaveIfError( aArray.Append( SipStrConsts::EBye ));
	}
// ===========================================================================
// SETUP HELPERS FOR THE LISTENER
// ===========================================================================
//
void T_PresencePublishing::SetupListenerReqCompleteL( CXIMPTestContextWrapper* aWrapper, TXIMPTestStatusEventTemplate aEventType )
    {
    RArray< TInt32 > array;
    CleanupClosePushL( array );
    array.Append( MXIMPContextStateEvent::KInterfaceId );
    array.Append( MOwnPresenceEvent::KInterfaceId );
    aWrapper->SetupListenerReqCompleteL( aEventType, &array );
    CleanupStack::PopAndDestroy(); // array
    }
// -----------------------------------------------------------------------------
// CMediaMtpDataProvider::Supported
// Defines the supported operations and formats of the data provider
// -----------------------------------------------------------------------------
//
void CMediaMtpDataProvider::Supported( TMTPSupportCategory aCategory,
    RArray<TUint>& aArray ) const
    {
    switch ( aCategory )
        {
        case EEvents:
            break;

        case EObjectCaptureFormats:
        case EObjectPlaybackFormats:
            {
            TInt count = sizeof( KMediaMtpDataProviderSupportedFormats ) / sizeof( TUint16 );
            for ( TInt i = 0; i < count; i++ )
                {
                aArray.Append( KMediaMtpDataProviderSupportedFormats[i] );
                }
            PRINT1( _L( "MM MTP <> CMediaMtpDataProvider::Supported format count = %d" ), count );
            }
            break;

        case EOperations:
            {
            TInt count = sizeof( KMediaMtpDataProviderSupportedOperations ) / sizeof( TUint16 );

            for ( TInt i = 0; i < count; i++ )
                {
                aArray.Append( KMediaMtpDataProviderSupportedOperations[i] );
                }
            PRINT1( _L( "MM MTP <> CMediaMtpDataProvider::Supported operation count = %d" ), count );
            }
            break;

        case EObjectProperties:
            {
            TInt count = iSupportedPropAll.Count();

            for ( TInt i = 0; i < count; i++ )
                {
                aArray.Append( iSupportedPropAll[i] );
                }
            PRINT1( _L( "MM MTP <> CMediaMtpDataProvider::Supported properties count = %d" ), aArray.Count() );
            }
            break;

        case EStorageSystemTypes:
            {
            aArray.Append( CMTPStorageMetaData::ESystemTypeDefaultFileSystem );
            }
            break;

        default:
            // Unrecognised category, leave aArray unmodified.
            break;
        }
    }
TInt CSbcEncoderTestDevice::GetSupportedAllocationMethods ( RArray<TSbcAllocationMethod>& aAllocationMethods )
	{
	TInt retVal = KErrNone;
	aAllocationMethods.Reset();
	retVal = aAllocationMethods.Append(ESbcAllocationSNR);
	if (retVal == KErrNone)
		{
		retVal = aAllocationMethods.Append(ESbcAllocationLoudness);
		}
	return retVal;
	}
// get the supported codecs
void CMMFRawFormatRead::GetSupportedDataTypesL(TMediaId aMediaId, RArray<TFourCC>& aDataTypes)
	{
	if (aMediaId.iMediaType != KUidMediaTypeAudio)
		User::Leave(KErrNotSupported);
	aDataTypes.Reset();
	User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM16));
	User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM16B));
	User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCMU16));
	User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeIMAD));
	User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeIMAS));
	}
// ---------------------------------------------------------
// CPosTp50::TestESLI_64LLU3L
// ESLI-64LLU3 - read/write lock only affects the same database instance.
//
// (other items were commented in a header).
// ---------------------------------------------------------
//	
void CPosTp50::TestESLI_64LLU3L()
    {
    RFs fs;
    User::LeaveIfError(fs.Connect());
    fs.Delete(KExportFile);
    fs.Close();

    // Create encoder that will take read lock
    CPosLandmarkEncoder* encoder = CPosLandmarkEncoder::NewL(KMimeType);
    CleanupStack::PushL(encoder);
    encoder->SetOutputFileL(KExportFile);

    // Create another db handle
    CPosLandmarkDatabase* lmd = CPosLandmarkDatabase::OpenL();
    CleanupStack::PushL(lmd);
    if (lmd->IsInitializingNeeded())
       {
       ExecuteAndDeleteLD(lmd->InitializeL()); 
       }

    // Create array of ids to export
    RArray<TPosLmItemId> arrayOfIds;
    CleanupClosePushL(arrayOfIds);
	User::LeaveIfError(arrayOfIds.Append(1));
	User::LeaveIfError(arrayOfIds.Append(2));
	User::LeaveIfError(arrayOfIds.Append(3));

    // Take read lock by starting exporting
    CPosLmOperation* op = lmd->ExportLandmarksL(*encoder, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions); 
    CleanupStack::PushL(op);

    // Verify take write lock fails on db instance 2
    TRAPD(err, lmd->RemoveLandmarkL(1));
    AssertTrueSecL(err == KErrLocked, _L("Didn't get KErrLocked but %d"), err);

    // Verify take write lock fails on db instance 1
    TRAP(err, iDatabase->RemoveLandmarkL(1)); 
    AssertTrueSecL(err == KErrLocked, _L("Didn't get KErrLocked but %d"), err);

    // Lock should prevent import threads to complete successfully
    iTestStep = EReadLockTaken;
    StartMultipleClientsL(KNoMultipleClients);

    // Release lock - import threads should complete successfully
    CleanupStack::PopAndDestroy(op);
    iTestStep = ESync;
    StartMultipleClientsL(KNoMultipleClients);

    CleanupStack::PopAndDestroy(&arrayOfIds);
    CleanupStack::PopAndDestroy(lmd);
    CleanupStack::PopAndDestroy(encoder);
    }
Beispiel #10
0
HX_RESULT HXAudioConfiguratorAAC::ConfigureEAACPDecoder(CMMFCodec* pDecoder)
{
    HX_RESULT result = HXR_OK;

    HXLOGL2(HXLOG_MDFA, "HXAudioConfiguratorAAC::ConfigureEAACPDecoder()");
    HXLOGL2(HXLOG_MDFA, "Samples Per Second     : %lu", m_ulSamplesPerSecond);
    HXLOGL2(HXLOG_MDFA, "Number of Channels     : %u", m_uNumChannels);
    HXLOGL2(HXLOG_MDFA, "Profile Type           : %d", m_nProfileType);
    HXLOGL2(HXLOG_MDFA, "Profile Type: Unknown(-1), MP(0), LC(1), SSR(2), LTP(3)");
    HXLOGL2(HXLOG_MDFA, "Samples Per Frame      : %u", m_uSamplesPerFrame);
    HXLOGL2(HXLOG_MDFA, "Frame Length           : %u", m_uInputFrameLength);
    HXLOGL2(HXLOG_MDFA, "Samples Per Second     : %lu", m_ulSamplesPerSecond);
    HXLOGL2(HXLOG_MDFA, "Down Sample Mode       : %u", m_uDownSampleMode);
    HXLOGL2(HXLOG_MDFA, "Bits Per Sample        : %u", m_uBitsPerSample);
    HXLOGL2(HXLOG_MDFA, "Output SamplesPerSecond: %lu", m_ulOutSamplesPerSecond);
    HXLOGL2(HXLOG_MDFA, "Extension Object Type  : %u", m_uExtObjectType);
    HXLOGL2(HXLOG_MDFA, "Object Type            : Main(1), LC(2), SSR(3), LTP(4), SBR(5), SCALABLE(6), TWINVQ(7)");

    RArray<TInt> configParams;
    configParams.Append(m_ulSamplesPerSecond);	//  0: Input Sample Frequency
    configParams.Append(m_uNumChannels);	  //  1: Num Channels [1|2]
    configParams.Append(m_nProfileType);	  //  2: Input Profile Object type [1 - LC, 3 - LTP]
    configParams.Append(m_uSamplesPerFrame);	//  3: Output Frame Size
    configParams.Append(m_uInputFrameLength);	//  4: Input Frame Len [1024, 960]
    configParams.Append(m_ulSamplesPerSecond);	//  5: Input Sample Rate
    configParams.Append(0);			//  6: 0
    configParams.Append(m_uDownSampleMode);	//  7: Down Sample Mode [0|1]
    configParams.Append(m_uBitsPerSample);	//  8: Sample resolution, 8Khz (8-bit PCM) or 16Khz (16-bit)
    configParams.Append(m_ulOutSamplesPerSecond); //  9: Output Sample Frequency
    configParams.Append(m_uExtObjectType);	// 10: Extension Object Type

    TUid codecId = TUid::Uid(KUidMmfCodecAudioSettings);

    TRAPD(err, pDecoder->ConfigureL(codecId, (TDesC8&) configParams));
    if(KErrNone != err)
    {
	result = HXR_FAIL;
    }

    configParams.Close();

    // don't change the sample rate if we operate the SBR tool in
    // downsampled mode
    if(m_uDownSampleMode == 0)
    {
	// now that we're done configuring, update the true sample rate
	m_ulSamplesPerSecond = m_ulOutSamplesPerSecond;
    }

    return result;
}
RArray<TFileName> ListImages::searchJPGL(TFileName tot, RFs fs,
        TFileName current)
{
    RArray<TFileName> result;
    TInt i;
    TBuf<50> totalPath;
    TBuf<30> fileName;
    CDir* dirList;

    totalPath = tot;
    CleanupStack::PushL(dirList);
    if ((current.Length()) > 0)
        totalPath.Append(current);
    //CleanupClosePushL(result);
    TRAPD(err,fs.GetDir(totalPath, KEntryAttMaskSupported,
                        ESortByDate, dirList));
    CleanupStack::Pop(1);
    if (!dirList)
        return result;

    for (i = 0; i < dirList->Count(); i++)
    {
        if ((*dirList)[i].IsDir())
        {
            TFileName tmp;
            tmp.Append((*dirList)[i].iName);
            tmp.Append(_L("\\"));
            RArray<TFileName> res = searchJPGL(totalPath, fs, tmp);
            for (int j = 0; j < res.Count(); j++)
                result.Append(res[j]);
            res.Reset();

        }
        else
        {
            fileName = (*dirList)[i].iName;
            if (fileName.Find(_L(".jpg")) != KErrNotFound)
            {
                TBuf<50> tmp;
                tmp = totalPath;
                tmp.Append(fileName);
                result.Append(tmp);
                tmp.Delete(0, tmp.Length() - 1);
            }
        }
    }
    delete dirList;
    return result;
}
// Actual implementation of method
TInt CMMFAacDecoderConfig::GetSupportedAudioConfigs(RArray<TAudioConfig>& aSupportedAudioConfigs)
	{
	TAudioConfig audioConfig;
	audioConfig.iAudioObjectType = TAudioConfig::ESbr;
	aSupportedAudioConfigs.Append(audioConfig);
	audioConfig.iAudioObjectType = TAudioConfig::EAacLtp;
	aSupportedAudioConfigs.Append(audioConfig);
	audioConfig.iAudioObjectType = TAudioConfig::EAacSsr;
	aSupportedAudioConfigs.Append(audioConfig);
	audioConfig.iAudioObjectType = TAudioConfig::EAacLc;
	aSupportedAudioConfigs.Append(audioConfig);
	audioConfig.iAudioObjectType = TAudioConfig::EAacMain;
	aSupportedAudioConfigs.Append(audioConfig);
	return KErrNone;
	}
// -----------------------------------------------------------------------------
// RVoIPAudioSession::PopulateArrayL
// -----------------------------------------------------------------------------
//
void RVoIPAudioSession::PopulateArrayL(
        TVoIPAudioClientServerRequest aRequest, RArray<TUint32>& aDecoders,
        TInt aCount)
    {
    HBufC8* buf = HBufC8::NewLC(aCount * sizeof(TUint32));
    TPtr8 ptr = buf->Des();
    TIpcArgs args;
    args.Set(0, &ptr);
    TInt err = SendClientRequest(aRequest, args);

    if (err == KErrNone)
        {
        RDesReadStream stream(ptr);
        CleanupClosePushL(stream);
        aDecoders.Reset();

        for (TInt i = 0; i < aCount; i++)
            {
            aDecoders.Append(stream.ReadUint32L());
            }

        CleanupStack::PopAndDestroy(&stream);
        }

    CleanupStack::PopAndDestroy(buf);
    }
EXPORT_C TInt CBaseMrInfoObject::SupportedFields(
    RArray<TESMRInfoField>& aFields ) const
    
    {
    /**@ have more fields to add.*/
    TESMRInfoField fields[] = 
        {
        EESMRInfoFieldId,
        EESMRInfoFieldSeqNo,
        EESMRInfoFieldMethod,
        EESMRInfoFieldMStatus,
        EESMRInfoFieldCreationDateTime,
        EESMRInfoFieldOrganizer,
        EESMRInfoFieldAttendee,
        EESMRInfoFieldOptAttendee,
        EESMRInfoFieldStartDateTime,
        EESMRInfoFieldStopDateTime,
        EESMRInfoFieldLocation,
        EESMRInfoFieldAlarm,
        EESMRInfoFieldSubject,
        EESMRInfoFieldDescription,
        EESMRInfoFieldRecurrence,
        EESMRInfoFieldPriority
        };
    
    TInt result = KErrNone;
    for ( TInt i = 0;
        i < sizeof( fields ) / sizeof( TESMRInfoField ) && result == KErrNone;
        i++ )
        {
        result = aFields.Append( fields[i] );
        }
    
    return result;
    }
TInt Cscp_server_api::PerformCleanUpL(CStifItemParser& aItem)
{
    RSCPClientTestClient client;
    TInt err = client.Connect();
    if(!err)
    {
        RArray<TUid> uids;
        TInt uid;

        while(!(err = aItem.GetNextInt(uid)))
        {
            uids.Append(TUid::Uid(uid));
        }   
        if(uids.Count())
        {
            TRAPD(lerr, (err = client.PerformCleanUpL(uids)));
            if(lerr)
                err = lerr;
        }
        else
            err = KErrGeneral;
    }
    client.Close();
    return err;
    
}
LOCAL_C void ReadL(RFs& aFs, RArray<TInt>& aArray)
    {
    TInt drive = -1;
    TFileName name(KMapFileName);
    for(TInt i = 'z'; drive < 0 && i >= 'a'; i--)
        {
        name[0] = (TUint16)i;
        if(BaflUtils::FileExists(aFs, name))
            drive = i;
        }
    if(drive < 0)
        return;
    CLineReader* reader = CLineReader::NewLC(aFs, name);
    while(reader->NextL())
        {
        TPtrC ln = reader->Current();
        TLex line(ln);
        TInt n = 0;
        for(;;)
            {
            const TPtrC token = line.NextToken();
            if(token.Length() == 0)
                break;
            if((n & 1) != 0)
                {
                TInt value;
                TLex lex(token);
                User::LeaveIfError(lex.Val(value));
                User::LeaveIfError(aArray.Append(value));
                }
            n++;
            }
        }
    CleanupStack::PopAndDestroy();
    }
// ---------------------------------------------------------------------------
// Find all ids of entries in cenrep.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CCenRepDatabaseUtil::FindEntryIdsL( RArray<TInt>& aEntryIds )
    {
    //CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryIdsL - IN" );
    
    aEntryIds.Reset();
    
    RKeyArray keys;
    CleanupClosePushL( keys );

    // Find all entry rows from ID column. Deleted rows are not returned.
    TInt err = iRepository->FindNeqL( iStartKey, iColMask, KNoEntryId, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && count > 0 )
        {
        for( TInt i = 0; i < count; i++ )
            {
            TUint32 key = keys[i];
            TInt entryId = 0;
            User::LeaveIfError( iRepository->Get( key, entryId ) );
            User::LeaveIfError( aEntryIds.Append( entryId ) );
            }
        }

    CleanupStack::PopAndDestroy( &keys );
    
    //CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryIdsL - OUT" );
    
    return err;
    }
// ---------------------------------------------------------------------------
// Deletes service properties
// ---------------------------------------------------------------------------
//
TInt CSPSettingsEngine::DeleteServicePropertiesL( TServiceId aServiceId,
                                                  const RPropertyNameArray& aNameArray  )
    {
    XSPSLOGSTRING2( 
        "CSPSettingsEngine::FindSubServicePropertyL( %d ) - IN", aServiceId );

    RArray<TUint32> nameArray;
    CleanupClosePushL( nameArray );
    TInt count = aNameArray.Count();
    
    for( TInt i = 0; i < count; i++ )
        {
        TUint32 name = (TUint32)( aNameArray[i] );
        User::LeaveIfError( nameArray.Append( name ) );
        }
        
    TInt id = (TInt)aServiceId;
    TInt err = iCenRepUtils->DeletePropertiesL( id, nameArray );
    
    CleanupStack::PopAndDestroy( &nameArray );
    
    XSPSLOGSTRING( "CSPSettingsEngine::FindSubServicePropertyL() - OUT" );
    
    return err;
    }
// ----------------------------------------------------------------------------
// CTVOutConfigForHDMI::GetSupportedHdmiModes
//
// ----------------------------------------------------------------------------
//
TInt CTVOutConfigForHDMI::GetSupportedHdmiModes( RArray<TSupportedHdmiDviMode>& asupportedModes )
    {
    FUNC_LOG;

	TUint count;
	TInt  retVal( KErrNone );
	
	retVal = iTvConfig->GetNumberOfHdmiModes( count );
	ERROR( retVal, "Getting supported hdmi modes failed" );

	if( KErrNone == retVal )
		{
		for( TInt i = 0; (i < count); i++)
			{
			TSupportedHdmiDviMode mode;			
			iTvConfig->GetSupportedHdmiMode( i, mode );
			TInt err = asupportedModes.Append( mode );
			if(KErrNone != err)
			    {
			    ERROR( err, "Failed to append supported modes in array" );
			    retVal = err;
			    break;
			    }
			}
		}

	return retVal;
    }
TInt CTestHistoryLog::AddNewJobEntryL( CStifItemParser& /*aItem*/ )
	{
	TInt arrayCount = iHistoryArray->Count() + 1;
	TInt profileId(1);	
	RArray<TInt> tasks;
	tasks.Append(KTaskId1);
	tasks.Append(KTaskId2);
	
	CSyncMLHistoryJob * entry = CSyncMLHistoryJob::NewL(profileId, tasks );
	CleanupStack::PushL(entry);
	
	tasks.Reset();
	tasks.Close();

	iHistoryArray->AppendEntryL(entry);
	
	TL(iHistoryArray->Count() == arrayCount);
	
	if (iOwnerShip)
		{
		CleanupStack::Pop(entry);
		}
	else
		{
		CleanupStack::PopAndDestroy(entry);		
		}	
	return KErrNone;
	}
EXPORT_C void CDictionaryCodePage::ConstructIndexMappingL(const TInt* aStringPoolToTokenMapping, 
													 TStringType aType)
/**
This method constructs the internal correlation between indices and tokens.

@param				aStringPoolToTokenMapping array of token values, NULL terminated.
@param				aType is the type of the token, e.g. element.

@panic				EXmlFrameworkPanicUnexpectedLogic If the type cannot be recognised.

*/
	{
	RArray<TInt>* toToken = 0;
	RArray<TStringPoolTokenMapping>* toIndex = 0;

	switch (aType)
		{
		case EStringTypeElement:
			{
			toToken = &iElementStringPoolIndexToToken;
			toIndex = &iElementTokenToStringPoolIndex;
			break;
			}
		case EStringTypeAttribute:
			{
			toToken = &iAttributeStringPoolIndexToToken;
			toIndex = &iAttributeTokenToStringPoolIndex;
			break;
			}
		case EStringTypeAttributeValue:
			{
			toToken = &iValueStringPoolIndexToToken;
			toIndex = &iValueTokenToStringPoolIndex;
			break;
			}
		default:
			{
			__ASSERT_ALWAYS(EFalse, Panic(EXmlFrameworkPanicUnexpectedLogic));
			}
		};

	TInt element = 0;
	for (TInt count=0; (element = aStringPoolToTokenMapping[count]) != 0; ++count)
		{
		// The index to token mapping is straight forward.
		// We simply add a table index. 
		// The table index is the same index into the RArray saving space.
		User::LeaveIfError(toToken->Append(element));

		// The token to index mapping is slightly more complicated,
		// and we use a compare function to extract it.
		TStringPoolTokenMapping mapping;
		mapping.iTokenValue = element;		// This is the primary key (Token)
		mapping.iTableIndex = count;								// This is the Table index
		User::LeaveIfError(toIndex->InsertInOrder(
								mapping, 
								TLinearOrder<TStringPoolTokenMapping>(
									CDictionaryCodePage::CompareStringPoolTokenMappingTable)));
		}	
	}
TInt CTestHistoryLog::AddMoreThanFiveJobsL( CStifItemParser& /*aItem*/ )
	{
	for (TInt i = 0; i < KMaxMsgSize; i++)
		{
		RArray<TInt> tasks;
		tasks.Append(KTaskId1);
		tasks.Append(KTaskId2);
	
		CSyncMLHistoryJob * entry = CSyncMLHistoryJob::NewL(i, tasks );
		CleanupStack::PushL(entry);
	
		tasks.Reset();
		tasks.Close();

		iHistoryArray->AppendEntryL(entry);

	if (iOwnerShip)
		{
		CleanupStack::Pop(entry);
		}
	else
		{
		CleanupStack::PopAndDestroy(entry);
		}
		}
	TL(iHistoryArray->Count() == KMaxMsgSize);
	
	return KErrNone;
	}
void CpCertTrustView::saveTrustSettings()
	{
	RDEBUG("0", 0);
	CCTCertInfo& entry = *( mCertDataContainer.iCALabelEntries[ mCertificateIndex ]->iCAEntry );
	if ( entry.IsDeletable() )
		{
		TInt itemCount = mFormModel->rowCount();
		RArray<TUid> newUids;
		QT_TRAP_THROWING
			(	
			CleanupClosePushL( newUids );
			
			for(int index = 0;index<itemCount;++index)
				{
				HbDataFormModelItem *item = mFormModel->item(index);
				QString trustValue = item->contentWidgetData("text").toString();
				if(trustValue == "On")
					{
					newUids.Append(trusterId(mTrustedClients[index]));
					}
				}
			if(newUids.Count() > 0 )
				{
				mCertDataContainer.iWrapper->SetApplicabilityL( mCertDataContainer.CertManager(), entry, newUids );
				}
			CleanupStack::PopAndDestroy(&newUids);
			)
		}
GLDEF_C TInt E32Main()
	{
	TBuf<256> cmdline;
	RArray< TInt > buff;
	TInt i, len, ret = KErrNone;

	User::CommandLine(cmdline);
	len = User::CommandLineLength();
	if (len)
		{
		for(i=0;i<len;i++)
			{
		    ret = buff.Append(cmdline[i]);
		    if (ret != KErrNone)
		    	{
		    	return ret;
		    	}
			}
		ret = ConsoleAlarmAlertServer::StartServerThreadFunction(&buff);
        }
    else
		{
		ret = ConsoleAlarmAlertServer::StartServerThreadFunction();
        }

	return ret;
	}
// ---------------------------------------------------------------------------
// Requests Media.
// ---------------------------------------------------------------------------
//
void CAiPlayerPluginEngine::RequestMediaL()
    {
    MMPXSource* s = iPlaybackUtility->Source();
    if ( s )
        {
        RArray<TMPXAttribute> attrs;
        CleanupClosePushL(attrs);
        attrs.Append( KMPXMediaGeneralUri );
        attrs.Append( KMPXMediaGeneralTitle );
        attrs.Append( KMPXMediaMusicArtist );
        attrs.Append( KMPXMediaMusicAlbumArtFileName );
        iPlaybackUtility->PropertyL( *this, EPbPropertyDuration );
        s->MediaL( attrs.Array(), *this );
        CleanupStack::PopAndDestroy( &attrs );
        }
    }
Beispiel #26
0
// Get phonebook list
EXPORT_C TInt CContactSyncChecker::PhonebookListL(RArray<TUid>& aPhonebookList)
	{
	CContactSyncData* temp = CContactSyncData::NewL();
	CleanupStack::PushL(temp);
	CContactSyncData& settings = temp->DataL();
	RPointerArray<CContactSyncPhonebookData>& perPhbkData = settings.PerPhonebookData();
	const TInt phbkCount = perPhbkData.Count();
	TInt ret = KErrNone;
	if (phbkCount == 0)
		{
		// too early - the phonebook list has not been set
		ret = KErrNotReady;
		}
		else
		{
		// copy/create phonebook list
		aPhonebookList.Reset();
		for (TInt k = 0; k < phbkCount; ++k)
			{
			if (aPhonebookList.Append(perPhbkData[k]->PhonebookUid()) != KErrNone)
				{
				// error
				aPhonebookList.Reset();
				ret = KErrNoMemory;
				break;
				}
			}
			
		}
	CleanupStack::PopAndDestroy(temp);		
	return ret;
	}
// -----------------------------------------------------------------------------
// CWPInternetAPDB::ReadItemsL
// -----------------------------------------------------------------------------
// 
void CWPInternetAPDB::ReadItemsL(RArray<TAccessPointItem>& aItemArray,
        TFileName QueryBuffer)
    {
    FLOG( _L( "[Provisioning] CWPInternetAPDB::ReadItemsL" ) );
    RDbView Myview;
    Myview.Prepare(iItemsDatabase, TDbQuery(QueryBuffer));
    CleanupClosePushL(Myview);
    Myview.EvaluateAll();
    if ( Myview.FirstL())
    {
    	while (Myview.AtRow())
        {
        Myview.GetL();

        TAccessPointItem AccessPointItem;
        AccessPointItem.iIndex = Myview.ColInt(1);
        AccessPointItem.iAPID = Myview.ColInt(2);
        AccessPointItem.iBearerType = Myview.ColInt(3);
        AccessPointItem.iOriginator.Copy(Myview.ColDes(4));

        aItemArray.Append(AccessPointItem);
        Myview.NextL();
        }
    }

    CleanupStack::PopAndDestroy(); // Myview
    FLOG( _L( "[Provisioning] CWPInternetAPDB::ReadItemsL: done" ) );
    }
EXPORT_C TInt RDirectPrintClient::GetPrinterCapabilityIDs( TInt aPrinterID, RArray<TInt>& aCapabilityIDs ) const
	{
	TInt count;
	TPckg<TInt> countBuf( count );
	
	LOG1("RDirectPrintClient::GetPrinterCapabilityIDs EGetPrinterCapabilityIDsCount aPrinterID: %d", aPrinterID);
	TInt err = SendReceive( EGetPrinterCapabilityIDsCount, TIpcArgs( aPrinterID, &countBuf ) );
	LOG1("RDirectPrintClient::GetPrinterCapabilityIDs EGetPrinterCapabilityIDsCount err: %d", err);
	if( !err )
		{
		LOG1("RDirectPrintClient::GetPrinterCapabilityIDs EGetPrinterCapabilityIDsCount count: %d", count);
		for( TInt i = 0; i < count && !err; i++ )
			{
			TInt capability;
			TPckg<TInt> capBuf( capability );
			LOG1("RDirectPrintClient::GetPrinterCapabilityIDs EGetPrinterCapabilityID i: %d", i);
			err = SendReceive( EGetPrinterCapabilityID, TIpcArgs( i, &capBuf ) );
			LOG1("RDirectPrintClient::GetPrinterCapabilityIDs EGetPrinterCapabilityID err: %d", err);
			if( !err )
				{
				LOG1("RDirectPrintClient::GetPrinterCapabilityIDs capability id: %d", capability);
				err = aCapabilityIDs.Append( capability );
				LOG1("RDirectPrintClient::GetPrinterCapabilityIDs append err: %d", err);
				}
			}
		}
	
	LOG1("RDirectPrintClient::GetPrinterCapabilityIDs end with: %d", err);
	return err;
	}
void CSWICertStoreTool::ParseApplicationsL(const CTestConfigSection& aSection, RArray<TUid>& aApplications)
	{
	for (TInt index = 0 ; ; ++index)
		{
		const CTestConfigItem* item = aSection.Item(KItemApplication, index);
		if (item == NULL)
			{
			break;
			}
		const TDesC8& appName = item->Value();
		TUid application;
		TRAPD(err, application = ParseApplicationNameL(appName));
		if (err != KErrNone)
			{
			LogL(KLogIllegalApplicationValue, &item->Value());
			User::Leave(KErrArgument);		
			}
		User::LeaveIfError(aApplications.Append(application));
		LogParameterL(KItemApplication, appName);
		}
	
	if (aApplications.Count() == 0)
		{
		LogL(KLogNoApplications);
		User::Leave(KErrArgument);
		}
	}
TBool CT_DataRGavdp::ConvertSEIDs(TDesC &aSEIDsStr, RArray<TUint>& aSEIDs)
{

    TBool ret = ETrue;

    TLex lex(aSEIDsStr);
    TInt tempSEID;
    if (lex.Val(tempSEID) == KErrNone)
    {
        aSEIDs.Append(tempSEID);
    }
    else
    {
        TInt location = aSEIDsStr.Match(_L("*,*"));
        if( location != KErrNotFound )
        {
            //Converting Left part of the data
            TPtrC	tempStr = aSEIDsStr.Left(location);
            ret = ConvertSEIDs(tempStr, aSEIDs);
            if(ret)
            {
                //Converting right data can be with another ","
                tempStr.Set(aSEIDsStr.Mid(location + 1));
                ret = ConvertSEIDs(tempStr, aSEIDs);
            }
        }
        else
        {
            ret = EFalse;
        }
    }

    return ret;
}