/*

* 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: 

*

*/

/*

Media Helper Class for handling surface events

Shy Ward

*/

#include "cmmfbackendengine.h"

#include <string.h>

#include <ctype.h>

#include <uri8.h>

extern "C" {

#include "xaadaptationmmf.h"

}

#define ENABLE_GRAPHICS_SURFACE_INTEGRATION_NOT_NOW

CMMFBackendEngine* CMMFBackendEngine::NewL()

    {

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

    self->ConstructL();

    return self;

    }

CMMFBackendEngine::~CMMFBackendEngine()

    {

    CloseAndDestroy();

    }

CMMFBackendEngine::CMMFBackendEngine()                  

    {

    iVideoPlayer = NULL;

    m_bWindowReferencePassed = FALSE;

    iRecordState = ERecorderNotReady;

    iPositionUpdateTimer = NULL;

    }

void CMMFBackendEngine::InitVideoPlayerUtilityL()

    {

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

	iVideoPlayer = (CVideoPlayerUtility2*)iBaseVideoPlayer;

	iVideoPlayer->RegisterForVideoLoadingNotification(*this);   

    }

void CMMFBackendEngine::CreateAndConfigureWindowL()

    {

#ifdef ENABLE_GRAPHICS_SURFACE_INTEGRATION_NOT_NOW

    // create window for attaching the surface as its background

    //RWsSession ws;

    //TInt err2(KErrNone);

    TInt err2 = m_ws.Connect();

    m_pScr = new(ELeave) CWsScreenDevice(m_ws);

    err2 = m_pScr->Construct();

    CWindowGc* gc = NULL;

    err2 = m_pScr->CreateContext(gc);

    RWindowGroup grp(m_ws);

    err2 = grp.Construct(0xf00f00);

    const TSize KWinSize(320, 240);

    m_pWindow = new (ELeave) RWindow(m_ws);

    err2 = m_pWindow->Construct(grp, 0xfeefee);

    m_pWindow->SetExtent(TPoint(), KWinSize);

    m_pWindow->SetBackgroundColor(TRgb(255,0,0,128));

    //win.SetBackgroundColor(TRgb(0,0,0,0));

    m_pWindow->Activate();

    m_pWindow->Invalidate();

    m_pWindow->BeginRedraw();

    gc->Activate(*m_pWindow);

    m_pWindow->EndRedraw();

    m_ws.Flush();

    //Create MediaClientUitlity for NGA Surfaces

    TInt displayId = m_pScr->GetScreenNumber();

    // Add the display window

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

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

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

    m_rotation = EVideoRotationNone;

#endif // ENABLE_GRAPHICS_SURFACE_INTEGRATION_NOT_NOW     

    }

void CMMFBackendEngine::ConstructL()

    {

	//iBaseAudioPlayer = CMdaAudioPlayerUtility::NewL(*this);

	//iAudioPlayer = (CMdaAudioPlayerUtility*)iBaseAudioPlayer;

	iAPIBeingUsed = EAudioPlayerUtility;	

	//InitVideoPlayerUtilityL();

	iPlayerState = EPlayerClosed;

	iBaseAudioRecorder = CMdaAudioRecorderUtility::NewL(*this);

	iAudioRecorder = (CMdaAudioRecorderUtility*)iBaseAudioRecorder;

	iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait;

    } 

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;

            iAPIBeingUsed = DetermineAPIToUse(uri, ERecord);

            TPtr8 fileuri(((TUint8*)uri), strlen(uri) ,strlen(uri));

            TPtr8 filepath = fileuri.RightTPtr(strlen(uri)-fileslashlen);

            if(iAPIBeingUsed == EAudioPlayerUtility)

                {

                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(!iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->Start();

                    }

                }

           }

        }

    else

        {

        if(iPlayerState == EPlayerClosed)

            {

            iFileFormat = format;

            iAPIBeingUsed = DetermineAPIToUse(uri,EPlay);

            TPtr8 fileuri((TUint8*)uri, strlen(uri),strlen(uri));

            if(iAPIBeingUsed == EAudioPlayerUtility)

                {

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

                fileuri.Delete(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;

                }

            else

                {

                HBufC* f(NULL);

                TRAP(err, f = HBufC::NewL(strlen(uri)));

                TPtr des = f->Des();

                des.Copy(fileuri);

                iFileName = des;

                delete f;

                f = NULL;

                }

           }

        }

    return err;

    }

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

    {

    char* tempExtensionPtr = NULL;

    char extension[MAX_EXTENSION_SIZE] = { 0 };

    tempExtensionPtr = strchr(uri, (int)'.');

    strcpy(extension, tempExtensionPtr);

    for(unsigned int i=0;i<sizeof(extension);i++)

        {

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

        }

    if(aFunc == ERecord)

        {

        return EAudioPlayerUtility; 

        }

    else

        {

        if(!strcmp(extension, ".mp3") || (!strcmp(extension, ".amr")) || (!strcmp(extension, ".aac")) || (!strcmp(extension, ".mid")) ||

                  (!strcmp(extension, ".awb")))

            {

            return EAudioPlayerUtility; 

            }

          else 

            {

            return EVideoPlayerUtility;

            }

        }

    }

void CMMFBackendEngine::SetWindowHandle(void* display_info)

    {

    XADataLocator_NativeDisplay* nativeDisplay;

    XADataSink* videoSink = (XADataSink*)display_info;

    nativeDisplay = (XADataLocator_NativeDisplay*) (videoSink->pLocator);

    m_pWindow = ((RWindow*)(nativeDisplay->hWindow));

    m_pWs =     ((RWsSession*)(nativeDisplay->hDisplay));

    m_bWindowReferencePassed = TRUE;

    }

//From MVidePlayerUtilityObserver

void CMMFBackendEngine::MvpuoOpenComplete(TInt aError)

    {

    if(aError == KErrNone)

        {

        //Issue the command to Play the file

        TRAPD (error, iVideoPlayer->Prepare());

        if (error == KErrNone)

            {

                //prepare success

            }

        else

            {

                //prepare failed

            }

        }

    else

        {

        //could not open file

        }

    }

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

    {

    }

void CMMFBackendEngine::MvpuoPlayComplete(TInt aError)

    {

    if(aError == KErrNone)

        {

            //playback complete

        }

    else

        {

            //playback complete with error

        }

    }

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

    {

    RDebug::Print(_L("CMMFBackendEngine::MvpuoEvent (0x%x %d)\n"),

  		          event.iEventType, event.iErrorCode);

    if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError &&

        event.iErrorCode == KErrHardwareNotAvailable)

        {

        //audio device taken

        //handle this case

        }

	else if (event.iEventType == KMMFEventCategoryVideoPlayerGeneralError &&

			 event.iErrorCode == KErrMMPartialPlayback)

        {

        //Partial Playback

        } 

    else if (event.iEventType == KMMFRefreshMetaData)

        {

       //entry = iVideoPlayer->MetaDataEntryL( event.iErrorCode );

        }

    else

        {

        }

}

void CMMFBackendEngine::MvpuoPrepareComplete(TInt aError)

    {

    TInt err(KErrNone);

    TAutoScaleType autoScale = EAutoScaleBestFit;

	if(aError == KErrNone)

	    {

        if(m_pWindow == NULL)

            {

            //no RWindow was given to use so I'll create one and handle it

            //CreateAndConfigureWindowL();

            }

        else

            {

            TRAP(err, iVideoPlayer->AddDisplayWindowL(*m_pWs, *m_pScr, *m_pWindow));

            TRAP(err, iVideoPlayer->SetAutoScaleL(*m_pWindow, autoScale));

            }

        TReal beginSecs = 1;

        TReal intervalSecs = 5;

        TTimeIntervalMicroSeconds  interval(1000000*intervalSecs);

        TTimeIntervalMicroSeconds  beginning(1000000*beginSecs);

        iVideoPlayer->Play();

        iPlayerState = EPlayerPlaying;

	    }

    }

// From MRebufferCallback

void CMMFBackendEngine::MvloLoadingStarted()

    {

    }

void CMMFBackendEngine::MvloLoadingComplete()

    {

    //file playing

    }

//MMdaAudioPlayerCallback

void CMMFBackendEngine::MapcInitComplete(TInt aError,

										  const TTimeIntervalMicroSeconds& /* aDuration */)

    {

    if (aError == KErrNone)

        {

        iAudioPlayer->Play();

        iPlayerState = EPlayerPlaying;

        }

    else

        {

        //init failed

        }

    }

void CMMFBackendEngine::MapcPlayComplete(TInt /* aError */)

    {

    //audio playback complete

    }

// from MMdaObjectStateChangeObserver

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

    {

    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)

                {

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

                TMMFMessageDestination destination(KUidMetaDataWriteCustomCommand);

                TMMFMessageDestinationPckg pckg = TMMFMessageDestinationPckg(destination);

                TInt ret = iAudioRecorder->RecordControllerCustomCommandSync(pckg, 0, KNullDesC8, KNullDesC8);

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

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

                    {

                    iPauseSupportMP4 = FALSE;

                    }

                if(iActiveSchedulerWait->IsStarted())

                    {

                    iActiveSchedulerWait->AsyncStop();

                    }

                }

            }

        else

            {

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

            XAAdaptationBaseMMF_SendAdaptEvents((XAAdaptationBaseMMFCtx*)iAdaptContext, &event );

            }

        }

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

        {

        iRecordState = CMMFBackendEngine::ERecorderRecording;

        iPositionUpdateTimer->Start(iTimerDelay);

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

        XAAdaptationBaseMMF_SendAdaptEvents((XAAdaptationBaseMMFCtx*)iAdaptContext, &event );

        }

    else   //ENotReady

        {

        //outputfile is not open

        iRecordState = CMMFBackendEngine::ERecorderNotReady;   

        }

    }

TInt CMMFBackendEngine::SetRecorderState(TRecorderState state, XAboolean stopCalled)

    {

    TInt err(KErrNone);

    switch(state)

        {

        case ERecorderNotReady:

            iAudioRecorder->Close();

            iRecordState = ERecorderNotReady;

            break;

        case ERecorderOpen:

            if(iFileFormat == XA_CONTAINERTYPE_MP4 && !iPauseSupportMP4 && !stopCalled)

                {

                err = KErrNotSupported;

                return err;

                }            

            iPositionUpdateTimer->Stop();

            iAudioRecorder->Stop(); 

            iRecordState = ERecorderOpen;

            break;

        case ERecorderRecording:

            TRAP(err, iAudioRecorder->RecordL());

            break;

        }

    return err;

    }

void CMMFBackendEngine::AudioOpenFile()

    {

	TRAPD(err, iAudioPlayer->OpenFileL(iFileName));

	if(err)

	    {

	    }

    }

void CMMFBackendEngine::AudioStop()

    {

	iAudioPlayer->Stop();

    }

void CMMFBackendEngine::AudioPause()

    {

	iAudioPlayer->Pause();

    }

void CMMFBackendEngine::AudioClose()

    {

	iAudioPlayer->Close();

    }

void CMMFBackendEngine::ResumePlayback()

    {

    if(iPlayerState == EPlayerClosed)

        {

        //prepare playback

        if(iAPIBeingUsed == EAudioPlayerUtility)

            {

            AudioOpenFile();

            }

        else

            {

            TRAPD (error, iVideoPlayer->OpenFileL(iFileName));

            if(error != KErrNone)

                {

                }

            }

        iPlayerState = EPlayerPaused;    

        }

    else if (iPlayerState == EPlayerPaused)

        {

        if(iAPIBeingUsed == EAudioPlayerUtility)

            {

            iAudioPlayer->Play();  

            }

        else

            {

            iVideoPlayer->Play();

            }

        iPlayerState = EPlayerPlaying;

        }

    }

void CMMFBackendEngine::PausePlayback()

    {

    if(iAPIBeingUsed == EAudioPlayerUtility)

        {

        AudioPause();

        }

    else

        {

        TRAPD(err, iVideoPlayer->PauseL());

        if(err != KErrNone)

            {

            }

        } 

    iPlayerState = EPlayerPaused;

    }

void CMMFBackendEngine::StopPlayback()

    {

    if(iAPIBeingUsed == EAudioPlayerUtility)

        {

        AudioStop();

        }

    if(iAPIBeingUsed == EVideoPlayerUtility)