// Copyright (c) 2009 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:
// USB Mass Storage Application - also used as an improvised boot loader mechanism
//
//



/**
 @file
*/

#include <e32cons.h>
#include <f32file.h>

#include "rusbotgsession.h"

#include "usbtypes.h"
#include "mdrivedisplay.h"
#include "cdisplay.h"

// Display positions and test constants
// Number of attached devices
static const TInt KRow_DevicesNumber = 13;
_LIT(KMsg_DevicesAttached, "USB Devices Attached = %d");

// Device Map
static const TInt KStartRow_DeviceMap = KRow_DevicesNumber + 2;
static const TInt KMaxRows_DeviceMap = 4;
_LIT(KMsg_DeviceMap_DriveList, "%d: ");          // [drive index]
_LIT(KMsg_DeviceMap_DriveLunEntry, "%c ");       // [drive letter]


// Drive Map
static const TInt KStartRow_DriveMap = KStartRow_DeviceMap + KMaxRows_DeviceMap;
static const TInt KMaxRows_DriveMap = 4;
_LIT(KMsg_DriveMap_EntryLetter, "%c token = %d");           // [drive letter] [token]
_LIT(KDbgMsg_DriveMap_EntryLetter, "*** %c token = %d");    // [drive letter] [token]

// System Status
static const TInt KStartRow_UpTime = 28;
_LIT(KMsg_UpTime, "up time     : %dh:%dm:%ds   ");	// use trailing space to overwrite any leftover chars in line

static const TInt KStartRow_MemoryFree = 29;
_LIT(KMsg_MemoryFree, "mem (bytes) : 0x%X");

// User Keys
static const TInt KStartRow_UserKeys = 25;
_LIT(KMsgUser1Keys, "[Esc]=Quit [A-Z]=DriveInfo");
_LIT(KMsgUser2Keys, "[F5]=Hub update");


// Scroll Window status
_LIT(KScrollWindowStatus, "Page %d of %d");

// Available drives
static const TInt KStartRow_AvailableDrives = 1;
_LIT(KAvailDriveMsg, "Drives: ");

_LIT(KDriveAtts,"DriveList %c: %02x ");

// Drive info
static const TInt KStartRow_MsgWindow = 3;
static const TInt KStartRow_DriveInfo = KStartRow_MsgWindow;

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


CScrollWindow* CScrollWindow::NewL(CConsoleBase& aConsole)
    {
	CScrollWindow* r = new (ELeave) CScrollWindow(aConsole);
	CleanupStack::PushL(r);
	r->ConstructL();
    CleanupStack::Pop(r);
	return r;
    }


void CScrollWindow::ConstructL()
    {

    }


CScrollWindow::CScrollWindow(CConsoleBase& aConsole)
:   iConsole(aConsole)
    {
    }

CScrollWindow::~CScrollWindow()
    {
    iLineArray.Close();
    }

void CScrollWindow::Reset()
    {
    iPage = 0;
    iLineArray.Reset();
    }


void CScrollWindow::AppendL(const TDesC& aLine)
    {
    iTmpLine.Zero();
    iLineArray.AppendL(iTmpLine);
    TInt last = iLineArray.Count() - 1;
    iLineArray[last].Copy(aLine);
    }


TLine* CScrollWindow::NewLineL()
    {
    iTmpLine.Zero();
    iLineArray.AppendL(iTmpLine);
    TInt last = iLineArray.Count() - 1;
    return &iLineArray[last];
    }


void CScrollWindow::Update()
    {
    TInt line = iPage * KPageLength;

    TInt row = KStartRow_DriveInfo;
    do
        {
        iConsole.SetPos(0, row + line%KPageLength);
        if (line < iLineArray.Count())
            {
            iConsole.Printf(iLineArray[line]);
            }
        iConsole.ClearToEndOfLine();
        line++;
        }
    while (((line-1)%KPageLength) != (KPageLength - 1));
    iConsole.SetPos(0, KStartRow_DriveInfo + KPageLength);
    iConsole.Printf(KScrollWindowStatus, iPage + 1, iLineArray.Count()/KPageLength + 1);
    }

void CScrollWindow::PageInc()
    {
    TInt lastPage = iLineArray.Count()/KPageLength;
    if (iPage == lastPage)
        {
        iPage = 0;
        }
    else
        {
        iPage++;
        }
    }


void CScrollWindow::PageDec()
    {
    if (iPage == 0)
        {
        TInt lastPage = iLineArray.Count()/KPageLength;
        iPage = lastPage;
        }
    else
        {
        iPage--;
        }
    }



CDisplay* CDisplay::NewLC(RFs& aFs, CConsoleBase& aConsole)
    {
	CDisplay* r = new (ELeave) CDisplay(aFs, aConsole);
	CleanupStack::PushL(r);
	r->ConstructL();
	return r;
    }


void CDisplay::ConstructL()
    {
    iScrollWindow = CScrollWindow::NewL(iConsole);
    }


CDisplay::CDisplay(RFs& aFs, CConsoleBase& aConsole)
:   iFs(aFs),
    iConsole(aConsole)
    {
    iConsole.ClearScreen();
    }


CDisplay::~CDisplay()
    {
    delete iScrollWindow;
    }


void CDisplay::Menu()
    {
    iConsole.SetPos(0, KStartRow_UserKeys);
    iConsole.Printf(KMsgUser1Keys);
    iConsole.SetPos(0, KStartRow_UserKeys + 1);
    iConsole.Printf(KMsgUser2Keys);
    iCursorPos = iConsole.CursorPos();
    }


void CDisplay::DriveListL() const
{
    TDriveList drivelist;
    TRAPD(err, iFs.DriveList(drivelist));
    if (err)
        {
        return;
        }
    // A TDriveList (the list of available drives), is an array of
    // 26 bytes. Each byte with a non zero value signifies that the
    // corresponding drive is available.
    TBuf<KDisplayWidth> iLineBuffer;
    iLineBuffer = KAvailDriveMsg;
    TChar driveLetter;

    for (TInt driveNumber = EDriveA; driveNumber <= EDriveZ;driveNumber++)
        {
        if (drivelist[driveNumber]) // if drive-list entry non-zero, drive is available
            {
            // overflow check
            if (iLineBuffer.Length() == iLineBuffer.MaxLength())
                {
                iLineBuffer[iLineBuffer.MaxLength() - 1] = '>';
                break;
                }

            User::LeaveIfError(iFs.DriveToChar(driveNumber,driveLetter));

            // The following line prints the drive letter followed by the hex value
            // of the integer indicating that drive's attributes
            RDebug::Print(KDriveAtts,TUint(driveLetter), drivelist[driveNumber]);
            iLineBuffer.Append(driveLetter);

            }
        }

	iConsole.SetPos(0, KStartRow_AvailableDrives);
    iConsole.Printf(iLineBuffer);
	iConsole.ClearToEndOfLine();
    CursorHome();
}


void CDisplay::DevicesNumber(TInt aDevicesNumber) const
    {
	iConsole.SetPos(0, KRow_DevicesNumber);
	iConsole.Printf(KMsg_DevicesAttached, aDevicesNumber);
	iConsole.ClearToEndOfLine();
    }


void CDisplay::DriveMapL(const TDriveMap& aDriveMap) const
    {
    TChar letter;

    TInt i = 0;

    // Output to debug port
    for (; i < aDriveMap.Count(); i++)
        {
        TToken token = aDriveMap[i];
        if (token)
            {
            User::LeaveIfError(iFs.DriveToChar(i, letter));
            RDebug::Print(KDbgMsg_DriveMap_EntryLetter, TUint(letter), token);
            }
        }

    // Output to console
    TInt row = KStartRow_DriveMap;
    for (i = (aDriveMap.Count() -1); i >= 0  &&  row < (KStartRow_DriveMap + KMaxRows_DriveMap); i--)
        {
        TToken token = aDriveMap[i];
        if (token)
            {
            User::LeaveIfError(iFs.DriveToChar(i, letter));
            iConsole.SetPos(0, row);
            iConsole.Printf(KMsg_DriveMap_EntryLetter, TUint(letter), token);
            iConsole.ClearToEndOfLine();
            row++;
            }
        }

    for (; row < KStartRow_DriveMap + KMaxRows_DriveMap; row++)
        {
        iConsole.SetPos(0, row);
        iConsole.ClearToEndOfLine();
        }
    }


void CDisplay::DeviceMapL(TInt aRow, TInt deviceIndex, const TDeviceMap& aDeviceMap) const
    {
    TChar letter;
    TInt drive;

    // Output to debug port
    RDebug::Printf("*** deviceIndex = %d", deviceIndex);
    for (TInt lunIndex = 0; lunIndex < 16; lunIndex++)
        {
        drive = aDeviceMap[lunIndex];

        if (drive == 0)
            break;

        User::LeaveIfError(iFs.DriveToChar(drive, letter));
        RDebug::Printf("*** drive=%d %c", drive, TUint(letter));
        }

    //  Output to console
    if (aRow >= KMaxRows_DeviceMap)
        {
        return;
        }
    RDebug::Printf("-----> Device MAP %x", deviceIndex);
    TInt row = KStartRow_DeviceMap + aRow;
    iConsole.SetPos(0, row);
    iConsole.Printf(KMsg_DeviceMap_DriveList, deviceIndex);

    for (TInt lunIndex = 0; lunIndex < 16; lunIndex++)
        {
        drive = aDeviceMap[lunIndex];

        if (drive == 0)
            break;

        User::LeaveIfError(iFs.DriveToChar(drive, letter));
        iConsole.Printf(KMsg_DeviceMap_DriveLunEntry, TUint(letter));
        iConsole.ClearToEndOfLine();
        }
    }


void CDisplay::DeviceMapClear(TInt aRow) const
    {
    TInt row = KStartRow_DeviceMap;

    if (aRow > KMaxRows_DeviceMap)
        return;

    for (row = KStartRow_DeviceMap + aRow; row < KStartRow_DeviceMap + KMaxRows_DeviceMap; row++)
        {
        iConsole.SetPos(0, row);
        iConsole.ClearToEndOfLine();
        }
    }


void CDisplay::GetDriveInfoL(TChar aChar)
    {
    iScrollWindow->Reset();

    TDriveInfo driveInfo;

    TInt driveNumber;
    User::LeaveIfError(iFs.CharToDrive(aChar, driveNumber));

    TLine* line;
    line = iScrollWindow->NewLineL();
    _LIT(KDrive,"Drive=%d %C");
    line->Format(KDrive, driveNumber, TInt(aChar.GetUpperCase()));

    iFs.Drive(driveInfo, driveNumber);
    if (driveInfo.iDriveAtt == KDriveAbsent)
        {
        _LIT(KTxt_MappingDriveError, "Drive absent !");
        iScrollWindow->AppendL(KTxt_MappingDriveError);
        return;
        }

    FormatDriveInfoL(driveInfo);

    TVolumeInfo volumeInfo;

    TInt err = iFs.Volume(volumeInfo, driveNumber);
    if (err != KErrNotReady)
        // Volume() returns KErrNotReady if no volume present.
        // In this case, check next drive number
        {
        FormatVolumeInfoL(volumeInfo);
        }
    }


void CDisplay::DriveInfo()
    {
    iScrollWindow->Update();
    CursorHome();
    }

void CDisplay::FormatDriveInfoL(const TDriveInfo& aDriveInfo)
    {
    // Append battery, media and drive information to aBuffer
    // Define descriptor constants using the _LIT macro
    _LIT(KDriveInfo1, "iType=%02x    iDriveAtt=%02x");
    _LIT(KDriveInfo2, "iBattery=%02x iMediaAtt=%02x");
    _LIT(KBatLow,"Battery low");
    _LIT(KBatGood,"Battery good");
    _LIT(KBatNotSupported,"Battery not supported");
    _LIT(KNotPresent,"No media present");
    _LIT(KFloppy,"Media is floppy disk");
    _LIT(KHard,"Media is hard disk");
    _LIT(KCDROM,"Media is CD-ROM");
    _LIT(KRam,"Media is RAM");
    _LIT(KFlash,"Media is flash");
    _LIT(KRom,"Media is ROM");
    _LIT(KRemote,"Media is remote");
    _LIT(KNANDFlash,"Media is NAND flash");
    _LIT(KUnknown,"Media unknownl");
    _LIT(KDriveAtts,"Drive attributes:");
    _LIT(KLocal," local");
    _LIT(KROMDrive," ROM");
    _LIT(KRedirected," redirected");
    _LIT(KSubstituted," substituted");
    _LIT(KInternal," internal");
    _LIT(KRemovable," removable");
    _LIT(KMediaAtts,"Media attributes:");
    _LIT(KDynamic," dynamic");
    _LIT(KDual," dual-density");
    _LIT(KFormattable," formattable");
    _LIT(KLockable," lockable");
    _LIT(KLocked," locked");
    _LIT(KHasPassword," has password");
    _LIT(KWriteProtected," write-protected");

    TLine* line;
    line = iScrollWindow->NewLineL();
    line->Format(KDriveInfo1, TInt(aDriveInfo.iType), TInt(aDriveInfo.iDriveAtt));

    line = iScrollWindow->NewLineL();
    line->Format(KDriveInfo2, TInt(aDriveInfo.iBattery), TInt(aDriveInfo.iMediaAtt));

    line = iScrollWindow->NewLineL();
    switch (aDriveInfo.iBattery)
        {
        case EBatLow:
            line->Append(KBatLow);
            break;
        case EBatGood:
            line->Append(KBatGood);
            break;
        default:
            line->Append(KBatNotSupported);
        }

    line = iScrollWindow->NewLineL();
    switch (aDriveInfo.iType)
            {
        case EMediaNotPresent:
            line->Append(KNotPresent);
            break;
        case EMediaFloppy:
            line->Append(KFloppy);
            break;
        case EMediaHardDisk:
            line->Append(KHard);
            break;
        case EMediaCdRom:
            line->Append(KCDROM);
            break;
        case EMediaRam:
            line->Append(KRam);
            break;
        case EMediaFlash:
            line->Append(KFlash);
            break;
        case EMediaRom:
            line->Append(KRom);
            break;
        case EMediaRemote:
            line->Append(KRemote);
            break;
        case EMediaNANDFlash:
            line->Append(KNANDFlash);
            break;
        default:
            line->Append(KUnknown);

        }

        // Drive Attributes
        line = iScrollWindow->NewLineL();
        line->Append(KDriveAtts);
        if (aDriveInfo.iDriveAtt & KDriveAttLocal)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KLocal);
            }
        if (aDriveInfo.iDriveAtt & KDriveAttRom)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KROMDrive);
            }
        if (aDriveInfo.iDriveAtt & KDriveAttRedirected)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KRedirected);
            }
        if (aDriveInfo.iDriveAtt & KDriveAttSubsted)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KSubstituted);
            }
        if (aDriveInfo.iDriveAtt & KDriveAttInternal)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KInternal);
            }
        if (aDriveInfo.iDriveAtt & KDriveAttRemovable)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KRemovable);
            }

        // Media Attributes
        line = iScrollWindow->NewLineL();
        line->Append(KMediaAtts);
        if (aDriveInfo.iMediaAtt & KMediaAttVariableSize)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KDynamic);
            }
        if (aDriveInfo.iMediaAtt & KMediaAttDualDensity)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KDual);
            }
        if (aDriveInfo.iMediaAtt & KMediaAttFormattable)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KFormattable);
            }
        if (aDriveInfo.iMediaAtt & KMediaAttWriteProtected)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KWriteProtected);
            }
        if (aDriveInfo.iMediaAtt & KMediaAttLockable)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KLockable);
            }

        if (aDriveInfo.iMediaAtt & KMediaAttLocked)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KLocked);
            }
        if (aDriveInfo.iMediaAtt & KMediaAttHasPassword)
            {
            line = iScrollWindow->NewLineL();
            line->Append(KHasPassword);
            }
    }

void CDisplay::FormatVolumeInfoL(const TVolumeInfo& aVolumeInfo)
    {
    // Append volume information to line
    _LIT(KUID,  "Unique ID:  0x%08X");
    _LIT(KSize, "Size:       0x%LX bytes");
    _LIT(KFree, "Free space: 0x%LX bytes");
    _LIT(KVolName, "Volume name: %S");
    TLine* line;
    line = iScrollWindow->NewLineL();
    line->Format(KUID, aVolumeInfo.iUniqueID);
    line = iScrollWindow->NewLineL();
    line->Format(KSize, aVolumeInfo.iSize);
    line = iScrollWindow->NewLineL();
    line->Format(KFree, aVolumeInfo.iFree);
    line = iScrollWindow->NewLineL();
    line->Format(KVolName, &aVolumeInfo.iName);

    }


void CDisplay::UpTime(TUint aUpTime) const
    {
    TUint totalMins = aUpTime/60;
    TUint totalHrs = totalMins/60;
    iConsole.SetPos(0, KStartRow_UpTime);
    iConsole.Printf(KMsg_UpTime, totalHrs, totalMins%60, aUpTime%60);
    CursorHome();
    }

void CDisplay::MemoryFree(TInt aBytes) const
    {
	iConsole.SetPos(0, KStartRow_MemoryFree);
	iConsole.Printf(KMsg_MemoryFree, aBytes);
    CursorHome();
    }


//////////////////////////////////////////////////////////////////////////////
//
// CMessageKeyProcessor
//
//////////////////////////////////////////////////////////////////////////////
CMessageKeyProcessor::CMessageKeyProcessor(CDisplay& aDisplay, RUsbOtgSession& aUsbOtgSession)
:   CActive(CActive::EPriorityUserInput),
    iDisplay(aDisplay),
    iUsbOtgSession(aUsbOtgSession)
	{
	}

CMessageKeyProcessor* CMessageKeyProcessor::NewLC(CDisplay& aDisplay, RUsbOtgSession& aUsbOtgSession)
	{
	CMessageKeyProcessor* self=new (ELeave) CMessageKeyProcessor(aDisplay, aUsbOtgSession);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}


void CMessageKeyProcessor::ConstructL()
	{
	// Add to active scheduler
	CActiveScheduler::Add(this);
	RequestCharacter();
	}


CMessageKeyProcessor::~CMessageKeyProcessor()
	{
	// Make sure we're cancelled
	Cancel();
	}

void CMessageKeyProcessor::DoCancel()
	{
	iDisplay.ReadCancel();
	}

void CMessageKeyProcessor::RunL()
	{
	  // Handle completed request
	ProcessKeyPressL(iDisplay.KeyCode());
	}

void CMessageKeyProcessor::RequestCharacter()
	{
	// A request is issued to the CConsoleBase to accept a
	// character from the keyboard.
	iDisplay.Read(iStatus);
	SetActive();
	}

void CMessageKeyProcessor::ProcessKeyPressL(TKeyCode aKeyCode)
	{
    TBool done = HandleKeyL(aKeyCode);

    if (done)
        {
        CActiveScheduler::Stop();
        return;
        }

    RequestCharacter();
	}


TBool CMessageKeyProcessor::HandleKeyL(TKeyCode aKeyCode)
    {
    TBool done = EFalse;
    if (TChar(aKeyCode).IsAlpha())
        {
        iDisplay.GetDriveInfoL(aKeyCode);
        iDisplay.DriveInfo();
        return done;
        }

    switch (aKeyCode)
        {
        case EKeyF5:
            {
            // Update USB status
            iUsbOtgSession.DeviceInserted();
            iDisplay.DriveListL();
            }
            break;

        case EKeyUpArrow:
        case EKeyPageUp:
            iDisplay.PageDec();
            iDisplay.DriveInfo();
            break;
        case EKeyDownArrow:
        case EKeyPageDown:
            iDisplay.PageInc();
            iDisplay.DriveInfo();
            break;
        case EKeyEscape:
            done = ETrue;
            break;
        default:
            break;
        }
    return done;
    }


