/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: EXPORT_C implementation of drm media WMA agent
*
*/
#include <caf/rightsinfo.h>
#include "mpxmedia.h"
#include "mpxmediadrmdefs.h"
#include "mpxdrmmediawmaagent.h"
#include "mpxlog.h"
// CONSTANTS
_LIT(KMPXWmaDrmDelLicensesType, "licensetype=");
_LIT(KMPXWmaDrmDelUnlimited, "unlimited");
_LIT(KMPXWmaDrmDelTime, "time");
_LIT(KMPXWmaDrmDelCount, "count");
_LIT(KMPXWmaDrmDelDuration, "duration");
_LIT(KMPXWmaDrmDelTimeCount, "time-count");
_LIT(KMPXWmaDrmDelDurationLeft, "duration=");
_LIT(KMPXWmaDrmDelCountLeft, "countleft=");
_LIT(KMPXWmaDrmDelStartTime, "starttime=");
_LIT(KMPXWmaDrmDelEndTime, "endtime=");
_LIT(KMPXWmaDrmDelColon, ":");
_LIT(KMPXWmaDrmDelSemiColon, ";");
_LIT(KMPXWmaDrmTimeFill, "0");
const TInt KMPXWmaDrmMaxLicenseTypeBufSize = 30;
const TInt KMPXWmaDrmDashCount = 2;
const TInt KMPXWmaDrmMaxTimeBufSize = 3;
const TInt KMPXWmaDrmMinutesHourMinSize = 2;
const TText KMPXWmaDrmSemiColonChar = ';';
const TText KMPXWmaDrmDashChar = '-';
const TText KMPXWmaDrmTChar = 'T';
const TText KMPXWmaDrmColonChar = ':';
const TText KMPXWmaDrmPeriodChar = '.';
const TText KMPXWmaDrmZChar = 'Z';
const TText KMPXWmaDrmPlusChar = '+';
// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CMPXDrmMediaWmaAgent* CMPXDrmMediaWmaAgent::NewL()
{
MPX_FUNC("CMPXDrmMediaWmaAgent::NewL()");
CMPXDrmMediaWmaAgent* p = CMPXDrmMediaWmaAgent::NewLC();
CleanupStack::Pop(p);
return p;
}
// -----------------------------------------------------------------------------
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CMPXDrmMediaWmaAgent* CMPXDrmMediaWmaAgent::NewLC()
{
MPX_FUNC("CMPXDrmMediaWmaAgent::NewLC()");
CMPXDrmMediaWmaAgent* p = new (ELeave) CMPXDrmMediaWmaAgent();
CleanupStack::PushL(p);
p->ConstructL();
return p;
}
// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CMPXDrmMediaWmaAgent::~CMPXDrmMediaWmaAgent()
{
MPX_FUNC("CMPXDrmMediaWmaAgent::~CMPXDrmMediaWmaAgent()");
Close();
delete iRightsManager;
delete iManager;
}
// -----------------------------------------------------------------------------
// Default constructor
// -----------------------------------------------------------------------------
//
CMPXDrmMediaWmaAgent::CMPXDrmMediaWmaAgent()
{
MPX_FUNC("CMPXDrmMediaWmaAgent::CMPXDrmMediaWmaAgent()");
}
// ----------------------------------------------------------------------------
// 2nd phase constructor.
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::ConstructL()
{
MPX_FUNC("CMPXDrmMediaWmaAgent::ConstructL()");
RArray< TAgent > agents;
CleanupClosePushL( agents );
iManager = CManager::NewL();
iManager->ListAgentsL( agents );
if ( agents.Count() > 0)
{
TInt i( 0 );
for ( i = 0; i < agents.Count(); i++ )
{
// break if we find the agent we want
// CAF UID
const TDesC& name( agents[i].Name() );
if ( name.Compare( KMPXWDRMCafAgentName ) == 0 ||
name.Compare( KMPXS60WMDRMCafAgent ) == 0 )
{
break;
}
}
if ( i < agents.Count() )
{
// We found the CAF agent
MPX_DEBUG2("CMPXDrmMediaWmaAgent::ConstructL(): CAF agent=%d", i);
iRightsManager = iManager->CreateRightsManagerL( agents[i] );
}
}
CleanupStack::PopAndDestroy( &agents );
}
// ----------------------------------------------------------------------------
// Initialize utility using a filename
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::InitL( const TDesC& aFileName )
{
MPX_DEBUG2("CMPXDrmMediaWmaAgent::InitL(%S) entering", &aFileName );
MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::InitL(aFileName)");
Close();
CreateMediaL();
iData = CData::NewL(
(TVirtualPathPtr) aFileName,
EPeek,
EContentShareReadOnly );
iFileName = aFileName.AllocL();
MPX_DEBUG1("CMPXDrmMediaWmaAgent::InitL() exiting" );
}
// ----------------------------------------------------------------------------
// Initialize utility using a file handle
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::InitL( RFile& aFile )
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::InitL(RFile) entering" );
MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::InitL(aFile)");
Close();
CreateMediaL();
iData = CData::NewL(
aFile,
KDefaultContentObject(),
EPeek );
TFileName filename;
aFile.FullName( filename );
iFileName = filename.AllocL();
MPX_DEBUG1("CMPXDrmMediaWmaAgent::InitL(RFile) exiting" );
}
// ----------------------------------------------------------------------------
// Gets media object with the given attributes
// ----------------------------------------------------------------------------
//
const CMPXMedia& CMPXDrmMediaWmaAgent::GetMediaL( TUint aAttributes )
{
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetMediaL(%d) entering", aAttributes );
MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::GetRightsTypeL()");
if ( iMedia )
{
if ( aAttributes & KMPXMediaDrmProtected.iAttributeId )
{
GetProtectedL();
}
if ( aAttributes & KMPXMediaDrmRightsStatus.iAttributeId )
{
GetRightsStatusL();
}
if ( aAttributes & KMPXMediaDrmRightsType.iAttributeId )
{
GetRightsTypeL();
}
if ( aAttributes & KMPXMediaDrmCount.iAttributeId )
{
GetCountL();
}
if ( aAttributes & KMPXMediaDrmStartTime.iAttributeId )
{
GetStartTimeL();
}
if ( aAttributes & KMPXMediaDrmEndTime.iAttributeId )
{
GetEndTimeL();
}
if ( aAttributes & KMPXMediaDrmInterval.iAttributeId )
{
GetIntervalL();
}
if ( aAttributes & KMPXMediaDrmIntervalStartTime.iAttributeId )
{
// Not Supported for WMA DRM
}
if ( aAttributes & KMPXMediaDrmAccumulatedTime.iAttributeId )
{
// Not Supported for WMA DRM
}
if ( aAttributes & KMPXMediaDrmSendingAllowed.iAttributeId )
{
GetSendingAllowedL();
}
if ( aAttributes & KMPXMediaDrmCanSetAutomated.iAttributeId )
{
GetCanSetAutomatedL();
}
if ( aAttributes & KMPXMediaDrmHasInfoUrl.iAttributeId )
{
// Not Supported for WMA DRM
}
if ( aAttributes & KMPXMediaDrmHasPreviewUrl.iAttributeId )
{
// Not Supported for WMA DRM
}
if ( aAttributes & KMPXMediaDrmAboutToExpire.iAttributeId )
{
GetAboutToExpireL();
}
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetMediaL() exiting" );
return *iMedia;
}
// ----------------------------------------------------------------------------
// Consumes the rights for the current media according
// to the specified consume type
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::ConsumeL(TDrmConsumeType /*aType*/)
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::ConsumeL() entering");
// WMA DRM does not have ability to manually control consumption
MPX_DEBUG1("CMPXDrmMediaWmaAgent::ConsumeL() exiting" );
}
// ----------------------------------------------------------------------------
// Cleans up member variables
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::Close()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::Close() entering");
CMPXDrmMediaAgent::Close();
delete iFileName;
iFileName = NULL;
delete iRightsDescription;
iRightsDescription = NULL;
MPX_DEBUG1("CMPXDrmMediaWmaAgent::Close() exiting");
}
// ----------------------------------------------------------------------------
// Creates a new media object
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::CreateMediaL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::CreateMediaL() entering");
CMPXDrmMediaAgent::CreateMediaL();
// Set the type to WMA
iMedia->SetTObjectValueL( KMPXMediaDrmType,
EMPXDrmTypeWMA );
MPX_DEBUG1("CMPXDrmMediaWmaAgent::CreateMediaL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the rights status
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetRightsStatusL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL() entering");
MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::GetRightsStatusL()");
if ( !iMedia->IsSupported( KMPXMediaDrmRightsStatus ))
{
// Check to make sure it's protected first
if ( !iMedia->IsSupported( KMPXMediaDrmProtected ))
{
GetProtectedL();
}
TBool prot( iMedia->ValueTObjectL<TBool>( KMPXMediaDrmProtected ));
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetRightsStatusL(): prot = %d", prot);
TInt rightsStatus( EMPXDrmRightsFull );
if ( prot )
{
TBool canPlay( ETrue );
#ifndef _DEBUG
User::LeaveIfError( iData->GetAttribute( ECanPlay, canPlay ));
#else
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL(): Getting ECanPlay");
TInt playErr( iData->GetAttribute( ECanPlay, canPlay ));
MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetRightsStatusL(): err = %d, canPlay = %d", playErr, canPlay );
User::LeaveIfError( playErr );
#endif
if ( !canPlay )
{
rightsStatus = EMPXDrmRightsExpired;
}
else
{
TBool rightsStateless( ETrue );
TBool rightsConsumable( EFalse );
#ifndef _DEBUG
User::LeaveIfError( iData->GetAttribute(
ERightsStateless,
rightsStateless ));
User::LeaveIfError( iData->GetAttribute(
ERightsConsumable,
rightsConsumable ));
#else
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL(): Getting ERightsStateless");
TInt statusErr( iData->GetAttribute(
ERightsStateless,
rightsStateless ));
MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetRightsStatusL(): err = %d, rightsStateless = %d", statusErr, rightsStateless );
User::LeaveIfError( statusErr );
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL(): Getting ERightsConsumable");
TInt conumeableErr( iData->GetAttribute(
ERightsConsumable,
rightsConsumable ));
MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetRightsStatusL(): err = %d, rightsConsumable = %d", conumeableErr, rightsConsumable );
User::LeaveIfError( conumeableErr );
#endif
if ( !rightsStateless || rightsConsumable )
{
rightsStatus = EMPXDrmRightsRestricted;
}
else
{
if ( !iMedia->IsSupported( KMPXMediaDrmRightsType ))
{
GetRightsTypeL();
}
TInt rightsType( iMedia->ValueTObjectL<TInt>(
KMPXMediaDrmRightsType ));
if ( EMPXDrmRightsTypeNoRestriction == rightsType )
{
rightsStatus = EMPXDrmRightsFull;
}
else
{
rightsStatus = EMPXDrmRightsRestricted;
}
}
}
}
iMedia->SetTObjectValueL( KMPXMediaDrmRightsStatus,
rightsStatus );
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetRightsStatusL(): setting status = %d", rightsStatus);
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsStatusL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the rights type attribute if not already obtained
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetRightsTypeL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsTypeL() entering");
MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::GetRightsTypeL()");
if ( !iMedia->IsSupported( KMPXMediaDrmRightsType ))
{
TInt rightsType( EMPXDrmRightsTypeNoRestriction );
if ( GetWmdrmRightsDescriptionL() == KErrNone )
{
TPtr strPtr( iRightsDescription->Des() );
TInt end( strPtr.FindF( KMPXWmaDrmDelSemiColon ));
HBufC* licensetype( HBufC::NewLC( KMPXWmaDrmMaxLicenseTypeBufSize ));
TPtr licensetypePtr( licensetype->Des());
licensetypePtr = strPtr.Mid(
KMPXWmaDrmDelLicensesType().Length(),
end - KMPXWmaDrmDelLicensesType().Length() );
if ( licensetypePtr == KMPXWmaDrmDelUnlimited )
{
rightsType = EMPXDrmRightsTypeNoRestriction;
}
else if ( licensetypePtr == KMPXWmaDrmDelTime )
{
rightsType = EMPXDrmRightsTypeTime;
}
else if ( licensetypePtr == KMPXWmaDrmDelCount )
{
rightsType = EMPXDrmRightsTypeCount;
}
else if ( licensetypePtr == KMPXWmaDrmDelDuration )
{
rightsType = EMPXDrmRightsTypeInterval;
}
else if ( licensetypePtr == KMPXWmaDrmDelTimeCount )
{
rightsType = EMPXDrmRightsTypeTimeCount;
}
CleanupStack::PopAndDestroy( licensetype );
}
iMedia->SetTObjectValueL( KMPXMediaDrmRightsType,
rightsType );
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetRightsTypeL() setting type = %d", rightsType);
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetRightsTypeL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the count attribute if not already obtained
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetCountL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetCountL() entering");
// Do not need to check if it already supported, we
// just overwrite the old value if possible
TUint32 count( 0 );
if ( GetWmdrmRightsDescriptionL() == KErrNone )
{
TPtr strPtr( iRightsDescription->Des() );
if ( strPtr.FindF( KMPXWmaDrmDelLicensesType ) == KErrNone )
{
TInt begin( strPtr.FindF( KMPXWmaDrmDelCountLeft ));
if ( begin != KErrNotFound )
{
TPtrC countPtr( strPtr.Mid( begin ));
TInt semiLoc( countPtr.Locate( KMPXWmaDrmSemiColonChar ));
TInt countLen( KMPXWmaDrmDelCountLeft().Length() );
TLex lex( strPtr.MidTPtr( begin + countLen, semiLoc - countLen ) );
User::LeaveIfError( lex.Val( count, EDecimal ) );
iMedia->SetTObjectValueL( KMPXMediaDrmCount,
count );
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetCountL(): setting count = %d", count);
}
}
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetCountL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the start time attribute if not already obtained
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetStartTimeL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetStartTimeL() entering");
if ( !iMedia->IsSupported( KMPXMediaDrmStartTime ))
{
TTime startTime;
if ( GetWmdrmTimeL( KMPXWmaDrmDelStartTime, startTime ) ==
KErrNone )
{
iMedia->SetTObjectValueL( KMPXMediaDrmStartTime,
startTime.Int64() );
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetStartTimeL(): setting start time");
}
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetStartTimeL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the end time attribute if not already obtained
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetEndTimeL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetEndTimeL() entering");
if ( !iMedia->IsSupported( KMPXMediaDrmEndTime ))
{
TTime endTime;
if ( GetWmdrmTimeL( KMPXWmaDrmDelEndTime, endTime ) ==
KErrNone )
{
iMedia->SetTObjectValueL( KMPXMediaDrmEndTime,
endTime.Int64() );
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetEndTimeL(): setting end time");
}
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetEndTimeL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the interval attribute if not already obtained
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetIntervalL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetIntervalL() entering");
if ( !iMedia->IsSupported( KMPXMediaDrmInterval ))
{
if ( GetWmdrmRightsDescriptionL() == KErrNone )
{
TPtr strPtr( iRightsDescription->Des() );
if ( strPtr.FindF( KMPXWmaDrmDelLicensesType ) == KErrNone )
{
TInt begin = strPtr.FindF( KMPXWmaDrmDelDurationLeft );
if ( begin != KErrNotFound )
{
TPtrC countPtr = strPtr.Mid( begin );
TInt semiLoc = countPtr.Locate( KMPXWmaDrmSemiColonChar );
TInt countLen = KMPXWmaDrmDelDurationLeft().Length();
TLex lex( strPtr.MidTPtr( begin + countLen, semiLoc - countLen ) );
TInt interval;
User::LeaveIfError( lex.Val( interval ) );
TTimeIntervalSeconds intervalSeconds( interval );
iMedia->SetTObjectValueL( KMPXMediaDrmInterval,
intervalSeconds );
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetIntervalL(): setting interval");
}
}
}
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetIntervalL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the sending allowed attribute if not already obtained
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetSendingAllowedL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetSendingAllowedL() entering");
if ( !iMedia->IsSupported( KMPXMediaDrmSendingAllowed ))
{
TBool sendingAllowed( ETrue );
#ifndef _DEBUG
User::LeaveIfError(
iData->GetAttribute( EIsForwardable, sendingAllowed ));
#else
TInt sendErr( iData->GetAttribute( EIsForwardable, sendingAllowed ));
MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetSendingAllowedL(): err = %d, sendingAllowed = %d", sendErr, sendingAllowed);
User::LeaveIfError( sendErr );
#endif
iMedia->SetTObjectValueL( KMPXMediaDrmSendingAllowed,
sendingAllowed );
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetSendingAllowedL(): setting sending allowed = %d", sendingAllowed);
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetSendingAllowedL() exiting");
}
// ----------------------------------------------------------------------------
// Gets the can set automated attribute if not already obtained
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetCanSetAutomatedL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetCanSetAutomatedL() entering");
if ( !iMedia->IsSupported( KMPXMediaDrmCanSetAutomated ))
{
TBool automated( ETrue );
// For WMA DRM files, they can only be set automated if not protected
TBool prot( EFalse );
if ( !iMedia->IsSupported( KMPXMediaDrmProtected ))
{
GetProtectedL();
}
prot = iMedia->ValueTObjectL<TBool>( KMPXMediaDrmProtected );
if ( prot )
{
automated = EFalse;
}
iMedia->SetTObjectValueL( KMPXMediaDrmCanSetAutomated,
automated );
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetCanSetAutomatedL(): setting automated = %d", automated);
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetCanSetAutomatedL() exiting");
}
// -----------------------------------------------------------------------------
// Get Rights Description String for WMDRM protected files
// -----------------------------------------------------------------------------
//
TInt CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL() entering");
MPX_DEBUG_THREAD("CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL()");
TInt error( KErrNotFound );
if ( iRightsDescription )
{
error = KErrNone;
}
else
{
// Currently software is that if no rights available, getting
// rights string will panic PVWMCaf server. To be removed
// if fixed in PV server later
TBool canPlay( ETrue );
#ifndef _DEBUG
User::LeaveIfError( iData->GetAttribute( ECanPlay, canPlay ));
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL(): canPlay = %d", canPlay);
#else
TInt playErr( iData->GetAttribute( ECanPlay, canPlay ));
MPX_DEBUG3("CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL(): err = %d, canPlay = %d", playErr, canPlay );
User::LeaveIfError( playErr );
#endif
if ( iRightsManager && canPlay )
{
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL(): iFileName = %S", iFileName);
RStreamablePtrArray<ContentAccess::CRightsInfo> rightsArray;
CleanupClosePushL( rightsArray );
TRAPD( err, iRightsManager->ListRightsL( rightsArray, *iFileName ));
if ( KErrNone == err )
{
if ( rightsArray.Count() > 0 )
{
ContentAccess::CRightsInfo* rightInfo = rightsArray[0];
iRightsDescription = rightInfo->Description().AllocL();
error = KErrNone;
}
}
CleanupStack::PopAndDestroy( &rightsArray );
}
}
#ifdef _DEBUG
if (!error)
{
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL(): %S", iRightsDescription);
}
#endif
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetWmdrmRightsDescriptionL() exiting");
return error;
}
// -----------------------------------------------------------------------------
// CMPXDrmMediaWmaAgent::GetWmdrmTimeL
// -----------------------------------------------------------------------------
//
TInt CMPXDrmMediaWmaAgent::GetWmdrmTimeL(
const TDesC& aTimeTypeDelimeter,
TTime& aTime )
{
MPX_DEBUG2("CMPXDrmMediaWmaAgent::GetWmdrmTimeL(%S) entering", &aTimeTypeDelimeter);
TInt err( KErrNone );
if ( GetWmdrmRightsDescriptionL() == KErrNone )
{
TPtr strPtr( iRightsDescription->Des() );
err = KErrNotFound;
if ( strPtr.FindF( KMPXWmaDrmDelLicensesType ) == KErrNone )
{
TInt begin = strPtr.FindF( aTimeTypeDelimeter );
if ( begin != KErrNotFound )
{
err = KErrNone;
TPtrC countPtr = strPtr.Mid( begin );
TInt semiLoc = countPtr.Locate( KMPXWmaDrmSemiColonChar );
TPtrC timePtr = strPtr.Mid( begin, semiLoc );
TInt finddash = timePtr.Locate( KMPXWmaDrmDashChar );
TInt dashcount = 0;
while ( finddash != KErrNotFound && dashcount < KMPXWmaDrmDashCount )
{
// after the first dash, subtract 1 from both day and time
// as Jan 01 is represented by 00, 00 in TTime.
++dashcount;
// convert buffer to TInt and decrement
TLex lex( timePtr.Mid( finddash + 1, KMPXWmaDrmDashCount ) );
TInt dateInt;
User::LeaveIfError( lex.Val( dateInt ) );
--dateInt;
// convert back to buffer
HBufC* datebuf = HBufC::NewLC( KMPXWmaDrmMaxTimeBufSize );
TPtr datebufPtr = datebuf->Des();
datebufPtr.Num( dateInt );
if ( datebufPtr.Length() < KMPXWmaDrmMinutesHourMinSize )
{
datebufPtr.Insert( 0, KMPXWmaDrmTimeFill );
}
strPtr.Replace( ( begin + finddash + 1 ),
KMPXWmaDrmMinutesHourMinSize, datebufPtr );
strPtr.Delete( ( begin + finddash ), 1 );
finddash = timePtr.Locate( KMPXWmaDrmDashChar );
CleanupStack::PopAndDestroy( datebuf );
}
// Format time to correspond TTime time
TInt findTdelim = timePtr.Locate( KMPXWmaDrmTChar );
if ( findTdelim != KErrNone )
{
TInt findcolon = timePtr.Locate( KMPXWmaDrmColonChar );
while ( findcolon != KErrNotFound )
{
strPtr.Delete( ( begin + findcolon ), 1 );
findcolon = timePtr.Locate( KMPXWmaDrmColonChar );
}
}
strPtr.Replace( ( begin + findTdelim), 1, KMPXWmaDrmDelColon );
// have removed desired characters from time, now isolate them.
TInt end = timePtr.Locate( KMPXWmaDrmPeriodChar );
if ( end == KErrNotFound )
{
// no milliseconds, look for time zone indicator +, -, or Z
end = timePtr.Locate( KMPXWmaDrmZChar );
if ( end == KErrNotFound )
{
end = timePtr.Locate( KMPXWmaDrmDashChar );
if ( end == KErrNotFound )
{
end = timePtr.Locate( KMPXWmaDrmPlusChar );
}
}
}
TInt delimLen = aTimeTypeDelimeter.Length();
aTime.Set( strPtr.MidTPtr( begin + delimLen , end - delimLen ) );
}
}
}
else
{
err = KErrNotFound;
}
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetWmdrmTimeL() exiting");
return err;
}
// ----------------------------------------------------------------------------
// Gets whether the DRM object is about to expire or not
// ----------------------------------------------------------------------------
//
void CMPXDrmMediaWmaAgent::GetAboutToExpireL()
{
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetAboutToExpireL() entering");
TBool aboutToExpire( EFalse );
// Currently WMDRM does not use about to expire
iMedia->SetTObjectValueL( KMPXMediaDrmAboutToExpire,
aboutToExpire );
MPX_DEBUG1("CMPXDrmMediaWmaAgent::GetAboutToExpireL() exiting");
}
// end of file