sl@0: // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // Defines CApaDataRecognizerType the base class for concrete mime recognizers that
sl@0: // perform the actual mime type recognitionand the CApaDataRecognizer that provides
sl@0: // the interface to the collection of recognizers.
sl@0: // 
sl@0: //
sl@0: 
sl@0: 
sl@0: #include "APMSTD.H"
sl@0: #include "APMREC.H"
sl@0: #include "APMPAN.H"
sl@0: #include "APMFNDR.H"
sl@0: 
sl@0: #ifdef USING_ECOM_RECOGS
sl@0: #include <ecom/ecom.h>
sl@0: #endif
sl@0: 
sl@0: NONSHARABLE_CLASS(CDataRecognizerExtension) : public CBase
sl@0: 	{
sl@0: public:
sl@0: 	inline static CDataRecognizerExtension* NewL() {return new(ELeave) CDataRecognizerExtension;}
sl@0: 	inline TUid DestructorUid() const {return iDtorKey;}
sl@0: 	inline TUid& DestructorUidReference() {return iDtorKey;}
sl@0: 	inline CApaDataRecognizer& DataRecognizer() {return *iDataRecognizer;}
sl@0: 	inline void SetDataRecognizer(CApaDataRecognizer& aDataRecognizer) {iDataRecognizer=&aDataRecognizer;}
sl@0: private:
sl@0: 	inline CDataRecognizerExtension() {}
sl@0: private:
sl@0: 	CApaDataRecognizer* iDataRecognizer; // no ownership
sl@0: 	TUid iDtorKey; // destructor key to track the instance of ECOM implementation class
sl@0: 	};
sl@0: 
sl@0: class TDataToRecognize
sl@0: 	{
sl@0: public:
sl@0: 	TDataToRecognize(const TDesC& aName, const TDesC8& aBuffer);
sl@0: 	TDataToRecognize(CApaDataRecognizer& aDataRecognizer, RFile& aFile, TInt aPreferredBufSize);
sl@0: 	void RecognizeL(CApaDataRecognizerType& aDataRecognizerType);
sl@0: 	void PrepareForRecognizeLoopLC();
sl@0: 	void PopOffCleanupStackAndResetAfterRecognizeLoopL();
sl@0: private:
sl@0: 	enum
sl@0: 		{
sl@0: 		EFlagFilePositionStored	=0x00000001,
sl@0: 		EFlagLeaveIfError		=0x00000002
sl@0: 		};
sl@0: private:
sl@0: 	static void ResetAfterRecognizeLoopL(TAny* aThis);
sl@0: 	void ResetAfterRecognizeLoopL();
sl@0: private:
sl@0: 	TUint iFlags;
sl@0: 	const TDesC* iName; // owned if iFile!=NULL
sl@0: 	const TDesC8* iBuffer; // owned if iFile!=NULL
sl@0: 	CApaDataRecognizer* iDataRecognizer;
sl@0: 	RFile* iFile;
sl@0: 	TInt iFilePosition;
sl@0: 	TInt iPreferredBufSize;
sl@0: 	};
sl@0: 
sl@0: //
sl@0: // class CApaDataRecognizer
sl@0: //
sl@0: 
sl@0: EXPORT_C TDataRecognitionResult CApaDataRecognizer::RecognizeL(const TDesC& aName, const TDesC8& aBuffer)
sl@0: 	{
sl@0: 	TDataToRecognize dataToRecognize(aName, aBuffer);
sl@0: 	return RecognizeL(dataToRecognize);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TDataRecognitionResult CApaDataRecognizer::RecognizeL(RFile& aFile, TInt aPreferredBufSize)
sl@0: 	{
sl@0: 	TDataToRecognize dataToRecognize(*this, aFile, aPreferredBufSize);
sl@0: 	return RecognizeL(dataToRecognize);
sl@0: 	}
sl@0: 
sl@0: TDataRecognitionResult CApaDataRecognizer::RecognizeL(TDataToRecognize& aDataToRecognize)
sl@0: // attempt to recognize using all recognizers
sl@0: // keeps recognizing until either a recognizer's confidence meets or 
sl@0: // exceeds the currently acceptable confidence, or all recognizers 
sl@0: // have been used
sl@0: 	{
sl@0: 	iResult.Reset();
sl@0: 	aDataToRecognize.PrepareForRecognizeLoopLC();
sl@0: 	TInt storedErr=KErrNone;
sl@0: 	TInt count=iDataRecognizerList.Count();
sl@0: 	for (TInt i=0; i<count; i++)
sl@0: 		{
sl@0: 		if (DoRecognize(iDataRecognizerList[i], aDataToRecognize, TDataType(), storedErr))
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		}
sl@0: 	aDataToRecognize.PopOffCleanupStackAndResetAfterRecognizeLoopL();
sl@0: 	// if we haven't recognized anything and there was a problem with a recognizer, propagate
sl@0: 	// the error.  n.b. if several recognizers had errors, only propagate the first error we 
sl@0: 	// encountered
sl@0: 	if (iResult.iConfidence==CApaDataRecognizerType::ENotRecognized)
sl@0: 		{
sl@0: 		User::LeaveIfError(storedErr);
sl@0: 		}
sl@0: 	return iResult;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TBool CApaDataRecognizer::RecognizeL(const TDesC& aName, const TDesC8& aBuffer, const TDataType& aDataType)
sl@0: 	{
sl@0: 	TDataToRecognize dataToRecognize(aName, aBuffer);
sl@0: 	return RecognizeL(dataToRecognize, aDataType);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TBool CApaDataRecognizer::RecognizeL(RFile& aFile, TInt aPreferredBufSize, const TDataType& aDataType)
sl@0: 	{
sl@0: 	TDataToRecognize dataToRecognize(*this, aFile, aPreferredBufSize);
sl@0: 	return RecognizeL(dataToRecognize, aDataType);
sl@0: 	}
sl@0: 
sl@0: TBool CApaDataRecognizer::RecognizeL(TDataToRecognize& aDataToRecognize, const TDataType& aDataType)
sl@0: // recognize using only recognizers which supply the aDataType
sl@0: 	{
sl@0: 	iResult.Reset();
sl@0: 	TInt count=iDataRecognizerList.Count();
sl@0: 	TInt storedErr=KErrNone;
sl@0: 	aDataToRecognize.PrepareForRecognizeLoopLC();
sl@0: 	for (TInt i=0; i<count; i++)
sl@0: 		{
sl@0: 		CApaDataRecognizerType* rec=iDataRecognizerList[i];
sl@0: 		TInt countMime=rec->MimeTypesCount();
sl@0: 		for (TInt ii=0; ii<countMime; ii++)
sl@0: 			{
sl@0: 			TDataType supportedDataType;
sl@0: 			TRAPD(err, supportedDataType=rec->SupportedDataTypeL(ii));
sl@0: 			if (err == KErrNone)
sl@0: 				{
sl@0: 				if (supportedDataType == aDataType)
sl@0: 					{
sl@0: 					if (DoRecognize(rec, aDataToRecognize, aDataType, storedErr))
sl@0: 						{
sl@0: 						aDataToRecognize.PopOffCleanupStackAndResetAfterRecognizeLoopL();
sl@0: 						return ETrue;
sl@0: 						}
sl@0: 					break;
sl@0: 					}
sl@0: 				}
sl@0: 			else if (storedErr==KErrNone)
sl@0: 				{
sl@0: 				// this is the first time we've hit an error with SupportedDataType,
sl@0: 				// so store it now and propagate later if we don't find a suitable 
sl@0: 				// recognizer
sl@0: 				storedErr=err;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	aDataToRecognize.PopOffCleanupStackAndResetAfterRecognizeLoopL();
sl@0: 	if (iResult.iConfidence==CApaDataRecognizerType::ENotRecognized)
sl@0: 		{
sl@0: 		// a suitable recognizer wasn't found, but we may have encountered an
sl@0: 		// error with one of the recognizers we scanned n.b. only the first error
sl@0: 		// encountered is propagated
sl@0: 		User::LeaveIfError(storedErr);
sl@0: 		}
sl@0: 	return iResult.iConfidence!=CApaDataRecognizerType::ENotRecognized;
sl@0: 	}
sl@0: 
sl@0: TBool CApaDataRecognizer::DoRecognize(CApaDataRecognizerType* aDataRecognizerType, TDataToRecognize& aDataToRecognize, const TDataType& aDataType, TInt& aError)
sl@0: // do the recognition, if the recognizer is sufficiently confident, return ETrue
sl@0: 	{
sl@0: 	TDataRecognitionResult result;
sl@0: 	TRAPD(err, result=aDataRecognizerType->RecognizeL(aDataToRecognize));
sl@0: 	if (err != KErrNone)
sl@0: 		{
sl@0: 		// We only want to store the first error, it if is not KErrNone, it means
sl@0: 		// we have set this error previously
sl@0: 		if (aError==KErrNone)
sl@0: 			{
sl@0: 			aError=err;
sl@0: 			}
sl@0: 		return EFalse;
sl@0: 		}
sl@0:  
sl@0: 	if (aDataType!=result.iDataType && aDataType!=TDataType())
sl@0: 		{
sl@0: 		return EFalse;
sl@0: 		}
sl@0: 	if (result.iConfidence>iResult.iConfidence)
sl@0: 		{
sl@0: 		iResult=result;
sl@0: 		return (result.iConfidence>=iAcceptedConfidence);
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CApaDataRecognizer::AcceptedConfidence() const
sl@0: 	{
sl@0: 	return iAcceptedConfidence;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizer::SetAcceptedConfidence(TInt aConfidence)
sl@0: 	{
sl@0: 	iAcceptedConfidence=aConfidence;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C CApaDataRecognizer::~CApaDataRecognizer()
sl@0: 	{
sl@0: 	iDataRecognizerList.ResetAndDestroy();
sl@0: 	iDataArray.Reset();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C CApaDataRecognizer::CApaDataRecognizer(RFs& aFs)
sl@0: 	:iFs(aFs),
sl@0: 	iMaxBufferSize(-1),
sl@0: 	iDataRecognizerList(KDataArrayGranularity),
sl@0: 	iDataArray(KDataArrayGranularity),
sl@0: 	iAcceptedConfidence(CApaDataRecognizerType::ECertain)
sl@0: 	{}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizer::AddDataRecognizerTypeL(CApaDataRecognizerType* aDataRecognizerType)
sl@0: // add the concrete recognizer into the list at the appropriate priority
sl@0: 	{
sl@0: #if defined(_DEBUG)
sl@0:  	CApaDataRecognizerType* rec=NULL;
sl@0: 	const TInt countDeb=iDataRecognizerList.Count();
sl@0: 	for (TInt ii=0; ii<countDeb; ii++)
sl@0: 		{
sl@0: 		rec=iDataRecognizerList[ii];
sl@0:  		__ASSERT_ALWAYS(rec->TypeUid()!=aDataRecognizerType->TypeUid(), Panic(EDPanicDuplicateRecognizer));
sl@0: 		}
sl@0: #endif // _DEBUG
sl@0: 
sl@0: 	TInt priority=aDataRecognizerType->Priority();
sl@0: 	TInt count=iDataRecognizerList.Count();
sl@0: 	for (TInt i=0; i<count; i++)
sl@0: 		{
sl@0: 		if (iDataRecognizerList[i]->Priority()<priority)
sl@0: 			{
sl@0: 			iDataRecognizerList.InsertL(aDataRecognizerType, i);
sl@0: 			aDataRecognizerType->DataRecognizerExtension()->SetDataRecognizer(*this);
sl@0: 			return;
sl@0: 			}
sl@0: 		}
sl@0: 	iDataRecognizerList.AppendL(aDataRecognizerType);
sl@0: 	aDataRecognizerType->DataRecognizerExtension()->SetDataRecognizer(*this);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizer::CApaDataRecognizer_Reserved_1()
sl@0: 	{}
sl@0: 
sl@0: EXPORT_C TInt CApaDataRecognizer::RemoveDataRecognizerType(const CApaDataRecognizerType* aDataRecognizerType)
sl@0: // remove the concrete recognizer from the list
sl@0: // if it is not locked, if it fails return an error code
sl@0: 	{
sl@0: 	// find the recognizer in the list
sl@0: 	TInt count=iDataRecognizerList.Count();
sl@0: 	TUid uid=aDataRecognizerType->TypeUid();
sl@0: 	TInt i;
sl@0: 	for (i=0; i<count; i++)
sl@0: 		{
sl@0: 		if (iDataRecognizerList[i]->TypeUid()==uid)
sl@0: 			break;
sl@0: 		}
sl@0: 	// did we find a match
sl@0: 	if (i==count)
sl@0: 		return KErrNotFound;
sl@0: 	// is the matching recognizer locked
sl@0: 	CApaDataRecognizerType* rec=iDataRecognizerList[i];
sl@0: 	if (rec->Locked())
sl@0: 		return KErrLocked;
sl@0: 	// remove the recognizer from the list, then delete it
sl@0: 	delete rec;
sl@0: 	iDataRecognizerList.Remove(i);
sl@0: 	iDataRecognizerList.Compress();
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizer::DataTypeL(CDataTypeArray& aArray)
sl@0: 	{
sl@0: 	TInt count=iDataArray.Count();
sl@0: 	for (TInt i=0; i<count; i++)
sl@0: 		aArray.AppendL(iDataArray[i]);
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizer::UpdateDataTypesL()
sl@0: // rebuild the list of unique mime types
sl@0: 	{
sl@0: 	iDataArray.Reset();
sl@0: 	TInt count=iDataRecognizerList.Count();
sl@0: 	for (TInt i=0; i<count; i++)
sl@0: 		{
sl@0: 		CApaDataRecognizerType* rec=iDataRecognizerList[i];
sl@0: 		TRAP_IGNORE(rec->UpdateDataTypesL());
sl@0: 		TInt mimeCount=rec->MimeTypesCount();
sl@0: 		for (TInt ii=0; ii<mimeCount; ii++)
sl@0: 			{
sl@0: 			TRAP_IGNORE(AddDataTypeL(rec->SupportedDataTypeL(ii)));
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TInt CApaDataRecognizer::PreferredBufSize() const
sl@0: // return the maximum preferred buf size
sl@0: 	{
sl@0: 	if (iMaxBufferSize < 0)
sl@0: 		{
sl@0: 		// The recognizers have been (re)loaded, so calulate the maximum buffer size.
sl@0: 		TInt count=iDataRecognizerList.Count();
sl@0: 		for (TInt i=0; i<count; i++)
sl@0: 			iMaxBufferSize=Max((TInt)iDataRecognizerList[i]->PreferredBufSize(), iMaxBufferSize);
sl@0: 		}
sl@0: 	return iMaxBufferSize;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizer::DestroyRecognizerList()
sl@0: 	{
sl@0: 	iDataRecognizerList.ResetAndDestroy();
sl@0: 	iDataArray.Reset();
sl@0: 	}
sl@0: 
sl@0: void CApaDataRecognizer::AddDataTypeL(const TDataType& aDataType)
sl@0: // add a mime type to the array if it's unique
sl@0: 	{
sl@0: 	TInt i=iDataArray.Count()-1;
sl@0: 	for (; i>=0; i--)
sl@0: 		{
sl@0: 		if (aDataType==iDataArray[i])
sl@0: 			return;
sl@0: 		}
sl@0: 	iDataArray.AppendL(aDataType);
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // class CApaDataRecognizerType
sl@0: //
sl@0: 
sl@0: EXPORT_C CApaDataRecognizerType::CApaDataRecognizerType(TUid aUid, TInt aPriority)
sl@0: 	:iTypeUid(aUid),
sl@0: 	iPriority(aPriority),iDataRecognizerExtn(NULL)
sl@0: /** Constructs the recognizer with a UID and a priority.
sl@0: 
sl@0: Typically, a derived class constructor calls this constructor through a constructor 
sl@0: initialization list.
sl@0: 
sl@0: The UID is the way that a recognizer is detected by the framework.
sl@0: 
sl@0: @param aUid A UID that identifies the recognizer.
sl@0: @param aPriority A value that estimates the probability that the recognizer 
sl@0: will successfully identify data. This is one of the CApaDataRecognizerType::TRecognizerPriority 
sl@0: enumerators.
sl@0: @see CApaDataRecognizerType::TRecognizerPriority */
sl@0: 	{}
sl@0: 
sl@0: EXPORT_C CApaDataRecognizerType::~CApaDataRecognizerType()
sl@0: // Destructor.
sl@0: 	{
sl@0: #ifdef USING_ECOM_RECOGS
sl@0: 	//if ecom plugin is used destroy its implementation
sl@0: 	if(iDataRecognizerExtn!=NULL)
sl@0: 		{
sl@0: 		REComSession::DestroyedImplementation(iDataRecognizerExtn->DestructorUid());
sl@0: 		delete iDataRecognizerExtn;
sl@0: 		}
sl@0: #endif
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizerType::Lock()
sl@0: /** Adds a lock to the recognizer.
sl@0: 
sl@0: This may be called any number of times, but each call to this function must 
sl@0: be matched by a corresponding call to Unlock() to completely unlock the recognizer.
sl@0: 
sl@0: This function is used to prevent the recognizer DLL from being unloaded.
sl@0: 
sl@0: @see Unlock()
sl@0: @see Locked() */
sl@0: 	{
sl@0: 	iLock++;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizerType::Unlock()
sl@0: /** Removes a lock from the recognizer.
sl@0: 
sl@0: All calls to Lock() should be matched by a corresponding call to this function. 
sl@0: The recognizer is not unlocked until all calls to Lock() have been matched 
sl@0: by corresponding calls to this function.
sl@0: 
sl@0: @see Lock()
sl@0: @see Locked() */
sl@0: 	{
sl@0: 	if (iLock>0)
sl@0: 		iLock--;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TUint CApaDataRecognizerType::PreferredBufSize()
sl@0: /** Gets the size of buffer preferred for the purpose of recognizing the data type.
sl@0: 
sl@0: Regardless of the preferred buffer size returned by an implementation of this 
sl@0: function, the actual size used is never greater than a maximum value as set 
sl@0: by the client of the Application Architecture server through a call to RApaLsSession::SetMaxDataBufSize().
sl@0: 
sl@0: @return The preferred data size. The default implementation returns zero.
sl@0: @see RApaLsSession::SetMaxDataBufSize() */
sl@0: 	{
sl@0: 	return 0;	// default to no buffer
sl@0: 				// name recognition only
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizerType::UpdateDataTypesL()
sl@0: /** Refreshes the list of data (MIME) types supported by this recognizer. */
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizerType::DoRecognizeL(const TDesC& aName, const TDesC8& aBuffer)
sl@0: /** Implements the attempt to recognize data.
sl@0: 
sl@0: Recognizers should provide an implementation of this function in a derived 
sl@0: class. Note that, when the implementation recognizes data, it must put the 
sl@0: result of the operation in the iDataType and iConfidence data members.
sl@0: 
sl@0: Note that if more data is required than is provided in aBuffer, then 
sl@0: CApaDataRecognizerType::FilePassedByHandleL should be called and the data 
sl@0: read from the returned RFile (if not NULL). If this returns NULL, it may be 
sl@0: possible to retrieve the data by calling RFile::Open() on aName, but only if 
sl@0: aName is a legal file-name. It may be something else, such as a URL.
sl@0: 
sl@0: The default implementation does not recognize data.
sl@0: 
sl@0: @param aName The name of the data; typically this is a file name containing 
sl@0: the data to be recognized. It is not necessarily a legal file-name though. It 
sl@0: may, for example, be a URL/URI.
sl@0: @param aBuffer A buffer containing data to be recognized; typically, this is 
sl@0: read from the start of the file containing the data.
sl@0: @see RecognizeL()
sl@0: @see FilePassedByHandleL()
sl@0: */
sl@0: 	{
sl@0: 	(void)aName;
sl@0: 	(void)aBuffer;
sl@0: 	iDataType=TDataType();
sl@0: 	}
sl@0: 
sl@0: EXPORT_C RFile* CApaDataRecognizerType::FilePassedByHandleL()
sl@0: /** Returns the RFile (if any) of file to be recognized.
sl@0: 
sl@0: This function returns the file passed by handle from the client-side (i.e. from calls to the RFile-parameter overloads of RApaLsSession's RecognizeData, RecognizeSpecificData, AppForDocument and StartDocument). The function returns NULL if the file to be recognized was not passed by handle.
sl@0: 
sl@0: It may only be called from implementations of DoRecognizeL - indeed the purpose of this function is logically to provide an extra parameter to the virtual DoRecognizeL function. All references/pointers to the 
sl@0: RFile object returned must be discarded when the implementation of DoRecognizeL returns.
sl@0: 
sl@0: The RFile returned (if any) may be used by implementations of DoRecognizeL to retrieve more data than is provided in DoRecognizeL's aBuffer parameter.
sl@0: 
sl@0: The current-position of the returned RFile is the start of the file.
sl@0: 
sl@0: @return The file, passed by handle, to be recognized. Returns NULL if the data to be recognized was passed from the client-side by name/buffer rather than by file-handle. Ownership of the returned object is NOT transferred to the caller.
sl@0: @see DoRecognizeL()
sl@0: */
sl@0: 	{
sl@0: 	RFile* const filePassedByHandle=iDataRecognizerExtn->DataRecognizer().FilePassedByHandle();
sl@0: 	if (filePassedByHandle!=NULL && (filePassedByHandle->SubSessionHandle()!=KNullHandle))
sl@0: 		{
sl@0: 		// set the current file-position to the start of the file
sl@0: 		TInt filePosition=0;
sl@0: 		User::LeaveIfError(filePassedByHandle->Seek(ESeekStart, filePosition));
sl@0: 		}
sl@0: 	return filePassedByHandle;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TDataRecognitionResult CApaDataRecognizerType::RecognizeL(const TDesC& aName, const TDesC8& aBuffer)
sl@0: /** Attempts to recognize data.
sl@0: 
sl@0: This function is called by the Application Architecture server as a result 
sl@0: of client calls to the server through an instance of RApaLsSession.
sl@0: 
sl@0: The function calls DoRecognizeL() which implements recognition behaviour.
sl@0: 
sl@0: @param aName The name of the data; typically this is a file name containing 
sl@0: the data to be recognized.
sl@0: @param aBuffer A buffer containing data to be recognized; typically, this is 
sl@0: read from the start of the file containing the data. Implement PreferredBufSize() 
sl@0: to define the ideal size for this buffer. Note that failure to implement PreferredBufSize() 
sl@0: results in a default buffer size of zero.
sl@0: @return The result of the attempt to recognize the data.
sl@0: @see PreferredBufSize()
sl@0: @see RApaLsSession
sl@0: @see RApaLsSession::SetMaxDataBufSize() */
sl@0: 	{
sl@0: 	TDataToRecognize dataToRecognize(aName, aBuffer);
sl@0: 	return RecognizeL(dataToRecognize);
sl@0: 	}
sl@0: 
sl@0: TDataRecognitionResult CApaDataRecognizerType::RecognizeL(TDataToRecognize& aDataToRecognize)
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: 	{
sl@0: 	iDataType=TDataType();
sl@0: 	iConfidence=ENotRecognized;
sl@0: 	aDataToRecognize.RecognizeL(*this);
sl@0: 	TDataRecognitionResult rec;
sl@0: 	rec.iDataType=iDataType;
sl@0: 	rec.iConfidence=iConfidence;
sl@0: 	return rec;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C TDataType CApaDataRecognizerType::MimeType()
sl@0: /** Gets the data (MIME) type of the most recently recognized data.
sl@0: 
sl@0: @return The data (MIME) type.
sl@0: @see iDataType */
sl@0: 	{
sl@0: 	return iDataType;
sl@0: 	}
sl@0: 
sl@0: EXPORT_C void CApaDataRecognizerType::Reserved_1()
sl@0: // a spare empty virtual function
sl@0: 	{}
sl@0: 
sl@0: // instantiate the ecom implementation class 
sl@0: EXPORT_C CApaDataRecognizerType* CApaDataRecognizerType::CreateDataRecognizerL(TUid aImplUid)
sl@0: 	{
sl@0: #if !defined(USING_ECOM_RECOGS)
sl@0: 	(void)aImplUid;
sl@0: 	return NULL;
sl@0: #endif
sl@0: 	CDataRecognizerExtension* const dataRecognizerExtn=CDataRecognizerExtension::NewL();
sl@0: 	CleanupStack::PushL(dataRecognizerExtn);
sl@0: 
sl@0: 	CApaDataRecognizerType* const dataRecType=static_cast <CApaDataRecognizerType*>(REComSession::CreateImplementationL(aImplUid, dataRecognizerExtn->DestructorUidReference()));
sl@0: 
sl@0: 	dataRecType->iDataRecognizerExtn = dataRecognizerExtn;
sl@0: 	CleanupStack::Pop(dataRecognizerExtn);
sl@0: 
sl@0: 	return dataRecType;
sl@0: 	}
sl@0: 
sl@0: CDataRecognizerExtension* CApaDataRecognizerType::DataRecognizerExtension()
sl@0: /** @internalComponent */
sl@0: 	{
sl@0: 	return iDataRecognizerExtn;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // class TDataRecognitionResult
sl@0: //
sl@0: 
sl@0: EXPORT_C void TDataRecognitionResult::Reset()
sl@0: /** Resets the data type to the default data type and sets the confidence rating 
sl@0: to CApaDataRecognizerType::ENotRecognized.
sl@0: 
sl@0: @see CApaDataRecognizerType::TRecognitionConfidence
sl@0: @see TDataType */
sl@0: 	{
sl@0: 	iDataType=TDataType();
sl@0: 	iConfidence=CApaDataRecognizerType::ENotRecognized;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // class TDataToRecognize
sl@0: //
sl@0: 
sl@0: TDataToRecognize::TDataToRecognize(const TDesC& aName, const TDesC8& aBuffer)
sl@0: 	:iFlags(0),
sl@0: 	 iName(&aName),
sl@0: 	 iBuffer(&aBuffer),
sl@0: 	 iDataRecognizer(NULL),
sl@0: 	 iFile(NULL),
sl@0: 	 iFilePosition(0),
sl@0: 	 iPreferredBufSize(0)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aName.Length()>0 || aBuffer.Length()>0, Panic(EDPanicInvalidData));
sl@0: 	}
sl@0: 
sl@0: TDataToRecognize::TDataToRecognize(CApaDataRecognizer& aDataRecognizer, RFile& aFile, TInt aPreferredBufSize)
sl@0: 	:iFlags(0),
sl@0: 	 iName(NULL),
sl@0: 	 iBuffer(NULL),
sl@0: 	 iDataRecognizer(&aDataRecognizer),
sl@0: 	 iFile(&aFile),
sl@0: 	 iFilePosition(0),
sl@0: 	 iPreferredBufSize(aPreferredBufSize)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: void TDataToRecognize::RecognizeL(CApaDataRecognizerType& aDataRecognizerType)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(iName!=NULL, Panic(EDPanicNullPointer1));
sl@0: 	__ASSERT_DEBUG(iBuffer!=NULL, Panic(EDPanicNullPointer2));
sl@0: 	aDataRecognizerType.DoRecognizeL(*iName, *iBuffer);
sl@0: 	}
sl@0: 
sl@0: void TDataToRecognize::PrepareForRecognizeLoopLC()
sl@0: 	{
sl@0: 	CleanupStack::PushL(TCleanupItem(ResetAfterRecognizeLoopL, this));
sl@0: 	if (iFile!=NULL)
sl@0: 		{
sl@0: 		// set the file-pointer returned by CApaDataRecognizerType::FilePassedByHandleL
sl@0: 		iDataRecognizer->SetFilePassedByHandle(iFile);
sl@0: 
sl@0: 		// store current-position in iFilePosition
sl@0: 		__ASSERT_DEBUG((iFlags&EFlagFilePositionStored)==0, Panic(EDPanicBadFlagState1));
sl@0: 		iFlags|=EFlagFilePositionStored;
sl@0: 		iFilePosition=0;
sl@0: 		User::LeaveIfError(iFile->Seek(ESeekCurrent, iFilePosition));
sl@0: 
sl@0: 		// read a buffer of the appropriate length from the start of the file
sl@0: 		__ASSERT_DEBUG(iBuffer==NULL, Panic(EDPanicNullPointerExpected1));
sl@0: 		TInt filePosition=0;
sl@0: 		User::LeaveIfError(iFile->Seek(ESeekStart, filePosition));
sl@0: 		HBufC8* const buffer=HBufC8::NewL(iPreferredBufSize);
sl@0: 		iBuffer=buffer; // iBuffer now "owns" this (as long as iFile!=NULL, which is true)
sl@0: 		TPtr8 buffer_asWritable(buffer->Des());
sl@0: 		User::LeaveIfError(iFile->Read(buffer_asWritable));
sl@0: 
sl@0: 		// prepend "::" to the file-name to be passed to DoRecognizeL to make it an illegal file-name - this
sl@0: 		// is to prevent any behavioural break since implementers of DoRecognizeL may assume that if aName is
sl@0: 		// *not* an illegal file-name they can pass it to RFile::Open, which will not be possible if we're
sl@0: 		// recognizing by file-handle, both because of data-caging (the file may not live in a directory that
sl@0: 		// the Apparc process has permission to open it from) and because aName does not contain the full path
sl@0: 		__ASSERT_DEBUG(iName==NULL, Panic(EDPanicNullPointerExpected2));
sl@0: 		TDes* const name=new(ELeave) TFileName;
sl@0: 		iName=name; // iName now "owns" this (as long as iFile!=NULL, which is true)
sl@0: 		User::LeaveIfError(iFile->Name(*name));
sl@0: 		_LIT(KLitIllegalifier, "::");
sl@0: 		name->Insert(0, KLitIllegalifier);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void TDataToRecognize::PopOffCleanupStackAndResetAfterRecognizeLoopL()
sl@0: 	{
sl@0: 	iFlags|=EFlagLeaveIfError; // we don't want to leave from ResetAfterRecognizeLoopL if we're being cleaned up from the clean-up stack because of a leave, but if we're leaving because of a CleanupStack::PopAndDestroy then it's okay to leave
sl@0: 	CleanupStack::PopAndDestroy(this); // calls ResetAfterRecognizeLoopL
sl@0: 	}
sl@0: 
sl@0: void TDataToRecognize::ResetAfterRecognizeLoopL(TAny* aThis)
sl@0: 	{ // static
sl@0: 	STATIC_CAST(TDataToRecognize*, aThis)->ResetAfterRecognizeLoopL();
sl@0: 	}
sl@0: 
sl@0: void TDataToRecognize::ResetAfterRecognizeLoopL()
sl@0: 	{
sl@0: 	TInt error=KErrNone;
sl@0: 	if (iFile!=NULL)
sl@0: 		{
sl@0: 		// NULLify the file-pointer returned by CApaDataRecognizerType::FilePassedByHandleL
sl@0: 		iDataRecognizer->SetFilePassedByHandle(NULL);
sl@0: 
sl@0: 		// reset the current-position of the file
sl@0: 		__ASSERT_DEBUG(iFlags&EFlagFilePositionStored, Panic(EDPanicBadFlagState2));
sl@0: 		error=iFile->Seek(ESeekStart, iFilePosition);
sl@0: 		iFlags&=~EFlagFilePositionStored;
sl@0: 
sl@0: 		// delete the objects that are owned if iFile!=NULL (which is true)
sl@0: 		delete iName;
sl@0: 		delete iBuffer;
sl@0: 		}
sl@0: 	if (iFlags&EFlagLeaveIfError)
sl@0: 		{
sl@0: 		iFlags&=~EFlagLeaveIfError; // probably not necessary, just defensive programming
sl@0: 		User::LeaveIfError(error);
sl@0: 		}
sl@0: 	}
sl@0: