/*

* Copyright (c) 2003-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:  Common utilities functions

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <Oma2Agent.h>

#include <DRMRightsManager.rsg>

#include <data_caging_path_literals.hrh>

#include <utf.h>

#include "DRMCommonUtilities.h"

#include "DRMRightsMgrApp.h"

#include "DRMUILogger.h"

#include "DRMRightsMgrAppUi.h"

#include "drmutilityinternaltypes.h"

// CONSTANTS

// ROM folder

_LIT( KDriveZ, "z:" );

// Private folder

_LIT( KPrivateFolder, "\\private" );

_LIT( KSystemFolder, "\\system" );

_LIT( KTempFolder, "\\temp" );

// Name of the MBM file containing icons

_LIT( KDRMUIMBMFile, "drmrightsmanager.mbm" );

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

//

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

// DRMCommonUtilities::ShowConfirmationQueryL

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

//

TBool DRMCommonUtilities::ShowConfirmationQueryL( const TInt aResourceId,

                                                  const TDesC& aString,

                                                  CCoeEnv* aLoaderEnv )

    {

    HBufC* stringNote = StringLoader::LoadLC( aResourceId, aString,

                                              aLoaderEnv );

    TBool retVal = ShowConfirmationQueryL( *stringNote );

    CleanupStack::PopAndDestroy( stringNote ); // stringNote

    return retVal;

    }

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

// DRMCommonUtilities::ShowConfirmationQueryL

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

//

TBool DRMCommonUtilities::ShowConfirmationQueryL( const TInt aResourceId,

                                                  CCoeEnv* aLoaderEnv )

    {

    HBufC* stringNote = StringLoader::LoadLC( aResourceId, aLoaderEnv );

    TBool retVal = ShowConfirmationQueryL( *stringNote );

    CleanupStack::PopAndDestroy( stringNote ); // stringNote

    return retVal;

    }

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

// DRMCommonUtilities::ShowConfirmationQueryL

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

//

TBool DRMCommonUtilities::ShowConfirmationQueryL( const TDesC& aPrompt )

    {

    CAknQueryDialog *queryDialog = CAknQueryDialog::NewL( CAknQueryDialog::ENoTone );

    return queryDialog->ExecuteLD( R_DRM_CONFIRMATION_QUERY, aPrompt ) != 0;

    }

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

// DRMCommonUtilities::ShowConfirmationNoteL

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

//

void DRMCommonUtilities::ShowConfirmationNoteL( const TInt aResourceId,

                                                const TDesC& aString,

                                                CCoeEnv* aLoaderEnv )

    {

    HBufC* stringNote = StringLoader::LoadLC( aResourceId, aString,

                                              aLoaderEnv );

    ShowConfirmationNoteL( *stringNote );

    CleanupStack::PopAndDestroy( stringNote ); // stringNote

    }

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

// DRMCommonUtilities::ShowConfirmationNoteL

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

//

void DRMCommonUtilities::ShowConfirmationNoteL( const TInt aResourceId,

                                                CCoeEnv* aLoaderEnv )

    {

    HBufC* stringNote = StringLoader::LoadLC( aResourceId, aLoaderEnv );

    ShowConfirmationNoteL( *stringNote );

    CleanupStack::PopAndDestroy( stringNote ); // stringNote

    }

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

// DRMCommonUtilities::ShowConfirmationNoteL

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

//

void DRMCommonUtilities::ShowConfirmationNoteL( const TDesC& aPrompt )

    {

    CAknConfirmationNote* confNote = new( ELeave )CAknConfirmationNote(

                                                                    ETrue );

    confNote->ExecuteLD( aPrompt );

    }

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

// DRMCommonUtilities::ShowConfirmationNoteL

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

//

void DRMCommonUtilities::ShowInformationNoteL( const TInt aResourceId,

                                               CCoeEnv* aLoaderEnv )

    {

    HBufC* stringLabel = StringLoader::LoadLC( aResourceId, aLoaderEnv );

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

    dialog->ExecuteLD( *stringLabel );

    CleanupStack::PopAndDestroy( stringLabel );   // stringLabel

    }

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

// DRMCommonUtilities::GetFutureActivationTime

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

//

TTime DRMCommonUtilities::GetFutureActivationTime( CDRMRights& aRights )

    {

    CDRMRightsConstraints* constraints = NULL;

    TTime playStartTime( Time::MaxTTime() );

    TTime displayStartTime( Time::MaxTTime() );

    TTime printStartTime( Time::MaxTTime() );

    TTime executeStartTime( Time::MaxTTime() );

    aRights.GetPlayRight( constraints );

    if ( constraints )

        {

        constraints->GetStartTime( playStartTime );

        delete constraints;

        constraints = NULL;

        }

    aRights.GetDisplayRight( constraints );

    if ( constraints )

        {

        constraints->GetStartTime( displayStartTime );

        delete constraints;

        constraints = NULL;

        }

    aRights.GetPrintRight( constraints );

    if ( constraints )

        {

        constraints->GetStartTime( printStartTime );

        delete constraints;

        constraints = NULL;

        }

    aRights.GetExecuteRight( constraints );

    if ( constraints )

        {

        constraints->GetStartTime( executeStartTime );

        delete constraints;

        constraints = NULL;

        }

    return ( Min( Min( playStartTime, displayStartTime ),

                  Min( printStartTime, executeStartTime ) ) );

    }

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

// DRMCommonUtilities::GetIconsFileName

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

//

void DRMCommonUtilities::GetIconsFileName( TDes& aIconsFileName )

    {

    aIconsFileName.Append( KDriveZ );

    aIconsFileName.Append( KDC_APP_BITMAP_DIR );

    aIconsFileName.Append( KDRMUIMBMFile );

    return;

    }

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

// DRMCommonUtilities::IsInPrivateFolderL

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

//

TBool DRMCommonUtilities::IsInPrivateFolderL( const TDesC& aContentPath )

    {

    TInt retval = EFalse;

    TParse path;

    User::LeaveIfError( path.Set( KNullDesC, &aContentPath, NULL ) );

    HBufC* driveBuf = HBufC::NewLC( KMaxFileName );

    TPtr driveAndPath( const_cast<TUint16*>( driveBuf->Ptr()), 0, KMaxFileName );

    driveAndPath = path.DriveAndPath();

    driveAndPath.LowerCase();

    retval = ( driveAndPath.Find( KPrivateFolder ) == path.Drive().Length() ||

               driveAndPath.Find( KSystemFolder ) == path.Drive().Length() ||

               driveAndPath.Find( KTempFolder ) == path.Drive().Length() );

    CleanupStack::PopAndDestroy( driveBuf );

    return retval;

    }

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

// DRMCommonUtilities::RightsIssuerUrlL

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

//

TInt DRMCommonUtilities::RightsIssuerUrlL( const TFileName& aFileName,

                                           HBufC*& aRightsIssuerURL )

    {

    TVirtualPathPtr virtualPath( aFileName, KDefaultContentObject );

    TBuf<KUrlMaxLen> rightsIssuer;

    TInt retval( KErrNone );

    CData* content = NULL;

    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 )

        {

        // Get value of rights-issuer header field

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

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

            {

            aRightsIssuerURL = rightsIssuer.AllocL();

            }

        else

            {

            delete aRightsIssuerURL;

            aRightsIssuerURL = NULL;

            retval = KErrNotFound;

            }

        }

    CleanupStack::PopAndDestroy( content );

    return retval;

    }

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

// DRMCommonUtilities::GetRightsStatus

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

//

TInt DRMCommonUtilities::GetRightsStatus( CDRMRights& aRights,

                                          CDRMRights::TExpiration& aExpir)

    {

    TUint32 constraintSpec = 0;

    CDRMRights::TRestriction restriction;

    TUint32 constType;

    TInt err = KErrNone;

    err = aRights.GetRightsInfo( constraintSpec, restriction, aExpir, constType );

    return err;

    }

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

// DRMCommonUtilities::ParseParametersAndStartL

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

//

void DRMCommonUtilities::ParseParametersAndStartL( TLex aLex,

                                                   TBool aStartEmbedded,

                                                   CDRMRightsMgrAppUi& aAppUi )

    {

    CArrayFixFlat<TPtrC>* params;       // array of parameters

    HBufC* url16( NULL );

    HBufC* fullName( NULL );

    TUint32 drmScheme( EDrmSchemeUnknownDrm );

    params = new( ELeave )CArrayFixFlat<TPtrC>( sizeof( TPtrC ) );

    CleanupStack::PushL( params );

    TChar ch;

    aLex.Mark();

    while ( !aLex.Eos() )                // Extract the parameters

        {

        ch = aLex.Get();

        if ( ch == '\x00' ) {

            aLex.UnGet();

            params->AppendL( aLex.MarkedToken() );

            aLex.Get();

            aLex.Mark();

            }

        }

    TInt startParam = KMaxTInt;

    // Parse the DRM Rights Manager launch parameter string. First parameter

    // indicates the launching type (embedded, stand alone, embedded with full

    // path name parameter or stand alone with full path name parameter), second

    // parameter is Local ID for OMA DRM file, third one is the content URI in

    // case of OMA DRM and full file path name in case of WM DRM, whereas the fourth

    // parameter indicates the DRM protection scheme of the file for which the

    // details view has been launched. The fifth parameter is the full file path in

    // case of an OMA DRM file.

    TLex lexStart ( params->At( 0 ) );

    // First parameter: type of operation to be performed

    User::LeaveIfError( lexStart.Val( startParam ) );

    if ( ( aStartEmbedded && ( startParam == EDrmLaunchParamEmbeddedHelper ||

        startParam == EDrmLaunchParamEmbeddedUtility ) ) ||

         ( !aStartEmbedded && ( startParam == EDrmLaunchParamStandAloneHelper ||

        startParam == EDrmLaunchParamStandAloneUtility ) ) )

        {

        TUint32 localID;

        TLex lexLocalID ( params->At( 1 ) );

        // Second parameter: LocalID

        User::LeaveIfError( lexLocalID.Val( localID, EDecimal ) );

        // Third parameter: Content URI

        HBufC8* contentURI = HBufC8::NewLC( params->At( 2 ).Length() );

        contentURI->Des().Copy( params->At( 2 ) );

        if ( params->Count() > 3 && ( startParam == EDrmLaunchParamEmbeddedUtility

            || startParam == EDrmLaunchParamStandAloneUtility ) )

            {

            // Fourth parameter: DRM protection scheme

            TLex lexDrmType( params->At( 3 ) );

            lexDrmType.Val( drmScheme, EDecimal );

            TParse parser;

            if ( drmScheme == EDrmSchemeWmDrm )

                {

                // We have a WM DRM file

                // Find out the file name and the item name and store them to

                // the file details.

                url16 = CnvUtfConverter::ConvertToUnicodeFromUtf8L(

                    contentURI->Des() );

                CleanupStack::PushL( url16 );

                if ( url16 )

                    {

                    // The received fourth parameter already has the

                    // full path name

                    aAppUi.SetSelectedItemFullName( url16->Des() );

                    User::LeaveIfError( parser.Set( url16->Des(), NULL, NULL ) );

                    // Get the file name and extension

                    aAppUi.SetSelectedItemName( parser.NameAndExt() );

                    }

                CleanupStack::PopAndDestroy( url16 );

                }

            // Fifth parameter: Full file path for OMA DRM

            if ( drmScheme == EDrmSchemeOmaDrm &&

                ( startParam == EDrmLaunchParamEmbeddedUtility ||

                startParam == EDrmLaunchParamStandAloneUtility ) )

                {

                // Find out the file name and the item name and store them to

                // the file details.

                fullName = HBufC::NewLC( params->At( 4 ).Length() );

                fullName->Des().Copy( params->At( 4 ) );

                aAppUi.SetSelectedItemFullName( fullName->Des() );

                User::LeaveIfError( parser.Set( fullName->Des(), NULL, NULL ) );

                // Get the file name and extension

                aAppUi.SetSelectedItemName( parser.NameAndExt() );

                CleanupStack::PopAndDestroy( fullName );

                }

            }

        else

            {

            // DRM Helper has launched DRM Rights Manager. Currently DRM Helper

            // blocks attempts to launch DRM Rights Manager for both the plain

            // and WM DRM content.

            drmScheme = EDrmSchemeOmaDrm;

            }

        aAppUi.StartOnlyForDetailsL( *contentURI, localID, aStartEmbedded,

            drmScheme );

        CleanupStack::PopAndDestroy( contentURI );

        }

    CleanupStack::PopAndDestroy( params );

    }

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

// DRMCommonUtilities::SplitPath

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

//

TPtrC DRMCommonUtilities::SplitPath( const TDesC& aFileName, TPtrC& aRestOfName )

    {

    TPtrC ptr( KNullDesC );

    TInt pos = aFileName.Locate('\\'); // first backslash

    TInt length = aFileName.Length();

    if ( pos != KErrNotFound && pos < length )

        {

        TInt totalPos = pos;

        TPtrC name1 = aFileName.Mid(totalPos + 1);

        pos = name1.Locate('\\'); // second backslash

        length = name1.Length();

        if ( pos != KErrNotFound && pos < length )

            {

            totalPos += pos + 1;

            TPtrC name2 = aFileName.Mid(totalPos + 1);

            pos = name2.Locate('\\'); // third backslash

            length = name2.Length();

            if ( pos != KErrNotFound && pos < length )

                {

                totalPos += pos + 1;

                aRestOfName.Set( aFileName.Mid( totalPos + 1, aFileName.Length() - 1 - totalPos ));

                // return the leftmost part of the filename up to third backslash

                return aFileName.Mid(0, totalPos + 1);

                }

            }

        }

    return ptr;

    }

// End of File