/*
* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 class CCodDocument.   
*
*/


// INCLUDE FILES

#include <AiwGenericParam.h>
#include <CodEng.h>
#include <DdEng.h>
#include <CodUtil.h>
#include "CodDocument.h"
#include "CodAppUi.h"
#include "RequestCompleteCallback.h"
#include "CodLogger.h"

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

// ---------------------------------------------------------
// CCodDocument::CodAppUi()
// ---------------------------------------------------------
//
CCodAppUi* CCodDocument::CodAppUi()
    {
    // Inline method must be defined before it is used.
    return STATIC_CAST( CCodAppUi*, iAppUi );
    }
    
// ---------------------------------------------------------
// CCodDocument::NewL()
// ---------------------------------------------------------
//
CCodDocument* CCodDocument::NewL( CEikApplication& aApp, TBool aCod )
    {
    CCodDocument* doc = new (ELeave) CCodDocument( aApp, aCod );
    CleanupStack::PushL( doc );
    doc->ConstructL();
    CleanupStack::Pop( doc );
    return doc;
    }
    
// ---------------------------------------------------------
// CCodDocument::~CCodDocument()
// ---------------------------------------------------------
//
CCodDocument::~CCodDocument()
    {
    delete iModel;      // Delete (==Cancel) the model...
    delete iCallback;   // ...before deleting (==Cancelling) the callback.
    }

// ---------------------------------------------------------
// CCodDocument::Model()
// ---------------------------------------------------------
//
CCodEngBase& CCodDocument::Model()
    {
    return *iModel;
    }

// ---------------------------------------------------------
// CCodDocument::CreateAppUiL()
// ---------------------------------------------------------
//
CEikAppUi* CCodDocument::CreateAppUiL()
    {
    return new (ELeave) CCodAppUi( iCod );
    }

// ---------------------------------------------------------
// CCodDocument::OpenFileL()
// ---------------------------------------------------------
//
CFileStore* CCodDocument::OpenFileL
( TBool aDoOpen, const TDesC& aFilename, RFs& aFs )
    {
    CLOG(( 2, _L("-> CCodDocument::OpenFileL aDoOpen(0x%x) aFname<%S>"), \
        aDoOpen, &aFilename ));
    CFileStore* store( NULL );
    if ( aDoOpen )
        {
        RFile file;
        TInt err = file.Open( aFs, aFilename,
            EFileShareReadersOnly | EFileStream | EFileRead );
        if ( err == KErrInUse )
            {
            err = file.Open( aFs, aFilename,
                EFileShareAny | EFileStream | EFileRead );
            }
        User::LeaveIfError( err );
        CleanupClosePushL<RFile>( file );
        store = OpenFileL( aFs, file );
        CleanupStack::PopAndDestroy();  // close file
        }
    CLOG(( 2, _L("<- CCodDocument::OpenFileL") ));
    return store;
    }

// ---------------------------------------------------------
// CCodDocument::OpenFileL()
// ---------------------------------------------------------
//
CFileStore* CCodDocument::OpenFileL( RFs& /*aFs*/, RFile& aFile )
    {
    CLOG(( 2, _L("-> CCodDocument::OpenFileL (RFs+RFile)") ));
    CFileStore* store( NULL );
    OpenFileL( store, aFile );
    CLOG(( 2, _L("<- CCodDocument::OpenFileL (RFs+RFile)") ));
    return store;
    }

// ---------------------------------------------------------
// CCodDocument::OpenFileL()
// ---------------------------------------------------------
//
void CCodDocument::OpenFileL( CFileStore*& aFileStore, RFile& aFile )
    {
    CLOG(( 2, _L("-> CCodDocument::OpenFileL (RFile)") ));
    if( iModel->IsActive() )
        {
        // Busy with something else.
        // Maybe we should Cancel the ongoing operation? I don't think so.
        CLOG(( 2, _L("  leave with KErrNotReady") ));
        User::Leave( KErrNotReady );
        }

    // Get params, extract the UI related ones.
    const CAiwGenericParamList* params = GetInputParameters();
    if ( params )
        {
        TBool silent( EFalse );
        TBool suppressNextUrl( EFalse );
        TBool suppressLaunch( EFalse );
        CodUtil::GetBoolParam( silent, EGenericParamSilentDownload, *params );
        CodUtil::GetBoolParam
            ( suppressNextUrl, EGenericParamSuppressNextUrl, *params );
        CodUtil::GetBoolParam
            ( suppressLaunch, EGenericParamSuppressLaunch, *params );
        CodAppUi()->SetServiceFlow( silent, suppressNextUrl, suppressLaunch );
        }

    // Read descriptor data from file.
    TInt fSize;
    User::LeaveIfError( aFile.Size( fSize ) );
    HBufC8* buf = HBufC8::NewLC( fSize );
    TPtr8 bufP( buf->Des() );
    User::LeaveIfError( aFile.Read( bufP ) );
    
    iModel->SetL( bufP, &iCallback->iStatus, params, NULL );
    iCallback->CallbackOnCompletion
        ( TCallBack( StaticOpenFileDone, this ) );
    CleanupStack::PopAndDestroy( buf );
    aFileStore = NULL;
    CLOG(( 2, _L("<- CCodDocument::OpenFileL (RFile)") ));
    }
    
// ---------------------------------------------------------
// CCodDocument::CCodDocument()
// ---------------------------------------------------------
//
CCodDocument::CCodDocument( CEikApplication& aApp, TBool aCod )
: CAiwGenericParamConsumer( aApp ), iCod( aCod )
    {
    }

// ---------------------------------------------------------
// CCodDocument::ConstructL()
// ---------------------------------------------------------
//
void CCodDocument::ConstructL()
    {
    if ( iCod )
        {
        iModel = CCodEng::NewL( iEikProcess, NULL );
        }
    else
        {
        iModel = CDdEng::NewL( iEikProcess, NULL );
        }
        
    iCallback = new ( ELeave ) CRequestCompleteCallback();
    }

// ---------------------------------------------------------
// CCodDocument::OpenFileDone()
// ---------------------------------------------------------
//
void CCodDocument::OpenFileDone()
    {
    CLOG(( 2, _L("-> CCodDocument::OpenFileDone") ));
    // Note that it is possible that we don't have iAppUi here. There is
    // blank screen with "Back" softkey while parsing the COD.
    // During that, "Back" command may be issued and
    // processed by AppUi during the wait.
    if ( iAppUi )
        {
        CodAppUi()->OpenFileDone( iCallback->iStatus.Int() );
        }
    CLOG(( 2, _L("<- CCodDocument::OpenFileDone") ));
    }

// ---------------------------------------------------------
// CCodDocument::StaticOpenFileDone()
// ---------------------------------------------------------
//
TInt CCodDocument::StaticOpenFileDone( TAny* aPtr )
    {
    STATIC_CAST( CCodDocument*, aPtr )->OpenFileDone();
    return EFalse;  // TCallback should return EFalse as TInt.
    }