// ---------------------------------------------------------
// CBrCtlSampleAppLinkResolver::RecognizeL
// ---------------------------------------------------------
//
HBufC*
CBrCtlSampleAppLinkResolver::RecognizeLC(const TDesC& aFileName, const TDesC8& aData)
{
TDataRecognitionResult dataType;
RApaLsSession apaSession;
TInt ret;
HBufC* contentTypeString = NULL;
User::LeaveIfError(apaSession.Connect());
// Ask the application architecture to find the file type
ret = apaSession.RecognizeData(aFileName, aData, dataType);
apaSession.Close();
if (ret == KErrNone &&
(dataType.iConfidence == CApaDataRecognizerType::ECertain) ||
(dataType.iConfidence == CApaDataRecognizerType::EProbable))
{
// If the file type was found, try to match it to a known file type
TPtrC8 mimeTypePtr = dataType.iDataType.Des8();
TInt len = mimeTypePtr.Length() + 1;
contentTypeString = HBufC::NewL(len);
contentTypeString->Des().Copy(mimeTypePtr);
contentTypeString->Des().ZeroTerminate();
}
CleanupStack::PushL(contentTypeString);
return contentTypeString;
}
HBufC*
CContentWindowContainer::RecognizeLC(
const TDesC& aFileName, const TDesC8& aData)
{
TDataRecognitionResult dataType;
RApaLsSession apaSession;
TInt ret;
HBufC* contentTypeString = NULL;
User::LeaveIfError(apaSession.Connect());
ret = apaSession.RecognizeData(aFileName, aData, dataType);
apaSession.Close();
if (ret == KErrNone &&
(dataType.iConfidence == CApaDataRecognizerType::ECertain) ||
(dataType.iConfidence == CApaDataRecognizerType::EProbable)) {
TPtrC8 mimeTypePtr = dataType.iDataType.Des8();
TInt len = mimeTypePtr.Length() + 1;
contentTypeString = HBufC::NewL(len);
contentTypeString->Des().Copy(mimeTypePtr);
contentTypeString->Des().ZeroTerminate();
}
CleanupStack::PushL(contentTypeString);
return contentTypeString;
}
void CBtMsgViewerUtils::StoreMessageMimeTypeL(TPtr aMsgPath)
{
RFs rfs;
RFile file;
User::LeaveIfError(rfs.Connect());
User::LeaveIfError(rfs.ShareProtected());
User::LeaveIfError(file.Open(rfs, aMsgPath, EFileShareReadersOrWriters | EFileRead));
TDataRecognitionResult dataType;
RApaLsSession apaSession;
if(apaSession.Connect() == KErrNone)
{
if (apaSession.RecognizeData(file, dataType) == KErrNone)
{
if(iMimeType)
{
delete iMimeType;
iMimeType = NULL;
}
iMimeType = dataType.iDataType.Des8().AllocL();
rfs.Close();
apaSession.Close();
}
}
rfs.Close();
}
// -----------------------------------------------------------------------------
// CDownloadUtils::FindContentTypeFromFileL
// -----------------------------------------------------------------------------
//
void CDownloadUtils::FindContentTypeFromFileL( RHttpDownload& aDownload, TUint8*& aContentTypeString)
{
TDataRecognitionResult dataType;
RApaLsSession apaSession;
TInt ret;
User::LeaveIfError(apaSession.Connect());
// Create a buffer to hold data from the file
TInt bufferSize = 0;
TInt seekPosition = 0;
apaSession.GetMaxDataBufSize(bufferSize);
HBufC8* buffer = HBufC8::NewLC(bufferSize);
TPtr8 buf = buffer->Des();
RFile file;
HBufC* fileName = HBufC::NewLC( KMaxPath );
TPtr fileNamePtr = fileName->Des();
User::LeaveIfError
( aDownload.GetStringAttribute( EDlAttrDestFilename, fileNamePtr ) );
RFs fs;
User::LeaveIfError( fs.Connect() );
CleanupClosePushL( fs );
User::LeaveIfError( file.Open( fs, fileNamePtr,
EFileShareAny |
EFileRead ) );
// Find current file pointer position
file.Seek(ESeekStart, seekPosition);
// Read from file
file.Read(buf);
// return file pointer to original position
file.Seek(ESeekStart, seekPosition);
// Ask the application architecture to find the file type
ret = apaSession.RecognizeData(fileNamePtr, buf, dataType);
apaSession.Close();
CleanupStack::PopAndDestroy(3); //fs, fileName, buffer
if (ret == KErrNone &&
(dataType.iConfidence == CApaDataRecognizerType::ECertain) ||
(dataType.iConfidence == CApaDataRecognizerType::EProbable))
{
// If the file type was found, try to match it to a known file type
TPtrC8 mimeTypePtr = dataType.iDataType.Des8();
TInt len = mimeTypePtr.Length() + 1;
aContentTypeString = new(ELeave) TUint8 [len];
TPtr8 contentTypeStringPtr(aContentTypeString, len);
contentTypeStringPtr.Copy(mimeTypePtr);
contentTypeStringPtr.ZeroTerminate();
return;
}
}
bool QMessageContentContainerPrivate::createAttachment(const QString& attachmentPath)
{
//set the attachment data
if (!QFile::exists(attachmentPath)) {
return false;
}
QFile attachmentFile(attachmentPath);
if (!attachmentFile.open(QIODevice::ReadOnly)) {
return false;
}
_content = attachmentFile.readAll();
_available = true;
_size = attachmentFile.size();
attachmentFile.close();
QFileInfo fi(attachmentPath);
_name = fi.fileName().toLatin1();
//set the mime-type
QByteArray mimeType;
QString type;
TBuf8<255> fileBuffer;
RApaLsSession session;
QString fileString = fi.fileName();
TPtrC16 filePtr(reinterpret_cast<const TUint16*>(fileString.utf16()));
TBuf8<20> fileType;
TPtrC8 ptr8((TUint8 *)(_content.constData()), _content.length());
if(session.Connect() == KErrNone){
TDataRecognitionResult fileDataType;
session.RecognizeData(filePtr, ptr8, fileDataType);
fileType.Copy(fileDataType.iDataType.Des8());
mimeType = QByteArray((const char*)fileType.Ptr(), fileType.Length());
session.Close();
}
QString extension(fi.suffix());
int index = mimeType.indexOf("/");
if (index != -1) {
_type = mimeType.left(index).trimmed();
_subType = mimeType.mid(index + 1).trimmed();
}
// set the whole filepath to _filename
_filename = fi.filePath().toLatin1();
return true;
}
// <qmail>
// -----------------------------------------------------------------------------
// CFSMailMessage::AddNewAttachmentL
// -----------------------------------------------------------------------------
EXPORT_C TInt CFSMailMessage::AddNewAttachmentL( const TDesC& aFilePath,
MFSMailRequestObserver& aOperationObserver)
{
NM_FUNCTION;
TFSPendingRequest request;
if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
// init asynchronous request
request = iRequestHandler->InitAsyncRequestL( GetMessageId().PluginId(),
aOperationObserver );
MFSMailRequestObserver* observer = request.iObserver;
// use recognizer to find out ContentType
RApaLsSession apaSession;
TDataRecognitionResult dataType;
TBufC8<KMaxDataTypeLength> buf;
User::LeaveIfError(apaSession.Connect());
User::LeaveIfError(apaSession.RecognizeData(aFilePath, buf, dataType));
apaSession.Close();
// Create new message part with correct Content-Type
TBuf<KMaxDataTypeLength> contentType;
contentType.Copy(dataType.iDataType.Des());
TRAPD( err, plugin->NewChildPartFromFileL(
GetMailBoxId(),
GetFolderId(),
GetMessageId(),
GetPartId(),
contentType,
aFilePath,
*observer,
request.iRequestId) );
if( err != KErrNone )
{
iRequestHandler->CompleteRequest( request.iRequestId );
User::Leave( err );
}
}
else
{
User::Leave( KErrNotFound );
}
return request.iRequestId;
}
// -----------------------------------------------------------------------------
// CFSMailMessage::AddNewAttachmentL
// -----------------------------------------------------------------------------
EXPORT_C CFSMailMessagePart* CFSMailMessage::AddNewAttachmentL( RFile& aFile,
const TDesC8& aMimeType )
{
NM_FUNCTION;
CFSMailMessagePart* newPart(NULL);
if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
TBuf<KMaxDataTypeLength> contentType;
if(aMimeType.Length() > 0)
{
// use user given content type
contentType.Copy(aMimeType);
}
else
{
// try to find out content type using recognizers
RApaLsSession apaSession;
TDataRecognitionResult dataType;
User::LeaveIfError(apaSession.Connect());
User::LeaveIfError(apaSession.RecognizeData(aFile, dataType));
apaSession.Close();
contentType.Copy(dataType.iDataType.Des());
}
// get file name
TFileName fileName;
aFile.FullName( fileName );
// get new part from plugin
newPart = plugin->NewChildPartFromFileL( GetMailBoxId(),
GetFolderId(),
GetMessageId(),
GetPartId(),
contentType,
aFile );
if (newPart)
{
CleanupStack::PushL(newPart);
// set attachment name
newPart->SetAttachmentNameL(fileName);
// store new message part
newPart->SaveL();
// set flag
SetFlag(EFSMsgFlag_Attachments);
CleanupStack::Pop(newPart);
}
}
return newPart;
}
HBufC8 *Cdmatest::LoadFileLC( const TDesC &aFileName, TDataType &aType )
{
RFs fs ;
LEAVE_IF_ERROR( fs.Connect(), _L( "Could not connect fileserver: %d" ) );
CleanupClosePushL( fs );
RFile file ;
LEAVE_IF_ERROR( file.Open(fs,aFileName,EFileRead), _L( "Could not open file: %d" ) );
CleanupClosePushL( file );
TInt dataSize ;
LEAVE_IF_ERROR( file.Size( dataSize ), _L( "Could not get file size: %d" ) );
HBufC8 *nodedata = HBufC8::NewL ( dataSize );
CleanupStack::PushL( nodedata );
TPtr8 nodedataptr( nodedata->Des() );
LEAVE_IF_ERROR( file.Read( nodedataptr ), _L( "Could not read file: %d" ) );
TDataRecognitionResult aDataType;
RApaLsSession ls ;
TInt err( ls.Connect() );
if ( err == KErrNone )
{
CleanupClosePushL( ls );
err = ls.RecognizeData(aFileName, nodedataptr, aDataType) ;
if ( err == KErrNone )
{
aType = aDataType.iDataType;
}
else
{
iLog->Log( _L("LoadFileLC: WARNING Failed to get type: %d" ), err );
aType = TDataType( KDefaultType );
}
CleanupStack::PopAndDestroy( &ls );
}
else
{
iLog->Log( _L("LoadFileLC: WARNING Failed to connect rapalssession: %d" ), err );
}
CleanupStack::Pop( nodedata );
CleanupStack::PopAndDestroy( &file );
CleanupStack::PopAndDestroy( &fs );
CleanupStack::PushL( nodedata );
return nodedata ;
}
// -----------------------------------------------------------------------------
// CFSMailMessage::AddNewAttachmentL
// -----------------------------------------------------------------------------
EXPORT_C CFSMailMessagePart* CFSMailMessage::AddNewAttachmentL( const TDesC& aFilePath,
const TFSMailMsgId /*aInsertBefore*/ )
{
NM_FUNCTION;
CFSMailMessagePart* newPart(NULL);
if(CFSMailPlugin* plugin = iRequestHandler->GetPluginByUid(GetMessageId()))
{
// use recognizer to find out ContentType
RApaLsSession apaSession;
TDataRecognitionResult dataType;
TBufC8<KMaxDataTypeLength> buf;
User::LeaveIfError(apaSession.Connect());
User::LeaveIfError(apaSession.RecognizeData(aFilePath, buf, dataType));
apaSession.Close();
// Create new message part with correct Content-Type
TBuf<KMaxDataTypeLength> contentType;
contentType.Copy(dataType.iDataType.Des());
newPart = plugin->NewChildPartFromFileL( GetMailBoxId(),
GetFolderId(),
GetMessageId(),
GetPartId(),
contentType,
aFilePath );
if (newPart)
{
CleanupStack::PushL(newPart);
// set attachment name
newPart->SetAttachmentNameL(aFilePath);
// store new message part
newPart->SaveL();
// set flag
SetFlag(EFSMsgFlag_Attachments);
CleanupStack::Pop(newPart);
}
}
return newPart;
}
void CImageReader::GetFileType(const TDesC& aFileName, TDes8& aFileType)
{
TEntry FileEntry;
if(CCoeEnv::Static()->FsSession().Entry(aFileName,FileEntry) == KErrNone)
{
TBuf8<255> FileBuffer;
if(!FileEntry.IsDir())
{
TInt FileSize = FileEntry.iSize;
if(FileSize > 255)
{
FileSize = 255;
}
if(CCoeEnv::Static()->FsSession().ReadFileSection(aFileName,0,FileBuffer,FileSize) == KErrNone)
{
RApaLsSession RSession;
if(RSession.Connect() == KErrNone)
{
TDataRecognitionResult FileDataType;
RSession.RecognizeData(aFileName,FileBuffer,*&FileDataType);
// if(FileDataType.iConfidence > aResult.iConfidence)
// {
aFileType.Copy(FileDataType.iDataType.Des8());
// }
RSession.Close();
}
}
}
}
}
// ---------------------------------------------------------------------------
// To get the mime type of the file
//
// ---------------------------------------------------------------------------
//
QString MsgViewUtils::mimeTypeL(QString aFileName)
{
RFs rfs;
RFile file;
HBufC* fileName = XQConversions::qStringToS60Desc(aFileName);
//TODO: The RFs and RApaLsSession has to be connected 1's, not for every mms
if(rfs.Connect() != KErrNone)
return QString();
if(rfs.ShareProtected() != KErrNone )
return QString();
if(file.Open(rfs, *fileName, EFileShareReadersOrWriters | EFileRead) != KErrNone )
return QString();
TDataRecognitionResult dataType;
RApaLsSession apaSession;
if(apaSession.Connect() == KErrNone)
{
if (apaSession.RecognizeData(file, dataType) == KErrNone)
{
TPtrC8 fileType = dataType.iDataType.Des8();
rfs.Close();
apaSession.Close();
return XQConversions::s60Desc8ToQString(fileType);
}
}
rfs.Close();
return QString();
}
EXPORT_C TVerdict CRecognizeStep::doTestStepL()
{
__UHEAP_MARK;
SetTestStepResult(EFail);
HBufC* fileNameBuf = HBufC::NewMaxLC(KMaxFileName);
TPtrC fileNamePtr(fileNameBuf->Des());
TBool found = GetStringFromConfig(ConfigSection(), KFileNameKey, fileNamePtr);
if (!found)
{
ERR_PRINTF1(_L("Missing file name key in .ini file!"));
SetTestStepResult(EInconclusive);
return TestStepResult();
}
TFileName fileName(KTestDataDir);
fileName.Append(fileNamePtr);
RFs fileSession;
CleanupClosePushL(fileSession);
TInt err = fileSession.Connect();
if (err != KErrNone)
{
ERR_PRINTF1(_L("Failed to open a file session"));
SetTestStepResult(EInconclusive);
return TestStepResult();
}
CFileSisDataProvider* dataProvider = CFileSisDataProvider::NewLC(fileSession, fileName);
TInt connectErr = KErrNotFound;
#ifndef SWI_TEXTSHELL_ROM
//CApaSisxRecognizer* rec= new (ELeave) CApaSisxRecognizer;
//CleanupStack::PushL(rec);
RApaLsSession apaSession;
connectErr = apaSession.Connect();
if (connectErr != KErrNotFound)
{
User::LeaveIfError(connectErr);
CleanupClosePushL(apaSession);
TBuf8<64> buffer;
dataProvider->Read(buffer);
TDataRecognitionResult result;
//rec->RecognizeL(fileName, buffer);
User::LeaveIfError(apaSession.RecognizeData(fileName, buffer, result));
if (result.iDataType.Des8() != KDataTypeSisx())
{
ERR_PRINTF1(_L("Recognised data incorrectly"));
SetTestStepResult(EFail);
}
else
{
TInt confidence = result.iConfidence;
if ((confidence == CApaDataRecognizerType::EProbable) || (confidence == CApaDataRecognizerType::ECertain))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(KErrCorrupt);
}
}
CleanupStack::PopAndDestroy(&apaSession);
}
#endif
if (connectErr == KErrNotFound)
{
// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)
TRAPD(error, RecognizeSisxL(fileName));
if (error != KErrNone)
{
ERR_PRINTF1(_L("Recognised data incorrectly"));
SetTestStepResult(EFail);
}
else
{
SetTestStepResult(EPass);
}
}
//CleanupStack::PopAndDestroy(rec);
CleanupStack::PopAndDestroy(dataProvider);
CleanupStack::PopAndDestroy(&fileSession);
CleanupStack::PopAndDestroy(fileNameBuf);
__UHEAP_MARKEND;
return TestStepResult();
}
