/*

* Copyright (c) 2002 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:  Implementation of text recognizer class.

*

*/

#include <apmrec.h>

#include <apmstd.h>

#include <e32svr.h>

#include <implementationproxy.h>

#include "TxtRecog.h"

#include <barsread.h>

#include <eikenv.h>

#include <f32file.h>

#include <data_caging_path_literals.hrh> 

#include <TxtRecog.rsg>

// CONSTANTS

_LIT8(KTextMimeType, "text/plain");

const TInt KMaxBufferSize(512);

_LIT(KTextExtension, ".txt");

_LIT( KResourceFile, "TxtRecog.rsc" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::CKthreeTextRecognizer

// -----------------------------------------------------------------------------

//

CKthreeTextRecognizer::CKthreeTextRecognizer()

    :CApaDataRecognizerType(

        TDataType(KTextMimeType).Uid(),

        CApaDataRecognizerType::ELow )

    {

    iCountDataTypes = 1;

    }

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::NewL

// -----------------------------------------------------------------------------

//

CKthreeTextRecognizer*  CKthreeTextRecognizer::NewL()

	{

	  CKthreeTextRecognizer* self = new(ELeave) CKthreeTextRecognizer();

	  CleanupStack::PushL( self  );

	  self->ConstructL();

	  CleanupStack::Pop();

	  return self;

	}

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::ConstructL()

// -----------------------------------------------------------------------------

//

void CKthreeTextRecognizer::ConstructL()

	{

	  TInt err = 0;

    RFs fs;

	  RResourceFile resourceFile;

    TResourceReader theReader;

    TBuf<254> resourceFileName;

    err = fs.Connect();

    if (err)

        {

        fs.Close();

		User::LeaveIfError( err );

        }

    TParse* fp = new(ELeave) TParse(); 

    fp->Set(KResourceFile, &KDC_APP_RESOURCE_DIR, NULL); 

    resourceFileName.Copy(fp ->FullName());

    TPtrC driveLetter = TParsePtrC( RProcess().FileName() ).Drive();

    TFileName fileName( driveLetter );

    fileName.Append( resourceFileName );

    TRAP(err, resourceFile.OpenL(fs, fileName));

    if (err)

       {

        fs.Close();

		delete fp;

		fp =NULL;

     	User::LeaveIfError( err );

       }

     delete fp;

	 fp =NULL;    

	HBufC8* res = resourceFile.AllocReadL( R_BLACK_LIST_EXTENSIONS_LIST	);

	theReader.SetBuffer(res);

	TInt count = theReader.ReadInt16() ;

	for( TInt i = 0 ; i < count ; i++)

	{

		HBufC* blExt = theReader.ReadHBufCL() ;

		iResListData.Append( blExt );

	}

	delete res;

    res = NULL;

    resourceFile.Close();

    fs.Close();

	}

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::PreferredBufSize

// -----------------------------------------------------------------------------

//

CKthreeTextRecognizer::~CKthreeTextRecognizer()

	{

	//iResListData.Close();

	iResListData.ResetAndDestroy();

	}

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::PreferredBufSize

// -----------------------------------------------------------------------------

//

TUint CKthreeTextRecognizer::PreferredBufSize()

    {

    return KMaxBufferSize;

    }

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::SupportedDataTypeL

// -----------------------------------------------------------------------------

//

TDataType CKthreeTextRecognizer::SupportedDataTypeL(TInt ) const

    {

    return TDataType(KTextMimeType);

    }

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::DoRecognizeL

// -----------------------------------------------------------------------------

//

void CKthreeTextRecognizer::DoRecognizeL(

    const TDesC& aName,

    const TDesC8& aBuffer )

    {

    iConfidence = ENotRecognized;

    TBool isTextExtension(EFalse);

	/* If extension is .txt and the buffer is empty return Probable */

    if ( aName.Length() > KTextExtension().Length() )

        {

        TPtrC extension = aName.Right(KTextExtension().Length());

		if (IsInBlackListL(extension))

			{

			iConfidence = ENotRecognized;

			return ;

			}

		if ( extension.CompareF(KTextExtension) == 0 )

            {

            isTextExtension = ETrue;

            iDataType = TDataType(KTextMimeType);

            iConfidence = EProbable;

			/* There may be a buffer of characters available for

			   us to scan through and we might get more confident */

            }

        }

    const TInt size(aBuffer.Size());

	/* This is the second call where we also get data in the buffer */

	if ( size > 0 )

		{

			/*  If BOM and .txt -> Certain.  If BOM only -> Probable */

			if (  size > 1 &&

			   (( aBuffer[0] == 0xfe && aBuffer[1] == 0xff ) ||

				( aBuffer[0] == 0xff && aBuffer[1] == 0xfe ) ))

				{

				  iDataType = TDataType(KTextMimeType);

				  iConfidence = isTextExtension ? ECertain : EProbable;

				}

			/* If No BOM. It is ASCII */

			else

				{

					/* See if all characters are valid ASCII. Any invalid ASCII chars make this non UNICODE file not a text file */

					TInt i(0);

					while ( i < size && !IsInvalidChar(aBuffer[i]))

						{

						i++;

						}

					if ( i == size )// chars in aBuffer are all valid.

						{

						iDataType = TDataType(KTextMimeType);

						if ( i >= KMaxBufferSize ) // we were  given at least as many samples as we asked for

							{

							if (isTextExtension)

								{

								iConfidence = ECertain;	    	// No BOM but .txt and losts of ascii characters

								}

							else

								{

								iConfidence = EProbable;	// No BOM or .txt but lots of ascii characters

								}

							}

						else  //not enough samples to be certain

							{

							if (isTextExtension)

								{

								iConfidence = EProbable;	// No BOM but .txt and a few ascii characters

								}

							else

								{

								iConfidence = EPossible;	// No BOM or .txt but some ascii characters

								}

							}

						} //end all valid chars

					} //end no BOM

		} //end size > 0

	}

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::IsInvalidChar

// -----------------------------------------------------------------------------

//

TBool CKthreeTextRecognizer::IsInvalidChar( const TUint8& aByte )

    {

    return aByte == 0x7f || aByte <= 0x07 ||

        ( aByte >= 0x0e && aByte <= 0x1f && aByte != 0x1b );

    }

// -----------------------------------------------------------------------------

// CKthreeTextRecognizer::IsInBlackListL

// -----------------------------------------------------------------------------

//

TBool CKthreeTextRecognizer::IsInBlackListL(TPtrC aExt)

	{

	TBool ret = EFalse;

	TInt count = iResListData.Count();

    for ( TInt index = 0; index < count; index++)

        {

				if (aExt.CompareF(*iResListData[index]) == 0 )

				{

				ret = ETrue ;

				break ;

				}

				}

   return ret;

	}

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------

// CApaDataRecognizerType* CreateRecognizer

// The gate function - ordinal 1

// -----------------------------------------------------------------------------

//

#ifdef EKA2

CApaDataRecognizerType* CKthreeTextRecognizer::CreateRecognizerL()

    {

    //return new (ELeave) CKthreeTextRecognizer();

    return CKthreeTextRecognizer::NewL();

    }

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY(KTxtRecognizerImplementationUid, 

    	CKthreeTextRecognizer::CreateRecognizerL)

    };

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

#else

EXPORT_C CApaDataRecognizerType* CreateRecognizer()

    {

    CApaDataRecognizerType* thing=new CKthreeTextRecognizer();

    return thing; // NULL if new failed

    }

#endif

// -----------------------------------------------------------------------------

// E32Dll

// DLL entry point

// -----------------------------------------------------------------------------

//

#ifndef EKA2

GLDEF_C TInt E32Dll(TDllReason /*aReason*/)

    {

    return KErrNone;

    }

#endif

// End of File