Mercurial Mercurial > oss > FCL > sf > mw > drm / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
omadrm/drmengine/agentv2/src/Oma2AgentRightsManager.cpp
changeset 23 493788a4a8a4
parent 0 95b198f216e5
child 84 b09186059647
equal deleted inserted replaced
5:79d62d1d7957 23:493788a4a8a4 
    17 
    17 
    18 
    18 
    19 
    19 
    20 // INCLUDE FILES
 
    20 // INCLUDE FILES
 
    21 #include <caf/caf.h>
 
    21 #include <caf/caf.h>
 
       
    22 #include <caf/cafplatform.h>
 
    22 #include <utf.h>
 
    23 #include <utf.h>
 
    23 #include "drmrights.h"
 
    24 #include "DRMRights.h"
 
    24 #include "oma2agentrightsmanager.h"
 
    25 #include "Oma2AgentRightsManager.h"
 
    25 #include "drmrightsclient.h"
 
    26 #include "DRMRightsClient.h"
 
    26 #include "dcfrep.h"
 
    27 #include "DcfRep.h"
 
    27 #include "dcfentry.h"
 
    28 #include "DcfEntry.h"
 
    28 
    29 
    29 using namespace ContentAccess;
 
    30 using namespace ContentAccess;
 
    30 
    31 
    31 // ============================= LOCAL FUNCTIONS ===============================
 
    32 // ============================= LOCAL FUNCTIONS ===============================
 
    32 
    33 
    37     RFs fs;
 
    38     RFs fs;
 
    38 
    39 
    39     User::LeaveIfError(client.Connect());
 
    40     User::LeaveIfError(client.Connect());
 
    40     CleanupClosePushL(client);
 
    41     CleanupClosePushL(client);
 
    41     User::LeaveIfError(fs.Connect());
 
    42     User::LeaveIfError(fs.Connect());
 
    42     User::LeaveIfError(fs.ShareAuto());    
    43     User::LeaveIfError(fs.ShareAuto());
 
    43     CleanupClosePushL(fs);
 
    44     CleanupClosePushL(fs);
 
    44     dcf = CDcfCommon::NewL(aVirtualPath.URI(), &fs);
 
    45     dcf = CDcfCommon::NewL(aVirtualPath.URI(), &fs);
 
    45     CleanupStack::PushL(dcf);
 
    46     CleanupStack::PushL(dcf);
 
    46     User::LeaveIfError( dcf->OpenPart(aVirtualPath.UniqueId()));
 
    47     User::LeaveIfError( dcf->OpenPart(aVirtualPath.UniqueId()));
 
    47     User::LeaveIfError( client.DeleteDbEntry(*dcf->iContentID));
 
    48     User::LeaveIfError( client.DeleteDbEntry(*dcf->iContentID));
 
    48     CleanupStack::PopAndDestroy(3); // dcf, fs, client
 
    49     CleanupStack::PopAndDestroy(3); // dcf, fs, client
 
    49     }
 
    50     }
 
    50 
    51 
    51 void DoDeleteAllRightsObjects( const TVirtualPathPtr& aVirtualPath )
 
    52 void DoDeleteAllRightsObjects( const TVirtualPathPtr& aVirtualPath )
 
    52     {
 
    53     {
 
    53     TRAP_IGNORE( DoDeleteAllRightsObjectsL( aVirtualPath ) );    
    54     TRAP_IGNORE( DoDeleteAllRightsObjectsL( aVirtualPath ) );
 
    54     }
 
    55     }
 
    55 
    56 
    56 void DoDeleteRightsObjectL(
 
    57 void DoDeleteRightsObjectL(
 
    57     const CRightsInfo& aRightsInfo)
 
    58     const CRightsInfo& aRightsInfo)
 
    58     {
 
    59     {
 
    81         User::LeaveIfError( lex.Val(uniqueId) );
 
    82         User::LeaveIfError( lex.Val(uniqueId) );
 
    82         User::LeaveIfError( client.DeleteDbEntry(*contentId, uniqueId) );
 
    83         User::LeaveIfError( client.DeleteDbEntry(*contentId, uniqueId) );
 
    83         }
 
    84         }
 
    84     CleanupStack::PopAndDestroy(2); // contentId, client
 
    85     CleanupStack::PopAndDestroy(2); // contentId, client
 
    85     }
 
    86     }
 
    86     
    87 
    87 void DoDeleteRightsObject(
 
    88 void DoDeleteRightsObject(
 
    88     const CRightsInfo& aRightsInfo)
 
    89     const CRightsInfo& aRightsInfo)
 
    89     {
 
    90     {
 
    90     TRAP_IGNORE( DoDeleteRightsObjectL( aRightsInfo ) );    
    91     TRAP_IGNORE( DoDeleteRightsObjectL( aRightsInfo ) );
 
    91     }
 
    92     }
 
    92 
    93 
    93 
    94 
    94 template<class S>
 
    95 template<class S>
 
    95 void PointerArrayResetDestroyAndClose(TAny* aPtr)
 
    96 void PointerArrayResetDestroyAndClose(TAny* aPtr)
 
   103     TIntent aIntent,
 
   104     TIntent aIntent,
 
   104     TTime aTime)
 
   105     TTime aTime)
 
   105     {
 
   106     {
 
   106     TBool r = EFalse;
 
   107     TBool r = EFalse;
 
   107     CDRMConstraint* constraint;
 
   108     CDRMConstraint* constraint;
 
   108     
   109 
   109     constraint = aPermission->ConstraintForIntent(aIntent);
 
   110     constraint = aPermission->ConstraintForIntent(aIntent);
 
   110     if (constraint != NULL && !constraint->Expired(aTime))
 
   111     if (constraint != NULL && !constraint->Expired(aTime))
 
   111         {
 
   112         {
 
   112         r = ETrue;
 
   113         r = ETrue;
 
   113         }
 
   114         }
 
   117 TRightsStatus PermissionStatus(
 
   118 TRightsStatus PermissionStatus(
 
   118     CDRMPermission* aPermission)
 
   119     CDRMPermission* aPermission)
 
   119     {
 
   120     {
 
   120     TRightsStatus r = ERightsStatusNone;
 
   121     TRightsStatus r = ERightsStatusNone;
 
   121     TTime time;
 
   122     TTime time;
 
   122     
   123 
   123     time.HomeTime();
 
   124     time.HomeTime();
 
   124     if ((!(aPermission->iAvailableRights & ERightsTopLevel) ||
 
   125     if ((!(aPermission->iAvailableRights & ERightsTopLevel) ||
 
   125         !aPermission->iTopLevel->Expired(time))
 
   126         !aPermission->iTopLevel->Expired(time))
 
   126         
   127 
   127         &&
 
   128         &&
 
   128         
   129 
   129         (IsValid(aPermission, EPlay, time) ||
 
   130         (IsValid(aPermission, EPlay, time) ||
 
   130         IsValid(aPermission, EView, time) ||
 
   131         IsValid(aPermission, EView, time) ||
 
   131         IsValid(aPermission, EPrint, time) ||
 
   132         IsValid(aPermission, EPrint, time) ||
 
   132         IsValid(aPermission, EExecute, time)))
 
   133         IsValid(aPermission, EExecute, time)))
 
   133         {
 
   134         {
 
   142     {
 
   143     {
 
   143     TRightsTypeMask type;
 
   144     TRightsTypeMask type;
 
   144     TPtr ptr(NULL, 0);
 
   145     TPtr ptr(NULL, 0);
 
   145     HBufC* id = NULL;
 
   146     HBufC* id = NULL;
 
   146     CRightsInfo* r = NULL;
 
   147     CRightsInfo* r = NULL;
 
   147     
   148 
   148     id = HBufC::NewLC(aContentId.Length() + 20);
 
   149     id = HBufC::NewLC(aContentId.Length() + 20);
 
   149     ptr.Set(id->Des());
 
   150     ptr.Set(id->Des());
 
   150     ptr.Copy(aContentId);
 
   151     ptr.Copy(aContentId);
 
   151     ptr.SetLength(aContentId.Length());
 
   152     ptr.SetLength(aContentId.Length());
 
   152     ptr.Append(0);
 
   153     ptr.Append(0);
 
   191 // -----------------------------------------------------------------------------
 
   192 // -----------------------------------------------------------------------------
 
   192 //
 
   193 //
 
   193 COma2AgentRightsManager* COma2AgentRightsManager::NewL()
 
   194 COma2AgentRightsManager* COma2AgentRightsManager::NewL()
 
   194     {
 
   195     {
 
   195     COma2AgentRightsManager* self = new( ELeave ) COma2AgentRightsManager;
 
   196     COma2AgentRightsManager* self = new( ELeave ) COma2AgentRightsManager;
 
   196     
   197 
   197     CleanupStack::PushL( self );
 
   198     CleanupStack::PushL( self );
 
   198     self->ConstructL();
 
   199     self->ConstructL();
 
   199     CleanupStack::Pop();
 
   200     CleanupStack::Pop();
 
   200 
   201 
   201     return self;
 
   202     return self;
 
   202     }
 
   203     }
 
   203 
   204 
   204     
   205 
   205 // Destructor
 
   206 // Destructor
 
   206 COma2AgentRightsManager::~COma2AgentRightsManager()
 
   207 COma2AgentRightsManager::~COma2AgentRightsManager()
 
   207     {
 
   208     {
 
   208     }
 
   209     }
 
   209 
   210 
   238         CleanupStack::PushL(permCleanup);
 
   239         CleanupStack::PushL(permCleanup);
 
   239         for (i = 0; i < permissions.Count(); i++)
 
   240         for (i = 0; i < permissions.Count(); i++)
 
   240             {
 
   241             {
 
   241             aArray.AppendL(ConvertToRightsInfoL(permissions[i], *idList[j]));
 
   242             aArray.AppendL(ConvertToRightsInfoL(permissions[i], *idList[j]));
 
   242             }
 
   243             }
 
   243         
   244 
   244         CleanupStack::PopAndDestroy(1); // permCleanup
 
   245         CleanupStack::PopAndDestroy(1); // permCleanup
 
   245         }
 
   246         }
 
   246     CleanupStack::PopAndDestroy(2); // idCleanup, client
 
   247     CleanupStack::PopAndDestroy(2); // idCleanup, client
 
   247     }
 
   248     }
 
   248     
   249 
   249 void COma2AgentRightsManager::ListRightsL(
 
   250 void COma2AgentRightsManager::ListRightsL(
 
   250     RStreamablePtrArray<CRightsInfo>& aArray,
 
   251     RStreamablePtrArray<CRightsInfo>& aArray,
 
   251     const TDesC& aUri) const
 
   252     const TDesC& aUri) const
 
   252     {
 
   253     {
 
   253     TVirtualPathPtr ptr(aUri, KDefaultContentObject);
 
   254     TVirtualPathPtr ptr(aUri, KDefaultContentObject);
 
   254     ListRightsL(aArray, ptr);
 
   255     ListRightsL(aArray, ptr);
 
   255     }
 
   256     }
 
   256     
   257 
   257 void COma2AgentRightsManager::ListRightsL(
 
   258 void COma2AgentRightsManager::ListRightsL(
 
   258     RStreamablePtrArray<CRightsInfo>& aArray, 
   259     RStreamablePtrArray<CRightsInfo>& aArray,
 
   259     TVirtualPathPtr& aVirtualPath) const
 
   260     TVirtualPathPtr& aVirtualPath) const
 
   260     {
 
   261     {
 
   261     RPointerArray<CDRMPermission> permissions;
 
   262     RPointerArray<CDRMPermission> permissions;
 
   262     RDRMRightsClient client;
 
   263     RDRMRightsClient client;
 
   263     TCleanupItem listCleanup(PointerArrayResetDestroyAndClose<CDRMPermission>,
 
   264     TCleanupItem listCleanup(PointerArrayResetDestroyAndClose<CDRMPermission>,
 
   270     TUint32 reason = 0;
 
   271     TUint32 reason = 0;
 
   271 
   272 
   272     User::LeaveIfError(client.Connect());
 
   273     User::LeaveIfError(client.Connect());
 
   273     CleanupClosePushL(client);
 
   274     CleanupClosePushL(client);
 
   274     User::LeaveIfError(fs.Connect());
 
   275     User::LeaveIfError(fs.Connect());
 
   275     User::LeaveIfError(fs.ShareAuto());    
   276     User::LeaveIfError(fs.ShareAuto());
 
   276     CleanupClosePushL(fs);
 
   277     CleanupClosePushL(fs);
 
   277     dcf = CDcfCommon::NewL(aVirtualPath.URI(), &fs);
 
   278     dcf = CDcfCommon::NewL(aVirtualPath.URI(), &fs);
 
   278     if (dcf == NULL)
 
   279     if (dcf == NULL)
 
   279         {
 
   280         {
 
   280         User::Leave(KErrArgument);
 
   281         User::Leave(KErrArgument);
 
   281         }
 
   282         }
 
   282     CleanupStack::PushL(dcf);
 
   283     CleanupStack::PushL(dcf);
 
   283     User::LeaveIfError(dcf->OpenPart(aVirtualPath.UniqueId()));
 
   284     User::LeaveIfError(dcf->OpenPart(aVirtualPath.UniqueId()));
 
   284     
   285 
   285     TRAP(error, permission = client.GetActiveRightsL(EUnknown, *dcf->iContentID, reason));
 
   286     TRAP(error, permission = client.GetActiveRightsL(EUnknown, *dcf->iContentID, reason));
 
   286     if (permission != NULL)
 
   287     if (permission != NULL)
 
   287         {
 
   288         {
 
   288         CleanupStack::PushL(permission);
 
   289         CleanupStack::PushL(permission);
 
   289         aArray.AppendL(ConvertToRightsInfoL(permission, *dcf->iContentID));
 
   290         aArray.AppendL(ConvertToRightsInfoL(permission, *dcf->iContentID));
 
   290         CleanupStack::PopAndDestroy(); // permission
 
   291         CleanupStack::PopAndDestroy(); // permission
 
   291         }
 
   292         }
 
   292     
   293 
   293     TRAP(error, client.GetDBEntriesL(*dcf->iContentID, permissions));
 
   294     TRAP(error, client.GetDBEntriesL(*dcf->iContentID, permissions));
 
   294     CleanupStack::PushL(listCleanup);
 
   295     CleanupStack::PushL(listCleanup);
 
   295 
   296 
   296     for (i = 0; i < permissions.Count(); i++)
 
   297     for (i = 0; i < permissions.Count(); i++)
 
   297         {
 
   298         {
 
   298         aArray.AppendL(ConvertToRightsInfoL(permissions[i], *dcf->iContentID));
 
   299         aArray.AppendL(ConvertToRightsInfoL(permissions[i], *dcf->iContentID));
 
   299         }
 
   300         }
 
   300     
   301 
   301     CleanupStack::PopAndDestroy(4); // listCleanup, dcf, fs, client
 
   302     CleanupStack::PopAndDestroy(4); // listCleanup, dcf, fs, client
 
   302     }
 
   303     }
 
   303     
   304 
   304 void COma2AgentRightsManager::ListContentL(
 
   305 void COma2AgentRightsManager::ListContentL(
 
   305     RStreamablePtrArray<CVirtualPath>& aArray,
 
   306     RStreamablePtrArray<CVirtualPath>& aArray,
 
   306     CRightsInfo& aRightsInfo) const
 
   307     CRightsInfo& aRightsInfo) const
 
   307     {
 
   308     {
 
   308     RDRMRightsClient client;
 
   309     RDRMRightsClient client;
 
   321         }
 
   322         }
 
   322     contentId = CnvUtfConverter::ConvertFromUnicodeToUtf8L(
 
   323     contentId = CnvUtfConverter::ConvertFromUnicodeToUtf8L(
 
   323         aRightsInfo.UniqueId().Left(n));
 
   324         aRightsInfo.UniqueId().Left(n));
 
   324     CleanupStack::PushL(contentId);
 
   325     CleanupStack::PushL(contentId);
 
   325     rep = CDcfRep::NewL();
 
   326     rep = CDcfRep::NewL();
 
   326     CleanupStack::PushL(rep);    
   327     CleanupStack::PushL(rep);
 
   327     rep->OrderListL();
 
   328     rep->OrderListL();
 
   328     entry = rep->NextL();
 
   329     entry = rep->NextL();
 
   329     while (entry != NULL)
 
   330     while (entry != NULL)
 
   330         {
 
   331         {
 
   331         CleanupStack::PushL(entry);
 
   332         CleanupStack::PushL(entry);
 
   333             KDefaultContentObject));
 
   334             KDefaultContentObject));
 
   334         aArray.AppendL(path);
 
   335         aArray.AppendL(path);
 
   335         CleanupStack::PopAndDestroy(); // entry
 
   336         CleanupStack::PopAndDestroy(); // entry
 
   336         entry = rep->NextL();
 
   337         entry = rep->NextL();
 
   337         }
 
   338         }
 
   338     
   339 
   339     CleanupStack::PopAndDestroy(3); // rep, contentId, client
 
   340     CleanupStack::PopAndDestroy(3); // rep, contentId, client
 
   340     }
 
   341     }
 
   341     
   342 
   342 MAgentRightsBase* COma2AgentRightsManager::GetRightsDataL(
 
   343 MAgentRightsBase* COma2AgentRightsManager::GetRightsDataL(
 
   343     const CRightsInfo& aRightsInfo) const
 
   344     const CRightsInfo& aRightsInfo) const
 
   344     {
 
   345     {
 
   345     RDRMRightsClient client;
 
   346     RDRMRightsClient client;
 
   346     CDRMPermission* permission = NULL;
 
   347     CDRMPermission* permission = NULL;
 
   376         rights->SetAssetL(*asset);
 
   377         rights->SetAssetL(*asset);
 
   377         CleanupStack::PopAndDestroy(2); // asset, permission
 
   378         CleanupStack::PopAndDestroy(2); // asset, permission
 
   378         }
 
   379         }
 
   379     CleanupStack::Pop(); // rights
 
   380     CleanupStack::Pop(); // rights
 
   380     CleanupStack::PopAndDestroy(2); // contentId, client
 
   381     CleanupStack::PopAndDestroy(2); // contentId, client
 
   381     
   382 
   382     return rights;
 
   383     return rights;
 
   383     }
 
   384     }
 
   384     
   385 
   385 TInt COma2AgentRightsManager::DeleteRightsObject(
 
   386 TInt COma2AgentRightsManager::DeleteRightsObject(
 
   386     const CRightsInfo& aRightsInfo)
 
   387     const CRightsInfo& aRightsInfo)
 
   387     {
 
   388     {
 
   388     TInt error = KErrNone;
 
   389     TInt error = KErrNone;
 
   389 		TRAP( error, DoDeleteRightsObject(aRightsInfo));
 
   390         TRAP( error, DoDeleteRightsObject(aRightsInfo));
 
   390 		return error;
 
   391         return error;
 
   391     }
 
   392     }
 
   392     
   393 
   393 TInt COma2AgentRightsManager::DeleteAllRightsObjects(
 
   394 TInt COma2AgentRightsManager::DeleteAllRightsObjects(
 
   394     const TVirtualPathPtr& aVirtualPath)
 
   395     const TVirtualPathPtr& aVirtualPath)
 
   395     {
 
   396     {
 
   396     TInt error = KErrNone;
 
   397     TInt error = KErrNone;
 
   397 		TRAP( error, DoDeleteAllRightsObjectsL(aVirtualPath));
 
   398         TRAP( error, DoDeleteAllRightsObjectsL(aVirtualPath));
 
   398 		return error;
 
   399         return error;
 
   399     }
 
   400     }
 
   400     
   401 
   401 TInt COma2AgentRightsManager::SetProperty(
 
   402 TInt COma2AgentRightsManager::SetProperty(
 
   402     TAgentProperty /*aProperty*/,
 
   403     TAgentProperty /*aProperty*/,
 
   403     TInt /*aValue*/)
 
   404     TInt /*aValue*/)
 
   404     {
 
   405     {
 
   405     return KErrCANotSupported;
 
   406     return KErrCANotSupported;
FCL/sf/mw/drm