diff -r 000000000000 -r a2952bb97e68 mpx/commonframework/common/src/mpxdrmmediawmaagent.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mpx/commonframework/common/src/mpxdrmmediawmaagent.cpp	Thu Dec 17 08:55:47 2009 +0200
@@ -0,0 +1,784 @@
+/*
+* 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