/*
* Copyright (c) 2002 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 MIDI.
*
*/


//  INCLUDE FILES
#include <jdebug.h>
#include <e32base.h>
#include <AudioPreference.h>

#include "cmmadrmaudioplayer.h"
#include "mmmadisplay.h"

const TInt KErrorMessageSize = 32;
const TInt64 KDurationUnknown = -1;
const TInt KMediaStartTime = 0;
const TInt KMediaTimeDurationTreshold = 100000;

_LIT(KErrDefaultError, "Symbian OS Error: %d");

CMMADRMAudioPlayer* CMMADRMAudioPlayer::NewLC(const TDesC& aContentType,
        TFileName aFileName)
{
    CMMADRMAudioPlayer* self = new(ELeave) CMMADRMAudioPlayer(aFileName);
    CleanupStack::PushL(self);
    self->ConstructL(aContentType);
    return self;
}

CMMADRMAudioPlayer::~CMMADRMAudioPlayer()
{
    CloseClientUtility();
    delete iUtility;

    DEBUG("MMA::CMMADRMAudioPlayer::~CMMADRMAudioPlayer ");
}

void CMMADRMAudioPlayer::ConstructL(const TDesC& aContentType)
{
    DEBUG("CMMADRMAudioPlayer::ConstructL");
    // Only file based sources are supported with DRM
    if (iFileName == KNullDesC)
    {
        User::Leave(KErrNotSupported);
    }
    iContentType = aContentType.AllocL();
    iUtility = CDrmPlayerUtility::NewL(*this, KAudioPriorityRealOnePlayer,
                                       (TMdaPriorityPreference) KAudioPrefRealOneLocalPlayback);

    CMMAPlayer::ConstructL();
}

CMMADRMAudioPlayer::CMMADRMAudioPlayer(TFileName aFileName):
        CMMAPlayer(),
        iFileName(aFileName)
{
}

CDrmPlayerUtility* CMMADRMAudioPlayer::DRMUtility() const
{
    return iUtility;
}


void CMMADRMAudioPlayer::RealizeL()
{
    DEBUG("CMMADRMAudioPlayer::RealizeL");
    CMMAPlayer::RealizeL();
}

void CMMADRMAudioPlayer::PrefetchL()
{
    DEBUG("CMMADRMAudioPlayer::PrefetchL");
    // Prefetch will be completed in init callback
    iUtility->OpenFileL(iFileName);
}

void CMMADRMAudioPlayer::DeallocateL()
{
    DEBUG("MMA: CMMAMidiPlayer: DeallocateL +");
    if (iState == EPrefetched)
    {
        CloseClientUtility();
        ChangeState(ERealized);
    }
    DEBUG("MMA: CMMAMidiPlayer: DeallocateL -");
}

void CMMADRMAudioPlayer::StartL(TBool aPostEvent)
{
    // start can't be called to not ready player
    ASSERT(iState == EPrefetched);

    TInt64 time = TInt64(KMediaStartTime);

    // Media time is not fetched using GetMediaTime
    // Because it adjusts the result if it is close
    // to duration.

    TTimeIntervalMicroSeconds position(KMediaStartTime);
    User::LeaveIfError(iUtility->GetPosition(position));

    time = position.Int64();

    TInt64 duration;
    GetDuration(&duration);
    if ((duration > 0) && (time > duration - KMediaTimeDurationTreshold))
    {
        time = KMediaStartTime;
        iUtility->SetPosition(time);
    }

    iUtility->Play();

    PostActionCompleted(KErrNone);   // java start return
    if (aPostEvent)
    {
        // inform java side
        PostLongEvent(CMMAPlayerEvent::EStarted, time);
    }
    ChangeState(EStarted);
}

void CMMADRMAudioPlayer::StopL(TBool aPostEvent)
{
    if (iState == EStarted)
    {
        User::LeaveIfError(iUtility->Pause());

        if (aPostEvent)
        {
            TInt64 time;
            GetMediaTime(&time);
            PostLongEvent(CMMAPlayerEvent::EStopped, time);
        }
        // go back to prefetched state
        ChangeState(EPrefetched);
    }
}

void CMMADRMAudioPlayer::GetDuration(TInt64* aDuration)
{
    if (iState < EPrefetched)
    {
        *aDuration = KDurationUnknown;
    }
    else
    {
        *aDuration = iUtility->Duration().Int64();
    }
}

void CMMADRMAudioPlayer::SetMediaTimeL(TInt64* aTime)
{
    DEBUG_INT("MMA::CMMADRMAudioPlayer::SetMediaTimeL + aTime: %d", *aTime);
    // Duration is needed so we do not try to set media time
    // too far away. If duration is not known, setting media time
    // is not allowed.

    TInt64 duration = TInt64(KMediaStartTime);
    GetDuration(&duration);
    if (duration < KErrNone)
    {
        // If duration is not known, we will leave with suitable code.
        User::Leave(KErrNotSupported);
    }

    // Check if desired media time is past media duration and
    // set it to duration in that case. Negative values are not
    // checked here because it's done already in Java side.

    // If media time is attempted to set to duration, then
    // it is set close to duration. This way
    // when utility is then started, end of media event
    // will come soon after. This is not indicated to Java
    // side but instead returned that the media time was
    // set to duration.

    TTimeIntervalMicroSeconds position;
    if (*aTime >= duration)
    {
        *aTime = duration;
        position = duration - KMediaTimeDurationTreshold;
    }
    else
    {
        position = *aTime;
    }

    iUtility->SetPosition(position);

    // Inform about the position change to the StateListeners
    ChangeState(iState);

    // Get the actual media time
    GetMediaTime(aTime);
}

void CMMADRMAudioPlayer::GetMediaTime(TInt64* aMediaTime)
{
    DEBUG_INT("MMA::CMMADRMAudioPlayer::GetMediaTime + aMediaTime: %d", *aMediaTime);
    TTimeIntervalMicroSeconds position;
    TInt64 duration = TInt64(KMediaStartTime);

    // Error code discarded on purpose
    GetDuration(&duration);

    TInt error(iUtility->GetPosition(position));
    if (error == KErrNone)
    {
        // set return value
        *aMediaTime = position.Int64();
        //if duration is unknown and position 0, player is realized and
        //we can not know media time
        if ((duration == KDurationUnknown) && (position == 0))
        {
            *aMediaTime = KTimeUnknown;
        }
    }
    else
    {
        // media time cannot be get
        *aMediaTime = KTimeUnknown;
    }

    // Second part of the set media time workaround.
    // If position is close to duration, then media
    // time of duration is returned instead.

    // If the duration is zero or not known
    // then this adjustment is not done.
    if ((duration > KErrNone) &&
            (*aMediaTime >= duration - KMediaTimeDurationTreshold))
    {
        *aMediaTime = duration;
    }
    DEBUG_INT("MMA::CMMADRMAudioPlayer::GetMediaTime - aMediaTime: %d", *aMediaTime);
}

void CMMADRMAudioPlayer::CloseL()
{
    CMMAPlayer::CloseL();
    CloseClientUtility();
}

const TDesC& CMMADRMAudioPlayer::Type()
{
    return KMMADRMPlayer;
}

void CMMADRMAudioPlayer::PlayCompleteL(TInt aError)
{
    DEBUG_INT("MMA: CMMADRMAudioPlayer: PlayCompleteL: Error=%d", aError);
    TInt64 time;
    GetDuration(&time);

    // Send 'Stopped' only when stop() is called.
    PostLongEvent(CMMAPlayerEvent::EEndOfMedia, time);

    ChangeState(EPrefetched);   // ready to play again

    if (aError == KErrNone)
    {
        iRepeatCount++;

        if (iRepeatForever || iRepeatCount < iRepeatNumberOfTimes)
        {
            StartL(ETrue);
        }
        else
        {
            iRepeatCount = 0;
            TTimeIntervalMicroSeconds position(time);
            iUtility->SetPosition(position);
        }
    }
    else
    {
        // error has occured, setting correct number of
        // repeats for next start
        SetLoopCount(iRepeatNumberOfTimes);
    }
    DEBUG("MMA: CMMADRMAudioPlayer: PlayCompleteL -");
}

void CMMADRMAudioPlayer::MdapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
{
    DEBUG_INT("MMA::CMMADRMAudioPlayer::MdapcInitComplete: aError = %d", aError);
    if (!aError)
    {
        ChangeState(EPrefetched);
    }
    PostActionCompleted(aError);
}

void CMMADRMAudioPlayer::MdapcPlayComplete(TInt aError)
{
    if (aError)
    {
        ErrorPlaybackComplete(aError);
    }
    else
    {
        TRAPD(error, PlayCompleteL(KErrNone));
        if (error)
        {
            ErrorPlaybackComplete(error);
        }
    }
}

void CMMADRMAudioPlayer::CloseClientUtility()
{
    DEBUG("MMA: CMMADRMAudioPlayer: CloseClientUtility +");
    if (iUtility)
    {
        iUtility->Close();
    }
    DEBUG("MMA: CMMADRMAudioPlayer: CloseClientUtility -");
}

void CMMADRMAudioPlayer::ErrorPlaybackComplete(TInt aError)
{
    DEBUG_INT("MMA::CMMADRMAudioPlayer::ErrorPlaybackComplete: aError = %d", aError);
    TBuf<KErrorMessageSize> errorMessage;
    errorMessage.Format(KErrDefaultError, aError);
    PostStringEvent(CMMAPlayerEvent::EError, errorMessage);

    CloseClientUtility();
    ChangeState(ERealized);
}
//  END OF FILE