diff -r b3cee849fa46 -r fad26422216a creator/src/creator_file.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/creator/src/creator_file.cpp Wed Sep 01 12:30:35 2010 +0100 @@ -0,0 +1,847 @@ +/* +* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + + +#include "creator_file.h" +#include +#include +#include +#include "creator_traces.h" + +using namespace ContentAccess; + +static const TInt KFilesFieldLength = 256; + +//_LIT(KCreatorFilesPrefixName, "CR_"); +//_LIT(KCreatorFilesPrefixFolderName, "CR_FLDR_"); + +//---------------------------------------------------------------------------- + +CFilesParameters::CFilesParameters() + { + LOGSTRING("Creator: CFilesParameters::CFilesParameters"); + iFullFilePath = HBufC::New(KFilesFieldLength); + } +CFilesParameters::CFilesParameters( CFilesParameters& aCopy ) + { + LOGSTRING("Creator: CFilesParameters::CFilesParameters"); + iFullFilePath = HBufC::New(KFilesFieldLength); + iFullFilePath->Des().Copy( *aCopy.iFullFilePath ); + iFileCommand = aCopy.iFileCommand; + iEncrypt = aCopy.iEncrypt; + if ( aCopy.iPermission ) + { + iPermission = CDRMPermission::NewL(); + iPermission->DuplicateL( *aCopy.iPermission ); + } + } +CFilesParameters::~CFilesParameters() + { + LOGSTRING("Creator: CFilesParameters::~CFilesParameters"); + delete iFullFilePath; + delete iPermission; + } + +//---------------------------------------------------------------------------- + +CCreatorFiles* CCreatorFiles::NewL(CCreatorEngine* aEngine) + { + CCreatorFiles* self = CCreatorFiles::NewLC(aEngine); + CleanupStack::Pop(self); + return self; + } + +CCreatorFiles* CCreatorFiles::NewLC(CCreatorEngine* aEngine) + { + CCreatorFiles* self = new (ELeave) CCreatorFiles; + CleanupStack::PushL(self); + self->ConstructL(aEngine); + return self; + } + +CCreatorFiles::CCreatorFiles() : + iFs ( CEikonEnv::Static()->FsSession() ) + { + } + +void CCreatorFiles::ConstructL(CCreatorEngine* aEngine) + { + LOGSTRING("Creator: CCreatorFiles::ConstructL"); + + iEngine = aEngine; + + iDirectoryQueriedFromUser = HBufC::New(KFilesFieldLength); + User::LeaveIfError( iApaLs.Connect() ); + + iFilePaths = new (ELeave) CDesCArrayFlat( 4 ); + + // Restore file id + CDictionaryFileStore* store = iEngine->FileStoreLC(); + User::LeaveIfNull( store ); + if ( store->IsPresentL( KUidDictionaryUidFiles ) ) + { + RDictionaryReadStream in; + in.OpenLC( *store, KUidDictionaryUidFiles ); + TRAPD( err, iFileId = in.ReadInt32L() ); + if ( err ) + { + iFileId = 1; + } + CleanupStack::PopAndDestroy(); // in + } + else + { + iFileId = 1; + } + CleanupStack::PopAndDestroy( store ); + } + +CCreatorFiles::~CCreatorFiles() + { + LOGSTRING("Creator: CCreatorFiles::~CCreatorFiles"); + + // this is done only once per file operation: + if ( iFilePaths && iFilePaths->Count() ) + { + TRAP_IGNORE( StorePathsForDeleteL( *iFilePaths ) ); + } + delete iFilePaths; + delete iDirectoryQueriedFromUser; + delete iParameters; + delete iUserParameters; + iApaLs.Close(); + } + +//---------------------------------------------------------------------------- + +TBool CCreatorFiles::AskDataFromUserL(TInt aCommand, TInt& aNumberOfEntries) + { + LOGSTRING("Creator: CCreatorFiles::AskDataFromUserL"); + + if ( aCommand == ECmdDeleteCreatorFiles ) + { + return iEngine->YesNoQueryDialogL( _L("Delete all files created with Creator?") ); + } + + delete iUserParameters; + iUserParameters = NULL; + iUserParameters = new(ELeave) CFilesParameters(); + + iDirectoryQueriedFromUser->Des().Copy( KNullDesC ); + + if (iEngine->EntriesQueryDialogL(aNumberOfEntries, _L("How many entries to create?"))) + { + // set a default directory (eg. c:\Nokia\Images\) + TFileName directory; + iEngine->SetDefaultPathForFileCommandL(aCommand, directory); + + // directory query dialog + CAknTextQueryDialog* textDialog = CAknTextQueryDialog::NewL(directory, CAknQueryDialog::ENoTone); + textDialog->SetMaxLength(256); + + TBuf<50> promptText; + + if (aCommand == ECmdCreateFileEntryEmptyFolder) + promptText.Copy( _L("Specify the folder path and name") ); + else + promptText.Copy( _L("Specify the directory") ); + + if (textDialog->ExecuteLD(R_DIRECTORY_QUERY, promptText)) + { + // check that the root folder is correct + if (directory.Length() < 3 || BaflUtils::CheckFolder(iFs, directory.Left(3)) != KErrNone) + { + CAknErrorNote* errorNote = new (ELeave) CAknErrorNote; + errorNote->ExecuteLD(_L("Invalid path")); + return EFalse; + } + else + { + // check the directory contains a trailing backlash + if (directory.Right(1) != _L("\\")) + directory.Append(_L("\\")); + + // copy the directory name to a class member + iDirectoryQueriedFromUser->Des() = directory; + if ( aCommand == ECmdCreateFileEntryEmptyFolder ) return ETrue; + else return AskDRMDataFromUserL(); + } + } + else + return EFalse; + } + else + return EFalse; + + } + + +//---------------------------------------------------------------------------- + +TInt CCreatorFiles::CreateFileEntryL(CFilesParameters *aParameters, TInt aCommand) + { + LOGSTRING("Creator: CCreatorFiles::CreateFileEntryL"); + + // clear any existing parameter definations + delete iParameters; + iParameters = NULL; + TFileName directoryToBeCreated; + + CFilesParameters* parameters = aParameters; + + if (!parameters) + { + if ( iUserParameters ) + { + iParameters = new (ELeave) CFilesParameters( *iUserParameters ); + // iUserParameters = NULL; + } + else + { + // random data needed if no predefined data available + iParameters = new (ELeave) CFilesParameters; + } + parameters = iParameters; + } + + TInt err = KErrNone; + + // if we just create directories + if ( aCommand == ECmdCreateFileEntryEmptyFolder) + { + // strip the last backslash from the path + if( iDirectoryQueriedFromUser && iDirectoryQueriedFromUser->Des().Length() > 0) + directoryToBeCreated = iDirectoryQueriedFromUser->Des(); + else if( parameters->iFullFilePath && parameters->iFullFilePath->Des().Length() > 0 ) + directoryToBeCreated = parameters->iFullFilePath->Des(); + else + return err; + + _LIT(KSlash, "\\"); + if( directoryToBeCreated.Right(1) == KSlash ) + directoryToBeCreated.SetLength ( directoryToBeCreated.Length() - 1 ); + + // generate a unique file name + err = CApaApplication::GenerateFileName( iFs, directoryToBeCreated); + if (err != KErrNone) + return err; + + // now append the backslah back + directoryToBeCreated.Append( _L("\\") ); + + // now create the new directory + err = iFs.MkDirAll( directoryToBeCreated ); + + // Add directoryToBeCreated to store + iFilePaths->AppendL( directoryToBeCreated ); + + LOGSTRING3("Creator: CCreatorFiles::CreateFileEntryL creating empty directory %S returns err", &directoryToBeCreated, err); + } + + else // files + { + LOGSTRING2("Creator: CCreatorFiles::CreateFileEntryL file id is %d", aCommand); + + // get source + TFileName fullSourcePath; + switch (aCommand) + { + case ECmdCreateFileEntryJPEG_25kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJPEG_25kB ); break; } + case ECmdCreateFileEntryJPEG_200kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJPEG_200kB ); break; } + case ECmdCreateFileEntryJPEG_500kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJPEG_500kB ); break; } + case ECmdCreateFileEntryPNG_15kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EPNG_15kB ); break; } + case ECmdCreateFileEntryGIF_2kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EGIF_2kB ); break; } + case ECmdCreateFileEntryRNG_1kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ERNG_1kB ); break; } + case ECmdCreateFileEntryMIDI_10kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMIDI_10kB ); break; } + case ECmdCreateFileEntryWAV_20kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWAVE_20kB ); break; } + case ECmdCreateFileEntryAMR_20kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EAMR_20kB ); break; } + case ECmdCreateFileEntryXLS_15kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EExcel_15kB ); break; } + case ECmdCreateFileEntryDOC_20kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWord_20kB ); break; } + case ECmdCreateFileEntryPPT_40kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EPowerPoint_40kB ); break; } + case ECmdCreateFileEntryTXT_10kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EText_10kB ); break; } + case ECmdCreateFileEntryTXT_70kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EText_70kB ); break; } + case ECmdCreateFileEntry3GPP_70kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::E3GPP_70kB ); break; } + case ECmdCreateFileEntryMP3_250kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMP3_250kB ); break; } + case ECmdCreateFileEntryAAC_100kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EAAC_100kB ); break; } + case ECmdCreateFileEntryRM_95kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ERM_95kB ); break; } + case ECmdCreateFileEntryBMP_25kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EBMP_25kB ); break; } + case ECmdCreateFileEntryDeck_1kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESavedDeck_1kB ); break; } + case ECmdCreateFileEntryHTML_20kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EHTML_20kB ); break; } + case ECmdCreateFileEntryJAD_1kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJAD_1kB ); break; } + case ECmdCreateFileEntryJAR_10kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJAR_10kB ); break; } + case ECmdCreateFileEntryJP2_65kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EJP2_65kB ); break; } + case ECmdCreateFileEntryMP4_200kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMP4_200kB ); break; } + case ECmdCreateFileEntryMXMF_40kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EMXMF_40kB ); break; } + case ECmdCreateFileEntryRAM_1kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ERAM_1kB ); break; } + case ECmdCreateFileEntrySVG_15kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESVG_15kB ); break; } + case ECmdCreateFileEntrySWF_15kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESWF_15kB ); break; } + case ECmdCreateFileEntryTIF_25kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ETIF_25kB ); break; } + case ECmdCreateFileEntryVCF_1kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EVCF_1kB ); break; } + case ECmdCreateFileEntryVCS_1kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EVCS_1kB ); break; } + case ECmdCreateFileEntrySISX_10kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::ESISX_10kB ); break; } + case ECmdCreateFileEntryWMA_50kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWMA_50kB ); break; } + case ECmdCreateFileEntryWMV_200kB: { fullSourcePath = iEngine->TestDataPathL( CCreatorEngine::EWMV_200kB ); break; } + case ECmdCreateFileEntryEmptyFolder: { User::Panic(_L("EmptyFolder"), 801); break; } + default: { return KErrPathNotFound; } + } + + + // define the full target path + TFileName fullTargetPath; + + if ( parameters->iFullFilePath && parameters->iFullFilePath->Des().Length() > 3 ) + { + _LIT(KSlash, "\\"); + // check the path is ok + fullTargetPath = parameters->iFullFilePath->Des(); + + if(fullTargetPath.Right(1) == KSlash) + { + // Remove '\' from the end, because the filename check does not work with it: + fullTargetPath.SetLength ( fullTargetPath.Length() - 1 ); + } + + if (!iFs.IsValidName( fullTargetPath )) + User::Leave(KErrBadName); + + // target path = directory + the file name from source path + TParse parser; + parser.Set(fullSourcePath, NULL, NULL); + + // Add '\' to the end: + fullTargetPath.Append(KSlash); + // Add filename: + fullTargetPath.Append( parser.NameAndExt() ); + + LOGSTRING2("Creator: CCreatorFiles::CreateFileEntryL iFullFilePath used, fullTargetPath: %S", &fullTargetPath); + } + + else if ( iDirectoryQueriedFromUser && iDirectoryQueriedFromUser->Des().Length() > 0 ) + { + // target path = directory + the file name from source path + TParse parser; + parser.Set(fullSourcePath, NULL, NULL); + + fullTargetPath = iDirectoryQueriedFromUser->Des(); + fullTargetPath.Append( parser.NameAndExt() ); + + LOGSTRING2("Creator: CCreatorFiles::CreateFileEntryL iDirectoryQueriedFromUser used, fullTargetPath: %S", &fullTargetPath); + } + + else + { + LOGSTRING("Creator: CCreatorFiles::CreateFileEntryL leaving with KErrPathNotFound"); + User::Leave(KErrPathNotFound); + } + + TBool encrypt = parameters->iEncrypt; + if ( encrypt ) fullTargetPath.Append( KOma2DcfExtension ); + // check the target path has a unique filename ie we won't overwrite existing files + // also generates any missing directories + if ( BaflUtils::FileExists( iFs, fullTargetPath ) ) + { + GenerateFileNameL( fullTargetPath ); + } + User::LeaveIfError(CApaApplication::GenerateFileName( iFs, fullTargetPath ) ); + + if ( encrypt ) + { + EncryptFileL( fullSourcePath, fullTargetPath, parameters ); + } + else + { + // copy the file (synchronous function) + err = BaflUtils::CopyFile(iFs, fullSourcePath, fullTargetPath); + LOGSTRING4("Creator: CCreatorFiles::CreateFileEntryL copy %S to %S, err=%d", &fullSourcePath, &fullTargetPath, err); + } + + if (err != KErrNone) + User::Leave(err); // leave because copying failed + + // Add fullTargetPath to store + iFilePaths->AppendL( fullTargetPath ); + + // make sure that the file won't have a read only attribute + TEntry fileEntry; + iFs.Entry(fullTargetPath, fileEntry); + iFs.SetEntry(fullTargetPath, fileEntry.iModified, NULL, KEntryAttReadOnly); + + // clear variables + parameters->iFullFilePath->Des().Copy ( KNullDesC ); + } + + return err; + } + +//---------------------------------------------------------------------------- + +void CCreatorFiles::EncryptFileL( const TDesC& aInFileName, const TDesC& aOutFileName, CFilesParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorFiles::EncryptFileL"); + TBuf8<64> mime; + SetMimeTypeL( aInFileName, mime, aParameters ); + CSupplier* supplier = CSupplier::NewLC(); + + CMetaDataArray* metaData = CMetaDataArray::NewLC(); + + // Tell the agent which MIME type to use for the encrypted data + metaData->AddL( KOmaImportMimeTypeField, mime ); + + if ( aParameters && aParameters->iPermission ) + { + // Combined Delivery file will be created + SetPermissionsL( metaData, aOutFileName, aParameters ); + } + + supplier->SetOutputDirectoryL( *iDirectoryQueriedFromUser ); + + // The KOmaImportContentType is a OMA DRM agent specific MIME type which + // indicates that plain content is to be encrypted + CImportFile* importFile = supplier->ImportFileL( KOmaImportContentType, + *metaData, + aOutFileName ); + CleanupStack::PushL( importFile ); + + // Peek the source file size: + TInt fileLen( 0 ); + RFile file; + User::LeaveIfError( file.Open( iFs, aInFileName, EFileRead ) ); + CleanupClosePushL( file ); + User::LeaveIfError( file.Size( fileLen ) ); + CleanupStack::PopAndDestroy( &file ); + + // Read the source file to inmemory buffer + RFileReadStream rs; + User::LeaveIfError( rs.Open( iFs, + aInFileName, + EFileStream | EFileRead ) ); + CleanupClosePushL( rs ); + HBufC8* fileBuf = HBufC8::NewLC( fileLen ); + TPtr8 p = fileBuf->Des(); + rs.ReadL( p, fileLen ); + + // Start encryption + TInt err = importFile->WriteData( p ); + if ( err == KErrCANewFileHandleRequired ) + { + RFile file; + User::LeaveIfError( file.Create( iFs, aOutFileName, EFileWrite ) ); + CleanupClosePushL( file ); + importFile->ContinueWithNewOutputFile( file, aOutFileName ); + CleanupStack::PopAndDestroy( &file ); + } + else + { + User::LeaveIfError( err ); + } + User::LeaveIfError( importFile->WriteDataComplete() ); + CleanupStack::PopAndDestroy( fileBuf ); + CleanupStack::PopAndDestroy( &rs ); + CleanupStack::PopAndDestroy( importFile ); + CleanupStack::PopAndDestroy( metaData ); + CleanupStack::PopAndDestroy( supplier ); + } + +//---------------------------------------------------------------------------- + +void CCreatorFiles::SetPermissionsL( CMetaDataArray* aMetaData, const TDesC& aOutFileName, CFilesParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorFiles::SetPermissionsL"); + CDRMRights* rights = CDRMRights::NewL(); + CleanupStack::PushL( rights ); + + HBufC8* cnturi = HBufC8::NewL( KMaxFileName ); + cnturi->Des().Copy( aOutFileName ); + + CDRMAsset* asset = CDRMAsset::NewLC(); + asset->iUid = cnturi; + // Set the asset to the rights class, it will duplicate the asset + rights->SetAssetL( *asset ); + CleanupStack::PopAndDestroy( asset ); + + rights->SetPermissionL( *aParameters->iPermission ); + + // Construct externalized presentation of the rights object + TInt rightsSize = 1024 *100; + HBufC8* rightBuf = HBufC8::NewLC( rightsSize ); + TPtr8 bptr = rightBuf->Des(); + bptr.SetLength( rightsSize ); + RMemWriteStream iWriteStream; + iWriteStream.Open( (TAny*)(rightBuf->Ptr() ), rightsSize ); + CleanupClosePushL( iWriteStream ); + iWriteStream << *rights; + iWriteStream.CommitL(); + TPtr8 rp = rightBuf->Des(); + + // Add rights to metadata + aMetaData->AddL( KOmaImportRightsField, rp ); + CleanupStack::PopAndDestroy( &iWriteStream ); + CleanupStack::PopAndDestroy( rightBuf ); + CleanupStack::PopAndDestroy( rights ); + } + +//---------------------------------------------------------------------------- + +void CCreatorFiles::SetMimeTypeL( const TDesC& aFileName, TDes8& aMime, CFilesParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorFiles::SetMimeTypeL"); + TUid appUid; + TDataType dataType; + User::LeaveIfError( iApaLs.AppForDocument( aFileName, appUid, dataType ) ); + if ( dataType.Des().Length() ) + { + aMime.Copy( dataType.Des() ); + } + else + { + // set default mime, because it was not recognized by iApaLs + aMime.Copy( _L("text/plain") ); + } + + // set DRM permissions according the type of the file + if ( aParameters->iPermission ) + { + if ( dataType.Des().FindF( _L("image") ) > KErrNotFound ) + { + aParameters->iPermission->iAvailableRights = ERightsDisplay | ERightsPrint; + } + else if ( dataType.Des().FindF( _L("audio") ) > KErrNotFound || + dataType.Des().FindF( _L("video") ) > KErrNotFound || + dataType.Des().FindF( _L("tone") ) > KErrNotFound || // e.g. application/vnd.nokia.ringing-tone + dataType.Des().FindF( _L("realmedia") ) > KErrNotFound ) + { + // media files + aParameters->iPermission->iAvailableRights = ERightsPlay; + } + else if ( dataType.Des().FindF( _L("archive") ) > KErrNotFound || + dataType.Des().FindF( _L("x-sis") ) > KErrNotFound ) + { + // application/java-archive + // x-epoc/x-sisx-app + aParameters->iPermission->iAvailableRights = ERightsExecute; + } + else if ( dataType.Des().FindF( _L("application") ) > KErrNotFound || + dataType.Des().FindF( _L("text") ) > KErrNotFound ) + { + // application/msexcel + // application/msword + // text/plain + // etc. + aParameters->iPermission->iAvailableRights = ERightsDisplay | ERightsPrint; + } + else + { + // other filetype + aParameters->iPermission->iAvailableRights = ERightsDisplay; + } + } + } + +//---------------------------------------------------------------------------- + +TBool CCreatorFiles::AskDRMDataFromUserL() + { + LOGSTRING("Creator: CCreatorFiles::AskDRMDataFromUserL"); + // Encryption -dialog + TInt encIndex( 0 ); + CAknListQueryDialog* encDlg = new (ELeave) CAknListQueryDialog( &encIndex ); + encDlg->PrepareLC( R_ENCRYPTION_DIALOG ); + //Create flat array from which list is built. + CDesCArrayFlat* items = new(ELeave) CDesCArrayFlat(5); + CleanupStack::PushL(items); + + // Add entires to list + items->AppendL( _L("None") ); + items->AppendL( _L("DRM Forward Lock") ); + items->AppendL( _L("DRM Combined Delivery") ); + + // Add items into main list + encDlg->SetOwnershipType( ELbmOwnsItemArray ); + encDlg->SetItemTextArray( items ); + CleanupStack::Pop( items ); + encDlg->ListBox()->SetCurrentItemIndexAndDraw( 0 ); + + if ( encDlg->RunLD() ) + { + if ( encIndex > 0 ) + { + iUserParameters->iEncrypt = ETrue; + } + if ( encIndex == 2 ) + { + iUserParameters->iPermission = CDRMPermission::NewL(); + CDRMPermission* perm = iUserParameters->iPermission; + perm->iTopLevel->iActiveConstraints = EConstraintNone; + perm->iPlay->iActiveConstraints = EConstraintNone; + perm->iDisplay->iActiveConstraints = EConstraintNone; + perm->iPrint->iActiveConstraints = EConstraintNone; + perm->iExecute->iActiveConstraints = EConstraintNone; + perm->iUniqueID = 0; + // DRM Combined Delivery + return AskDRMCDDataFromUserL(); + } + return ETrue; + } + else + { + return EFalse; + } + } + +//---------------------------------------------------------------------------- + +TBool CCreatorFiles::AskDRMCDDataFromUserL() + { + LOGSTRING("Creator: CCreatorFiles::AskDRMCDDataFromUserL"); + TInt count( 0 ); + if ( iEngine->EntriesQueryDialogL( count, _L("How many counts\r\n(0=unlimited)?"), ETrue ) ) + { + if ( count > 0 ) + { + CDRMPermission* perm = iUserParameters->iPermission; + // apply constraints to all permission types + // applied type will be selected by setting iAvailableRights + // when determining the file type + perm->iDisplay->iActiveConstraints |= EConstraintCounter; + perm->iDisplay->iCounter = count; + perm->iDisplay->iOriginalCounter = count; + + perm->iPlay->iActiveConstraints |= EConstraintCounter; + perm->iPlay->iCounter = count; + perm->iPlay->iOriginalCounter = count; + + perm->iPrint->iActiveConstraints |= EConstraintCounter; + perm->iPrint->iCounter = count; + perm->iPrint->iOriginalCounter = count; + + perm->iExecute->iActiveConstraints |= EConstraintCounter; + perm->iExecute->iCounter = count; + perm->iExecute->iOriginalCounter = count; + } + } + else + { + return EFalse; + } + /* + TInt seconds( 0 ); + if ( iEngine->EntriesQueryDialogL( seconds, _L("How many accumulated seconds until expire (0=unlimited)?"), ETrue ) ) + { + if ( seconds > 0 ) + { + CDRMPermission* perm = iUserParameters->iPermission; + // apply constraints to all permission types + // applied type will be selected by setting iAvailableRights + // when determining the file type + perm->iDisplay->iActiveConstraints |= EConstraintAccumulated; + perm->iDisplay->iEndTime = Time::MaxTTime(); + perm->iDisplay->iStartTime = Time::MinTTime();; + perm->iDisplay->iAccumulatedTime = seconds; + + perm->iPlay->iActiveConstraints |= EConstraintAccumulated; + perm->iPlay->iEndTime = Time::MaxTTime(); + perm->iPlay->iStartTime = Time::MinTTime();; + perm->iPlay->iAccumulatedTime = seconds; + + perm->iPrint->iActiveConstraints |= EConstraintAccumulated; + perm->iPrint->iEndTime = Time::MaxTTime(); + perm->iPrint->iStartTime = Time::MinTTime();; + perm->iPrint->iAccumulatedTime = seconds; + + perm->iExecute->iActiveConstraints |= EConstraintAccumulated; + perm->iExecute->iEndTime = Time::MaxTTime(); + perm->iExecute->iStartTime = Time::MinTTime();; + perm->iExecute->iAccumulatedTime = seconds; + } + } + else + { + return EFalse; + } + */ + + TInt minutes( 0 ); + if ( iEngine->EntriesQueryDialogL( minutes, _L("How many minutes until expire (0=unlimited)?"), ETrue ) ) + { + if ( minutes > 0 ) + { + CDRMPermission* perm = iUserParameters->iPermission; + // apply constraints to all permission types + // applied type will be selected by setting iAvailableRights + // when determining the file type + perm->iDisplay->iActiveConstraints |= EConstraintInterval; + perm->iDisplay->iInterval = TTimeIntervalSeconds( 60 * minutes ); + perm->iDisplay->iIntervalStart = Time::NullTTime(); + + perm->iPlay->iActiveConstraints |= EConstraintInterval; + perm->iPlay->iInterval = TTimeIntervalSeconds( 60 * minutes ); + perm->iPlay->iIntervalStart = Time::NullTTime(); + + perm->iPrint->iActiveConstraints |= EConstraintInterval; + perm->iPrint->iInterval = TTimeIntervalSeconds( 60 * minutes ); + perm->iPrint->iIntervalStart = Time::NullTTime(); + + perm->iExecute->iActiveConstraints |= EConstraintInterval; + perm->iExecute->iInterval = TTimeIntervalSeconds( 60 * minutes ); + perm->iExecute->iIntervalStart = Time::NullTTime(); + } + } + else + { + return EFalse; + } + + return ETrue; + } + +//---------------------------------------------------------------------------- +void CCreatorFiles::DeleteAllL() + { + LOGSTRING("Creator: CCreatorFiles::DeleteAllL"); + User::Leave( KErrNotSupported ); // will not be supported + } + +//---------------------------------------------------------------------------- +void CCreatorFiles::DeleteAllCreatedByCreatorL() + { + LOGSTRING("Creator: CCreatorFiles::DeleteAllCreatedByCreatorL"); + iFileId = 1; + CDictionaryFileStore* store = iEngine->FileStoreLC(); + User::LeaveIfNull( store ); + + if ( store->IsPresentL( KUidDictionaryUidFiles ) ) + { + RDictionaryReadStream in; + in.OpenLC( *store, KUidDictionaryUidFiles ); + CFileMan* fileMan = CFileMan::NewL( iFs ); + CleanupStack::PushL( fileMan ); + TFileName fullPath; + // ignore return value, don't update iFileId here: + TRAPD( err, in.ReadInt32L() ); + while ( !err ) + { + TInt len( KErrNotFound ); + TRAP( err, len = in.ReadInt8L() ); // will leave with KErrEof + if ( !err ) + { + TRAP( err, in.ReadL( fullPath, len ) ); + } + if ( !err ) + { + TEntry fileEntry; + iFs.Entry( fullPath, fileEntry ); + if ( fileEntry.IsDir() ) + { + fileMan->RmDir( fullPath ); // ignore return value + } + else + { + iFs.Delete( fullPath ); // ignore return value + } + } + } + CleanupStack::PopAndDestroy( fileMan ); + CleanupStack::PopAndDestroy( &in ); + + // files deleted, remove the Creator internal file registry + store->Remove( KUidDictionaryUidFiles ); + store->CommitL(); + } + CleanupStack::PopAndDestroy( store ); + } + +//---------------------------------------------------------------------------- +void CCreatorFiles::StorePathsForDeleteL( CDesCArray& aPaths ) + { + LOGSTRING("Creator: CCreatorFiles::StorePathsForDeleteL"); + CDictionaryFileStore* store = iEngine->FileStoreLC(); + User::LeaveIfNull( store ); + + // backup previous filepaths from store + // otherwise they would be overwritten when calling out.WriteL + CDesCArray* previousPaths = new (ELeave) CDesCArrayFlat( 4 ); + CleanupStack::PushL( previousPaths ); + + TFileName fullPath; + + if ( store->IsPresentL( KUidDictionaryUidFiles ) ) + { + RDictionaryReadStream in; + in.OpenLC( *store, KUidDictionaryUidFiles ); + // ignore return value, don't update iFileId here: + TRAPD( err, in.ReadInt32L() ); + while ( !err ) + { + TRAP( err, + TInt len = in.ReadInt8L(); // will leave with KErrEof + in.ReadL( fullPath, len ); + previousPaths->AppendL( fullPath ); + ); + } + CleanupStack::PopAndDestroy(); // in + } + + RDictionaryWriteStream out; + out.AssignLC( *store, KUidDictionaryUidFiles ); + + // write latest file id to store + out.WriteInt32L( iFileId ); + + // restore previous paths to store + for ( TInt i = 0; i < previousPaths->Count(); i++ ) + { + out.WriteInt8L( (*previousPaths)[i].Length() ); + out.WriteL( (*previousPaths)[i] ); + } + + // write new paths to store + for ( TInt i = 0; i < aPaths.Count(); i++ ) + { + out.WriteInt8L( aPaths[i].Length() ); + out.WriteL( aPaths[i] ); + } + + out.CommitL(); + CleanupStack::PopAndDestroy(); // out + + store->CommitL(); + CleanupStack::PopAndDestroy( previousPaths ); + CleanupStack::PopAndDestroy( store ); + } + +//---------------------------------------------------------------------------- +void CCreatorFiles::GenerateFileNameL( TFileName& aRootName ) + { + LOGSTRING("Creator: CCreatorFiles::GenerateFileNameL"); + if ( iFileId ) + { + TBuf<16> extension; + if ( iFileId < 10 ) + { + extension.Format( _L("(0%d)"), iFileId ); + } + else + { + extension.Format( _L("(%d)"), iFileId ); + } + aRootName.Insert( aRootName.Locate( '.' ), extension ); + } + iFileId++; + } + +// End of file