* Description:

#include <uri16.h>

#include "markerpositiontimer.h"

#include "positionupdatetimer.h"

#include "profileutilmacro.h"

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

const XAuint32 XA_PLAYSTATE_PLAYERUNINITIALIZED = 0;

    CleanupStack::PushL(self);

    CleanupStack::Pop(self);

    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;

    iAPIBeingUsed = ENoUtility;

    iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this);

    iAudioRecorder = (CMdaAudioRecorderUtility*)iBaseAudioRecorder;

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    }

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();

    }

    if (func == ERecord)

        if (iRecordState == ERecorderNotReady)

            iAPIBeingUsed = EAudioRecorderUtility;

            TInt pos = filepath.LocateReverse(':');

            if(pos != KErrNotFound)

                fileuri.Delete(fileslashlen+pos,1);

                }

            TUriParser8 localfileUri;

            TInt ret = localfileUri.Parse(fileuri);

            HBufC* file = NULL;

            TRAP(err,file = localfileUri.GetFileNameL());

            TPtr des = file->Des();

            iFileName = des;

            delete file;

            file = NULL;

            TRAP(err, iAudioRecorder->OpenFileL(iFileName));

            if (!err)

                { /* Wait until we receive moscostatechanged callback */

                err = iErrorCode;

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

        if ((iMediaPlayerState == XA_PLAYSTATE_PLAYERUNINITIALIZED) ||

                (iMediaPlayerState == XA_PLAYSTATE_STOPPED))

            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);

                /* Open file */

                TAG_TIME_PROFILING_BEGIN;

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

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                TAG_TIME_PROFILING_END;

                PRINT_TO_CONSOLE_TIME_DIFF;

                /* 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;

        }

    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;

        if (!strcasecmp(ext, ".mp3") ||

           !strcasecmp(ext, ".amr") ||

           !strcasecmp(ext, ".aac") ||

           !strcasecmp(ext, ".mid") ||

		   !strcasecmp(ext, ".wav") ||

           !strcasecmp(ext, ".awb"))

            return EAudioPlayerUtility;

          else

    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);

        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();

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

        //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 );

        }

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

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

                                          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();

    TInt err(KErrNone);

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

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

        if (iErrorCode == KErrNone)

                //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 2"));

                TRAP(err,iaudioInputRecord = CAudioInput::NewL( *iAudioRecorder ));

                RArray<CAudioInput::TAudioInputPreference> inputArray;

                inputArray.Append( CAudioInput::EDefaultMic );

                // Set Audio Input

                iaudioInputRecord->SetAudioInputL( inputArray.Array( ) );

                inputArray.Close();

                //RDebug::Print(_L("CMMFBackendEngine::MoscoStateChangeEvent 3 [%d]"),ret);

                if (ret != KErrNone && iFileFormat == XA_CONTAINERTYPE_MP4)

                if (iActiveSchedulerWait->IsStarted())

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

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

    else if (iCurrentRecordState == CMdaAudioClipUtility::ERecording)  //ERecording

        XAAdaptEvent event = {XA_RECORDITFEVENTS, XA_RECORDEVENT_HEADMOVING, 0, NULL};

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