/* ------------------------------------------------------------------
 * Copyright (C) 1998-2009 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
#ifndef PVMF_STREAMING_MANAGER_NODE_H_INCLUDED
#include "pvmf_streaming_manager_node.h"
#endif

#ifndef PV_INTERFACE_H
#include "pv_interface.h"
#endif

#ifndef PVMF_SM_FSP_REGISTRY_H
#include "pvmf_sm_fsp_registry.h"
#endif

#ifndef PVMF_BASIC_ERRORINFOMESSAGE_H_INCLUDED
#include "pvmf_basic_errorinfomessage.h"
#endif

#ifndef PVMF_SM_FSP_REGISTRY_H
#include "pvmf_sm_fsp_registry.h"
#endif

#ifndef OSCL_DLL_H_INCLUDED
#include "oscl_dll.h"
#endif

//////////////////////////////////////////////////////////////////////
//To make this module as DLL we need to define entry point for the DLL
//////////////////////////////////////////////////////////////////////
OSCL_DLL_ENTRY_POINT_DEFAULT()


//////////////////////////////////////////////////
// Node Constructor & Destructor
//////////////////////////////////////////////////


PVMFStreamingManagerNode* PVMFStreamingManagerNode::New(int32 aPriority)
{
    PVMFStreamingManagerNode* smNode = NULL;
    smNode = OSCL_NEW(PVMFStreamingManagerNode, (aPriority));
    if (smNode)
    {
        smNode->Construct();
    }
    return smNode;
}

OSCL_EXPORT_REF PVMFStreamingManagerNode::PVMFStreamingManagerNode(int32 aPriority):
        OsclActiveObject(aPriority, "StreamingManagerNode"),
        iSMFSPRegistry(NULL),
        iSMFSPlugin(NULL),
        iLogger(NULL)
{
    iFSPDataSourceInitializationIntf = NULL;
}

void PVMFStreamingManagerNode::Construct()
{
    int32 err;
    OSCL_TRY(err,
             /*
              * Create the input command queue.  Use a reserve to avoid lots of
              * dynamic memory allocation.
              */
             iInputCommands.Construct(PVMF_STREAMING_MANAGER_NODE_COMMAND_ID_START,
                                      PVMF_STREAMING_MANAGER_VECTOR_RESERVE);
             iSMFSPRegistry = OSCL_NEW(PVMFSMFSPRegistry, ());
            );

    if (err != OsclErrNone)
    {
        OSCL_LEAVE(err);
    }
}

OSCL_EXPORT_REF PVMFStreamingManagerNode::~PVMFStreamingManagerNode()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::~PVMFStreamingManagerNode - In"));

    if (iSMFSPlugin)
    {
        if (iSMFSPRegistry)
        {
            if (iFSPDataSourceInitializationIntf)
            {
                iFSPDataSourceInitializationIntf->removeRef();
                iFSPDataSourceInitializationIntf = NULL;
            }

            bool retval = iSMFSPRegistry->ReleaseSMFSP(iFSPUuid, iSMFSPlugin);
            if (false == retval)
            {
                PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::~PVMFStreamingManagerNode - Error FSP could not be deleted "));
            }
            iSMFSPlugin = NULL;
        }
    }
    if (iSMFSPRegistry)
    {
        OSCL_DELETE(iSMFSPRegistry);
        iSMFSPRegistry = NULL;
    }

    iLogger = NULL;

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::~PVMFStreamingManagerNode - Out"));
}

/* PVMFNodeInterface's virtual functions implemenation*/
OSCL_EXPORT_REF PVMFStatus PVMFStreamingManagerNode::ThreadLogon()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogon - In"));

    PVMFStatus status = PVMFSuccess;
    switch (iInterfaceState)
    {
        case EPVMFNodeCreated:
        {
            if (!IsAdded())
                AddToScheduler();
            iLogger = PVLogger::GetLoggerObject("PVMFStreamingManagerNode");
            SetState(EPVMFNodeIdle);
        }
        break;
        default:
            status = PVMFErrInvalidState;
            break;
    }

    if (PVMFSuccess == status && iSMFSPlugin)
    {
        status = iSMFSPlugin->ThreadLogon();
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogon - Out status[%d]", status));
    return (status);
}

OSCL_EXPORT_REF PVMFStatus PVMFStreamingManagerNode::ThreadLogoff()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogoff - In"));


    PVMFStatus status = PVMFSuccess;

    if (iSMFSPlugin)
    {
        status = iSMFSPlugin->ThreadLogoff();
        OSCL_ASSERT(PVMFFailure != status);
        if (PVMFSuccess != status)
        {
            return status;
        }
    }

    switch (iInterfaceState)
    {
        case EPVMFNodeIdle:
        {
            iLogger = NULL;
            if (IsAdded())
                RemoveFromScheduler();
            SetState(EPVMFNodeCreated);
        }
        break;

        case EPVMFNodeCreated:
            status = PVMFSuccess;
            break;

        default:
            status = PVMFErrInvalidState;
            break;
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ThreadLogoff - Out status[%d]", status));
    return status;
}

PVMFSessionId PVMFStreamingManagerNode::Connect(const PVMFNodeSessionInfo &aSession)
{
    iUpstreamSession.iId = PVMFNodeInterface::Connect(aSession);
    iUpstreamSession.iInfo =  aSession;
    if (iSMFSPlugin)
    {
        iSMFSPlugin->Connect(iUpstreamSession);
    }
    return iUpstreamSession.iId;
}

PVMFStatus PVMFStreamingManagerNode::Disconnect(PVMFSessionId aSessionId)
{
    if (iSMFSPlugin)
        iSMFSPlugin->Disconnect(aSessionId);
    return PVMFNodeInterface::Disconnect(aSessionId);
}

OSCL_EXPORT_REF PVMFStatus PVMFStreamingManagerNode::GetCapability(PVMFNodeCapability& aNodeCapability)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetCapability - In"));

    PVMFStatus status = PVMFSuccess;
    if (iSMFSPlugin)
    {
        status = iSMFSPlugin->GetCapability(aNodeCapability);
    }
    else
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetCapability - Error iSMFSPlugin 0x%x, ", iSMFSPlugin));
        status = PVMFFailure;
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetCapability - Out status[%d]", status));
    return status;
}

OSCL_EXPORT_REF PVMFPortIter* PVMFStreamingManagerNode::GetPorts(const PVMFPortFilter* aFilter)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetPorts - In"));

    PVMFPortIter* portIter = NULL;
    if (iSMFSPlugin)
    {
        portIter = iSMFSPlugin->GetPorts(aFilter);
    }
    else
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::GetPorts - Error iSMFSPlugin 0x%x", iSMFSPlugin));
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::GetPorts - Out portIter[0x%x]", portIter));
    return portIter;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::QueryUUID(PVMFSessionId aSessId,
        const PvmfMimeString& aMimeType,
        Oscl_Vector< PVUuid, OsclMemAllocator >& aUuids,
        bool aExactUuidsOnly,
        const OsclAny* aContext)
{
    PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::QueryUUID - Error Deprecated Interface - Call Not Expected"));
    OSCL_UNUSED_ARG(aSessId);
    OSCL_UNUSED_ARG(aMimeType);
    OSCL_UNUSED_ARG(aUuids);
    OSCL_UNUSED_ARG(aExactUuidsOnly);
    OSCL_UNUSED_ARG(aContext);
    //We dont expect the user of streaming manager node to call QueryUUID, this API is deprecated for SM node.
    OSCL_LEAVE(OsclErrNotSupported);
    return 0;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::QueryInterface(PVMFSessionId aSessId, const PVUuid& aUuid,
        PVInterface*& aInterfacePtr,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryInterface - In"));

    //Check if we can handle this API in this node itself
    PVInterface* ifptr = NULL;
    if (queryInterface(aUuid, ifptr) == false)
    {
        if (!iSMFSPlugin)
            OSCL_LEAVE(OsclErrInvalidState);
        return 	iSMFSPlugin->QueryInterface(aSessId, aUuid, aInterfacePtr, aContext);
    }
    else
    {
        PVMFStreamingManagerNodeCommand cmd;
        cmd.Construct(aSessId, PVMF_STREAMING_MANAGER_NODE_QUERYINTERFACE, aUuid, aInterfacePtr, aContext);
        PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::QueryInterface - Out"));
        return QueueCommandL(cmd);
    }
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::RequestPort(PVMFSessionId aSessId,
        int32 aPortTag,
        const PvmfMimeString* aPortConfig,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::RequestPort - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->RequestPort(aSessId, aPortTag, aPortConfig, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::RequestPort - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::ReleasePort(PVMFSessionId aSessId,
        PVMFPortInterface& aPort,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ReleasePort - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->ReleasePort(aSessId, aPort, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ReleasePort - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Init(PVMFSessionId aSessId,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Init - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->Init(aSessId, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Init - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Prepare(PVMFSessionId aSessId,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Prepare - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->Prepare(aSessId, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Prepare - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Start(PVMFSessionId aSessId,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Start - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->Start(aSessId, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Start - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Stop(PVMFSessionId aSessId,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Stop - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->Stop(aSessId, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Stop - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Flush(PVMFSessionId aSessId,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Flush - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->Flush(aSessId, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Flush - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Pause(PVMFSessionId aSessId,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Pause - In"));

    if (!iSMFSPlugin)
        OSCL_LEAVE(OsclErrInvalidState);

    PVMFCommandId cmdId = 0;
    cmdId = iSMFSPlugin->Pause(aSessId, aContext);

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Pause - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::Reset(PVMFSessionId aSessId,
        const OsclAny* aContext)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Reset - In"));

    PVMFCommandId cmdId = 0;
    if (iSMFSPlugin)
    {
        cmdId = iSMFSPlugin->Reset(aSessId, aContext);
    }
    else
    {
        PVMFStreamingManagerNodeCommand cmd;
        cmd.Construct(aSessId, PVMF_STREAMING_MANAGER_NODE_RESET, aContext);
        cmdId = QueueCommandL(cmd);
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Reset - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::CancelAllCommands(PVMFSessionId aSessId,
        const OsclAny* aContextData)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CancelAllCommands"));

    PVMFCommandId cmdId = 0;
    if (iSMFSPlugin)
    {
        cmdId = iSMFSPlugin->CancelAllCommands(aSessId, aContextData);
    }
    else
    {
        PVMFStreamingManagerNodeCommand cmd;
        cmd.Construct(aSessId, PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS, aContextData);
        cmdId = QueueCommandL(cmd);
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CancelAllCommands() - Out cmdId[%d]", cmdId));
    return cmdId;
}

OSCL_EXPORT_REF PVMFCommandId PVMFStreamingManagerNode::CancelCommand(PVMFSessionId aSessId,
        PVMFCommandId aCmdId,
        const OsclAny* aContextData)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CancelCommand with id %d", aCmdId));

    PVMFCommandId cmdId = 0;
    if (iSMFSPlugin)
    {
        cmdId = iSMFSPlugin->CancelCommand(aSessId, aCmdId, aContextData);
    }
    else
    {
        PVMFStreamingManagerNodeCommand cmd;
        cmd.Construct(aSessId, PVMF_STREAMING_MANAGER_NODE_CANCELCOMMAND, aContextData);
        cmdId = QueueCommandL(cmd);
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::CancelCommand() - Out cmdId[%d]", cmdId));
    return cmdId;
}

/* PVMFPortActivityHandler's virtual functions implemenation */
void PVMFStreamingManagerNode::HandlePortActivity(const PVMFPortActivity& aActivity)
{
    //this node just acts as a proxy and does'nt has any port of its own, So, this func will never be called
    OSCL_UNUSED_ARG(aActivity);
    OSCL_ASSERT(false);
}

/* PVMFDataSourceInitializationExtensionInterface's virtual functions implemenation */
PVMFStatus PVMFStreamingManagerNode::SetSourceInitializationData(OSCL_wString& aSourceURL,
        PVMFFormatType& aSourceFormat,
        OsclAny* aSourceData)
{
    PVMFStatus status = PVMFFailure;
    //we may have the sequence like
    //Reset->queryinterface(PVMFDataSourceInitializationExtensionInterface)->PVMFDataSourceInitializationExtensionInterface::SetSourceInitializationData
    //Hence, we cannot rule out the possibility of FSP plugin already being created or multiple calls to
    //PVMFDataSourceInitializationExtensionInterface::SetSourceInitializationData
    if (iSMFSPlugin)
    {
        if (iSMFSPRegistry)
        {
            if (iFSPDataSourceInitializationIntf)
            {
                iFSPDataSourceInitializationIntf->removeRef();
                iFSPDataSourceInitializationIntf = NULL;
            }
            OSCL_ASSERT(iSMFSPRegistry->ReleaseSMFSP(iFSPUuid, iSMFSPlugin));
            iSMFSPlugin = NULL;
        }
    }

    PVMFFormatType fspSrcFormat = aSourceFormat;
    //Check if tunelling plugin is to be instantiated?
    if (aSourceFormat == PVMF_MIME_DATA_SOURCE_RTSP_URL)//check for SDP files too???
    {
        OSCL_wStackString<8> rtsptScheme(_STRLIT_WCHAR("rtspt"));
        if (oscl_strncmp(rtsptScheme.get_cstr(), aSourceURL.get_cstr(), 5) == 0)
        {
            fspSrcFormat = PVMF_MIME_DATA_SOURCE_RTSP_TUNNELLING;
        }
    }
    if (fspSrcFormat != PVMF_MIME_DATA_SOURCE_RTSP_TUNNELLING) //Check if [RTSPUnicast and PVR]/[RTSPBroadcast and/or PVR] feature is required
    {
        if (aSourceData)
        {
            PVInterface* pvInterface = OSCL_STATIC_CAST(PVInterface*, aSourceData);
            PVInterface* sourceDataContext = NULL;
            PVUuid sourceContextUuid(PVMF_SOURCE_CONTEXT_DATA_UUID);
            if (pvInterface)
            {
                if (pvInterface->queryInterface(sourceContextUuid, sourceDataContext))
                {
                    if (sourceDataContext)
                    {
                        PVInterface* packetSourceContextData = NULL;
                        PVUuid packetSourceContextUuid(PVMF_SOURCE_CONTEXT_DATA_PACKETSOURCE_UUID); //Check for Broadcast Plugin

                        PVInterface* pvrDataContext = NULL;
                        PVUuid pvrContextUuid(PVMF_SOURCE_CONTEXT_DATA_PVR_UUID); //Check for RTSP Unicast + PVR plugin

                        PVInterface* pvrFilePlaybackContextData = NULL;
                        PVUuid pvrFileContextUuid(PVMF_SOURCE_CONTEXT_DATA_PVRLOCALPLAYBACK_UUID); //Check for PVR FilePlayback Plugin

                        if (sourceDataContext->queryInterface(packetSourceContextUuid, packetSourceContextData))
                        {
                            if (packetSourceContextData)
                            {
                                //Broadcast is to be enabled
                                if ((aSourceFormat == PVMF_MIME_DATA_SOURCE_RTSP_URL) || (aSourceFormat == PVMF_MIME_DATA_SOURCE_SDP_FILE))
                                {
                                    OSCL_ASSERT(fspSrcFormat == aSourceFormat);
                                    fspSrcFormat = PVMF_MIME_DATA_SOURCE_RTSP_BROADCAST;
                                }
                                packetSourceContextData->removeRef();
                            }
                        }

                        else if (sourceDataContext->queryInterface(pvrFileContextUuid, pvrFilePlaybackContextData))
                        {
                            if (pvrFilePlaybackContextData)
                            {
                                //PVR File Playback Pluign enable
                                if (aSourceFormat == PVMF_MIME_DATA_SOURCE_SDP_FILE)
                                {
                                    OSCL_ASSERT(fspSrcFormat == aSourceFormat);
                                    fspSrcFormat = PVMF_MIME_DATA_SOURCE_PVR_FILEPLAYBACK;
                                }
                                pvrFilePlaybackContextData->removeRef();
                            }
                        }

                        else if (sourceDataContext->queryInterface(pvrContextUuid, pvrDataContext))
                        {

                            if (pvrDataContext)
                            {
                                //PVR is to be enabled.
                                //set fsp src format type
                                if ((aSourceFormat == PVMF_MIME_DATA_SOURCE_RTSP_URL) || (aSourceFormat == PVMF_MIME_DATA_SOURCE_SDP_FILE))
                                {
                                    OSCL_ASSERT(fspSrcFormat == aSourceFormat);
                                    fspSrcFormat = PVMF_MIME_DATA_SOURCE_RTSP_UNICAST_PLUS_PVR;
                                }
                                pvrDataContext->removeRef();
                            }

                        }
                        sourceDataContext->removeRef();

                    }
                }
            }

        }
    }

    Oscl_Vector<PVUuid, OsclMemAllocator> srcNodeUuidVec;
    if (PVMFSuccess == iSMFSPRegistry->QueryRegistry(fspSrcFormat, srcNodeUuidVec))
    {
        iFSPUuid = srcNodeUuidVec.front();
        iSMFSPlugin = iSMFSPRegistry->CreateSMFSP(iFSPUuid);
        //(ii)threadlogon to FSP
        iSMFSPlugin->ThreadLogon();
        //(iii)connect to it, make sure datasource initialization interface is present
        PVMFSessionId sessID = iSMFSPlugin->Connect(iUpstreamSession);
        PVInterface* temp = NULL;
        PVMFStatus statusQ = PVMFFailure;

        statusQ = iSMFSPlugin->queryInterface(PVMF_DATA_SOURCE_INIT_INTERFACE_UUID, temp);
        iFSPDataSourceInitializationIntf = OSCL_STATIC_CAST(PVMFDataSourceInitializationExtensionInterface*, temp);

        if ((statusQ == PVMFSuccess) && (iFSPDataSourceInitializationIntf != NULL))
        {
            status = iFSPDataSourceInitializationIntf->SetSourceInitializationData(aSourceURL, aSourceFormat, aSourceData);
        }
        else
        {
            iSMFSPlugin->Disconnect(sessID);
            iSMFSPlugin->ThreadLogoff();
            iSMFSPRegistry->ReleaseSMFSP(iFSPUuid, iSMFSPlugin);
            iSMFSPlugin = NULL;
            PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::SetSourceInitializationData() - Destructed FSP "));
        }
    }

    return status;
}

PVMFStatus PVMFStreamingManagerNode::SetClientPlayBackClock(PVMFMediaClock* aClientClock)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::SetClientPlayBackClock - In"));

    PVMFStatus status = PVMFSuccess;
    if (iFSPDataSourceInitializationIntf)
    {
        status = iFSPDataSourceInitializationIntf->SetClientPlayBackClock(aClientClock);
    }
    else
    {
        status = PVMFFailure;
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::SetClientPlayBackClock - Out status [%d]", status));
    return status;
}

PVMFStatus PVMFStreamingManagerNode::SetEstimatedServerClock(PVMFMediaClock* aEstimatedServerClock)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::SetEstimatedServerClock - In"));

    PVMFStatus status = PVMFSuccess;
    if (iFSPDataSourceInitializationIntf)
    {
        status = iFSPDataSourceInitializationIntf->SetEstimatedServerClock(aEstimatedServerClock);
    }
    else
    {
        status = PVMFFailure;
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::SetEstimatedServerClock - Out status [%d]", status));
    return status;
}

/**
 * This routine is called by various command APIs to queue an
 * asynchronous command for processing by the command handler AO.
 * This function may leave if the command can't be queued due to
 * memory allocation failure.
 */
PVMFCommandId PVMFStreamingManagerNode::QueueCommandL(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMFCommandId id;

    id = iInputCommands.AddL(aCmd);

    if (IsAdded())
    {
        //wakeup the AO
        RunIfNotReady();
    }
    return id;
}

/* From OsclActiveObject */
void PVMFStreamingManagerNode::Run()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Run - In"));
    /* Process commands */
    if (!iInputCommands.empty())
    {
        if (ProcessCommand(iInputCommands.front()))
        {
            /*
             * re-schedule if more commands to do
             * and node isn't reset.
             */
            if (!iInputCommands.empty() && iInterfaceState != EPVMFNodeCreated)
            {
                if (IsAdded())
                {
                    RunIfNotReady();
                }
            }
            return;
        }
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::Run - Out"));
}

void PVMFStreamingManagerNode::DoCancel()
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoCancel - In"));
    /* the base class cancel operation is sufficient */
    OsclActiveObject::DoCancel();
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoCancel - Out"));
}

bool PVMFStreamingManagerNode::ProcessCommand(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::ProcessCommand - In"));
    //Because all the commands are processed in one AO cycle. So, there's no need for current command Q/Cancel command Q.

    switch (aCmd.iCmd)
    {
        case PVMF_STREAMING_MANAGER_NODE_QUERYINTERFACE:
            DoQueryInterface(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_RESET:
            ThreadLogoff();
            CommandComplete(iInputCommands, aCmd, PVMFSuccess);
            break;

        case PVMF_STREAMING_MANAGER_NODE_CANCELALLCOMMANDS:
            DoCancelAllCommands(aCmd);
            break;

        case PVMF_STREAMING_MANAGER_NODE_CANCELCOMMAND:
            CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
            break;

        default:
            /* unknown command type */
            CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
            break;
    }
    return true;
}

bool PVMFStreamingManagerNode::DoCancelAllCommands(PVMFStreamingManagerNodeCommand& aCmd)
{
    const int32 cancelCmdId = iInputCommands.front().iId;
    const int32 inputCmndsSz = iInputCommands.size();

    for (int ii = inputCmndsSz - 1; ii > 0 ; ii--) //we dont want to process element at index 0 (being cancel command)
    {
        if (iInputCommands[ii].iId < cancelCmdId)
        {
            CommandComplete(iInputCommands, iInputCommands[ii], PVMFErrCancelled);
        }
    }
    CommandComplete(iInputCommands, aCmd, PVMFSuccess); //complete the cancel all command

    PVMF_SM_LOGSTACKTRACE((0, "PVMFSMFSPBaseNode::DoCancelAllCommands Out"));
    return true;
}

void PVMFStreamingManagerNode::CommandComplete(PVMFStreamingManagerNodeCmdQ& aCmdQ,
        PVMFStreamingManagerNodeCommand& aCmd,
        PVMFStatus aStatus,
        OsclAny* aEventData,
        PVUuid* aEventUUID,
        int32* aEventCode)
{
    PVMF_SM_LOGSTACKTRACE((0, "StreamingManagerNode:CommandComplete Id %d Cmd %d Status %d Context %d Data %d"
                           , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));

    PVInterface* extif = NULL;
    PVMFBasicErrorInfoMessage* errormsg = NULL;
    if (aEventUUID && aEventCode)
    {
        errormsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (*aEventCode, *aEventUUID, NULL));
        extif = OSCL_STATIC_CAST(PVInterface*, errormsg);
    }

    /* create response */
    PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, extif, aEventData);
    PVMFSessionId session = aCmd.iSession;

    /* Erase the command from the queue */
    aCmdQ.Erase(&aCmd);

    /* Report completion to the session observer */
    ReportCmdCompleteEvent(session, resp);

    if (errormsg)
    {
        errormsg->removeRef();
    }

    /* Reschedule AO if input command queue is not empty */
    if (!iInputCommands.empty() && IsAdded())
    {
        if (IsAdded())
        {
            RunIfNotReady();
        }
    }
}

void PVMFStreamingManagerNode::DoQueryInterface(PVMFStreamingManagerNodeCommand& aCmd)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryInterface - In"));

    PVUuid* uuid;
    PVInterface** ifptr;
    aCmd.Parse(uuid, ifptr);
    if (ifptr == NULL)
    {
        PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFStreamingManagerNode::DoQueryInterface() Passed in parameter invalid."));
        CommandComplete(iInputCommands, aCmd, PVMFErrArgument);
        return;
    }

    if (queryInterface(*uuid, *ifptr) == false)
    {
        CommandComplete(iInputCommands, aCmd, PVMFFailure);
    }
    else
    {
        (*ifptr)->addRef();
        CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::DoQueryInterface - Out"));
}

bool PVMFStreamingManagerNode::queryInterface(const PVUuid& uuid, PVInterface*& iface)
{
    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::queryInterface - In"));

    if (uuid == PVMF_DATA_SOURCE_INIT_INTERFACE_UUID)
    {
        iface = OSCL_STATIC_CAST(PVInterface*, this);
    }
    else
    {
        PVMF_SM_LOGERROR((0, "PVMFStreamingManagerNode::queryInterface() Unsupported interface UUID."));
        return false;
    }

    PVMF_SM_LOGSTACKTRACE((0, "PVMFStreamingManagerNode::queryInterface - Out"));
    return true;
}

//Streaming Source node implements all the interfaces in the Streaming Manager
//Node or FSP, So they are created and destroyed with the creation/destruction
//of StreamingManager Node/FSP. Hence addref and removeref doesn't really do
//any thing..
void PVMFStreamingManagerNode::addRef()
{

}

void PVMFStreamingManagerNode::removeRef()
{

}