/*

* 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 "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:

*

*/

// INCLUDE FILES

#include "audiofetcherdialogutils.h"

#include "audiofetcherlog.h"

#include <bautils.h>  // bafl.lib

#include <StringLoader.h>

#include <driveinfo.h>

#include <pathinfo.h>

#include <aknnavide.h>          // CAknNavigationDecorator

#include <aknnavilabel.h>       // CAknNaviLabel

#include <akntitle.h>           // CAknTitlePane

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <AknsUtils.h>          // AknsUtils

#include <data_caging_path_literals.hrh> // KDC_APP_RESOURCE_DIR

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

 * class CActiveCaller

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

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

// CActiveCaller::NewL

// 

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

//

CActiveCaller* CActiveCaller::NewL( MActiveCallerObserver* aObserver )

    {

    CActiveCaller* self = new (ELeave) CActiveCaller( aObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

 	return self;

    }

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

// Destructor

// 

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

//

CActiveCaller::~CActiveCaller()

    {

    WLOG("CActiveCaller::~CActiveCaller >");

 	Cancel();

	iTimer.Close();

	WLOG("CActiveCaller::~CActiveCaller <");

    }

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

// CActiveCaller::CActiveCaller

// 

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

//

CActiveCaller::CActiveCaller(MActiveCallerObserver* aObserver) : CActive(CActive::EPriorityStandard)

    {

	iObserver = aObserver;

    }

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

// CActiveCaller::ConstructL

// 

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

//

void CActiveCaller::ConstructL()

    {

    WLOG("CActiveCaller::ConstructL >");

	User::LeaveIfError( iTimer.CreateLocal() );

	CActiveScheduler::Add( this );

	WLOG("CActiveCaller::ConstructL <");

    }

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

// CActiveCaller::DoCancel

//

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

//

void CActiveCaller::DoCancel()

    {

    WLOG("CActiveCaller::DoCancel >");

 	iTimer.Cancel();

 	WLOG("CActiveCaller::DoCancel <");

    }

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

// CActiveCaller::RunL

//

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

//

void CActiveCaller::RunL()

    {

    WLOG("CActiveCaller::RunL >");

    TRAP_IGNORE( iObserver->HandleActiveCallL( iCallId ) );

    WLOG("CActiveCaller::RunL <");

    }

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

// CActiveCaller::Request

//

// This function calls this class RunL.

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

//

void CActiveCaller::Request()

    {

	Cancel();

	SetActive();

	TRequestStatus* status = &iStatus;

	User::RequestComplete( status, KErrNone );

    }

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

// CActiveCaller::Start

//

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

//

void CActiveCaller::Start( TInt aCallId, TInt aMilliseconds )

    {

    WLOG("CActiveCaller::Start >");

    const TInt KThousand = 1000;

    Cancel();

	iCallId = aCallId;

	if ( aMilliseconds <= 0 )

		{

		Request();  // no delay - complete asap

		}

	else

		{

	    iTimer.After( iStatus, aMilliseconds*KThousand );

	    SetActive();

		}

	WLOG("CActiveCaller::Start <");

    }

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

// CActiveCaller::Stop

//

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

//

void CActiveCaller::Stop()

    {

    WLOG("CActiveCaller::Stop >");

    Cancel();

    WLOG("CActiveCaller::Stop <");

    }

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

 * class CNaviPaneHandler

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

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

// Destructor

//

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

//

CNaviPaneHandler::~CNaviPaneHandler()

    {

    WLOG("CNaviPaneHandler::~CNaviPaneHandler >");

    if ( iNaviDecorator )

        {

        if ( iNaviPane && iNavidecoratorPushed )

            {

            iNaviPane->Pop( iNaviDecorator );

            }

        delete iNaviDecorator;

        }

    if ( iNaviPane && iNavipanePushed )

        {

        iNaviPane->Pop(); // restore previous navi pane

        }

    WLOG("CNaviPaneHandler::~CNaviPaneHandler <");

    }

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

// CNaviPaneHandler::CNaviPaneHandler

//

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

//

CNaviPaneHandler::CNaviPaneHandler( CEikStatusPane* aStatusPane ) : iStatusPane( aStatusPane )

    {

    iNavidecoratorPushed = EFalse;

    iNavipanePushed = EFalse;

    if ( iStatusPane )

        {

        TRAP_IGNORE( iNaviPane = (CAknNavigationControlContainer*)iStatusPane->ControlL(TUid::Uid(EEikStatusPaneUidNavi)) );

        }

    }

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

// CNaviPaneHandler::SetNaviPaneTitleL

// 

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

//

void CNaviPaneHandler::SetNaviPaneTitleL(const TDesC& aTitle)

    {

    if ( !iStatusPane || !iNaviPane )

        {

        return;

        }

    if ( iNaviDecorator )

        {

        CAknNaviLabel* naviLabel = static_cast<CAknNaviLabel*>(iNaviDecorator->DecoratedControl());

        if ( naviLabel )

            {

            naviLabel->SetTextL( aTitle );

            iNaviDecorator->DrawDeferred();

            }

        }

     else

        {

        iNaviDecorator = iNaviPane->CreateNavigationLabelL( aTitle ) ;

        iNaviPane->PushL( *iNaviDecorator ); // activate navi label in navi pane

        iNavidecoratorPushed = ETrue;

        }

    }

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

// CNaviPaneHandler::StoreNavipaneL

// 

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

//

void CNaviPaneHandler::StoreNavipaneL()

    {

    if ( !iNaviPane || !iStatusPane || iNavipanePushed )

        {

        return;

        }

    if ( iStatusPane->PaneCapabilities(TUid::Uid(EEikStatusPaneUidTitle)).IsPresent() )

        {

        iNaviPane->PushDefaultL();

        iNavipanePushed = ETrue;

        }

    }

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

 * class CStatusPaneHandler

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

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

// CStatusPaneHandler::NewL

//

// Two-phased constructor.

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

//

CStatusPaneHandler* CStatusPaneHandler::NewL( CAknAppUi* aAppUi )

    {

    CStatusPaneHandler* self = new (ELeave) CStatusPaneHandler( aAppUi );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

//

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

//

CStatusPaneHandler::~CStatusPaneHandler()

    {

    WLOG("CStatusPaneHandler::~CStatusPaneHandler >");

    TRAP_IGNORE( RestoreOriginalTitleL() );

    delete iNaviPaneHandler;

    WLOG("CStatusPaneHandler::~CStatusPaneHandler <");

    }

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

// CStatusPaneHandler::ConstructL

//

// Symbian 2nd phase constructor can leave.

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

//

void CStatusPaneHandler::ConstructL()

    {

    WLOG("CStatusPaneHandler::ConstructL >");

    iNaviPaneHandler = new (ELeave) CNaviPaneHandler( iAppUi->StatusPane() );

    WLOG("CStatusPaneHandler::ConstructL <");

    }

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

// CStatusPaneHandler::CStatusPaneHandler

//

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

//

CStatusPaneHandler::CStatusPaneHandler( CAknAppUi* aAppUi ) : iAppUi(aAppUi )

    {

    //__ASSERT_ALWAYS( iAppUi, User::Panic( KErrGeneral ) );

    iOriginalTitleStored = EFalse;

    iOriginalTitle = KNullDesC;

    }

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

// CStatusPaneHandler::GetTitleL

// 

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

//

TBool CStatusPaneHandler::GetTitleL( CAknAppUi* aAppUi, TDes& aTitle )

    {

    aTitle = KNullDesC;

    CEikStatusPane* statusPane = aAppUi->StatusPane();

    if (statusPane && statusPane->PaneCapabilities( TUid::Uid( EEikStatusPaneUidTitle ) ).IsPresent() )

        {

        CAknTitlePane* titlePane = static_cast<CAknTitlePane*>

            ( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

        if ( titlePane->Text() ) 

            {

            StrCopy( aTitle, *titlePane->Text() );

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CStatusPaneHandler::SetTitleL

// 

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

//

TBool CStatusPaneHandler::SetTitleL( CAknAppUi* aAppUi, const TDesC& aTitle )

    {

    CEikStatusPane* statusPane = aAppUi->StatusPane();

    if ( statusPane && statusPane->PaneCapabilities( TUid::Uid( EEikStatusPaneUidTitle ) ).IsPresent() )

        {

        CAknTitlePane* titlePane = static_cast<CAknTitlePane*>

            ( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

        if ( titlePane->Text() ) 

            {

            titlePane->SetTextL( aTitle );

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CStatusPaneHandler::SetNaviPaneTitleL

// 

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

//

void CStatusPaneHandler::SetNaviPaneTitleL( const TDesC& aTitle )

    {

    iNaviPaneHandler->SetNaviPaneTitleL( aTitle );

    }

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

// CStatusPaneHandler::SetNaviPaneTitle

// 

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

//

void CStatusPaneHandler::SetNaviPaneTitle( const TDesC& aTitle )

    {

    TRAP_IGNORE( iNaviPaneHandler->SetNaviPaneTitleL( aTitle ) );

    }

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

// CStatusPaneHandler::SetNaviPaneTitleL

// 

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

//

void CStatusPaneHandler::SetNaviPaneTitleL( TInt aResource )

    {

    HBufC* hBuf = StringLoader::LoadLC( aResource) ;

    SetNaviPaneTitleL( hBuf->Des() );

    CleanupStack::PopAndDestroy( hBuf );

    }

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

// CStatusPaneHandler::StoreNavipaneL

// 

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

//

void CStatusPaneHandler::StoreNavipaneL()

    {

    iNaviPaneHandler->StoreNavipaneL();

    }

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

// CStatusPaneHandler::StoreOriginalTitleL

// 

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

//

void CStatusPaneHandler::StoreOriginalTitleL()

    {

    TBool ret = GetTitleL( iAppUi, iOriginalTitle );

    if ( ret )

        {

        iOriginalTitleStored = ETrue;

        }

    }

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

// CStatusPaneHandler::RestoreOriginalTitleL

// 

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

//

void CStatusPaneHandler::RestoreOriginalTitleL()

    {

    if ( iOriginalTitleStored )

        {

        SetTitleL( iAppUi, iOriginalTitle );

        }

    }

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

// CStatusPaneHandler::SetTitleL

// 

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

//

void CStatusPaneHandler::SetTitleL( const TDesC& aText )

    {

    if ( iOriginalTitleStored )

        {

        SetTitleL( iAppUi, aText );

        }

    }

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

// CStatusPaneHandler::SetTitleL

// 

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

//

void CStatusPaneHandler::SetTitleL( TInt aResourceId )

    {

    HBufC* hBuf = StringLoader::LoadLC( aResourceId );

    SetTitleL( hBuf->Des() );

    CleanupStack::PopAndDestroy( hBuf );

    }

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

// CStatusPaneHandler::StrCopy

//

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

//

void CStatusPaneHandler::StrCopy( TDes& aTarget, const TDesC& aSource )

    {

    WLOG("CStatusPaneHandler::StrCopy >");

    TInt len = aTarget.MaxLength();

    if( len < aSource.Length() ) 

        {

        aTarget.Copy( aSource.Left(len) );

        return;

        }

    aTarget.Copy( aSource );

    WLOG("CStatusPaneHandler::StrCopy <");

    }

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

 * class CDriveUtil

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

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

// CDriveUtil::NewL

// 

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

//

CDriveUtil* CDriveUtil::NewL()

    {

    CDriveUtil* self = new (ELeave) CDriveUtil();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );