/*

* 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 <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:" );

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

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

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

    if ( charCode == EKeyEnter )

        // Default is to show details

        {

        TInt command = EDRMRightsManagerCmdAppViewDet;

        HandleCommandL( command );

        return EKeyWasConsumed;

        }

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

        || charCode == EKeyBackspace )

        {

        return EKeyWasConsumed;

        }

    return EKeyWasNotConsumed;

    }

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

// CDRMRightsMgrAppUi::HandleCommandL

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

//

void CDRMRightsMgrAppUi::HandleCommandL( TInt aCommand )

    {

    switch ( aCommand )

        {

        case EEikCmdExit:

        case EAknSoftkeyExit:

            {

            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 ) 

                {

                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;

    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 )

            {

            if ( aIsGroup )

                {

                aItemName = aFullName;

                }

            else

                {

                parse.Set( aFullName, NULL, NULL );

                aItemName = parse.NameAndExt();

                }

            }

        else if ( err == KErrNone )

            {

            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 )

            {

            // FL or CD content

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

                 buffer )

                {

                if ( aContentURI.Compare( *buffer ) != 0 ) //forward lock content?

                    {

                    // CD content

                    aListable = ETrue;

                    }

                delete buffer;

                }

            else

                {

                retval = KErrGeneral;

                }

            }

        else if (aContentURI.Left( 4 ).Compare( Kldf ) != 0) //local data file?

            {

            // SD or OMA DRM2 content

            // also rights issuer url existence SHOULD be checked but not possible here

            aListable = aSendable = ETrue;

            }

        }

    else

        {

        if ( ConeUtils::FileExists( aFileName ) )

            {

            TInt protection;

            CData* content = NULL;

            TVirtualPathPtr virtualPath( aFileName, KDefaultContentObject );

            TRAPD( r, content = CData::NewL( virtualPath, EPeek, EContentShareReadWrite ) );

            if ( r == KErrInUse )

                {

                content = CData::NewL( virtualPath, EPeek, EContentShareReadOnly );

                }

            else if ( r != KErrNone )

                {

                retval = r;

                }

            CleanupStack::PushL( content );

            if ( retval == KErrNone )

                {

                retval = content->GetAttribute( EDeliveryMethod, protection );

                if ( retval == KErrNone )

                    {

                    aListable = ( protection == EOmaDrm1ForwardLockDcf ||

                                  protection == EOmaDrm1CombinedDelivery ||

                                  protection == EOmaDrm1CombinedDeliveryDcf ||

                                  protection == EOmaDrm1SeparateDelivery ||

                                  protection == EOmaDrm2 );

                    if ( protection == EOmaDrm1SeparateDelivery ||

                         protection == EOmaDrm2 )

                        {

                        TBuf<KUrlMaxLen> rightsIssuer;

                        // Get rights issuer URL

                        retval = content->GetStringAttribute( ERightsIssuerUrl, rightsIssuer );

                        if ( ( retval == KErrNone ) && ( rightsIssuer.Length() > 0 ) )

                            {

                            aSendable = ETrue;

                            }

                        else

                            {

                            // Can't be sent, any error returned can be ignored

                            aSendable = EFalse;

                            retval = KErrNone;

                            }

                        }

                    }

                }

            CleanupStack::PopAndDestroy( content );

            }

        }

    return retval;

    }

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

// CDRMRightsMgrAppUi::DialogDismissedL

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

//

void CDRMRightsMgrAppUi::DialogDismissedL( TInt aButtonId )

    {

    if ( aButtonId == -1 )

        {

        // When pressing cancel button.

        // Only cancel if we know that there is an outstanding request

        if ( iStatusScan == EDRMStatusOpening ||

             iStatusScan == EDRMStatusOpeningEmbedded )

            {

            // Issue cancel to service provider

            iRightsClient.Cancel();

            if ( iStatusScan == EDRMStatusOpening )

                {

                // Cancel pressed when opening application --> Exit

                HandleCommandL( EEikCmdExit );

                }

            else if ( iStatusScan == EDRMStatusOpeningEmbedded )

                {

                // Cancel pressed when opening application embedded -->

                // Shut the app

                RunAppShutter();

                }

            }

        }

    }

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

// CDRMRightsMgrAppUi::HandleGainingForeground()

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

//

void CDRMRightsMgrAppUi::HandleGainingForeground()

    {

    // Refresh details view when the details view is returned

    // from the background to the foreground.

    if ( iForegroundHasBeenActive && iContentURI )

        {

        StartOnlyForDetailsL( iContentURI->Des(), iLocalID, 

            iStartEmbedded, iDrmScheme );

        }