/*
* Copyright (c) 2006 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: Implemention of the auto resume handler.
*
*/


#include <e32std.h>
#include <ctsydomainpskeys.h>
#include <mpxpskeywatcher.h>
#include <mpxlog.h>
#include "mpxplaybackengine.h"
#include "mpxautoresumehandler.h"

// CONSTANTS
const TInt KMPXErrDiedTimeout = 2000000;

// Time to wait before resume after call has ended.
const TInt KMPXResumeWaitTime = 3000000; // 3.0s



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


// -----------------------------------------------------------------------------
// C++ constructor
// -----------------------------------------------------------------------------
//
CMPXAutoResumeHandler::CMPXAutoResumeHandler(
    CMPXPlaybackEngine& aEngine,
    TBool aMixerSupport) :
    iEngine(aEngine),
    iMixerSupport(aMixerSupport),
    iAutoResume(ETrue)
    {
    }

// -----------------------------------------------------------------------------
// Symbian OS default constructor
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::ConstructL()
    {
    // Listen to call state changes
    iStateObserver = CMPXPSKeyWatcher::NewL(KPSUidCtsyCallInformation,
                                            KCTsyCallState,this);

    // Listen to call type changes
    iTypeObserver = CMPXPSKeyWatcher::NewL(KPSUidCtsyCallInformation,
                                           KCTsyCallType,this);
    iResumeTimer = CPeriodic::NewL(CActive::EPriorityStandard);
    }

// -----------------------------------------------------------------------------
// Constructs a new entry with given values.
// -----------------------------------------------------------------------------
//
CMPXAutoResumeHandler* CMPXAutoResumeHandler::NewL(
                                         CMPXPlaybackEngine& aEngine,
                                         TBool aMixerSupport)
    {
    CMPXAutoResumeHandler* self =
        new (ELeave) CMPXAutoResumeHandler(aEngine, aMixerSupport);

    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::CMPXAutoResumeHandler()
// Destructor
// -----------------------------------------------------------------------------
//
CMPXAutoResumeHandler::~CMPXAutoResumeHandler()
    {
    delete iStateObserver;
    delete iTypeObserver;
    if ( iResumeTimer )
        {
        CancelResumeTimer();
        delete iResumeTimer;
        }
    }

// -----------------------------------------------------------------------------
// Open file completed
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::HandleOpenFileComplete()
    {
    MPX_FUNC("CMPXAutoResumeHandler::HandleOpenFileComplete()");
    iPausedForCall = EFalse;
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::MPlayerStateChanged
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::HandlePlaybackStateChange(TMPXPlaybackState aState)
    {
    MPX_DEBUG2("CMPXAutoResumeHandler::HandlePlaybackStateChange(%d) entering", aState);

    // Any state change means that possible waiting resume is not to be done
    // anymore.
    CancelResumeTimer();

    if (aState != EPbStatePaused)
        {
        iPausedForCall = EFalse;
        }
    MPX_DEBUG1("CMPXAutoResumeHandler::HandlePlaybackStateChange() exiting");
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::MPlayerPlayComplete
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::HandlePlaybackComplete(TInt aError)
    {
    MPX_DEBUG2("CMPXAutoResumeHandler::HandlePlaybackComplete(%d) entering", aError);
    iPausedForCall = EFalse;
    if ( KErrDied == aError ||
         KErrAccessDenied == aError )
        {
        iKErrDiedTime.HomeTime();

        TInt callType = EPSCTsyCallTypeNone;
        TInt callState = EPSCTsyCallStateNone;

        if (!iTypeObserver->GetValue(callType) &&
            !iStateObserver->GetValue(callState))
            {
            if ((callState == EPSCTsyCallStateRinging && iMixerSupport) ||
                 ShouldPause())
                {
                // Getting a play complete with KErrDied here
                // means Audio Policy terminated our playback,
                // due to phone call being connected. Enable
                // autoresume.
                iPausedForCall = ETrue;
                }
            }
        }
    MPX_DEBUG1("CMPXAutoResumeHandler::HandlePlaybackComplete() exiting");
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::CancelResumeTimer
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::CancelResumeTimer()
    {
    if ( iResumeTimer )
        {
        iResumeTimer->Cancel();
        }
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::HandlePSEvent
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::HandlePSEvent(TUid /*aUid*/, TInt /*aKey*/)
    {
    MPX_FUNC("CMPXAutoResumeHandler::HandlePSEvent()");
    TRAP_IGNORE(DoHandleStateChangeL());
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::DoHandleStateChangeL
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::DoHandleStateChangeL()
    {
    MPX_FUNC("CMPXAutoResumeHandler::DoHandleStateChangeL()");
    MPX_DEBUG2("CMPXAutoResumeHandler::DoHandleStateChangeL(): iPausedForCall = %d", iPausedForCall);
    MPX_DEBUG2("CMPXAutoResumeHandler::DoHandleStateChangeL(): engineState = %d", iEngine.State());
    // if autoresume is disabled, do nothing
    if ( !iAutoResume )
        {
        return;
        }
    
    TBool shouldPause = ShouldPause();
    if (shouldPause &&
        !iPausedForCall &&
        iEngine.State() == EPbStatePlaying)
        {
        iEngine.HandleCommandL(EPbCmdPause);
        iPausedForCall = ETrue;
        }
    else if ( shouldPause &&
            !iPausedForCall &&
            ( iEngine.State() == EPbStateSeekingForward ||
            iEngine.State() == EPbStateSeekingBackward ) )
        {
        iEngine.HandleCommandL( EPbCmdStopSeeking );
        if ( iEngine.State() == EPbStatePlaying )
            {
            iEngine.HandleCommandL( EPbCmdPause );
            iPausedForCall = ETrue;
            }
        }
    else if(!shouldPause &&
            iPausedForCall &&
            iEngine.State() == EPbStatePaused)
        {
        MPX_DEBUG1("CMPXAutoResumeHandler::DoHandleStateChangeL(): starting resume timer");
        if ( iResumeTimer->IsActive() )
            iResumeTimer->Cancel();
        iResumeTimer->Start(
            KMPXResumeWaitTime,
            KMPXResumeWaitTime,
            TCallBack(ResumeTimerCallback, this) );
        iPausedForCall = EFalse;
        }
    else if ( shouldPause &&
             iEngine.State() == EPbStatePaused &&
             !iPausedForCall &&
             iKErrDiedTime.Int64())
        {
        // Check if we recently got a playcomplete with KErrDied,
        // it was most likely caused by an active call
        TTime now;
        now.HomeTime();
        TInt64 deltaTime = now.MicroSecondsFrom(iKErrDiedTime).Int64();
        if ( deltaTime > 0 &&
             deltaTime < KMPXErrDiedTimeout)
            {
            iResumeTimer->Cancel();
            iPausedForCall = ETrue;
            }
        }
    MPX_DEBUG2("CMPXAutoResumeHandler::DoHandleStateChangeL(): iPausedForCall = %d", iPausedForCall);
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::ShouldPause
// -----------------------------------------------------------------------------
//
TBool CMPXAutoResumeHandler::ShouldPause()
    {
    MPX_DEBUG1("CMPXAutoResumeHandler::ShouldPause() entering");
    TBool ret = EFalse;

    if ( !IsPlaybackRemote() )
        {
        TInt callType;
        TInt callState;
        iTypeObserver->GetValue(callType);
        iStateObserver->GetValue(callState);
        MPX_DEBUG3("CMPXAutoResumeHandler::ShouldPause(): type = %d, state = %d", callType, callState);

        if (callType == EPSCTsyCallTypeCSVoice ||
            callType == EPSCTsyCallTypeH324Multimedia ||
            callType == EPSCTsyCallTypeVoIP ||
            callType == EPSCTsyCallTypeUninitialized)
            {
            switch (callState)
                {
                case EPSCTsyCallStateAnswering:
                case EPSCTsyCallStateAlerting:
                case EPSCTsyCallStateConnected:
                case EPSCTsyCallStateDialling:
                case EPSCTsyCallStateHold:
                case EPSCTsyCallStateDisconnecting:
                    {
                    ret = ETrue;
                    break;
                    }
                case EPSCTsyCallStateRinging:
                    {
                    if (iPausedForCall)
                       {
                       ret = ETrue;
                       }
                    else
                        {
                        // Pause playback if we cannot mix music playback
                        // with ringing tone.
                        ret = !iMixerSupport;
                        }
                    break;
                    }
                default:
                    {
                    // Default is no pause
                    break;
                    }
                }
            }
        }
    MPX_DEBUG2("CMPXAutoResumeHandler::ShouldPause() exiting: %d", ret);
    return ret;
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::HandleResumeTimerCallback
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::HandleResumeTimerCallback()
    {
    MPX_FUNC("CMPXAutoResumeHandler::HandleResumeTimerCallback() entering");

    CancelResumeTimer();
    TRAP_IGNORE( iEngine.HandleCommandL( EPbCmdPlayWithFadeIn ));
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::ResumeTimerCallbackL
// -----------------------------------------------------------------------------
//
TInt CMPXAutoResumeHandler::ResumeTimerCallback(TAny* aPtr)
    {
    MPX_FUNC("CMPXAutoResumeHandler::ResumeTimerCallback()");

    CMPXAutoResumeHandler* ptr =
        static_cast<CMPXAutoResumeHandler*>(aPtr);
    ptr->HandleResumeTimerCallback();

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMPXAutoResumeHandler::IsPlaybackRemote
// -----------------------------------------------------------------------------
//
TBool CMPXAutoResumeHandler::IsPlaybackRemote()
    {
    MPX_DEBUG1("CMPXAutoResumeHandler::IsPlaybackRemote() entering");
    TBool isRemote = EFalse;

    if ( iEngine.State() == EPbStatePlaying )
        {
        TMPXPlaybackPlayerType type( EPbLocal );
        TUid uid;
        TInt index;
        TPtrC subPlayerName( KNullDesC );
        iEngine.PluginHandler()->GetSelection( type, uid,
                                               index, subPlayerName );

        if ( type != EPbLocal )
            {
            isRemote = ETrue;
            }
        }

    MPX_DEBUG2("CMPXAutoResumeHandler::IsPlaybackRemote() exiting: %d", isRemote);
    return isRemote;
    }

// -----------------------------------------------------------------------------
// Set autoresume value
// -----------------------------------------------------------------------------
//
void CMPXAutoResumeHandler::SetAutoResume(TBool aAutoResume)
    {
    MPX_DEBUG2("CMPXAutoResumeHandler::SetAutoResume(): AutoResume = %d", aAutoResume);
    iAutoResume = aAutoResume;
    }

//  End of File