/*

* 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:    LandmarksUi Content File -    Provides LM UI class methods.

*

*/

// INCLUDE FILES

#include "CLmkMsgViewerAppUi.h"

#include "CLmkMsgViewerAppView.h"

#include "landmarks.hrh"

#include "CLmkMsgViewerDocument.h"

#include "CLmkParser.h"

#include "CLmkSender.h"

#include "CLmkPackageEditorImpl.h"

#include "CLmkDlgPackageSelectorImpl.h"

#include "LmkConsts.h"

#include "CLmkEditorDlg.h"

#include <AknsUtils.h>

#include <AknWaitDialog.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <lmkmsgviewer.rsg>

#include <aknnotewrappers.h>

#include <StringLoader.h>

#include "LmkNotes.h"

#include <lmkerrors.h>

#if defined(_DEBUG)

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

_LIT( KPanicMsg, "CLmkMsgViewerAppUi");

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

}  // namespace

#endif

// Constant for periodic timer

const TInt KOneMicroSec = 1;

// ================= LOCAL FUNCTIONS =======================

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

// ErrorNoteL

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

//

void ErrorNoteL(const TInt aResourceId)

    {

    HBufC* noteText = CEikonEnv::Static()->AllocReadResourceLC(aResourceId);

    CAknErrorNote* dialog =

        new( ELeave ) CAknErrorNote( R_AKN_INFORMATION_NOTE_WAIT );

    dialog->ExecuteLD( *noteText );

    CleanupStack::PopAndDestroy(noteText); //noteText

    }

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

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

// CLmkMsgViewerAppUi::ConstructL

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

//

void CLmkMsgViewerAppUi::ConstructL()

    {

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible);

    iAppView = CLmkMsgViewerAppView::NewL( ClientRect() );

    // Start an idle timer to start the dialog synchronously.

    iIdleTimer = CPeriodic::NewL(CActive::EPriorityIdle);

    iIdleTimer->Start(KOneMicroSec, KOneMicroSec,

        TCallBack(CallBackFuncL,this));

    }

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

// CLmkMsgViewerAppUi::~CLmkMsgViewerAppUi

// Destructor

// Frees reserved resources

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

//

CLmkMsgViewerAppUi::~CLmkMsgViewerAppUi()

    {

    if ( iIdleTimer )

        {

        delete iIdleTimer;

        iIdleTimer = NULL;

        }

    TInt err = KErrNone;

    TRAP(err, CloseWaitNoteL());

    delete iAppView;

    delete iLmkSender;

    delete iParser;

    delete iDb;

    if( iDoorObserver )

        {

        iDoorObserver->NotifyExit( MApaEmbeddedDocObserver::EEmpty );

        }

    }

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

// CLmkMsgViewerAppUi::HandleCommandL

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

//

void CLmkMsgViewerAppUi::HandleCommandL( TInt aCommand )

    {

    switch ( aCommand )

        {

        // these all are same: save & exit

        case EAknSoftkeyBack:

        case EAknSoftkeyExit:

        case EAknCmdExit:

        case EEikCmdExit:

            {

            Exit();

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CLmkMsgViewerAppUi::LmkSender

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

//

CLmkSender& CLmkMsgViewerAppUi::LmkSender() const

    {

    __ASSERT_DEBUG( iLmkSender, Panic( KLmkPanicNullMember ) );

    return *iLmkSender;

    }

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

// CLmkMsgViewerAppUi::OpenFileL

// This is called by framework when application is already open in background

// and user opens other file

// New file to been shown is passed via aFileName.

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

//

void CLmkMsgViewerAppUi::OpenFileL( const TDesC& aFileName )

	{

	// File changed.

    // TODO: What to do with the possibly existing package?

    // Should we just leave or do something else?

    if ( iParser )

        {

        User::Leave( KErrAlreadyExists );

        }

    else

        {

        Document()->OpenFileL( EFalse, aFileName, iEikonEnv->FsSession() );

        }

	}

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

// CLmkMsgViewerAppUi::OpenFileL

// This is called by framework when application is already open in background

// and user opens other file

// New file to been shown is passed via aFileName.

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

//

void CLmkMsgViewerAppUi::OpenFileL(RFile& aFileHandle )

	{

	// File changed.

    if ( iParser )

        {

        User::Leave( KErrAlreadyExists );

        }

    else

        {

        CFileStore* aFileStore = NULL;

        static_cast<CLmkMsgViewerDocument*>(Document())->OpenFileL(aFileStore, aFileHandle);

        }

	}

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

// CLmkMsgViewerAppUi::ProcessCommandParametersL

// This method must return true or documents OpenFileL() get wrong file name.

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

//

TBool CLmkMsgViewerAppUi::ProcessCommandParametersL(

    TApaCommand /*aCommand*/,

	TFileName& /*aDocumentName*/,

	const TDesC8& /*aTail*/ )

    {

    // Never call CEikAppUi::ProcessCommandParametersL(..) because

    // it is so harmful to overwrite and destroy aDocumentName.

	// Return ETrue so that CLmkMsgViewerAppUi::OpenFileL() gets

    // the right document name.

    return ETrue;

    }

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

// CLmkMsgViewerAppUi::HandleOperationL

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

//

void CLmkMsgViewerAppUi::HandleOperationL(

    TOperationTypes aType,

    TReal32 /*aProgress*/,

    TInt aStatus )

    {

    __ASSERT_DEBUG( ( aType == EInitialize ||

                      aType == EParse ) &&

                    aStatus != KPosLmOperationNotComplete,

                    Panic( KLmkPanicAlreadyActive ) );

    TInt err = KErrNone;

    if (aType == EInitialize)

        {

        TRAP(err, HandleDbInitFinishedL(aStatus));

        }

    else // (aType == EParse)

        {

        TRAP(err, HandleParseFinishedL(aStatus));

        }

    if (err)

        {

        CloseWaitNoteL(); // when wait note closes, application exits

        }

    }

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

// CLmkMsgViewerAppUi::HandleDbInitFinishedL

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

//

void CLmkMsgViewerAppUi::HandleDbInitFinishedL( TInt aStatus )

    {

    if (aStatus != KErrNone)

        {

        CCoeEnv::Static()->HandleError(aStatus);

        User::Leave(aStatus);

        }

    iParser->StartParsingL();

    }

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

// CLmkMsgViewerAppUi::HandleParseFinishedL

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

//

void CLmkMsgViewerAppUi::HandleParseFinishedL( TInt aStatus )

    {

    if (aStatus != KErrNone)

        {

        ErrorNoteL(R_LMK_BADPACKAGE_ERROR);

        User::Leave(aStatus);

        }

    // now everything's ready for viewing

    iDataReadyForView = ETrue;

    CloseWaitNoteL(); // when wait note closes, view dialog opens

    }

void CLmkMsgViewerAppUi::CloseWaitNoteL()

    {

    if (iWaitDialog)

        {

        iWaitDialog->ProcessFinishedL();

        iWaitDialog = NULL;

        }

    }

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

// CLmkMsgViewerAppUi::ExecuteLmViewerL

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

//

void CLmkMsgViewerAppUi::ExecuteLmViewerL()

    {

    __ASSERT_DEBUG( iParser->NumOfParsedLandmarks() == 1,

                    Panic( KLmkPanicOutOfRange ) );

    CLmkPackageEditorImpl* editorImpl =

        CLmkPackageEditorImpl::NewL( *iDb, *iParser, *iLmkSender, 0 );

    // Parser observing responsibility is given to the lm viewer,

    // application is not interested in it anymore:

    iParser->ChangeObserver( *editorImpl );

    editorImpl->ExecuteLD();

    }

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

// CLmkMsgViewerAppUi::ExecutePkgViewerL

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

//

void CLmkMsgViewerAppUi::ExecutePkgViewerL()

    {

    __ASSERT_DEBUG( iParser->NumOfParsedLandmarks() > 1,

                    Panic( KLmkPanicOutOfRange ) );

    CLmkDlgPackageSelectorImpl* pkgViewer =

        CLmkDlgPackageSelectorImpl::NewL( *iDb, *iParser, *iLmkSender );

    CleanupStack::PushL( pkgViewer );

    // Parser observing responsibility is given to the package viewer,

    // application is not interested in it anymore:

    iParser->ChangeObserver( *pkgViewer );

    CArrayFix<TInt>* selectedItems =

        new( ELeave ) CArrayFixFlat<TInt>( KLmkMultiSelectionGranularity );

    CleanupStack::PushL( selectedItems );

    pkgViewer->ExecuteL( *selectedItems,  iParser->PackageName());

    CleanupStack::PopAndDestroy( selectedItems );

    CleanupStack::PopAndDestroy( pkgViewer );

    }

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

// CLmkMsgViewerAppUi::OpenL

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

//

void CLmkMsgViewerAppUi::OpenL( const TDesC& aFilename )

    {

    iParser = CLmkParser::NewL( aFilename, *iDb, *this, EFalse );

    DoOpenL();

    Exit();

    }

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

// CLmkMsgViewerAppUi::OpenL

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

//

void CLmkMsgViewerAppUi::OpenL(RFile& aFile)

    {

    iParser = CLmkParser::NewL( aFile, *iDb, *this, EFalse );

    DoOpenL();

    Exit();

    }

void CLmkMsgViewerAppUi::DoOpenL()

    {

    // We need to initialize db before we start parsing:

    iParser->InitializeDbL();

    iWaitDialog = new( ELeave ) CAknWaitDialog( NULL, ETrue );

    if (!iWaitDialog->ExecuteLD( R_LMK_MSGVIEWER_WAIT ))

        {

        //making iWaitDialog null, since framework destroys waitnote

        //dialog on pressing cancel.

        iWaitDialog = NULL;

        }

    if( iDataReadyForView )

        {

        if ( iParser->NumOfParsedLandmarks() == 1 )

            {

            ExecuteLmViewerL();

            }

        else if ( iParser->NumOfParsedLandmarks() > 1 )

            {

            ExecutePkgViewerL();

            }

        else

            {

            // exit

            }

        }

    }

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

// CLmkMsgViewerAppUi::CallBackFuncL()

// Used to callback by the idle timer in order to launch

// the dialog

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

//

TInt CLmkMsgViewerAppUi::CallBackFuncL(TAny *aPtr)

    {

    CLmkMsgViewerAppUi* appUi =

        static_cast< CLmkMsgViewerAppUi* >( aPtr );

    if ( appUi )

        {

        return ( appUi->LaunchDialogL() );

        }

    else

        {

        // To indicate that the timer is not

        // called again, return false to the timer

        // RunL

        return ( EFalse );

        }

    }

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

// CLmkMsgViewerAppUi::LaunchDialogL()

// This function accesses the document and launches the

// content.

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

//

TBool CLmkMsgViewerAppUi::LaunchDialogL()

	{

	if(!iIsDbOpen)

		{

		// Try to open DB

		TRAPD( err, iDb = CPosLandmarkDatabase::OpenL() );

    	if( KErrNone != err )

    		{

    		// Cancel the periodic timer

        	if ( iIdleTimer->IsActive() )

            	{

            	iIdleTimer->Cancel();

            	}

            // Display general system error note

		    HBufC* noteText = StringLoader::LoadL( R_LMK_ERR_EIKON_GENERAL, iEikonEnv );

		    CleanupStack::PushL( noteText );

	    	CAknErrorNote* dialog = new(ELeave)CAknErrorNote( ETrue );

		    dialog->SetTone( CAknNoteDialog::EErrorTone );

		    dialog->ExecuteLD( *noteText );

	   		CleanupStack::PopAndDestroy( noteText ); //noteText

	   		// exit LmkMsgViewer app

		    Exit();

		    }

    	    // DB was opened successfully

    	    iIsDbOpen = ETrue;

    		iLmkSender = CLmkSender::NewL( *iDb );

    	}

	CLmkMsgViewerDocument* document =

	    static_cast<CLmkMsgViewerDocument*>(iDocument);

	// Check if file-handle in document is valid

	if (document->IsFileHandleValid())

		{

		// Obtain the file-handle

		RFile& fileHandle = document->GetLandmarkContentFileHandle();

        // Cancel the periodic timer

        if ( iIdleTimer->IsActive() )

            {

            iIdleTimer->Cancel();

            }

		// Launch the content

		TRAPD(err,OpenL(fileHandle));

		if(err != KErrNone)

			{

			if( err == KErrNotSupported)

				{

				LmkNotes::InformationNoteL( iEikonEnv, R_LMK_BADPACKAGE_ERROR );

				}

			Exit();

			}

		// Delete and reset the idle-timer

        delete iIdleTimer;

        iIdleTimer = NULL;

		// Return False to indicate that

		// timer need not callback further.

		return EFalse;

		}

	else

		{

		// Return True to indicate that the

		// timer needs to callback this function

		// again, as the file-handle is not valid

		// yet.

		return ETrue;

		}

	}

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

// CLmkMsgViewerAppUi::HandleResourceChangeL()

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

//

void CLmkMsgViewerAppUi::HandleResourceChangeL(TInt aType)

    {

     CAknAppUi::HandleResourceChangeL( aType );

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        iAppView->SetRect(ClientRect());

        }

    }

// End of File