/*

* 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 CCodAppUi.

*

*/

#include <avkon.hrh>

#include <eikbtgpc.h>

#include <eikapp.h>

#include <apgcli.h>

#include <CodUi.rsg>

#include <avkon.rsg>

#include <AknQueryDialog.h>

#include <ErrorUi.h>

#include <TextResolver.h>

#include <AiwGenericParam.h>

#include <DocumentHandler.h>

#include <DcfRep.h>

#include <RoapDef.h>

#include <DRMCommon.h>

#include <StringLoader.h>

#include "CodAppUi.h"

#include "CodView.h" 

#include "CodDocument.h" 

#include "CodWaitDialog.h" 

#include "CodUi.hrh"

#include "CodUiPanic.h"

#include "RequestCompleteCallback.h"

#include "CodUiResource.h"

#include "CodLogger.h"

#include "CodDialog.h"

// ================= CONSTANTS =======================

/// UID of Wml Browser.

LOCAL_D const TInt KCodWmlBrowserUid = 0x10008D39;

/// Message prefix, to launch browser with URL.

_LIT( KCodMsgLaunchBrowserWithUrl, "4 " );

/// Reserved word "local".

_LIT8( KCodReservedWordLocal, "local" );

/// Reserved word "back".

_LIT8( KCodReservedWordBack, "back" );

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

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

// CCodAppUi::CodDocument()

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

//

CCodDocument* CCodAppUi::CodDocument()

    {

    // Inline method must be defined before it is used.

    return STATIC_CAST( CCodDocument*, Document() );

    }

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

// CCodAppUi::CCodAppUi()

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

//

CCodAppUi::CCodAppUi( TBool aCod )

: iCod( aCod ),

  iCurrentCba( R_AVKON_SOFTKEYS_BACK ),

  iError( KErrNone ),

  iSilentMode( EFalse ),

  iSuppressNextUrl( EFalse ),

  iSuppressLaunch( EFalse ),

  iRoap( EFalse )

    {

    CLOG(( 2, _L("*** CCodAppUi::CCodAppUi") ));

    }

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

// CCodAppUi::ConstructL()

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

//

void CCodAppUi::ConstructL()

    {

    iCodResource = CCodUiResource::NewL( *iEikonEnv );

    BaseConstructL( EAknEnableMSK );

    CodDocument()->Model().SetObserver( this );    

    iView = new (ELeave) CCodView;

    iView->SetMopParent( this );

    iView->ConstructL();

    iView->SetRect( ClientRect() );

    iView->ActivateL();

    iCallback = new ( ELeave ) CRequestCompleteCallback();

    iErrorUi = CErrorUI::NewL( *iCoeEnv );

    HandleModelChangeL();   // Initialize view with data.

    }

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

// CCodAppUi::~CCodAppUi()

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

//

CCodAppUi::~CCodAppUi()

    {

    CLOG(( 2, _L("*** -> CCodAppUi::~CCodAppUi") ));

    delete iDocHandler;

    delete iDocParams;

    // First of all NULL out observer to avoid further callbacks.

    CodDocument()->Model().SetObserver( NULL );

    // We must Cancel the model before deleting the callback.

    CodDocument()->Model().Cancel();

    delete iCallback;

    delete iErrorUi;

    delete iWaitNote;

    delete iView;

    if ( iDoorObserver )

        {

        iDoorObserver->NotifyExit( MApaEmbeddedDocObserver::ENoChanges );

        }

    delete iCodResource;

    iFs.Close();

    CLOG(( 2, _L("<- CCodAppUi::~CCodAppUi") ));

    }

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

// CCodAppUi::OpenFileDone()

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

//

void CCodAppUi::OpenFileDone( TInt aError )

    {

    CLOG(( 2, _L("-> CCodAppUi::OpenFileDone aError(%d)"), aError ));

    iError = aError;

    TRAPD( err, OpenFileDoneL() );

    if ( err )

        {

        RunAppShutter();

        }

    CLOG(( 2, _L("<- CCodAppUi::OpenFileDone") ));

    }

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

// CCodAppUi::SetServiceFlow()

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

//

void CCodAppUi::SetServiceFlow

        (

        TBool aSilentMode,

        TBool aSuppressNextUrl,

        TBool aSuppressLaunch

        )

    {

    CLOG(( 2, \

        _L("CCodAppUi::SetServiceFlow silent(%d) noUrl(%d) noLaunch(%d)"), \

        aSilentMode, aSuppressNextUrl, aSuppressLaunch ));

    iSilentMode = aSilentMode;

    iSuppressNextUrl = aSuppressNextUrl;

    iSuppressLaunch = aSuppressLaunch;

    }

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

// CCodAppUi::HandleModelChangeL()

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

//

void CCodAppUi::HandleModelChangeL()

    {

    CLOG(( 2, _L("-> CCodAppUi::HandleModelChangeL") ));

    TInt commandSet( R_AVKON_SOFTKEYS_BACK );

    const CCodData& data = CodDocument()->Model().Data();

    if ( data.IsValid() )

        {

        // Valid data: show details, show buttons "Accept" / "Reject".

        iView->SetDataL( data, iCod );

        commandSet = R_COD_UI_CBA_ACCEPT_REJECT;

        }

    else

        {

        // Invalid data: don't show details, show button "Back".

        iView->Clear();

        commandSet = R_AVKON_SOFTKEYS_BACK;

        }

    SetCbaL( commandSet );

    CLOG(( 2, _L("<- CCodAppUi::HandleModelChangeL") ));

    }

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

// CCodAppUi::OpenFileL()

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

//

void CCodAppUi::OpenFileL( const TDesC& aFileName )

    {

    CLOG(( 2, _L("-> CCodAppUi::OpenFileL aFileName<%S>"), &aFileName ));

    Document()->OpenFileL( ETrue, aFileName, iCoeEnv->FsSession() );

    CLOG(( 2, _L("<- CCodAppUi::OpenFileL") ));

    }

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

// CCodAppUi::HandleCommandL()

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

//

void CCodAppUi::HandleCommandL( TInt aCommand )

    {

    CLOG(( 2, _L("-> CCodAppUi::HandleCommandL aCommand(%d)"), \

        aCommand ));

    switch ( aCommand )

        {

        // From blank screen show during startup (incl. parsing).

        case EAknSoftkeyBack:

        // CAknShutter generated command.

        case EEikCmdExit:

            {

            Exit();

            break;

            }

        case EAknSoftkeyEmpty:

            {

            break;

            }

        case ECodUiCmdAccept:

            {

            // Safety code: ignore commands until completion of previous.

            // Quite unlikely to happen as we don't have this CBA.

            if( !CodDocument()->Model().IsActive() )

                {

                SetCbaL( R_AVKON_SOFTKEYS_EMPTY );

                CodDocument()->Model().Accept( &iCallback->iStatus );

                // Exit after processing is done.

                iCallback->CallbackOnCompletion

                    ( TCallBack( StaticLoadDone, this ) );

                }

            break;

            }

        case ECodUiCmdReject:

            {

            // Safety code: ignore commands until completion of previous.

            // Quite unlikely to happen as we don't have this CBA.

            if( !CodDocument()->Model().IsActive() )

                {

                SetCbaL( R_AVKON_SOFTKEYS_EMPTY );

                CodDocument()->Model().Reject( &iCallback->iStatus );

                iCallback->CallbackOnCompletion

                    ( TCallBack( StaticLoadDone, this ) );

                }

            break;

            }

        case ECodUiCmdCancel:

            {

            CodDocument()->Model().Stop();

            break;

            }

        default:

            {

            CLOG(( 0, _L("  unknown command") ));

            __ASSERT_DEBUG

                ( EFalse, CodUiPanic( ECodUiUnknownCommand ) );

            break;

            }

        }

    CLOG(( 2, _L("<- CCodAppUi::HandleCommandL") ));

    }

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

// CCodAppUi::ProcessCommandParametersL()

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

//

TBool CCodAppUi::ProcessCommandParametersL

( TApaCommand aCommand, TFileName& /*aDocumentName*/, const TDesC8& /*aTail*/ )

    {

    if ( aCommand == EApaCommandOpen )

        {

        CLOG(( 2, _L("CCodAppUi::ProcessCommandParametersL: EApaCommandOpen - noop") ));

        // Do not handle this here - CAiwGenericParamList not ready

        //OpenFileL( aDocumentName );

        }

    return EFalse;

    }

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

// CCodAppUi::HandleKeyEventL()

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

//

TKeyResponse CCodAppUi::HandleKeyEventL

( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    CLOG(( 2, _L("-> CCodAppUi::HandleKeyEventL") ));

    CLOG(( 3, _L("  aKeyEvent.iCode(%d)"), aKeyEvent.iCode ));

    CLOG(( 3, _L("  aKeyEvent.iScanCode(%d)"), aKeyEvent.iScanCode ));

    CLOG(( 3, _L("  aKeyEvent.iModifiers(%d)"), aKeyEvent.iModifiers ));

    CLOG(( 3, _L("  aKeyEvent.iRepeats(%d)"), aKeyEvent.iRepeats ));

    CLOG(( 3, _L("  aType(%d)"), aType ));

    TKeyResponse result = EKeyWasNotConsumed;

    if (

        ( aKeyEvent.iCode == EKeyOK || aKeyEvent.iCode == EKeyEnter ) &&

        ( !(aKeyEvent.iModifiers & EModifierShift) ) &&

        ( iCurrentCba == R_COD_UI_CBA_ACCEPT_REJECT )

       )

        {

        // Selection key press is same as Accept softkey (provided we have

        // the Accept softkey).

        HandleCommandL( ECodUiCmdAccept );

        result = EKeyWasConsumed;

        }

    else if ( aKeyEvent.iCode == EKeyPhoneEnd &&

              iCurrentCba == R_COD_UI_CBA_ACCEPT_REJECT )

        {

        // Red key press -> Reject.

        HandleCommandL( ECodUiCmdReject );

        result = EKeyWasConsumed;

        }

    else

        {

        result = iView->OfferKeyEventL( aKeyEvent, aType );

        }

    CLOG(( 2, _L("<- CCodAppUi::HandleKeyEventL returns (0x%x)"), \

                                                                    result ));

    return result;

    }

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

// CCodAppUi::HandleResourceChangeL()

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

//

void CCodAppUi::HandleResourceChangeL( TInt aType )

    {

    CAknAppUi::HandleResourceChangeL( aType );

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        iView->SetRect( ClientRect() );

        }

    iView->HandleResourceChange( aType );

    }

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

// CCodAppUi::GetRootPathL()

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

//

void CCodAppUi::GetRootPathL( TDes& aRootPath )

    {

    CLOG(( 2, _L("CCodAppUi::GetRootPathL") ));

    CodDialog::GetRootPathL( aRootPath );

    }

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

// CCodAppUi::StartLoadL()

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

//

void CCodAppUi::StartLoadL( TInt aStatusCode )

    {

    CLOG(( 2, _L("-> CCodAppUi::StartLoadL aStatusCode(%d)"), \

        aStatusCode ));

    __ASSERT_DEBUG( !iWaitNote, CodUiPanic( ECodUiInternal ) );

    TInt resId = R_QTN_CD_WAIT_PLEASE_WAIT;

    if ( aStatusCode == KHttp900Success )

        {

        resId = R_QTN_CD_WAIT_DOWNLOADING;

        }

    else if ( aStatusCode == KHttp921UserAborted )

        {

        resId = R_QTN_CD_WAIT_REJECT;

        }

    iWaitNote = new (ELeave) CCodWaitDialog

        ( REINTERPRET_CAST( CEikDialog**, &iWaitNote ), *this );

    iWaitNote->PrepareLC( R_COD_UI_WAIT_NOTE );

    iWaitNote->SetTextL( resId );

    iWaitNote->RunLD();

    CLOG(( 2, _L("<- CCodAppUi::StartLoadL") ));

    }

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

// CCodAppUi::StartCancelL()

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

//

void CCodAppUi::StartCancelL()

    {

    CLOG(( 2, _L("-> CCodAppUi::StartCancelL") ));

    __ASSERT_DEBUG( iWaitNote, CodUiPanic( ECodUiInternal ) );

    iWaitNote->SetTextL( R_QTN_CD_WAIT_REJECT );

    CLOG(( 2, _L("<- CCodAppUi::StartCancelL") ));

    }

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

// CCodAppUi::ProgressL()

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

//

void CCodAppUi::ProgressL( TInt /*aFinalValue*/, TInt /*aCurrentValue*/ )

    {

    // TODO

    }

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

// CCodAppUi::Done()

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

//

void CCodAppUi::Done( TInt LOG_ONLY( aStatusCode ), TInt LOG_ONLY( aError ) )

    {

    CLOG(( 2, _L("-> CCodAppUi::Done aStatusCode(%d) aError(%d)"), \

        aStatusCode, aError ));

    delete iWaitNote;

    iWaitNote = NULL;

    CLOG(( 2, _L("<- CCodAppUi::Done") ));

    }

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

// CCodAppUi::ConfirmConnectL()

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

//

TBool CCodAppUi::ConfirmConnectL()

    {

    CLOG(( 2, _L("CCodAppUi::ConfirmConnectL") ));

    return CodDialog::ConfirmConnectL();

    }

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

// CCodAppUi::StartConnect()

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

//

void CCodAppUi::StartConnect( TUint32 LOG_ONLY( aIap ) )

    {

    CLOG(( 2, _L("CCodAppUi::StartConnect aIap(%d)"), aIap ));

    }

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

// CCodAppUi::EndConnect()

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

//

void CCodAppUi::EndConnect()

    {

    CLOG(( 2, _L("CCodAppUi::EndConnect") ));

    }

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

// CCodAppUi::WaitForLicenseL()

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

//

void CCodAppUi::WaitForLicenseL()

    {

    CLOG(( 2, _L("CCodAppUi::WaitForLicenseL") ));

    }

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

// CCodAppUi::UserAuthL()

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

//

TBool CCodAppUi::UserAuthL

        (

        const TDesC& LOG_ONLY( aHost ),

        const TDesC& LOG_ONLY( aRealm ),

        TBool LOG_ONLY( aProxyAuth ),

        TDes& aUsername,

        TDes& aPassword

        )

    {

    CLOG(( 2, _L("CCodAppUi::UserAuthL") ));

    CLOG(( 3, _L("  aHost<%S>"), &aHost ));

    CLOG(( 3, _L("  aRealm<%S>"), &aRealm ));

    CLOG(( 3, _L("  aProxyAuth(0x%x)"), aProxyAuth ));

    // Feature dropped - empty implementation.

    aUsername.Zero();

    aPassword.Zero();

    return ETrue;

    }

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

// CCodAppUi::RoapTriggerParsedL()

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

//

void CCodAppUi::RoapTriggerParsedL( const CRoapData& aData )

    {

    CLOG(( 2, _L("-> CCodAppUi::RoapTriggerParsedL") ));

    iRoap = ETrue;

    if ( aData.iContextStatus == Roap::EInvalidContext )

        {

        // No valid RI context, ROAP will involve device registration.

        // User must confirm.

        CLOG(( 4, _L("  invalid context") ));

        CAknQueryDialog* dialog = CAknQueryDialog::NewL();

        dialog->PrepareLC( R_COD_UI_CONFIRM_NOTE );

        HBufC* prompt;

        if ( aData.iRiAlias )

            {

            // "Registration with %U needed. Register phone?"

            HBufC* riAlias16 = CodUtil::ConvertLC( *aData.iRiAlias );

            prompt = StringLoader::LoadL

                ( R_QTN_DRM_QUERY_REGISTER_WITH_U, *riAlias16, iCoeEnv );

            CleanupStack::PopAndDestroy( riAlias16 );

            CleanupStack::PushL( prompt );

            }

        else

            {

            // "Registration with content provider needed. Register phone?"

            prompt = StringLoader::LoadLC

                ( R_QTN_DRM_QUERY_REGISTER_WITH_CP, iCoeEnv );

            }

        dialog->SetPromptL( *prompt );

        CleanupStack::PopAndDestroy( prompt );

        if ( !dialog->RunLD() ) 

            {

            CLOG(( 4, _L("  cancelled") ));

            User::Leave( KErrCancel );

            }

        }

    // Update the wait note with ROAP-specific text.

    TInt resId = 0;

    switch ( aData.iType )

        {

        case Roap::ERegistrationTrigger:

            {

            resId = R_QTN_DRM_WAIT_REGISTERING_DEVICE;