/* ------------------------------------------------------------------
 * Copyright (C) 2008 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 OSCL_EXCLUSIVE_PTR_H_INCLUDED
#include "oscl_exclusive_ptr.h"
#endif
#ifndef PVMF_CPMPLUGIN_PASSTHRU_OMA1_H_INCLUDED
#include "pvmf_cpmplugin_passthru_oma1.h"
#endif
#ifndef PVLOGGER_H_INCLUDED
#include "pvlogger.h"
#endif
#ifndef PVMF_BASIC_ERRORINFOMESSAGE_H_INCLUDED
#include "pvmf_basic_errorinfomessage.h"
#endif
#ifndef PVMF_ERRORINFOMESSAGE_EXTENSION_H_INCLUDED
#include "pvmf_errorinfomessage_extension.h"
#endif
#ifndef OSCL_DLL_H_INCLUDED
#include "oscl_dll.h"
#endif
#include "pvmf_local_data_source.h"
#include "pvmf_cpmplugin_passthru_oma1_factory.h"
#include "pvmf_cpmplugin_passthru_oma1_types.h"

#ifndef PVMI_DRM_KVP_H_INCLUDED
#include "pvmi_drm_kvp.h"
#endif

// Define entry point for this DLL
OSCL_DLL_ENTRY_POINT_DEFAULT()

OSCL_EXPORT_REF PVMFOma1PassthruPluginFactory::PVMFOma1PassthruPluginFactory()
{
    iFailAuthorizeUsage = false; // To simulate "authorizeusage" failure
    iCancelAcquireLicense = false; //to simulate "cancelgetLicense"
    iCPMContentType = PVMF_CPM_FORMAT_AUTHORIZE_BEFORE_ACCESS; //default value
    iSourceInitDataNotSupported = false; //To simulate SourceInitializationData failure
}

//This constructor has only been introduced for test case scenarios simulation
OSCL_EXPORT_REF PVMFOma1PassthruPluginFactory::PVMFOma1PassthruPluginFactory(bool aAuthorizeUsage, bool aCancelAcquireLicense,
        bool aSourceInitDataNotSupported,
        PVMFCPMContentType aCPMContentType)
{
    iFailAuthorizeUsage = aAuthorizeUsage;// To simulate "authorizeusage" failure
    iCancelAcquireLicense = aCancelAcquireLicense; //To simulate "cancelAcquire"
    iCPMContentType = aCPMContentType; //what test case sets
    iSourceInitDataNotSupported = aSourceInitDataNotSupported;
}

//Oma1 Passthru plugin factory.
OSCL_EXPORT_REF PVMFCPMPluginInterface* PVMFOma1PassthruPluginFactory::CreateCPMPlugin()
{
    return PVMFCPMPassThruPlugInOMA1::CreatePlugIn(iFailAuthorizeUsage, iCancelAcquireLicense,
            iSourceInitDataNotSupported, iCPMContentType);
}

OSCL_EXPORT_REF void PVMFOma1PassthruPluginFactory::DestroyCPMPlugin(PVMFCPMPluginInterface* aPlugIn)
{
    PVMFCPMPassThruPlugInOMA1::DestroyPlugIn(aPlugIn);
}

PVMFCPMPluginInterface* PVMFCPMPassThruPlugInOMA1::CreatePlugIn(bool aFailAuthorizeUsage, bool aCancelAcquireLicense, bool aSourceInitDataNotSupported, PVMFCPMContentType aCPMContentType)
{
    PVMFCPMPassThruPlugInOMA1* plugIn = NULL;
    int32 err;
    OSCL_TRY(err,
             /*
              * Create pass thru OMA1.0 Plugin
              */
             plugIn = OSCL_NEW(PVMFCPMPassThruPlugInOMA1, (aFailAuthorizeUsage, aCancelAcquireLicense, aSourceInitDataNotSupported, aCPMContentType));
            );
    if (err != OsclErrNone)
    {
        OSCL_LEAVE(err);
    }

    return (OSCL_STATIC_CAST(PVMFCPMPluginInterface*, plugIn));
}

void PVMFCPMPassThruPlugInOMA1::DestroyPlugIn(PVMFCPMPluginInterface* aPlugIn)
{
    OSCL_DELETE(aPlugIn);
}

/**
 * Plugin Constructor & Destructor
 */
OSCL_EXPORT_REF PVMFCPMPassThruPlugInOMA1::PVMFCPMPassThruPlugInOMA1(bool aFailAuthorizeUsage, bool aCancelAcquireLicense,
        bool aSourceInitDataNotSupported, PVMFCPMContentType aCPMContentType,
        int32 aPriority)
        : OsclActiveObject(aPriority, "PVMFCPMPassThruPlugInOMA1"),
        iExtensionRefCount(0)
{
    iLogger = NULL;
    oSourceSet = false;
    iFileHandle = NULL;
    iDataStreamReadCapacityObserver = NULL;
    // To simulate "authorizeusage" failure
    iFailAuthorizeUsage = aFailAuthorizeUsage;
    //to simualte cancelGetLic
    iCancelAcquireLicense = aCancelAcquireLicense;
    //to simulate "notsupported" content
    iSourceInitDataNotSupported = aSourceInitDataNotSupported;

    iCPMContentType = aCPMContentType;
    int32 err;
    OSCL_TRY(err,
             /*
              * Create the input command queue.  Use a reserve to avoid lots of
              * dynamic memory allocation
              */
             iInputCommands.Construct(PVMF_CPM_PASSTHRU_PLUGIN_OMA1_COMMAND_ID_START,
                                      PVMF_CPM_PASSTHRU_PLUGIN_OMA1_INTERNAL_CMDQ_SIZE);

             /*
              * Create the "current command" queue.  It will only contain one
              * command at a time, so use a reserve of 1
              */
             iCurrentCommand.Construct(0, 1);

            );
    if (err != OsclErrNone)
    {
        OSCL_LEAVE(err);
    }
    //set the fixed metadata query and value strings.
    iMetaData[EIsProtectedOMA1].iQuery = PVMF_DRM_INFO_IS_PROTECTED_QUERY;
    iMetaData[EIsProtectedOMA1].iValue = PVMF_DRM_INFO_IS_PROTECTED_VALUE;

    iMetaData[ELicAvailableOMA1].iQuery = PVMF_DRM_INFO_IS_LICENSE_AVAILABLE_QUERY;
    iMetaData[ELicAvailableOMA1].iValue = PVMF_DRM_INFO_IS_LICENSE_AVAILABLE_VALUE;

    iMetaData[ELicTypeOMA1].iQuery = PVMF_DRM_INFO_LICENSE_TYPE_QUERY;
    iMetaData[ELicTypeOMA1].iValue = PVMF_DRM_INFO_LICENSE_TYPE_VALUE;

    iMetaData[EForwardLockOMA1].iQuery = PVMF_DRM_INFO_IS_FORWARD_LOCKED_QUERY;
    iMetaData[EForwardLockOMA1].iValue = PVMF_DRM_INFO_IS_FORWARD_LOCKED_VALUE;

    for (uint32 i = 0;i < ELicLastOMA1;i++)
    {
        iMetaData[i].iKvp.key = iMetaData[i].iValue.get_str();
        iMetaData[i].iKvp.length = 0;
        iMetaData[i].iKvp.capacity = 0;
    }

}

PVMFCPMPassThruPlugInOMA1::~PVMFCPMPassThruPlugInOMA1()
{
    oSourceSet = false;
    /*
     * Cleanup commands
     * The command queues are self-deleting, but we want to
     * notify the observer of unprocessed commands.
     */
    while (!iCurrentCommand.empty())
    {
        CommandComplete(iCurrentCommand, iCurrentCommand.front(), PVMFFailure);
    }
    while (!iInputCommands.empty())
    {
        CommandComplete(iInputCommands, iInputCommands.front(), PVMFFailure);
    }
}

void PVMFCPMPassThruPlugInOMA1::ThreadLogon()
{
    if (!iLoggedOn)
    {
        iLogger = PVLogger::GetLoggerObject("PVMFCPMPassThruPlugInOMA1");
        AddToScheduler();
        iLoggedOn = true;
    }
}

void PVMFCPMPassThruPlugInOMA1::ThreadLogoff()
{
    if (iLoggedOn)
    {
        iLogger = NULL;
        Cancel();
        RemoveFromScheduler();
        iLoggedOn = false;
    }
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::QueryUUID(PVMFSessionId s,
                                     const PvmfMimeString& aMimeType,
                                     Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
                                     bool aExactUuidsOnly,
                                     const OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:QueryUUID"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
            PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYUUID,
            aMimeType,
            aUuids,
            aExactUuidsOnly,
            aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::QueryInterface(PVMFSessionId s,
        const PVUuid& aUuid,
        PVInterface*& aInterfacePtr,
        const OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:QueryInterface"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
            PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYINTERFACE,
            aUuid,
            aInterfacePtr,
            aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::Init(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:Init"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
            PVMF_CPM_PASSTHRU_PLUGIN_OMA1_INIT,
            aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::Reset(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:Reset"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
            PVMF_CPM_PASSTHRU_PLUGIN_OMA1_RESET,
            aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::AuthenticateUser(PVMFSessionId aSessionId,
        OsclAny* aAuthenticationData,
        OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:AuthenticateUser"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.Construct(aSessionId,
                  PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHENTICATE,
                  aAuthenticationData,
                  NULL,
                  aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::AuthorizeUsage(PVMFSessionId aSessionId,
        PvmiKvp& aRequestedUsage,
        PvmiKvp& aApprovedUsage,
        PvmiKvp& aAuthorizationData,
        uint32&  aRequestTimeOutInMS,
        OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:AuthorizeUsage"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.Construct(aSessionId,
                  PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHORIZE_USAGE,
                  &aRequestedUsage,
                  &aApprovedUsage,
                  &aAuthorizationData,
                  &aRequestTimeOutInMS,
                  aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::UsageComplete(PVMFSessionId s, const OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:UsageComplete"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
            PVMF_CPM_PASSTHRU_PLUGIN_OMA1_USAGE_COMPLETE,
            aContext);
    return QueueCommandL(cmd);
}

PVMFStatus
PVMFCPMPassThruPlugInOMA1::SetSourceInitializationData(OSCL_wString& aSourceURL,
        PVMFFormatType& aSourceFormat,
        OsclAny* aSourceData)
{
    OSCL_UNUSED_ARG(aSourceData);
    //just save the parameters-- the passthru plugin does not
    //do any format checks.
    {
        iFilename = aSourceURL;
        iSourceFormatType = aSourceFormat;
        /*
        if(aSourceData)
        {
        	iFileHandle=((PVMFLocalDataSource*)aSourceData)->iFileHandle;
        }
        else
        {
        	iFileHandle=NULL;
        }
        */
        if (iSourceInitDataNotSupported)
        {
            iSourceInitDataNotSupported = false; //reset for next time
            return PVMFErrNotSupported;
        }
        oSourceSet = true;
        return PVMFSuccess;
    }
}

PVMFCPMContentType
PVMFCPMPassThruPlugInOMA1::GetCPMContentType()
{
    return iCPMContentType;
}

PVMFStatus PVMFCPMPassThruPlugInOMA1::QueryAccessInterfaceUUIDs(Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids)
{
    aUuids.push_back(PVMFCPMPluginLocalSyncAccessInterfaceUuid);
    return PVMFSuccess;
}

PVInterface*
PVMFCPMPassThruPlugInOMA1::CreatePVMFCPMPluginAccessInterface(PVUuid& aUuid)
{
    if (aUuid == PVMIDataStreamSyncInterfaceUuid)
    {
        PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl* iface = NULL;
        iface = OSCL_NEW(PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl, (*this));

        PVMIDataStreamSyncInterface* interimPtr1
        = OSCL_STATIC_CAST(PVMIDataStreamSyncInterface*, iface);

        return (OSCL_STATIC_CAST(PVInterface*, interimPtr1));
    }

    return NULL;
}

void
PVMFCPMPassThruPlugInOMA1::DestroyPVMFCPMPluginAccessInterface(PVUuid& aUuid,
        PVInterface* aPtr)
{
    if (aUuid == PVMIDataStreamSyncInterfaceUuid)
    {
        PVMIDataStreamSyncInterface* interimPtr =
            (PVMIDataStreamSyncInterface*)aPtr;
        PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl* datastream =
            (PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl*)interimPtr;
        OSCL_DELETE(datastream);
    }
    else
    {
        OSCL_ASSERT(false);
    }
}

void
PVMFCPMPassThruPlugInOMA1::SetStreamReadCapacityObserver(PVMFDataStreamReadCapacityObserver* aObs)
{
    iDataStreamReadCapacityObserver = aObs;
}


/**
 * 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 PVMFCPMPassThruPlugInOMA1::QueueCommandL(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    PVMFCommandId id;
    id = iInputCommands.AddL(aCmd);
    /* wakeup the AO */
    RunIfNotReady();
    return id;
}

/**
 * The various command handlers call this when a command is complete.
 */
void PVMFCPMPassThruPlugInOMA1::CommandComplete(PVMFCPMPassThruPlugInOMA1CmdQ& aCmdQ,
        PVMFCPMPassThruPlugInOMA1Command& aCmd,
        PVMFStatus aStatus,
        OsclAny* aEventData,
        PVUuid* aEventUUID,
        int32* aEventCode)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1: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 if there are more commands.
    if (!iInputCommands.empty()
            && IsAdded())
    {
        RunIfNotReady();
    }
}

void
PVMFCPMPassThruPlugInOMA1::MoveCmdToCurrentQueue(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    int32 err;
    OSCL_TRY(err, iCurrentCommand.StoreL(aCmd););
    if (err != OsclErrNone)
    {
        PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGERROR((0, "PVMFCPMPassThruPlugInOMA1:MoveCmdToCurrentQueue - No Memory"));
        CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
        return;
    }
    iInputCommands.Erase(&aCmd);
    return;
}

/**
 * Called by the command handler AO to process a command from
 * the input queue.
 * Return true if a command was processed, false if the command
 * processor is busy and can't process another command now.
 */
bool PVMFCPMPassThruPlugInOMA1::ProcessCommand(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    /*
     * normally this node will not start processing one command
     * until the prior one is finished.  However, a hi priority
     * command such as Cancel must be able to interrupt a command
     * in progress.
     */
    if (!iCurrentCommand.empty() && !aCmd.hipri() && aCmd.iCmd != PVMF_CPM_PASSTHRU_PLUGIN_OMA1_CANCEL_GET_LICENSE)
        return false;

    switch (aCmd.iCmd)
    {
        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYUUID:
            DoQueryUuid(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYINTERFACE:
            DoQueryInterface(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_INIT:
            DoInit(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_RESET:
            DoReset(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHENTICATE:
            DoAuthenticate(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHORIZE_USAGE:
            DoAuthorizeUsage(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_USAGE_COMPLETE:
            DoUsageComplete(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_GET_LICENSE:
        {
            PVMFStatus aCmdStatus = DoGetLicense(aCmd);
            switch (aCmdStatus)
            {
                case PVMFPending:
                    MoveCmdToCurrentQueue(aCmd);
                    break;
            }
        }
        break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_CANCEL_GET_LICENSE:
            DoCancelGetLicense(aCmd);
            break;


        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_KEYS:
            DoMetadataKeys(aCmd);
            break;

        case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_VALUES:
            DoMetadataValues(aCmd);
            break;

        default:
        {
            /* unknown command type */
            PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGWARNING((0, "PVMFCPMPassThruPlugInOMA1:ProcessCommand - Unknown Command"));
            CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
        }
        break;
    }

    return true;
}

/**
 * Called by the command handler AO to do the Query UUID
 */
void PVMFCPMPassThruPlugInOMA1::DoQueryUuid(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    OSCL_String* mimetype;
    Oscl_Vector<PVUuid, OsclMemAllocator> *uuidvec;
    bool exactmatch;
    aCmd.PVMFCPMPassThruPlugInOMA1CommandBase::Parse(mimetype, uuidvec, exactmatch);

    if (exactmatch == false)
    {
        CommandComplete(iInputCommands, aCmd, PVMFErrArgument);
    }
    /*
     * Try to match the input mimetype against any of
     * the interfaces supported by this plugin
     */
    if (*mimetype == PVMF_CPMPLUGIN_AUTHENTICATION_INTERFACE_MIMETYPE)
    {
        PVUuid uuid(PVMFCPMPluginAuthenticationInterfaceUuid);
        uuidvec->push_back(uuid);
    }
    else if (*mimetype == PVMF_CPMPLUGIN_AUTHORIZATION_INTERFACE_MIMETYPE)
    {
        PVUuid uuid(PVMFCPMPluginAuthorizationInterfaceUuid);
        uuidvec->push_back(uuid);
    }
    else if (*mimetype == PVMF_CPMPLUGIN_ACCESS_INTERFACE_FACTORY_MIMETYPE)
    {
        PVUuid uuid(PVMFCPMPluginAccessInterfaceFactoryUuid);
        uuidvec->push_back(uuid);
    }
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

/**
 * Called by the command handler AO to do the Query Interface.
 */
void PVMFCPMPassThruPlugInOMA1::DoQueryInterface(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    PVUuid* uuid;
    PVInterface** ptr;
    aCmd.PVMFCPMPassThruPlugInOMA1CommandBase::Parse(uuid, ptr);

    if ((*uuid == PVMFCPMPluginAuthorizationInterfaceUuid) ||
            (*uuid == PVMFCPMPluginAccessInterfaceFactoryUuid))
    {
        if (oSourceSet == false)
        {
            CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
            return;
        }
    }

    if (queryInterface(*uuid, *ptr))
    {
        CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    }
    else
    {
        /* not supported */
        *ptr = NULL;
        CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
    }
}

bool PVMFCPMPassThruPlugInOMA1::queryInterface(const PVUuid& uuid, PVInterface*& iface)
{
    if (uuid == PVMFCPMPluginAuthenticationInterfaceUuid)
    {
        PVMFCPMPluginAuthenticationInterface* myInterface =
            OSCL_STATIC_CAST(PVMFCPMPluginAuthenticationInterface*, this);
        iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    }
    else if (uuid == PVMFCPMPluginAuthorizationInterfaceUuid)
    {
        PVMFCPMPluginAuthorizationInterface* myInterface =
            OSCL_STATIC_CAST(PVMFCPMPluginAuthorizationInterface*, this);
        iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    }
    else if (uuid == PVMFCPMPluginAccessInterfaceFactoryUuid)
    {
        PVMFCPMPluginAccessInterfaceFactory* myInterface =
            OSCL_STATIC_CAST(PVMFCPMPluginAccessInterfaceFactory*, this);
        iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    }
    else if (uuid == PVMFCPMPluginLicenseInterfaceUuid)
    {
        PVMFCPMPluginLicenseInterface* myInterface =
            OSCL_STATIC_CAST(PVMFCPMPluginLicenseInterface*, this);
        iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    }
    else if (uuid == KPVMFMetadataExtensionUuid)
    {
        PVMFMetadataExtensionInterface* myInterface
        = OSCL_STATIC_CAST(PVMFMetadataExtensionInterface*, this);
        iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    }
    else
    {
        return false;
    }
    addRef();
    return true;
}

void PVMFCPMPassThruPlugInOMA1::DoInit(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    /* Nothing to do */
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

void PVMFCPMPassThruPlugInOMA1::DoReset(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    oSourceSet = false;
    /* Nothing to do */
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

void PVMFCPMPassThruPlugInOMA1::DoAuthenticate(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    OsclAny* authenticationData;
    OsclAny* dummy;
    aCmd.Parse(authenticationData, dummy);

    /* Return success always, till siemens api become available */
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

void PVMFCPMPassThruPlugInOMA1::DoAuthorizeUsage(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    if (iFailAuthorizeUsage)
    {
        iFailAuthorizeUsage = false; //reset for next try
        CommandComplete(iInputCommands, aCmd, PVMFErrLicenseRequired);
        return;
    }
    MakeMetadata();
    PvmiKvp* requestedUsage;
    PvmiKvp* approvedUsage;
    PvmiKvp* authorizationData;
    uint32*  requestTimeOutInMS;
    aCmd.Parse(OSCL_STATIC_CAST(OsclAny*&, requestedUsage),
               OSCL_STATIC_CAST(OsclAny*&, approvedUsage),
               OSCL_STATIC_CAST(OsclAny*&, authorizationData),
               OSCL_STATIC_CAST(OsclAny*&, requestTimeOutInMS));


    /* No check needed - approve everything */
    approvedUsage->value.uint32_value = requestedUsage->value.uint32_value;
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

void PVMFCPMPassThruPlugInOMA1::DoUsageComplete(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

PVMFStatus PVMFCPMPassThruPlugInOMA1::DoGetLicense(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    if (!iCancelAcquireLicense)
    {
        CommandComplete(iInputCommands, aCmd, PVMFSuccess);
        return PVMFSuccess;
    }
    else
    {
        iCancelAcquireLicense = false; //Reset for next time
        return PVMFPending;
    }
}

void PVMFCPMPassThruPlugInOMA1::DoCancelGetLicense(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    //Complete all pending commands, basically "GetLicense"
    while (iCurrentCommand.size() > 0)
    {
        CommandComplete(iCurrentCommand, iCurrentCommand.front(), PVMFErrCancelled);
    }
    //complete the CancelGetLicense
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

void PVMFCPMPassThruPlugInOMA1::DoMetadataKeys(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

void PVMFCPMPassThruPlugInOMA1::DoMetadataValues(PVMFCPMPassThruPlugInOMA1Command& aCmd)
{
    CommandComplete(iInputCommands, aCmd, PVMFSuccess);
}

/**
  * This AO handles API commands. The AO will process one command
  * per call. It will re-schedule itself and run continuously
  * until it runs out of things to do.
  */
void PVMFCPMPassThruPlugInOMA1::Run()
{
    /*
     * Process commands.
     */
    if (!iInputCommands.empty())
    {
        ProcessCommand(iInputCommands.front());
    }
}

OSCL_EXPORT_REF PVMFStatus
PVMFCPMPassThruPlugInOMA1::GetLicenseURL(PVMFSessionId aSessionId,
        OSCL_wString& aContentName,
        OSCL_wString& aLicenseURL)
{
    OSCL_UNUSED_ARG(aSessionId);
    OSCL_UNUSED_ARG(aContentName);
    OSCL_UNUSED_ARG(aLicenseURL);
    return PVMFErrNotSupported;
}

OSCL_EXPORT_REF PVMFStatus
PVMFCPMPassThruPlugInOMA1::GetLicenseURL(PVMFSessionId aSessionId,
        OSCL_String&  aContentName,
        OSCL_String&  aLicenseURL)
{
    OSCL_UNUSED_ARG(aSessionId);
    OSCL_UNUSED_ARG(aContentName);
    OSCL_UNUSED_ARG(aLicenseURL);
    return PVMFErrNotSupported;
}

OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetLicense(PVMFSessionId aSessionId
        , OSCL_wString& aContentName
        , OsclAny* aLicenseData
        , uint32 aDataSize
        , int32 aTimeoutMsec
        , OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:GetLicense"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.Construct(aSessionId,
                  PVMF_CPM_PASSTHRU_PLUGIN_OMA1_GET_LICENSE,
                  &aContentName,
                  aLicenseData,
                  &aDataSize,
                  &aTimeoutMsec,
                  aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetLicense(PVMFSessionId aSessionId
        , OSCL_String&  aContentName
        , OsclAny* aLicenseData
        , uint32 aDataSize
        , int32 aTimeoutMsec
        , OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:GetLicense"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.Construct(aSessionId,
                  PVMF_CPM_PASSTHRU_PLUGIN_OMA1_GET_LICENSE,
                  &aContentName,
                  aLicenseData,
                  &aDataSize,
                  &aTimeoutMsec,
                  aContext);
    return QueueCommandL(cmd);
}

OSCL_EXPORT_REF PVMFCommandId
PVMFCPMPassThruPlugInOMA1::CancelGetLicense(PVMFSessionId aSessionId, PVMFCommandId aCmdId, OsclAny* aContext)
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1::CancelGetLicense - called"));
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(aSessionId, PVMF_CPM_PASSTHRU_PLUGIN_OMA1_CANCEL_GET_LICENSE, aCmdId, aContext);
    return QueueCommandL(cmd);
}

/**
 * Synchronous method to return the number of metadata keys for the specified query key string
 *
 * @param aQueryKeyString A NULL terminated character string specifying a subset of metadata keys to count.
 *                        If the string is NULL, total number of all keys will be returned
 *
 * @returns The number of metadata keys
 **/
OSCL_EXPORT_REF uint32 PVMFCPMPassThruPlugInOMA1::GetNumMetadataKeys(char* aQueryKeyString)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFCPMPassThruPlugInOMA1::GetNumMetadataKeys() called"));
    uint32 total = 0;
    for (uint32 i = 0;i < ELicLastOMA1;i++)
    {
        if (iMetaData[i].iValid)
        {
            if (!aQueryKeyString
                    || iMetaData[i].iQuery == aQueryKeyString)
            {
                total++;
            }
        }
    }
    return total;
}


/**
 * Synchronous method to return the number of metadata values for the specified list of key strings
 *
 * @param aKeyList A reference to a metadata key list to specifying the values of interest to count
 *
 * @returns The number of metadata values based on the provided key list
 **/
OSCL_EXPORT_REF uint32 PVMFCPMPassThruPlugInOMA1::GetNumMetadataValues(PVMFMetadataList& aKeyList)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFCPMPassThruPlugInOMA1::GetNumMetadataValues() called"));
    uint32 total = 0;
    for (uint32 i = 0;i < aKeyList.size();i++)
    {
        for (uint32 j = 0;j < ELicLastOMA1;j++)
        {
            if (iMetaData[j].iValid
                    && iMetaData[j].iQuery == aKeyList[i])
            {
                total++;
                break;//goto next query.
            }
        }
    }
    return total;
}

/**
 * Asynchronous method to retrieve a list of metadata keys. The subset of all available keys in the node can
 * be specified by providing a combination of query key string, starting index, and maximum number of keys to retrieve
 *
 * @param aSessionId The assigned node session ID to use for this request
 * @param aKeyList A reference to a metadata key list to add the metadata keys
 * @param aStartingKeyIndex Index into the node's total key list that corresponds to the first key entry to retrieve
 * @param aMaxKeyEntries The maximum number of key entries to add to aKeyList. If there is no maximum, set to -1.
 * @param aQueryKeyString Optional NULL terminated character string to select a subset of keys
 * @param aContext Optional opaque data to be passed back to user with the command response
 *
 * @returns A unique command ID for asynchronous completion
 **/
OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetNodeMetadataKeys(PVMFSessionId aSessionId,
        PVMFMetadataList& aKeyList,
        uint32 aStartingKeyIndex,
        int32 aMaxKeyEntries ,
        char* aQueryKeyString ,
        const OsclAny* aContextData)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFCPMPassThruPlugInOMA1::GetNodeMetadataKeys() called"));
    int32 total = 0;
    for (uint32 i = aStartingKeyIndex;i < ELicLastOMA1;i++)
    {
        if (iMetaData[i].iValid)
        {
            if (aMaxKeyEntries >= 0
                    && total >= aMaxKeyEntries)
                break;
            if (!aQueryKeyString
                    || iMetaData[i].iQuery == aQueryKeyString)
            {
                aKeyList.push_back(iMetaData[i].iQuery);
                total++;
            }
        }
    }
    //MyCmdResp resp(aSessionId,aContextData);
    //return QueueCmdResp(resp,PVMFSuccess);
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(aSessionId,
            PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_KEYS,
            aContextData);
    return QueueCommandL(cmd);
}

/**
 * Asynchronous method to retrieve a list of metadata values. The subset of all available values in the node can
 * be specified by providing a combination of key list, starting index, and maximum number of values to retrieve
 *
 * @param aSessionId The assigned node session ID to use for this request
 * @param aKeyList A reference to a metadata key list specifying the metadata values to retrieve
 * @param aValueList A reference to a metadata value list to add the metadata values
 * @param aStartingValueIndex Index into the node's value list specified by the key list that corresponds to the first value entry to retrieve
 * @param aMaxValueEntries The maximum number of value entries to add to aValueList. If there is no maximum, set to -1.
 * @param aContext Optional opaque data to be passed back to user with the command response
 *
 * @returns A unique command ID for asynchronous completion
 **/
OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetNodeMetadataValues(PVMFSessionId aSessionId,
        PVMFMetadataList& aKeyList,
        Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList,
        uint32 aStartingValueIndex,
        int32 aMaxValueEntries ,
        const OsclAny* aContextData)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFCPMPassThruPlugInOMA1::GetNodeMetadataValues() called"));
    uint32 total = 0;
    for (uint32 j = 0;j < aKeyList.size();j++)
    {
        for (int32 i = aStartingValueIndex;i < ELicLastOMA1;i++)
        {
            if (iMetaData[i].iValid)
            {
                if (aMaxValueEntries >= 0
                        && total >= aMaxValueEntries)
                    break;
                if (iMetaData[i].iQuery == aKeyList[j])
                {
                    aValueList.push_back(iMetaData[i].iKvp);
                    total++;
                    break;//go to next key.
                }
            }
        }
    }
    PVMFCPMPassThruPlugInOMA1Command cmd;
    cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(aSessionId,
            PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_VALUES,
            aContextData);
    return QueueCommandL(cmd);
}

/**
 * Synchronous method to free up the specified range of metadata keys in the list. It is assumed that caller of this function
 * knows that start and end indices should correspond to metadata keys returned by this particular instance of the
 * metadata extension interface using GetNodeMetadataKeys().
 *
 * @param aKeyList A reference to a metadata key list to free the key entries
 * @param aStartingKeyIndex Index into aKeyList that corresponds to the first key entry to release
 * @param aEndKeyIndex Index into aKeyList that corresponds to the last key entry to release
 *
 * @returns PVMFSuccess if the release of specified keys succeeded. PVMFErrArgument if indices are invalid or the list is empty.
 *          PVMFFailure otherwise.
 **/
OSCL_EXPORT_REF PVMFStatus PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataKeys(PVMFMetadataList& aKeyList,
        uint32 aStartingKeyIndex,
        uint32 aEndKeyIndex)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataKeys() called"));
    //nothing needed.  metadata memory persists through the life of the plugin.
    OSCL_UNUSED_ARG(aKeyList);
    OSCL_UNUSED_ARG(aStartingKeyIndex);
    OSCL_UNUSED_ARG(aEndKeyIndex);
    return PVMFSuccess;
}

/**
 * Synchronous method to free up the specified range of metadata values in the list. It is assumed that caller of this function
 * knows that start and end indices should correspond to metadata values returned by this particular instance of the
 * metadata extension interface using GetNodeMetadataValues().
 *
 * @param aValueList A reference to a metadata value list to free the value entries
 * @param aStartingValueIndex Index into aValueList that corresponds to the first value entry to release
 * @param aEndValueIndex Index into aValueList that corresponds to the last value entry to release
 *
 * @returns PVMFSuccess if the release of specified values succeeded. PVMFErrArgument if indices are invalid or the list is empty.
 *          PVMFFailure otherwise.
 **/
OSCL_EXPORT_REF PVMFStatus PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataValues(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList,
        uint32 aStartingValueIndex,
        uint32 aEndValueIndex)
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataValues() called"));
    OSCL_UNUSED_ARG(aValueList);
    OSCL_UNUSED_ARG(aStartingValueIndex);
    OSCL_UNUSED_ARG(aEndValueIndex);
    return PVMFSuccess;
}

//Make Metadata from license state data.
void PVMFCPMPassThruPlugInOMA1::MakeMetadata()
{
    PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
                    (0, "PVMFCPMPassThruPlugInOMA1::MakeMetadata() called"));

    //always set "is protected" here.  we rely on the source nodes
    //to only use this plugin for protected content.
    iMetaData[EIsProtectedOMA1].iValid = true;
    iMetaData[EIsProtectedOMA1].iKvp.value.bool_value = true;

    iMetaData[ELicAvailableOMA1].iValid = true;
    iMetaData[ELicAvailableOMA1].iKvp.value.bool_value = true;

    iLicType = "unlimited";
    iMetaData[ELicTypeOMA1].iValid = true;
    iMetaData[ELicTypeOMA1].iKvp.value.pChar_value = iLicType.get_str();

    iMetaData[EForwardLockOMA1].iValid = true;
    iMetaData[EForwardLockOMA1].iKvp.value.bool_value = true;
}

/**
** PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl
*/
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl(PVMFCPMPassThruPlugInOMA1&c)
        : iContainer(c)
{
    iFileObject = NULL;
    iLogger = iContainer.iLogger;
    iFs.Connect();
    iDataStreamReadCapacityObserver = iContainer.iDataStreamReadCapacityObserver;
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl"));
}

PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::~PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl()
{
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::~PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl"));
    if (iFileObject)
        OSCL_DELETE(iFileObject);
    iFileObject = NULL;
    iFs.Close();
    iLogger = NULL;
    iDataStreamReadCapacityObserver = NULL;
}

OSCL_EXPORT_REF bool
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::queryInterface(const PVUuid& uuid,
        PVInterface*& iface)
{
    iface = NULL;
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::queryInterface"));
    if (uuid == PVMIDataStreamSyncInterfaceUuid)
    {
        PVMIDataStreamSyncInterface* myInterface
        = OSCL_STATIC_CAST(PVMIDataStreamSyncInterface*, this);
        iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
        return true;
    }
    return false;
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::OpenSession(PvmiDataStreamSession& aSessionID,
        PvmiDataStreamMode aMode,
        bool nonblocking)
{
    OSCL_UNUSED_ARG(aSessionID);
    OSCL_UNUSED_ARG(nonblocking);
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::OpenSession"));
    if (!iFileObject)
        iFileObject = OSCL_NEW(Oscl_File, (0, iContainer.iFileHandle));

    int32 result;
    if ((aMode == PVDS_READ_ONLY) || (aMode == PVDS_READ_WRITE))
    {
        result = iFileObject->Open(iContainer.iFilename.get_cstr(), Oscl_File::MODE_READ, iFs);
        PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::OpenSession - File Open returning %d", result));
        return (result == 0) ? PVDS_SUCCESS : PVDS_FAILURE;
    }
    else
    {
        return PVDS_UNSUPPORTED_MODE;
    }

    return PVDS_SUCCESS;
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CloseSession(PvmiDataStreamSession sessionID)
{
    OSCL_UNUSED_ARG(sessionID);
    if (!iFileObject)
    {
        PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CloseSession returning %d", -1));
        return PVDS_FAILURE;
    }
    int32 result = iFileObject->Close();
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CloseSession returning %d", result));
    OSCL_DELETE(iFileObject);
    iFileObject = NULL;
    if (result == 0)
        return PVDS_SUCCESS;

    return PVDS_FAILURE;
}

OSCL_EXPORT_REF PvmiDataStreamRandomAccessType
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryRandomAccessCapability()
{
    return PVDS_FULL_RANDOM_ACCESS;
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryReadCapacity(PvmiDataStreamSession sessionID,
        uint32& capacity)
{
    OSCL_UNUSED_ARG(sessionID);
    if (iDataStreamReadCapacityObserver != NULL)
    {
        return (iDataStreamReadCapacityObserver->GetStreamReadCapacity(capacity));
    }
    else
    {
        if (!iFileObject)
            return PVDS_FAILURE;
        int32 result = iFileObject->Size();
        PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryReadCapacity returning %d", result));
        if (result < 0)
        {
            return PVDS_FAILURE;
        }
        else
        {
            capacity = result;
            return PVDS_SUCCESS;
        }
    }
}

OSCL_EXPORT_REF PvmiDataStreamCommandId
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::RequestReadCapacityNotification(PvmiDataStreamSession sessionID,
        PvmiDataStreamObserver& observer,
        uint32 capacity,
        OsclAny* aContextData)
{
    OSCL_UNUSED_ARG(sessionID);
    OSCL_UNUSED_ARG(observer);
    OSCL_UNUSED_ARG(capacity);
    OSCL_UNUSED_ARG(aContextData);
    OSCL_LEAVE(OsclErrNotSupported);
    return 0;
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryWriteCapacity(PvmiDataStreamSession sessionID,
        uint32& capacity)
{
    OSCL_UNUSED_ARG(sessionID);
    OSCL_UNUSED_ARG(capacity);
    return PVDS_NOT_SUPPORTED;
}

OSCL_EXPORT_REF PvmiDataStreamCommandId
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::RequestWriteCapacityNotification(PvmiDataStreamSession sessionID,
        PvmiDataStreamObserver& observer,
        uint32 capacity,
        OsclAny* aContextData)
{
    OSCL_UNUSED_ARG(sessionID);
    OSCL_UNUSED_ARG(observer);
    OSCL_UNUSED_ARG(capacity);
    OSCL_UNUSED_ARG(aContextData);
    OSCL_LEAVE(OsclErrNotSupported);
    return 0;
}

OSCL_EXPORT_REF PvmiDataStreamCommandId
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CancelNotification(PvmiDataStreamSession sessionID,
        PvmiDataStreamObserver& observer,
        PvmiDataStreamCommandId aID,
        OsclAny* aContextData)
{
    OSCL_UNUSED_ARG(sessionID);
    OSCL_UNUSED_ARG(observer);
    OSCL_UNUSED_ARG(aID);
    OSCL_UNUSED_ARG(aContextData);
    OSCL_LEAVE(OsclErrNotSupported);
    return 0;
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Read(PvmiDataStreamSession sessionID,
        uint8* buffer,
        uint32 size,
        uint32& numelements)
{
    OSCL_UNUSED_ARG(sessionID);
    if (!iFileObject)
        return PVDS_FAILURE;

    uint32 result = iFileObject->Read(buffer, size, numelements);
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::ReadAndUnlockContent returning %d", result));

    numelements = result;
    return PVDS_SUCCESS;
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Write(PvmiDataStreamSession sessionID,
        uint8* buffer,
        uint32 size,
        uint32& numelements)
{
    OSCL_UNUSED_ARG(sessionID);
    OSCL_UNUSED_ARG(buffer);
    OSCL_UNUSED_ARG(size);
    OSCL_UNUSED_ARG(numelements);
    return PVDS_NOT_SUPPORTED;
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Seek(PvmiDataStreamSession sessionID,
        int32 offset,
        PvmiDataStreamSeekType origin)
{
    OSCL_UNUSED_ARG(sessionID);
    if (!iFileObject)
        return PVDS_FAILURE;
    Oscl_File::seek_type seekType;
    switch (origin)
    {
        case PVDS_SEEK_SET:
            seekType = Oscl_File::SEEKSET;
            break;
        case PVDS_SEEK_CUR:
            seekType = Oscl_File::SEEKCUR;
            break;
        case PVDS_SEEK_END:
            seekType = Oscl_File::SEEKEND;
            break;
        default:
            return PVDS_FAILURE;
    }
    int32 result = iFileObject->Seek(offset, seekType);
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::SeekContent returning %d", result));
    if (result != 0)
    {
        return PVDS_FAILURE;
    }
    return PVDS_SUCCESS;
}

OSCL_EXPORT_REF uint32
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::GetCurrentPointerPosition(PvmiDataStreamSession sessionID)
{
    OSCL_UNUSED_ARG(sessionID);
    if (!iFileObject)
        return PVDS_FAILURE;
    int32 result = iFileObject->Tell();
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::GetCurrentContentPosition returning %d", result));
    return (uint32)(result);
}

OSCL_EXPORT_REF PvmiDataStreamStatus
PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Flush(PvmiDataStreamSession sessionID)
{
    OSCL_UNUSED_ARG(sessionID);
    if (!iFileObject)
    {
        PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Flush returning %d", -1));
        return PVDS_FAILURE;
    }
    int32 result = iFileObject->Flush();
    PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Flush returning %d", result));
    return PVDS_SUCCESS;
}