/*
* Copyright (c) 2006-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:  The class implements a long task wrapper for load file
*
*/



// INCLUDE FILES
#include <coemain.h>
#include <s32file.h>
#include <charconv.h>
#include "NpdLoadFileAO.h"
#include "NpdUtil.h"

// CONSTANTS

// the max length of the sample text which attempts to determine the character set
static const TInt KMaxSampleLengthForAutoDetection = 1024;

// the file length load in one step
static const TInt KLengthOneStepLoad = 1024 * 10;

// when the value is large than this, the auto detect result is available 
static const TInt KValueAutoDetectCharacterSetAvailable = 50;

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

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::CNotepadLoadFileAO()
//
// ----------------------------------------------------------------------------
CNotepadLoadFileAO::CNotepadLoadFileAO( MNotepadLoadFileObserver* aObserver,
                                        CCoeEnv& aCoeEnv,
                                        RFile& aFile, 
                                        TBool aGuessEncoding,
                                        TUint aEncoding, 
                                        CPlainText& aText ):
    CActive( CActive::EPriorityLow ),
    iObserver( aObserver ),
    iCoeEnv( aCoeEnv ),
    iGuessEncoding( aGuessEncoding ),
    iEncoding( aEncoding ),
    iText( aText )
    {
    iFile.Duplicate( aFile );
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::~CNotepadLoadFileAO()
//
// ----------------------------------------------------------------------------
CNotepadLoadFileAO::~CNotepadLoadFileAO()
    {
    iFile.Close();
    Cancel();
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::NewL()
//
// ----------------------------------------------------------------------------
CNotepadLoadFileAO* CNotepadLoadFileAO::NewL( MNotepadLoadFileObserver* aObserver,
                                              CCoeEnv& aCoeEnv,
                                              RFile& aFile, 
                                              TBool aGuessEncoding,
                                              TUint aEncoding, 
                                              CPlainText& aText )
    {
    CNotepadLoadFileAO* self = new (ELeave) CNotepadLoadFileAO(aObserver,
            aCoeEnv, aFile, aGuessEncoding, aEncoding, aText);

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::ConstructL()
//
// ----------------------------------------------------------------------------
void CNotepadLoadFileAO::ConstructL()
    {
    CActiveScheduler::Add( this );
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::StartLoadFile()
//
// ----------------------------------------------------------------------------
TInt CNotepadLoadFileAO::StartLoadFile()
    {
    TInt err( KErrAlreadyExists );
    if ( !IsActive() )
      {
        err = KErrNone;
        TRAP ( err, InitImportExportParamL() )
        if ( err == KErrNone )
            {
            TRequestStatus *statue = &iStatus;
            User::RequestComplete( statue, KErrStep );
            SetActive();
            }
      }
    return err;
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::CancelLoadFile()
//
// ----------------------------------------------------------------------------
void CNotepadLoadFileAO::CancelLoadFile()
    {
    iCancel = ETrue;
    }


// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::RunL()
//
// ----------------------------------------------------------------------------
void CNotepadLoadFileAO::RunL()
    {
    TInt status = iStatus.Int();
    if ( status == KErrStep )
        {
        DoStepL();
        }
    iObserver->NotifyCompletedL( status );
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::DoCancel()
//
// ----------------------------------------------------------------------------
void CNotepadLoadFileAO::DoCancel()
    {
    iCancel = ETrue;
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::DoStepL()
//
// ----------------------------------------------------------------------------
void CNotepadLoadFileAO::DoStepL()
    {  
    TInt completeCode = KErrStep;
    // if the load file completed 
    if ( iReadPos >= iFileSize )
        {
        completeCode = KErrNone;
        }
    // if the load file canceled
    else if ( iCancel )
        {
        completeCode = KErrCancel;
        }
    // load file for one step
    else
        {
        CPlainText::TImportExportResult result;
        TInt leaveSize = iFileSize - iReadPos ;
        iParam.iMaxInputChars =  leaveSize > KLengthOneStepLoad ? KLengthOneStepLoad: leaveSize;
        TInt err = KErrNone;
        RFile tempFile;
        tempFile.Duplicate( iFile );
        RFileReadStream stream( tempFile,iReadPos );
        CleanupClosePushL(stream);
        TRAP( err, iText.ImportTextL( iText.DocumentLength(), stream, iParam, result) );
        stream.Release();// closing of tempfile
        CleanupStack::PopAndDestroy(); // stream
        if ( err != KErrNone )
            {
            completeCode = err;
            }
        iReadPos += result.iInputChars;
        }
    
    TRequestStatus *statue = &iStatus;
    User::RequestComplete( statue,completeCode );
    SetActive();
    }

// ----------------------------------------------------------------------------
// CNotepadLoadFileAO::InitImportExportParamL()
//
// ----------------------------------------------------------------------------
void CNotepadLoadFileAO::InitImportExportParamL()
    {
    User::LeaveIfError( iFile.Size( iFileSize ) );
    
    // need to guess the foreign encoding for this file or not 
    if ( !iGuessEncoding )
        {
        iParam.iForeignEncoding = iEncoding;
        }
    else
        {
        TBuf8<KMaxSampleLengthForAutoDetection> sample;
        User::LeaveIfError( iFile.Read( sample, iFileSize > KMaxSampleLengthForAutoDetection ? 
             KMaxSampleLengthForAutoDetection : iFileSize ) );
         
        // Creates an array identifying all the character sets for which conversion is available 
        CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* 
        lists = CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(
                                         iCoeEnv.FsSession() );
        
        // Attempts to determine the character set of the sample text from those supported on the phone
        TInt confidence(0);
        TUint charset(0);
        CCnvCharacterSetConverter::AutoDetectCharacterSetL( confidence, charset, *lists, sample );
        CleanupStack::PopAndDestroy();
        
        // the auto detect result is available 
        if ( confidence > KValueAutoDetectCharacterSetAvailable )
             {
             iParam.iForeignEncoding = charset;
             }
        else 
             {   
             // Checks wether the descriptor contains big endian unicode text
             if ( NotepadUtil::IsBigEndianUnicodeText( sample ) )
                 {
                 iParam.iForeignEncoding = KCharacterSetIdentifierUnicodeBig; 
                 }
             // Checks wether the descriptor contains little endian unicode text
             else if ( NotepadUtil::IsLittleEndianUnicodeText( sample ) )
                 {
                 iParam.iForeignEncoding = KCharacterSetIdentifierUnicodeLittle;
                 }
             // Checks wether the descriptor contains UTF8 text
             else if ( NotepadUtil::IsUTF8Text( sample ) )
                 {
                 iParam.iForeignEncoding = KCharacterSetIdentifierUtf8;
                 }
             // Checks wether the descriptor contains SHIFT-JIS encoded text
             else if ( NotepadUtil::IsShiftJisText( sample ) )
                 {
                 iParam.iForeignEncoding = KCharacterSetIdentifierShiftJis;
                 }
             // Guess the encoding from the language
             else
                 {
                 iParam.iForeignEncoding = NotepadUtil::GuessEncodingFromLanguage();
                 if ( iParam.iForeignEncoding == 0 ) // Variant not found
                     {
                     iParam.iForeignEncoding = KCharacterSetIdentifierAscii;
                     }
                 }
             }
        } 
    }


// End of File