/*

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

*

*/

// INCLUDE FILES

#include <DcfRep.h>

#include <DcfEntry.h>

#include <DRMCommon.h>

#include <DcfCommon.h>

#include <wmdrmagent.h> // for WMDRM file details view

#include <DRMRightsManager.rsg>

#include <AknWaitDialog.h>

#include <aknlistquerydialog.h>

#include <StringLoader.h>

#include <aknnavide.h>

#include <AknDef.h>

#include <barsread.h>  // for resource reader

#include <centralrepository.h>

#include <coeutils.h>

#include <eikserverapp.h>

#include <starterclient.h>

// character conversions

#include <utf.h>

// caf

#include <caf/data.h>

#include <caf/caftypes.h>

#include "DRMRightsMgrAppUi.h"

#include "DRMRightsMgrDetailsView.h"

#include "DRMRightsMgrDocument.h"

#include "DRMCommonUtilities.h"

#include "DRMUILogger.h"

#include "DRMRightsManagerPrivateCRKeys.h"

#include "DRMClockClient.h"

#include "drmutilityinternaltypes.h"

#include "Oma1Dcf.h"

#include "oma2dcf.h"

// CONSTANTS

_LIT8( Kflk, "flk:" );

_LIT8( Kldf, "ldf:" );

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

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

// DoResetAndDestroy

// Does RPointerArray< >->ResetAndDestroy() for the given array aPtr.

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

//

LOCAL_C void DoResetAndDestroyPermission( TAny* aPtr )

    {

    ( reinterpret_cast< RPointerArray< CDRMPermission >* >( aPtr ) )->

        ResetAndDestroy();

    }

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

// PrepareRightsObjectL

// Creates rights object based on the given permission.

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

//

LOCAL_C void PrepareRightsObjectL( CDRMRights*& aRights,

                                   CDRMPermission* aPermission )

    {

    CDRMAsset* asset( NULL );

    if ( !aPermission )

        {

        User::Leave( KErrArgument );

        }

    aRights = CDRMRights::NewL();

    CleanupStack::PushL( aRights );

    aRights->SetPermissionL( *aPermission );

    asset = CDRMAsset::NewLC();

    aRights->SetAssetL( *asset );

    CleanupStack::PopAndDestroy( asset );

    CleanupStack::Pop( aRights );

    // Content URI and Local Id are not set

    }

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

// EndTime

// Calculate the true end time: pick the smaller one of aTime1 & aTime2,

// but ignore Time::NullTTime anyhow.

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

//

LOCAL_C TTime EndTime( const TTime& aTime1, const TTime& aTime2 )

    {

    TTime nullTime = Time::NullTTime();

    if ( aTime1 == nullTime )

        {

        return aTime2;

        }

    if ( aTime2 == nullTime )

        {

        return aTime1;

        }

    return Min( aTime1, aTime2 );

    }

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

//

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

// CDRMRightsMgrAppUi::CDRMRightsMgrAppUi

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

//

CDRMRightsMgrAppUi::CDRMRightsMgrAppUi()

: iStartEmbedded( EFalse ),

  iStatusScan( EDRMStatusFinished ),

  iDrmScheme( EDrmSchemeUnknownDrm ),

  iLocalID( 0 ),

  iContentURI( NULL ),

  iForegroundHasBeenActive( EFalse )

    {

    CLOG_WRITE( "CDRMRightsMgrAppUi::CDRMRightsMgrAppUi" );

    }

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

// void CDRMRightsMgrAppUi::ConstructL

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

//

void CDRMRightsMgrAppUi::ConstructL()

    {

    CLOG_WRITE( "-->ConstructL" );

    iCoeEnv->AddForegroundObserverL( *this );

    CDRMRightsMgrDetailsView* detailsView( NULL );

    BaseConstructL( EAknEnableSkin | EAppOrientationAutomatic |

        EAknEnableMSK | EAknSingleClickCompatible  );

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

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

    iDRMCommon = DRMCommon::NewL();

    if ( !iDRMCommon )

        {

        ProcessEngineErrorL( ETrue );

        }

    iStartEmbedded = iEikonEnv->StartedAsServerApp();

    // Create details view

    if ( iStartEmbedded )

        {

        detailsView = CDRMRightsMgrDetailsView::NewLC( ETrue );

        }

    else

        {

        detailsView = CDRMRightsMgrDetailsView::NewLC( EFalse );

        }

    AddViewL( detailsView );      // transfer ownership to CAknViewAppUi

    CleanupStack::Pop( detailsView );

    }

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

// CDRMRightsMgrAppUi::~CDRMRightsMgrAppUi

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

//

CDRMRightsMgrAppUi::~CDRMRightsMgrAppUi()

    {

    iCoeEnv->RemoveForegroundObserver( *this );

    delete iWaitDialog;

    delete iDRMCommon;

    iRightsClient.Close();

    iClockClient.Close();

    if ( iStartEmbedded && iDoorObserver )

        {

        iDoorObserver->NotifyExit( MApaEmbeddedDocObserver::ENoChanges );

        }

    if ( iContentURI )

        {

        delete iContentURI;

        }

    }

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

// CDRMRightsMgrAppUi::HandleKeyEventL

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

//

TKeyResponse CDRMRightsMgrAppUi::HandleKeyEventL( const TKeyEvent& aKeyEvent,

                                                  TEventCode /*aType*/ )

    {

    TChar charCode( aKeyEvent.iCode );

        // Default is to show details

        {

        HandleCommandL( command );

        return EKeyWasConsumed;

        }

    else if ( charCode == EKeyLeftArrow || charCode == EKeyRightArrow

        || charCode == EKeyBackspace )

        {

        return EKeyWasConsumed;

        }

    return EKeyWasNotConsumed;

    }

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

// CDRMRightsMgrAppUi::HandleCommandL

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

//

void CDRMRightsMgrAppUi::HandleCommandL( TInt aCommand )

    {

    CEikAppServer* server = iEikonEnv->AppServer();

    switch ( aCommand )

        {

        case EEikCmdExit:

        case EAknSoftkeyExit:

            {

            Exit();

            break;

            }

        case EAknSoftkeyClose:

            {

            if (server)

                {

                server->NotifyServerExit(EAknSoftkeyClose);

                }

            Exit();

            break;

            }    

        default:

            break;

        }

    }

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

// CDRMRightsMgrAppUi::StartOnlyForDetailsL

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

//

void CDRMRightsMgrAppUi::StartOnlyForDetailsL( const TDesC8& aContentURI,

                                               const TUint32 aLocalID,

                                               const TBool aEmbedded,

                                               const TInt aDrmScheme )

    {

    // Store the content related information when the details view

    // is to be shown for the first time so that the information will be

    // available for details view refreshing in the future.

    if ( !iContentURI )

        {

        iDrmScheme = aDrmScheme;

        iLocalID = aLocalID;

        iContentURI = aContentURI.AllocL();

        }

    // For storing WM DRM rights information

    ContentAccess::RStreamablePtrArray<ContentAccess::CRightsInfo> array;

    CleanupClosePushL( array );

    TInt status( KErrCANoRights );

    CDRMRights* rights = NULL;

    if ( aEmbedded )

        {

        iStatusScan = EDRMStatusOpeningEmbedded;

        }

    else

        {

        iStatusScan = EDRMStatusOpening;

        }

    // Check the status of rights. Currently supports OMA and WM DRM.

    switch ( iDrmScheme )

        {

        case EDrmSchemeOmaDrm:

            CheckOmaDrmRightsL( aContentURI, aLocalID, rights, status );

            if ( status < 0 )

                {

                rights = NULL;

                }

            break;

        case EDrmSchemeWmDrm:

            CheckWmDrmRightsL( aContentURI, status, array );

            break;

        default:

            break;

        }

    TFileName itemName;

    TFileName fullName;

    // Find the name and full name for the current item

    SelectedItemName( itemName );

    SelectedItemFullName( fullName );

    TUid uidView = TUid::Uid( EDRMDetailsView );

    CDRMRightsMgrDetailsView* detailsView =

                                ( CDRMRightsMgrDetailsView* )View( uidView );

    if ( detailsView )

        {

        if ( !aEmbedded )

            {

            // If DRM Rights manager has not been launched as embedded,

            // activate details wiew as a local view.

            ActivateLocalViewL( uidView );

            }

            // Refresh the details view window with rights information of the

            // current item

            switch ( iDrmScheme )

                {

                case EDrmSchemeOmaDrm:

                    // Refresh the listbox

                    TRAP( status, detailsView->RefreshListBoxL( rights, itemName,

                        fullName, SelectedContentCanBeSent(), IndividualConstraint(),

                        UsageAllowed() ) );

                    break;

                case EDrmSchemeWmDrm:

                    // WM DRM, Refresh the listbox

                    TRAP( status, detailsView->RefreshListBoxL( array,

                        itemName, fullName ) );

                    break;

                default:

                    break;

                }

            if ( status != KErrNone )

                {

                // If there was an error, show to the user

                ProcessEngineErrorL( ETrue );

            }

        }

    if ( rights )

        {

        delete rights;

        }

    CleanupStack::PopAndDestroy( &array );

    }

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

// CDRMRightsMgrAppUi::CreateWaitDialogLC

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

//

void CDRMRightsMgrAppUi::CreateWaitDialogLC()

    {

    if ( iWaitDialog )

        {

        delete iWaitDialog;

        iWaitDialog = NULL;

        }

    // Create WaitDialog with message and Cancel button

    iWaitDialog = new( ELeave )CAknWaitDialog( ( REINTERPRET_CAST(

                                CEikDialog**, &iWaitDialog ) ), EFalse );

    iWaitDialog->SetCallback( this );

    iWaitDialog->PrepareLC( R_WAITNOTE );

    iWaitDialog->RunLD();

    }

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

// CDRMRightsMgrAppUi::GetItemNameL

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

//

void CDRMRightsMgrAppUi::GetItemNameL( const TDesC& aFullName,

                                       TDes& aItemName,

                                       const TDesC8& aID,

                                       const TBool aIsGroup )

    {

    CDcfCommon* dcf = NULL;

    HBufC8* buffer( NULL );

    TBool getName = ETrue;

    TParse parse;

    // don't get the name if dealing with a file from a group

    if ( !aIsGroup )

        {

        TRAPD( r, dcf = CDcfCommon::NewL( aFullName ) );

        if ( r == KErrNone &&

             dcf &&

             dcf->iVersion == EOma2Dcf &&

             static_cast<COma2Dcf*>( dcf )->iGroupId )

            {

            getName = EFalse;

            parse.Set( aFullName, NULL, NULL );

            aItemName = parse.NameAndExt();

            }

        delete dcf;

        }

    if ( getName )

        {

        HBufC* itemNameBuf = NULL;

        TInt err = iRightsClient.GetName( aID, itemNameBuf );

        if ( err == KErrNotFound || itemNameBuf->Length() == 0 )

            {

            // Do not show name if group rights or forward lock

            if ( !aIsGroup )

                {

                if ( ( iRightsClient.ForwardLockURI( buffer ) ==

                        KErrNone ) && buffer )

                    {

                    // Not forward lock

                    if ( aID.Compare( *buffer ) != 0 )

                        {

                        parse.Set( aFullName, NULL, NULL );

                        aItemName = parse.NameAndExt();

                        }

                    delete buffer;

                    buffer = NULL;

                    }

                else

                    {

                    parse.Set( aFullName, NULL, NULL );

                    aItemName = parse.NameAndExt();

                    }

                }

            }

        else if ( err == KErrNone )

            {

            // Forward lock or combined delivery

            // If forward lock, do not show name

            if ( iRightsClient.ForwardLockURI( buffer ) == KErrNone &&

                    buffer )

                {

                if ( aID.Compare( *buffer ) != 0 )

                    {

                    // Combined delivery

                    aItemName = *itemNameBuf;

                    }

                delete buffer;

                }

            else

                {

                // Do not show name if having group rights

                if ( !aIsGroup )

                    {

                    aItemName = *itemNameBuf;

                    }

                }

            }

        else

            {

            User::Leave( err );

            }

        if ( itemNameBuf )

            {

            delete itemNameBuf;

            }

        }

    }

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

// CDRMRightsMgrAppUi::GetItemDataL

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

//

TInt CDRMRightsMgrAppUi::GetItemDataL( const TDesC& aFileName,

                                       const TDesC8& aContentURI,

                                       TBool& aListable,

                                       TBool& aSendable )

    {

    TInt retval( KErrNone );

    aSendable = aListable = EFalse;

    HBufC8* buffer;

    if ( DRMCommonUtilities::IsInPrivateFolderL( aFileName ) )

        {

        if ( aContentURI.Left( 4 ).Compare( Kflk ) == 0 )