/*

#include <string.h>

#include <ctype.h>

#include <uri8.h>

#include <uri16.h>

#include "markerpositiontimer.h"

#include "positionupdatetimer.h"

#include "profileutilmacro.h"

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

    }

    {

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

        }

    }

void CMMFBackendEngine::InitAudioPlayerUtilityL()

    {

    if (!iAudioPlayer)

        {

        iBaseAudioPlayer = CMdaAudioPlayerUtility::NewL(*this);

        }

    InitPlayerTimersL();

    }

void CMMFBackendEngine::InitVideoPlayerUtilityL()

    {

    if (!iVideoPlayer)

        {

        iVideoPlayer->RegisterForVideoLoadingNotification(*this);

        }

    InitPlayerTimersL();

    }

void CMMFBackendEngine::InitPlayerTimersL()

    {

    if (!iMarkerPositionTimer)

        {

        iMarkerPositionTimer->SetContext(iAdaptContext);

        }

    if (!iPlayItfPositionUpdateTimer)

        {

        iPlayItfPositionUpdateTimer->SetContext(iAdaptContext);

        }

    iMarkerPositionTimer->Stop();

    iPlayItfPositionUpdateTimer->Stop();

    }

    {

    TInt err(KErrNone);

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

    TInt fileslashlen = KFileSlash().Length();

    if (func == ERecord)

        {

        if (iRecordState == ERecorderNotReady)

            {

            iFileFormat = format;

            iAPIBeingUsed = DetermineAPIToUse(uri, ERecord);

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

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

                RET_IF_ERR(err, XA_RESULT_INTERNAL_ERROR);

                /* Wait until we receive moscostatechanged callback */

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

            }

        }

    else

        {

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

            {

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

                PRINT_TO_CONSOLE_TIME_DIFF;

                /* Wait until we receive mapc init complete */

                PRINT_TO_CONSOLE_HOME_TIME;

                    {

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

                    PRINT_TO_CONSOLE_TIME_DIFF;

                    }

                else

                    {

                    /* Open URL */

                    TAG_TIME_PROFILING_BEGIN;

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

                    PRINT_TO_CONSOLE_TIME_DIFF;

                    }

                /* Wait until we receive  MvpuoOpenComplete */

                PRINT_TO_CONSOLE_HOME_TIME;

                    {

                    iActiveSchedulerWait->Start();

                    }

                RET_IF_ERR(iErrorCode, XA_RESULT_INTERNAL_ERROR);

                /* Prepare utility */

                TAG_TIME_PROFILING_BEGIN_NO_VAR_DEF;

                iVideoPlayer->Prepare();

                PRINT_TO_CONSOLE_TIME_DIFF;

                /* Wait until we receive  MvpuoPrepareComplete */

                PRINT_TO_CONSOLE_HOME_TIME_NO_VAR_DEF;

                    {

                    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;

    int extLen;

    int colpos;

    int urischemeLen;

    if (!dotPtr)

        {

        return KErrNotFound;

        }

    /*Null terminate the string*/

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

    extLen = sizeof(ext);

        {

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

        }

    /*Null terminate the string*/

    urischemeLen = sizeof(urischeme);

        {

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

        }

    if (aFunc == ERecord)

        {

        return EAudioRecorderUtility;

        }

    else

        {

            {

                {

                return EAudioPlayerUtility;

                }

                {

                return EVideoPlayerUtility;

                }

            }

        else

            {

            return EVideoPlayerUtility;

            }

        }

    }

//From MVidePlayerUtilityObserver

void CMMFBackendEngine::MvpuoOpenComplete(TInt aError)

    {

    PRINT_TO_CONSOLE_HOME_TIME;

    iErrorCode = aError;

    if (iErrorCode == KErrNone)

        {

        iMMFPlayerState = EPlayerOpened;

        }

        {

        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;

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

                TAG_TIME_PROFILING_BEGIN;

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

                PRINT_TO_CONSOLE_TIME_DIFF;

                }

            }

        }

        {

        iActiveSchedulerWait->AsyncStop();

        }

    }

    {

    }

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;

        }

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

        {

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

        }

        {

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

        {

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

        PausePlayback();

        }

    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,

    {

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

        }

        {

        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;