/*

 * Copyright (c) 2006-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 UI Handling implementation class

 *

 */

// INCLUDE FILES

// connection

#include <cmconnectionmethod.h>

#include <cmdestination.h>

#include <cmconnectionmethoddef.h>

#include <cmmanager.h>

#include <sacls.h>

#include <utf.h>

// publish & subscribe

#include <e32property.h>

#include <psvariables.h>

#include <centralrepository.h>

// coeenv

#include <coemain.h>

#include <apgtask.h>

#include <avkon.hrh>

#include <aknenv.h>

// browser

#ifdef __SERIES60_NATIVE_BROWSER

#include <browseruisdkcrkeys.h>

#endif

// caf

#include <caf/data.h>

#include <caf/caftypes.h>

// launching embedded details view

#include <aknlaunchappservice.h>

#include <aiwgenericparam.h>

#include <apgcli.h>

// character conversions

#include <utf.h>

// handling urls

#include <schemehandler.h>

// resources

#include <data_caging_path_literals.hrh>

#include <drmutility.rsg>

// drm

#include <oma2agent.h>

#include <drmagents.h>

#include <drmpermission.h>

#include <drmconstraint.h>

#include <drmrightsclient.h>

#include <drmutility.h>

#include <drmutilitytypes.h>

#include <drmasyncobserver.h>

#include <drmhandleerrorobserver.h>

#ifdef _DEBUG

#include <e32debug.h>

#endif

#include "drmutilitycommon.h"

#include "drmutilityui.h"

#include "drmuihandlingimpl.h"

#include "drmuihandlingdata.h"

#include "drmutilitydownloadmanager.h"

#include "drmutilityinternaltypes.h"

#include "drmuicheckrightsobserver.h"

#include "drmutilitywmdrm.h"

#include "drmutilitywmdrmwrapper.h"

#include "roapstorageclient.h"

#include "drmtypes.h"

#include "drmsettingsplugininternalcrkeys.h"

#include "drmricontext.h"

#include "drmdomaincontext.h"

#include "drmutilityinternalcrkeys.h"      // Cenrep extension for OmaBased

// CONSTANTS

const TInt KCommandHandleErrorFile( 1 );

const TInt KCommandHandleErrorData( 2 );

const TInt KCommandCheckRightsAmountFile( 3 );

const TInt KCommandCheckRightsAmountData( 4 );

const TInt KCommandShowDetailsViewFile( 5 );

const TInt KCommandShowDetailsViewData( 6 );

const TInt KCommandHandleUrlFile( 7 );

const TInt KCommandHandleUrlData( 8 );

const TInt KCommandAvailableUrlsFile( 9 );

const TInt KCommandAvailableUrlsData( 10 );

// browser

#ifndef __SERIES60_NATIVE_BROWSER

const TUid KCRUidBrowser =

    {0x10008D39};

const TUint32 KBrowserDefaultAccessPoint = 0x0000000E;

const TUint32 KBrowserAccessPointSelectionMode = 0x0000001E;

const TUint32 KBrowserNGDefaultSnapId = 0x00000053;

#endif

_LIT( KEncryptedRightsIssuerMatchString, "flk*" );

// buffer sizes

const TInt KDRMMaxETABufSize( 11 );

const TInt KUrlMaxLen( 1024 );

const TInt KIntegerMaxLen( 10 );

// constant sizes

const TInt KOmaDomainGenerationLength( 3 );

// masks for constraint existence

const TInt KDRMOmaConstraintCount( 1 );

const TInt KDRMOmaConstraintTime( 2 );

const TInt KDRMOmaConstraintAccumulated( 4 );

const TInt KCenRepDataLength( 50 );

const TInt KresOmaBasedBuf( 512 );

const TInt KNameBuf( 256 );

#ifdef _DEBUG

// debug panic

_LIT( KDRMUtilityDebugPanicMessage, "DrmUiHandlingDebugPanic" );

const TInt KDRMUtilityDebugPanicCode( 1 );

#endif

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

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

// MapToCallError

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

//

LOCAL_C inline TInt CheckAndMapToCallError(

    RDRMRightsClient& aOmaClient,

    ContentAccess::TIntent aIntent,

    const TDesC8& aContentUri )

    {

    TUint32 rr( KErrNone );

    TInt err( aOmaClient.CheckRights( aIntent, aContentUri, rr ) );

    return err ? KErrCANoRights : KErrNone;

    }

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

// 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;

    }

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

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

// CDrmUiHandlingImpl::CDrmUiHandlingImpl

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

// might leave.

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

//

DRM::CDrmUiHandlingImpl::CDrmUiHandlingImpl(

    DRM::CDrmUtility* aDrmUtility,

    CCoeEnv* aCoeEnv ) :

    CActive( EPriorityStandard ), iCoeEnv( aCoeEnv ), iDrmUtility(

        aDrmUtility )

    {

    }

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

// CDrmUiHandlingImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void DRM::CDrmUiHandlingImpl::ConstructL()

    {

    TInt err( KErrNone );

    iDrmUtilityCommon = DRM::CDrmUtilityCommon::NewL();

    iDrmUtilityUi = DRM::CDrmUtilityUI::NewL( iCoeEnv );

    User::LeaveIfError( iOmaClient.Connect() );

    User::LeaveIfError( iSemaphore.CreateLocal( 1 ) );

        TRAP_IGNORE( iWrapperLoader = DRM::CDrmUtilityWMDrm::NewL( iCoeEnv ) );

    if ( iWrapperLoader )

        {

        iWmClient = iWrapperLoader->GetWrapper();

        }

        TRAP(err, GetOmaBasedInfoL() );

    if ( err )

        {

        if ( iOmaBasedAgentName )

            {

            delete iOmaBasedAgentName;

            }

        iOmaBasedAgentName = NULL;

        iOmaBasedUid = 0;

        if ( iOmaBasedMimeType )

            {

            delete iOmaBasedMimeType;

            }

        iOmaBasedMimeType = NULL;

        }

    }

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

// CDrmUiHandlingImpl::GetOmaBasedInfoL

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

//

void DRM::CDrmUiHandlingImpl::GetOmaBasedInfoL()

    {

    TInt err = KErrNone;

    CRepository* repository( NULL );

    RBuf bOmaBasedAgentName;

    RBuf bOmaBasedMimeType;

    CleanupClosePushL( bOmaBasedAgentName );

    CleanupClosePushL( bOmaBasedMimeType );

    bOmaBasedAgentName.CreateL( KCenRepDataLength );

    bOmaBasedMimeType.CreateL( KCenRepDataLength );

        TRAP( err, repository = CRepository::NewL( KCRUidOmaBased ) );

    if ( !err )

        {

        CleanupStack::PushL( repository );

        err = repository->Get( KDrmOmaBasedName, bOmaBasedAgentName );

        if ( !err )

            {

            iOmaBasedAgentName = bOmaBasedAgentName.AllocL();

            }

        err = repository->Get( KDrmOmaBasedUID, iOmaBasedUid );

        err = repository->Get( KOmaBasedMimeType, bOmaBasedMimeType );

        if ( !err )

            {

            iOmaBasedMimeType = CnvUtfConverter::ConvertFromUnicodeToUtf8L(

                bOmaBasedMimeType );

            }

        CleanupStack::PopAndDestroy( repository );

        }

    CleanupStack::PopAndDestroy( 2, &bOmaBasedAgentName );

    User::LeaveIfError( err );

    }

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

// CDrmUiHandlingImpl::NewL

// Two-phased constructor.

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

//

EXPORT_C DRM::CDrmUiHandlingImpl* DRM::CDrmUiHandlingImpl::NewL(

    DRM::CDrmUtility* aDrmUtility,

    CCoeEnv* aCoeEnv )

    {

    DRM::CDrmUiHandlingImpl* self( NewLC( aDrmUtility, aCoeEnv ) );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDrmUiHandlingImpl::NewLC

// Two-phased constructor.

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

//

EXPORT_C DRM::CDrmUiHandlingImpl* DRM::CDrmUiHandlingImpl::NewLC(

    DRM::CDrmUtility* aDrmUtility,

    CCoeEnv* aCoeEnv )

    {

    DRM::CDrmUiHandlingImpl* self( new ( ELeave ) CDrmUiHandlingImpl(

        aDrmUtility, aCoeEnv ) );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CDrmUiHandlingImpl::~CDrmUiHandlingImpl()

// Destructor

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

//

DRM::CDrmUiHandlingImpl::~CDrmUiHandlingImpl()

    {

    DRM::CDrmUiHandlingData* data( PopFront() );

    // Empty the queue:

    while ( data )

        {

        // Complete the outstanding requestest with cancel

        data->iObserver->OperationCompleted( data->iOperationId, KErrCancel );

        delete data;

        data = PopFront();

        }

    delete iDrmUtilityCommon;

    delete iDrmUtilityUi;

    delete iSchemeHandler;

    delete iWrapperLoader;

    delete iOmaBasedAgentName;

    delete iOmaBasedMimeType;

    iOmaClient.Close();

    // Close the semaphone

    iSemaphore.Close();

    // Remove the object from active scheduler etc.

    if ( IsAdded() )

        {

        Deque();

        }

    }

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

// CDrmUiHandlingImpl::CheckRightsAmountAsyncL

// Check how much rights there are left for the content.

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

//

EXPORT_C TInt DRM::CDrmUiHandlingImpl::CheckRightsAmountAsyncL(

    RFile& aFile,

    ContentAccess::TIntent aIntent,

    DRM::MDrmUiCheckRightsObserver& aObserver )

    {

    TRequestStatus* status( &iStatus );

    // Create data object:

    DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );

    data->iObserver = &aObserver;

    data->iOperationId = reinterpret_cast<TInt> ( data );

    data->iOperation = KCommandCheckRightsAmountFile;

    data->iFile = &aFile;

    data->iIntent = aIntent;

    data->iCheckRightsObserver = &aObserver;

    // Add it to the queue:

    AppendToQueue( data );

    // Pop it from the cleanup stack

    CleanupStack::Pop( data );

    Activate( status );

    return data->iOperationId;

    }

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

// CDrmUiHandlingImpl::CheckRightsAmountL

// Check how much rights there are left for the content.

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

//

EXPORT_C void DRM::CDrmUiHandlingImpl::CheckRightsAmountL(

    RFile& aFile,

    ContentAccess::TIntent aIntent,

    DRM::MDrmUiCheckRightsObserver* aObserver )

    {

    DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );

    data->iOperationId = 0; // operation id zero for a syncronous operation

    data->iFile = &aFile;

    data->iIntent = aIntent;

    data->iCheckRightsObserver = aObserver;

    PerformCheckRightsAmountFileL( *data );

    CleanupStack::PopAndDestroy( data );

    }

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

// CDrmUiHandlingImpl::CheckRightsAmountAsyncL

// Check how much rights there are left for the content.

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

//

EXPORT_C TInt DRM::CDrmUiHandlingImpl::CheckRightsAmountAsyncL(

    ContentAccess::CData& aFile,

    ContentAccess::TIntent aIntent,

    DRM::MDrmUiCheckRightsObserver& aObserver )

    {

    TRequestStatus* status( &iStatus );

    // create data object:

    DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );

    data->iObserver = &aObserver;

    data->iOperationId = reinterpret_cast<TInt> ( data );

    data->iOperation = KCommandCheckRightsAmountData;

    data->iFileData = &aFile;

    data->iIntent = aIntent;

    data->iCheckRightsObserver = &aObserver;

    // Add it to the queue:

    AppendToQueue( data );

    // Pop it from the cleanup stack

    CleanupStack::Pop( data );

    Activate( status );

    return data->iOperationId;

    }

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

// CDrmUiHandlingImpl::CheckRightsAmountL

// Check how much rights there are left for the content.

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

//

EXPORT_C void DRM::CDrmUiHandlingImpl::CheckRightsAmountL(

    ContentAccess::CData& aFile,

    ContentAccess::TIntent aIntent,

    DRM::MDrmUiCheckRightsObserver* aObserver )

    {

    DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );

    data->iOperationId = 0; // operation id zero for a syncronous operation

    data->iFileData = &aFile;

    data->iIntent = aIntent;

    data->iCheckRightsObserver = aObserver;

    PerformCheckRightsAmountDataL( *data );

    CleanupStack::PopAndDestroy( data );

    }

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

// CDrmUiHandlingImpl::ShowDetailsViewAsyncL

// Shows DRM specific details

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

//

EXPORT_C TInt DRM::CDrmUiHandlingImpl::ShowDetailsViewAsyncL(

    RFile& aFile,

    DRM::MDrmAsyncObserver& aObserver )

    {

    TRequestStatus* status( &iStatus );

    // create data object:

    DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );

    data->iObserver = &aObserver;

    data->iOperationId = reinterpret_cast<TInt> ( data );

    data->iOperation = KCommandShowDetailsViewFile;

    data->iFile = &aFile;

    // Add it to the queue:

    AppendToQueue( data );

    // Pop it from the cleanup stack

    CleanupStack::Pop( data );

    Activate( status );

    return data->iOperationId;

    }

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

// CDrmUiHandlingImpl::ShowDetailsViewL

// Shows DRM specific details

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

//

EXPORT_C void DRM::CDrmUiHandlingImpl::ShowDetailsViewL( RFile& aFile )

    {

    DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );

    data->iOperationId = 0; // operation id zero for a syncronous operation

    data->iFile = &aFile;

    PerformShowDetailsViewFileL( *data );

    CleanupStack::PopAndDestroy( data );

    }

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

// CDrmUiHandlingImpl::ShowDetailsViewAsyncL

// Shows DRM specific details

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

//

EXPORT_C TInt DRM::CDrmUiHandlingImpl::ShowDetailsViewAsyncL(

    ContentAccess::CData& aFile,

    DRM::MDrmAsyncObserver& aObserver )

    {

    TRequestStatus* status( &iStatus );

    // create data object:

    DRM::CDrmUiHandlingData* data( DRM::CDrmUiHandlingData::NewLC() );

    data->iObserver = &aObserver;

    data->iOperationId = reinterpret_cast<TInt> ( data );