/*
* Copyright (c) 2005-2010 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:  
*     This class is the container class of the CStartupTone.
*     Is used to play startup tone.
*
*/


// INCLUDE FILES
#include <Profile.hrh>
#include <centralrepository.h>
#include <StartupDomainCRKeys.h>
#include <ProfileEngineSDKCRKeys.h>
#include "StartupTone.h"
#include "StartupAppUi.h"
#include "AudioPreference.h"

#define MIN_VOLUME 0
#define MAX_VOLUME 10000

//=============================== MEMBER FUNCTIONS ============================
// ---------------------------------------------------------
// Constructor & destructor
// EPOC two phased constructor
// ---------------------------------------------------------
//
CStartupTone::CStartupTone( CStartupAppUi* aStartupAppUi ) :
    iTone( NULL ),
    iAudioReady( EFalse ),
    iPlaying( EFalse ),
    iStartupAppUi( aStartupAppUi ),
    iHiddenReset (EFalse ),
    iStartupWaitingForTone ( EFalse )
    {
    }

CStartupTone::~CStartupTone()
    {
    TRACES("CStartupTone::~CStartupTone()");

    if (iTone)
        {
        if (iPlaying)
            {
            TRACES("CStartupTone::~CStartupTone(): Still playing. Stop it!");
            iTone->Stop();
            }
        delete iTone;
        iTone = NULL;
        TRACES("CStartupTone::~CStartupTone(): iTone deleted");
        }
    TRACES("CStartupTone::~CStartupTone(): End");
    }

// ----------------------------------------------------
// CStartupTone::NewL( CStartupAppUi* aStartupAppUi )
// ----------------------------------------------------
CStartupTone* CStartupTone::NewL( CStartupAppUi* aStartupAppUi, TToneType aToneType )
    {
    TRACES("CStartupTone::NewL()");
    CStartupTone* self = new (ELeave) CStartupTone( aStartupAppUi );
    
    CleanupStack::PushL( self );
    self->ConstructL(aToneType);
    CleanupStack::Pop(); // self

    TRACES("CStartupTone::NewL(): End");
    return self;
    }

void CStartupTone::ConstructL(TToneType aToneType)
    {
    TRACES("CStartupTone::ConstructL()");
    // Check tone volume
    iVolume = GetRingingToneVolumeL();
    // Check if hidden reset
    iHiddenReset = iStartupAppUi->HiddenReset();

    iToneType = aToneType;

    if ((!iHiddenReset) && (iVolume))
        {
        TPath tonePath;
        TRACES("CStartupTone::ConstructL(): Get tone path from CenRep");

        CRepository* repository(NULL);

        TRAPD( err, repository = CRepository::NewL( KCRUidStartupConf ) );
        if ( err != KErrNone )
            {
            TRACES("CStartupTone::ConstructL(): End, ERROR: Failed to get startup tone path");
            return;
            }
        if (iToneType == EStartupTone)
            {
            TRACES("CStartupTone::ConstructL(): Tone type EStartupTone");
            err = repository->Get( KStartupTonePath, tonePath );
            }
        else
            {
            TRACES("CStartupTone::ConstructL(): Tone type EStartupOpTone");
            err = repository->Get( KStartupOperatorTonePath, tonePath );
            }
        delete repository;

        TRACES2("CStartupTone::ConstructL(): Get tone to play. err = %d, Path = '%S'", err, &tonePath );

        RFs fs;
        err = fs.Connect();
        TFindFile findExe(fs);
        err = findExe.FindByPath( tonePath, NULL );
        fs.Close();
        if (err != KErrNone)
            {
            TRACES1("CStartupTone::ConstructL(): Tone to play: Cannot find tone. err = %d", err);
            }
        else
            {
            TRACES("CStartupTone::ConstructL(): Tone found");
            iTone = CMdaAudioPlayerUtility::NewFilePlayerL(
                        tonePath, 
                        *this, KAudioPriorityPhonePower, 
                        TMdaPriorityPreference( KAudioPrefDefaultTone));
            }
        }
    }
// ---------------------------------------------------------
// void CStartupTone::Play()
// ---------------------------------------------------------
//

TInt CStartupTone::Play()
    {
    TRACES("CStartupTone::Play()");
    TRACES1("CStartupTone::Play(): Tone type: %d", iToneType);
    if (iAudioReady && !iHiddenReset && iVolume && iTone)
        {
        TRACES("CStartupTone::Play(): Audio ready. Play tone");
        iVolume = Max( MIN_VOLUME, Min( iVolume, MAX_VOLUME ) );
        iTone->SetVolume(iVolume);
        iTone->Play();
        iPlaying = ETrue;
        TRACES("CStartupTone::Play(): End, return KErrNone");
        return KErrNone;
        }
    else
        {
        TRACES("CStartupTone::Play(): Audio not ready, hidden reset, volume null or tone is not initialized. Unable to play tone.");
        TRACES1("CStartupTone::Play(): Audio ready:  %d",iAudioReady);
        TRACES1("CStartupTone::Play(): Hidden reset: %d",iHiddenReset);
        TRACES1("CStartupTone::Play(): Volume:       %d",iVolume);
        TRACES1("CStartupTone::Play(): Tone:         %d",iTone);
        TRACES("CStartupTone::Play(): End, return KErrNotReady");
        return KErrNotReady;
        }
    }

// ---------------------------------------------------------
// void CStartupTone::Stop()
// ---------------------------------------------------------
//

void CStartupTone::Stop()
    {
    TRACES("CStartupTone::Stop()");
    if (iTone)
        {
        TRACES("CStartupTone::Stop(): Stop the tone");
        iPlaying=EFalse;
        iTone->Stop();
        iToneType = EStartupNoTone;
        MapcPlayComplete(KErrNone);
        }
    TRACES("CStartupTone::Stop(): End");
    }

// ---------------------------------------------------------
// CStartupTone::ToneFound()
// ---------------------------------------------------------
//
TBool CStartupTone::ToneFound()
    {
    TBool status(EFalse);
    if(iTone)
        status = ETrue;
    return status;
    }

// ---------------------------------------------------------
// CStartupTone::AudioReady()
// ---------------------------------------------------------
//
TBool CStartupTone::AudioReady()
    {
    return iAudioReady;
    }

// ---------------------------------------------------------
// void CStartupTone::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
// ---------------------------------------------------------
//
void CStartupTone::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
    {
    TRACES("CStartupTone::MapcInitComplete()");
    if (aError == KErrNone)
        {
        TRACES("CStartupTone::MapcInitComplete(): Ready to play startup tone");
        iAudioReady = ETrue;
        }
    else
        {
        TRACES("CStartupTone::MapcInitComplete(): Unable to play startup tone");
        }
    TRACES("CStartupTone::MapcInitComplete(): End");
    }

// ---------------------------------------------------------
// void CStartupTone::MapcPlayComplete(TInt /*aError*/)
// ---------------------------------------------------------
//
void CStartupTone::MapcPlayComplete(TInt /*aError*/)
    {
    TRACES("StartupTone::MapcPlayComplete()");
    iPlaying=EFalse;
    if (iStartupWaitingForTone)
        {
        TRACES("StartupTone::MapcPlayComplete(): Startup waiting ");
        TRAPD(err, iStartupAppUi->ContinueStartupAfterToneL(iToneType));
        if (err != KErrNone)
            {
            TRACES1("CStartupTone::MapcPlayComplete(): ContinueStartupAfterToneL() leaves, err = %d", err );
            }
        }
    TRACES("StartupTone::MapcPlayComplete(): End");
    }

// ---------------------------------------------------------
// TBool CStartupTone::Playing()
// ---------------------------------------------------------
//
TBool CStartupTone::Playing()
    {
    TRACES1("StartupTone::Playing(): Return %d", iPlaying );
    return iPlaying;
    }

// ---------------------------------------------------------
// void CStartupTone::StartupWaiting()
// ---------------------------------------------------------
//
void CStartupTone::StartupWaiting(TBool aValue)
    {
    TRACES1("StartupTone::StartupWaiting(): aValue == %d", aValue);
    iStartupWaitingForTone = aValue;
    }

// ----------------------------------------------------------
// CStartupTone::GetRingingToneVolumeL
// Startup tone volume is always 4 but when ringing type is 
// silent or ringing volume is 0 or 1 startup tone is silent.
// ----------------------------------------------------------
//
TInt CStartupTone::GetRingingToneVolumeL()
    {
    TRACES("StartupTone::GetRingingToneVolumeL()");

    TInt retval(0);
    TInt ringingType(EProfileRingingTypeSilent);
    TInt ringingVol(0);
    
    CRepository* repository(NULL);

    TRAPD( err, repository = CRepository::NewL( KCRUidProfileEngine ) );
    if ( err != KErrNone )
        {
        TRACES("StartupTone::GetRingingToneVolumeL(): End, ERROR, Cannot connect to CenRep");
        return 0;    
        }

    User::LeaveIfError( repository->Get( KProEngActiveRingingVolume, ringingVol ));
    User::LeaveIfError( repository->Get( KProEngActiveRingingType, ringingType ));
    delete repository;

    TRACES1("StartupTone::GetRingingToneVolumeL(): Ringing tone volume = %d", ringingVol);
    TRACES1("StartupTone::GetRingingToneVolumeL(): Ringing type = %d", ringingType);

    if ((ringingType != EProfileRingingTypeSilent) && 
        (ringingVol != 0) &&
        (ringingVol != EProfileRingingVolumeLevel1))
        {
        TRACES("StartupTone::GetRingingToneVolumeL(): Get startup tone volume");
        TInt defaultRingingVol;
        CRepository* repository(NULL);

        TRAPD( err, repository = CRepository::NewL( KCRUidStartupConf ) );
        if ( err != KErrNone )
            {
            return 0;    
            }

        User::LeaveIfError( repository->Get( KStartupToneVolume, defaultRingingVol ));
        delete repository;

        ringingVol = defaultRingingVol;
        retval =  ringingVol;
        }

    TRACES1("StartupTone::GetRingingToneVolumeL(): End, return %d", retval);
    return retval;
    }

// End of File