/*

* 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:  Handle special load events such as network connection,

*                deal with non-http or non-html requests

*

*/

// INCLUDE FILES

#include "BrowserLoadObserver.h"

#include "ApiProvider.h"

#include "Display.h"

#include "BrowserContentView.h"

#include "CommonConstants.h"

#include "BrowserAppUi.h"

#include "logger.h"

#include "BrowserWindow.h"

#include "BrowserWindowManager.h"

#include "BrowserDialogsProviderProxy.h"

#include <FeatMgr.h>

#include <mconnection.h>

#include <browserdialogsprovider.h>

#ifdef I__LOG_EVENT_TIME

    // defines a local timer with name 'localTime'

    #define START_TIMER( localTime )  TTime localTime;  localTime.HomeTime();

    // count the elapsed time based on timer 'localTime'

    // and increment number of timers called ( numOfTimer )

    #define STOP_TIMER( localTime, numOfTimer ) \

        TTime locTime__a;  locTime__a.HomeTime(); \

        TInt64 updateTime = locTime__a.MicroSecondsFrom( localTime ).Int64(); \

        LOG_WRITE_FORMAT( "Update time: %d", updateTime ); \

        ++numOfTimer; \

        CBrowserLoadObserver::iTotalUpdateTime += updateTime;

#else  // I__LOG_EVENT_TIME

    // empty macros

    #define START_TIMER( a )

    #define STOP_TIMER( a, b )

#endif  // I__LOG_EVENT_TIME

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

// CBrowserLoadObserver::NewL()

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

//

CBrowserLoadObserver* CBrowserLoadObserver::NewL(

        MApiProvider& aApiProvider,

        CBrowserContentView& aContentView,

        CBrowserWindow& aWindow )

    {

    CBrowserLoadObserver* self = 

        new (ELeave) CBrowserLoadObserver( aApiProvider, aContentView, aWindow );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop();    // self

    return self;

    }

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

// CBrowserLoadObserver::~CBrowserLoadObserver()

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

//

CBrowserLoadObserver::~CBrowserLoadObserver()

    {

    	// iApiProvider, iContentView, iWindow not owned by CBRowserLoadObserver.

		// invalidate pointer for a cleaner/clearer destruction

        iApiProvider = NULL;

        iContentView = NULL;

		iWindow = NULL;

    }

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

// CBrowserLoadObserver::HandleBrowserLoadEventL()

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

//

void CBrowserLoadObserver::HandleBrowserLoadEventL(

        TBrCtlDefs::TBrCtlLoadEvent aLoadEvent,

        TUint aSize,

        TUint16 aTransactionId)

    {

LOG_ENTERFN("CBrowserLoadObserver::HandleBrowserLoadEventL");

LOG_WRITE_FORMAT(" LoadEvent: %d", aLoadEvent );

LOG_WRITE_FORMAT("      Size: %d", aSize );

LOG_WRITE_FORMAT("      TrId: %d", aTransactionId );

LOG_WRITE_FORMAT(" LoadState: %d", iLoadState );

LOG_WRITE_FORMAT("  LoadType: %d", iLoadUrlType );

	if( aLoadEvent == TBrCtlDefs::EEventNewContentDisplayed )

		{

		iWindow->ResetPageOverviewLocalSettingL();

		iWindow->SetImagesLoaded(EFalse);		

        } 

	HandleLoadEventOtherL( aLoadEvent, aSize, aTransactionId );

    }

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

// CBrowserLoadObserver::HandleLoadEventOtherL()

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

//

void CBrowserLoadObserver::HandleLoadEventOtherL(

        TBrCtlDefs::TBrCtlLoadEvent aLoadEvent,

        TUint aSize,

        TUint16 aTransactionId )

    {

#define STATECHECK( a ) { if( (iLoadState & a) == 0 ) break; }

    TInt err( KErrNone );

    switch( aLoadEvent )

        {

        case TBrCtlDefs::EEventLoadError:

            {

            if(LoadStatus( ELoadStatusSecurePage ))

                {

                ClearStatus( ELoadStatusSecurePage );

                ClearStatus( ELoadStatusAllItemIsSecure );

                SetStatus ( ELoadStatusSecurePageVisited );

                UpdateSecureIndicatorL();

                }

            ClearStatus();

            SetStatus( ELoadStatusMainError );

            break;

            }

        case TBrCtlDefs::EEventEnteringSecurePage:

            {

            SetStatus( ELoadStatusSecurePage );

            SetStatus( ELoadStatusAllItemIsSecure );

            UpdateSecureIndicatorL();

            break;

            }

        case TBrCtlDefs::EEventSomeItemsNotSecure:

            {

            ClearStatus( ELoadStatusAllItemIsSecure );

            UpdateSecureIndicatorL();

            break;

            }

        case TBrCtlDefs::EEventSecureItemInNonSecurePage:

            {

            SetStatus( ELoadStatusSecureItemNonSecurePage );

            UpdateSecureIndicatorL();

            break;

            }

        case TBrCtlDefs::EEventExitingSecurePage:

        case TBrCtlDefs::EEventSubmittingToNonSecurePage:

            {

            ClearStatus( ELoadStatusSecurePage );

            ClearStatus( ELoadStatusAllItemIsSecure );

            SetStatus ( ELoadStatusSecurePageVisited );

            UpdateSecureIndicatorL();

            break;

            }

        case TBrCtlDefs::EEventTitleAvailable:

            {

            SetStatus( ELoadStatusTitleAvailable );

            NewTitleAvailableL();

            break;

            }

        case TBrCtlDefs::EEventNewContentStart:

            {

#ifdef I__LOG_EVENT_TIME

            iStartDownloadTime.HomeTime();

            iTotalUpdateTime = 0;

            iNumberOfUpdates = 0;

#endif  // I__LOG_EVENT_TIME

            StateChange( ELoadStateResponseInProgress );

            iApiProvider->SetProgressShown( ETrue );

            iApiProvider->Display().StartProgressAnimationL();

            // in case we're in bookmarks view and a background page load is in

            // progress, don't update the softkeys

            if( iApiProvider->IsForeGround() && InBrowserContentView() )

                {

                if( CBrowserAppUi::Static()->ActiveView() )

                    {

                    CBrowserAppUi::Static()->ActiveView()->UpdateCbaL();

                    }

                }

            iApiProvider->WindowMgr().NotifyObserversL( EWindowLoadStart, iWindow->WindowId() );

            break;

            }

        case TBrCtlDefs::EEventUrlLoadingStart:

            {

            STATECHECK( ELoadStateResponseInProgress )

            iApiProvider->Display().StartProgressAnimationL();

            // If the load is not initiated from the bookmarks view (ie. engine initiated

            // via some timer on a page like cnn.com) then don't change view to content view

            if (iBrowserInitLoad)

                {

                iApiProvider->SetViewToBeActivatedIfNeededL(KUidBrowserContentViewId);

                iBrowserInitLoad = EFalse;

                }

            // add transaction to ProgressBar

            iApiProvider->Display().AddTransActIdL( aTransactionId );    

            // Display the status pane, while loading

            if ( InBrowserContentView() && iContentView->FullScreenMode() )

                {

                iContentView->ShowFsStatusPane(ETrue);

                }

            break;

            }

        // first content chunk arrived

        case TBrCtlDefs::EEventNewUrlContentArrived:

            {

            STATECHECK( ELoadStateResponseInProgress )

            SetStatus( ELoadStatusFirstChunkArrived );

            // set MaxData for this transaction

            iApiProvider->Display().AddProgressDataL(

                aTransactionId, 0, aSize );

            break;

            }

        // additional content chunk arrived

        case TBrCtlDefs::EEventMoreUrlContentArrived:

            {

            STATECHECK( ELoadStateResponseInProgress )

            START_TIMER( t1 );

            // set RecvdData for this transaction

            iApiProvider->Display().AddProgressDataL(

                aTransactionId, aSize, 0 );

            if( iApiProvider->IsForeGround() )

                {

                iApiProvider->Display().NotifyProgress();

                }

            STOP_TIMER( t1, iNumberOfUpdates );

            break;

            }

        // content is processed, new fetch is allowed.

        // some more event may still remain

        case TBrCtlDefs::EEventContentFinished:

            {

            StateChange( ELoadStateIdle );

            if( !ContentDisplayed() )

                {

                SetContentDisplayed( ETrue );

                }

            if( !iApiProvider->ExitInProgress() && 

                iApiProvider->IsForeGround() )

                {

                iApiProvider->Display().StopProgressAnimationL();

                }

            User::ResetInactivityTime();

            if( LoadUrlType() == ELoadUrlTypeEmbeddedBrowserWithUrl &&

                !LoadStatus( ELoadStatusFirstChunkArrived ) && 

                !iApiProvider->ExitInProgress() )

                {

                // Don't do anything; let the embedder close the browser

                }

            // No content to be shown, go back to where we came from

            else if ( !iRestoreContentFlag  )

                {

                CBrowserAppUi::Static()->ActivateLocalViewL( 

                                            iApiProvider->LastActiveViewId() );

                if( iApiProvider->IsForeGround() )

                    {

                    if  ( CBrowserAppUi::Static()->ActiveView() )

                        {

                        CBrowserAppUi::Static()->ActiveView()->UpdateCbaL();

                        }

                    }

                }                        

            else

                {

                ContentArrivedL();

                // in case we're in bookmarks view and a background page load is in

                // progress, don't update the softkeys

                if( iApiProvider->IsForeGround() && InBrowserContentView() )

                    {

                    if  ( CBrowserAppUi::Static()->ActiveView() )

                        {

                        CBrowserAppUi::Static()->ActiveView()->UpdateCbaL();

                        }

                    }

                }

#ifdef I__LOG_EVENT_TIME

            TTime endDownloadTime;

            endDownloadTime.HomeTime();

            TInt64 dlTime = endDownloadTime.MicroSecondsFrom(iStartDownloadTime).Int64();

            LOG_WRITE_FORMAT( "Total download time: %d", dlTime );

            LOG_WRITE_FORMAT( "Total update time: %d", iTotalUpdateTime );

            LOG_WRITE_FORMAT( "Total number of updates: %d", iNumberOfUpdates );

            if( iNumberOfUpdates )

                {

                LOG_WRITE_FORMAT( "Average update time: %d", 

                    iTotalUpdateTime / iNumberOfUpdates );

                }

            if( dlTime )

                {

                LOG_WRITE_FORMAT( "Total update time (%% of download time): %d",

                    iTotalUpdateTime / (dlTime / 100) );

                }

#endif  // I__LOG_EVENT_TIME

            break;

            }

        // first chunk displayed, no parameter

        case TBrCtlDefs::EEventNewContentDisplayed:

            {

            iApiProvider->WindowMgr().SetContentExist( ETrue );

            SetStatus( ELoadStatusFirstChunkDisplayed );

            SetRestoreContentFlag( ETrue );

            ContentArrivedL();

            if( !ContentDisplayed() )

                {

                SetContentDisplayed( ETrue );

                }

            break;

            }

        // additional chunk displayed, no parameter

        case TBrCtlDefs::EEventMoreContentDisplayed:

            {

            SetStatus( ELoadStatusContentDisplayed );

            SetRestoreContentFlag( ETrue );

            ContentArrivedL();

            break;

            }

        // last chunk arrived

        case TBrCtlDefs::EEventUrlLoadingFinished:

            {

            iApiProvider->Display().TransActIdComplete( aTransactionId );

			SetRestoreContentFlag( ETrue );

            ContentArrivedL();

			TRAP( err, iApiProvider->LogAccessToRecentUrlL( iWindow->BrCtlInterface() ) );            

            break;

            }

        case TBrCtlDefs::EEventLoadFinished:

            {

            if( !iApiProvider->ExitInProgress() &&

                iApiProvider->IsForeGround() )

                {

                iApiProvider->Display().StopProgressAnimationL();

                // Turn off status pane, SK, and Cba 

                // If in content view, set to fullscreen after download complete

                if ( InBrowserContentView() && iContentView->FullScreenMode() )

                    {

                    iContentView->ShowFsStatusPane(EFalse);

                    }

                }

            iApiProvider->WindowMgr().NotifyObserversL( EWindowLoadStop, iWindow->WindowId() );

            break;

            }

        case TBrCtlDefs::EEventAuthenticationFailed:

            {

            // don't add url to Adaptive Bookmarks

            ClearStatus( ELoadStatusFirstChunkArrived );

            break;

            }

        // Large file upload events

		case TBrCtlDefs::EEventUploadStart:

			{

			iMaxUploadContent = aSize;

            iWindow->DialogsProviderProxy().UploadProgressNoteL( 

                iMaxUploadContent, 0, EFalse, this );

			break;

			}

		case TBrCtlDefs::EEventUploadIncrement:

			{

            iWindow->DialogsProviderProxy().UploadProgressNoteL( 

                iMaxUploadContent, aSize, EFalse, this );

			break;

         	}

		case TBrCtlDefs::EEventUploadFinished:

			{

            iWindow->DialogsProviderProxy().UploadProgressNoteL( 

                iMaxUploadContent, aSize, ETrue, this ); 

			break;         

			}

        default:

            break;

        }

#undef STATECHECK

    }

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

// CBrowserLoadObserver::CBrowserLoadObserver()

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

//

CBrowserLoadObserver::CBrowserLoadObserver(

        MApiProvider& aApiProvider,

        CBrowserContentView& aContentView,

        CBrowserWindow& aWindow ) :

    iApiProvider( &aApiProvider ),

    iContentView( &aContentView ),

    iWindow( &aWindow ),

    iLoadState( ELoadStateIdle ),

    iLoadUrlType( ELoadUrlTypeOther ),

    iStatus( 0 )

    {

    }

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

// CBrowserLoadObserver::ConstructL()

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

//

void CBrowserLoadObserver::ConstructL()

    {

    }

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

// CBrowserLoadObserver::DoStartLoad()

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

//

void CBrowserLoadObserver::DoStartLoad(

        TBrowserLoadUrlType aLoadUrlType )

    {

/*

LOG_WRITE("-------------------")

LOG_WRITE_FORMAT(" UrlType: %d ", aLoadUrlType )

*/

    // __ASSERT_DEBUG instead of condition?

    if( iLoadState == ELoadStateIdle )

        {                

        if (LoadStatus(ELoadStatusSecurePageVisited))

            {

            ClearStatus();  

            SetStatus(ELoadStatusSecurePageVisited);  

            }

        else 

            {

            ClearStatus();            

            }        

        iLoadUrlType = aLoadUrlType;

        iRestoreContentFlag = EFalse;

        }

    iBrowserInitLoad = ETrue;

    }

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

// CBrowserLoadObserver::DoEndLoad()

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

//

void CBrowserLoadObserver::DoEndLoad(

        TBool aIsUserInitiated )

    {

// LOG_WRITE( "Cancelling.")

    if( aIsUserInitiated)

        {

        // wait for the remaining load events

        StateChange( ELoadStateLoadDone );

        }

    else  // don't wait for anything

        {

        StateChange( ELoadStateIdle );

        }

    // first arrives ContentFinished and then UrlLoadingFinished!

    // what to do with status?

    // updatesoftkeys()  done in appui

    CBrowserViewBase* view = CBrowserAppUi::Static()->ActiveView();

    if( view ) // just to be sure

        {

        TVwsViewId activeViewId = view->ViewId();

        if( activeViewId.iViewUid == KUidBrowserBookmarksViewId)

            {

            SetRestoreContentFlag( EFalse );

            }

        }

    }

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

// CBrowserLoadObserver::NewTitleAvailableL()

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

//

void CBrowserLoadObserver::NewTitleAvailableL()

    {

    if( iWindow->IsWindowActive() )

        {

        CBrowserViewBase* view = CBrowserAppUi::Static()->ActiveView();        

         if( view ) // just to be sure

              {

              TVwsViewId activeViewId = view->ViewId();

              if( activeViewId.iViewUid == KUidBrowserContentViewId )

                  {

                  iContentView->UpdateTitleL( *iApiProvider );

                  }

              }

        }

    SetRestoreContentFlag( ETrue );

    }

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

// CBrowserLoadObserver::InBrowserContentView()

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

//

TBool CBrowserLoadObserver::InBrowserContentView()

    {

    CBrowserViewBase* view = CBrowserAppUi::Static()->ActiveView();        

    if( view ) // just to be sure

        {

        TVwsViewId activeViewId = view->ViewId();

        return ( activeViewId.iViewUid == KUidBrowserContentViewId );

        }

    return EFalse;

    }

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

// CBrowserLoadObserver::ContentArrivedL()

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

//

void CBrowserLoadObserver::ContentArrivedL()

    {

    if( iApiProvider->Connection().Connected()

        && iApiProvider->Preferences().HttpSecurityWarningsStatSupressed() )

        {

        TInt secureUpdate = EAknIndicatorStateOff;

        if( LoadStatus( ELoadStatusSecurePage ) )

            {

            if( LoadStatus( ELoadStatusAllItemIsSecure ) )

                {