/*

* 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 "cmmfbackendengine.h"

#include <string.h>

#include <ctype.h>

#include <uri8.h>

#include <uri16.h>

#include "markerpositiontimer.h"

#include "positionupdatetimer.h"

#include "profileutilmacro.h"

extern "C" {

#include "xaadaptationmmf.h"

}

#define RET_IF_ERR(res, val) if (res != KErrNone) return val

const XAuint32 XA_PLAYSTATE_PLAYERUNINITIALIZED = 0;

CMMFBackendEngine* CMMFBackendEngine::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CMMFBackendEngine::~CMMFBackendEngine()

    {

    Close();

    Destroy();

    }

CMMFBackendEngine::CMMFBackendEngine()

:iPositionUpdatePeriod(1000), /* default is 1000 millisec */

 iUriPtr(NULL,0)

    {

/*    m_bWindowReferencePassed = FALSE;*/

    iRecordState = ERecorderNotReady;

    iPositionUpdateTimer = NULL;

    iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

    iMMFPlayerState = EPlayerClosed;

    }

void CMMFBackendEngine::ConstructL()

    {

    iAPIBeingUsed = ENoUtility;

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    }

void CMMFBackendEngine::InitAudioRecorderUtilityL()

    {

    if (!iAudioRecorder)

        {

        iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this);

        iAudioRecorder = (CMdaAudioRecorderUtility*)iBaseAudioRecorder;

        }

    }

void CMMFBackendEngine::InitAudioPlayerUtilityL()

    {

    if (!iAudioPlayer)

        {

        iBaseAudioPlayer = CMdaAudioPlayerUtility::NewL(*this);

        iAudioPlayer = (CMdaAudioPlayerUtility*)iBaseAudioPlayer;

        }

    InitPlayerTimersL();

    }

void CMMFBackendEngine::InitVideoPlayerUtilityL()

    {

    if (!iVideoPlayer)

        {

        iBaseVideoPlayer = CVideoPlayerUtility2::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

        iVideoPlayer = (CVideoPlayerUtility2*)iBaseVideoPlayer;

        iVideoPlayer->RegisterForVideoLoadingNotification(*this);

        }

    InitPlayerTimersL();

    }

void CMMFBackendEngine::InitPlayerTimersL()

    {

    if (!iMarkerPositionTimer)

        {

        iMarkerPositionTimer = CMarkerPositionTimer::NewL(iAudioPlayer, iVideoPlayer);

        iMarkerPositionTimer->SetContext(iAdaptContext);

        }

    if (!iPlayItfPositionUpdateTimer)

        {

        iPlayItfPositionUpdateTimer = CPositionUpdateTimer::NewL(iAudioPlayer, iVideoPlayer);

        iPlayItfPositionUpdateTimer->SetContext(iAdaptContext);

        }

    iMarkerPositionTimer->Stop();

    iPlayItfPositionUpdateTimer->Stop();

    }

TInt CMMFBackendEngine::SetFileName(char* uri, XAuint32 format, TFuncInUse func)

    {

    TInt err(KErrNone);

    _LIT8(KFileSlash,"file:///");

    TInt fileslashlen = KFileSlash().Length();

    if (func == ERecord)

        {

        if (iRecordState == ERecorderNotReady)

            {

            iFileFormat = format;

            err = XA_RESULT_INTERNAL_ERROR;

            if (iAPIBeingUsed == EAudioRecorderUtility)

                {

                /* Initialize URI as needed by MMF utilities */

                err = InitializeURIForMMFUtil(uri);

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Initalize Recorder related objects */

                TRAP(err, InitAudioRecorderUtilityL());

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Wait until we receive moscostatechanged callback */

                if(!iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

               }

            }

        }

    else

        {

        /* The second one is needed for dynamic source interface */

        if ((iMediaPlayerState == XA_PLAYSTATE_PLAYERUNINITIALIZED) ||

                (iMediaPlayerState == XA_PLAYSTATE_STOPPED))

            {

            iFileFormat = format;

            iAPIBeingUsed = DetermineAPIToUse(uri, EPlay);

            err = XA_RESULT_INTERNAL_ERROR;

            if (iAPIBeingUsed == EAudioPlayerUtility)

                {

                /* Initialize URI as needed by MMF utilities */

                err = InitializeURIForMMFUtil(uri);

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Initalize Player related objects */

                TRAP(err, InitAudioPlayerUtilityL());

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                TAG_TIME_PROFILING_BEGIN;

                TRAP(err, iAudioPlayer->OpenFileL(iUriPtr));

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                TAG_TIME_PROFILING_END;

                PRINT_TO_CONSOLE_TIME_DIFF;

                /* Wait until we receive mapc init complete */

                PRINT_TO_CONSOLE_HOME_TIME;

                if (!iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                }

            else if (iAPIBeingUsed == EVideoPlayerUtility)

                {

                /* Initialize URI as needed by MMF utilities */

                err = InitializeURIForMMFUtil(uri);

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Initalize Player related objects */

                TRAP(err, InitVideoPlayerUtilityL());

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Wait until we receive  MvpuoOpenComplete */

                PRINT_TO_CONSOLE_HOME_TIME;

                if (!iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                /* Prepare utility */

                TAG_TIME_PROFILING_BEGIN_NO_VAR_DEF;

                iVideoPlayer->Prepare();

                TAG_TIME_PROFILING_END_NO_VAR_DEF;

                PRINT_TO_CONSOLE_TIME_DIFF;

                /* Wait until we receive  MvpuoPrepareComplete */

                PRINT_TO_CONSOLE_HOME_TIME_NO_VAR_DEF;

                if (!iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                }

           }

        }

    if (err != KErrNone)

        {

        err = XA_RESULT_INTERNAL_ERROR;

        }

    return err;

    }

TInt CMMFBackendEngine::DetermineAPIToUse(char* uri, TFuncInUse aFunc)

    {

    char* dotPtr = NULL;

    char ext[MAX_EXTENSION_SIZE] = { 0 };

    int extLen;

    dotPtr = strrchr(uri, (int)'.');

    if (!dotPtr)

        {

        return KErrNotFound;

        }

    strncpy(ext, dotPtr,strlen(dotPtr));

    /*Null terminate the string*/

    ext[strlen(dotPtr)] = '\0';

    extLen = sizeof(ext);

    for(unsigned int i=0; i < extLen; i++)

        {

        ext[i] = tolower(ext[i]);

        }

    if (aFunc == ERecord)

        {

        return EAudioRecorderUtility;

        }

    else

        {

            {

            }

            {

            return EVideoPlayerUtility;

            }

        }

    }

//From MVidePlayerUtilityObserver

void CMMFBackendEngine::MvpuoOpenComplete(TInt aError)

    {

    PRINT_TO_CONSOLE_HOME_TIME;

    iErrorCode = aError;

    if (iErrorCode == KErrNone)

        {

        iMMFPlayerState = EPlayerOpened;

        }

    if (iActiveSchedulerWait->IsStarted())

        {

        iActiveSchedulerWait->AsyncStop();

        }

    }

void CMMFBackendEngine::MvpuoPrepareComplete(TInt aError)

    {

    PRINT_TO_CONSOLE_HOME_TIME;

    TAutoScaleType autoScale = EAutoScaleBestFit;

    iErrorCode = aError;

    iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

    iMediaDuration = 0;

    iMarkerPositionTimer->ResetPlayer();

    iPlayItfPositionUpdateTimer->ResetPlayer();

    if (iErrorCode == KErrNone)

        {

        iMMFPlayerState = EPlayerPrepared;

        TAG_TIME_PROFILING_BEGIN;

        TRAP(iErrorCode, iMediaDuration = iVideoPlayer->DurationL());

        TAG_TIME_PROFILING_END;

        PRINT_TO_CONSOLE_TIME_DIFF;

        if (iErrorCode == KErrNone)

            {

            iPlaybackHead = 0;

            iMediaPlayerState = XA_PLAYSTATE_STOPPED;

            iMarkerPositionTimer->UseVideoPlayer();

            iPlayItfPositionUpdateTimer->UseVideoPlayer();

            if (m_pWs && m_pScr && m_pWindow)

                {

                TRect videoExtent = TRect(m_pWindow->Size());

                TRect clipRect = TRect(m_pWindow->Size());        

                TAG_TIME_PROFILING_BEGIN;

                TRAP_IGNORE(iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow, videoExtent, clipRect));

                TRAP_IGNORE(iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale));

                TAG_TIME_PROFILING_END;

                PRINT_TO_CONSOLE_TIME_DIFF;

                }

            }

        }

    if (iActiveSchedulerWait->IsStarted())

        {

        iActiveSchedulerWait->AsyncStop();

        }

    }

void CMMFBackendEngine::MvpuoFrameReady(CFbsBitmap& /*aFrame*/,TInt /*aError*/)

    {

    }

void CMMFBackendEngine::MvpuoPlayComplete(TInt aError)

    {

    iErrorCode = aError;

    if (iErrorCode == KErrNone)

        {

        iPlaybackHead = iMediaDuration;

        /* Per OpenMAX AL Spec, when playback is completed, media player stays in

         * paused state with playhead at the end of the media clip */

        iMediaPlayerState = XA_PLAYSTATE_PAUSED;

        DoPostEvent(XA_PLAYEVENT_HEADATEND);

        }

    else

        {

        iPlaybackHead = 0;

        iMediaPlayerState = XA_PLAYSTATE_STOPPED;

        XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL};

        XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event );

        }

    iMMFPlayerState = EPlayerPrepared;

    iMarkerPositionTimer->Stop();

    iPlayItfPositionUpdateTimer->Stop();

    }

void CMMFBackendEngine::MvpuoEvent(class TMMFEvent const & event)

    {

    //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent (0x%x %d)"), event.iEventType, event.iErrorCode);

    if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError &&

        event.iErrorCode == KErrHardwareNotAvailable)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Hardware Not Available"));

        }

    else if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError &&

             event.iErrorCode == KErrMMPartialPlayback)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Partial playback"));

        }    

    if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError &&

        event.iErrorCode == -12014)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Audio Device taken"));

        PausePlayback();

        XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL};

        XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event );

        }

    else if (event.iEventType == KMMFRefreshMetaData)

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: EventType == KMMFRefreshMetaData"));

        }

    else

        {

        //RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent: Unhandled event"));

        }

    }

// From MRebufferCallback

void CMMFBackendEngine::MvloLoadingStarted()

    {

    }

void CMMFBackendEngine::MvloLoadingComplete()

    {

    //file playing

    }

//MMdaAudioPlayerCallback

void CMMFBackendEngine::MapcInitComplete(TInt aError,

                                          const TTimeIntervalMicroSeconds& aDuration)

    {

    PRINT_TO_CONSOLE_HOME_TIME;

    iErrorCode = aError;

    iMediaPlayerState = XA_PLAYSTATE_PLAYERUNINITIALIZED;

    iMMFPlayerState = EPlayerClosed;

    iMediaDuration = 0;

    iMarkerPositionTimer->ResetPlayer();

    iPlayItfPositionUpdateTimer->ResetPlayer();

    if (iErrorCode == KErrNone)

        {

        iMediaDuration = aDuration;

        iPlaybackHead = 0;

        iMediaPlayerState = XA_PLAYSTATE_STOPPED;

        iMMFPlayerState = EPlayerOpened;

        iMarkerPositionTimer->UseAudioPlayer();

        iPlayItfPositionUpdateTimer->UseAudioPlayer();

        }

    if (iActiveSchedulerWait->IsStarted())

        {

        iActiveSchedulerWait->AsyncStop();

        }

    }

void CMMFBackendEngine::MapcPlayComplete(TInt aError)

    {

    iErrorCode = aError;

    if (iErrorCode == KErrNone)

        {

        /* Now we should have better value. Start using that */

        iAudioPlayer->Duration(iMediaDuration);

        iPlaybackHead = iMediaDuration;

        /* Per OpenMAX AL Spec, when playback is completed, media player stays in

         * paused state with playhead at the end of the media clip */

        iMediaPlayerState = XA_PLAYSTATE_PAUSED;

        DoPostEvent(XA_PLAYEVENT_HEADATEND);

        iMMFPlayerState = EPlayerOpened;

        }

    else

        {

        iAudioPlayer->GetPosition(iPlaybackHead);

        iMediaPlayerState = XA_PLAYSTATE_PAUSED;

        iMMFPlayerState = EPlayerPaused;

        XAAdaptEvent event = {XA_PLAYITFEVENTS, XA_OBJECT_EVENT_RESOURCES_LOST, 0, NULL};

        XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iAdaptContext, &event );

        }

    iMarkerPositionTimer->Stop();

    iPlayItfPositionUpdateTimer->Stop();

    }

// from MMdaObjectStateChangeObserver

void CMMFBackendEngine::MoscoStateChangeEvent(CBase* /*aObject*/, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode)

    {

    TInt err(KErrNone);

    iPreviousRecordState = aPreviousState;

    iCurrentRecordState = aCurrentState;

    iErrorCode = aErrorCode;

    //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 1 Error[%d]"),aErrorCode);

    if (iCurrentRecordState == CMdaAudioClipUtility::EOpen)  //EOpen

        {

        //outputfile is open and ready for recording

        iRecordState = CMMFBackendEngine::ERecorderOpen;

        if (iErrorCode == KErrNone)

            {

            if (iPreviousRecordState == CMdaAudioClipUtility::ENotReady)