void CCmdCustomCommand::WriteHandleToFileL(TInt aHandle) { const TChar sysDrive = RFs::GetSystemDriveChar(); RBuf filename; filename.CreateL(KNeverUnloadLibHandleFile().Length() + 1); filename.Append(sysDrive); filename.Append(KNeverUnloadLibHandleFile()); filename.CleanupClosePushL(); RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); fs.MkDirAll(filename); // ignore any error RFile file; CleanupClosePushL(file); TInt err=KErrNone; TInt pos = 0; if(KErrNotFound == (err = file.Open(fs, filename, EFileShareExclusive|EFileStream|EFileWrite))) { User::LeaveIfError(file.Replace(fs, filename, EFileShareExclusive|EFileStream|EFileWrite)); } else { User::LeaveIfError(err); file.Seek(ESeekEnd, pos); } RFileWriteStream targetStream; targetStream.Attach(file, pos); // file gets closed by this call, but that's okay, we don't need it any more (targetStream has its own copy of this RFile object that it owns) CleanupClosePushL(targetStream); targetStream.WriteInt32L(aHandle); targetStream.CommitL(); CleanupStack::PopAndDestroy(4); }
/* * Save Form data, function to be executed when save option is selected. * Creates the second form which allows for selecting the category. */ TBool CYPagesForm1::SaveFormDataL() { CAknPopupFieldText* popupFieldText = static_cast <CAknPopupFieldText*> (ControlOrNull(EYPagesPopup)); if (popupFieldText) { TInt categoryIndex = popupFieldText->CurrentValueIndex(); TBuf <30> KMyTextFile; KMyTextFile.Format(_L("D:\\YPages\\%d%d.txt"), iColor, categoryIndex); RFs fileServer; User :: LeaveIfError (fileServer.Connect()); RFile file; User::LeaveIfError(file.Open(fileServer, KMyTextFile, EFileRead|EFileStreamText)); CleanupClosePushL(file); TFileText fileText; fileText.Set(file); TBuf<100> buffer; buffer = _L(""); RBuf rBuf; rBuf.Create(buffer); rBuf.CleanupClosePushL(); TInt err = KErrNone; while(err != KErrEof) { err = fileText.Read(buffer); if ((err != KErrNone) && (err != KErrEof)) { User :: Leave(err); } if (KErrNone == err) { rBuf.ReAllocL(rBuf.Length() + buffer.Length()+2); rBuf.Append(buffer); rBuf.Append(_L("\n")); } } CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL(rBuf); dlg->PrepareLC(R_ABOUT_HEADING_PANE); dlg->SetHeaderTextL(_L("")); dlg->RunLD(); CleanupStack::PopAndDestroy(&rBuf); CleanupStack::PopAndDestroy(&file); fileServer.Close(); } return ETrue; }
// ---------------------------------------------------------- // CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndCompleteL // Shows the notifier in backround // ---------------------------------------------------------- // void CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndCompleteL() { FLOG(_L("[BTNOTIF]\t CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndComplete()")); //get full path to the DCMO resource file TParse* parser = new (ELeave) TParse; parser->Set(KDcmoResourceFileName(), &KDC_RESOURCE_FILES_DIR, NULL); CleanupStack::PushL(parser); TFileName* fileName = new (ELeave) TFileName; *fileName = parser->FullName(); CleanupStack::PopAndDestroy(parser); CleanupStack::PushL(fileName); //create the resource reader object that we need to use several times CTulStringResourceReader* reader = CTulStringResourceReader::NewL(*fileName); CleanupStack::PushL(reader); //get pointer to the message part of the notifier TPtrC resourceString; resourceString.Set(reader->ReadResourceString(R_DM_RUN_TIME_VAR_DISABLE)); //create descriptor with a max length to fit the localised "disabled" text + new line + "Bluetooth" RBuf content; content.CreateL(resourceString.Length() + KNewLine().Length() + KDefaultBluetoothStringLength); CleanupClosePushL(content); //add resource string and new line character to the content descriptor content.Append(resourceString); content.Append(KNewLine()); //get pointer to the Bluetooth name part of the notifier (can't assume this is actually "Bluetooth" in all languages) resourceString.Set(reader->ReadResourceString(R_DM_RUN_TIME_VAR_BLUETOOTH)); //check that the resource string will fit into the content descriptor TInt requiredLength = content.Length() + resourceString.Length(); if (requiredLength > content.MaxLength()) { //allocate more space in the content descriptor content.ReAllocL(requiredLength); } //add resource string to the content descriptor content.Append(resourceString); //display the notifier and complete iNotifUiUtil->ShowInfoNoteL(content, ECmdBTnotifUnavailable); CompleteMessage(KErrNone); //pop and destroy the content descriptor, resource reader and file name CleanupStack::PopAndDestroy(3, fileName); FLOG(_L("[BTNOTIF]\t CBTEnterpriseItSecurityInfoNotifier::ShowNoteAndComplete() complete")); }
LOCAL_C void mainL() { CCommandLineArguments* cmdLine = CCommandLineArguments::NewLC(); CConsoleBase* console = Console::NewL(_L("Siftestintegrationlockfile"),TSize(KConsFullScreen,KConsFullScreen)); CleanupStack::PushL(console); TInt argTotal(cmdLine->Count()); if (argTotal < 2 || argTotal > 3) { console->Printf(_L("Incorrect arguments specified: expected 1, received %d"), argTotal - 1); User::Leave(KErrArgument); } TPtrC filename(cmdLine->Arg(1)); _LIT(KDoLockFileParam, " lockfile"); if (argTotal == 2) { RBuf params; params.CreateL(filename.Length() + KDoLockFileParam().Length()); params.CleanupClosePushL(); params.Append(cmdLine->Arg(1)); params.Append(KDoLockFileParam()); // Since this executable is used by TEF, we wish to lock the file after the launched process has exited, so we spawn this process again with a different set of parameters RProcess newInstance; User::LeaveIfError(newInstance.Create(_L("Siftestintegrationlockfile"), params)); CleanupClosePushL(newInstance); newInstance.Resume(); TRequestStatus status; newInstance.Rendezvous(status); User::WaitForRequest(status); User::LeaveIfError(status.Int()); CleanupStack::PopAndDestroy(2, ¶ms); // newInstance } else { // This is the execution for locking the file, invoked using the branch above console->Printf(_L("Locking file %S for read"), &filename); RFs fs; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); RFile file; User::LeaveIfError(file.Open(fs, filename, EFileShareReadersOnly|EFileRead)); CleanupClosePushL(file); // Signal the invoker only here, so that the file will definitely get locked before TEF proceeds to the next step RProcess::Rendezvous(KErrNone); User::After(10*1000*1000); // Wait for 10 seconds CleanupStack::PopAndDestroy(2 , &fs); // file } CleanupStack::PopAndDestroy(2, cmdLine); // console, }
void CVideoEntry::GenerateThumbnailFileL( const TDesC& aCacheDirectory ) { delete iThumbnailFile; RBuf path; CleanupClosePushL( path ); path.Create( aCacheDirectory.Length() + iVideoId->Length() + KCacheFileExtension().Length() ); path.Copy( aCacheDirectory ); path.Append( *iVideoId ); path.Append( KCacheFileExtension() ); iThumbnailFile = path.AllocL(); CleanupStack::PopAndDestroy( &path ); }
void CPluginUtils::AddUrlParamL( RBuf& aBuf, const TDesC& aParam, const TDesC& aValue, TBool aLast) { aBuf.ReAllocL( aBuf.Length() + 1 + aParam.Length() + aValue.Length() ); aBuf.Append( aParam ); aBuf.Append( _L("=") ); aBuf.Append( aValue ); if( !aLast ) { aBuf.ReAllocL( aBuf.Length() + 1 ); aBuf.Append( _L("&") ); } }
void CTestRControlChannel::ExtractServiceDescriptionL (const TDesC& aConfigSection, CUPnPServiceRegisterParamSet& aServiceRegisterParamSet) { RFs fs; RFile file; RBuf8 buf; User::LeaveIfError(fs.Connect()); CleanupClosePushL(fs); TPtrC descriptionPath; _LIT(KDescriptionPath, "Description_Path"); GetStringFromConfig(aConfigSection, KDescriptionPath, descriptionPath); TInt err = file.Open(fs, descriptionPath, EFileShareReadersOnly); // For Hardware system path is c:, so descriptionPath value present in '.ini' is referring 'c:' if ( err == KErrPathNotFound ) { RBuf fileName; TDriveName aSystemDrive; TDriveUnit driveunit(RFs::GetSystemDrive()); aSystemDrive.Zero(); aSystemDrive=driveunit.Name(); fileName.CreateL ( descriptionPath.Length () ); fileName.Zero(); fileName.Append(aSystemDrive); fileName.Append ( descriptionPath.Mid ( aSystemDrive.Length () ) ); err = file.Open(fs, fileName, EFileShareReadersOnly); } if (err != KErrNone) { User::LeaveIfError(err); } CleanupClosePushL(file); TInt fileSize = 0; file.Size(fileSize); buf.Create(fileSize); err = file.Read(buf, fileSize); aServiceRegisterParamSet.SetServiceDescriptionL ( buf ); CleanupStack::PopAndDestroy(2 ); buf.Close(); _LIT(KInfoLogFile, "CRControlChannelObserver::ExtractServiceDescriptionL End.... \n"); INFO_PRINTF1(KInfoLogFile); }
void CPluginUtils::AddUrlParamL( RBuf& aBuf, const TDesC& aParam, TInt aValue, TBool aLast ) { TBuf<12> t; t.Format( _L("%d"), aValue ); aBuf.ReAllocL( aBuf.Length() + 1 + aParam.Length() + t.Length() ); aBuf.Append( aParam ); aBuf.Append( _L("=") ); aBuf.Append( t ); if( !aLast ) { aBuf.ReAllocL( aBuf.Length() + 1 ); aBuf.Append( _L("&") ); } }
// ----------------------------------------------------------------------------- // CMoveObject::MoveObjectL // Move object operation // ----------------------------------------------------------------------------- // void CMoveObject::MoveObjectL() { PRINT( _L( "MM MTP => CMoveObject::MoveObjectL" ) ); TMTPResponseCode responseCode = EMTPRespCodeOK; GetParametersL(); RBuf newObjectName; newObjectName.CreateL( KMaxFileName ); newObjectName.CleanupClosePushL(); // + newObjectName newObjectName = *iDest; TPtrC suid( iObjectInfo->DesC( CMTPObjectMetaData::ESuid ) ); TParsePtrC fileNameParser( suid ); if ( ( newObjectName.Length() + fileNameParser.NameAndExt().Length() ) <= newObjectName.MaxLength() ) { newObjectName.Append( fileNameParser.NameAndExt() ); responseCode = CanMoveObjectL( suid, newObjectName ); if ( responseCode == EMTPRespCodeOK ) MoveFileL( newObjectName ); } else // Destination is not appropriate for the full path name shouldn't be longer than 255 responseCode = EMTPRespCodeInvalidDataset; SendResponseL( responseCode ); CleanupStack::PopAndDestroy( &newObjectName ); // - newObjectName PRINT1( _L( "MM MTP <= CMoveObject::MoveObjectL responseCode = 0x%x" ), responseCode ); }
void CWindowGroupListBoxData::DoInfoForDialogL(RBuf& aTitle, RBuf& inf, TDes* name) { SWgInfo& info = *reinterpret_cast<SWgInfo*>(iInfo); _LIT(KInfo, "Window group info"); aTitle.Copy(KInfo); CApaWindowGroupName* wg = info.iName; *name = wg->WindowGroupName(); PrettyName(EListWindowGroups, *name); inf.Append(*name); TThreadId tid; TInt res = info.iSession->GetWindowGroupClientThreadId(info.iHandle, tid); inf.AppendFormat(_L("\n\nOwner thread: %i"), res == KErrNone ? (TInt)tid : res); RThread thread; if (res == KErrNone) { res = thread.Open(tid); } if (res == KErrNone) { *name = thread.FullName(); PrettyName(EListThread, *name); inf.AppendFormat(_L(" (%S)"), name); } inf.AppendFormat(_L("\nBusy=%i System=%i Hidden=%i"), wg->IsBusy(), wg->IsSystem(), wg->Hidden()); }
HBufC* CPluginUtils::ConvertUtfToUnicodeL( const TDesC8& aUtf7 ) { RBuf output; CleanupClosePushL( output ); TBuf16<20> outputBuffer; TPtrC8 remainderOfUtf7( aUtf7 ); for(;;) { const TInt returnValue = CnvUtfConverter::ConvertToUnicodeFromUtf8(outputBuffer, remainderOfUtf7); if (returnValue==CnvUtfConverter::EErrorIllFormedInput) return NULL; else if (returnValue<0) return NULL; output.ReAllocL( output.Length() + outputBuffer.Length() ); output.Append( outputBuffer ); if (returnValue == 0) break; remainderOfUtf7.Set(remainderOfUtf7.Right(returnValue)); } HBufC* ret = output.AllocL(); CleanupStack::PopAndDestroy( &output ); return ret; }
/** A helper function of MoveObjectL. @param aNewFolderName the new file folder name after the folder is moved. */ void CMTPMoveObject::MoveFolderL() { OstTraceFunctionEntry0( CMTPMOVEOBJECT_MOVEFOLDERL_ENTRY ); RBuf oldFolderName; oldFolderName.CreateL(KMaxFileName); oldFolderName.CleanupClosePushL(); oldFolderName = iObjectInfo->DesC(CMTPObjectMetaData::ESuid); iPathToMove = oldFolderName.AllocL(); if (iObjectInfo->Uint(CMTPObjectMetaData::EDataProviderId) == iFramework.DataProviderId()) { GetPreviousPropertiesL(oldFolderName); // Remove backslash. oldFolderName.SetLength(oldFolderName.Length() - 1); SetPreviousPropertiesL(*iNewRootFolder); _LIT(KBackSlash, "\\"); oldFolderName.Append(KBackSlash); iObjectInfo->SetDesCL(CMTPObjectMetaData::ESuid, *iNewRootFolder); iObjectInfo->SetUint(CMTPObjectMetaData::EParentHandle, iNewParentHandle); iObjectInfo->SetUint(CMTPObjectMetaData::EStorageId, iStorageId); iFramework.ObjectMgr().ModifyObjectL(*iObjectInfo); } CleanupStack::PopAndDestroy(); // oldFolderName. OstTraceFunctionExit0( CMTPMOVEOBJECT_MOVEFOLDERL_EXIT ); }
void CTestRControlChannel::SavePreviousLogFileL() { _LIT(KInfoLogFile, "Saving Previous logs If any.... \n"); INFO_PRINTF1(KInfoLogFile); RFs fileserv; TInt error = fileserv.Connect(); if(!error) { _LIT(KlogFile, "C:\\logs\\log.txt"); _LIT(KPrefixLog, "C:\\logs\\"); _LIT(KSuffix, "_UDEB"); _LIT(KExtn, ".txt"); CFileMan* fMan = NULL; TRAP_IGNORE(fMan = CFileMan::NewL(fileserv)); if(fMan != NULL) { CleanupStack::PushL(fMan); RBuf newFileName; const TInt KTwenty = 20; newFileName.Create(ConfigSection().Length() + KTwenty ); newFileName.Copy(KPrefixLog); //Script file name iScriptName.Copy(ConfigSection()); newFileName.Append(iScriptName); newFileName.Append(KSuffix); newFileName.Append(KExtn); TInt error = fMan->Rename(KlogFile, newFileName); if (error != KErrNone) { _LIT(KErrInfo, "Unable to Save Previous logs...May be NO Previous logs exist \n"); ERR_PRINTF1(KErrInfo); } else { _LIT(KSavingInfo, "Saved Previous logs with File Name: %S \n"); INFO_PRINTF2(KSavingInfo, &newFileName); } CleanupStack::PopAndDestroy(fMan); newFileName.Close(); } } fileserv.Close(); _LIT(KInfoLogFile1, "Saving Previous logs End.... \n"); INFO_PRINTF1(KInfoLogFile1); }
void IntegrityRestoreFileL(const TDesC& aPath, CIntegrityTreeLeaf* aLeaf, RFs& aFs, RLoader& /*aLoader*/, CFileMan& /*aFileMan*/) { RBuf name; name.CreateL(aPath, KMaxFileName); CleanupClosePushL(name); name.Append(aLeaf->Name()); // find the peer file, and check it's a backup. CIntegrityTreeLeaf* peer = aLeaf->Peer(); if (peer->Type() != EBackupFile) { User::Leave(KErrCorrupt); } TParsePtrC parse(peer->Journal()); RBuf backup; backup.CreateL(parse.DriveAndPath(), KMaxFileName); CleanupClosePushL(backup); backup.Append(parse.Name()); backup.Append(KPathDelimiter); backup.Append(peer->Name()); TInt err = aFs.MkDirAll(name); if(err != KErrNone && err != KErrAlreadyExists) { User::Leave(err); } err = aFs.Rename(backup, name); if (err != KErrNone) { VerifyDeletionErrorL(err); // we may have already moved it back during a previous recovery // attempt, check for its presence in the original location TEntry restoredEntry; User::LeaveIfError(aFs.Entry(name, restoredEntry)); } else { // prune the backup directory tree if possible. RemoveDirectoryTreeL(aFs, backup); } CleanupStack::PopAndDestroy(2, &name); // backup }
void CPluginUtils::AddMultipartParamL( RBuf& aBuf, const TDesC& aParam, const TDesC& aValue ) { aBuf.ReAllocL( aBuf.Length() + KBoundary().Length() + aParam.Length() + aValue.Length() + 2 + 2 + 2 + 2 + 2 + 1 + KDisposition().Length() ); aBuf.Append( _L("--") ); aBuf.Append( KBoundary() ); aBuf.Append( KCrLf ); aBuf.Append( KDisposition() ); aBuf.Append( aParam ); aBuf.Append( _L("\"") ); aBuf.Append( KCrLf ); aBuf.Append( KCrLf ); aBuf.Append( aValue ); aBuf.Append( KCrLf ); }
EXPORT_C void SoftwareTypeRegInfoUtils::SerializeUniqueSwTypeNamesL(const RPointerArray<Usif::CSoftwareTypeRegInfo>& aSwTypeRegInfoArray, RBuf& aSerializedNames) { const TInt numNames = aSwTypeRegInfoArray.Count(); TInt bufLen = 0; for (TInt i=0; i<numNames; ++i) { const Usif::CSoftwareTypeRegInfo& info = *aSwTypeRegInfoArray[i]; bufLen += info.UniqueSoftwareTypeName().Length() + sizeof(TChar); } aSerializedNames.ReAllocL(aSerializedNames.Length()+bufLen); for (TInt i=0; i<numNames; ++i) { const Usif::CSoftwareTypeRegInfo& info = *aSwTypeRegInfoArray[i]; aSerializedNames.Append(info.UniqueSoftwareTypeName()); aSerializedNames.Append(static_cast<TChar>(KUniqueNameSeparator)); } }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::CreateIdListL( const TInt aIdEntryCount, RBuf& aEntryIdList, const TDesC& aColName ) { DEBUG(("_CA_:CASqlQueryCreator::CreateIdListL")); // Create an list of ids seperated by commas if( aIdEntryCount > 0 ) { aEntryIdList.CreateL( aIdEntryCount * ( aColName.Length() + KMaxIntNumLength ) - 1 ); for( TInt i = 0; i < aIdEntryCount; i++ ) { aEntryIdList.Append( aColName ); aEntryIdList.AppendNum( i ); if( i != aIdEntryCount - 1 ) { aEntryIdList.Append( KComma ); } } } }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::CreateLocalizationTableQueryL( CCaSqlQuery* aSqlQuery, const TDesC& aStatement) { DEBUG(("_CA_:CASqlQueryCreator::CreateLocalizationTableQueryL")); RBuf query; query.CleanupClosePushL(); query.CreateL( aStatement.Length() ); query.Append( aStatement ); aSqlQuery->SetQueryL( query ); CleanupStack::PopAndDestroy( &query ); }
void CPluginUtils::AddMultipartParamL( RBuf& aBuf, const TDesC& aParam, TInt aValue ) { TBuf<12> t; t.Format( _L("%d"), aValue ); aBuf.ReAllocL( aBuf.Length() + KBoundary().Length() + aParam.Length() + t.Length() + 2 + 2 + 2 + 2 + 2 + 1 + KDisposition().Length() ); aBuf.Append( _L("--") ); aBuf.Append( KBoundary() ); aBuf.Append( KCrLf ); aBuf.Append( KDisposition() ); aBuf.Append( aParam ); aBuf.Append( _L("\"") ); aBuf.Append( KCrLf ); aBuf.Append( KCrLf ); aBuf.Append( t ); aBuf.Append( KCrLf ); }
void AppendL(RBuf& aBuf, const TDesC& aDes, TBool aQuote) { const TInt requiredSpace = aDes.Length() + ((aBuf.Length() == 0) ? 0 : KEnumSeparator().Length()) + (aQuote ? 2 : 0); if ((aBuf.Length() + requiredSpace) > aBuf.MaxLength()) { aBuf.ReAllocL(Max(aBuf.Length() * 2, aBuf.Length() + requiredSpace)); } if (aBuf.Length() > 0) { aBuf.Append(KEnumSeparator); } if (aQuote) { aBuf.Append(KEnumQuote); } aBuf.Append(aDes); if (aQuote) { aBuf.Append(KEnumQuote); } }
/** Terminates the timer @param aComment Name of API. */ EXPORT_C void TTimerLogger::EndTimer(const TDesC& aComment) { #if defined (__LOG_PERFORMANCE) && !defined (_DEBUG) iEndTime.UniversalTime(); TTimeIntervalMicroSeconds iTimeDifference = iEndTime.MicroSecondsFrom(iStartTime); _LIT(KTimeDiff, ",%d microseconds\n"); RBuf myBuf; TInt err = myBuf.Create (aComment.Length()+64); __ASSERT_ALWAYS(KErrNone == err, User::Invariant() ); myBuf.Append (aComment ); myBuf.AppendFormat(KTimeDiff, iTimeDifference.Int64()); LogIt(myBuf); myBuf.Close(); iStartTime = 0; iEndTime = 0; #endif }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::ModifyQueryForSortOrderLastMostUsedL( const CCaInnerQuery::TSortAttribute aSortType, RBuf& aQuery ) { DEBUG(("_CA_:CASqlQueryCreator::ModifyQueryForSortOrderLastMostUsedL")); RBuf descPart; descPart.CleanupClosePushL(); if( aSortType == CCaInnerQuery::MostUsedDesc || aSortType == CCaInnerQuery::LastUsedDesc ) { descPart.CreateL( KDesc ); } else { descPart.CreateL( KNullDesC ); } RBuf usageDataQuery; usageDataQuery.CleanupClosePushL(); if( aSortType == CCaInnerQuery::MostUsed || aSortType == CCaInnerQuery::MostUsedDesc ) { usageDataQuery.CreateL( KSQLGetMostUsed ); } else { usageDataQuery.CreateL( KSQLGetLastUsed ); } RBuf newQuery; newQuery.CleanupClosePushL(); newQuery.CreateL( KSQLGetListByLaunchDataPart1().Length() + KSQLGetListByLaunchDataPart1().Length() + KSQLGetListByLaunchDataPart3().Length() + usageDataQuery.Length() + descPart.Length() + aQuery.Length() ); newQuery.Append( KSQLGetListByLaunchDataPart1 ); newQuery.Append( aQuery ); newQuery.Append( KSQLGetListByLaunchDataPart2 ); newQuery.Append( usageDataQuery ); newQuery.Append( KSQLGetListByLaunchDataPart3 ); newQuery.Append( descPart ); aQuery.Close(); aQuery.CreateL( newQuery ); CleanupStack::PopAndDestroy( &newQuery ); CleanupStack::PopAndDestroy( &usageDataQuery ); CleanupStack::PopAndDestroy( &descPart ); }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::CreateUpdateIconQueryL( const CCaInnerEntry* aEntry, CCaSqlQuery* aQuery ) { DEBUG(("_CA_:CASqlQueryCreator::CreateUpdateIconQueryL")); RBuf query; query.CleanupClosePushL(); query.CreateL( KSQLUpdateIcon().Length() ); query.Append( KSQLUpdateIcon ); if( aEntry->Icon()->FileName().Compare( KNullDesC ) ) { query.ReAllocL( query.Length() + KSQLUpdateIconFileName().Length() + KComma().Length() ); query.Append( KSQLUpdateIconFileName ); query.Append( KComma ); } if( aEntry->Icon()->SkinId().Compare( KNullDesC ) ) { query.ReAllocL( query.Length() + KSQLUpdateIconSkinId().Length() + KComma().Length() ); query.Append( KSQLUpdateIconSkinId ); query.Append( KComma ); } if( aEntry->Icon()->ApplicationId().Compare(KNullDesC) ) { query.ReAllocL( query.Length() + KSQLUpdateIconAppId().Length() + KComma().Length() ); query.Append( KSQLUpdateIconAppId ); } if( !query.Right( KComma().Length() ).Compare( KComma ) ) { query.Delete( query.Length() - KComma().Length(), KComma().Length() ); } // add WHERE expr query.ReAllocL( query.Length() + KSQLUpdateIconWhere().Length() ); query.Append( KSQLUpdateIconWhere ); aQuery->SetQueryL( query ); aQuery->SetTableType( CCaSqlQuery::EIconTable ); CleanupStack::PopAndDestroy( &query ); }
void IntegrityDeleteFileL(const TDesC& aPath, CIntegrityTreeLeaf* aLeaf, RFs& aFs, RLoader& aLoader, CFileMan& aFileMan) { _LIT(KSysBin, "\\sys\\bin"); RBuf name; name.CreateL(aPath, KMaxFileName); CleanupClosePushL(name); name.Append(aLeaf->Name()); TEntry entry; TInt err = aFs.Entry(name, entry); if (err == KErrNone) { aFs.SetAtt(name, 0, KEntryAttReadOnly); if(entry.IsDir()) { // Make sure to append slash before calling RmDir - otherwise it deletes the parent directory if (name[name.Length()-1] != KPathDelimiter) { name.Append(KPathDelimiter); } User::LeaveIfError(aFileMan.RmDir(name)); } else { if ( aLeaf->Type() == EBackupFile ) // Implies a commit operation is in progress { if ( IsBinary(entry) ) { // Forming the file name so the renamed file can be under sys/bin // for special delete mechanism using RLoader::Delete RBuf tmpName; TParsePtrC fileName(name); tmpName.CreateL(name.Length() + KSysBin.iTypeLength); CleanupClosePushL(tmpName); tmpName.Append(fileName.Drive()); tmpName.Append(KSysBin); tmpName.Append(fileName.Path()); tmpName.Append(fileName.NameAndExt()); DEBUG_PRINTF3(_L("Integrity Services - Renaming %S to %S"), &name, &tmpName); aFileMan.Rename(name,tmpName,CFileMan::EOverWrite); User::LeaveIfError(aLoader.Delete(tmpName)); // Using RLoader delete for paged binaries DEBUG_PRINTF2(_L("Integrity Services - Deleted renamed file %S"), &tmpName); // prune the directory tree if possible RemoveDirectoryTreeL(aFs, tmpName); CleanupStack::PopAndDestroy(&tmpName); } else { User::LeaveIfError(aFileMan.Delete(name)); } } else { // Need to use RLoader Delete which can be used during deletion of Added files during Rollback User::LeaveIfError(aLoader.Delete(name)); } } // prune the directory tree if possible RemoveDirectoryTreeL(aFs, name); } else if(err != KErrNotFound && err != KErrPathNotFound) { DEBUG_PRINTF3(_L("Integrity Services - error %d removing %S"), err, &name); User::Leave(err); } else { DEBUG_PRINTF3(_L("Integrity Services - error %d removing %S"), err, &name); // Check for any renamed files to move it to sys/bin for special delete mechanism RBuf tmpName; TParsePtrC fileName(name); tmpName.CreateL(name.Length() + KSysBin.iTypeLength); CleanupClosePushL(tmpName); tmpName.Append(fileName.Drive()); tmpName.Append(KSysBin); tmpName.Append(fileName.Path()); tmpName.Append(fileName.NameAndExt()); DEBUG_PRINTF2(_L("Integrity Services - Removing %S renamed binary files if any"), &tmpName); aLoader.Delete(tmpName); // prune the directory tree if possible RemoveDirectoryTreeL(aFs, tmpName); CleanupStack::PopAndDestroy(&tmpName); } CleanupStack::PopAndDestroy(&name); }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::ModifyQueryForSortOrderL( const CCaInnerQuery::TSortAttribute aSortType, RBuf& aQuery, TBool aSortByGroup ) { DEBUG(("_CA_:CASqlQueryCreator::ModifyQueryForSortOrderL")); switch ( aSortType ) { case CCaInnerQuery::Name: { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderNameAsc().Length() ); aQuery.Append( KSQLSortOrderNameAsc ); break; } case CCaInnerQuery::NameDesc: { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderNameDesc().Length() ); aQuery.Append( KSQLSortOrderNameDesc ); break; } case CCaInnerQuery::CreatedTimestamp: { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderCreatedTimestampAsc().Length() ); aQuery.Append( KSQLSortOrderCreatedTimestampAsc ); break; } case CCaInnerQuery::CreatedTimestampDesc: { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderCreatedTimestampDesc().Length() ); aQuery.Append( KSQLSortOrderCreatedTimestampDesc ); break; } case CCaInnerQuery::MostUsed: case CCaInnerQuery::MostUsedDesc: case CCaInnerQuery::LastUsed: case CCaInnerQuery::LastUsedDesc: { ModifyQueryForSortOrderLastMostUsedL( aSortType, aQuery ); break; } case CCaInnerQuery::DefaultDesc: { if( aSortByGroup ) { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderDefaultDesc().Length() ); aQuery.Append( KSQLSortOrderDefaultDesc ); } else { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderIdDesc().Length() ); aQuery.Append( KSQLSortOrderIdDesc ); } break; } case CCaInnerQuery::Default: default: { if( aSortByGroup ) { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderDefault().Length() ); aQuery.Append( KSQLSortOrderDefault ); } else { aQuery.ReAllocL( aQuery.Length() + KSQLSortOrderIdAsc().Length() ); aQuery.Append( KSQLSortOrderIdAsc ); } break; } } }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::CreateGetEntriesQueryByQueryL( const CCaInnerQuery* aQuery, CCaSqlQuery* aSqlQuery ) { DEBUG(("_CA_:CASqlQueryCreator::CreateGetEntriesQueryByQueryL")); RBuf whereStatement; whereStatement.CleanupClosePushL(); TUint flagsOn = aQuery->GetFlagsOn(); if( flagsOn != 0 ) { whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length() + KSQLGetEntryFlagsOn().Length() ); whereStatement.Append( KAnd ); whereStatement.Append( KSQLGetEntryFlagsOn ); } TUint flagsOff = aQuery->GetFlagsOff(); if( flagsOff != 0 ) { whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length() + KSQLGetEntryFlagsOff().Length() ); whereStatement.Append( KAnd ); whereStatement.Append( KSQLGetEntryFlagsOff ); } TInt role = aQuery->GetRole(); if( role != 0 ) { whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length() + KSQLGetEntryRole().Length() ); whereStatement.Append( KAnd ); whereStatement.Append( KSQLGetEntryRole ); } TUint uid = aQuery->GetUid(); if( uid != 0 ) { whereStatement.ReAllocL( KAnd().Length() + whereStatement.Length() + KSQLGetEntryUid().Length() ); whereStatement.Append( KAnd ); whereStatement.Append( KSQLGetEntryUid ); } const CDesC16ArrayFlat* typeNames = aQuery->GetEntryTypeNames(); if( typeNames && typeNames->MdcaCount() > 0 ) { RBuf typeNameWhereStatement; typeNameWhereStatement.CleanupClosePushL(); for( TInt i = 0; i < typeNames->MdcaCount(); i++ ) { typeNameWhereStatement.ReAllocL( typeNameWhereStatement.Length() + typeNames->MdcaPoint( i ).Length() + KSingleQuotes().Length() * 2 + KComma().Length() ); typeNameWhereStatement.Append( KSingleQuotes ); typeNameWhereStatement.Append( typeNames->MdcaPoint( i ) ); typeNameWhereStatement.Append( KSingleQuotes ); if( i != typeNames->MdcaCount() - 1 ) { typeNameWhereStatement.Append( KComma ); } } whereStatement.ReAllocL( KAnd().Length() + KSQLGetEntryTypeNames().Length() + typeNameWhereStatement.Length() + whereStatement.Length() ); whereStatement.Append( KAnd ); whereStatement.AppendFormat( KSQLGetEntryTypeNames, &typeNameWhereStatement ); CleanupStack::PopAndDestroy( &typeNameWhereStatement ); } if( aQuery->GetAttributes().Count() ) { RBuf whereAttributes; whereAttributes.CleanupClosePushL(); whereAttributes.CreateL( KEmpty ); for( TInt j=1; j <= aQuery->GetAttributes().Count(); j++ ) { // at1.AT_NAME = 'Attribute_Name_1' AND at1.AT_VALUE = 'Attribute_VALUE_1' TPtrC atrName( aQuery->GetAttributes().operator [](j-1)->Name() ); TPtrC atrValue( aQuery->GetAttributes().operator [](j-1)->Value() ); whereAttributes.ReAllocL( whereAttributes.Length() + 2 * KAnd().Length() + 4 * KSingleQuotes().Length() + 2 * KMaxIntNumLength + 2 * KAt().Length() + 2 * KDot().Length() + 2 * KEqual().Length() + KColumnAttrName().Length() + KColumnAttrValue().Length() + atrName.Length() + atrValue.Length() ); whereAttributes.Append( KAnd ); whereAttributes.Append( KAt ); whereAttributes.AppendNum( j ); whereAttributes.Append( KDot ); whereAttributes.Append( KColumnAttrName ); whereAttributes.Append( KEqual ); whereAttributes.Append( KSingleQuotes ); whereAttributes.Append( atrName ); whereAttributes.Append( KSingleQuotes ); whereAttributes.Append( KAnd ); whereAttributes.Append( KAt ); whereAttributes.AppendNum( j ); whereAttributes.Append( KDot ); whereAttributes.Append( KColumnAttrValue ); whereAttributes.Append( KEqual ); whereAttributes.Append( KSingleQuotes ); whereAttributes.Append( atrValue ); whereAttributes.Append( KSingleQuotes ); } whereStatement.ReAllocL( whereStatement.Length() + whereAttributes.Length() ); whereStatement.Append( whereAttributes ); CleanupStack::PopAndDestroy( &whereAttributes ); } RBuf leftJoins; leftJoins.CleanupClosePushL(); leftJoins.CreateL( KEmpty ); if( aQuery->GetAttributes().Count() ) { for( TInt j=1; j <= aQuery->GetAttributes().Count(); j++ ) { // LEFT JOIN CA_ATTRIBUTE as at1 ON ENTRY_ID = at1.AT_ENTRY_ID leftJoins.ReAllocL( leftJoins.Length() + KLeftJoinCaAttrubute1().Length() + KMaxIntNumLength + KLeftJoinCaAttrubute2().Length() + KMaxIntNumLength + KLeftJoinCaAttrubute3().Length() ); leftJoins.Append( KLeftJoinCaAttrubute1 ); leftJoins.AppendNum( j ); leftJoins.Append( KLeftJoinCaAttrubute2 ); leftJoins.AppendNum( j ); leftJoins.Append( KLeftJoinCaAttrubute3 ); } } whereStatement.ReAllocL( whereStatement.Length() + KGroupBy().Length() + KColumnEntryId().Length() ); whereStatement.Append( KGroupBy ); whereStatement.Append( KColumnEntryId ); TInt groupId = aQuery->GetParentId(); RBuf query; query.CleanupClosePushL(); if( groupId > 0 ) { RBuf getListByParentId2withWhere; getListByParentId2withWhere.CleanupClosePushL(); getListByParentId2withWhere.CreateL( KSQLGetListByParentId2().Length() + whereStatement.Length() ); getListByParentId2withWhere.AppendFormat( KSQLGetListByParentId2, &whereStatement ); query.ReAllocL( KSQLGetListByParentId1().Length() + leftJoins.Length() + getListByParentId2withWhere.Length() ); query.Append( KSQLGetListByParentId1 ); query.Append( leftJoins ); query.Append( getListByParentId2withWhere ); CleanupStack::PopAndDestroy( &getListByParentId2withWhere ); } else if ( aQuery->GetChildId() > 0 ) { RBuf getListByCildIdwithWhere; getListByCildIdwithWhere.CleanupClosePushL(); getListByCildIdwithWhere.CreateL( KSQLGetListByChildId().Length() + whereStatement.Length() ); getListByCildIdwithWhere.AppendFormat( KSQLGetListByChildId, &whereStatement ); query.ReAllocL( KSQLGetListByParentId1().Length() + leftJoins.Length() + getListByCildIdwithWhere.Length() ); query.Append( KSQLGetListByParentId1 ); query.Append( leftJoins ); query.Append( getListByCildIdwithWhere ); CleanupStack::PopAndDestroy( &getListByCildIdwithWhere ); } else { query.CreateL( KSQLGetList1().Length() ); query.Append( KSQLGetList1 ); query.ReAllocL( query.Length() + leftJoins.Length() + KSQLGetList2().Length() ); query.Append( leftJoins ); query.Append( KSQLGetList2 ); if( whereStatement.Length() >= KAnd().Length() ) { TPtrC ptrWhereStatement( whereStatement.Right( whereStatement.Length() - KAnd().Length() ) ); query.ReAllocL( query.Length() + KWhere().Length() + ptrWhereStatement.Length() ); query.Append( KWhere ); query.Append( ptrWhereStatement ); } } CCaInnerQuery::TSortAttribute sort = aQuery->GetSort(); ModifyQueryForSortOrderL( sort, query, groupId > 0 ); if( aQuery->GetCount() > 0 ) { query.ReAllocL( query.Length() + KLimit().Length() + KMaxIntNumLength ); query.Append( KLimit ); TInt limitCount = aQuery->GetCount(); query.AppendNum( limitCount ); } aSqlQuery->SetQueryL( query ); CleanupStack::PopAndDestroy( &query ); CleanupStack::PopAndDestroy( &leftJoins ); CleanupStack::PopAndDestroy( &whereStatement ); }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::CreateAddQueryL( CCaInnerEntry* aEntry, RPointerArray<CCaSqlQuery>& aSqlQuery, RSqlDatabase& aSqlDb ) { DEBUG(("_CA_:CASqlQueryCreator::CreateAddQueryL")); CCaSqlQuery* queryIcon = CCaSqlQuery::NewLC( aSqlDb ); TIconType iconType = CaSqlQueryCreator::CheckIconType( aEntry ); if( iconType == EProperIcon ) { CreateAddIconQueryL( aEntry, queryIcon, aSqlDb ); //add new icon to DB aSqlQuery.AppendL( queryIcon ); CleanupStack::Pop( queryIcon ); } else { // icon added to DB by another entry or not added CleanupStack::PopAndDestroy( queryIcon ); queryIcon = NULL; } if( aEntry->GetId() != -1 ) { // check if entry is new and has to be added to DB or just updated CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb ); if( aEntry->GetId() > 0 ) { //Update query is faster than replace query CreateUpdateQueryEntryL( aEntry, query ); } else { // check if entry's Uid was set if( aEntry->GetUid() == 0 ) { if( ( aEntry->GetIconId() == 0 ) && ( queryIcon == NULL ) ) { query->SetQueryL( KSQLInsertToEntryUniqueUidWithoutIcon ); } else { query->SetQueryL( KSQLInsertToEntryUniqueUid ); } } else { if( ( aEntry->GetIconId() == 0 ) && ( queryIcon == NULL ) ) { query->SetQueryL( KSQLInsertToEntryWithoutIcon ); } else { query->SetQueryL( KSQLInsertToEntry ); } } } query->SetTableType( CCaSqlQuery::EEntryTable ); aSqlQuery.AppendL( query ); CleanupStack::Pop( query ); } // remove all entry's attributs from DB CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb ); query->SetQueryL( KSQLDeleteAttribute ); aSqlQuery.Append( query ); query->SetTableType( CCaSqlQuery::EAttributeTable ); CleanupStack::Pop( query ); if( aEntry->GetAttributes().Count() > 0 ) { CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb ); query->SetQueryL( KSQLInsertToAttribute ); aSqlQuery.AppendL( query ); query->SetTableType( CCaSqlQuery::EAttributeTable ); CleanupStack::Pop( query ); } if( iconType == ENullIconToRemove ) { RBuf queryRemoveIcon; queryRemoveIcon.CleanupClosePushL(); queryRemoveIcon.CreateL( KSQLDeleteIconWhereIconId().Length() ); queryRemoveIcon.Append( KSQLDeleteIconWhereIconId ); queryRemoveIcon.ReAllocL( KSQLDeleteIconWhereIconId().Length() + KMaxIntNumLength ); queryRemoveIcon.AppendNum( aEntry->GetIconId() ); CCaSqlQuery* query = CCaSqlQuery::NewLC( aSqlDb ); query->SetQueryL( queryRemoveIcon ); aSqlQuery.AppendL( query ); query->SetTableType( CCaSqlQuery::EIconTable ); CleanupStack::Pop( query ); CleanupStack::PopAndDestroy( &queryRemoveIcon ); } }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::CreateFindIconQueryL( CCaInnerEntry* aEntry, CCaSqlQuery* aQuery) { RBuf iconQuery; iconQuery.CleanupClosePushL(); iconQuery.CreateL( KSQLGetIconIdWhere ); if( aEntry->Icon()->FileName().Compare( KNullDesC ) ) { iconQuery.ReAllocL( iconQuery.Length() + KSQLUpdateIconFileName().Length() + KAnd().Length() ); iconQuery.Append( KSQLUpdateIconFileName ); iconQuery.Append( KAnd ); } else { iconQuery.ReAllocL( iconQuery.Length() + KSQLEmptyIconFileName().Length() + KAnd().Length() ); iconQuery.Append( KSQLEmptyIconFileName ); iconQuery.Append( KAnd ); } if( aEntry->Icon()->SkinId().Compare( KNullDesC ) ) { iconQuery.ReAllocL( iconQuery.Length() + KSQLUpdateIconSkinId().Length() + KAnd().Length() ); iconQuery.Append( KSQLUpdateIconSkinId ); iconQuery.Append( KAnd ); } else { iconQuery.ReAllocL( iconQuery.Length() + KSQLEmptyIconSkinId().Length() + KAnd().Length() ); iconQuery.Append( KSQLEmptyIconSkinId ); iconQuery.Append( KAnd ); } if( aEntry->Icon()->ApplicationId().Compare( KNullDesC ) ) { iconQuery.ReAllocL( iconQuery.Length() + KSQLUpdateIconAppId().Length() + KAnd().Length() ); iconQuery.Append( KSQLUpdateIconAppId ); iconQuery.Append( KAnd ); } else { iconQuery.ReAllocL( iconQuery.Length() + KSQLEmptyIconAppId().Length() + KAnd().Length() ); iconQuery.Append( KSQLEmptyIconAppId ); iconQuery.Append( KAnd ); } if (!iconQuery.Right(KAnd().Length()).Compare(KAnd)) { iconQuery.Delete( iconQuery.Length() - KAnd().Length(), KAnd().Length() ); } aQuery->SetQueryL( iconQuery ); CleanupStack::PopAndDestroy( &iconQuery ); }
// --------------------------------------------------------------------------- // // --------------------------------------------------------------------------- // void CaSqlQueryCreator::CreateUpdateQueryEntryL( const CCaInnerEntry* aEntry, CCaSqlQuery* aQuery ) { DEBUG( ("_CA_:CASqlQueryCreator::CreateUpdateQueryEntryL") ); RBuf query; query.CleanupClosePushL(); query.CreateL( KSQLUpdateEntry().Length() ); query.Append( KSQLUpdateEntry ); // text if( aEntry->GetText().Length() != 0 ) { query.ReAllocL( query.Length() + KSQLUpdateEntryText().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryText ); query.Append( KComma ); } // description query.ReAllocL( query.Length() + KSQLUpdateEntryDescription().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryDescription ); query.Append( KComma ); // role query.ReAllocL( query.Length() + KSQLUpdateEntryRole().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryRole ); query.Append( KComma ); // type_name if( aEntry->GetEntryTypeName().Length() != 0 ) { query.ReAllocL( query.Length() + KSQLUpdateEntryTypeName().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryTypeName ); query.Append( KComma ); } // id_icon TIconType iconType = CaSqlQueryCreator::CheckIconType( aEntry ); if( iconType == ENullIconToRemove || iconType == ENullIcon ) { query.ReAllocL( query.Length( ) + KSQLUpdateEntryIdIconNull().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryIdIconNull ); } else { query.ReAllocL( query.Length( ) + KSQLUpdateEntryIdIcon().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryIdIcon ); } query.Append( KComma ); // check if entry's Uid was set if( aEntry->GetUid() ) { query.ReAllocL( query.Length() + KSQLUpdateEntryUid().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryUid ); query.Append( KComma ); } else { query.ReAllocL( query.Length() + KSQLUpdateEntryUidNULL().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryUidNULL ); query.Append( KComma ); } //flags query.ReAllocL( query.Length() + KSQLUpdateEntryFlags().Length() + KComma().Length() ); query.Append( KSQLUpdateEntryFlags ); query.ReAllocL( query.Length() + KSQLUpdateWhere().Length() ); query.Append( KSQLUpdateWhere ); aQuery->SetQueryL( query ); CleanupStack::PopAndDestroy( &query ); }
/** GetObjectHandles request handler */ void CMTPGetObjectHandles::ServiceL() { OstTraceFunctionEntry0( CMTPGETOBJECTHANDLES_SERVICEL_ENTRY ); if(iSingletons.DpController().EnumerateState() != CMTPDataProviderController::EEnumeratedFulllyCompleted) { TUint storageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1); TUint handle = Request().Uint32(TMTPTypeRequest::ERequestParameter3); TUint enumerateState = iSingletons.DpController().StorageEnumerateState(storageId); if ( (enumerateState < CMTPDataProviderController::EEnumeratingPhaseOneDone) || (enumerateState != CMTPDataProviderController::EEnumeratedFulllyCompleted && handle != KMTPHandleAll)) { if (iTimeoutCount++ >= KMTPGetObjectHandlesTimeOut) { OstTrace0( TRACE_NORMAL, CMTPGETOBJECTHANDLES_SERVICEL, "Wait for enumeration time out, return busy." ); SendResponseL(EMTPRespCodeDeviceBusy); iTimeoutCount = 0; OstTraceFunctionExit0( CMTPGETOBJECTHANDLES_SERVICEL_EXIT ); return; } else { OstTrace0( TRACE_NORMAL, DUP1_CMTPGETOBJECTHANDLES_SERVICEL, "Enumeration not completed, suspend request." ); RegisterPendingRequest(20); OstTraceFunctionExit0( DUP1_CMTPGETOBJECTHANDLES_SERVICEL_EXIT ); return; } } } iTimeoutCount = 0; delete iHandles; iHandles = NULL; iHandles = CMTPTypeArray::NewL(EMTPTypeAUINT32); OstTraceExt2( TRACE_NORMAL, DUP2_CMTPGETOBJECTHANDLES_SERVICEL, "IsConnectMac = %d; ERequestParameter2 = %d", iDevDpSingletons.DeviceDataStore().IsConnectMac(), Request().Uint32(TMTPTypeRequest::ERequestParameter2)); if(iDevDpSingletons.DeviceDataStore().IsConnectMac() &&(KMTPFormatsAll == Request().Uint32(TMTPTypeRequest::ERequestParameter2))) { OstTrace0( TRACE_NORMAL, DUP3_CMTPGETOBJECTHANDLES_SERVICEL, "ConnectMac and Fetch all." ); HandleObjectHandlesUnderMacL(*iHandles); } else { RMTPObjectMgrQueryContext context; RArray<TUint> handles; CleanupClosePushL(context); CleanupClosePushL(handles); TMTPObjectMgrQueryParams params(Request().Uint32(TMTPTypeRequest::ERequestParameter1), Request().Uint32(TMTPTypeRequest::ERequestParameter2), Request().Uint32(TMTPTypeRequest::ERequestParameter3)); do { iFramework.ObjectMgr().GetObjectHandlesL(params, context, handles); TUint32 storageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1); TUint32 parentHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter3); if ( storageId != KMTPStorageAll && parentHandle == KMTPHandleNoParent ) { const CMTPStorageMetaData& storage(iFramework.StorageMgr().StorageL(storageId)); HBufC* StorageSuid = storage.DesC(CMTPStorageMetaData::EStorageSuid).AllocL(); RBuf suid; suid.CleanupClosePushL(); suid.CreateL(KMaxFileName); suid = *StorageSuid; _LIT(WMPInfoXml,"WMPInfo.xml"); suid.Append(WMPInfoXml); TUint32 handle = iFramework.ObjectMgr().HandleL(suid); if ( handle != KMTPHandleNone ) { TInt index = handles.Find(handle); if ( index != KErrNotFound ) { handles.Remove(index); handles.InsertL(handle,0); } } delete StorageSuid; StorageSuid = NULL; CleanupStack::PopAndDestroy(); } iHandles->AppendL(handles); } while (!context.QueryComplete()); CleanupStack::PopAndDestroy(&handles); CleanupStack::PopAndDestroy(&context); } SendDataL(*iHandles); OstTraceFunctionExit0( DUP2_CMTPGETOBJECTHANDLES_SERVICEL_EXIT ); }