/*

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

 *

 */

// INCLUDE FILES

// publish & subscribe

#include <e32property.h>

#include <PSVariables.h>

#include <centralrepository.h>

// coeenv

#include <coemain.h>

#include <apgtask.h>

#include <avkon.hrh>

#include <aknenv.h>

// caf

#include <caf/data.h>

#include <caf/caftypes.h>

// launching embedded details view

#include <AknLaunchAppService.h>

#include <AiwGenericParam.h>

#include <apgcli.h>

// DCF repository

#include <DcfRep.h>

#include <DcfEntry.h>

// character conversions

#include <utf.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>

#include <drmbrowserlauncher.h>

//connectivity logic

#include <cmconnectionmethod.h> // RCmConnectionMethod

#include <cmdestination.h> // RCmDestination

#include <cmmanager.h> // RCmManager

#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

#include "drmuidialogids.h"

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

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

const TInt KNoValue = -1;

#ifdef _DEBUG

// debug panic

_LIT( KDRMUtilityDebugPanicMessage, "DrmUiHandlingDebugPanic" );

const TInt KDRMUtilityDebugPanicCode( 1 );

#endif

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

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

// HasDefaultConnectionL

// Finds default IAP id

// @return Etrue: valid AP found

//         EFalse: valid AP not found

// @leave system wide error codes

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

//

LOCAL_C TBool HasDefaultConnectionL()

    {

    TBool hasDefault(EFalse);

    TCmDefConnValue defConn;

    RCmManager cmManager;

    cmManager.OpenLC();

    cmManager.ReadDefConnL(defConn);

    if (defConn.iType == ECmDefConnConnectionMethod)

        {

        cmManager.GetConnectionMethodInfoIntL(defConn.iId,

                CMManager::ECmIapId);

        hasDefault = ETrue;

        }

    else if (defConn.iType == ECmDefConnDestination)

        {

        RCmDestination dest(cmManager.DestinationL(defConn.iId));

        CleanupClosePushL(dest);

        if (dest.ConnectionMethodCount() <= 0)

            {

            User::Leave(KErrNotFound);

            }

        RCmConnectionMethod cMeth(dest.ConnectionMethodL(0));

        CleanupClosePushL(cMeth);

        cMeth.GetIntAttributeL(CMManager::ECmIapId);

        CleanupStack::PopAndDestroy(&cMeth);

        CleanupStack::PopAndDestroy(&dest);

        hasDefault = ETrue;

        }

    CleanupStack::PopAndDestroy(&cmManager);

    return hasDefault;

    }

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

// HasAccessPointsL

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

//

LOCAL_C TBool HasAccessPointsL()

    {

    TInt apCount(0);

    RCmManager cmManager;

    CleanupClosePushL(cmManager);

    cmManager.OpenL();

    RArray<TUint32> aps;

    CleanupClosePushL(aps);

    cmManager.ConnectionMethodL(aps, EFalse, EFalse, ETrue);

    apCount = aps.Count();

    CleanupStack::PopAndDestroy(2, &cmManager); //aps, cmManager

    return apCount > 0;

    }

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

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

    }

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

// HasDefConn

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

//

inline TBool HasDefConn()

    {

    TBool found( EFalse );

    TRAP_IGNORE( found = HasDefaultConnectionL() );

    return found;

    }

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

// UpdateDCFRepositoryL()

// Update saved file to DCFRepository

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

LOCAL_C void UpdateDCFRepositoryL( TDesC& aFullFileName )

    {

    CDcfEntry* dcfEntry( NULL );

    CDcfRep* dcfRep( NULL );

    dcfEntry = CDcfEntry::NewL();

    CleanupStack::PushL( dcfEntry );

    dcfRep = CDcfRep::NewL();

    CleanupStack::PushL( dcfRep );

    dcfEntry->SetLocationL( aFullFileName, 0 );

    dcfRep->UpdateL( dcfEntry );

    CleanupStack::PopAndDestroy( dcfRep );

    CleanupStack::PopAndDestroy( dcfEntry );

    }

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

// FindFullFileNameAndUpdateDCFRepositoryL()

// Find full file name for the content and update saved 

// file to DCFRepository

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

LOCAL_C void FindFullFileNameAndUpdateDCFRepositoryL(

    const RFile& aFileHandle )

    {

    HBufC* fullPath( NULL );

    TPtr fullPathPtr( NULL, 0 );

    fullPath = HBufC::NewLC( KUrlMaxLen );

    fullPathPtr.Set( fullPath->Des() );

    aFileHandle.FullName( fullPathPtr );

    UpdateDCFRepositoryL( fullPathPtr );

    CleanupStack::PopAndDestroy( fullPath );

    }

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

// FindFullFileNameAndUpdateDCFRepositoryL()

// Find full file name for the content and update saved 

// file to DCFRepository

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

LOCAL_C void FindFullFileNameAndUpdateDCFRepositoryL(

    const ContentAccess::CData& aFileData  )

    {

    HBufC* fullPath( NULL );

    TPtr fullPathPtr( NULL, 0 );

    fullPath = HBufC::NewLC( KUrlMaxLen );

    fullPathPtr.Set( fullPath->Des() );

    aFileData.GetStringAttribute( DRM::EDrmFullName, 

        fullPathPtr );

    UpdateDCFRepositoryL( fullPathPtr );

    CleanupStack::PopAndDestroy( fullPath );    

    }

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

    }