/*

* Copyright (c) 2002-2007 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:  Model class for Psln application.

*

*/

// Psln specific.

#include "PslnModel.h"

#include "PslnDiskUtil.h"

#include "PslnFeatures.h"

#include "PslnSkinEntry.h"

#include "PslnSkinStore.h"

#include "PslnEcomListener.h"

#include "PslnDebug.h"

#include "PslnConst.h"

// Wrapper for wallpaper utils.

#include "pslnwallpaperutilsloader.h"

#include "pslnbrowserlaunchloader.h"

// Resources

#include <psln.rsg>

#include <pslnskinnames.rsg>

// Generic

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <f32file.h>

#include <hal.h>

// UI libraries

#include <AknsSkinUID.h>

#include <AknsConstants.h>

#include <eikenv.h>

#include <AknQueryDialog.h>

// Misc

#include <bautils.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // For CleanupResetAndDestroyPushL

// Central Repository and Publish&Subscribe keys.

#include <centralrepository.h>

#include <e32property.h>

#include "pslninternalcrkeys.h"

#include <AknSkinsInternalCRKeys.h>             // wallpaper, screen saver

#include <ScreensaverInternalCRKeys.h>          // KScreenSaverObject

#include <ScreensaverInternalPSKeys.h>          // KScreenSaverPreviewMode

#include <cenrepnotifyhandler.h>

// For enabling first component transition effect

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntranseffect.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

// CONSTANTS

// Path of skin files.

_LIT( KPslnSkinNamesFile,"z:PslnSkinNames.rsc" );

// Preview mode activated.

const TInt KPslnActivatePreviewMode = 1;

// Default item index.

const TInt KPslnDefaultItemIndex = 0;

// Screen saver type: user defined text

const TInt KPslnSsText = 0;

// Screen saver type: date & time

const TInt KPslnSsDate = 1;

// Screen saver type: object

const TInt KPslnSsObject = 3;

// Screen saver type: none

const TInt KPslnSsNone = 4;

// Granularity of screen saver array.

const TInt KPslnSsArrayGranularity = 5;

// Length of drive number descriptor.

const TInt KPslnDriveNumberLength = 2;

// Free RAM required when activating transition effects.

const TInt KPslnTransitionEffectRAMThreshold = 2000000;

// Maximum of text length in text screensaver for APAC.

// For western variant, value is taken directly from resources.

const TInt KPslnSsTextDialogAPACMaxLength = 7;

// Path to wallpaper utils.

_LIT( KPslnWallpaperUtilsLoaderName, 

     "\\system\\libs\\PslnWallpaperUtilsLoader.dll");

_LIT( KPslnBrowserLaunchLoaderName, 

     "\\system\\libs\\PslnBrowserLaunchLoader.dll");

// Screen saver UID is stored like [ss_uid]. This is the end mark.

_LIT( KPslnScreenSaverUidEndMark, "]" );

// CLASS DECLARATIONS

class CPslnActivationGuard : public CBase

    {

    public:

        virtual ~CPslnActivationGuard()

            {

            PSLN_TRACE_DEBUG("CPslnActivationGuard::destructor");

            iModel->SkinSrvSession().EnableSkinChangeNotify();

            }

        static CPslnActivationGuard* NewL( CPslnModel* aModel )

            {

            PSLN_TRACE_DEBUG("CPslnActivationGuard::NewL");

            CPslnActivationGuard* self = new (ELeave) CPslnActivationGuard();

            self->iModel = aModel;

            PSLN_TRACE_DEBUG("CPslnActivationGuard DisableSkinChangeNotify");

            aModel->SkinSrvSession().DisableSkinChangeNotify();

            return self;

            }

    private:

        CPslnModel* iModel;

    };

// TYPE DEFINITIONS

// Wallpaper Utils entry.

typedef TAny* (*NewWallpaperUtilsL)();

// Browser Launcher entry.

typedef TAny* (*NewBrowserLauncherL)();

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

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

// Two-phased constructor.

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

//

EXPORT_C CPslnModel* CPslnModel::NewL( MAknsSkinChangeObserver* aObserver )

    {

    PSLN_TRACE_DEBUG("CPslnModel::NewL");

    CPslnModel* self = new(ELeave) CPslnModel;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    CleanupStack::Pop( self );

    PSLN_TRACE_DEBUG("CPslnModel::NewL OK");

    return self;

    }

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

// Two-phased constructor. Simpler version for PslnFramework use.

// Deprecated.

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

//

EXPORT_C CPslnModel* CPslnModel::NewL()

    {

    CPslnModel* self = new(ELeave) CPslnModel;

    return self;

    }

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

// Destructor

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

//

EXPORT_C CPslnModel::~CPslnModel()

    {

    PSLN_TRACE_DEBUG("CPslnModel::destructor");

    delete iSkinsRepository;

    delete iScreenSaverRepository;

    iSkinSrvSession.Close();

    while( iSkinNames.Count() )

        {

        delete iSkinNames[0].iListName;

        delete iSkinNames[0].iTitleName;

        iSkinNames.Remove(0);

        }

    iSkinNames.Close();

    delete iScreensaverFilenameArr;

    delete iScreensaverNameArr;

    iScreensaverCapsArr.Reset();

    delete iSkinStore;

    if( iVisibleSkinArr )

        {

        iVisibleSkinArr->ResetAndDestroy();

        delete iVisibleSkinArr;

        }

    delete iScreenSaverInfo;

    delete iWallpaperSetter;

    if( iInternalState.IsSet( EPslnModelStateWallpaperDllLoaded  ) )

        {

        iWallpaperDll.Close();

        }

    delete iBrowserLauncher;

    if( iInternalState.IsSet( EPslnModelStateBrowserLaunchDllLoaded ) )

        {

        iBrowserLaunchDll.Close();

        }

    // If client is bad-behaving and has not cancelled listening, 

    // cancel itself.

    if ( iScreenSaverListener )

        {

        if ( iScreenSaverListener->IsActive() )

            {

            iScreenSaverListener->Cancel();

            }

        delete iScreenSaverListener;

        // NUllified here, just in case if client later decides to try and

        // destroy this.

        iScreenSaverListener = NULL;

        }

    if(iThemesAppCenRepNotifyHandler)

        {

        iThemesAppCenRepNotifyHandler->StopListening();

        delete iThemesAppCenRepNotifyHandler;

        }

    delete iThemesAppRepository;

    }

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

// Activate a Skin.

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

//

EXPORT_C TBool CPslnModel::ActivateSkinL(

    const TDesC8& /*aPreviewType*/,

    const TInt /*aActiveSkinIndex*/ )

    {

    PSLN_TRACE_DEBUG("CPslnModel::ActivateSkinL -- depricated!!");

    User::Leave( KErrNotSupported );

    return EFalse;

    }

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

// Activate a screen saver.

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

//

EXPORT_C TInt CPslnModel::ActivateScreenSaver( const TInt aItemIndex, 

    TPslnScreenSaverActivation aActivationType )

    {

    PSLN_TRACE_DEBUG("CPslnModel::ActivateScreenSaver");

    TRAPD( err, ActivateScreenSaverL( aItemIndex, aActivationType ) );

    PSLN_TRACE_DEBUG1("CPslnModel::ActivateScreenSaver %d", err );

    return err;

    }

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

// CPslnModel::GuardActivationLC

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

//

EXPORT_C void  CPslnModel::GuardActivationLC()

    {

    PSLN_TRACE_DEBUG("CPslnModel::GuardActivationLC");

    CleanupStack::PushL( CPslnActivationGuard::NewL( this ) );

    }

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

// Download a skin.

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

//

EXPORT_C void CPslnModel::DownloadSkinL()

    {

    PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL BEGIN");

    PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL Load DLL");

    LoadBrowserLaunchL();

    if ( iBrowserLauncher )

        {

        PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL Launch embedded browser");

        TRAPD( error, 

               iBrowserLauncher->LaunchBrowserStandaloneL( ) );

        if ( error != KErrNone )

            {

            PSLN_TRACE_DEBUG1("CPslnModel::DownloadSkinL Handle exit: %d", error );

            }

        if ( error == KErrNoMemory )

            {

            PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL OOM");

            User::Leave( error );

            }

        }

    PSLN_TRACE_DEBUG("CPslnModel::DownloadSkinL END");

    }

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

// Set Background image path name.

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

//

EXPORT_C TInt CPslnModel::SetBackgroundImagePath( const TDesC& aImagePath )

    {

    PSLN_TRACE_DEBUG("CPslnModel::SetBackgroundImagePath");

    TRAP_IGNORE( LoadWallpaperUtilsL() );

    TInt retVal = KErrNone;

    if ( iWallpaperSetter )

        {

        if( aImagePath.Length() > 0 )

            {

            retVal = iWallpaperSetter->SetIdleWallpaper(

                aImagePath, 

                CCoeEnv::Static(),

                R_PSLN_SKINS_LOADING_IMAGE,

                R_PSLN_GENERAL_WAIT_NOTE );

            }

        else

            {

            retVal = iWallpaperSetter->SetIdleWallpaper( KNullDesC, NULL );

            }

        }

    else

        {

        retVal = KErrNoMemory;

        }

    return retVal;

    }

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

// CPslnModel::InvokeSSPluginFunctionL

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

//

EXPORT_C void CPslnModel::InvokeSSPluginFunctionL(

    TInt aIndex,

    TScPluginCaps aFunction )

    {

    PSLN_TRACE_DEBUG("CPslnModel::InvokeSSPluginFunctionL");

    if ( !iScreensaverFilenameArr || iScreensaverFilenameArr->Count() == 0 )

        {

        User::Leave( KErrNotFound );

        }

    if( aIndex >= iScreensaverFilenameArr->MdcaCount() )

        {

        User::Leave( KErrArgument );

        }

    if(aFunction == EScpCapsConfigure &&

       aIndex == GetScreenSaverIndexByFileName(KPslnScreenSaverTypeText))

        {

        TBool ret = QueryAndSetScreensaverTextL();

        if ( !ret )

            {

            User::Leave( KErrCancel );

            }

        return;

        }

    // Convert the UID of the given screensaver plugin from text to integer

    // The string format of the UID: [12345678]

    // The number inside the brackets in hexadecimal format

    TLex lex( iScreensaverFilenameArr->MdcaPoint( aIndex ) );

    // Skip the first character: '['

    lex.Get();

    TUint screenSaverPluginImpUid;

    // Get the UID

    TInt err = lex.Val( screenSaverPluginImpUid, EHex );

    PSLN_TRACE_DEBUG1("CPslnModel::InvokeSSPluginFunctionL lexed: %d", err );

    User::LeaveIfError( err );

    CScreensaverPluginInterfaceDefinition* plugin =

        CScreensaverPluginInterfaceDefinition::NewL(

        TUid::Uid( screenSaverPluginImpUid ) );

    CleanupStack::PushL( plugin );

    err = plugin->PluginFunction( aFunction, iEikEnv );

    PSLN_TRACE_DEBUG1("CPslnModel::InvokeSSPluginFunctionL call return: %d", err );

    CleanupStack::PopAndDestroy( plugin );

    if( err == KErrCancel && aIndex == CurrentPropertyIndexL( KPslnScreenSettingId ) )

        {

        SetScreenSaverToDefault();

        }

    User::LeaveIfError( err );

    }

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

// CPslnModel::PerformCompleteUpdateL

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

//

EXPORT_C void CPslnModel::PerformCompleteUpdateL()

    {

    PSLN_TRACE_DEBUG("CPslnModel::PerformCompleteUpdateL");

    if ( iInternalState.IsClear( EPslnModelStateSkinNamesLoaded ) )

        {

        LoadSkinNamesResourceL();

        }

    UpdateFromServerL();

    SetActiveSkinL();

    PSLN_TRACE_DEBUG("CPslnModel::PerformCompleteUpdateL COMPLETED");

    }

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

// CPslnModel::LoadScreensaverArrayL

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

//

EXPORT_C void CPslnModel::LoadScreensaverArrayL()

    {

    PSLN_TRACE_DEBUG("CPslnModel::LoadScreensaverArrayL");

    // Destroy old arrays, if any

    delete iScreensaverNameArr;

    iScreensaverNameArr = NULL;

    delete iScreensaverFilenameArr;

    iScreensaverFilenameArr = NULL;

    iScreensaverCapsArr.Reset();

    // Load default items

    iScreensaverNameArr = iEikEnv->ReadDesC16ArrayResourceL(

        R_SCREEN_SAVER_SETTING_PAGE_LBX );

    // Add descriptors for system screensavers

    iScreensaverFilenameArr =

        new (ELeave) CDesC16ArrayFlat( KPslnSsArrayGranularity );

    if ( IsSupportScreenSaverNoneOption() )

        {

        iScreensaverFilenameArr->InsertL(0, KPslnScreenSaverTypeNone ); 

        User::LeaveIfError( iScreensaverCapsArr.Insert( 0, EFalse ) );

        }

    else

        {

        iScreensaverNameArr->Delete(0);

        }

    FindAndAppendScreensaversL();

    }

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

// CPslnModel::VisibleSkin

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

//

EXPORT_C CPslnSkinEntry* CPslnModel::VisibleSkin( const TInt aIndex )

    {

    PSLN_TRACE_DEBUG("CPslnModel::VisibleSkin");

    if ( !iSkinStore )

        {

        TRAPD( err, iSkinStore = CPslnSkinStore::NewL( this ) );

        if ( err != KErrNone )

            {

            return NULL;

            }

        }

    CPslnSkinEntry* visibleSkin = NULL;

    if ( iVisibleSkinArr )

        {

        if( ( aIndex >= 0 ) && ( aIndex < iVisibleSkinArr->Count() ) )

            {

            CPslnSkinNameEntry* nameEntry = (*iVisibleSkinArr)[aIndex];

            visibleSkin = iSkinStore->Find(

                nameEntry->PkgID(), nameEntry->Location() );

            }

        }

    return visibleSkin;

    }

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

// Get a skin's name by index.

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

//

EXPORT_C void CPslnModel::GetSkinNameByIndex( const TInt aIndex, TDes& aSkinName,

    const TPslnSkinNameType aType ) const

    {

    PSLN_TRACE_DEBUG("CPslnModel::GetSkinNameByIndex");

    TAknsPkgID pid = KAknsNullPkgID;

    if ( iVisibleSkinArr )

        {

        if( ( aIndex >= 0 ) && ( aIndex < iVisibleSkinArr->Count() ) )

            {

            pid = (*iVisibleSkinArr)[aIndex]->PkgID();

            }

        }

    GetSkinNameByPID( pid, aSkinName, aType );

    }

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

// Return if the selected skin is activated.

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

//

EXPORT_C TBool CPslnModel::IsActiveSkinSelected( TInt aSkinIndex ) const

    {

    PSLN_TRACE_DEBUG("CPslnModel::IsActiveOfSkinSelected");

    TInt skinIndex = iCurrentSkinIndex;

    if ( aSkinIndex >= 0 )

        {

        skinIndex = aSkinIndex;

        }

    return ( iActiveSkinIndex == skinIndex );

    }

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

// CPslnModel::LocationOfSkin

// Deprecated.

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

//

EXPORT_C TAknSkinSrvSkinPackageLocation CPslnModel::LocationOfSkin(

    const TInt aIndex )

    {

    PSLN_TRACE_DEBUG("CPslnModel::LocationOfSkin");

    TAknSkinSrvSkinPackageLocation skinLocation = EAknsSrvPhone;

    CPslnSkinEntry* entry = VisibleSkin( aIndex );

    if( entry )

        {

        skinLocation = entry->Location();

        }

    return skinLocation;

    }

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

// Return the active skin index.

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

//

EXPORT_C TInt CPslnModel::ActiveSkinIndex () const