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


/**
@file
@internalComponent
*/

#include "omxthreadrequest.h"

COmxThreadRequest* COmxThreadRequest::NewL()
    {
    COmxThreadRequest* self = new (ELeave) COmxThreadRequest();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

COmxThreadRequest::COmxThreadRequest()
    {
    }

void COmxThreadRequest::ConstructL()
    {
    //Parameters to send to the sub thread
    TThreadParam param;
    param.iThreadRequestObj = this;
    
    //Get a reference to this thread's heap
    RHeap& thisHeap = User::Heap();
            
    //Get the id of this thread
    RThread thisThread;
    TThreadId thisThreadId = thisThread.Id();
    param.iMainThreadId = thisThreadId;
    
    //Get a request to signal for setup completion
    TRequestStatus setupComplete = KRequestPending;
    param.iSetupComplete = &setupComplete;
    
    //current time and the "this" pointer for a unique key
    _LIT(KFormatString,"%S.%020Lu.%08X");
    TName threadName;
    TTime now;
    now.UniversalTime();
    threadName.Format(KFormatString, &KXMLClientOMXThreadName, now.Int64(), reinterpret_cast<TUint>(this));

    //Create a new thread using the same heap as this thread
    TInt result = iRequestThread.Create(threadName,
                                    ThreadCreateFunction,
                                    KDefaultStackSize,
                                    &thisHeap,
                                    &param);
    User::LeaveIfError(result);

    //Run the thread under high priority
    iRequestThread.SetPriority(EPriorityNormal); 

    //Wait for thread startup to complete
    TRequestStatus threadStatus = KRequestPending;
    iRequestThread.Logon(threadStatus);

    //Start the thread
    iRequestThread.Resume();
    User::WaitForRequest(threadStatus, setupComplete);
    if(threadStatus != KRequestPending)
        {
        //Thread creation failed
        TInt reason = iRequestThread.ExitReason();
        User::Leave(reason);
        }

    // Thread creation was successfull
    TInt error = iRequestThread.LogonCancel(threadStatus);
    User::LeaveIfError(error); // There is no outstanding request
    User::WaitForRequest(threadStatus); // Consume the signal

    iThreadCreated = ETrue;
    User::LeaveIfError(setupComplete.Int());
    }

/**
Main thread entry point for the omx sub-thread.
Create a cleanup stack for the thread and process the commands
inside a trap for cleanup behaviour.
@internalComponent

@param aPtr Parameters to be used for creating the thread.
@return The error code for thread termination.
*/
TInt COmxThreadRequest::ThreadCreateFunction(TAny* aPtr)
    {
    TInt error = KErrNone;

    // Create a cleanup stack for the thread
    CTrapCleanup* cleanupStack = CTrapCleanup::New();
    if (cleanupStack)
        {
        if(error == KErrNone)
            {
            TRAP(error, ThreadTrapFunctionL(aPtr));
            }
        }
    else
        {
        error = KErrNoMemory;
        }

    delete cleanupStack;
    return error;
    }

/**
Function for thread execution. If the thread is successfully created signal
the main thread that the thread creation was successfull. Then enter OMX
request loop.

@internalComponent

@param aPtr A pointer to a TThreadParam object containing the startup parameters
            for the thread.
*/
void COmxThreadRequest::ThreadTrapFunctionL(TAny* aPtr)
    {
    TThreadParam* param = static_cast<TThreadParam*>(aPtr);
    COmxThreadRequest* iThreadRequestObj = param->iThreadRequestObj;
    
    // tell main thread that setup is complete
    RThread mainThread;
    mainThread.Open(param->iMainThreadId);
    mainThread.RequestComplete(param->iSetupComplete, KErrNone);
    mainThread.Close();
    
    // loop to execute OMX commands in own thread
    while(iThreadRequestObj->iFunction != EOMXFunctionCodeTerminate)
        {
        iThreadRequestObj->iRequestThreadStatus = KRequestPending;
        
        // block until client request is made
        User::WaitForRequest(iThreadRequestObj->iRequestThreadStatus);
        switch(iThreadRequestObj->iFunction)
            {
            case EOMXFunctionCodeGetHandle:
                iThreadRequestObj->iErrorType = OMX_GetHandle(
                        iThreadRequestObj->ipHandle,
                        iThreadRequestObj->icComponentName,
                        iThreadRequestObj->ipAppData,
                        iThreadRequestObj->ipCallBacks);
                break;
                
            case EOMXFunctionCodeFreeHandle:
                iThreadRequestObj->iErrorType = OMX_FreeHandle(
                        iThreadRequestObj->ihComponent);
                break;
                
            case EOMXFunctionCodeTerminate:
                break;
                
            default:
                // should never be reached
                User::Panic(_L("COmxThreadRequest"), KErrNotSupported);
            }
        
        // complete client request
        TRequestStatus *status = iThreadRequestObj->iCallingStatus;
        RThread callingThread;
        callingThread.Open(iThreadRequestObj->iCallingThreadId);
        callingThread.RequestComplete(status, KErrNone);
        callingThread.Close();
        }
    }

COmxThreadRequest::~COmxThreadRequest()
    {
    if(iThreadCreated)
        {
        TRequestStatus status;
        // Logon to ensure thread has completely terminated, not just broken out of message handling loop.
        // In particular this ensures the cleanup stack is destroyed before the heap marks are inspected.
        iRequestThread.Logon(status);
        Terminate();
        User::WaitForRequest(status);
        iThreadCreated = EFalse;
        iRequestThread.Close();
        }
    }

OMX_ERRORTYPE COmxThreadRequest::GetHandle(
        OMX_OUT OMX_HANDLETYPE* pHandle,
        OMX_IN  OMX_STRING cComponentName,
        OMX_IN  OMX_PTR pAppData,
        OMX_IN  OMX_CALLBACKTYPE* pCallBacks)
    {
    ipHandle = pHandle;
    icComponentName = cComponentName;
    ipAppData = pAppData;
    ipCallBacks = pCallBacks;
    
    iFunction = EOMXFunctionCodeGetHandle; 
    DoRequest();
    
    return iErrorType;
    }

OMX_ERRORTYPE COmxThreadRequest::FreeHandle(
    OMX_IN  OMX_HANDLETYPE hComponent)
    {
    ihComponent = hComponent;
    
    iFunction = EOMXFunctionCodeFreeHandle; 
    DoRequest();
    
    return iErrorType;
    }

void COmxThreadRequest::Terminate()
    {
    iFunction = EOMXFunctionCodeTerminate; 
    DoRequest();
    }

void COmxThreadRequest::DoRequest()
    {
    RThread me;
    iCallingThreadId = me.Id();

    TRequestStatus callingRequestStatus = KRequestPending;
    iCallingStatus = &callingRequestStatus;
      
    // send request to request thread
    RThread requestThread;
    requestThread.Open(iRequestThread.Id());
    TRequestStatus* requestStatus = &iRequestThreadStatus;
    requestThread.RequestComplete(requestStatus, KErrNone);
    requestThread.Close();
     
    // block calling request until OMX request completes
    User::WaitForRequest(callingRequestStatus);
    }