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 ); }
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)); }
// ----------------------------------------------------------------------------- // 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); }
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 ); } }
// 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; }