/*

* Copyright (c) 2006 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:  

*

*/

//INCLUDES

#include "../../bidi.h"

#include "PlatformString.h"

#include <centralrepository.h>

#include <BrowserUiSDKCRKeys.h>

#include "PluginSkin.h"

#include "PluginWin.h"

#include "PluginHandler.h"

#include "PluginStreamLoaderClient.h"

#include "PluginStream.h"

#include "WebFrame.h"

#include "WebFrameView.h"

#include "WebView.h"

#include "WebPageFullScreenHandler.h"

#include "BrCtl.h"

#include "WebCoreGraphicsContext.h"

#include "StaticObjectsContainer.h"

#include "BrCtlDefs.h"

#include "SettingsContainer.h"

#include <StringLoader.h>

#include <Webkit.rsg>

#include "Frame.h"

#include "FrameLoader.h"

#include "DocumentLoader.h"

#include "ResourceRequest.h"

#include "Widget.h"

#include <ApEngineConsts.h>

#include <InternetConnectionManager.h>

#include <es_enum.h>

#include <TextEncoding.h>

#include "CString.h"

#include "WidgetExtension.h"

#include <WidgetRegistryClient.h>

// CONSTANTS

using namespace WebCore;

// scheme for RTSP url

_LIT8(KRtsp, "rtsp");

_LIT(KAccessPtId, "accesspointid");

_LIT(KContentType, "contenttype");

_LIT(KContentTypeFlash, "flash");

_LIT(KContentTypeUnknown, "application/octet-stream");

_LIT(KRequestContentType, "Content-Type:");

_LIT(KRequestEOF, "\r\n");

_LIT(KRequestEOH, "\r\n\r\n");

// The default placeholder width, matches the value set in html4.css

const TUint KPlaceholderWidth( 100 );

const TUint KPlaceholderHeight( 50 );

// The Padding between object and border, matches the value in html4.css

const TUint KHtml4cssPadding( 1 );

// The border is grow/shrink by this much when the focus changes

const TUint KBorderWidthUnfocus( 0 );

const TUint KBorderWidthFocus( KHtml4cssPadding );

_LIT(KBrowserMode,"BrowserMode");

_LIT(KWidgetMode,"WidgetMode");

_LIT(KUnknownMode, "UnKnownMode");

_LIT(KApplicationId,"ApplicationId");

_LIT(KSecMgrScriptSession,"SecMgrScriptSession");

_LIT(KAllowNetworkAccess,"AllowNetworkAccess");

#define KArraySize 3

const TInt32 KWidgetApplicationId =  0x10282822;

const TInt32 KBrowserApplicationId = 0x10008D39;

//MACROS

//DATATYPES

// LOCAL FUNCTION PROTOTYPES

TInt RunScriptCb( TAny* aPtr );

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

// makeAbsoluteUrlL()

// return an absolute url that results from refUrl being resolved against 

// baseUrl.

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

HBufC8* makeAbsoluteUrlL(const TDesC8& baseUrl, const TDesC8& refUrl)

{

    TUriParser8 baseUrlparser;

    baseUrlparser.Parse(baseUrl); 

    TUriParser8 refUrlparser;

    refUrlparser.Parse(refUrl); 

    CUri8* absoluteUrl = CUri8::ResolveL(baseUrlparser, refUrlparser);

    CleanupStack::PushL(absoluteUrl);

    HBufC8* absoluteUrlBuf = HBufC8::NewL(absoluteUrl->Uri().UriDes().Length());

    TPtr8 absoluteUrlDes = absoluteUrlBuf->Des();

    absoluteUrlDes.Copy(absoluteUrl->Uri().UriDes());

    CleanupStack::PopAndDestroy(absoluteUrl);

    return absoluteUrlBuf;

}

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

// PluginSkin::NewL()

// Two-phased constructor for PluginSkin

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

PluginSkin* PluginSkin::NewL( WebFrame& frame,

                                     const TPtrC8& url,

                                     const Vector<WebCore::String>& attributesNames,

                                     const Vector<WebCore::String>& attributeValues,

                                     const TPtrC8& baseUrl,

                                     const WebCore::String& mimeType,

                                     TBool canInteract )

    {

    PluginSkin* self = NULL;

    //Check if the flash plugin is enabled or disabled.

    self = new (ELeave) PluginSkin( frame );

    CleanupStack::PushL( self );

    self->ConstructL( mimeType, attributesNames, attributeValues,

                      url, baseUrl, canInteract );

    CleanupStack::Pop();    // self

    return self;

    }

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

// PluginSkin::PluginSkin()

// Default constructor for PluginSkin

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

PluginSkin::PluginSkin( WebFrame& frame )

    : m_pluginwin(0),

      m_frame( &frame ),

      m_visible( EFalse ),

      m_pluginSupported( EFalse ),

      m_pluginClosed(false),

      m_canInteract( EFalse ),

      m_rect(TRect(0,0,0,0)),

      m_ref(1),

      m_handle(-1),

      m_instance(0),    

      m_pluginfuncs(0),

      m_resized(false),

      m_oldRect(TRect(0,0,0,0)),

      m_oldViewport(TRect(0,0,0,0))

  {

  }

void PluginSkin::addWidgetAttributesL()

{

    const TDesC& SecMgrScriptSession = KSecMgrScriptSession();

    RWidgetRegistryClientSession widgetregistry;

    TInt ret = widgetregistry.Connect();

    if ( ret != KErrNone && ret != KErrAlreadyExists ) { 

        User::Leave( ret );

    }

    else {

        CleanupClosePushL( widgetregistry );

    }

    CBrCtl*   brCtl = control(this->frame());

    WebView*  view = brCtl->webView();

    CWidgetExtension* wdgtExt = view->widgetExtension();

    if(wdgtExt){

#if defined(BRDO_LIW_FF)

        void* scriptSession =  wdgtExt->getSecuritySession();

        if ( !scriptSession ) {

            User::Leave( KErrGeneral );

        }

        NPN_GenericElement ScriptSession(SecMgrScriptSession,scriptSession);

        iGenericElementArray->AppendL(ScriptSession);           

#endif

        TInt uid = wdgtExt->GetWidgetId();         

        CWidgetPropertyValue* AccessValue = widgetregistry.GetWidgetPropertyValueL(TUid::Uid(uid), EAllowNetworkAccess ); 

        TInt networkAccess = *AccessValue;

        const TDesC& allowNetworkAccess = KAllowNetworkAccess();

        NPN_GenericElement NetworkAccess(allowNetworkAccess,networkAccess);

        iGenericElementArray->AppendL(NetworkAccess);

    }

    User::LeaveIfError(widgetregistry.Disconnect());

    CleanupStack::PopAndDestroy(); //widgetregistry

}

const TDesC& PluginSkin::GetExecutionMode()

{

    TUid uid  = RProcess().SecureId();

    if( uid.iUid == KWidgetApplicationId ){

        return KWidgetMode;

    }

    else if( uid.iUid == KBrowserApplicationId ){

        return KBrowserMode;

    }   

    return KUnknownMode;

 }

 void PluginSkin::setupGenericElementArrrayL()

 {

    iGenericElementArray = new (ELeave) RArray<NPN_GenericElement> (KArraySize);

    const TDesC& appId = KApplicationId();

    const TDesC& executionMode = GetExecutionMode();

    NPN_GenericElement ExecutionModeElement(appId,executionMode);

    iGenericElementArray->AppendL(ExecutionModeElement);

    if(0 == executionMode.Compare(KWidgetMode())) {

        addWidgetAttributesL();

    }

 }

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

// PluginSkin::ConstructL()

// Second phase constructor for PluginSkin

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

void PluginSkin::ConstructL( const WebCore::String& mimeType,

                             const Vector<WebCore::String>& attributesNames,

                             const Vector<WebCore::String>& attributeValues,

                             const TPtrC8& url,

                             const TPtrC8& baseUrl,

                             TBool canInteract )

    {

    // Get the canned object images

    m_cannedimg = WebCore::StaticObjectsContainer::instance()->webCannedImages()->getImage( WebCannedImages::EImageObject );

    TInt value( 0 );

    CRepository* rep = CRepository::NewL( KCRUidBrowser );

    rep->Get( KBrowserUsBuild, value );

    delete rep;

    if ( !value || canInteract )

        {

        m_canInteract = ETrue;

        }

    // Create the plugin if supported by platform

    PluginHandler* pluginHandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();

    TPtrC mimeTypePtr;

    if (mimeType.length() > 0) {

        mimeTypePtr.Set(mimeType.des());

        m_pluginSupported = pluginHandler->isSupported( mimeTypePtr, url );

    }

    else {

        HBufC* ptr = pluginHandler->pluginMimeByExtention(url);

        if (ptr) {

            mimeTypePtr.Set(ptr->Des());

        }

        m_pluginSupported = ((ptr != NULL) && (mimeTypePtr.Length() > 0));

    }

    if ( m_pluginSupported ) {

        m_attributeNames = new (ELeave) CDesCArrayFlat(attributesNames.size());

        m_attributeValues = new (ELeave) CDesCArrayFlat(attributeValues.size());

        for (TInt i = 0; i < attributesNames.size(); i++)

                { m_attributeNames->AppendL(attributesNames[i].des());}

        for (TInt i = 0; i < attributeValues.size(); i++)

                { m_attributeValues->AppendL(attributeValues[i].des());}

        m_attributeNames->AppendL( KContentType() );

        m_attributeValues->AppendL( mimeType.des());

        // Append the browser access point id.

        // The access point id could be used by plugins to make open up a connection.

        m_attributeNames->AppendL( KAccessPtId );

        // Convert int value to string and append it

        TBuf16<4> value;

        value.Format( _L("%d"), m_frame->frameView()->topView()->accessPointId() );

        m_attributeValues->AppendL( value );      

        setupGenericElementArrrayL();

        if(url.Length())

            m_url = url.AllocL();

        bool loadPluginContent = m_frame->frameView()->topView()->brCtl()->settings()->brctlSetting(TBrCtlDefs::ESettingsAutoLoadImages);

        if((mimeTypePtr.Find(KContentTypeFlash) != KErrNotFound)) {

            loadPluginContent = loadPluginContent && !m_frame->frameView()->topView()->brCtl()->settings()->brctlSetting(TBrCtlDefs::ESettingsDisableFlash);

            m_flashContent = ETrue;

        }

        else {

            m_flashContent = EFalse;           

        }

        if (loadPluginContent) {

            if (isBrowserScheme(url)) {            

                NetscapePlugInStreamLoaderClient* pluginloader = NetscapePlugInStreamLoaderClient::NewL(url, this, core(m_frame));

                if (pluginloader) {

                    pluginloader->start();                            

                }                                                

            }

            else {

                TPtrC8 urlPtr(url);

                HBufC8* mime = NULL;

                mime = HBufC8::NewLC(mimeTypePtr.Length());

                mime->Des().Copy(mimeTypePtr);

                createPluginWinL(urlPtr, mimeTypePtr);

                loadPluginL(*mime);

                CleanupStack::PopAndDestroy(); // mime

            }

        }                

    }   // end of if (iIsPluginSupported)

    else {

        if(url.Length())

            m_url = url.AllocL();

    }

    // register itself

    MemoryManager::AddCollector(this);

    iJavascriptTimer = NULL;

}

void PluginSkin::addPluginStream(PluginStream* stream)

{

    m_streams.add(stream);

}

void PluginSkin::removePluginStream(PluginStream* stream)

{

    m_streams.remove(stream);

}

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

// PluginSkin::~PluginSkin()

// PluginSkin class Destructor

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

PluginSkin::~PluginSkin()

    {

    MemoryManager::RemoveCollector(this);

    Close();

    RFs& rfs = StaticObjectsContainer::instance()->fsSession();

    for(TInt i=0; i < m_tempFilesArray.Count(); i++)

        {

          rfs.Delete(m_tempFilesArray[i]->Des());

        }

    m_tempFilesArray.ResetAndDestroy();

    if (iGenericElementArray){

        iGenericElementArray->Close();

        delete iGenericElementArray;

	}

    }

void PluginSkin::Close()

{    

    // close any pending stream

    Vector<PluginStream*> streams;

    for (HashSet<PluginStream*>::iterator it = m_streams.begin(); it != m_streams.end(); ++it) {

        streams.append(*it);

    }    

    for (int i=0; i<streams.size(); ++i) {

        streams[i]->close();

    }

    m_streams.clear();

    if (m_instance && m_pluginfuncs && m_pluginfuncs->destroy) {        

        m_pluginfuncs->destroy(m_instance, NULL);

    }    

    if (m_handle >= 0) {

        PluginHandler* pluginhandler = WebCore::StaticObjectsContainer::instance()->pluginHandler();

        if ( pluginhandler) {

            pluginhandler->unloadPlugin( m_handle );

            pluginhandler->removePluginObject(this);

            if (this == pluginhandler->activePlugin()) {

                pluginhandler->setActivePlugin(NULL);

            }

        }

        m_handle = -1;

    }

    User::Free(m_instance); m_instance = 0;

    delete m_pluginwin; m_pluginwin = 0;

    delete m_attributeNames; m_attributeNames = 0;

    delete m_attributeValues; m_attributeValues = 0;

    delete m_url; m_url = 0;

    delete iJavascriptTimer; iJavascriptTimer = 0;

    m_pluginfuncs = 0;

    m_pluginSupported = EFalse;

    m_pluginClosed = true;

 }

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

// PluginSkin::pluginFocusChanged()

// PluginSkin function to show/hide fullscreen sprite

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

void PluginSkin::pluginFocusChanged(TBool focus) 

{ 

    if (control(m_frame)->webView()->pageFullScreenHandler() && 

        !control(m_frame)->webView()->pageFullScreenHandler()->isFullScreenMode()) 

            return;

    if (focus && !m_flashContent)

        {

        TRAP_IGNORE(

        control(m_frame)->webView()->LeaveFullscreenBrowsingL();

        control(m_frame)->webView()->notifyFullscreenModeChangeL( EFalse );

        );

        }

    else if (focus)

        {

        TRAP_IGNORE(

        control(m_frame)->webView()->pageFullScreenHandler()->showEscBtnL();

        );

        }

    else 

        {

        TRAP_IGNORE(

        control(m_frame)->webView()->pageFullScreenHandler()->hideEscBtnL();

        );

        }

}

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

// PluginSkin::Draw

// From MWebCoreObjectWidget

//

// The "focus" border width of this widget is adjusted to show when it has

// focus.  The border width is grown to KBorderWidthFocus. The default padding

// (set in Html4.css) is set up to handle the focus border growing into it.

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

void PluginSkin::draw( WebCoreGraphicsContext& context,

                        const TRect& /*rect*/ )

    {

    if(!control(m_frame)->webView()->IsVisible())

        return;

    TRect newRect(m_rect);

    TInt z(context.view().scalingFactor());

    if (z != 100 )

        {

        newRect = m_frame->frameView()->toViewCoords(m_rect);

        }

    CFbsBitGc* gc = &context.gc();

    gc->SetPenStyle( CGraphicsContext::ENullPen );

    gc->SetBrushStyle( CGraphicsContext::ENullBrush );

    CFbsBitmap* bitmap = m_cannedimg.m_img;

    TSize bmpSize( bitmap->SizeInPixels() );

    if ( !m_pluginwin && newRect.Height() >= bmpSize.iHeight && newRect.Width() >= bmpSize.iWidth )

        {

        // The inner rect is big enough, draw the placeholder image

        TPoint bitmapStartPoint( newRect.Center() );

        bitmapStartPoint -= TPoint(bmpSize.iWidth/2,bmpSize.iHeight/2);

        gc->BitBltMasked( bitmapStartPoint, m_cannedimg.m_img,

                        bmpSize, m_cannedimg.m_msk, ETrue );

        }

    if(m_pluginwin)

        {

        positionChanged();

        // Force the control to be redrawn.

        m_pluginwin->refreshPlugin(*gc,newRect);

        }

    }

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

// PluginSkin::IsVisible

// From MWebCoreObjectWidget

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

TBool PluginSkin::isVisible() const

    {

    return m_visible;

    }

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

// PluginSkin::SizeHint

// From MWebCoreObjectWidget

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

TSize PluginSkin::sizeHint() const

    {

    return TSize( KPlaceholderWidth, KPlaceholderHeight );

    }

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

// PluginSkin::MakeVisible

// From MWebCoreObjectWidget

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

void PluginSkin::makeVisible( TBool visible )

    {

    if ( m_pluginwin )

        {

        m_visible = visible;

        if(m_active)

            deActivate();

        m_pluginwin->makeVisible(visible);

        }

    }

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

// PluginSkin::SetFocus

// From MWebCoreObjectWidget