/*

* Copyright (c) 2003-2010 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:  Implementation of CDRMHelper class

*

*/

// INCLUDE FILES

#include "DRMHelper.h"

#include "DRMHelperGlobalNoteWrapper.h"

#include "DRMHelperInfoNoteWrapper.h"

#include "DRMRightsClient.h"

#include "DcfCommon.h"

#include "DRMHelperDownloadManager.h"

#include <sacls.h>

#include <Drmhelper.rsg>

#include <AknQueryDialog.h>

#include <DRMCommon.h>

#include <starterclient.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif

#include <StringLoader.h>

#include <eikproc.h> //CEikProcess

#include <eikdoc.h> //CEikDocument

#include <DocumentHandler.h> // KDRMErr*

#include <aknnotewrappers.h> // information note

#include <AknGlobalNote.h> // global info note

#include <DrmConstraint.h>

#include <stringresourcereader.h>

#include <apgcli.h>

#include <data_caging_path_literals.hrh>

#include <AiwGenericParam.h>

#include <DcfRep.h>

#include <DcfEntry.h>

#include <caf/caf.h>

#include <caf/cafplatform.h>

#include <AknLaunchAppService.h> // for launching RMUI embedded

#include <utf.h>

#include <schemehandler.h> // for handling URLs

#include "DRMHelperServer.h"

#include "ConsumeData.h"

#include "DRMTypes.h"

#include "DRMClockClient.h"

#include "DRMPointerArray.h"

#include <SecondaryDisplay/DRMHelperSecondaryDisplay.h> // for secondary display support

#include <AknMediatorFacade.h>

#include <MediatorEventProvider.h>

#include <MediatorDomainUIDs.h>

#include <featmgr.h>

#include "RoapStorageClient.h"

#include <centralrepository.h>

#include <e32property.h>

#ifdef RD_DRM_SILENT_RIGHTS_ACQUISITION

#include "drmsettingsplugininternalcrkeys.h"

#endif

#include "DRMRIContext.h"

#include "DRMDomainContext.h"

#include <cmconnectionmethod.h>

#include <cmdestination.h>

#include <cmconnectionmethoddef.h>

#include <cmmanager.h>

// publish & subrscibe

#include <e32property.h>

#include <PSVariables.h>

#ifdef __SERIES60_NATIVE_BROWSER

#include <browseruisdkcrkeys.h>

#endif

#ifndef __SERIES60_NATIVE_BROWSER

const TUid KCRUidBrowser   = {0x10008D39};

const TUint32 KBrowserDefaultAccessPoint =  0x0000000E;

const TUint32 KBrowserAccessPointSelectionMode = 0x0000001E;

#endif

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

#ifndef RD_MULTIPLE_DRIVE

_LIT( KDriveZ, "z:" );

#endif

_LIT( KCDRMHelperResFileName,"DRMHelper.rsc" );

_LIT( KEncryptedRightsIssuerMatchString, "flk*" );

_LIT( KDRMHelperClassificationRingingTone, "Ringtone" );

_LIT( KDRMHelperClassificationVideoTone, "Videotone" );

// masks for constaint existence

const TInt KDRMHelperConstraintCount = 1;

const TInt KDRMHelperConstraintTime = 2;

const TInt KDRMHelperConstraintAccumulated = 4;

// Buffer sizes

const TInt KDRMHelperMaxDateFormatLen = 30;

const TInt KDRMHelperMaxDateLen = 30;

const TInt KDRMHelperMaxTimeFormatLen = 30;

const TInt KDRMHelperMaxTimeLen = 30;

const TInt KUrlMaxLen = 1024;

const TInt KDRMHelperMaxETABufSize = 11;

// limit in minutes when start to display 'about to expire' notes for accumulated

// time content

#ifndef RD_DRM_REMOVAL_OF_EXPIRATION_WARNING_PROMPTS

const TInt KDRMHelperAccumulatedTimeLimit = 15;

#endif // RD_DRM_REMOVAL_OF_EXPIRATION_WARNING_PROMPTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================ auto_handde helper class =======================

//Auto handle for easening handle release on exceptional exit situations

template<typename T> class auto_handle

    {

public:

    auto_handle() {}

    auto_handle(T aHandle) : iHandle( aHandle ) {}

    auto_handle( auto_handle<T>& aHandle) : iHandle( aHandle.release() ) {}

    ~auto_handle() { iHandle.Close(); }

    const T& operator()() const { return iHandle; }

    T& operator()() { return iHandle; }

    T get() const { return iHandle; }

    T release() { T temp = iHandle; iHandle = 0; return temp; }

private:

    T iHandle;

    };

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// IapIdOfDefaultSnapL

// for trapping purposes only

// -----------------------------------------------------------------------------

//

LOCAL_C TUint32 IapIdOfDefaultSnapL(

    RCmManager& aCmManager,

    const TUint32 aDefaultSnap )

    {

    RCmDestination dest( aCmManager.DestinationL( aDefaultSnap ) );

    CleanupClosePushL( dest );

    TUint32 iapIdOfDest( 0 );

    if ( dest.ConnectionMethodCount() <= 0 )

        {

        User::Leave( KErrNotFound );

        }

    RCmConnectionMethod cMeth( dest.ConnectionMethodL( 0 ) );

    CleanupClosePushL( cMeth );

    iapIdOfDest = cMeth.GetIntAttributeL( CMManager::ECmIapId );

    CleanupStack::PopAndDestroy( &cMeth );

    CleanupStack::PopAndDestroy( &dest );

    return iapIdOfDest;

    }

// -----------------------------------------------------------------------------

// Creates note for resource text to be viewed,

// Defaults to information note.

// -----------------------------------------------------------------------------

LOCAL_C CAknResourceNoteDialog* CreateNoteForResourceL( TInt aResId )

    {

    CAknResourceNoteDialog* r( NULL );

    switch (aResId)

        {

        case R_DRM_ERR_OPENING_FAIL_PERM:

            r = new ( ELeave ) CAknErrorNote( ETrue );

            break;

        case R_DRM_WARN_NO_CONN_DEFINED:

        case R_DRM_WARN_INVALID_OR_NO_AP:

            r = new  ( ELeave ) CAknWarningNote( ETrue );

            break;

        default:

            r = new ( ELeave ) CAknInformationNote( ETrue );

            break;

        }

    return r;

    }

// -----------------------------------------------------------------------------

// Returns note type for globan note to be viewed.

// Defaults to information note.

// -----------------------------------------------------------------------------

LOCAL_C TAknGlobalNoteType GlobalNoteTypeForResource( TInt aResId )

    {

    TAknGlobalNoteType t( EAknGlobalInformationNote );

    switch (aResId)

        {

        case R_DRM_ERR_OPENING_FAIL_PERM:

            t = EAknGlobalErrorNote;

            break;

        case R_DRM_WARN_NO_CONN_DEFINED:

        case R_DRM_WARN_INVALID_OR_NO_AP:

            t = EAknGlobalWarningNote;

            break;

        default:

            break;

        }

    return t;

    }

// -----------------------------------------------------------------------------

// LeaveIfWrongReturnForHandleErrorOrPreviewL

// Leaves if error code under test (argument aError) does match those documented

// for HandleErrorOrPreviewL

// -----------------------------------------------------------------------------

LOCAL_C void LeaveIfWrongReturnForHandleErrorOrPreviewL( TInt aError )

    {

    switch ( aError )

        {

        case KErrNone:

        case KErrCancel:

        case KErrCANoRights:

        case KErrCANoPermission:

        case KErrCompletion:

            break;

        default:

            User::Leave( aError );

        }

    }

// -----------------------------------------------------------------------------

// Checks whether given media type is video type

// -----------------------------------------------------------------------------

LOCAL_C TBool IsVideo(const CData* aData)

    {

    TPtr mimeDes( NULL, 0);

    TBool ret( EFalse );

    HBufC* mimeType( HBufC::New( KMaxDataTypeLength ) );

    if ( !mimeType )

        {

        return ret;

        }

    mimeDes.Set( mimeType->Des() );

    //Note mime types borrowed from CDRMHelper::Intent

    _LIT( KDRMHelperMimeTypeVideo, "Video" );

    _LIT( KDRMHelperMimeTypeShockwave, "Application/x-shockwave-flash" );

    _LIT( KDRMHelperMimeTypeRealMedia, "Application/x-pn-realmedia" );

    _LIT( KDRMHelperMimeTypeVndRealMedia, "Application/vnd.rn-realmedia" );

    if ( aData->GetStringAttribute( EMimeType, mimeDes ) == KErrNone )

        {

        ret = !mimeDes.FindF( KDRMHelperMimeTypeShockwave ) ||

            !mimeDes.FindF( KDRMHelperMimeTypeRealMedia ) ||

            !mimeDes.FindF( KDRMHelperMimeTypeVndRealMedia ) ||

            !mimeDes.FindF( KDRMHelperMimeTypeVideo );

        }

    delete mimeType;

    return ret;

    }

// ---------------------------------------------------------

// Evaluate media type for preview playback

// ---------------------------------------------------------

#ifdef RD_DRM_PREVIEW_RIGHT_FOR_AUDIO

LOCAL_C TInt EvaluatePreviewMediaType( CData* aContent )

    {

    TInt theType( -1 );

    _LIT( KDRMHelperMimeTypeAudio, "Audio" );

    HBufC* mimeType( HBufC::New( KMaxDataTypeLength ) );

    if ( !mimeType )

        {

        return theType;

        }

    TPtr ptr = mimeType->Des();

    TInt error = aContent->GetStringAttribute( EMimeType, ptr );

    if ( IsVideo( aContent ) )

        {

        theType = EPreviewTypeVideo;

        }

    else if ( !ptr.FindF( KDRMHelperMimeTypeAudio ) )

        {

        theType = EPreviewTypeAudio;

        }

    delete mimeType;

    return theType;

    }

#endif

#pragma mark -

// -----------------------------------------------------------------------------

//

// Functions related to WMDRM protection check

//

// -----------------------------------------------------------------------------

// Some magic constants

static const TInt KMinContentLength( 16 );

_LIT8( KWrmHeader, "W\0R\0M\0H\0E\0A\0D\0E\0R\0" );

_LIT8( KASFHeaderObject, "75B22630668E11CFA6D900AA0062CE6C" );

// -----------------------------------------------------------------------------

// FormatGUID

// -----------------------------------------------------------------------------

LOCAL_C void FormatGUID( TDes8 &aGUID )

    {

    TBuf8<16> copyGUID(aGUID);

    TInt i;

    for (i = 0; i < 4; i++)

        {

        copyGUID[i] = aGUID[3 - i];

        }

    for (i = 4; i < 6; i++)

        {

        copyGUID[i] = aGUID[9 - i];

        }

    for (i = 6; i < 8; i++)

        {

        copyGUID[i] = aGUID[13 - i];

        }

    for (i = 8; i < 16 ; i++)

        {

        copyGUID[i] = aGUID[i];

        }

    aGUID.Delete(0, 32);

    for (i = 0; i <16; i++)

        {

        aGUID.AppendNumFixedWidthUC(copyGUID[i], EHex, 2);

        }

    }

// -----------------------------------------------------------------------------

// ConvertToInt64

// -----------------------------------------------------------------------------

LOCAL_C TInt64 ConvertToInt64( TDesC8& aDes )

    {

    TInt64 num = 0;

    TInt i;

    for (i = 7 ; i >= 0; i--)

        {

        num <<= 8;

        num |= aDes[i];

        }

    return num;

    }

// -----------------------------------------------------------------------------

// IsProtectedWmDrmL

// returns ETrue, if file is protected WMDRM file

//         EFalse if file is not protected WMDRM file

// Leaves with KErrUnderflow if file has too little data to decide

//         whether WmDrm or not

//         may also leave with other system wide error code

// -----------------------------------------------------------------------------

LOCAL_C TBool IsProtectedWmDrmL( RFile& aFileHandle )

    {

    TInt r( KErrNone );

    HBufC8* buffer( NULL );

    TInt pos( 0 );

    RFile file;

    TBuf8< 32 > header;

    TInt64 headerSize( 0 );

    TBool isProtectedWmDrm( EFalse );

    TPtr8 headerPtr( NULL, 0 );

    // Leave if given handle is invalid

    if ( !aFileHandle.SubSessionHandle() )

        {

        User::Leave( KErrBadHandle );

        }

    User::LeaveIfError( file.Duplicate( aFileHandle ) );

    CleanupClosePushL( file );

    User::LeaveIfError( file.Seek( ESeekStart, pos ) );

    // Check if the file is an ASF file

    User::LeaveIfError( file.Read( 0, header, KMinContentLength ) );

    if ( header.Length() < KMinContentLength )

        {

        User::Leave( KErrUnderflow );

        }

    FormatGUID( header );

    if ( header == KASFHeaderObject )

        {

        // It's ASF, check still whether it's WM DRM protected or not

        file.Read( header,8 );

        headerSize = ConvertToInt64( header );

        if ( headerSize <= 30 )

            {

            User::Leave( KErrUnderflow );

            }

        if ( headerSize > ( ( KMaxTInt32 / 2 ) - 1 ) )

            {

            User::Leave( KErrOverflow );

            }

        buffer = HBufC8::NewLC( headerSize );

        headerPtr.Set( buffer->Des() );

        User::LeaveIfError( file.Read( headerPtr, headerSize - 24 ) );

        r = headerPtr.Find( KWrmHeader );

        if ( r != KErrNotFound )

            {

            isProtectedWmDrm = ETrue;

            }

        CleanupStack::PopAndDestroy( buffer );

        }

    CleanupStack::PopAndDestroy( &file );

    return isProtectedWmDrm;

    }

#pragma mark -

// -----------------------------------------------------------------------------

//

// End of Functions related to WMDRM protection check

//

// -----------------------------------------------------------------------------

// ---------------------------------------------------------

// UpdateDCFRepositoryL()

// Update saved file to DCFRepository

// ---------------------------------------------------------

LOCAL_C void UpdateDCFRepositoryL( const RFile& aFileHandle )

    {

    TFileName fullName;

    aFileHandle.FullName( fullName );

    CDcfEntry* dcfEntry = NULL;

    dcfEntry = CDcfEntry::NewL();

    CleanupStack::PushL( dcfEntry );

    CDcfRep* dcfRep = NULL;

    dcfRep = CDcfRep::NewL();

    CleanupStack::PushL( dcfRep );

    dcfEntry->SetLocationL( fullName, 0 );

    dcfRep->UpdateL( dcfEntry );

    CleanupStack::PopAndDestroy( dcfRep );

    CleanupStack::PopAndDestroy( dcfEntry );

    }

#pragma mark -

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

// -----------------------------------------------------------------------------

// CDRMHelperRightsConstraints::CDRMHelperRightsConstraints

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CDRMHelperRightsConstraints::CDRMHelperRightsConstraints(

    CDRMRightsConstraints* aConstraints )

    {

    iConstraints = aConstraints;

    }

// -----------------------------------------------------------------------------

// CDRMHelperRightsConstraints::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CDRMHelperRightsConstraints::ConstructL()

    {

    }

// -----------------------------------------------------------------------------

// CDRMHelperRightsConstraints::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CDRMHelperRightsConstraints* CDRMHelperRightsConstraints::NewLC(

    CDRMRightsConstraints* aConstraints )

    {

    CleanupStack::PushL( aConstraints );

    CDRMHelperRightsConstraints* self =

        new (ELeave) CDRMHelperRightsConstraints( aConstraints );

    CleanupStack::Pop( aConstraints );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }