/*

* Copyright (c) 2002-2007 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: 

*           Phonebook 2 DRM manager.

*

*/

// INCLUDE FILES

#include "CPbk2DrmManager.h"

// Phonebook 2

// System includes

#include <featmgr.h>

#include <DRMCommon.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <apgcli.h>                     // RApaLsSession

#include <musicplayerdomaincrkeys.h>    // KCRUidMusicPlayerFeatures

#include <centralrepository.h>

#include <DRMHelper.h>

#include <coemain.h>

#ifdef RD_DRM_COMMON_INTERFACE_FOR_OMA_AND_WMDRM

#include <drmutility.h>

#include <drmagents.h>

#endif

/// Unnamed namespace for local definitions

namespace {

_LIT(KSpaceTxt, " ");

} /// namespace

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

// CPbk2DrmManager::CPbk2DrmManager

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

//

CPbk2DrmManager::CPbk2DrmManager() :

        iDrmEnabled( EFalse )

    {

    }

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

// CPbk2DrmManager::~CPbk2DrmManager

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

//

EXPORT_C CPbk2DrmManager::~CPbk2DrmManager()

    {

    if ( iDrmClient )

        {

        iDrmClient->Disconnect();

        }

    delete iDrmClient;

    delete iDrmHelper;

    delete iMusicPlayerFeatures;

    FeatureManager::UnInitializeLib();

    }

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

// CPbk2DrmManager::NewL

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

//

EXPORT_C CPbk2DrmManager* CPbk2DrmManager::NewL()

    {

    CPbk2DrmManager* self = new ( ELeave ) CPbk2DrmManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CPbk2DrmManager::ConstructL

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

//

void CPbk2DrmManager::ConstructL()

    {

    // Sets up TLS, must be done before FeatureManager is used

    FeatureManager::InitializeLibL();

    iDrmHelper = CDRMHelper::NewL();

    iDrmClient = DRMCommon::NewL();

    if ( iDrmClient->Connect() == DRMCommon::EOk )

        {

        // If unable to connect, DRM protection is always on

        iDrmEnabled = ETrue;

        }

    iMusicPlayerFeatures = CRepository::NewLC( KCRUidMusicPlayerFeatures );

    CleanupStack::Pop(); // iMusicPlayerFeatures

    }

#ifndef RD_DRM_COMMON_INTERFACE_FOR_OMA_AND_WMDRM

// Some magic constants

static const TInt KMinContentLength( 16 );

_LIT8( KContentProtectionType, "DRM" );

_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 );

        }

    file.Duplicate( aFileHandle );

    CleanupClosePushL( file );

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

    // Check if the file is an ASF file

    // TODO: Check on runtime wether WM DRM is supporeted or not

    //       Take Implementation from DRM::CDrmUtility::GetDrmInfoL,

    //       which is not yet available

    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 > KMaxTInt16 )

            {

            User::Leave( KErrOverflow );

            }

        buffer = HBufC8::NewLC( headerSize );

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

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

        r = headerPtr.Find( KContentProtectionType );

        if ( KErrNotFound != r )

            {

            isProtectedWmDrm = ETrue;

            }

        CleanupStack::PopAndDestroy( buffer ); // buffer

        }

        CleanupStack::PopAndDestroy(); // file

    return isProtectedWmDrm;

    }

#endif // RD_DRM_COMMON_INTERFACE_FOR_OMA_AND_WMDRM

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

// CPbk2DrmManager::IsFileWMDRMProtectedL

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

//

TBool CPbk2DrmManager::IsFileWMDRMProtectedL( const TDesC& aFileName,

											TBool& aIsProtected  ) const

	{

	TBool res = EFalse;

	RFs& fsSession( CCoeEnv::Static()->FsSession() );

	RFile hFile;

	TInt err = hFile.Open( fsSession, aFileName, 

						EFileRead | EFileStream | EFileShareReadersOnly );

	if( err == KErrInUse )

		{

		err = hFile.Open( fsSession, aFileName, 

						EFileRead | EFileStream | EFileShareAny );

		}

	if( err != KErrNone )

		{

		User::Leave( err );

		}

	CleanupClosePushL( hFile );

#ifdef RD_DRM_COMMON_INTERFACE_FOR_OMA_AND_WMDRM

	TPtrC agent( KNullDesC );

	DRM::CDrmUtility* drmUtil( DRM::CDrmUtility::NewLC() );

	drmUtil->GetAgentL( hFile, agent );

	if( agent.Compare( DRM::KDrmWMAgentName ) == 0 )

		{

		res = ETrue;

		}

	else

		{

		res = iDrmClient->IsProtectedFile( aFileName, aIsProtected );	

		}	

	CleanupStack::PopAndDestroy( drmUtil );

#else

	res = IsProtectedWmDrmL( hFile );

	aIsProtected = EFalse;

#endif

	CleanupStack::PopAndDestroy( &hFile );

	return res;

	}

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

// CPbk2DrmManager::IsProtectedFile

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

//

EXPORT_C TInt CPbk2DrmManager::IsProtectedFile(

        const TDesC& aFileName,

        TBool& aIsProtected )

    {

    aIsProtected = ETrue;

    const TBool drmSupported =

        ( FeatureManager::FeatureSupported( KFeatureIdDrm )||

          FeatureManager::FeatureSupported( KFeatureIdDrmFull ) );

    TInt drmErrorCode( KErrNone );

    if ( !drmSupported )

        {

        // No DRM support, file retrieval always ok

        aIsProtected = EFalse;

        }

    else if ( iDrmEnabled )

        {

        // Check is the file protected

		drmErrorCode = IsFileWMDRMProtectedL( aFileName,aIsProtected );

        }

    return drmErrorCode;

    }

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

// CPbk2DrmManager::IsRingingToneForbidden

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

//

EXPORT_C TInt CPbk2DrmManager::IsRingingToneForbidden( 

        const TDesC& aFileName,

        TBool& aIsProtected )

    {

    aIsProtected = ETrue;

    TInt error( KErrNone );

    const TBool drmSupported =

        ( FeatureManager::FeatureSupported( KFeatureIdDrm ) ||

          FeatureManager::FeatureSupported( KFeatureIdDrmFull ) );

    if ( !drmSupported )

        {

        // No DRM support, file retrieval always ok

        aIsProtected = EFalse;

        }

    else

        {

        // DRM is enabled. File must be checked

        error = IsProtectedFile( aFileName, aIsProtected );

        if ( error == KErrNone )

            {

            if ( aIsProtected )

                {

                TRAP( error, CheckProtectedFileL( aFileName, aIsProtected ) );

                }

            else

                {

                TRAP( error, CheckUnprotectedFileL( aFileName, aIsProtected ) );

                }

            }

         else

         	{

         	error = 0;

         	TRAP_IGNORE( ShowErrorNoteL( R_QTN_PHOB_PROTECTED_TONE ) );

         	}           

        }

    return error;       

    }

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

// CPbk2DrmManager::IsThumbnailForbidden

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

//

EXPORT_C TInt CPbk2DrmManager::IsThumbnailForbidden( 

        const TDesC& aFileName,

        TBool& aIsProtected )

    {

    aIsProtected = ETrue;

    TInt error = IsProtectedFile( aFileName, aIsProtected );

    // Thumbnails with any DRM protection are not allowed

    if ( error == KErrNone && aIsProtected )

        {

        TRAP_IGNORE( ShowErrorNoteL( R_PBK2_QTN_DRM_NOT_ALLOWED ) );

        }

    return error;

    }

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

// CPbk2DrmManager::ShowErrorNoteL

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

//

void CPbk2DrmManager::ShowErrorNoteL( TInt aResource )

    {

    CEikonEnv* env = CEikonEnv::Static();

    HBufC* noteText = StringLoader::LoadLC( aResource, env );

    // DRM notifications are shown as waiting information notes

    CAknInformationNote* note = new ( ELeave ) CAknInformationNote( ETrue );

    note->ExecuteLD( *noteText );

    CleanupStack::PopAndDestroy( noteText ); //noteText

    }

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

// CPbk2DrmManager::IsDrmRequiredForPlaybackL

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

//

TBool CPbk2DrmManager::IsDrmRequiredForPlaybackL()

    {

    // It is possible to disable support for non-DRM protected rich audio

    // formats    

    TInt value( 0 );

    User::LeaveIfError(

        iMusicPlayerFeatures->Get( KRequireDRMInPlayback, value ) );    

    return static_cast<TBool>( value );

    }

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

// CPbk2DrmManager::IsBlockedMimeTypeL

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

//

TBool CPbk2DrmManager::IsBlockedMimeTypeL( const TDesC& aMimeType )

    {

    TBool ret = EFalse;    

    TBuf<1> tmp; // Magic: 1 char to get length of actual value

    TInt realLen = 0;

    TInt err = iMusicPlayerFeatures->Get(

        KPlaybackRestrictedMimeTypes, tmp, realLen );

    if ( err == KErrOverflow )

        {

        // Prepare list of blocked MIME types

        HBufC* listBuf = HBufC::NewLC( realLen + KSpaceTxt().Length() );

        TPtr list = listBuf->Des();

        User::LeaveIfError(

            iMusicPlayerFeatures->Get

                ( KPlaybackRestrictedMimeTypes, list ) );

        list.Append( KSpaceTxt );

        // Prepare buffer for aMimeType

        HBufC* mimeBuf = HBufC::NewLC( aMimeType.Length() +

                                       KSpaceTxt().Length() );

        TPtr mime = mimeBuf->Des();

        mime = aMimeType;

        // FindF() would find "audio/3gpp" in "audio/3gpp2" without

        // the added space

        mime.Append( KSpaceTxt );

        // If result is not KErrNotFound, this MIME-type is indeed blocked

        ret = ( list.FindF( mime ) >= 0 );

        CleanupStack::PopAndDestroy(2); // listBuf, mimeBuf

        }

    else

        {

        User::LeaveIfError( err );

        }    

    return ret;

    }

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

// CPbk2DrmManager::CheckProtectedFileL

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

//

void CPbk2DrmManager::CheckProtectedFileL( 

        const TDesC& aFileName,

        TBool& aProtected )

    {

    aProtected = ETrue;

    TBool automatedOk(EFalse);

    // Check that file can be set as automated content.

    TInt err = iDrmHelper->CanSetAutomated( aFileName, automatedOk );

    if ( err==KErrNone )

        {

        if ( !automatedOk )

            {

            ShowErrorNoteL(R_QTN_PHOB_DRM_PREV_RIGHTS_SET);

            }

        else

            {

            DRMCommon::TContentProtection protection;

            HBufC8* mimeType = NULL; // ignored

            HBufC8* contentUri = NULL;

            TUint dataLength; // ignored

            err = iDrmClient->GetFileInfo( 

                    aFileName, protection, mimeType, contentUri, dataLength );

            delete mimeType;

            mimeType = NULL;

            if( err )

                {

                delete contentUri;

                User::Leave( err );

                }

            CDRMRights* rights = NULL;

            err = iDrmClient->GetActiveRights( 

                    *contentUri, DRMCommon::EPlay, rights );

            switch ( err )

                {

                case CDRMRights::EFullRights: // Fall through

                case CDRMRights::ERestrictedRights:

                    {

                    CDRMRights::TRestriction restriction; // ignore

                    CDRMRights::TExpiration expiration;

                    TUint32 constType;

                    // Ignore return value

                    rights->GetRightsInfo( 

                        DRMCommon::EPlay, restriction, expiration, constType );

                    // This is CFM protected file, ringingtone is set to "no"

                    if ( ( rights->GetPermission().iInfoBits & ENoRingingTone )

                        // This is normal DRM protected tone

                        || ( constType & ( CDRMRights::ECountBased |

                                           CDRMRights::ETimeIsAccumulatedTime ) ) )

                        {

                        ShowErrorNoteL( R_QTN_PHOB_DRM_PREV_RIGHTS_SET );

                        }

                    else

                        {

                        switch ( expiration )

                            {

                            case CDRMRights::EValidRights:

                                {

                                aProtected = EFalse;

                                break;

                                }

                            case CDRMRights::EFutureRights:

                                {

                                iDrmHelper->HandleErrorL( 

                                    DRMCommon::ENoRights, aFileName );

                                break;

                                }

                            case CDRMRights::EExpiredRights:

                                {