/*
* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "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:  A view displaying basic playback state and feature
*
*/

#include <stiflogger.h>
#include <e32const.h>
#include "testplaybackviewobserver.h"
#include "testplaybackview.h"

// CONSTANTS
_LIT(KSpacer,           " ");
_LIT(KPlay,             " Play-1 ");
_LIT(KPlaySel,          "(Play-1)");
_LIT(KBackward,         " <<-2 ");
_LIT(KForward,          " >>-3 ");
_LIT(KStop,             " Stop-4 ");
_LIT(KStopSel,          "(Stop-4)");
_LIT(KFastRewind,       " FR-5 ");
_LIT(KFastRewindSel,    "(FR-5)");
_LIT(KFastForward,      " FF-6 ");
_LIT(KFastForwardSel,   "(FF-6)");
_LIT(KPause,            " Pause-7 ");
_LIT(KPauseSel,         "(Pause-7)");
    
_LIT(KExit,             "Exit-Esc"  );

const TInt KSongInfoYOffset = 10;
const TInt KDisplayScreenWidthOffset = 10;

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

// ---------------------------------------------------------------------------
// Symbian 2-phrase constructor
// ---------------------------------------------------------------------------
//
EXPORT_C CTestPlaybackView* CTestPlaybackView::NewL(CConsoleMain* aConsoleMain,
                                            CTestBaseView* aParent,
                                            const TDesC& aName,
                                            CStifLogger* aLogger)
    {
    CTestPlaybackView* self = new (ELeave) CTestPlaybackView(aConsoleMain,
                                                             aParent,
                                                             aName,
                                                             aLogger);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    
    }

// ---------------------------------------------------------------------------
// C++ destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CTestPlaybackView::~CTestPlaybackView()
    {
    }

// ---------------------------------------------------------------------------
// Add observer
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestPlaybackView::AddObserver(MTestPlaybackViewObserver* aObs)
    {
    iTestPlaybackViewObs = aObs;
    }

// ---------------------------------------------------------------------------
// Update current index
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestPlaybackView::UpdateItemIndex(TInt aIndex, TInt aTotalItem)
    {
    iCurrentStatus.iItemIndex = aIndex;
    iCurrentStatus.iMaxItems = aTotalItem;
    RedrawIndex();
    }
    
// ---------------------------------------------------------------------------
// Update position in the song
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestPlaybackView::UpdateProgress(TInt aPosition, TInt aDuration)
    {
    iCurrentStatus.iProgressPos = aPosition;
    iCurrentStatus.iProgressDur = aDuration;
    RedrawProgress();
    }
    
// ---------------------------------------------------------------------------
// Update volume
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestPlaybackView::UpdateVolume(TInt aVolume, TInt aMaxVolume)
    {
    iCurrentStatus.iVolume = aVolume;
    iCurrentStatus.iMaxVolume = aMaxVolume;
    RedrawVolume();
    }
    
// ---------------------------------------------------------------------------
// Update artist and song name
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestPlaybackView::UpdateSongInfo(const TDesC& aArtist, 
                                       const TDesC& aSongName)
    {
    TInt y = iDisplaySize.iHeight/ 2 - 2;
    //erase previous text
    for(TInt i = 0; i < iDisplaySize.iWidth; i++)
        {
        iConsole->SetPos(i,y);
        iConsole->Printf(_L(" "));
        iConsole->SetPos(i,y+1);
        iConsole->Printf(_L(" "));
        }
    iConsole->SetPos(
                Max((iDisplaySize.iWidth - aArtist.Length())/2, 0), y++);
    iConsole->Printf(_L("%S"), &aArtist);
    iConsole->SetPos(
                Max((iDisplaySize.iWidth - aSongName.Length())/2, 0), y);
    iConsole->Printf(_L("%S"), &aSongName);
    //DisplayViewL();
    }

// ---------------------------------------------------------------------------
// Handles state changes in playbackutility
// ---------------------------------------------------------------------------
//
EXPORT_C void CTestPlaybackView::StateChanged(TTestPlaybackState aState)
    {
    
    switch(aState)
        {
    case ETPbStateInitialising:
        UpdateSongInfo(KNullDesC, _L("Opening file"));
    case ETPbStateShuttingDown:
    case ETPbStateBuffering:
    case ETPbStateDownloading:
    case ETPbStateStopped:
    case ETPbStateNotInitialised:
        iCurrentStatus.iPlaying = iCurrentStatus.iForwardSeek 
        = iCurrentStatus.iBackwardSeek = iCurrentStatus.iPause = EFalse;
        break;
    case ETPbStatePaused:
        iCurrentStatus.iPlaying = iCurrentStatus.iForwardSeek 
        = iCurrentStatus.iBackwardSeek = EFalse;
        iCurrentStatus.iPause = ETrue;
        break;
    case ETPbStatePlaying:
        iCurrentStatus.iPause = iCurrentStatus.iForwardSeek 
        = iCurrentStatus.iBackwardSeek = EFalse;
        iCurrentStatus.iPlaying = ETrue;
        break;
    case ETPbStateSeekingForward:
        iCurrentStatus.iBackwardSeek = EFalse;
        iCurrentStatus.iForwardSeek = ETrue;
        break;
    case ETPbStateSeekingBackward:
        iCurrentStatus.iForwardSeek = EFalse;
        iCurrentStatus.iBackwardSeek = ETrue;
        break;
        }
    RedrawPlayerStatue();
    }
    
// ---------------------------------------------------------------------------
// From class CTestBaseView.
// Initialization of a view before first time activation
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::InitializeViewL()
    {
    iConsole->ClearScreen();
    RedrawProgress();
    RedrawVolume();
    UpdateSongInfo(KNullDesC, KNullDesC);
    RedrawPlayerStatue();
    }
    
// ---------------------------------------------------------------------------
// From class CTestBaseView.
// Cleanup the child view before deactivate/destroy view
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::CleanupViewL()
    {
    }

// ---------------------------------------------------------------------------
// From class CTestBaseView.
// Display this view 
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::DisplayViewL()
    {
    DisplayViewBase();
    RedrawIndex();
    RedrawProgress();
    RedrawVolume();
    RedrawPlayerStatue();
    }
    
// ---------------------------------------------------------------------------
// From class CTestBaseView.
// Process keypresses on this view - called by ConsoleMain
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::SelectL( TKeyCode aSelection, TBool& aContinue )
    {
    aContinue = ETrue;
    switch(aSelection)
        {
        case '1':
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdPlay);
            break;
        case '2':
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdPrevious);
            break;
        case '3':
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdNext);
            break;
        case '4':
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdStop);
            break;
        case '5':
            iTestPlaybackViewObs->HandleUiCommandL(iCurrentStatus.iBackwardSeek?
                                                  ETPbViewCmdStopSeeking : 
                                                  ETPbViewCmdStartSeekBackward);
            break;
        case '6':
            iTestPlaybackViewObs->HandleUiCommandL(iCurrentStatus.iForwardSeek?
                                                  ETPbViewCmdStopSeeking : 
                                                  ETPbViewCmdStartSeekForward);
            break;
        case '7':
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdPause);
            break;
        case '8':
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdDecreaseVolume);
            break;
        case '9':
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdIncreaseVolume);
            break;
        case EKeyEscape:
            iTestPlaybackViewObs->HandleUiCommandL(ETPbViewCmdClose);
            aContinue = EFalse;
            CurrentViewDoneL();
            break;
        }
    }

// ---------------------------------------------------------------------------
// From class CTestBaseView.
// Update display from timer - called by ConsoleMain
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::TimerUpdate()
    {
    
    }

// ---------------------------------------------------------------------------
// C++ constructor
// ---------------------------------------------------------------------------
//
CTestPlaybackView::CTestPlaybackView(CConsoleMain* aConsoleMain,
                                      CTestBaseView* aParent,
                                      const TDesC& aName,
                                      CStifLogger* aLogger)
    : CTestBaseView(aConsoleMain, aParent, aName)
    {
    iDisplaySize = iConsole->ScreenSize();
    iDisplaySize.iWidth = iDisplaySize.iWidth - KDisplayScreenWidthOffset;
    iLogger = aLogger;
    }

// ---------------------------------------------------------------------------
// Symbian 2-phrase constructor
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::ConstructL()
    {
    
    iCurrentStatus.iBackwardSeek = EFalse;
    iCurrentStatus.iForwardSeek = EFalse;
    iCurrentStatus.iPlaying = EFalse;
    iCurrentStatus.iPause = EFalse;
    iCurrentStatus.iVolume = 0;
    iCurrentStatus.iMaxVolume = 20; //magic number??
    iCurrentStatus.iProgressPos = 0;
    iCurrentStatus.iProgressDur = KMaxTInt;
    iCurrentStatus.iItemIndex = 0;
    iCurrentStatus.iMaxItems = 0;
    
    InitializeViewL();
    }


// ---------------------------------------------------------------------------
// Redraw index in view
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::RedrawIndex()
    {
    if(iCurrentStatus.iMaxItems <= 0)
        return;
    iConsole->SetPos(iDisplaySize.iWidth - 5, 3);   //##/## format
    iConsole->Printf(_L("     "));                  //clean
    iConsole->SetPos(iDisplaySize.iWidth - 5, 3);
    iConsole->Printf(_L("%d/%d"), iCurrentStatus.iItemIndex, 
                                  iCurrentStatus.iMaxItems);
    
    }
    
// ---------------------------------------------------------------------------
// Redraw progress bar in view
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::RedrawProgress()
    {
    if(iCurrentStatus.iProgressDur <= 0)
        return;
    TInt pos = iCurrentStatus.iProgressPos * 
                    iDisplaySize.iWidth / iCurrentStatus.iProgressDur ;
    iConsole->SetPos(0,  iDisplaySize.iHeight / 2);
    for(TInt x = 1; x <= iDisplaySize.iWidth; x++)
        iConsole->Printf(x<=pos? _L("=") : _L("-"));
    }
    
// ---------------------------------------------------------------------------
// Redraw volume bar in view
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::RedrawVolume()
    {
    if(iCurrentStatus.iMaxVolume <= 0)
        return;
    TInt pos = iCurrentStatus.iVolume * 
                    iCurrentStatus.iMaxVolume / iCurrentStatus.iMaxVolume ;
    iConsole->SetPos(0, 1);
    iConsole->Printf(_L("Volume(8|9):"));
    for(TInt x = 1; x <= iCurrentStatus.iMaxVolume; x++)
        iConsole->Printf(x <= pos? _L("=") : _L("-"));
    iConsole->Printf(_L(" %d/%d"), 
                     iCurrentStatus.iVolume, 
                     iCurrentStatus.iMaxVolume);
    }

// ---------------------------------------------------------------------------
// Redraw status/control part of the view
// ---------------------------------------------------------------------------
//
void CTestPlaybackView::RedrawPlayerStatue()
    {
    TInt linePosY = iDisplaySize.iHeight - KSongInfoYOffset;
    
    //Line 1
    iConsole->SetPos(0, linePosY);
    iConsole->Printf(iCurrentStatus.iPlaying?
                        KStop : KStopSel);
    iConsole->Printf(KSpacer);
    iConsole->Printf(iCurrentStatus.iBackwardSeek?
                        KFastRewindSel : KFastRewind);
    iConsole->Printf(KSpacer);
    iConsole->Printf(iCurrentStatus.iForwardSeek?
                        KFastForwardSel : KFastForward);
    iConsole->Printf(KSpacer);
    iConsole->Printf(iCurrentStatus.iPause?
                        KPauseSel : KPause);
    
    //Line 2
    iConsole->SetPos(0, ++linePosY);
    iConsole->Printf(iCurrentStatus.iPlaying?
                        KPlaySel : KPlay);
    iConsole->Printf(KSpacer);
    iConsole->Printf(KBackward);
    iConsole->Printf(KSpacer);
    iConsole->Printf(KForward);
    
    //Line Exit
    iConsole->SetPos(iDisplaySize.iWidth - KExit().Length(),  
                     iDisplaySize.iHeight - 1);    
    iConsole->Printf(KExit);
    }