Home | History | Annotate | Download | only in src 
      1 /* ------------------------------------------------------------------
      2  * Copyright (C) 1998-2009 PacketVideo
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     13  * express or implied.
     14  * See the License for the specific language governing permissions
     15  * and limitations under the License.
     16  * -------------------------------------------------------------------
     17  */
     18 #ifndef OSCL_EXCLUSIVE_PTR_H_INCLUDED
     19 #include "oscl_exclusive_ptr.h"
     20 #endif
     21 #ifndef PVMF_CPMPLUGIN_PASSTHRU_OMA1_H_INCLUDED
     22 #include "pvmf_cpmplugin_passthru_oma1.h"
     23 #endif
     24 #ifndef PVLOGGER_H_INCLUDED
     25 #include "pvlogger.h"
     26 #endif
     27 #ifndef PVMF_BASIC_ERRORINFOMESSAGE_H_INCLUDED
     28 #include "pvmf_basic_errorinfomessage.h"
     29 #endif
     30 #ifndef PVMF_ERRORINFOMESSAGE_EXTENSION_H_INCLUDED
     31 #include "pvmf_errorinfomessage_extension.h"
     32 #endif
     33 #ifndef OSCL_DLL_H_INCLUDED
     34 #include "oscl_dll.h"
     35 #endif
     36 #include "pvmf_local_data_source.h"
     37 #include "pvmf_cpmplugin_passthru_oma1_factory.h"
     38 #include "pvmf_cpmplugin_passthru_oma1_types.h"
     39 
     40 #ifndef PVMI_DRM_KVP_H_INCLUDED
     41 #include "pvmi_drm_kvp.h"
     42 #endif
     43 
     44 // Define entry point for this DLL
     45 OSCL_DLL_ENTRY_POINT_DEFAULT()
     46 
     47 OSCL_EXPORT_REF PVMFOma1PassthruPluginFactory::PVMFOma1PassthruPluginFactory()
     48 {
     49     iFailAuthorizeUsage = false; // To simulate "authorizeusage" failure
     50     iCancelAcquireLicense = false; //to simulate "cancelgetLicense"
     51     iCPMContentType = PVMF_CPM_FORMAT_AUTHORIZE_BEFORE_ACCESS; //default value
     52     iSourceInitDataNotSupported = false; //To simulate SourceInitializationData failure
     53 }
     54 
     55 //This constructor has only been introduced for test case scenarios simulation
     56 OSCL_EXPORT_REF PVMFOma1PassthruPluginFactory::PVMFOma1PassthruPluginFactory(bool aAuthorizeUsage, bool aCancelAcquireLicense,
     57         bool aSourceInitDataNotSupported,
     58         PVMFCPMContentType aCPMContentType)
     59 {
     60     iFailAuthorizeUsage = aAuthorizeUsage;// To simulate "authorizeusage" failure
     61     iCancelAcquireLicense = aCancelAcquireLicense; //To simulate "cancelAcquire"
     62     iCPMContentType = aCPMContentType; //what test case sets
     63     iSourceInitDataNotSupported = aSourceInitDataNotSupported;
     64 }
     65 
     66 //Oma1 Passthru plugin factory.
     67 OSCL_EXPORT_REF PVMFCPMPluginInterface* PVMFOma1PassthruPluginFactory::CreateCPMPlugin()
     68 {
     69     return PVMFCPMPassThruPlugInOMA1::CreatePlugIn(iFailAuthorizeUsage, iCancelAcquireLicense,
     70             iSourceInitDataNotSupported, iCPMContentType);
     71 }
     72 
     73 OSCL_EXPORT_REF void PVMFOma1PassthruPluginFactory::DestroyCPMPlugin(PVMFCPMPluginInterface* aPlugIn)
     74 {
     75     PVMFCPMPassThruPlugInOMA1::DestroyPlugIn(aPlugIn);
     76 }
     77 
     78 PVMFCPMPluginInterface* PVMFCPMPassThruPlugInOMA1::CreatePlugIn(bool aFailAuthorizeUsage, bool aCancelAcquireLicense, bool aSourceInitDataNotSupported, PVMFCPMContentType aCPMContentType)
     79 {
     80     PVMFCPMPassThruPlugInOMA1* plugIn = NULL;
     81     int32 err;
     82     OSCL_TRY(err,
     83              /*
     84               * Create pass thru OMA1.0 Plugin
     85               */
     86              plugIn = OSCL_NEW(PVMFCPMPassThruPlugInOMA1, (aFailAuthorizeUsage, aCancelAcquireLicense, aSourceInitDataNotSupported, aCPMContentType));
     87             );
     88     if (err != OsclErrNone)
     89     {
     90         OSCL_LEAVE(err);
     91     }
     92 
     93     return (OSCL_STATIC_CAST(PVMFCPMPluginInterface*, plugIn));
     94 }
     95 
     96 void PVMFCPMPassThruPlugInOMA1::DestroyPlugIn(PVMFCPMPluginInterface* aPlugIn)
     97 {
     98     OSCL_DELETE(aPlugIn);
     99 }
    100 
    101 /**
    102  * Plugin Constructor & Destructor
    103  */
    104 OSCL_EXPORT_REF PVMFCPMPassThruPlugInOMA1::PVMFCPMPassThruPlugInOMA1(bool aFailAuthorizeUsage, bool aCancelAcquireLicense,
    105         bool aSourceInitDataNotSupported, PVMFCPMContentType aCPMContentType,
    106         int32 aPriority)
    107         : OsclActiveObject(aPriority, "PVMFCPMPassThruPlugInOMA1"),
    108         iExtensionRefCount(0)
    109 {
    110     iLogger = NULL;
    111     oSourceSet = false;
    112     iFileHandle = NULL;
    113     iDataStreamReadCapacityObserver = NULL;
    114     // To simulate "authorizeusage" failure
    115     iFailAuthorizeUsage = aFailAuthorizeUsage;
    116     //to simualte cancelGetLic
    117     iCancelAcquireLicense = aCancelAcquireLicense;
    118     //to simulate "notsupported" content
    119     iSourceInitDataNotSupported = aSourceInitDataNotSupported;
    120 
    121     iCPMContentType = aCPMContentType;
    122     int32 err;
    123     OSCL_TRY(err,
    124              /*
    125               * Create the input command queue.  Use a reserve to avoid lots of
    126               * dynamic memory allocation
    127               */
    128              iInputCommands.Construct(PVMF_CPM_PASSTHRU_PLUGIN_OMA1_COMMAND_ID_START,
    129                                       PVMF_CPM_PASSTHRU_PLUGIN_OMA1_INTERNAL_CMDQ_SIZE);
    130 
    131              /*
    132               * Create the "current command" queue.  It will only contain one
    133               * command at a time, so use a reserve of 1
    134               */
    135              iCurrentCommand.Construct(0, 1);
    136 
    137             );
    138     if (err != OsclErrNone)
    139     {
    140         OSCL_LEAVE(err);
    141     }
    142     //set the fixed metadata query and value strings.
    143     iMetaData[EIsProtectedOMA1].iQuery = PVMF_DRM_INFO_IS_PROTECTED_QUERY;
    144     iMetaData[EIsProtectedOMA1].iValue = PVMF_DRM_INFO_IS_PROTECTED_VALUE;
    145 
    146     iMetaData[ELicAvailableOMA1].iQuery = PVMF_DRM_INFO_IS_LICENSE_AVAILABLE_QUERY;
    147     iMetaData[ELicAvailableOMA1].iValue = PVMF_DRM_INFO_IS_LICENSE_AVAILABLE_VALUE;
    148 
    149     iMetaData[ELicTypeOMA1].iQuery = PVMF_DRM_INFO_LICENSE_TYPE_QUERY;
    150     iMetaData[ELicTypeOMA1].iValue = PVMF_DRM_INFO_LICENSE_TYPE_VALUE;
    151 
    152     iMetaData[EForwardLockOMA1].iQuery = PVMF_DRM_INFO_IS_FORWARD_LOCKED_QUERY;
    153     iMetaData[EForwardLockOMA1].iValue = PVMF_DRM_INFO_IS_FORWARD_LOCKED_VALUE;
    154 
    155     for (uint32 i = 0; i < ELicLastOMA1; i++)
    156     {
    157         iMetaData[i].iKvp.key = iMetaData[i].iValue.get_str();
    158         iMetaData[i].iKvp.length = 0;
    159         iMetaData[i].iKvp.capacity = 0;
    160     }
    161 
    162 }
    163 
    164 PVMFCPMPassThruPlugInOMA1::~PVMFCPMPassThruPlugInOMA1()
    165 {
    166     oSourceSet = false;
    167     /*
    168      * Cleanup commands
    169      * The command queues are self-deleting, but we want to
    170      * notify the observer of unprocessed commands.
    171      */
    172     while (!iCurrentCommand.empty())
    173     {
    174         CommandComplete(iCurrentCommand, iCurrentCommand.front(), PVMFFailure);
    175     }
    176     while (!iInputCommands.empty())
    177     {
    178         CommandComplete(iInputCommands, iInputCommands.front(), PVMFFailure);
    179     }
    180 }
    181 
    182 void PVMFCPMPassThruPlugInOMA1::ThreadLogon()
    183 {
    184     if (!iLoggedOn)
    185     {
    186         iLogger = PVLogger::GetLoggerObject("PVMFCPMPassThruPlugInOMA1");
    187         AddToScheduler();
    188         iLoggedOn = true;
    189     }
    190 }
    191 
    192 void PVMFCPMPassThruPlugInOMA1::ThreadLogoff()
    193 {
    194     if (iLoggedOn)
    195     {
    196         iLogger = NULL;
    197         Cancel();
    198         RemoveFromScheduler();
    199         iLoggedOn = false;
    200     }
    201 }
    202 
    203 OSCL_EXPORT_REF PVMFCommandId
    204 PVMFCPMPassThruPlugInOMA1::QueryUUID(PVMFSessionId s,
    205                                      const PvmfMimeString& aMimeType,
    206                                      Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
    207                                      bool aExactUuidsOnly,
    208                                      const OsclAny* aContext)
    209 {
    210     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:QueryUUID"));
    211     PVMFCPMPassThruPlugInOMA1Command cmd;
    212     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
    213             PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYUUID,
    214             aMimeType,
    215             aUuids,
    216             aExactUuidsOnly,
    217             aContext);
    218     return QueueCommandL(cmd);
    219 }
    220 
    221 OSCL_EXPORT_REF PVMFCommandId
    222 PVMFCPMPassThruPlugInOMA1::QueryInterface(PVMFSessionId s,
    223         const PVUuid& aUuid,
    224         PVInterface*& aInterfacePtr,
    225         const OsclAny* aContext)
    226 {
    227     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:QueryInterface"));
    228     PVMFCPMPassThruPlugInOMA1Command cmd;
    229     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
    230             PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYINTERFACE,
    231             aUuid,
    232             aInterfacePtr,
    233             aContext);
    234     return QueueCommandL(cmd);
    235 }
    236 
    237 OSCL_EXPORT_REF PVMFCommandId
    238 PVMFCPMPassThruPlugInOMA1::Init(PVMFSessionId s, const OsclAny* aContext)
    239 {
    240     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:Init"));
    241     PVMFCPMPassThruPlugInOMA1Command cmd;
    242     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
    243             PVMF_CPM_PASSTHRU_PLUGIN_OMA1_INIT,
    244             aContext);
    245     return QueueCommandL(cmd);
    246 }
    247 
    248 OSCL_EXPORT_REF PVMFCommandId
    249 PVMFCPMPassThruPlugInOMA1::Reset(PVMFSessionId s, const OsclAny* aContext)
    250 {
    251     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:Reset"));
    252     PVMFCPMPassThruPlugInOMA1Command cmd;
    253     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
    254             PVMF_CPM_PASSTHRU_PLUGIN_OMA1_RESET,
    255             aContext);
    256     return QueueCommandL(cmd);
    257 }
    258 
    259 OSCL_EXPORT_REF PVMFCommandId
    260 PVMFCPMPassThruPlugInOMA1::AuthenticateUser(PVMFSessionId aSessionId,
    261         OsclAny* aAuthenticationData,
    262         OsclAny* aContext)
    263 {
    264     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:AuthenticateUser"));
    265     PVMFCPMPassThruPlugInOMA1Command cmd;
    266     cmd.Construct(aSessionId,
    267                   PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHENTICATE,
    268                   aAuthenticationData,
    269                   NULL,
    270                   aContext);
    271     return QueueCommandL(cmd);
    272 }
    273 
    274 OSCL_EXPORT_REF PVMFCommandId
    275 PVMFCPMPassThruPlugInOMA1::AuthorizeUsage(PVMFSessionId aSessionId,
    276         PvmiKvp& aRequestedUsage,
    277         PvmiKvp& aApprovedUsage,
    278         PvmiKvp& aAuthorizationData,
    279         uint32&  aRequestTimeOutInMS,
    280         OsclAny* aContext)
    281 {
    282     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:AuthorizeUsage"));
    283     PVMFCPMPassThruPlugInOMA1Command cmd;
    284     cmd.Construct(aSessionId,
    285                   PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHORIZE_USAGE,
    286                   &aRequestedUsage,
    287                   &aApprovedUsage,
    288                   &aAuthorizationData,
    289                   &aRequestTimeOutInMS,
    290                   aContext);
    291     return QueueCommandL(cmd);
    292 }
    293 
    294 OSCL_EXPORT_REF PVMFCommandId
    295 PVMFCPMPassThruPlugInOMA1::UsageComplete(PVMFSessionId s, const OsclAny* aContext)
    296 {
    297     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:UsageComplete"));
    298     PVMFCPMPassThruPlugInOMA1Command cmd;
    299     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(s,
    300             PVMF_CPM_PASSTHRU_PLUGIN_OMA1_USAGE_COMPLETE,
    301             aContext);
    302     return QueueCommandL(cmd);
    303 }
    304 
    305 PVMFStatus
    306 PVMFCPMPassThruPlugInOMA1::SetSourceInitializationData(OSCL_wString& aSourceURL,
    307         PVMFFormatType& aSourceFormat,
    308         OsclAny* aSourceData)
    309 {
    310     OSCL_UNUSED_ARG(aSourceData);
    311 
    312     //In a real OMA1 plugin, we would be able to verify whether the source is really OMA1
    313     //content or not.  This passthru plugin is not smart enough to do that, so it
    314     //generally accepts all formats.  However, it rejects ASF content to avoid conflicts
    315     //with the PV Janus plugin.
    316     if (aSourceFormat == PVMF_MIME_ASFFF || PVMF_MIME_DATA_SOURCE_MS_HTTP_STREAMING_URL)
    317     {
    318         return PVMFErrNotSupported;
    319     }
    320     else
    321     {
    322         iFilename = aSourceURL;
    323         iSourceFormatType = aSourceFormat;
    324         /*
    325         if(aSourceData)
    326         {
    327             iFileHandle=((PVMFLocalDataSource*)aSourceData)->iFileHandle;
    328         }
    329         else
    330         {
    331             iFileHandle=NULL;
    332         }
    333         */
    334         if (iSourceInitDataNotSupported)
    335         {
    336             iSourceInitDataNotSupported = false; //reset for next time
    337             return PVMFErrNotSupported;
    338         }
    339         oSourceSet = true;
    340         return PVMFSuccess;
    341     }
    342 }
    343 
    344 PVMFCPMContentType
    345 PVMFCPMPassThruPlugInOMA1::GetCPMContentType()
    346 {
    347     return iCPMContentType;
    348 }
    349 
    350 PVMFStatus PVMFCPMPassThruPlugInOMA1::QueryAccessInterfaceUUIDs(Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids)
    351 {
    352     aUuids.push_back(PVMIDataStreamSyncInterfaceUuid);
    353     return PVMFSuccess;
    354 }
    355 
    356 PVInterface*
    357 PVMFCPMPassThruPlugInOMA1::CreatePVMFCPMPluginAccessInterface(PVUuid& aUuid)
    358 {
    359     if (aUuid == PVMIDataStreamSyncInterfaceUuid)
    360     {
    361         PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl* iface = NULL;
    362         iface = OSCL_NEW(PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl, (*this));
    363 
    364         PVMIDataStreamSyncInterface* interimPtr1
    365         = OSCL_STATIC_CAST(PVMIDataStreamSyncInterface*, iface);
    366 
    367         return (OSCL_STATIC_CAST(PVInterface*, interimPtr1));
    368     }
    369 
    370     return NULL;
    371 }
    372 
    373 void
    374 PVMFCPMPassThruPlugInOMA1::DestroyPVMFCPMPluginAccessInterface(PVUuid& aUuid,
    375         PVInterface* aPtr)
    376 {
    377     if (aUuid == PVMIDataStreamSyncInterfaceUuid)
    378     {
    379         PVMIDataStreamSyncInterface* interimPtr =
    380             (PVMIDataStreamSyncInterface*)aPtr;
    381         PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl* datastream =
    382             (PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl*)interimPtr;
    383         OSCL_DELETE(datastream);
    384     }
    385     else
    386     {
    387         OSCL_ASSERT(false);
    388     }
    389 }
    390 
    391 void
    392 PVMFCPMPassThruPlugInOMA1::SetStreamReadCapacityObserver(PVMFDataStreamReadCapacityObserver* aObs)
    393 {
    394     iDataStreamReadCapacityObserver = aObs;
    395 }
    396 
    397 
    398 /**
    399  * This routine is called by various command APIs to queue an
    400  * asynchronous command for processing by the command handler AO.
    401  * This function may leave if the command can't be queued due to
    402  * memory allocation failure.
    403  */
    404 PVMFCommandId PVMFCPMPassThruPlugInOMA1::QueueCommandL(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    405 {
    406     PVMFCommandId id;
    407     id = iInputCommands.AddL(aCmd);
    408     /* wakeup the AO */
    409     RunIfNotReady();
    410     return id;
    411 }
    412 
    413 /**
    414  * The various command handlers call this when a command is complete.
    415  */
    416 void PVMFCPMPassThruPlugInOMA1::CommandComplete(PVMFCPMPassThruPlugInOMA1CmdQ& aCmdQ,
    417         PVMFCPMPassThruPlugInOMA1Command& aCmd,
    418         PVMFStatus aStatus,
    419         OsclAny* aEventData,
    420         PVUuid* aEventUUID,
    421         int32* aEventCode)
    422 {
    423     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:CommandComplete Id %d Cmd %d Status %d Context %d Data %d"
    424                                          , aCmd.iId, aCmd.iCmd, aStatus, aCmd.iContext, aEventData));
    425 
    426     PVInterface* extif = NULL;
    427     PVMFBasicErrorInfoMessage* errormsg = NULL;
    428     if (aEventUUID && aEventCode)
    429     {
    430         errormsg = OSCL_NEW(PVMFBasicErrorInfoMessage, (*aEventCode, *aEventUUID, NULL));
    431         extif = OSCL_STATIC_CAST(PVInterface*, errormsg);
    432     }
    433 
    434     /* create response */
    435     PVMFCmdResp resp(aCmd.iId, aCmd.iContext, aStatus, extif, aEventData);
    436     PVMFSessionId session = aCmd.iSession;
    437 
    438     /* Erase the command from the queue */
    439     aCmdQ.Erase(&aCmd);
    440 
    441     /* Report completion to the session observer */
    442     ReportCmdCompleteEvent(session, resp);
    443 
    444     if (errormsg)
    445     {
    446         errormsg->removeRef();
    447     }
    448     //Reschedule if there are more commands.
    449     if (!iInputCommands.empty()
    450             && IsAdded())
    451     {
    452         RunIfNotReady();
    453     }
    454 }
    455 
    456 void
    457 PVMFCPMPassThruPlugInOMA1::MoveCmdToCurrentQueue(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    458 {
    459     int32 err;
    460     OSCL_TRY(err, iCurrentCommand.StoreL(aCmd););
    461     if (err != OsclErrNone)
    462     {
    463         PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGERROR((0, "PVMFCPMPassThruPlugInOMA1:MoveCmdToCurrentQueue - No Memory"));
    464         CommandComplete(iInputCommands, aCmd, PVMFErrNoMemory);
    465         return;
    466     }
    467     iInputCommands.Erase(&aCmd);
    468     return;
    469 }
    470 
    471 /**
    472  * Called by the command handler AO to process a command from
    473  * the input queue.
    474  * Return true if a command was processed, false if the command
    475  * processor is busy and can't process another command now.
    476  */
    477 bool PVMFCPMPassThruPlugInOMA1::ProcessCommand(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    478 {
    479     /*
    480      * normally this node will not start processing one command
    481      * until the prior one is finished.  However, a hi priority
    482      * command such as Cancel must be able to interrupt a command
    483      * in progress.
    484      */
    485     if (!iCurrentCommand.empty() && !aCmd.hipri() && aCmd.iCmd != PVMF_CPM_PASSTHRU_PLUGIN_OMA1_CANCEL_GET_LICENSE)
    486         return false;
    487 
    488     switch (aCmd.iCmd)
    489     {
    490         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYUUID:
    491             DoQueryUuid(aCmd);
    492             break;
    493 
    494         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_QUERYINTERFACE:
    495             DoQueryInterface(aCmd);
    496             break;
    497 
    498         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_INIT:
    499             DoInit(aCmd);
    500             break;
    501 
    502         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_RESET:
    503             DoReset(aCmd);
    504             break;
    505 
    506         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHENTICATE:
    507             DoAuthenticate(aCmd);
    508             break;
    509 
    510         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_AUTHORIZE_USAGE:
    511             DoAuthorizeUsage(aCmd);
    512             break;
    513 
    514         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_USAGE_COMPLETE:
    515             DoUsageComplete(aCmd);
    516             break;
    517 
    518         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_GET_LICENSE:
    519         {
    520             PVMFStatus aCmdStatus = DoGetLicense(aCmd);
    521             switch (aCmdStatus)
    522             {
    523                 case PVMFPending:
    524                     MoveCmdToCurrentQueue(aCmd);
    525                     break;
    526             }
    527         }
    528         break;
    529 
    530         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_CANCEL_GET_LICENSE:
    531             DoCancelGetLicense(aCmd);
    532             break;
    533 
    534 
    535         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_KEYS:
    536             DoMetadataKeys(aCmd);
    537             break;
    538 
    539         case PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_VALUES:
    540             DoMetadataValues(aCmd);
    541             break;
    542 
    543         default:
    544         {
    545             /* unknown command type */
    546             PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGWARNING((0, "PVMFCPMPassThruPlugInOMA1:ProcessCommand - Unknown Command"));
    547             CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
    548         }
    549         break;
    550     }
    551 
    552     return true;
    553 }
    554 
    555 /**
    556  * Called by the command handler AO to do the Query UUID
    557  */
    558 void PVMFCPMPassThruPlugInOMA1::DoQueryUuid(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    559 {
    560     OSCL_String* mimetype;
    561     Oscl_Vector<PVUuid, OsclMemAllocator> *uuidvec;
    562     bool exactmatch;
    563     aCmd.PVMFCPMPassThruPlugInOMA1CommandBase::Parse(mimetype, uuidvec, exactmatch);
    564 
    565     if (exactmatch == false)
    566     {
    567         CommandComplete(iInputCommands, aCmd, PVMFErrArgument);
    568     }
    569     /*
    570      * Try to match the input mimetype against any of
    571      * the interfaces supported by this plugin
    572      */
    573     if (*mimetype == PVMF_CPMPLUGIN_AUTHENTICATION_INTERFACE_MIMETYPE)
    574     {
    575         PVUuid uuid(PVMFCPMPluginAuthenticationInterfaceUuid);
    576         uuidvec->push_back(uuid);
    577     }
    578     else if (*mimetype == PVMF_CPMPLUGIN_AUTHORIZATION_INTERFACE_MIMETYPE)
    579     {
    580         PVUuid uuid(PVMFCPMPluginAuthorizationInterfaceUuid);
    581         uuidvec->push_back(uuid);
    582     }
    583     else if (*mimetype == PVMF_CPMPLUGIN_ACCESS_INTERFACE_FACTORY_MIMETYPE)
    584     {
    585         PVUuid uuid(PVMFCPMPluginAccessInterfaceFactoryUuid);
    586         uuidvec->push_back(uuid);
    587     }
    588     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    589 }
    590 
    591 /**
    592  * Called by the command handler AO to do the Query Interface.
    593  */
    594 void PVMFCPMPassThruPlugInOMA1::DoQueryInterface(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    595 {
    596     PVUuid* uuid;
    597     PVInterface** ptr;
    598     aCmd.PVMFCPMPassThruPlugInOMA1CommandBase::Parse(uuid, ptr);
    599 
    600     if ((*uuid == PVMFCPMPluginAuthorizationInterfaceUuid) ||
    601             (*uuid == PVMFCPMPluginAccessInterfaceFactoryUuid))
    602     {
    603         if (oSourceSet == false)
    604         {
    605             CommandComplete(iInputCommands, aCmd, PVMFErrInvalidState);
    606             return;
    607         }
    608     }
    609 
    610     if (queryInterface(*uuid, *ptr))
    611     {
    612         CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    613     }
    614     else
    615     {
    616         /* not supported */
    617         *ptr = NULL;
    618         CommandComplete(iInputCommands, aCmd, PVMFErrNotSupported);
    619     }
    620 }
    621 
    622 bool PVMFCPMPassThruPlugInOMA1::queryInterface(const PVUuid& uuid, PVInterface*& iface)
    623 {
    624     if (uuid == PVMFCPMPluginAuthenticationInterfaceUuid)
    625     {
    626         PVMFCPMPluginAuthenticationInterface* myInterface =
    627             OSCL_STATIC_CAST(PVMFCPMPluginAuthenticationInterface*, this);
    628         iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    629     }
    630     else if (uuid == PVMFCPMPluginAuthorizationInterfaceUuid)
    631     {
    632         PVMFCPMPluginAuthorizationInterface* myInterface =
    633             OSCL_STATIC_CAST(PVMFCPMPluginAuthorizationInterface*, this);
    634         iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    635     }
    636     else if (uuid == PVMFCPMPluginAccessInterfaceFactoryUuid)
    637     {
    638         PVMFCPMPluginAccessInterfaceFactory* myInterface =
    639             OSCL_STATIC_CAST(PVMFCPMPluginAccessInterfaceFactory*, this);
    640         iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    641     }
    642     else if (uuid == PVMFCPMPluginLicenseInterfaceUuid)
    643     {
    644         PVMFCPMPluginLicenseInterface* myInterface =
    645             OSCL_STATIC_CAST(PVMFCPMPluginLicenseInterface*, this);
    646         iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    647     }
    648     else if (uuid == KPVMFMetadataExtensionUuid)
    649     {
    650         PVMFMetadataExtensionInterface* myInterface
    651         = OSCL_STATIC_CAST(PVMFMetadataExtensionInterface*, this);
    652         iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
    653     }
    654     else
    655     {
    656         return false;
    657     }
    658     addRef();
    659     return true;
    660 }
    661 
    662 void PVMFCPMPassThruPlugInOMA1::DoInit(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    663 {
    664     /* Nothing to do */
    665     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    666 }
    667 
    668 void PVMFCPMPassThruPlugInOMA1::DoReset(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    669 {
    670     oSourceSet = false;
    671     /* Nothing to do */
    672     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    673 }
    674 
    675 void PVMFCPMPassThruPlugInOMA1::DoAuthenticate(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    676 {
    677     OsclAny* authenticationData;
    678     OsclAny* dummy;
    679     aCmd.Parse(authenticationData, dummy);
    680 
    681     /* Return success always, till siemens api become available */
    682     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    683 }
    684 
    685 void PVMFCPMPassThruPlugInOMA1::DoAuthorizeUsage(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    686 {
    687     if (iFailAuthorizeUsage)
    688     {
    689         iFailAuthorizeUsage = false; //reset for next try
    690         CommandComplete(iInputCommands, aCmd, PVMFErrLicenseRequired);
    691         return;
    692     }
    693     MakeMetadata();
    694 
    695     OsclAny* temp1 = NULL;
    696     OsclAny* temp2 = NULL;
    697     OsclAny* temp3 = NULL;
    698     OsclAny* temp4 = NULL;
    699 
    700     aCmd.Parse(temp1, temp2, temp3, temp4);
    701 
    702     PvmiKvp* requestedUsage = OSCL_STATIC_CAST(PvmiKvp*, temp1);
    703     PvmiKvp* approvedUsage = OSCL_STATIC_CAST(PvmiKvp*, temp2);
    704     PvmiKvp* authorizationData = OSCL_STATIC_CAST(PvmiKvp*, temp3);
    705     uint32*  requestTimeOutInMS = OSCL_STATIC_CAST(uint32*, temp4);
    706 
    707     /* No check needed - approve everything */
    708     approvedUsage->value.uint32_value = requestedUsage->value.uint32_value;
    709     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    710     OSCL_UNUSED_ARG(authorizationData);
    711     OSCL_UNUSED_ARG(requestTimeOutInMS);
    712 }
    713 
    714 void PVMFCPMPassThruPlugInOMA1::DoUsageComplete(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    715 {
    716     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    717 }
    718 
    719 PVMFStatus PVMFCPMPassThruPlugInOMA1::DoGetLicense(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    720 {
    721     if (!iCancelAcquireLicense)
    722     {
    723         CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    724         return PVMFSuccess;
    725     }
    726     else
    727     {
    728         iCancelAcquireLicense = false; //Reset for next time
    729         return PVMFPending;
    730     }
    731 }
    732 
    733 void PVMFCPMPassThruPlugInOMA1::DoCancelGetLicense(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    734 {
    735     //Complete all pending commands, basically "GetLicense"
    736     while (iCurrentCommand.size() > 0)
    737     {
    738         CommandComplete(iCurrentCommand, iCurrentCommand.front(), PVMFErrCancelled);
    739     }
    740     //complete the CancelGetLicense
    741     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    742 }
    743 
    744 void PVMFCPMPassThruPlugInOMA1::DoMetadataKeys(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    745 {
    746     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    747 }
    748 
    749 void PVMFCPMPassThruPlugInOMA1::DoMetadataValues(PVMFCPMPassThruPlugInOMA1Command& aCmd)
    750 {
    751     CommandComplete(iInputCommands, aCmd, PVMFSuccess);
    752 }
    753 
    754 /**
    755   * This AO handles API commands. The AO will process one command
    756   * per call. It will re-schedule itself and run continuously
    757   * until it runs out of things to do.
    758   */
    759 void PVMFCPMPassThruPlugInOMA1::Run()
    760 {
    761     /*
    762      * Process commands.
    763      */
    764     if (!iInputCommands.empty())
    765     {
    766         ProcessCommand(iInputCommands.front());
    767     }
    768 }
    769 
    770 OSCL_EXPORT_REF PVMFStatus
    771 PVMFCPMPassThruPlugInOMA1::GetLicenseURL(PVMFSessionId aSessionId,
    772         OSCL_wString& aContentName,
    773         OSCL_wString& aLicenseURL)
    774 {
    775     OSCL_UNUSED_ARG(aSessionId);
    776     OSCL_UNUSED_ARG(aContentName);
    777     OSCL_UNUSED_ARG(aLicenseURL);
    778     return PVMFErrNotSupported;
    779 }
    780 
    781 OSCL_EXPORT_REF PVMFStatus
    782 PVMFCPMPassThruPlugInOMA1::GetLicenseURL(PVMFSessionId aSessionId,
    783         OSCL_String&  aContentName,
    784         OSCL_String&  aLicenseURL)
    785 {
    786     OSCL_UNUSED_ARG(aSessionId);
    787     OSCL_UNUSED_ARG(aContentName);
    788     OSCL_UNUSED_ARG(aLicenseURL);
    789     return PVMFErrNotSupported;
    790 }
    791 
    792 OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetLicense(PVMFSessionId aSessionId
    793         , OSCL_wString& aContentName
    794         , OsclAny* aLicenseData
    795         , uint32 aDataSize
    796         , int32 aTimeoutMsec
    797         , OsclAny* aContext)
    798 {
    799     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:GetLicense"));
    800     PVMFCPMPassThruPlugInOMA1Command cmd;
    801     cmd.Construct(aSessionId,
    802                   PVMF_CPM_PASSTHRU_PLUGIN_OMA1_GET_LICENSE,
    803                   &aContentName,
    804                   aLicenseData,
    805                   &aDataSize,
    806                   &aTimeoutMsec,
    807                   aContext);
    808     return QueueCommandL(cmd);
    809 }
    810 
    811 OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetLicense(PVMFSessionId aSessionId
    812         , OSCL_String&  aContentName
    813         , OsclAny* aLicenseData
    814         , uint32 aDataSize
    815         , int32 aTimeoutMsec
    816         , OsclAny* aContext)
    817 {
    818     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1:GetLicense"));
    819     PVMFCPMPassThruPlugInOMA1Command cmd;
    820     cmd.Construct(aSessionId,
    821                   PVMF_CPM_PASSTHRU_PLUGIN_OMA1_GET_LICENSE,
    822                   &aContentName,
    823                   aLicenseData,
    824                   &aDataSize,
    825                   &aTimeoutMsec,
    826                   aContext);
    827     return QueueCommandL(cmd);
    828 }
    829 
    830 OSCL_EXPORT_REF PVMFCommandId
    831 PVMFCPMPassThruPlugInOMA1::CancelGetLicense(PVMFSessionId aSessionId, PVMFCommandId aCmdId, OsclAny* aContext)
    832 {
    833     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGINFO((0, "PVMFCPMPassThruPlugInOMA1::CancelGetLicense - called"));
    834     PVMFCPMPassThruPlugInOMA1Command cmd;
    835     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(aSessionId, PVMF_CPM_PASSTHRU_PLUGIN_OMA1_CANCEL_GET_LICENSE, aCmdId, aContext);
    836     return QueueCommandL(cmd);
    837 }
    838 
    839 /**
    840  * Synchronous method to return the number of metadata keys for the specified query key string
    841  *
    842  * @param aQueryKeyString A NULL terminated character string specifying a subset of metadata keys to count.
    843  *                        If the string is NULL, total number of all keys will be returned
    844  *
    845  * @returns The number of metadata keys
    846  **/
    847 OSCL_EXPORT_REF uint32 PVMFCPMPassThruPlugInOMA1::GetNumMetadataKeys(char* aQueryKeyString)
    848 {
    849     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    850                     (0, "PVMFCPMPassThruPlugInOMA1::GetNumMetadataKeys() called"));
    851     uint32 total = 0;
    852     for (uint32 i = 0; i < ELicLastOMA1; i++)
    853     {
    854         if (iMetaData[i].iValid)
    855         {
    856             if (!aQueryKeyString
    857                     || iMetaData[i].iQuery == aQueryKeyString)
    858             {
    859                 total++;
    860             }
    861         }
    862     }
    863     return total;
    864 }
    865 
    866 
    867 /**
    868  * Synchronous method to return the number of metadata values for the specified list of key strings
    869  *
    870  * @param aKeyList A reference to a metadata key list to specifying the values of interest to count
    871  *
    872  * @returns The number of metadata values based on the provided key list
    873  **/
    874 OSCL_EXPORT_REF uint32 PVMFCPMPassThruPlugInOMA1::GetNumMetadataValues(PVMFMetadataList& aKeyList)
    875 {
    876     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    877                     (0, "PVMFCPMPassThruPlugInOMA1::GetNumMetadataValues() called"));
    878     uint32 total = 0;
    879     for (uint32 i = 0; i < aKeyList.size(); i++)
    880     {
    881         for (uint32 j = 0; j < ELicLastOMA1; j++)
    882         {
    883             if (iMetaData[j].iValid
    884                     && iMetaData[j].iQuery == aKeyList[i])
    885             {
    886                 total++;
    887                 break;//goto next query.
    888             }
    889         }
    890     }
    891     return total;
    892 }
    893 
    894 /**
    895  * Asynchronous method to retrieve a list of metadata keys. The subset of all available keys in the node can
    896  * be specified by providing a combination of query key string, starting index, and maximum number of keys to retrieve
    897  *
    898  * @param aSessionId The assigned node session ID to use for this request
    899  * @param aKeyList A reference to a metadata key list to add the metadata keys
    900  * @param aStartingKeyIndex Index into the node's total key list that corresponds to the first key entry to retrieve
    901  * @param aMaxKeyEntries The maximum number of key entries to add to aKeyList. If there is no maximum, set to -1.
    902  * @param aQueryKeyString Optional NULL terminated character string to select a subset of keys
    903  * @param aContext Optional opaque data to be passed back to user with the command response
    904  *
    905  * @returns A unique command ID for asynchronous completion
    906  **/
    907 OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetNodeMetadataKeys(PVMFSessionId aSessionId,
    908         PVMFMetadataList& aKeyList,
    909         uint32 aStartingKeyIndex,
    910         int32 aMaxKeyEntries ,
    911         char* aQueryKeyString ,
    912         const OsclAny* aContextData)
    913 {
    914     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    915                     (0, "PVMFCPMPassThruPlugInOMA1::GetNodeMetadataKeys() called"));
    916     int32 total = 0;
    917     for (uint32 i = aStartingKeyIndex; i < ELicLastOMA1; i++)
    918     {
    919         if (iMetaData[i].iValid)
    920         {
    921             if (aMaxKeyEntries >= 0
    922                     && total >= aMaxKeyEntries)
    923                 break;
    924             if (!aQueryKeyString
    925                     || iMetaData[i].iQuery == aQueryKeyString)
    926             {
    927                 aKeyList.push_back(iMetaData[i].iQuery);
    928                 total++;
    929             }
    930         }
    931     }
    932     //MyCmdResp resp(aSessionId,aContextData);
    933     //return QueueCmdResp(resp,PVMFSuccess);
    934     PVMFCPMPassThruPlugInOMA1Command cmd;
    935     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(aSessionId,
    936             PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_KEYS,
    937             aContextData);
    938     return QueueCommandL(cmd);
    939 }
    940 
    941 /**
    942  * Asynchronous method to retrieve a list of metadata values. The subset of all available values in the node can
    943  * be specified by providing a combination of key list, starting index, and maximum number of values to retrieve
    944  *
    945  * @param aSessionId The assigned node session ID to use for this request
    946  * @param aKeyList A reference to a metadata key list specifying the metadata values to retrieve
    947  * @param aValueList A reference to a metadata value list to add the metadata values
    948  * @param aStartingValueIndex Index into the node's value list specified by the key list that corresponds to the first value entry to retrieve
    949  * @param aMaxValueEntries The maximum number of value entries to add to aValueList. If there is no maximum, set to -1.
    950  * @param aContext Optional opaque data to be passed back to user with the command response
    951  *
    952  * @returns A unique command ID for asynchronous completion
    953  **/
    954 OSCL_EXPORT_REF PVMFCommandId PVMFCPMPassThruPlugInOMA1::GetNodeMetadataValues(PVMFSessionId aSessionId,
    955         PVMFMetadataList& aKeyList,
    956         Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList,
    957         uint32 aStartingValueIndex,
    958         int32 aMaxValueEntries ,
    959         const OsclAny* aContextData)
    960 {
    961     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
    962                     (0, "PVMFCPMPassThruPlugInOMA1::GetNodeMetadataValues() called"));
    963     int32 total = 0;
    964     for (uint32 j = 0; j < aKeyList.size(); j++)
    965     {
    966         for (int32 i = aStartingValueIndex; i < ELicLastOMA1; i++)
    967         {
    968             if (iMetaData[i].iValid)
    969             {
    970                 if (aMaxValueEntries >= 0
    971                         && total >= aMaxValueEntries)
    972                     break;
    973                 if (iMetaData[i].iQuery == aKeyList[j])
    974                 {
    975                     aValueList.push_back(iMetaData[i].iKvp);
    976                     total++;
    977                     break;//go to next key.
    978                 }
    979             }
    980         }
    981     }
    982     PVMFCPMPassThruPlugInOMA1Command cmd;
    983     cmd.PVMFCPMPassThruPlugInOMA1CommandBase::Construct(aSessionId,
    984             PVMF_CPM_PASSTHRU_PLUGIN_OMA1_METADATA_VALUES,
    985             aContextData);
    986     return QueueCommandL(cmd);
    987 }
    988 
    989 /**
    990  * Synchronous method to free up the specified range of metadata keys in the list. It is assumed that caller of this function
    991  * knows that start and end indices should correspond to metadata keys returned by this particular instance of the
    992  * metadata extension interface using GetNodeMetadataKeys().
    993  *
    994  * @param aKeyList A reference to a metadata key list to free the key entries
    995  * @param aStartingKeyIndex Index into aKeyList that corresponds to the first key entry to release
    996  * @param aEndKeyIndex Index into aKeyList that corresponds to the last key entry to release
    997  *
    998  * @returns PVMFSuccess if the release of specified keys succeeded. PVMFErrArgument if indices are invalid or the list is empty.
    999  *          PVMFFailure otherwise.
   1000  **/
   1001 OSCL_EXPORT_REF PVMFStatus PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataKeys(PVMFMetadataList& aKeyList,
   1002         uint32 aStartingKeyIndex,
   1003         uint32 aEndKeyIndex)
   1004 {
   1005     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1006                     (0, "PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataKeys() called"));
   1007     //nothing needed.  metadata memory persists through the life of the plugin.
   1008     OSCL_UNUSED_ARG(aKeyList);
   1009     OSCL_UNUSED_ARG(aStartingKeyIndex);
   1010     OSCL_UNUSED_ARG(aEndKeyIndex);
   1011     return PVMFSuccess;
   1012 }
   1013 
   1014 /**
   1015  * Synchronous method to free up the specified range of metadata values in the list. It is assumed that caller of this function
   1016  * knows that start and end indices should correspond to metadata values returned by this particular instance of the
   1017  * metadata extension interface using GetNodeMetadataValues().
   1018  *
   1019  * @param aValueList A reference to a metadata value list to free the value entries
   1020  * @param aStartingValueIndex Index into aValueList that corresponds to the first value entry to release
   1021  * @param aEndValueIndex Index into aValueList that corresponds to the last value entry to release
   1022  *
   1023  * @returns PVMFSuccess if the release of specified values succeeded. PVMFErrArgument if indices are invalid or the list is empty.
   1024  *          PVMFFailure otherwise.
   1025  **/
   1026 OSCL_EXPORT_REF PVMFStatus PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataValues(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList,
   1027         uint32 aStartingValueIndex,
   1028         uint32 aEndValueIndex)
   1029 {
   1030     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1031                     (0, "PVMFCPMPassThruPlugInOMA1::ReleaseNodeMetadataValues() called"));
   1032     OSCL_UNUSED_ARG(aValueList);
   1033     OSCL_UNUSED_ARG(aStartingValueIndex);
   1034     OSCL_UNUSED_ARG(aEndValueIndex);
   1035     return PVMFSuccess;
   1036 }
   1037 
   1038 //Make Metadata from license state data.
   1039 void PVMFCPMPassThruPlugInOMA1::MakeMetadata()
   1040 {
   1041     PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE,
   1042                     (0, "PVMFCPMPassThruPlugInOMA1::MakeMetadata() called"));
   1043 
   1044     //always set "is protected" here.  we rely on the source nodes
   1045     //to only use this plugin for protected content.
   1046     iMetaData[EIsProtectedOMA1].iValid = true;
   1047     iMetaData[EIsProtectedOMA1].iKvp.value.bool_value = true;
   1048 
   1049     iMetaData[ELicAvailableOMA1].iValid = true;
   1050     iMetaData[ELicAvailableOMA1].iKvp.value.bool_value = true;
   1051 
   1052     iLicType = "unlimited";
   1053     iMetaData[ELicTypeOMA1].iValid = true;
   1054     iMetaData[ELicTypeOMA1].iKvp.value.pChar_value = iLicType.get_str();
   1055 
   1056     iMetaData[EForwardLockOMA1].iValid = true;
   1057     iMetaData[EForwardLockOMA1].iKvp.value.bool_value = true;
   1058 }
   1059 
   1060 /**
   1061 ** PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl
   1062 */
   1063 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl(PVMFCPMPassThruPlugInOMA1&c)
   1064         : iContainer(c)
   1065 {
   1066     iFileObject = NULL;
   1067     iLogger = iContainer.iLogger;
   1068     iFs.Connect();
   1069     iDataStreamReadCapacityObserver = iContainer.iDataStreamReadCapacityObserver;
   1070     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl"));
   1071 }
   1072 
   1073 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::~PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl()
   1074 {
   1075     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::~PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl"));
   1076     if (iFileObject)
   1077         OSCL_DELETE(iFileObject);
   1078     iFileObject = NULL;
   1079     iFs.Close();
   1080     iLogger = NULL;
   1081     iDataStreamReadCapacityObserver = NULL;
   1082 }
   1083 
   1084 OSCL_EXPORT_REF bool
   1085 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::queryInterface(const PVUuid& uuid,
   1086         PVInterface*& iface)
   1087 {
   1088     iface = NULL;
   1089     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::queryInterface"));
   1090     if (uuid == PVMIDataStreamSyncInterfaceUuid)
   1091     {
   1092         PVMIDataStreamSyncInterface* myInterface
   1093         = OSCL_STATIC_CAST(PVMIDataStreamSyncInterface*, this);
   1094         iface = OSCL_STATIC_CAST(PVInterface*, myInterface);
   1095         return true;
   1096     }
   1097     return false;
   1098 }
   1099 
   1100 OSCL_EXPORT_REF PvmiDataStreamStatus
   1101 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::OpenSession(PvmiDataStreamSession& aSessionID,
   1102         PvmiDataStreamMode aMode,
   1103         bool nonblocking)
   1104 {
   1105     OSCL_UNUSED_ARG(aSessionID);
   1106     OSCL_UNUSED_ARG(nonblocking);
   1107     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::OpenSession"));
   1108     if (!iFileObject)
   1109         iFileObject = OSCL_NEW(Oscl_File, (0, iContainer.iFileHandle));
   1110 
   1111     int32 result;
   1112     if ((aMode == PVDS_READ_ONLY) || (aMode == PVDS_READ_WRITE))
   1113     {
   1114         result = iFileObject->Open(iContainer.iFilename.get_cstr(), Oscl_File::MODE_READ, iFs);
   1115         PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::OpenSession - File Open returning %d", result));
   1116         return (result == 0) ? PVDS_SUCCESS : PVDS_FAILURE;
   1117     }
   1118     else
   1119     {
   1120         return PVDS_UNSUPPORTED_MODE;
   1121     }
   1122 
   1123     return PVDS_SUCCESS;
   1124 }
   1125 
   1126 OSCL_EXPORT_REF PvmiDataStreamStatus
   1127 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CloseSession(PvmiDataStreamSession sessionID)
   1128 {
   1129     OSCL_UNUSED_ARG(sessionID);
   1130     if (!iFileObject)
   1131     {
   1132         PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CloseSession returning %d", -1));
   1133         return PVDS_FAILURE;
   1134     }
   1135     int32 result = iFileObject->Close();
   1136     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CloseSession returning %d", result));
   1137     OSCL_DELETE(iFileObject);
   1138     iFileObject = NULL;
   1139     if (result == 0)
   1140         return PVDS_SUCCESS;
   1141 
   1142     return PVDS_FAILURE;
   1143 }
   1144 
   1145 OSCL_EXPORT_REF PvmiDataStreamRandomAccessType
   1146 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryRandomAccessCapability()
   1147 {
   1148     return PVDS_FULL_RANDOM_ACCESS;
   1149 }
   1150 
   1151 OSCL_EXPORT_REF PvmiDataStreamStatus
   1152 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryReadCapacity(PvmiDataStreamSession sessionID,
   1153         uint32& capacity)
   1154 {
   1155     OSCL_UNUSED_ARG(sessionID);
   1156     if (iDataStreamReadCapacityObserver != NULL)
   1157     {
   1158         return (iDataStreamReadCapacityObserver->GetStreamReadCapacity(capacity));
   1159     }
   1160     else
   1161     {
   1162         if (!iFileObject)
   1163             return PVDS_FAILURE;
   1164         int32 result = (TOsclFileOffsetInt32)iFileObject->Size();
   1165         PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryReadCapacity returning %d", result));
   1166         if (result < 0)
   1167         {
   1168             return PVDS_FAILURE;
   1169         }
   1170         else
   1171         {
   1172             capacity = result;
   1173             return PVDS_SUCCESS;
   1174         }
   1175     }
   1176 }
   1177 
   1178 OSCL_EXPORT_REF PvmiDataStreamCommandId
   1179 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::RequestReadCapacityNotification(PvmiDataStreamSession sessionID,
   1180         PvmiDataStreamObserver& observer,
   1181         uint32 capacity,
   1182         OsclAny* aContextData)
   1183 {
   1184     OSCL_UNUSED_ARG(sessionID);
   1185     OSCL_UNUSED_ARG(observer);
   1186     OSCL_UNUSED_ARG(capacity);
   1187     OSCL_UNUSED_ARG(aContextData);
   1188     OSCL_LEAVE(OsclErrNotSupported);
   1189     return 0;
   1190 }
   1191 
   1192 OSCL_EXPORT_REF PvmiDataStreamStatus
   1193 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::QueryWriteCapacity(PvmiDataStreamSession sessionID,
   1194         uint32& capacity)
   1195 {
   1196     OSCL_UNUSED_ARG(sessionID);
   1197     OSCL_UNUSED_ARG(capacity);
   1198     return PVDS_NOT_SUPPORTED;
   1199 }
   1200 
   1201 OSCL_EXPORT_REF PvmiDataStreamCommandId
   1202 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::RequestWriteCapacityNotification(PvmiDataStreamSession sessionID,
   1203         PvmiDataStreamObserver& observer,
   1204         uint32 capacity,
   1205         OsclAny* aContextData)
   1206 {
   1207     OSCL_UNUSED_ARG(sessionID);
   1208     OSCL_UNUSED_ARG(observer);
   1209     OSCL_UNUSED_ARG(capacity);
   1210     OSCL_UNUSED_ARG(aContextData);
   1211     OSCL_LEAVE(OsclErrNotSupported);
   1212     return 0;
   1213 }
   1214 
   1215 OSCL_EXPORT_REF PvmiDataStreamCommandId
   1216 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::CancelNotification(PvmiDataStreamSession sessionID,
   1217         PvmiDataStreamObserver& observer,
   1218         PvmiDataStreamCommandId aID,
   1219         OsclAny* aContextData)
   1220 {
   1221     OSCL_UNUSED_ARG(sessionID);
   1222     OSCL_UNUSED_ARG(observer);
   1223     OSCL_UNUSED_ARG(aID);
   1224     OSCL_UNUSED_ARG(aContextData);
   1225     OSCL_LEAVE(OsclErrNotSupported);
   1226     return 0;
   1227 }
   1228 
   1229 OSCL_EXPORT_REF PvmiDataStreamStatus
   1230 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Read(PvmiDataStreamSession sessionID,
   1231         uint8* buffer,
   1232         uint32 size,
   1233         uint32& numelements)
   1234 {
   1235     OSCL_UNUSED_ARG(sessionID);
   1236     if (!iFileObject)
   1237         return PVDS_FAILURE;
   1238 
   1239     uint32 result = iFileObject->Read(buffer, size, numelements);
   1240     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::ReadAndUnlockContent returning %d", result));
   1241 
   1242     numelements = result;
   1243     return PVDS_SUCCESS;
   1244 }
   1245 
   1246 OSCL_EXPORT_REF PvmiDataStreamStatus
   1247 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Write(PvmiDataStreamSession sessionID,
   1248         uint8* buffer,
   1249         uint32 size,
   1250         uint32& numelements)
   1251 {
   1252     OSCL_UNUSED_ARG(sessionID);
   1253     OSCL_UNUSED_ARG(buffer);
   1254     OSCL_UNUSED_ARG(size);
   1255     OSCL_UNUSED_ARG(numelements);
   1256     return PVDS_NOT_SUPPORTED;
   1257 }
   1258 
   1259 OSCL_EXPORT_REF PvmiDataStreamStatus
   1260 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Seek(PvmiDataStreamSession sessionID,
   1261         int32 offset,
   1262         PvmiDataStreamSeekType origin)
   1263 {
   1264     OSCL_UNUSED_ARG(sessionID);
   1265     if (!iFileObject)
   1266         return PVDS_FAILURE;
   1267     Oscl_File::seek_type seekType;
   1268     switch (origin)
   1269     {
   1270         case PVDS_SEEK_SET:
   1271             seekType = Oscl_File::SEEKSET;
   1272             break;
   1273         case PVDS_SEEK_CUR:
   1274             seekType = Oscl_File::SEEKCUR;
   1275             break;
   1276         case PVDS_SEEK_END:
   1277             seekType = Oscl_File::SEEKEND;
   1278             break;
   1279         default:
   1280             return PVDS_FAILURE;
   1281     }
   1282     int32 result = iFileObject->Seek(offset, seekType);
   1283     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::SeekContent returning %d", result));
   1284     if (result != 0)
   1285     {
   1286         return PVDS_FAILURE;
   1287     }
   1288     return PVDS_SUCCESS;
   1289 }
   1290 
   1291 OSCL_EXPORT_REF uint32
   1292 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::GetCurrentPointerPosition(PvmiDataStreamSession sessionID)
   1293 {
   1294     OSCL_UNUSED_ARG(sessionID);
   1295     if (!iFileObject)
   1296         return PVDS_FAILURE;
   1297     int32 result = (TOsclFileOffsetInt32)iFileObject->Tell();
   1298     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::GetCurrentContentPosition returning %d", result));
   1299     return (uint32)(result);
   1300 }
   1301 
   1302 OSCL_EXPORT_REF PvmiDataStreamStatus
   1303 PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Flush(PvmiDataStreamSession sessionID)
   1304 {
   1305     OSCL_UNUSED_ARG(sessionID);
   1306     if (!iFileObject)
   1307     {
   1308         PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Flush returning %d", -1));
   1309         return PVDS_FAILURE;
   1310     }
   1311     int32 result = iFileObject->Flush();
   1312     PVMF_CPMPLUGIN_PASSTHRUOMA1_LOGDEBUG((0, "PVMFCPMPassThruPlugInOMA1DataStreamSyncInterfaceImpl::Flush returning %d", result));
   1313     OSCL_UNUSED_ARG(result);
   1314     return PVDS_SUCCESS;
   1315 }
   1316 
   1317