/*

* 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:  Application UI class required by AVKON application architecture.

*

*/

// INCLUDE FILES

#include <AknGlobalNote.h>

#include <avkon.hrh>

#include <apgwgnam.h>

#include <hlplch.h>

#include <e32base.h>

#include <e32property.h>

#include <eikproc.h>

#include <apacln.h>

#include <coeutils.h>

#include <StringLoader.h>

#include <textresolver.h>

#include <aknnotewrappers.h>

#include <AknTaskList.h>

#include <aknview.h>

#include <featmgr.h>

#include <centralrepository.h>

#include <settingsinternalcrkeys.h>

#include <ctsydomainpskeys.h>

#include <caf/caferr.h>

#include <eikapp.h>

#include <pathinfo.h>

#include <sysutil.h>

#include <apgcli.h>

#include <AknDlgShut.h>

#include <aknconsts.h>

#include <activeidle2domainpskeys.h>

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

#include <AiwGenericParam.h>

#endif

#include <mpxplaybackutility.h>

#include <mpxcollectionutility.h>

#include <mpxplaybackmessage.h>

#include <mpxviewutility.h>

#include <mpxmusicplayerviewplugin.hrh>

#include <mpx.rsg>

#include <mpxcollectionmessage.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionplugin.hrh>

#include <mpxmedia.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxcollectionuihelper.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxmediaarray.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediakeyhandler.h>

#include <mpxharvesterutility.h>

#include <mpxdrmmediautility.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionplugin.hrh>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

// Cover UI start

//#ifdef __COVER_DISPLAY

#include <aknSDData.h>

#include <AknMediatorFacade.h>

#include <MediatorCommandInitiator.h>

#include <MediatorDomainUIDs.h>

#include "mplayersecondarydisplayapi.h"

#include <featmgr.h>

//#endif

// Cover UI end

#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT 

#include "camesedrmhandler.h"

#endif 

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

#include <DocumentHandler.h>

#include <apmstd.h>

#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER

#include "mpxinternalcrkeys.h"

#include "mpxcommandhandler.h"

#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD

#include <AiwGenericParam.h>

#include "mpxPDcommandhandler.h"

#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD

#include "mpxcommonuihelper.h"

#include <mpxcommonui.rsg> //for R_MPX_FILE_NOT_FOUND_TEXT

#include "mpxappui.h"

#include "mpxcontroller.h"

#include "mpxrestorepath.h"

#include "mpxdocument.h"

#include "mpxtlshelper.h"

#include "mpxlog.h"

#include "mpxappui.hrh"

#include <mpxconstants.h>

#include <mpxviewpluginmanager.h>

#include <mpxviewplugin.h>

#include <iaupdate.h>

#include <iaupdateparameters.h>

#include <iaupdateresult.h>

// CONSTANTS

_LIT( KMPXLineChange, "\n" );

_LIT(KMPXMusicplayerPrivateFolder, "\\private\\");

_LIT(KMPXMusicPlayerExec, "mpx.exe" );

const TInt KMPXMusicPlayerAlreadySaved( -5000 );

// Application Uid for Active Idle app

#ifdef __ACTIVE_IDLE

const TUid KMPXUidIdleApp = { 0x101FD64C };

#else

const TUid KMPXUidIdleApp = KPSUidActiveIdle2; // use this one instead because the "aisystemuids.hrh" is not export

#endif

// MusicPlayer SIS Package UID

#define KMPXMusicPlayerSISPkgUid  0x101FFC62 

_LIT8( KMmMessage, "mm://musicsuite?action=exit" );

const TInt KMmUid3( 0x101f4cd2 );

// Granularity for ring tone mime types array

const TInt KMPXRingToneMimeTypesGranularity( 10 );

const TInt KMPXMinVolume( 0 );

const TInt KMPXMaxVolume(100);

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

_LIT8(KDataTypeRAM,"audio/x-pn-realaudio-plugin");

#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER

const TInt KMaxIntLen( 10 );

_LIT8( KMVPrefix, "MVviewID:" );

const TInt KMVPrefixLen( 9 );

const TUid  KLocalPlaybackUid = { 0x101FFC06 };

const TUid  KPhoneAppUid      = {0x100058B3};

const TInt  KWaitNoteImpUid   = 0x101FFC6C; // refresh wait note UID

const TInt KLowestMemoryNeeded = 5242880; //5 Mbytes

const TUid KCRUidMPXMPSettings = {0x101FFCDC};

const TUint32 KMPXMPPlaybackRandomMode = 0x0B;

const TUint32 KMPXMPPlaybackRepeatMode = 0x0C;

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

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

// C++ default constructor.

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

//

CMPXAppUi::CMPXAppUi()

    : iRingToneMimeTypes( KMPXRingToneMimeTypesGranularity ),

      iCurrentIndex( KErrNotFound ), iSaveMode( EMPXSaveModeIdle ),

      iStandAlone(EFalse),

      iMaxVolume(KMPXMaxVolume)

#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD

      ,iAppStartedByBrowser(EFalse)

      ,iPdPbvStartedByBrowser(EFalse)

      ,icollectionBrowsed(EFalse)

#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD

#ifdef FF_OOM_MONITOR2_COMPONENT   //__ENABLE_MPX_BUSYSETTING_FOR_OOM2

      ,iOomPriority( ROomMonitorSession::EOomPriorityNormal )

#endif //FF_OOM_MONITOR2_COMPONENT

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXAppUi::ConstructL()

    {

    MPX_FUNC( "CMPXAppUi::ConstructL" );

#ifndef __ENABLE_MSK

    BaseConstructL( EAknEnableSkin 

#ifdef SINGLE_CLICK_INCLUDED

    | EAknSingleClickCompatible

#endif

	);

#else

    BaseConstructL( EAknEnableSkin | EAknEnableMSK 

#ifdef SINGLE_CLICK_INCLUDED

    | EAknSingleClickCompatible

#endif

	);

#endif // __ENABLE_MSK

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

// Cover UI start

//#ifdef __COVER_DISPLAY

// initialize FeatureManager

    FeatureManager::InitializeLibL();

    if ( FeatureManager::FeatureSupported( KFeatureIdCoverDisplay ) )

        {

        iCoverDisplay = ETrue;

        iCommandInitiator = CMediatorCommandInitiator::NewL( NULL );

        }

    else

        {

        iCoverDisplay = EFalse;

        }

//#endif // __COVER_DISPLAY

// Cover UI end

    if ( MPXUser::IsCallOngoing( EPSCTsyCallTypeH324Multimedia ) )

        {

        HBufC* text =

            StringLoader::LoadLC( R_MPX_VIDEO_CALL_ONGOING );

        CAknGlobalNote* globalInfoNote = CAknGlobalNote::NewLC();

// Cover UI start

//#ifdef __COVER_DISPLAY

    if ( iCoverDisplay )

        {

        CAknSDData* sddata = CAknSDData::NewL(

            KMPlayerNoteCategory,

            EMPlayerNoteVideoCall,

            KNullDesC8);

        globalInfoNote->SetSecondaryDisplayData(sddata); // ownership transferred

        }

//#endif //__COVER_DISPLAY

// Cover UI end

        globalInfoNote->ShowNoteL(

            EAknGlobalInformationNote,

            text->Des() );

        CleanupStack::PopAndDestroy( globalInfoNote );

        CleanupStack::PopAndDestroy( text );

        Exit();

        return;

        }

    //check memory

#ifdef FF_OOM_MONITOR2_COMPONENT

    CheckAvailableMemoryByOomL( KLowestMemoryNeeded );

#else

    CheckAvailableMemory( KLowestMemoryNeeded );

#endif    //FF_OOM_MONITOR2_COMPONENT

    if ( !IsEmbedded() )

        {

        // Do we support podcasting in music player?

        // Event if repository get fails, it will default to EFalse

        //

        TInt val(0);

        CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );

        repository->Get( KMPXMPLocalVariation, val );

        iDisablePodcasting = val&KMPXDisablePodcastingOption ? ETrue : EFalse;

        iStartInAlbumMenu = val&KMPXStartMusicPlayerinArtistsandAlbums ? ETrue : EFalse;

        delete repository;

        CreateMemberVariablesL();

        TUid defaultView( iViewUtility->DefaultViewUid() );

        // Pre-load views in standalone mode

        iViewUtility->PreLoadViewsL( TUid::Uid( KMusicPlayerAppUidConstant ) );

#ifndef __ENABLE_PODCAST_IN_MUSIC_MENU

        iCollectionUtility->Collection().OpenL(

            TUid::Uid(EMPXCollectionPluginMusic));

#endif

		if ( iStartInAlbumMenu )

			{

			// We want to open the music player to the albums level for 9.2

			// Changes in other areas will also be needed.

			CMPXCollectionPath* path = iCollectionUiHelper->MusicMenuPathL();

			CleanupStack::PushL( path );

			path->AppendL(3); // Albums

			MPX_DEBUG_PATH(*path);

			iCollectionUtility->Collection().OpenL( *path );

			CleanupStack::PopAndDestroy( path );

			}

		else

			{

			CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();

			CleanupStack::PushL( path );

			MPX_DEBUG1("CMPXAppUi::ConstructL() current collection path");

#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU

        MPX_DEBUG1("CMPXAppUi::ConstructL() restoring stale path");

        CMPXCollectionPath* mainMusicMenu = CMPXCollectionPath::NewL();

        CleanupStack::PushL( mainMusicMenu );

        mainMusicMenu->AppendL(0x101FFC3A);

        iCollectionUtility->Collection().OpenL( *mainMusicMenu );

        CleanupStack::PopAndDestroy( mainMusicMenu );

        CleanupStack::PopAndDestroy( path );

#else

        MPX_DEBUG1( "CMPXAppUi::ConstructL wrong path" );

        if( path->Levels() > 1 )

            {

            // Correct the path by opening 0 levels

            MPX_DEBUG1("CMPXAppUi::ConstructL() restoring stale path");

            CMPXCollectionPath* root = CMPXCollectionPath::NewL();

            CleanupStack::PushL( root );

            iCollectionUtility->Collection().OpenL( *root );

            CleanupStack::PopAndDestroy( root );

            }

        CleanupStack::PopAndDestroy( path );

#endif

			}

        if ( defaultView != KNullUid )

            {

            iViewUtility->SetAsDefaultViewL( defaultView );

            }

        else

            {

            iViewUtility->SetAsDefaultViewL(

                TUid::Uid( KMPXPluginTypeMainUid ) );

            }

#ifdef __ENABLE_PODCAST_IN_MUSIC_MENU

        // Startup database checker

        iController = CMPXController::NewL(iDisablePodcasting);

#endif // __ENABLE_PODCAST_IN_MUSIC_MENU

        // Only in stand alone mode

        iHarvesterUtility = CMPXHarvesterFactory::NewL();

        iHarvesterUtility->CheckForSystemEventsL();

#ifdef _DEBUG

        TBool iExitOptionHidden = EFalse;

#else // _DEBUG

        TBool iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL();

#endif // _DEBUG

        if(iExitOptionHidden)

            {

            // Do not offer choice to exit application from task swapper.

            CEikonEnv::Static()->SetSystem( ETrue );

            }

        RProcess proc;

        CleanupClosePushL( proc );

        CMPXCommonUiHelper::SetStandAloneModePId( proc.Id().Id() );

        CleanupStack::PopAndDestroy( &proc );

        }

    iRingToneMimeTypes.AppendL(_L("application/vnd.nokia.ringing-tone"));

    iRingToneMimeTypes.AppendL(_L("audio/x-midi"));

    iRingToneMimeTypes.AppendL(_L("audio/midi"));

    iRingToneMimeTypes.AppendL(_L("audio/sp-midi"));

    iRingToneMimeTypes.AppendL(_L("audio/amr"));

    iRingToneMimeTypes.AppendL(_L("audio/amr-wb"));

    iRingToneMimeTypes.AppendL(_L("audio/awb"));

    iRingToneMimeTypes.AppendL(_L("audio/x-amr"));

    iRingToneMimeTypes.AppendL(_L("audio/audio/vnd.nokia.mobile-xmf"));

    iLaunchModePlaying = EFalse;

    }

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

// Destructor

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

//

CMPXAppUi::~CMPXAppUi()

    {

    MPX_DEBUG1( "-->CMPXAppUi::~CMPXAppUi()" );

#ifdef FF_OOM_MONITOR2_COMPONENT

    SetMpxOomPriorityL( ROomMonitorSession::EOomPriorityNormal );

#endif //FF_OOM_MONITOR2_COMPONENT

    if ( !IsEmbedded() )

        {

        CMPXCommonUiHelper::SetStandAloneModePId( 0 );

        }

// Cover UI Start

// #ifdef __COVER_DISPLAY

    FeatureManager::UnInitializeLib();

    delete iCommandInitiator;

// #endif // __COVER_DISPLAY

// Cover UI End

    delete iPathRestore;

    delete iController;

    delete iProcessParameter;

#ifdef RD_BROWSER_PROGRESSIVE_DOWNLOAD

    delete iPdParameterHandler;

#endif // RD_BROWSER_PROGRESSIVE_DOWNLOAD

    delete iIdle;

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iPlaybackUtility )

        {

        TRAP_IGNORE( iPlaybackUtility->CommandL( EPbCmdClose ) );

        TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

        iPlaybackUtility->Close();

        }

    if ( iViewUtility )

        {

        iViewUtility->RemoveObserver( this );

        iViewUtility->Close();

        }

    delete iCommonUiHelper;

    if( iCollectionUiHelper )

        {

        iCollectionUiHelper->Close();

        }

    if ( iCollectionHelper )

        {

        iCollectionHelper->Close();

        }

    if( iHarvesterUtility )

        {

        iHarvesterUtility->Close();

        }

    delete iMediaKeyHandler;

    delete iSettingsRepository;

    iFile.Close();

    iDeferredViewActivationUid.Close();

    delete iSavePath;

    iRingToneMimeTypes.Reset();

    delete iSaveHelper;

#ifdef __CAMESE_SUPERDISTRIBUTION_SUPPORT 

    delete iCameseDrmHandler;

#endif 

#ifdef RD_RA_SUPPORT_FOR_MUSIC_PLAYER

    delete iDocHandler;

#endif //RD_RA_SUPPORT_FOR_MUSIC_PLAYER

    CleanUpdateParams();

    MPX_DEBUG1( "<--CMPXAppUi::~CMPXAppUi()" );

    }

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

// Querying whether the application is launched in embedded mode or not.

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

//

TBool CMPXAppUi::IsEmbedded() const

    {

    return iEikonEnv->StartedAsServerApp();

    }

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

// Opens temporary playlist or album from buffer.

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

//

void CMPXAppUi::OpenPlaylistFromBufferL(

    const TDesC& aBuffer,

    TDesC& aName )

    {

    MPX_FUNC( "CMPXAppUi::OpenPlaylistFromBufferL" );

    TPtrC bufPtr( aBuffer );

    TInt offset = 0;

    CMPXMediaArray* tracksArray = CMPXMediaArray::NewL();

    CleanupStack::PushL( tracksArray );

    while ( bufPtr.Length() > 0 )

        {

        offset = bufPtr.Find( KMPXLineChange );

        CMPXMedia* track = CMPXMedia::NewL();

        CleanupStack::PushL( track );

        track->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem);

        track->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXSong );

        if ( offset == KErrNotFound )

            {

            TParsePtrC fn( bufPtr );

            track->SetTextValueL( KMPXMediaGeneralTitle, fn.Name() );

            track->SetTextValueL( KMPXMediaGeneralUri, bufPtr );

            // Set bufPtr to the end of buffer

            bufPtr.Set( bufPtr.Right( 0 ) ); //magic

            }

        else

            {

            TParsePtrC fn( bufPtr.Left( offset ) );

            track->SetTextValueL( KMPXMediaGeneralTitle, fn.Name() );

            track->SetTextValueL( KMPXMediaGeneralUri, fn.FullName() );

            // Move past the line feed

            bufPtr.Set( bufPtr.Mid( ++offset ) );

            }

        tracksArray->AppendL( track );

        CleanupStack::Pop( track );

        }

    CMPXMedia* media = CMPXMedia::NewL();

    CleanupStack::PushL( media );

    media->SetTObjectValueL( KMPXMediaGeneralType, EMPXItem);

    media->SetTObjectValueL( KMPXMediaGeneralCategory, EMPXPlaylist );

    if ( aName.Length() > 0 )

        {

        media->SetTObjectValueL( KMPXMediaGeneralTitle, aName );

        }

    media->SetCObjectValueL( KMPXMediaArrayContents, tracksArray );

    media->SetTObjectValueL( KMPXMediaArrayCount, tracksArray->Count() );

    iCollectionUiHelper->OpenL( MPXTlsHelper::HostUid(), *media,

                                this, EMPXCollectionPluginMusic );

    CleanupStack::PopAndDestroy( media );