/*

* 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:  This class is used for volume setting

*

*/

//  INCLUDE FILES

#include "cmmaplayer.h"

#include "cmmavolumecontrol.h"

#include <jdebug.h>

#include <MProfile.h>

#include <MProfileEngine.h>

#include <CProfileChangeNotifyHandler.h>

_LIT(KMMAVolumeErrorMsg, "Can't set volume level");

const TInt KMMAJavaSoundIndex = 0;

const TInt KMMAProfileSoundIndex = 1;

const TInt KMMAGlobalVolumeSoundIndex = 2;

const TInt KAudioEarpiece = 3;

void CMMAVolumeControl::StaticSetLevelL(CMMAVolumeControl* aVolumeControl,

                                        TInt aLevel)

{

    // Java level is the first

    aVolumeControl->SetVolumeLevelL(KMMAJavaSoundIndex, aLevel);

}

void CMMAVolumeControl::StaticGetLevelL(CMMAVolumeControl* aVolumeControl,

                                        TInt* aLevel)

{

    // Java level is the first

    aVolumeControl->GetVolumeLevelL(KMMAJavaSoundIndex, aLevel);

}

EXPORT_C CMMAVolumeControl::CMMAVolumeControl(CMMAPlayer* aPlayer)

        : iPlayer(aPlayer), iLevel(KMMAVolumeMaxLevel)

{

}

EXPORT_C CMMAVolumeControl::~CMMAVolumeControl()

{

    delete iProfChangeNotifier;

    iLevels.Close();

}

EXPORT_C void CMMAVolumeControl::ConstructBaseL()

{

    iPlayer->AddStateListenerL(this);

    // Add level for javasound, will set in StaticSetLevelL method.

    SetJavaSoundVolumeLevelL();

    SetProfileSoundVolumeLevelL();

    // Sets level to 0 if profile isn't on

    iLevel = CalculateLevel();

    // The default value is not yet known. Volume control may change the

    // volume of the controller before it has been retrieved so when the

    // state of the player is changed the Java volume is retrieved from

    // the controller.

    iLevels[ KMMAJavaSoundIndex ] = KErrNotFound;

}

void CMMAVolumeControl::SetJavaSoundVolumeLevelL()

{

    // In constructor iLevels array is empty and Java level will be the first,

    // KMMAJavaSoundIndex.

    AddLevelL();

}

void CMMAVolumeControl::SetProfileSoundVolumeLevelL()

{

    // Add level for profile, level's index will be 1, KMMAProfileSoundIndex

    AddLevelL();

}

void CMMAVolumeControl::SetProfilesBasedSoundMutingL()

{

    //Get the current active profile id.

    MProfileEngine* lProfileEngine = CreateProfileEngineL();

    iProfileId =lProfileEngine->ActiveProfileId();

    lProfileEngine->Release();

    // if profile is silent or meeting and no headset or bluetooth device

    // connected,set profile volume level to 0, otherwise keep the original

    // value 100

    if ( (EProfileSilentId == iProfileId || EProfileMeetingId == iProfileId)&&

            iAudioOutputPreference != KAudioEarpiece )

    {

        iLevels[ KMMAProfileSoundIndex ] = 0;

    }

    // Gets notfication about profile changes

    // Notification is sent to MProfileChangeObserver::HandleActiveProfileEventL()

    iProfChangeNotifier = CProfileChangeNotifyHandler::NewL( this );

    // Sets level to 0 if profile isn't on

    iLevel = CalculateLevel();

}

EXPORT_C void CMMAVolumeControl::HandleActiveProfileEventL(

                                 TProfileEvent aProfileEvent, TInt aProfileId)

{

    switch (aProfileEvent)

    {

    case EProfileNewActiveProfile:

    {

        // New profile is activated

        // Update the volume level, if profile is changed to silent or meeting

        // then mute it, if no headset or bluetooth device is connected

        // else set it to max volume level

        TInt level = 0;

        iProfileId = aProfileId;

        if ( EProfileSilentId != aProfileId &&

                EProfileMeetingId != aProfileId)

        {

            level = KMMAVolumeMaxLevel;

        }

        else if (iAudioOutputPreference == KAudioEarpiece)

        {

            level = KMMAVolumeMaxLevel;

        }

        else

        {

            level = 0;

        }

        TRAPD( error, SetVolumeLevelL( KMMAProfileSoundIndex, level ) );

        if ( error != KErrNone )

        {

            iPlayer->PostStringEvent( CMMAPlayerEvent::EError,

                                      KMMAVolumeErrorMsg );

        }

        break;

    }

    default: // do nothing

        break;

    }

}

EXPORT_C const TDesC& CMMAVolumeControl::ClassName() const

{

    return KMMAVolumeControlName;

}

void CMMAVolumeControl::SetLevelL(TInt aLevel)

{

    // Level cannot be set to derived control if player is not prefetched.

    if (iPlayer->State() > CMMAPlayer::ERealized)

    {

        DoSetLevelL(aLevel);

    }

    iLevel = aLevel;

}

EXPORT_C void CMMAVolumeControl::StateChanged(TInt aState)

{

    DEBUG_INT("CMMAVolumeControl::StateChanged - state %d", aState);

    // Set the volume if the player is prefetched

    if (aState == CMMAPlayer::EPrefetched)

    {

        TRAPD(error,

        {

            // Get the default value for the Java sound level

            if (iLevels[ KMMAJavaSoundIndex ] == KErrNotFound)

            {

                iLevels[ KMMAJavaSoundIndex ] = DoGetLevelL();

                iLevel = CalculateLevel();

            }

            SetLevelL(iLevel);

        });

        if (error != KErrNone)

        {

            iPlayer->PostStringEvent(CMMAPlayerEvent::EError,

                                     KMMAVolumeErrorMsg);

        }

    }

    // Level is already set for Global Volume so no need to set it again

    // Notify the initial global volume value to java

    // Notify only if STATE == CMMAPlayer::ERealized

    // Error ID AKUR-7G69Q5 GLOBAL VOLUME EVENT CR

    if (aState == CMMAPlayer::ERealized)

    {

        if ((iLevels.Count() - 1) == KMMAGlobalVolumeSoundIndex)

        {

            if ((iLevels[ KMMAGlobalVolumeSoundIndex ] != KErrNotFound) && 

            (iLevels[ KMMAGlobalVolumeSoundIndex] != iInitialGlobalVolumeLevel))

            {

                DEBUG("MMA::CMMAVolumeControl::StateChanged : Post GLOBAL VOL EVENT  ");

                DEBUG_INT("MMA::CMMAVolumeControl::StateChanged : Post complete Val = %d ",

                                       iLevels[ KMMAGlobalVolumeSoundIndex ]);

                iPlayer->PostLongEvent(CMMAPlayerEvent::ENOKIA_EXTERNAL_VOLUME_EVENT,

                                       iLevels[ KMMAGlobalVolumeSoundIndex ]);

            }

        }

    }

}

EXPORT_C void CMMAVolumeControl::RefreshVolume()

{

    DEBUG("MMA::CMMAVolumeControl::RefreshVolume ++ ");

    TRAPD(error,

    {

        // Get the default value for the Java sound level

        if (iLevels[ KMMAJavaSoundIndex ] == KErrNotFound)

        {

            iLevels[ KMMAJavaSoundIndex ] = DoGetLevelL();

            iLevel = CalculateLevel();

        }

        SetLevelL(iLevel);

    });

    if (error != KErrNone)

    {

        iPlayer->PostStringEvent(CMMAPlayerEvent::EError,

                                 KMMAVolumeErrorMsg);

    }

    DEBUG("MMA::CMMAVolumeControl::RefreshVolume -- ");

}

EXPORT_C void CMMAVolumeControl::RefreshControl()

{

    RefreshVolume();

}

EXPORT_C TInt CMMAVolumeControl::AddLevelL()

{

    User::LeaveIfError(iLevels.Append(KMMAVolumeMaxLevel));

    // New level is the last element

    return iLevels.Count() - 1;

}

EXPORT_C void CMMAVolumeControl::SetVolumeLevelL(TInt aLevelIndex,

        TInt aVolumeLevel)

{

    DEBUG_INT2("CMMAVolumeControl::SetVolumeLevelL - setting index %d, level %d",

               aLevelIndex, aVolumeLevel);

    if (0 >= iLevels.Count() ||  iLevels.Count() > 4)

    {

        return ;

    }

    TInt oldVolumeLevel = iLevels[ aLevelIndex ];

    iLevels[ aLevelIndex ] = aVolumeLevel;

    SetLevelL(CalculateLevel());

    // send event if level is really changed

    if ((aLevelIndex == KMMAJavaSoundIndex) &&

            (aVolumeLevel != oldVolumeLevel))

    {

        iPlayer->PostObjectEvent(CMMAPlayerEvent::EVolumeChanged,

                                 iControlObject);

    }

    // send event if global volume level is really changed

    // Error ID AKUR-7G69Q5 GLOBAL VOLUME EVENT CR

    if ((aLevelIndex == KMMAGlobalVolumeSoundIndex) &&

            (aVolumeLevel != oldVolumeLevel))

    {

        iPlayer->PostLongEvent(CMMAPlayerEvent::ENOKIA_EXTERNAL_VOLUME_EVENT,

                               iLevels[ aLevelIndex ]);

    }

}

void CMMAVolumeControl::InitializeGlobalVolumeLevel(TInt aGlobalVolumeLevel)

{

    iInitialGlobalVolumeLevel = aGlobalVolumeLevel;

}

void CMMAVolumeControl::GetVolumeLevelL(TInt aLevelIndex,

                                        TInt* aVolumeLevel)

{

    DEBUG_INT("CMMAVolumeControl::GetVolumeLevelL - level index %d", aLevelIndex);

    // Return max volume if the default Java volume level is not yet known

    if (aLevelIndex == KMMAJavaSoundIndex &&

            iLevels[ KMMAJavaSoundIndex ] == KErrNotFound)

    {

        *aVolumeLevel = KMMAVolumeMaxLevel;

        return;

    }

    *aVolumeLevel = iLevels[ aLevelIndex ];

    DEBUG_INT("CMMAVolumeControl::GetVolumeLevelL - level %d", *aVolumeLevel);

}

EXPORT_C void CMMAVolumeControl::SetAudioOutputPreferenceL(

    TInt aRoutingPreference)

{

    iAudioOutputPreference = aRoutingPreference;

    // If audio o/p preference is set to private then set the profile sound

    // to max value else if profile is in silent or meeting set the profile

    // sound to 0   

    if ( iAudioOutputPreference == KAudioEarpiece)

    {

       SetVolumeLevelL(KMMAProfileSoundIndex, KMMAVolumeMaxLevel);

    }

    else if (EProfileSilentId == iProfileId || EProfileMeetingId == iProfileId)

    {

       SetVolumeLevelL(KMMAProfileSoundIndex, 0);

    }

}

TInt CMMAVolumeControl::CalculateLevel()

{

    TInt levelCount = iLevels.Count();

    // 64 bit integer must be used to have more than 4 levels.

    TInt64 level = KMMAVolumeMaxLevel;

    TInt64 sum = 1;

    // All levels in the array are percentage of the max volume (0..100).

    // Actual sound level will be multiplying all levels.

    for (TInt i = 0; i < levelCount; i++)

    {

        DEBUG_INT2("CMMAVolumeControl::CalculateLevel value at iLevels[ %d ] is %d",i,iLevels[i]);

        // If the level is not known it is expected to be max volume

        level = (iLevels[ i ] == KErrNotFound ?

                 level * KMMAVolumeMaxLevel :

                 level * iLevels[ i ]);

        sum *= KMMAVolumeMaxLevel;

    }

    return level / sum;

}

//  END OF FILE