/*

* Copyright (c) 2006 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:  Helper utility for Common UI

*

*/

// INCLUDE FILES

#include <coeutils.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <AknWaitDialog.h>

#include <AknProgressDialog.h>

#include <AknCommonDialogs.h>

#include <CAknFileNamePromptDialog.h>

#include <centralrepository.h>

#include <AknsUtils.h>

#include <AknIconArray.h>

#include <barsread.h>

#include <StringLoader.h>

#include <AknUtils.h>

#include <bautils.h>

#include <eikapp.h>

#include <cprofiletonehandler.h>

#include <pathinfo.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif // RD_MULTIPLE_DRIVE

#include <MProfileEngine.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h>

#include <data_caging_path_literals.hrh>

#include <caf/caferr.h>

#include <sysutil.h>

#include <textresolver.h>

#include <aknnotewrappers.h>

#include <mpxmedia.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediaarray.h>

#include <mpxcommonui.rsg>

#include <mpxcommonui.mbg>

#include <mpx.rsg>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionpath.h> // TMPXItemId

#include <mpxcollectionutility.h>

#include <mpxcollectionplugin.hrh>

#include <mpxuser.h>

#include <AknGlobalNote.h>

// Cover UI start

//#ifdef __COVER_DISPLAY

#include <aknSDData.h>

#include <AknMediatorFacade.h>

#include <mplayersecondarydisplayapi.h>

#include <featmgr.h>

//#endif

// Cover UI end

#include <mpxconstants.h>

#include "mpxfilenamequerydlg.h"

#include "mpxcommonui.hrh"

#include "mpxtlshelper.h"

#include "mpxcommonuihelper.h"

#include "mpxdrmuihelper.h"

#include "mpxinternalcrkeys.h"

#include "mpxlog.h"

// CONSTANTS

const TInt KMPXOneSecInMicroSecs( 1000000 );

const TInt KMPXOneMinInSeconds( 60 );

const TInt KMPXOneHourInSeconds( 3600 );

const TInt KMPXOneDayInSeconds( 86400 );

const TInt KMPXOneHundredHoursInSecs( 360000 );

const TInt KMPXDurationDisplayResvLen( 10 );

const TInt KMPXDecimalPlaces ( 1 );

const TInt KMPXWidthOfChar ( 10 );

const TInt KMPXMaxBufferLen ( 160 );

const TInt KMPXMaxPlaylistPathLen ( 200 );

const TInt KMPXPlaylistinfoLen ( 300 );

const TInt KMPXStandAloneProcessIDTop32( 1 );

const TInt KMPXStandAloneProcessIDBottom32( 2 );

const TReal KMPXOneKB ( 1024 );

const TReal KMPXOneMB ( 1048576 );

const TReal KMPXOneGB ( 1073741824 );

const TText KRightToLeftMark = 0x200F;

const TInt KMPXChunkSize = 100;  // number of songs added in each chunk, IncAddL

const TInt KSQLErrGeneral = -311; // SQL General error. Don't want to include sql header here

_LIT( KMPXCommonUiRscPath, "mpxcommonui.rsc" );

_LIT( KMPXAddToPlaylistMemoryCardIcon, "\t0");

_LIT( KMPXCommonUiIconFile, "mpxcommonui.mbm" );

_LIT( KMPXAppUiRscPath, "mpx.rsc" );

// autonaming format

_LIT( KAutoNamingFormat, "%S(%S)");

#ifndef RD_MULTIPLE_DRIVE

_LIT( KDriveFormatString, ":\\" );

#endif // RD_MULTIPLE_DRIVE

_LIT( KAutoNumberFormat, "%u");

_LIT( KAutoNumberPaddedFormat, "%+02u");

_LIT( KWildCardCharacter, "*");

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

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

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

// might leave.

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

//

CMPXCommonUiHelper::CMPXCommonUiHelper(MMPXCollectionUtility* aCollectionUtility)

    : iCollectionUtility(aCollectionUtility)

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXCommonUiHelper::ConstructL()

    {

    CCoeEnv* coeEnv = CEikonEnv::Static();

    TParse parse;

    parse.Set( KMPXCommonUiRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resourceFile( parse.FullName() );

    User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );

    BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    TParse appUiparse;

    appUiparse.Set( KMPXAppUiRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName appUiResourceFile( appUiparse.FullName() );

    User::LeaveIfError( MPXUser::CompleteWithDllPath( appUiResourceFile ) );

    BaflUtils::NearestLanguageFile( coeEnv->FsSession(), appUiResourceFile );

    iAppUiResourceOffset = coeEnv->AddResourceFileL( appUiResourceFile );

    iMpxDrmHelper = CMPXDrmUiHelper::NewL( this );

//#ifdef __COVER_DISPLAY

    if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )

        {

        iCoverDisplay = ETrue;

        }

    else

        {

        iCoverDisplay = EFalse;

        }

//#endif // __COVER_DISPLAY

    }

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

// Two-phased constructor.

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

//

EXPORT_C CMPXCommonUiHelper* CMPXCommonUiHelper::NewL(MMPXCollectionUtility* aCollectionUtility)

    {

    CMPXCommonUiHelper* self = new ( ELeave ) CMPXCommonUiHelper(aCollectionUtility);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//

CMPXCommonUiHelper::~CMPXCommonUiHelper()

    {

    if ( iCollectionUiHelper )

        {

        iCollectionUiHelper->Close();

        }

    if ( iWaitDialog )

        {

        iWaitDialog->SetCallback( NULL );

        TRAP_IGNORE( iWaitDialog->ProcessFinishedL() );

        }

    if ( iResourceOffset )

        {

        CEikonEnv::Static()->DeleteResourceFile( iResourceOffset );

        }

    if ( iAppUiResourceOffset )

        {

        CEikonEnv::Static()->DeleteResourceFile( iAppUiResourceOffset );

        }

    delete iMpxDrmHelper;

    }

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

// Check if the host application is messaging or browser

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

//

EXPORT_C TBool CMPXCommonUiHelper::IsHostMessagingBrowserL()

    {

    return ( IsHostMessagingL() || IsHostBrowserL() );

    }

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

// Check if the host application is messaging

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

//

EXPORT_C TBool CMPXCommonUiHelper::IsHostMessagingL()

    {

    TBool ret( EFalse );

    TInt hostUid = MPXTlsHelper::HostUid().iUid;

    if ( hostUid == KMPXMmsViewerUid || hostUid == KMPXMmsEditorUid ||

         hostUid == KMPXMailViewerUid || hostUid == KMPXMailEditorUid ||

         hostUid == KMPXMessagingUid || hostUid == KMPXUniEditorUid )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// Check if the host application is browser

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

//

EXPORT_C TBool CMPXCommonUiHelper::IsHostBrowserL()

    {

    TBool ret( EFalse );

    TInt hostUid = MPXTlsHelper::HostUid().iUid;

    if ( hostUid == KMPXBrowserUid || hostUid == KMPXBrowserUid2 ) // browser

        {

        ret = ETrue;

        }

    return ret;

    }

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

// Check if the host application is Podcasting Application

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

//

EXPORT_C TBool CMPXCommonUiHelper::IsHostPodcastingAppL()

    {

    return MPXTlsHelper::HostUid().iUid == KPodcastingAppUid;

    }

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

// Convert to displayable duration.

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

//

EXPORT_C HBufC* CMPXCommonUiHelper::DisplayableDurationL(

    TInt64 aDuration,

    TMPXDuratDisplayMode aMode )

    {

    TInt resId;

    HBufC* format = NULL;

    if ( aDuration >= KMPXOneHundredHoursInSecs )

        {

        resId = R_MPX_TIME_DURAT_HHHMMSS_WITH_ZERO;

        format = StringLoader::LoadLC(

            resId, aDuration / KMPXOneHourInSeconds );

        }

    else

        {

        resId = R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO;

        if ( ( aMode == EMPXDuratHMS ) ||

            ( aDuration >= KMPXOneHourInSeconds ) )

            {

            resId = R_QTN_TIME_DURAT_LONG_WITH_ZERO;

            }

        format = StringLoader::LoadLC( resId );

        }

    // Convert total playing time to texts.

    TTime durTime( aDuration * KMPXOneSecInMicroSecs );

    HBufC* buf =

        HBufC::NewLC( format->Length() + KMPXDurationDisplayResvLen );

    TPtr bufTPtr( buf->Des() );

    durTime.FormatL( bufTPtr, *format );

    AknTextUtils::LanguageSpecificNumberConversion( bufTPtr );

    CleanupStack::Pop( buf );

    CleanupStack::PopAndDestroy( format );

    return buf;

    }

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

// Convert to displayable duration in text format.

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

//

EXPORT_C HBufC* CMPXCommonUiHelper::DisplayableDurationInTextL(

    TInt64 aDuration )

    {

    HBufC* buf = NULL;

    TInt days = I64INT( aDuration / KMPXOneDayInSeconds );

    TInt hours =

        I64INT( ( aDuration % KMPXOneDayInSeconds ) /

            KMPXOneHourInSeconds );

    TInt mins =

        I64INT( ( aDuration % KMPXOneHourInSeconds ) /

            KMPXOneMinInSeconds );

    TInt secs = I64INT( aDuration % KMPXOneMinInSeconds );

    CArrayFix< TInt >* intArray =

        new ( ELeave ) CArrayFixFlat<TInt>( 2 );  // magic number

    CleanupStack::PushL( intArray );

    if ( days > 1 && ( hours == 0 || hours > 1 ) )

        {

        intArray->AppendL( days );

        intArray->AppendL( hours );

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_DAYS_HRS_TEXT, *intArray );

        }

    else if ( days > 1 && hours == 1 )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_DAYS_HR_TEXT, days );

        }

    else if ( days == 1 && ( hours == 0 || hours > 1 ) )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_DAY_HRS_TEXT, hours );

        }

    else if ( days == 1 && hours == 1 )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_DAY_HR_TEXT );

        }

    else if ( hours > 1 &&  ( mins == 0 || mins > 1 ) )

        {

        intArray->AppendL( hours );

        intArray->AppendL( mins );

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_HRS_MINS_TEXT, *intArray );

        }

    else if ( hours > 1 && mins == 1 )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_HRS_MIN_TEXT, hours );

        }

    else if ( hours == 1 && ( mins == 0 || mins > 1 ) )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_HR_MINS_TEXT, mins );

        }

    else if ( hours == 1 && mins == 1 )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_HR_MIN_TEXT );

        }

    else if ( mins > 1 && ( secs == 0 || secs > 1 ) )

        {

        intArray->AppendL( mins );

        intArray->AppendL( secs );

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_MINS_SECS_TEXT, *intArray );

        }

    else if ( mins > 1 && secs == 1 )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_MINS_SEC_TEXT, mins );

        }

    else if ( mins == 1 && ( secs == 0 || secs > 1 ) )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_MIN_SECS_TEXT, secs );

        }

    else if ( mins == 1 && secs == 1 )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_MIN_SEC_TEXT );

        }

    else if ( secs > 1 )

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_SECS_TEXT, secs );

        }

    else

        {

        buf = StringLoader::LoadLC( R_MPX_CUI_TIME_SEC_TEXT );

        }

    TPtr bufPtr = buf->Des();

    AknTextUtils::LanguageSpecificNumberConversion( bufPtr );

    CleanupStack::Pop( buf );

    CleanupStack::PopAndDestroy( intArray );

    return buf;

    }

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

// Set current file as ringing tone.

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

//

EXPORT_C void CMPXCommonUiHelper::DoSetAsRingingToneL(

    const CMPXMedia& aMedia,

    TBool aSetToAllProfiles,

    TBool aShowQuery )

    {

    TInt rightsStatus( KErrNotFound );

    TBool canSetAutomated( EFalse );

    TBool okToSet( ETrue );

    TBool isProtected( EFalse );

    if ( aMedia.IsSupported ( KMPXMediaDrmProtected ) )

        {

        isProtected = aMedia.ValueTObjectL<TBool>( KMPXMediaDrmProtected );

        }

    if ( isProtected )

        {

        if ( aMedia.IsSupported ( KMPXMediaDrmRightsStatus ) )

            {

            rightsStatus = aMedia.ValueTObjectL<TInt>( KMPXMediaDrmRightsStatus );

            }

        if ( aMedia.IsSupported ( KMPXMediaDrmCanSetAutomated ) )

            {

            canSetAutomated = aMedia.ValueTObjectL<TBool>( KMPXMediaDrmCanSetAutomated );

            }

        }

    if ( ( !isProtected ) || ( rightsStatus == EMPXDrmRightsFull )

        || ( canSetAutomated ) )

        {

        if ( aShowQuery && aSetToAllProfiles )

            {

            // Show query only if set ringtone to all profiles and needed

            CAknQueryDialog* query =

                CAknQueryDialog::NewL( CAknQueryDialog::EConfirmationTone );

            okToSet = query->ExecuteLD(

                R_MPX_CHANGE_RT_FOR_ALL_CONFIRMATION_QUERY );

            }

        if ( okToSet )

            {

            TInt error( KErrNone );

            TInt leaveError( KErrNone );

            CProfileToneHandler* toneHandler = CProfileToneHandler::NewLC();

            if ( aSetToAllProfiles )

                {

                MPX_TRAP( leaveError, error = toneHandler->SetToneForAllProfilesL(

                        EProfileRingingToneSetting,

                        aMedia.ValueText( KMPXMediaGeneralUri ) ) );

                }

            else

                {

                MPX_TRAP( leaveError, error = toneHandler->SetActiveProfileRingingToneL(

                        aMedia.ValueText( KMPXMediaGeneralUri ) ) );

                }

            if ( leaveError != KErrNone )

                {

                error = leaveError;

                }

            CleanupStack::PopAndDestroy( toneHandler );

            if ( KErrNone == error && !aSetToAllProfiles )

                {

                HBufC* text = StringLoader::LoadLC(

                    R_MPX_RINGTONE_SET_TEXT, aMedia.ValueText(

                        KMPXMediaGeneralTitle ) );

                DisplayConfirmNoteL( *text );

                CleanupStack::PopAndDestroy( text );

                }

            else if ( KErrPermissionDenied == error )

                {

                DisplayInfoNoteL( R_MPX_RINGTONE_UNPROTECTED_FILE_TEXT );

                }

            else if ( KErrArgument == error ||

                      KErrAccessDenied == error )

                {

                DisplayInfoNoteL( R_MPX_RINGTONE_NOT_ALLOWED_TEXT );

                }

            else if ( KErrNotFound == error )

                {

                DisplayInfoNoteL( R_MPX_FILE_NOT_FOUND_TEXT );

                }

            else

                {

                // do nothing

                }

            }

        }

    else

        {

        DisplayInfoNoteL( R_MPX_DRM_PREV_RIGHTS_SET );

        }

    }

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

// Check if current profile mode is offline mode.

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

//

EXPORT_C TBool CMPXCommonUiHelper::IsProfileOfflineModeL()

    {

    TBool isOfflineMode( EFalse );

    MProfileEngine* profileEngine;

    profileEngine = CreateProfileEngineL();

    if ( profileEngine->ActiveProfileId() == EProfileOffLineId )

        {

        isOfflineMode = ETrue;

        }

    profileEngine->Release();

    return isOfflineMode;

    }

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

// Returns a path of the default drive used for saving playlists, ringtones,

// downloads and attachments.

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

//

EXPORT_C HBufC* CMPXCommonUiHelper::DefaultDriveLC()

    {

#ifdef RD_MULTIPLE_DRIVE

    // Use an internal mass storage drive as the default drive. If no internal

    // drive (other than the phone memory) exists, use an external drive.

    // Otherwise use the phone memory.