/*******************************************************************************

 * Copyright (c) 2007, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <apgcli.h>

#include <charconv.h>

#include <eikappui.h>

#include <eiksbfrm.h>

#include <uri16.h>

#include <avkon.rsg>

#include <avkon.hrh>

#include <eikon.hrh>

#include <eswtcore.rsg>

#include <eikbtgpc.h>

#include <favouritesfile.h>

#include <favouritesdb.h>

#ifdef ESWT_ON_PUBLIC_SDK

#include <featureinfo.h>

#endif // ESW_ON_PUBLIC_SDK

#include "swtbrowserapsettingshandler.h"

#include "eswtmobileextensions.h"

#include "swtbrowserdialogsproviderproxy.h"

#include "swtbrowseraputils.h"

#include "swtbrowseractiveapdb.h"

#include "swtbrowser.h"

#include "swtbrowsercontainer.h"

#include "swtbrowserloadeventobserver.h"

#include "swtbrowserlinkresolver.h"

#include "swtbrowserstatechangeobserver.h"

#include "swtbrowserspecialloadobserver.h"

#include "swtbrowserdialogsproviderproxy.h"

#include "swtbrowsersoftkeysobserver.h"

#include "swtbrowserpreferences.h"

#include "swtbrowserconnectionmanager.h"

#include "swtuiutils.h"

// Use the same error codes as browsrNG

const TInt KBrsrMalformedUrl = -26018;

const TInt KBrsrUnknownScheme = -26026;

const TInt KMSKCbaButtonIndex = 2;

// A temporary directory location for widgetExtensions

_LIT(KWidgetPath, "C:\\");

// Default URL

_LIT(KUrl, "data:");

typedef CBrCtlInterface*(*FuncPtr_CreateBrowserControlL)(CCoeControl* aParent, TRect aRect,

        TUint aBrCtlCapabilities, TUint aCommandIdBase,

        MBrCtlSoftkeysObserver* aBrCtlSoftkeysObserver,

        MBrCtlLinkResolver* aBrCtlLinkResolver,

        MBrCtlSpecialLoadObserver* aBrCtlSpecialLoadObserver,

        MBrCtlLayoutObserver* aBrCtlLayoutObserver,

        MBrCtlDialogsProvider* aBrCtlDialogsProvider,

        MBrCtlWindowObserver* aBrCtlWindowObserver,

        MBrCtlDownloadObserver* aBrCtlDownloadObserver);

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

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

// Constructor. Scrollbar flags are removed before aStyle is passed to the CSwtComposite.

// So, supper class does not know anything about the existence of scrollbar.

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

//

CSwtBrowser::CSwtBrowser(MSwtDisplay& aDisplay, TSwtPeer aPeer, MSwtComposite* aParent

                         , TInt aStyle,TBool aVisibility, TBool aDimmed)

        : CSwtComposite(aDisplay, aPeer, aParent,

                        aStyle & ~KSwtStyleHScroll & ~KSwtStyleVScroll, aVisibility, aDimmed)

        , iBrowserLevelStyle(aStyle)

        , iFeatureManager(EFalse)

{

}

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

// 2nd phase constructor

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

//

void CSwtBrowser::ConstructL()

{

    CSwtComposite::ConstructL();

    SetBlank(); // needs to draw border at least

    SetComponentsToInheritVisibility(ETrue);

}

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

// Separated second phase constructor, specially for the construction of CBrCtlInterface

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

//

void CSwtBrowser::ConstructBrowserL(TBool aVisibility)

{

    // Init FavouritesSess

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

    // Init FeatureManager

    CSwtLafFacade::InitFeatureManagerL();

    iFeatureManager = ETrue;

    // Init active ap database

    iActiveApDb = CSwtBrowserActiveApDb::NewL();

    // Creating object to hold application settings

    iPreferences = CSwtBrowserPreferences::NewL(*iActiveApDb, *this);

    iPreferences->AddObserverL(this);

    iConnection = new(ELeave) CSwtBrowserConnectionManager(&iActiveApDb->CommsDb(), *this);

    // Set AP to be a default one

    SetRequestedAP(Preferences().DefaultAccessPoint());

    // Create Observers

    iLoadEventObserver = new(ELeave) CSwtBrowserLoadEventObserver(this , iPeer);

    iLinkResolver = new(ELeave) CSwtBrowserLinkResolver(this , iPeer);

    iStateChangeObserver = new(ELeave) CSwtBrowserStateChangeObserver(this, iPeer);

    iSpecialLoadObserver = CSwtBrowserSpecialLoadObserver::NewL(this);

    iDialogsProviderProxy = CSwtBrowserDialogsProviderProxy::NewL(iLoadEventObserver);

    iSoftkeysObserver = new(ELeave) CSwtBrowserSoftkeysObserver(this);

    // BrCtlCapabilities

    TUint capabilityFlags = TBrCtlDefs::ECapabilityLoadHttpFw

                            | TBrCtlDefs::ECapabilityConfirmDownloads

                            | TBrCtlDefs::ECapabilitySavedPage

                            | TBrCtlDefs::ECapabilityUseDlMgr

                            | TBrCtlDefs::ECapabilityCursorNavigation

                            | TBrCtlDefs::ECapabilityFavicon

                            | TBrCtlDefs::ECapabilityToolBar

                            | TBrCtlDefs::ECapabilityFitToScreen

#ifdef RD_JAVA_S60_RELEASE_9_2

                            | TBrCtlDefs::ECapabilityPinchZoom

#endif

                            ;

    if ((iBrowserLevelStyle | KSwtStyleHScroll) || (iBrowserLevelStyle |  KSwtStyleVScroll))

    {

        capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityDisplayScrollBar;

    }

    if (Preferences().UiLocalFeatureSupported(

                CSwtLafFacade::GetConstant(CSwtLafFacade::EBrowserGraphicalPage)))

    {

        capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityGraphicalPage;

    }

    if (Preferences().UiLocalFeatureSupported(

                CSwtLafFacade::GetConstant(CSwtLafFacade::EBrowserGraphicalPage)) &&

            Preferences().UiLocalFeatureSupported(

                CSwtLafFacade::GetConstant(CSwtLafFacade::EBrowserGraphicalHistory)))

    {

        capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityGraphicalHistory;

    }

    if (Preferences().UiLocalFeatureSupported(

                CSwtLafFacade::GetConstant(CSwtLafFacade::EBrowserAutoFormFill)))

    {

        capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityAutoFormFill;

    }

    if (Preferences().UiLocalFeatureSupported(

                CSwtLafFacade::GetConstant(CSwtLafFacade::EBrowserAccessKeys)))

    {

        capabilityFlags = capabilityFlags | TBrCtlDefs::ECapabilityAccessKeys;

    }

    // Create browser container.

    TRect rect=CalcBrowserRect();

    iContainer = CSwtBrowserContainer::NewL(*this);

    iContainer->SetRect(rect);

    iContainer->SetComponentsToInheritVisibility(ETrue);

    TLibraryFunction dllEntry = UiUtils().BrowserDllEntryL();

    FuncPtr_CreateBrowserControlL fptr = (FuncPtr_CreateBrowserControlL) dllEntry;

    iBrCtlInterface = (*fptr)(iContainer,

                              iContainer->Rect(),

                              capabilityFlags,

                              static_cast < TUint >(TBrCtlDefs::ECommandIdBase),    // command base

                              iSoftkeysObserver,

                              iLinkResolver,

                              iSpecialLoadObserver,

                              NULL,

                              iDialogsProviderProxy,

                              NULL,

                              NULL);

    if (!iBrCtlInterface)

    {

        User::Leave(KErrNoMemory);

    }

    TPtrC selfDownloadContentTypes = Preferences().SelfDownloadContentTypesL();

    iBrCtlInterface->SetSelfDownloadContentTypesL(selfDownloadContentTypes);

    // Add two more observers

    iBrCtlInterface->AddLoadEventObserverL(iLoadEventObserver);

    iBrCtlInterface->AddStateChangeObserverL(iStateChangeObserver);

    // Update browser global settings according to values stored in preferences

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsAutoLoadImages, Preferences().AutoLoadImages());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsDisableFlash, !Preferences().AutoLoadImages());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsEmbedded , EFalse);

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsCookiesEnabled, Preferences().Cookies());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsECMAScriptEnabled, Preferences().Ecma());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsIMEINotifyEnabled, Preferences().IMEINotification());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsSendRefererHeader, Preferences().SendReferrer());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsSecurityWarnings, Preferences().HttpSecurityWarnings());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsPageOverview, Preferences().PageOverview());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsBackList, Preferences().BackList());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsAutoRefresh, Preferences().AutoRefresh());

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsAutoFormFillEnabled, Preferences().FormDataSaving());

    // Update browser local settings according to values stored in preferences

    const TPreferencesValues& pref = iPreferences->AllPreferences();

    iFontSize = pref.iFontSize;

    iTextWrap = pref.iTextWrap;

    iEncoding = pref.iEncoding;

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsFontSize, iFontSize);

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsTextWrapEnabled, iTextWrap);

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsCharacterset, iEncoding);

    iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsLaunchAppUid, iDisplay.ApplicationUid());

    if (pref.iZoomMin < pref.iZoomMax && pref.iZoomDef >= pref.iZoomMin && pref.iZoomDef <= pref.iZoomMax)

    {

        iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsZoomLevelMin, pref.iZoomMin);

        iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsZoomLevelMax, pref.iZoomMax);

        iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsZoomLevelDefault, pref.iZoomDef);

    }

    else

    {

        iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsZoomLevelMin, 10);

        iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsZoomLevelMax, 200);

        iBrCtlInterface->SetBrowserSettingL(TBrCtlDefs::ESettingsZoomLevelDefault, 100);

    }

    // WidgetExtension needs a valid base path.

    // Base path would be used to write preferences on Widget runtime context but

    // when embedded into eSWT it does not really write any data. The base path still

    // needs to be provided to avoid any crashes during exit.

    MWidgetExtension* widgetExtension = iBrCtlInterface->CreateWidgetExtensionL(*this);

    widgetExtension->SetParamL(TBrCtlDefs::EWidgetBasePath, KWidgetPath);

    iBrCtlInterface->MakeVisible(aVisibility);

    iContainer->MakeVisible(aVisibility);

    MakeVisible(aVisibility);

    ActivateL();

    if (IsFocused())

    {

        CCoeControl::SetFocus(EFalse, ENoDrawNow);

    }

    ASSERT(!IsFocused());

    iStartedUp = ETrue; // Inddicates Browser is ready for using

}

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

// 1st and 2nd phase constructor wrapper.

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

//

CSwtBrowser* CSwtBrowser::NewL(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                               MSwtComposite& aParent, TInt aStyle)

{

    CCoeControl& parentCtrl = aParent.Control()->CoeControl();

    CSwtBrowser* self = new(ELeave) CSwtBrowser(aDisplay, aPeer, &aParent, aStyle,

            parentCtrl.IsVisible(), parentCtrl.IsDimmed());

    CleanupStack::PushL(self);

    self->ConstructL();

    self->UiUtils().NotifyNewBrowserCreated();

    self->ConstructBrowserL(parentCtrl.IsVisible());

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// Destructor

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

//

CSwtBrowser::~CSwtBrowser()

{

    if (iFeatureManager)

    {

        CSwtLafFacade::UnInitFetureManager();

        iFeatureManager = EFalse;

    }

    CSwtBrowserConnectionManager* inetconman = static_cast <CSwtBrowserConnectionManager*>(iConnection);

    delete inetconman;

    if (iPreferences)

    {

        iPreferences->RemoveObserver(this);

        delete iPreferences;

    }

    delete iActiveApDb;

    iFavouritesSess.Close();

    if (iBrCtlInterface)

    {

        iBrCtlInterface->RemoveLoadEventObserver(iLoadEventObserver);

        iBrCtlInterface->RemoveStateChangeObserver(iStateChangeObserver);

        delete iBrCtlInterface;

    }

    delete iContainer;

    delete iLoadEventObserver;

    delete iLinkResolver;

    delete iStateChangeObserver;

    delete iSpecialLoadObserver;

    delete iDialogsProviderProxy;

    delete iSoftkeysObserver;

}

CBrCtlInterface& CSwtBrowser::BrCtlInterface() const

{

    ASSERT(iBrCtlInterface);

    return *iBrCtlInterface;

}

CSwtBrowserActiveApDb& CSwtBrowser::ActiveApDb() const

{

    ASSERT(iActiveApDb);

    return *iActiveApDb;

}

MBrowserPreferences& CSwtBrowser::Preferences() const

{

    ASSERT(iPreferences);

    return *iPreferences;

}

CSwtBrowserLoadEventObserver& CSwtBrowser::LoadObserver() const

{

    ASSERT(iLoadEventObserver);

    return *iLoadEventObserver;

}

CSwtBrowserSpecialLoadObserver& CSwtBrowser::SpecialLoadObserver() const

{

    ASSERT(iSpecialLoadObserver);

    return *iSpecialLoadObserver;

}

MSwtDisplay& CSwtBrowser::Display() const

{

    return iDisplay;

}

void CSwtBrowser::UpdateCbaL()

{

    if (StartedUp())

    {

        CEikButtonGroupContainer& cba = iDisplay.UiUtils().Cba();

        TBrCtlDefs::TBrCtlElementType elementtype =

            iBrCtlInterface->FocusedElementType();

        // Cba2 must set to cancel and command observer must be added

        // when a inputbox is actvated becasue browser supposes the concel command is there

        // and will send a simulated cba2 event to deactivate input box

        if ((elementtype == TBrCtlDefs::EElementActivatedInputBox)

                || (elementtype == TBrCtlDefs::EElementActivatedObjectBox))

        {

            if (iCbaState != CSwtBrowser::EActivatedInputBox)

            {

                iCbaState = CSwtBrowser::EActivatedInputBox;

                HBufC* label = iEikonEnv->AllocReadResourceL(R_SWT_SOFTKEY_TEXT_CANCEL);

                CleanupStack::PushL(label);

                iDisplay.CommandArranger()->UpdateRightSoftkeyCommandAndObserver(

                    KSwtCommandBaseId + EAknSoftkeyCancel, *label, *this);

                CleanupStack::Pop(label);

            }

            return;

        }

        if (iCbaState != CSwtBrowser::EDefault)

        {

            iCbaState = CSwtBrowser::EDefault;

            iDisplay.CommandArranger()->RefreshCba();

        }

    }

}

#ifdef RD_SCALABLE_UI_V2

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

// Originated from CSwtBrowserContainer, not CSwtShell.

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

//

void CSwtBrowser::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    iHandlingPointerEv = ETrue;

    if (!iDisplay.RevertPointerEvent())

    {

#ifdef RD_JAVA_S60_RELEASE_9_2

        // From parent Shell coordinates to CSwtBrowserContainer coordinates

        if (aPointerEvent.AdvancedPointerEvent())

        {

            TAdvancedPointerEvent event = *(static_cast<const TAdvancedPointerEvent*>(&aPointerEvent));

            event.iPosition -= Rect().iTl;

            iBrCtlInterface->HandlePointerEventL(event);

        }

        else

#endif

        {

            TPointerEvent event = *(static_cast<const TPointerEvent *>(&aPointerEvent));

            event.iPosition -= Rect().iTl;

            iBrCtlInterface->HandlePointerEventL(event);

        }

    }

    iHandlingPointerEv = EFalse;

}

#endif

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

// This function only gets called on device

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

//

TBool CSwtBrowser::StartPreferencesViewL()

{

    TUint32 defaultAp = iPreferences->DefaultAccessPoint();

    TBool retVal(EFalse);

    if (defaultAp == KWmlNoDefaultAccessPoint)

    {

        // Showing AP selection dialog

        CSwtBrowserApSettingsHandler* ApUi = NULL;

        ApUi = CSwtBrowserApSettingsHandler::NewLC();

        TRAPD(err, ApUi->RunSettingsL(defaultAp, defaultAp));

        CleanupStack::PopAndDestroy(ApUi);

        if (err)

        {

            defaultAp = KWmlNoDefaultAccessPoint;

        }

        iPreferences->SetDefaultAccessPointL(defaultAp);

        defaultAp = iPreferences->DefaultAccessPoint(); //get it

    }

    if (defaultAp != KWmlNoDefaultAccessPoint)

    {

        SetRequestedAP(defaultAp);

        retVal = ETrue;

    }

    return retVal;

}

TBool CSwtBrowser::IsConnecting() const

{

    return (LoadObserver().LoadState() != CSwtBrowserLoadEventObserver::ELoadStateIdle);

}

void CSwtBrowser::SetRequestedAP(TInt aAp)

{

    iRequestedAp = aAp;

}

TBool CSwtBrowser::StartedUp() const

{

    return iStartedUp;

}

TUint32 CSwtBrowser::RequestedAp() const

{

    return iRequestedAp;

}

void CSwtBrowser::FetchSavedDeckL(TInt aUid)

{

    _LIT(KSavedPage,  "savedpage://");

    _LIT(KUidFormat, "%d");

    const TInt KUidFullMaxLength = 22;// max uid length, containing length of KSavedPage

    const TInt KUidMaxLength = 10;// max uid length, not containing length of KSavedPage

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

    RFavouritesDb db;

    User::LeaveIfError(db.Open(iFavouritesSess, KBrowserSavedPages));

    CleanupClosePushL<RFavouritesDb>(db);

    RFavouritesFile favFile;

    if (favFile.Open(db, aUid) == KErrNone)

    {

        TInt siz;

        favFile.Size(siz);

        HBufC8* buf  = HBufC8::NewLC(siz);

        TPtr8 des = buf->Des();

        TInt err = favFile.Read(des);

        if (err == KErrNone)

        {

            TBuf < KUidFullMaxLength > uidText;

            TBuf < KUidMaxLength > uid ;

            uid.Format(KUidFormat, aUid);

            uidText.Copy(KSavedPage);

            uidText.Append(uid);

            HBufC16* copyBuf = HBufC::NewLC(siz);

            copyBuf->Des().Copy(des);

            LoadObserver().DoStartLoad(CSwtBrowserLoadEventObserver::ELoadUrlTypeOther);

            BrCtlInterface().LoadSavedPageL(uidText , *copyBuf);

            CleanupStack::PopAndDestroy(copyBuf);

        }

        favFile.Close();

        CleanupStack::PopAndDestroy(buf);

    }

    CleanupStack::PopAndDestroy(); // db

}

MBrowserConnection& CSwtBrowser::Connection() const

{

#if defined( _DEBUG )

    _LIT(KAppName, "eSwtBrowser");

#endif

    __ASSERT_DEBUG(iConnection, User::Panic(KAppName, 0));

    return *iConnection;

}