--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmfenh/advancedaudiocontroller/tsrc/advancedaudiocontrollertestmodule/AudioRecorderTestModule/src/RecordOpen.cpp Tue Feb 02 01:08:46 2010 +0200
@@ -0,0 +1,653 @@
+/*
+* Copyright (c) 2007 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: AudioRecorder Test
+*
+*/
+
+
+#include "RecordOpen.h"
+#include <e32des8.h>
+
+const TInt KOpenFile = 1; //File
+const TInt KOpenFile2 = 2; //File with controller
+const TInt KOpenRFile = 3; //RFile
+const TInt KOpenRFile2 = 4; //RFile with controller
+const TInt KOpenSFile = 5; //SourceFile
+const TInt KOpenSFile2 = 6; //SourceFile with controller
+const TInt KOpenDescriptor = 7; //Desc
+const TInt KOpenDescriptor2 = 8; //Desc with const
+const TInt KOpenDescriptor3 = 9; //Desc with controller
+const TInt KOpenURL = 10; //URL
+const TInt KOpenURL2 = 11; //URL with controller
+const TInt KOpenLocation = 12; //Open Location
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+CRecordOpen::CRecordOpen(CTestModuleIf *aConsole, CStifLogger *aLogger)
+{
+ console = aConsole;
+ logger = aLogger;
+ callbackErr = KErrNone;
+}
+
+CRecordOpen::~CRecordOpen()
+{
+
+}
+
+CRecordOpen* CRecordOpen::NewL(CTestModuleIf *aConsole, CStifLogger *aLogger)
+{
+ CRecordOpen* self = new (ELeave) CRecordOpen(aConsole, aLogger);
+ CleanupStack::PushL(self);
+
+ self->ConstructL();
+
+ CleanupStack::Pop(self);
+ return self;
+}
+
+TInt CRecordOpen::RunTestL(CTestModuleIf *aConsole, CStifLogger *aLogger, CStifSectionParser *aParser, TInt* /*clipCounter*/)
+{
+ //Creating scheduler
+ aLogger->Log(_L("Creating scheduler"));
+
+ CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
+ CleanupStack::PushL(scheduler); // push to clean-up stack
+ CActiveScheduler::Install(scheduler); // install as active scheduler
+
+ //Creating CRecordOpen
+ aLogger->Log(_L("Creating CRecordOpen"));
+
+ CRecordOpen* selfObj = CRecordOpen::NewL(aConsole, aLogger);
+ CleanupStack::PushL(selfObj);
+
+ //Creating recorder
+ aLogger->Log(_L("Creating CMdaAudioRecorderUtility"));
+
+ CMdaAudioRecorderUtility* recorder = CMdaAudioRecorderUtility::NewL(*selfObj);
+ CleanupStack::PushL(recorder);
+
+ TInt error = KErrNone;
+ TPtrC fileName;
+ TTimeIntervalMicroSeconds duration = TInt64(0);
+ TTimeIntervalMicroSeconds errRange = TInt64(KDefaultErrorRange);
+
+ TBuf<5> nextItem;
+ TInt itemCounter = 0;
+ nextItem.Format(_L("%d"),++itemCounter);
+ TInt opType;
+
+ //Get error range
+ CStifItemParser* item = aParser->GetItemLineL(KErrorRange, ENoTag);
+
+ CleanupStack::PushL(item);
+ errRange = CRecordOpen::ParseTime(item);
+ CleanupStack::PopAndDestroy();
+
+ LogTime(_L("Error range:"),errRange.Int64(),aLogger);
+
+ item = aParser->GetItemLineL(nextItem, ENoTag);
+
+ if (!item)
+ {
+ aLogger->Log(_L("No file provided"));
+ CleanupStack::PopAndDestroy(3);
+ return KErrSyntax;
+ }
+
+ //Cicle to get files and open them
+ bool loop = true;
+ while (loop == true)
+ {
+ CleanupStack::PushL(item);
+
+ //Get file name
+ if (CRecordOpen::ParseTag(item, opType, fileName, duration) != KErrNone)
+ {
+ aLogger->Log(_L("Invalid tag"));
+ CleanupStack::PopAndDestroy(4);
+ return KErrSyntax;
+ }
+
+ switch (opType)
+ {
+ case KOpenFile: aLogger->Log(_L("Opening file: %S"),&fileName); break;
+ case KOpenFile2: aLogger->Log(_L("Opening file with controller: %S"),&fileName); break;
+ case KOpenRFile: aLogger->Log(_L("Opening Rfile: %S"),&fileName); break;
+ case KOpenRFile2: aLogger->Log(_L("Opening Rfile with controller: %S"),&fileName); break;
+ case KOpenSFile: aLogger->Log(_L("Opening source file: %S"),&fileName); break;
+ case KOpenSFile2: aLogger->Log(_L("Opening source file with controller: %S"),&fileName); break;
+ case KOpenDescriptor: aLogger->Log(_L("Opening descriptor: %S"),&fileName); break;
+ case KOpenDescriptor2: aLogger->Log(_L("Opening const descriptor: %S"),&fileName); break;
+ case KOpenDescriptor3: aLogger->Log(_L("Opening descriptor with controller: %S"),&fileName); break;
+ case KOpenURL: aLogger->Log(_L("Opening URL: %S"),&fileName); break;
+ case KOpenURL2: aLogger->Log(_L("Opening URL with controller: %S"),&fileName); break;
+ }
+
+ if (duration.Int64() == 0)
+ {
+ aLogger->Log(_L("Invalid file duration"));
+ CleanupStack::PopAndDestroy(4);
+ return KErrFileDuration;
+ }
+
+ //Create descriptor
+ HBufC8* desc = NULL;
+ if (opType == KOpenDescriptor)
+ {
+ TRAPD(err,desc = CRecordOpen::GetDescriptor8LC(fileName, aLogger));
+ if (err != KErrNone || desc == NULL)
+ {
+ aLogger->Log(_L("Error %d creating descriptor for: %S"),err,&fileName);
+ CleanupStack::PopAndDestroy(4);
+ return KErrRecOpenFile;
+ }
+ CleanupStack::PushL(desc);
+ }
+
+ //Parse URL params
+ TInt iapId = KUseDefaultIap;
+ TDesC8 nullMimeType = KNullDesC8;
+ TDesC8* mimeType = &nullMimeType;
+ if (opType == KOpenURL)
+ {
+ TPtrC mime;
+ if (aParser->GetNextLine(KMimeType,mime,ENoTag) == KErrNone)
+ {
+ HBufC8* buf = HBufC8::NewL(mime.Length()+1);
+ CleanupStack::PushL(buf);
+ mimeType = buf;
+ TPtr8 ptr(buf->Des());
+ ptr.Append(mime);
+ ptr.Append('\0');
+ aLogger->Log(_L8("Provided Mime type: %S"),mimeType);
+ }
+ else
+ aLogger->Log(_L8("Default Mime type: %S"),mimeType);
+
+ CStifItemParser* item2;
+ if ((item2 = aParser->GetNextItemLineL(KIAPID, ETag)) != NULL)
+ {
+ item2->GetInt(KIAPID,iapId);
+ aLogger->Log(_L("Provided Internet Access Point ID: %d"),iapId);
+ }
+ else
+ aLogger->Log(_L("Default Internet Access Point ID: %d"),iapId);
+ }
+
+
+
+ //Call open function
+ TRAPD(err2,OpenTarget(recorder,fileName,opType,desc,iapId,*mimeType,aLogger));
+ if (err2 != KErrNone)
+ {
+ aLogger->Log(_L("Error %d opening: %S"),err2,&fileName);
+ if (desc == NULL || *mimeType != KNullDesC8)
+ CleanupStack::PopAndDestroy(4);
+ else
+ CleanupStack::PopAndDestroy(5);
+ if (err2 == KErrNotSupported)
+ {
+ return KErrNone;
+ }
+ else
+ {
+ return KErrRecOpenFile;
+ }
+ }
+ aLogger->Log(_L("Open OK!!! "));
+ CActiveScheduler::Start();
+
+ aLogger->Log(_L("Opened: %S with error %d"),&fileName,selfObj->callbackErr);
+ if (selfObj->callbackErr == KErrNotSupported || selfObj->callbackErr == KErrNotFound)
+ {
+ error = KErrNone;
+ }
+ else
+ {
+ error = error || selfObj->callbackErr;
+ }
+
+ recorder->Close();
+ if (desc != NULL)
+ {
+ aLogger->Log(_L("Clean descriptor buffer "));
+ CleanupStack::PopAndDestroy();
+ }
+ if (*mimeType != KNullDesC8) CleanupStack::PopAndDestroy();
+ CleanupStack::PopAndDestroy(); // item
+
+ //Obtain next file name
+ nextItem.Format(_L("%d"),++itemCounter);
+ if ((item = aParser->GetItemLineL(nextItem, ENoTag)) == NULL)
+ break;
+ }
+
+ CleanupStack::PopAndDestroy(); // selfObj
+ CleanupStack::PopAndDestroy(); // recorder
+ CleanupStack::PopAndDestroy(); // scheduler
+
+// aLogger->Log(_L("CRecordOpen finished"));
+
+ return error;
+}
+
+void CRecordOpen::OpenTarget(CMdaAudioRecorderUtility* rec, TPtrC fileName, TInt type, HBufC8* desc, TInt iapid, TDesC8& mime, CStifLogger* aLogger)
+{
+ aLogger->Log(_L("openTarget with type %d"),type);
+
+ //File
+ if (type == KOpenFile)
+ {
+ rec->OpenFileL(fileName);
+ return;
+ }
+
+ //File with controller
+ if (type == KOpenFile2)
+ {
+ TInt aUid = 1;
+ //TUid aRecordControllerUid = TUid::Uid(aUid);
+ TUid aRecordControllerUid = KNullUid;//KUidInterfaceMMFController;//TUid::Uid(KMmfUidPluginInterfaceFormatDecode);//KMmfUidPluginInterfaceController;//{0x10203827};
+ //const TUid KUidBassBoostEffect = {0x10203827};
+
+ TUid aPlaybackControllerUid = KNullUid;
+ TUid aFormatUid = KNullUid;
+ TFourCC aCodec = NULL;
+ rec->OpenFileL(fileName, aRecordControllerUid, aPlaybackControllerUid, aFormatUid, aCodec);
+ return;
+ }
+ //RFile
+ if (type == KOpenRFile)
+ {
+ RFs aFs;
+ RFile aFileHandler;
+ User::LeaveIfError(aFs.Connect());
+
+ User::LeaveIfError(aFileHandler.Open( aFs, fileName, EFileRead));
+ rec->OpenFileL(aFileHandler);
+
+ aFileHandler.Close();
+ aFs.Close();
+
+ return;
+ }
+
+
+ //RFile with controller
+ if (type == KOpenRFile2)
+ {
+ TUid aRecordControllerUid = KNullUid;
+ TUid aPlaybackControllerUid = KNullUid;
+ TUid aFormatUid = KNullUid;
+ TFourCC aCodec = NULL;
+
+ RFs aFs;
+ RFile aFileHandler;
+ User::LeaveIfError(aFs.Connect());
+
+ User::LeaveIfError(aFileHandler.Open( aFs, fileName, EFileRead));
+ rec->OpenFileL(aFileHandler, aRecordControllerUid, aPlaybackControllerUid, aFormatUid, aCodec);
+
+ aFileHandler.Close();
+ aFs.Close();
+
+ return;
+ }
+
+ //SourceFile
+ if (type == KOpenSFile)
+ {
+
+
+ RFs aFs;
+ RFile aFileHandler;
+ User::LeaveIfError(aFs.Connect());
+
+ User::LeaveIfError(aFileHandler.Open( aFs, fileName, EFileRead));
+
+ //TMMSource aSourceFile;
+ TMMFileHandleSource filesource(aFileHandler, ContentAccess::KDefaultContentObject, ContentAccess::EPlay);
+ rec->OpenFileL(filesource);
+ aFileHandler.Close();
+ aFs.Close();
+ return;
+ }
+
+ //SourceFile with controller
+ if (type == KOpenSFile2)
+ {
+ TUid aRecordControllerUid = KNullUid;
+ TUid aPlaybackControllerUid = KNullUid;
+ TUid aFormatUid = KNullUid;
+ TFourCC aCodec = NULL;
+
+ RFs aFs;
+ RFile aFileHandler;
+ User::LeaveIfError(aFs.Connect());
+ User::LeaveIfError(aFileHandler.Open( aFs, fileName, EFileRead));
+
+ //TMMSource aSourceFile;
+ TMMFileHandleSource filesource(aFileHandler, ContentAccess::KDefaultContentObject, ContentAccess::EPlay);
+
+
+
+ rec->OpenFileL(filesource,aRecordControllerUid, aPlaybackControllerUid, aFormatUid, aCodec);
+ aFileHandler.Close();
+ aFs.Close();
+ return;
+ }
+
+ //Desc
+ if (type == KOpenDescriptor)
+ {
+
+ TPtrC fileNamePtr;
+ RFile file;
+ RFs fileServer;
+ HBufC8* buffer = NULL;
+ User::LeaveIfError(fileServer.Connect());
+ TInt err = file.Open(fileServer, fileName, EFileShareReadersOnly);
+ if (err != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ User::Leave(err);
+ }
+
+ TInt size;
+
+
+ if ((err = file.Size(size)) == KErrNone)
+ {
+ TRAP(err, buffer = HBufC8::NewL(size));
+ if (err != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ User::Leave(err);
+ }
+
+ TPtr8 bufferpointer = buffer->Des();
+ if ((err = file.Read(bufferpointer)) != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ delete buffer;
+ User::Leave(err);
+ }
+ rec->OpenDesL (bufferpointer);
+ }
+
+
+ file.Close();
+ fileServer.Close();
+// rec->OpenDesL (*desc);
+ return;
+ }
+
+ //Desc with const
+ if (type == KOpenDescriptor2)
+ {
+ aLogger->Log(_L("KOpenDescriptor2 Desc with const "));
+
+ TPtrC fileNamePtr;
+ RFile file;
+ RFs fileServer;
+ HBufC8* buffer = NULL;
+ User::LeaveIfError(fileServer.Connect());
+ TInt err = file.Open(fileServer, fileName, EFileShareReadersOnly);
+ if (err != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ User::Leave(err);
+ }
+
+ TInt size;
+
+ if ((err = file.Size(size)) == KErrNone)
+ {
+ TRAP(err, buffer = HBufC8::NewL(size));
+ if (err != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ User::Leave(err);
+ }
+
+ TPtr8 bufferpointer = buffer->Des();
+ if ((err = file.Read(bufferpointer)) != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ delete buffer;
+ User::Leave(err);
+ }
+
+ }
+
+ rec->OpenDesL (*buffer);
+ file.Close();
+ fileServer.Close();
+ return;
+ }
+
+ //Desc with controller
+ if (type == KOpenDescriptor3)
+ {
+ aLogger->Log(_L("KOpenDescriptor3 Desc with controller "));
+ TUid aRecordControllerUid = KUidInterfaceMMFController;
+ TUid aPlaybackControllerUid = KNullUid;
+ TUid aFormatUid = KNullUid;
+ TFourCC aCodec = NULL;
+
+ TPtrC fileNamePtr;
+ RFile file;
+ RFs fileServer;
+ HBufC8* buffer = NULL;
+ User::LeaveIfError(fileServer.Connect());
+ TInt err = file.Open(fileServer, fileName, EFileShareReadersOnly);
+ if (err != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ User::Leave(err);
+ }
+
+ TInt size;
+
+ if ((err = file.Size(size)) == KErrNone)
+ {
+ TRAP(err, buffer = HBufC8::NewL(size));
+ if (err != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ User::Leave(err);
+ }
+
+ TPtr8 bufferpointer = buffer->Des();
+ if ((err = file.Read(bufferpointer)) != KErrNone)
+ {
+
+ file.Close();
+ fileServer.Close();
+ delete buffer;
+ User::Leave(err);
+ }
+ rec->OpenDesL(bufferpointer,aRecordControllerUid,aPlaybackControllerUid,aFormatUid, aCodec);
+ file.Close();
+ fileServer.Close();
+ }
+
+ return;
+ }
+
+ //URL
+ if (type == KOpenURL)
+ {
+ rec->OpenUrlL(fileName,iapid,mime);
+ return;
+ }
+
+ //URL with controller
+ if (type == KOpenURL2)
+ {
+ TUid aRecordControllerUid = KNullUid;
+ TUid aPlaybackControllerUid = KNullUid;
+ TUid aFormatUid = KNullUid;
+ TFourCC aCodec = NULL;
+
+ rec->OpenUrlL(fileName,iapid,aRecordControllerUid,aPlaybackControllerUid,aFormatUid, aCodec);
+ return;
+ }
+
+ if (type == KOpenLocation)
+ {
+
+ TMdaClipFormat dummyFormat;
+ TMdaPackage* codc = NULL;
+ TMdaPackage* codc1 = NULL;
+
+ TMdaFileClipLocation* fileSrc= new TMdaFileClipLocation( fileName );
+ rec->OpenL( fileSrc, &dummyFormat, codc, codc1 );
+ return;
+ }
+
+ User::Leave(KErrSyntax);
+}
+
+TInt CRecordOpen::ParseTag(CStifItemParser* item, TInt & type, TPtrC& name, TTimeIntervalMicroSeconds& duration)
+{
+ TInt sec=0, mil=0, mic=0;
+
+ type = 0;
+ if (item->GetString(KFileName,name) == KErrNone)
+ type = KOpenFile;
+ else if (item->GetString(KFileName2,name) == KErrNone)
+ type = KOpenFile2;
+ else if (item->GetString(KRFileName,name) == KErrNone)
+ type = KOpenRFile;
+ else if (item->GetString(KRFileName2,name) == KErrNone)
+ type = KOpenRFile2;
+ else if (item->GetString(KSFileName,name) == KErrNone)
+ type = KOpenSFile;
+ else if (item->GetString(KSFileName2,name) == KErrNone)
+ type = KOpenSFile2;
+ else if (item->GetString(KDescriptor,name) == KErrNone)
+ type = KOpenDescriptor;
+ else if (item->GetString(KDescriptor2,name) == KErrNone)
+ type = KOpenDescriptor2;
+ else if (item->GetString(KDescriptor3,name) == KErrNone)
+ type = KOpenDescriptor3;
+ else if (item->GetString(KURL,name) == KErrNone)
+ type = KOpenURL;
+ else if (item->GetString(KURL2,name) == KErrNone)
+ type = KOpenURL2;
+ else if (item->GetString(KLocation,name) == KErrNone)
+ type = KOpenLocation;
+
+ if (type == 0) return KErrSyntax;
+
+ item->GetInt(name,sec);
+ item->GetNextInt(mil);
+ item->GetNextInt(mic);
+
+ duration = TInt64(sec*1000000 + mil*1000 + mic);
+
+ return KErrNone;
+}
+
+TDesC8* CRecordOpen::ConvertTDesC(TDesC16& string)
+{
+ HBufC8* buf = HBufC8::NewL(string.Length()+1);
+ TPtr8 ptr(buf->Des());
+ ptr.Copy(string);
+ return buf;
+}
+
+void CRecordOpen::ConstructL()
+{
+
+}
+
+void CRecordOpen::MoscoStateChangeEvent(CBase* /*aObject*/, TInt /*aPreviousState*/, TInt aCurrentState, TInt aErrorCode)
+{
+ logger->Log(_L("MoscoStateChangeEvent called"));
+
+ if(aErrorCode == KErrNone && aCurrentState == CMdaAudioClipUtility::EOpen)
+ {
+
+
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ callbackErr = aErrorCode;
+ CActiveScheduler::Stop();
+ }
+}
+
+HBufC8 *CRecordOpen::GetDescriptor8LC(const TFileName &aFileName, CStifLogger *iLogger)
+{
+ TInt FileError, SoundSize=0;
+ RFile file;
+ RFs FsSession;
+ HBufC8 *SoundFile;
+
+ iLogger->Log(_L("Connecting to File Server Session") );
+ FileError = FsSession.Connect();
+ if (FileError)
+ {
+ iLogger->Log(_L("File error (%d)") , FileError);
+ User::LeaveIfError(FileError);
+ }
+
+ iLogger->Log(_L("Opening file to get size") );
+ FileError = file.Open(FsSession, aFileName, EFileStream);
+ if (FileError)
+ {
+ iLogger->Log(_L("File error (%d)") , FileError);
+ User::LeaveIfError(FileError);
+ }
+ FileError = file.Size(SoundSize);
+ iLogger->Log(_L("File Size (%d)") , SoundSize);
+ if (FileError)
+ {
+ iLogger->Log(_L("Error getting size") );
+ User::LeaveIfError(FileError);
+ }
+
+ SoundFile = HBufC8::NewL(SoundSize);
+ TPtr8 helper = SoundFile->Des();
+ FileError = file.Read( helper );
+
+ iLogger->Log(_L("Descriptor length [%d]") , SoundFile->Size() );
+ file.Close();
+ FsSession.Close();
+ return SoundFile;
+}
+
+