/*

* 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:  Base Controller class for handling browser requests to play

*                audio or video

*

*/

// INCLUDE FILES

#include <bautils.h>

#include <f32file.h>

#include <utf.h>

#include <e32cmn.h>

#include <aknquerydialog.h>                 // Volume list query dialog

#include <aknlists.h>

#include <CTSYDomainPSKeys.h>

#include <BrowserAudioVideoPlugin.rsg>

#include "BavpController.h"

#include "BavpClipInfo.h"

#include "BavpView.h"

#include "BavpLogger.h"

#if defined(BRDO_ASX_FF)

#include "AsxParser.h"

#endif //BRDO_ASX_FF

#include "eikon.hrh"

using namespace RT_GestureHelper;

// CONSTANTS

const TInt KBavpMaxLinkFileSize = 5120; // 5kB

const TInt KRectPadding = 2;

// Define our static BavpController array

RPointerArray<CBavpController> CBavpController::iBavpControllerArray;

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

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

// CBavpController::CBavpController

// C++ default constructor can NOT contain any code, that

// might leave.

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

CBavpController::CBavpController( MBavpView* aView,

                                  TUint aAccessPtId )

    : CActive( EPriorityStandard ),

      iCurrentState( EBavpNone ),

      iPreCallState( EBavpNone ),

      iLastCommand( EBavpCmdUnknown ),

      iLoopCount( 1 ),

      iInitLoopCount( 1 ),

      iInfiniteLoopFlag( EFalse ),

      iAccessPtId( aAccessPtId ),

      iBavpView( aView ),

      iOriginalFileName ( NULL ),

      iMimeType ( NULL )

    {

        CActiveScheduler::Add( this );

    }

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

// CBavpController::~CBavpController()

// Destructor

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

CBavpController::~CBavpController()

    {

    Log( EFalse, _L("CBavpController::~CBavpController this="), (TInt)this );

    if ( iClipInfo )

        {

        delete iClipInfo;

        }

    iIncomingCalls.Close();

    // Cancel active object and deleting removes from the ActiveScheduler

    Cancel();

    if ( iBavpVolumeHandler )

        {

        delete iBavpVolumeHandler;

        }

    // No need to check, if not active, Cancel() does nothing

    if ( iPositionUpdater )

        {

        iPositionUpdater->Cancel();

        delete iPositionUpdater;

        }

    if ( iHwKeyEvents )

        {

        delete iHwKeyEvents;

        }

     if ( iOriginalFileName )

     {

        delete iOriginalFileName;

     }

     if ( iMimeType )

     {

        delete iMimeType;

     }

    // Remove this instance from the array

    TInt index = iBavpControllerArray.Find( this );

    if ( index != KErrNotFound )

        {

        iBavpControllerArray.Remove( index );

        }

    if ( iBavpControllerArray.Count() == 0 )

        {

        iBavpControllerArray.Close();

        }

    }

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

// CBavpController::HandleBrowserNotification

// Default implementation, override as needed.

// Handles notification from the Browser concerning the Browser's focus state

// (Browser is in-focus, out-focus, foreground, or the background application)

// and if this plugin is in-focus or out-focus. If the Browser is out-focus,

// this plugin (all plugins) are out-focus. This is not used currently,

// because we do not react to the Browser changing focus. We historically would

// stop playing audio when the browser's focus changed (including when option

// menu is popped up, ie menu top of stack).

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

void CBavpController::HandleBrowserNotification( TBool aFocus )

    {

    Log( EFalse, _L("CBavpController::HandleBrowserNotification: aBrowserFocus="),

            aFocus );

    }

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

// CBavpController::HandleError

// Default implementation, override as needed.

// This default error handling implementation just displays the broken (bad)

// content animation and sets state to EBavpBadContent.

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

void CBavpController::HandleError( TInt aError )

    {

    Log( EFalse, _L("CBavpController::HandleError(): aError="), aError );

    if ( aError != KErrNone )

        {

        // Any error, display we have bad content

        iCurrentState = EBavpBadContent;

        iBavpView->UpdateView();

        }

    }

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

// CBavpController::HandleKeysL

// Default implementation, override as needed.

// Handles user key presses when the Plugin is Activated.

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

TKeyResponse CBavpController::HandleKeysL( const TKeyEvent& aKeyEvent,

                                           TEventCode /*aType*/ )

    {

    Log( EFalse, _L("CBavpController::HandleKeysL()") );

    TKeyResponse keyResponse = EKeyWasNotConsumed;

    switch ( aKeyEvent.iCode )

        {

        // Cancel key (RSK) was pressed

        case EKeyDevice1:

            // Return the focus to the Browser, remove it from Bavp

            iBavpView->CoeControl().SetFocus( EFalse );

            keyResponse = EKeyWasConsumed;

            break;

        // Arrow keys was pressed

        case EKeyUpArrow:             // North

        case EKeyRightUpArrow:        // Northeast

        case EStdKeyDevice11:         // Extra KeyEvent supports diagonal event simulator wedge

        case EKeyRightArrow:          // East

        case EKeyRightDownArrow:      // Southeast

        case EStdKeyDevice12:         // Extra KeyEvent supports diagonal event simulator wedge

        case EKeyDownArrow:           // South

        case EKeyLeftDownArrow:       // Southwest

        case EStdKeyDevice13:         // Extra KeyEvent supports diagonal event simulator wedge

        case EKeyLeftArrow:           // West

        case EKeyLeftUpArrow:         // Northwest

        case EStdKeyDevice10:         // Extra KeyEvent supports diagonal event simulator wedge

            // Do nothing with these keys, there is no navigating inside Bavp.

            keyResponse = EKeyWasConsumed;

            break;

        default:

        // Do nothing, let the rest of the key events pass back not consumed

        break;

        }   // end of switch

    return keyResponse;

    }

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

// CBavpController::HandleCommandL

// Default implementation, override as needed.

// Handles the commands from the Option Menu defined in TBavpCommandIds

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

void CBavpController::HandleCommandL( TBavpCommandIds aCommand )

    {

    Log( EFalse, _L("CBavpController::HandleCommandL(): aCommand="), (TInt)aCommand );

    switch ( aCommand )

        {

        case EBavpCmdPlay:

            iLastCommand = EBavpCmdPlay;

            PlayL();

            break;

        case EBavpCmdStop:

            iLastCommand = EBavpCmdStop;

            Stop();

            break;

        case EBavpCmdPause:

            iLastCommand = EBavpCmdPause;

            PauseL();

            break;

        case EBavpCmdFastForward:

            iLastCommand = EBavpCmdFastForward;

            FastForwardL();

            break;

        case EBavpCmdRewind:

            iLastCommand = EBavpCmdRewind;

            RewindL();

            break;

        case EBavpCmdChangeVolume:

            iLastCommand = EBavpCmdChangeVolume;

            CreateVolumeListDlgL();

            break;

        case EBavpCmdMuteVolume:

            iLastCommand = EBavpCmdMuteVolume;

            iBavpVolumeHandler->HandleNotifyInt( KBrowserMediaVolumeControl,

                                                 KCRVolumeMute );

            break;

        default:

            iLastCommand = EBavpCmdUnknown;

            break;

        }

    }

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

// CBavpController::BavpGainedFocus

// Default implementation, override as needed.

// Called by CBavpView to CBavpPlugin whenever Bavp Plugin has focus and soft key

// cancel is hit. When this happens the Browser calls NotifyL with 1.

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

void CBavpController::BavpFocusChanged( TBool aFocus )

    {

    iBavpHasFocus = aFocus;

    }

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

// CBavpController::SetVolumeFromAttribute

// Provides CBavpController with the volume attribute from the tags on the

// HTTP page, i.e. <object volume="high"...

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

void CBavpController::SetVolumeFromAttribute( TInt aAttributeVolume )

    {

    // Use the lower volume:

    // 1) Current volume (iCurrentVolume)

    // 2) Volume setting on web page (aAttributeVolume)

    if ( aAttributeVolume < iCurrentVolume )

        {

        iCurrentVolume = aAttributeVolume;

        iBavpVolumeHandler->HandleNotifyInt( KBrowserMediaVolumeControl,

                                             iCurrentVolume );

        }

    }

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

// CBavpController::SetLoopFromAttribute

// Provides CBavpController with the loop attribute from the tags on the

// HTTP page, i.e. <object loop="infinite"... or <object loop="4"...

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

void CBavpController::SetLoopFromAttribute( TInt aLoopValue, TBool aInfiniteFlag )

    {

    // Save the loop count, already checked for valid range

    iLoopCount = aLoopValue;

    // Save the initial loop count, in case we get an error while looping

    // through the content

    iInitLoopCount = iLoopCount;

    // If the loop value is set to "infinite" looping. We currently use

    // a max loop of 50 for infinite

    iInfiniteLoopFlag = aInfiniteFlag;

}

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

// CBavpControllerAudioo::RefreshRectCoordinatesL

// Refresh the coordinates of rect for display

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

void CBavpController::RefreshRectCoordinatesL()

    {

    Log( EFalse, _L("CBavpController::RefreshRectCoordinatesL()") );

    }

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

// CBavpController::ParseRamFileL

// Read the ram file and parse the the url, put into iClipInfo->iUrl

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

void CBavpController::ParseRamFileL()

    {

    Log( EFalse, _L("CBavpController::ParseRamFileL() ") );

    RFs rFs;

    RFile ramFile;

    // Connect to file server:

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

    CleanupClosePushL( rFs );

    if ( !BaflUtils::FileExists( rFs, *iClipInfo->iFileName ) )

        {

        User::Leave( KErrNotFound );

        }

    User::LeaveIfError( ramFile.Open( rFs, *iClipInfo->iFileName, EFileShareAny ) );

    CleanupClosePushL( ramFile );

    TInt size;

    User::LeaveIfError( ramFile. Size( size ) );

    if ( size > KBavpMaxLinkFileSize )

        {

        User::Leave( KErrNotFound );

        }

    HBufC8* urlBuf = HBufC8::NewLC( size );

    TPtr8 ptr = urlBuf->Des();

    // Read file to urlBuf

    User::LeaveIfError( ramFile.Read( ptr ) );

    // Set the iClipInfo->iUrl

    if ( iClipInfo->iUrl )

        {

        delete iClipInfo->iUrl;

        iClipInfo->iUrl = NULL;

        }

    iClipInfo->iUrl = HBufC::NewL( urlBuf->Length() );

    TPtr urlDes = iClipInfo->iUrl->Des();

    // Read to the end of the line that should be a link

    TInt lineChange = urlBuf->LocateF( EKeyLineFeed );

    if ( lineChange == KErrNotFound )

        {

        // No line change was found --> last line had no line change

        // Copy last line to (unicode) aLink

        CnvUtfConverter::ConvertToUnicodeFromUtf8( urlDes, *urlBuf );

        }

    else

        {

        // Set the descriptor to the  end of the line

        if ( (lineChange > 0) && (urlBuf->Des()[lineChange - 1] == EKeyEnter) )

            {

            lineChange--;

            }

        // Copy line to (unicode) url

        CnvUtfConverter::ConvertToUnicodeFromUtf8( urlDes, urlBuf->Left( lineChange ) );

        }

    CleanupStack::PopAndDestroy( 3 ); // ramFile, urlBuf, rFs

    }

#if defined(BRDO_ASX_FF)

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

// CBavpController::ParseAsxFileL

// Read the asx file and parse the the url, put into iClipInfo->iUrl

// Only retrieve the first URL found

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

void CBavpController::ParseAsxFileL()

    {

    Log( EFalse, _L("CBavpController::ParseAsxFileL() ") );

    TUint urls = 0;

    TPtrC8 url;

    if ( iClipInfo->iUrl )

        {

        delete iClipInfo->iUrl;

        iClipInfo->iUrl = NULL;

        }

    CAsxParser* asxParser = CAsxParser::NewL(*iClipInfo->iFileName);

    CleanupStack::PushL( asxParser );

    if ( asxParser )

        {

        asxParser->GetUrlCount(urls);

        if ( urls > 0 )

            asxParser->GetUrl(1,url);

        }

    iClipInfo->iUrl = HBufC::NewL( url.Length() );

    TPtr urlDes = iClipInfo->iUrl->Des();

    CnvUtfConverter::ConvertToUnicodeFromUtf8( urlDes, url);

    CleanupStack::PopAndDestroy();  // asxparser

    }

#endif // BRDO_ASX_FF

// CBavpController::GetClipRect

// Retrieve the rect position. Ex. not intersect with title pane and status pane

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

TRect CBavpController::GetClipRect( TRect aRect )

    {

    TRect clipRect ( aRect );

    Log( EFalse, _L("GetClipRect") );

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, iNormalScreenRect );

  // Calculate not to cover the bottom or the top of the rect.

  if ( clipRect.iTl.iX < iNormalScreenRect.iTl.iX )

    {

    clipRect.iTl.iX = iNormalScreenRect.iTl.iX;

    }

  if ( clipRect.iTl.iY < iNormalScreenRect.iTl.iY )

    {

    clipRect.iTl.iY = iNormalScreenRect.iTl.iY;

    }

  if ( clipRect.iBr.iY > iNormalScreenRect.iBr.iY )

    {

    clipRect.iBr.iY = iNormalScreenRect.iBr.iY;

    }

  if ( clipRect.iBr.iX > iNormalScreenRect.iBr.iX )

    {

    clipRect.iBr.iX = iNormalScreenRect.iBr.iX - KRectPadding;

    }

    return clipRect;

    }

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

// CBavpController::CreateVolumeListDlg

// Create the volume list query dialog

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

void CBavpController::CreateVolumeListDlgL()

{

    CEikTextListBox* list = new(ELeave) CAknSinglePopupMenuStyleListBox;

    CleanupStack::PushL( list );

    // Create popup list and PUSH it.

    CAknPopupList* popupList = CAknPopupList::NewL( list,

                                                    R_AVKON_SOFTKEYS_OK_CANCEL,

                                                    AknPopupLayouts::EMenuWindow);

    CleanupStack::PushL( popupList );

    // Initialize listbox.

    list->ConstructL( popupList, CEikListBox::ELeftDownInViewRect );

    list->CreateScrollBarFrameL( ETrue );

    list->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,

                                                     CEikScrollBarFrame::EAuto );

    // Make list items and PUSH it

    CDesCArrayFlat* items =

            CCoeEnv::Static()->ReadDesCArrayResourceL( R_AKNTAPOPLIST_MENU_VOLUME_ITEMS );

    // Set list items.

    CTextListBoxModel* model = list->Model();

    model->SetItemTextArray( items );

    model->SetOwnershipType( ELbmOwnsItemArray );

    // Using the current volume set to determine the index of the volume value

    // to highlight in the list

    TInt volumeIndex( 0 );

    if ( iCurrentVolume == KCRVolume0 )

        {

        volumeIndex = 0;

        }

    else if ( iCurrentVolume == KCRVolume2 )

        {

        volumeIndex = 1;

        }

    else if ( iCurrentVolume == KCRVolume5 )

        {

        volumeIndex = 2;

        }

    else if ( iCurrentVolume == KCRVolume8 )

        {

        volumeIndex = 3;

        }

    else if ( iCurrentVolume == KCRVolume10 )

        {

        volumeIndex = 4;