/*

* 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 "BrowserContentView.h"  // not used, to be removed

#include "BrowserSpecialLoadObserver.h"

#include "BrowserLoadObserver.h"

#include "logger.h"

#include "BrowserAppDocument.h"

#include "ApiProvider.h"

#include "Preferences.h"

#include "BrowserUIVariant.hrh"

#include "Display.h"

#include "BrowserAppUi.h"

#include "BrowserWindow.h"

#include "BrowserWindowManager.h"

#include "CommonConstants.h"

#ifdef __WINS__

    #include <commdb.h>

    #include <aknselectionlist.h>

    #include <AknLists.h>

#endif // __WINS__

#include <DocumentHandler.h>

#include <schemehandler.h>

#include <BrowserNG.rsg>

#include <FeatMgr.h>

#include <AiwGenericParam.h>

#include <aknnavi.h>

//CONSTANTS

const TInt KMaxDocHandlerUrlLen = 255;

//DestNetChange

#include <CmApplicationSettingsUi.h>

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

// CBrowserSpecialLoadObserver::NewL()

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

//

CBrowserSpecialLoadObserver* CBrowserSpecialLoadObserver::NewL(

        MApiProvider& aApiProvider,

        CBrowserWindow* aWindow,

        CEikDocument* aDocument,

        CBrowserContentView* aContentView )

    {

    CBrowserSpecialLoadObserver* self = 

        new (ELeave) CBrowserSpecialLoadObserver(

            aApiProvider, aWindow, aDocument, aContentView );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop();  // self

    return self;

    }

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

// CBrowserSpecialLoadObserver::~CBrowserSpecialLoadObserver()

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

//

CBrowserSpecialLoadObserver::~CBrowserSpecialLoadObserver()

    {

    delete iSchemeHandler;

    delete iDocHandler;

    }

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

// CBrowserSpecialLoadObserver::CBrowserSpecialLoadObserver()

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

//

CBrowserSpecialLoadObserver::CBrowserSpecialLoadObserver(

        MApiProvider& aApiProvider,

        CBrowserWindow* aWindow,

        CEikDocument* aDocument,

        CBrowserContentView* aContentView ) : 

    iApiProvider( &aApiProvider ),

    iWindow( aWindow ),

    iDocument( aDocument ),

    iSchemeHandler( NULL ),

    iContentView( aContentView ),

    iSchemeProcessing( EFalse ),

    iLongZeroStartup( EFalse ),

    iConnectionStarted( EFalse )

    {

    }

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

// CBrowserSpecialLoadObserver::ConstructL()

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

//

void CBrowserSpecialLoadObserver::ConstructL()

    {

    }

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

// CBrowserSpecialLoadObserver::NetworkConnectionNeededL()

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

//

void CBrowserSpecialLoadObserver::NetworkConnectionNeededL(

        TInt* aConnectionPtr,

        TInt* aSockSvrHandle,

        TBool* aNewConn,

        TApBearerType* aBearerType )

    {

LOG_ENTERFN("CBrowserSpecialLoadObserver::NetworkConnectionNeededL");

	__ASSERT_DEBUG( (aConnectionPtr != NULL), Util::Panic( Util::EUninitializedData ) );

	__ASSERT_DEBUG( (aSockSvrHandle != NULL), Util::Panic( Util::EUninitializedData ) );

	__ASSERT_DEBUG( (aNewConn != NULL), Util::Panic( Util::EUninitializedData ) );

	__ASSERT_DEBUG( (aBearerType != NULL), Util::Panic( Util::EUninitializedData ) );

    iApiProvider->SetProgressShown( ETrue );

    TBool query( EFalse );

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

        {

        TInt a( iWindow->WindowId() );

		BROWSER_LOG( ( _L( "already connected, WindowId: %d" ), a ) );

        *aConnectionPtr = (TInt) &iApiProvider->Connection().Connection();

        *aSockSvrHandle = iApiProvider->Connection().SocketServer().Handle();

        *aNewConn = EFalse;

        *aBearerType = iApiProvider->Connection().CurrentBearerTypeL();

        }

    else

        {

		BROWSER_LOG((_L("not connected.")));

        *aNewConn = ETrue;

        TBool isValid( EFalse );

        TUint32 ap( 0 );

        TInt err( KErrNone );

		BROWSER_LOG((_L("AP selectionMode: %d."),

    	iApiProvider->Preferences().AccessPointSelectionMode() ));

       //determine the type of connection

        switch (iApiProvider->Preferences().AccessPointSelectionMode() )

        	{

        	case EAlwaysAsk:

        		{

	            BROWSER_LOG((_L("always ask.")));

	            // Always ask

	            isValid = ETrue;

	        	break;	

        		}

        	case EDestination:

        		{

                isValid = ETrue;  // force to show LAN connection dialog

#ifdef __WINS__

                query = ETrue;  // disable connection query dialog

#endif  // __WINS__

                // for bug fix MLAN-7EKFV4, if bookmark has defined its AP, use it

                if ( iApiProvider->RequestedAp() != KWmlNoDefaultAccessPoint )

                    {

                    #ifndef __WINS__

                                        ap = Util::IapIdFromWapIdL(

                                            *iApiProvider, iApiProvider->RequestedAp() );

				                        BROWSER_LOG((_L("ap: %d"), ap));

                    #else  // __WINS__

                                        // On WINS no need to convert the AP ID

                                        ap = iApiProvider->RequestedAp();

                    #endif // __WINS__

                    iApiProvider->Connection().SetRequestedAP( ap );

                    iApiProvider->Connection().SetConnectionType( EConnectionMethod );

                    }

                else

                    {

                    TUint32 snapId = iApiProvider->Preferences().DefaultSnapId();

                    //connection type is destination nw 

                    iApiProvider->Connection().SetConnectionType( EDestination );

                    //set snap id

                    iApiProvider->Connection().SetRequestedSnap( snapId );        		        		

                    }

                break;	

        		}

        	case EConnectionMethod:

        		{

        		BROWSER_LOG((_L("user defined.")));

                // User defined

                TRAP( err, isValid = Util::CheckApValidityL( *iApiProvider, 

                    iApiProvider->RequestedAp() ));

			    BROWSER_LOG((_L("isValid 1: %d"), isValid));

			    BROWSER_LOG((_L("err: %d"), err));

                if( isValid )

                    {  // valid AP, get it

#ifndef __WINS__

                    ap = Util::IapIdFromWapIdL(

                        *iApiProvider, iApiProvider->RequestedAp() );

				    BROWSER_LOG((_L("ap: %d"), ap));

#else  // __WINS__

                    // On WINS no need to convert the AP ID

                    ap = iApiProvider->RequestedAp();

#endif // __WINS__

                    }

                else if( err == KErrNone )

                    {  // still try to get AP

                    TUint apUid = iApiProvider->Preferences().DefaultAccessPoint();

				    BROWSER_LOG((_L("apUid: %d"), apUid));

                    if ( apUid == KWmlNoDefaultAccessPoint )

                        {

#ifdef __WINS__

                        query = ETrue;  // disable connection query dialog

                        isValid = ETrue;  // force to show LAN connection dialog

#else  // __WINS__

						BROWSER_LOG((_L("StartPrefView.")));

                        //  there are no AP, show preferences view without always ask

                        isValid  = iApiProvider->StartPreferencesViewL( EShowDestinations | EShowConnectionMethods );

                        if( isValid )

                            {

                            if( iApiProvider->Preferences().AccessPointSelectionMode() == EConnectionMethod )

                                {

                       		    ap = iApiProvider->Preferences().DefaultAccessPoint();

                                }

                            // else if EDestination, user choosed SNAP in preference view

                            }

#endif  // __WINS__

                        }

                    }

                //set connection type and AP or SNAP Id                     

                if( iApiProvider->Preferences().AccessPointSelectionMode() == EDestination )

                    {

                    TUint32 snapId = iApiProvider->Preferences().DefaultSnapId();

                    iApiProvider->Connection().SetConnectionType( EDestination );

                    iApiProvider->Connection().SetRequestedSnap( snapId );        		        		

                    }

                else // EConnectionMethod

                    {

                    iApiProvider->Connection().SetRequestedAP( ap );

                    iApiProvider->Connection().SetConnectionType( EConnectionMethod );

                    }

        		break;	

        		}

        	default:

        		{

        		BROWSER_LOG((_L("wrong type of connection")));	

        		}

        	} //switch	

		BROWSER_LOG((_L("isValid 2: %d"), isValid));

        if( isValid )

            {

            iConnectionCancelled = EFalse;

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

                {

                iApiProvider->Connection().SetRequestedAP( ap );

                TBool startPage = iWindow->LoadObserver().LoadUrlType() == 

                                    CBrowserLoadObserver::ELoadUrlTypeStartPage;

                TBool noConnDlgs = !iApiProvider->Preferences().ShowConnectionDialogs();

                // Disable connection dialogs if...

                TBool disableConnDlgs = 

                        query ||

                        startPage ||    // ...the load type is StartPage

                        noConnDlgs ||   // ...connection dialogs setting = OFF

                        LongZeroStartup();  // ...Browser started with long zero keypress

                SetLongZeroStartup( EFalse );

				BROWSER_LOG((_L("StartConnection params, query: %d, temp: %d"), query, disableConnDlgs));

                iConnectionStarted = ETrue; // is true when connection request submited.

                // might leave, don't TRAP. OK.

                err = iApiProvider->Connection().StartConnectionL( disableConnDlgs );

                iConnectionStarted = EFalse; // is false when connection response completed.

                }

            // during StartConnectionL user pressing "Stop" can cancel

            if (iConnectionCancelled)

                {

                err = KErrCancel;

                }

            BROWSER_LOG((_L("err after StartConnection: %d"), err));

            if( err == KErrNone )

                {

                *aConnectionPtr = (TInt) &iApiProvider->Connection().Connection();

                *aSockSvrHandle = iApiProvider->Connection().SocketServer().Handle();

                *aBearerType = iApiProvider->Connection().CurrentBearerTypeL();

                }

            CBrowserAppUi::Static()->ConnNeededStatusL( err );

            if (( err == KErrCancel ) && !iApiProvider->IsPageLoaded())

                {                

	          	// Close Browser's Content View window if connection setup is cancelled to avoid a blank white screen

                //  ** Don't do this is page was previously loaded and is visible to user.

				// ALSO, if feeds are enabled, don't close the window if coming from feeds folder view

				// or in topic or feed views

				// *** Changing back to CloseContentView as a part of the new Browser exit functionality				   

#ifdef __RSS_FEEDS

 				TUid previousViewID = iApiProvider->LastActiveViewId();

                if( (previousViewID != KUidBrowserFeedsFolderViewId) &&

                	(previousViewID != KUidBrowserFeedsTopicViewId) &&

                	(previousViewID != KUidBrowserFeedsFeedViewId) )

                	{

                	iApiProvider->Display().NaviPaneL()->Pop();

        	        CBrowserAppUi::Static()->CloseContentViewL();

                	}

#else //__RSS_FEEDS           

                CBrowserAppUi::Static()->CloseContentViewL();

#endif //__RSS_FEEDS

                }

            else if( err == KErrGeneral )

                {

                if( !iApiProvider->Preferences().HttpSecurityWarningsStatSupressed() )

                    {

                    iWindow->Display().UpdateSecureIndicatorL(

                        EAknIndicatorStateOff );

                    }

                }

            // user might cancel, pass result to BrowserEngine

            User::LeaveIfError( err );

            iApiProvider->Display().StartProgressAnimationL();

            }

        else

            {

            User::LeaveIfError( err );

            }

        }

    }

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

// CBrowserSpecialLoadObserver::DoHandleRequestL()

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

//

TBool CBrowserSpecialLoadObserver::DoHandleRequestL

    ( RArray<TUint>* aTypeArray, CDesCArrayFlat* aDesArray )

    {

    LOG_ENTERFN("CBrowserSpecialLoadObserver::HandleRequestL");

    if( !iSchemeProcessing )

        {

        iSchemeProcessing = ETrue;

        TBool paramFound( EFalse );

        TPtrC requestUrl = ExtractBrCtlParam( 

            EParamRequestUrl, 

            aTypeArray,

            aDesArray, 

            paramFound );

        __ASSERT_DEBUG( paramFound, Util::Panic( Util::EUninitializedData ) );

        BROWSER_LOG( ( _L( " EParamRequestUrl: %S" ), &requestUrl ) );

        // pass to the CSchemaHandler             

        CSchemeHandler* newSH = CSchemeHandler::NewL( requestUrl );

        delete iSchemeHandler;

        iSchemeHandler = newSH;

        BROWSER_LOG( ( _L( " iSchemeHandler OK" ) ) );

        // construct the current accesspoint

        // if it's connected, always add it 

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

            {

            CAiwGenericParamList* paramsList = CAiwGenericParamList::NewL();

            CleanupStack::PushL(paramsList);

        	TInt32 ap = iApiProvider->Connection().CurrentAPId(); 

        	TAiwVariant paramVariant (ap);

        	TAiwGenericParam genericParam( EGenericParamAccessPoint, paramVariant );

        	paramsList->AppendL (genericParam );

		    // set the parameter

     	    iSchemeHandler->SetParameterList( paramsList );

         	CleanupStack::Pop();

            }

        iSchemeHandler->Observer( this );

        iSchemeHandler->HandleUrlEmbeddedL();

        }

    return ETrue;

    }

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

// CBrowserSpecialLoadObserver::HandleRequestL()

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

//

TBool CBrowserSpecialLoadObserver::HandleRequestL

    ( RArray<TUint>* aTypeArray, CDesCArrayFlat* aDesArray )

    {

    TBool ret( ETrue );

    TRAPD( err, DoHandleRequestL( aTypeArray, aDesArray ) );

    if( KErrNone != err )

        {

        iSchemeProcessing = EFalse;

        User::Leave( err );

        }

    return ret;

    }

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

// CBrowserSpecialLoadObserver::HandleDownloadL()

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

//

TBool CBrowserSpecialLoadObserver::HandleDownloadL

    ( RArray<TUint>* aTypeArray, CDesCArrayFlat* aDesArray )

    {

    LOG_ENTERFN("CBrowserSpecialLoadObserver::HandleDownloadL");

    TBool downloadHandled = EFalse;

#ifdef __RSS_FEEDS

	// Check to see if this is content to be handled by UI (rss or opml)

	//

    if (HandleUiContentL(aTypeArray, aDesArray))

    	{

    	return ETrue;

    	}

#endif  // __RSS_FEEDS

    CBrowserAppDocument* appDoc = STATIC_CAST( CBrowserAppDocument*, iDocument );

    __ASSERT_DEBUG( (appDoc != NULL), Util::Panic( Util::EUninitializedData ) );

    if ( appDoc->IsContentHandlerRegistered() )

        {

        BROWSER_LOG( ( _L( "Calling file handler." ) ) );

        TBool paramFound( EFalse );

        TPtrC fileName = ExtractBrCtlParam( 

                            EParamLocalFileName, 

                            aTypeArray,

                            aDesArray, 

                            paramFound );

        __ASSERT_DEBUG( paramFound, Util::Panic( Util::EUninitializedData ) );

        if ( fileName.Length() == 0 )

            {

            // May be a Rights Object download - 

            // no downloaded file, nothing to open/handle/pass to BrowserLauncher client.

            BROWSER_LOG( ( _L( " Empty fileName" ) ) );

            }

        else

            {

            CAiwGenericParamList* genericParamList = 

                BrCtlParamList2GenericParamListL( aTypeArray, aDesArray );

            CleanupStack::PushL( genericParamList );

            // Forward the file to the registered handler.

            TBool continueBrowsing( EFalse );

            downloadHandled = CBrowserAppUi::Static()->HandleContentL

                             ( fileName, *genericParamList, continueBrowsing );

            BROWSER_LOG( ( _L( " downloadHandled: %d, continueBrowsing: %d" ),

                downloadHandled, continueBrowsing ) );

            CleanupStack::PopAndDestroy( genericParamList ); // genericParamList

            if ( downloadHandled )

                {

                // We can delete the file now.

                RFs fs;

                User::LeaveIfError( fs.Connect() );

                CleanupClosePushL( fs );

                fs.Delete( fileName ); // Return value is ignored.

                CleanupStack::PopAndDestroy( &fs ); // fs

                }

            if ( !continueBrowsing )

                {

                iApiProvider->SetExitFromEmbeddedMode( ETrue );

                }

            }

        }

    else

        {

        // No handler registered.

        BROWSER_LOG( ( _L( " No handler registered." ) ) );

        }

    // If the download (file) was not handled, 

    //   the BrowserUI handles it with Document Handler.

    if ( !downloadHandled )

        {

        // This content must be handled by BrowserUI - Browser Control cannot handle it.

        OpenFileEmbeddedL( aTypeArray, aDesArray );

        downloadHandled = ETrue;

        }

    BROWSER_LOG( ( _L( " downloadHandled: [%d]" ), (TInt)downloadHandled ) );

    return downloadHandled;

    }

#ifdef __RSS_FEEDS

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

// CBrowserSpecialLoadObserver::HandleUiContentL()

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

//

TBool CBrowserSpecialLoadObserver::HandleUiContentL( 

                         RArray<TUint>* aTypeArray, 

                         CDesCArrayFlat* aDesArray ) const

    {

    TDataType dataType;

    TBool contentTypeFound( EFalse );

    TBool urlFound( EFalse );

    TBool fileFound( EFalse );

    TBool result( EFalse );

    TPtrC receivedContentType = ExtractBrCtlParam( 

        EParamReceivedContentType, 

        aTypeArray,

        aDesArray, 

        contentTypeFound );

    TPtrC url = ExtractBrCtlParam( 

        EParamRequestUrl, 

        aTypeArray,