/*

* Copyright (c) 2008-2009 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:    DRM utility implementation

*

*/

/**

 * @internal reviewed 03/07/2007 by Rowland Cook

 */

// INCLUDES

#include "glxdrmutility.h"

#include <glxpanic.h>

#include <DRMHelper.h>

#include <DRMCommon.h>

#include <caf/caf.h>

#include <caf/content.h>

#include <caf/data.h>

#include <caf/manager.h>

#include "glxtracer.h"

const TInt KGlxDRMThumbnailHeight = 120;

const TInt KGlxDRMThumbnailWidth = 90;

// ======== MEMBER FUNCTIONS ========

/**

 * CGlxDrmTls

 *

 * Global object stored in TLS. 

 * Owns the only instance of a CGlxDRMUtility

 */

struct CGlxDrmTls

    {

    CGlxDrmTls(CGlxDRMUtility* aUtility) 

        {

        iDrmUtility = aUtility;

        iRefCount = 0;

        }

    CGlxDRMUtility* iDrmUtility;

    TInt iRefCount;

    };

//============================================================================

// InstanceL

//============================================================================

EXPORT_C CGlxDRMUtility* CGlxDRMUtility::InstanceL()

    {

    TRACER("CGlxDRMUtility::InstanceL()");

    CGlxDrmTls* tls = reinterpret_cast<CGlxDrmTls*>(Dll::Tls());

    if ( !tls )

        {

        CGlxDRMUtility* drmutil = new(ELeave)CGlxDRMUtility();

        CleanupStack::PushL(drmutil);

        drmutil->ConstructL();

        tls = new (ELeave) CGlxDrmTls(drmutil);

        CleanupStack::Pop(drmutil);

        Dll::SetTls( reinterpret_cast<TAny*>(tls));

        }

    tls->iRefCount++;

    return tls->iDrmUtility;

    }

//============================================================================

// Close

//============================================================================ 

EXPORT_C void CGlxDRMUtility::Close()

    {

    TRACER("CGlxDRMUtility::Close()");

    CGlxDrmTls* tls = reinterpret_cast<CGlxDrmTls*>(Dll::Tls());

    if ( tls ) 

        {

        tls->iRefCount--;

        // Delete the tls pointer and list manager instance if this was the 

        // last reference

        if (tls->iRefCount == 0)

            {

            delete tls->iDrmUtility;

            delete tls;

            Dll::SetTls(NULL);

            }

        }

    }

//============================================================================

// Destructor

//============================================================================ 

CGlxDRMUtility::~CGlxDRMUtility()

    {

    TRACER("CGlxDRMUtility::~CGlxDRMUtility()");

    delete iCManager;

    delete iDrmHelper;

    delete iLastConsumedItemUri;

    }

//============================================================================

// CheckOpenRightsL

//============================================================================ 

EXPORT_C TBool CGlxDRMUtility::CheckOpenRightsL( const TDesC& aUri, 

                                                TBool aCheckViewRights )

    {

    TRACER("CGlxDRMUtility::CheckOpenRightsL()");

    // When checking current rights for a URI, clear stored URI

    TPtr ptr = iLastConsumedItemUri->Des();

    ptr.Zero();

    iLastConsumedItemUri = iLastConsumedItemUri->ReAllocL( 0 );

    TBool rightsValid = EFalse;

    TVirtualPathPtr path( aUri, KDefaultContentObject() );

    ContentAccess::TAttribute attr = 

        aCheckViewRights ? ContentAccess::ECanView : ContentAccess::ECanPlay;

    // rightsValid is not updated if an error occurs

    iCManager->GetAttribute( attr, rightsValid, path );

    return rightsValid;

    }

//============================================================================

// CheckDisplayRightsL

//============================================================================ 

EXPORT_C TBool CGlxDRMUtility::CheckDisplayRightsL( const TDesC& aUri, 

                                                    TBool aCheckViewRights )

    {

    TRACER("CGlxDRMUtility::CheckDisplayRightsL()");

    // Allow to display if rights for a URI was just consumed (i.e. same as stored URI)

    if ( iLastConsumedItemUri->Length() > 0 )

        {

        if ( aUri.CompareF( *iLastConsumedItemUri ) == 0 )

            {

            return ETrue;

            }

        }

    // Otherwise, check current rights for the URI

    return CheckOpenRightsL( aUri, aCheckViewRights );

    }

//============================================================================

// ConsumeRightsL

//============================================================================    

EXPORT_C TBool CGlxDRMUtility::ConsumeRightsL(const TDesC& aUri)

    {

    TRACER("CGlxDRMUtility::ConsumeRightsL()");

    TVirtualPathPtr path( aUri, KDefaultContentObject() );

    // Create a CData object to read the content

    // Tell the agent we are planning to display the content

    CData* data = CData::NewLC(path, ContentAccess::EView, EContentShareReadOnly);

    // When consuming rights for a URI, clear stored URI

    TPtr oldPtr = iLastConsumedItemUri->Des();

    oldPtr.Zero();

    iLastConsumedItemUri = iLastConsumedItemUri->ReAllocL( aUri.Length() );

    // Execute the intent, tell the agent that we plan to display the content

    // It is at this point that any stateful rights will be decremented

    TInt err = data->ExecuteIntent(ContentAccess::EView);

    if ( err == KErrNone )

        {

        // Update stored URI

        TPtr newPtr = iLastConsumedItemUri->Des();

        newPtr.Copy( aUri );

        }

    CleanupStack::PopAndDestroy(data);

    return (err == KErrNone);

    }

//============================================================================

// Test whether a media item is OMA DRM 2.0 protected and has an associated

// info URL.

//============================================================================

EXPORT_C TBool CGlxDRMUtility::CanShowInfoOnlineL(TDesC& aUri)

    {

    TRACER("CGlxDRMUtility::CanShowInfoOnlineL()");

    TBool canShowInfoOnline = EFalse;

    HBufC8* urlBuf = NULL;

    canShowInfoOnline = iDrmHelper->HasInfoUrlL(aUri, urlBuf);

    // discard buf we don't need it

    delete urlBuf;

    return canShowInfoOnline;

    }

//============================================================================

// Open the associated info URL for a media item in the browser.

//============================================================================

EXPORT_C void CGlxDRMUtility::ShowInfoOnlineL(TDesC& aUri)

    {

    TRACER("CGlxDRMUtility::ShowInfoOnlineL()");

    iDrmHelper->OpenInfoUrlL(aUri);

    }

//============================================================================

// Test whether a media item can be set as automated content.

//============================================================================

EXPORT_C TBool CGlxDRMUtility::CanSetAsAutomatedL(const TDesC& aUri, 

                                    TGlxDrmAutomatedType aType)

    {

    TRACER("CGlxDRMUtility::CanSetAsAutomatedL()");

    TBool canSetAutomated = EFalse;

    switch(aType)

        {

    case EGlxDrmAutomatedTypeWallpaper:

        {

        User::LeaveIfError(iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper));

        User::LeaveIfError(iDrmHelper->CanSetAutomated(aUri, canSetAutomated));

        break;

        }

    default:

        break;

        };

    return canSetAutomated;

    }

//============================================================================

// SetAsAutomatedL

//============================================================================

EXPORT_C void CGlxDRMUtility::SetAsAutomatedL(const TDesC& aUri, 

                                    TGlxDrmAutomatedType aType)

    {

    TRACER("CGlxDRMUtility::SetAsAutomatedL()");

     switch(aType)

        {

    case EGlxDrmAutomatedTypeWallpaper:

        {

        TInt error = iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);

        if(KErrNone==error)

            {

            error= iDrmHelper->SetAutomatedPassive(aUri);

            if(KErrNone!=error)

                {

                iDrmHelper->HandleErrorL(error, aUri);

                }

            }

        break;

        }

    default:

        break;

        };

    }

//============================================================================

// ShowDRMDetailsPane

//============================================================================  

EXPORT_C void CGlxDRMUtility::ShowDRMDetailsPaneL( const TDesC& aUri )

    {

    TRACER("CGlxDRMUtility::ShowDRMDetailsPaneL()");

    TRAPD( err, iDrmHelper->LaunchDetailsViewEmbeddedL( aUri ) );

    // if no rights ask user to re-activate?

    if( err == KErrCANoRights )

        {

        HBufC* buf = aUri.AllocLC();

        iDrmHelper->ActivateContentL( *buf );        

        CleanupStack::PopAndDestroy( buf );

        }

    }

//============================================================================

// IsForwardLockedL

//============================================================================  

EXPORT_C TBool CGlxDRMUtility::IsForwardLockedL(const TDesC& aUri)

    {

    TRACER("CGlxDRMUtility::IsForwardLockedL()");

    TBool forwardLocked = EFalse;

    TVirtualPathPtr path( aUri, KDefaultContentObject() );

    // forwardLocked is not updated if an error occurs

    iCManager->GetAttribute( ContentAccess::EIsForwardable, forwardLocked, path );

    return forwardLocked;

    }

//============================================================================

// ShowRightsInfoL

//============================================================================    

EXPORT_C void CGlxDRMUtility::ShowRightsInfoL(const TDesC& aUri)    

    {

    TRACER("CGlxDRMUtility::ShowRightsInfoL()");

    iDrmHelper->CheckRightsAmountL( aUri );

    }

//============================================================================

// Return size for DRM thumbnail request.

//============================================================================

EXPORT_C TSize CGlxDRMUtility::DRMThumbnailSize(TSize& aSize)

    {

    TRACER("CGlxDRMUtility::DRMThumbnailSize()");

    TSize thumbnailSize(KGlxDRMThumbnailWidth, KGlxDRMThumbnailHeight);

    if((aSize.iWidth*aSize.iHeight)/4 < 

            KGlxDRMThumbnailWidth * KGlxDRMThumbnailHeight)

        {

        thumbnailSize.iWidth = aSize.iWidth/2;

        thumbnailSize.iHeight = aSize.iHeight/2;

        }

    return thumbnailSize;

    }

/**

 * C++ default constructor.

 */

CGlxDRMUtility::CGlxDRMUtility()

    {

    TRACER("CGlxDRMUtility::CGlxDRMUtility()");

    }

/**

 * By default Symbian 2nd phase constructor is private.

 */

void CGlxDRMUtility::ConstructL()

    {

    TRACER("CGlxDRMUtility::ConstructL()");

    iCManager = ContentAccess::CManager::NewL();

    iDrmHelper = CDRMHelper::NewL();

    iLastConsumedItemUri = HBufC::NewL(0);

    }

// End of File