/*

* Copyright (c) 2002-2008 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:  Skin server core class.

*

*/

// INCLUDE FILES

#include "AknsSrv.h"

#include <e32svr.h>

#include <AknLayoutDef.h>

#include <DRMHelper.h>

#include <Oma2Agent.h>

#include <bautils.h>

#include <hal.h>

#include <AknSkinsInternalCRKeys.h>

#include <centralrepository.h>

#include "tfxconfigparser.h"

#include <TfxSrvEcomIds.h>

#include <apgwgnam.h>

#include "AknsSrvSettings.h"

#include "AknsSrvScheduler.h"

#include "AknsSkinContent.h"

#include <AknsSkinUID.h>

#include "AknsSrvUtils.h"

#include "AknsSrvExclusion.h"

#include "AknsSrvBitmapStore.h"

#include "aknssrvwallpaperscaling.h"

#include "aknssrvactivedataowner.h"

#include "AknsDriveMaster.h"

#include "aknssrviconconfigmap.h"

#include "AknsDebug.h"

_LIT(KTFxDefaultExtensionPath, "z:\\resource\\skins\\");

_LIT(KTFxExtFileExt, ".sel");

// Extension for ini file.

_LIT( KAknsSkinSrvIniFileExt, ".ini" );

// Extension for scalable vector graphics file.

_LIT( KAknsSkinSrvSvgFileExt, ".svg" );

// No wallpaper

const TInt KAknsSkinSrvNoWallpaper = 0;

// Image wallpaper

const TInt KAknsSkinSrvImageWallpaper = 1;

// Slideset wallpaper type

const TInt KAknsSkinSrvSlidesetWallpaper = 2;

// Filenames and locations of slideset ini-files.

_LIT( KAknsSrvSSSSInifile, "\\private\\10207114\\SSSS.ini");

_LIT( KAknsSrvSSWPInifile, "\\private\\10207114\\SSWP.ini");

const TUint KSlidesetEnableAppUid[] = {

    0x100056cf,    // ScreenSaver

    0x102750f0,    // ActiveIdle

    0x10005a32,    // Psln

    0x10207218,    // CapServer

    0x00000000     // Empty

    };

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

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

// CAknsSrv::CAknsSrv

// C++ constructor can NOT contain any code, that might leave.

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

//

CAknsSrv::CAknsSrv() :

    CServer2( CActive::EPriorityStandard),

    iNotifyEnabled( ETrue ),

    iContentChanged( EFalse ),

    iOutstandingChangeEvents( 0 )

    {

    }

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

// CAknsSrv::New

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

//

CAknsSrv* CAknsSrv::New( TBool &aStartFailed )

    {

    AKNS_TRACE_INFO("CAknsSrv::New STARTED");

	aStartFailed = EFalse;

    CAknsSrv* server = new CAknsSrv();

    server->iMergeType = (TAknsSkinSrvMergeType)(

        EAknsSkinSrvSkin | EAknsSkinSrvIdleWp );

    server->iBootFinished = EFalse;

    if ( server )

        {

        if ( server->Start( KAknSkinSrvName ) != KErrNone )

            {

            AKNS_TRACE_ERROR("CAknsSrv::New START FAILED!");

           	aStartFailed = ETrue;

            delete server;

            return NULL;

            }

        }

    else

        {

        AKNS_TRACE_ERROR("CAknsSrv::New SERVER ALLOCATION FAILED!");

        return NULL;

        }

    server->iBitmapStore = new CAknsSrvBitmapStore;

    if( !server->iBitmapStore )

        {

        AKNS_TRACE_ERROR("CAknsSrv::New BITMAPSTORE CREATION FAILED!");

        delete server;

        return NULL;

        }

    server->iChunkMaintainer =

        new CAknsSrvChunkMaintainer(server->iBitmapStore);

    if( !server->iChunkMaintainer )

        {

        AKNS_TRACE_ERROR("CAknsSrv::New CHUNK CREATION FAILED!");

        delete server;

        return NULL;

        }

    TInt err = server->iFsSession.Connect();

    AKNS_TRACE_INFO1("CAknsSrv::New RFs connected, ret=%d", err);

    AKNS_TRACE_INFO("CAknsSrv::New server up, connecting shared data");

    TInt errorCode( KErrNone );

    TRAP( errorCode, (server->iSettings=CAknsSrvSettings::NewL(server, server->iFsSession )) );

    if( errorCode )

        {

        AKNS_TRACE_ERROR("CAknsSrv::New SETTING MANAGER CREATION FAILED!");

        delete server;

        return NULL;

        }

    AKNS_TRACE_INFO("CAknsSrv::New Settings manager created");

    TRAPD( exlListErr, server->iExclusionList =

        CAknsSrvExclusionList::NewL() );

    AKNS_TRACE_INFO1("CAknsSrv::New Exclusion list init, ret=%d", exlListErr);

    if( exlListErr == KErrNone )

        {

        TRAP( exlListErr, server->iExclusionList->LoadDefaultListFromFileL( server->iFsSession ) );

        AKNS_TRACE_INFO1("CAknsSrv::New Exclusion list loaded, ret=%d", exlListErr);

        if( exlListErr != KErrNone )

            {

            delete server->iExclusionList;

            server->iExclusionList = NULL;

            }

        }

    // Connection to Fbs-server is needed for server side bitmaps

    // and should allways be kept connected.

    err = server->iFbsSession.Connect();

    AKNS_TRACE_INFO1("CAknsSrv::New FBS connected, ret=%d", err);

    TRAP( errorCode, server->iSettings->InstallAdditionalWatchersL() );

    AKNS_TRACE_INFO1("CAknsSrv::New Additional watchers installed, ret=%d", errorCode);

    server->InitSlidesetEnableAppUid();

    TRAP_IGNORE( server->InitMaxImageSizeL() );

    TRAP( errorCode,server->iWallpaperCache = CAknsSrvWallpaperCache::NewL( KAknsWallpaperCacheSize ) );

    AKNS_TRACE_INFO("CAknsSrv::New PrepareMergedSkinContentL");

    TRAPD( mergeErr, server->PrepareMergedSkinContentL() );

    if( mergeErr != KErrNone )

        {

        AKNS_TRACE_ERROR1("CAknsSrv::New MERGE ERROR %i", mergeErr);

        server->SetDefaultSkinActive();

        server->RestoreDefaultSDSettings();

        TRAP( mergeErr, server->PrepareMergedSkinContentL() );

        AKNS_TRACE_INFO1("CAknsSrv::New FALLBACK MERGE, ret=%d", mergeErr);

        __ASSERT_DEBUG( mergeErr==KErrNone, User::Panic(

            KAknSkinSrvPanicCategory, EAknsSrvFatalMergeFailure ) );

        }

    TRAP(err, server->iBackupSession = CBaBackupSessionWrapper::NewL() );

    AKNS_TRACE_INFO1("CAknsSrv::New Backup session wrapper created, ret=%d", err);

    if( server->iBackupSession )

        {

        TRAP(err, server->iBackupSession->RegisterBackupOperationObserverL(

            *(server->iSettings) ) );

        AKNS_TRACE_INFO1("CAknsSrv::New Backup observer registered, ret=%d", err);

        }

    TRAP( err, server->iBackupNotifier = CAknsSrvActiveDataOwner::NewL( server->iFsSession ) );

    AKNS_TRACE_INFO1("CAknsSrv::New Backup notifier created, ret=%d", err);

    AKNS_TRACE_INFO("CAknsSrv::New COMPLETED");

    TRAP(err,server->iInstallObserver = CAknsSrvFileObserver::NewL(server));

    server->iInstallObserver->IssueRequest();

    server->iMergeType =  EAknsSkinSrvNone;

    server->iBootFinished = ETrue;

    server->iWallpaperType = server->iSettings->WallpaperType();

    return server;

    }

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

// Destructor.

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

//

CAknsSrv::~CAknsSrv()

    {

    // In theory we should never get here, since the server is always running.

   delete iWPFilename;

   iWPFilename = NULL;

    if( iBackupSession )

        {

        iBackupSession->DeRegisterBackupOperationObserver( *iSettings );

        delete iBackupSession;

        iBackupSession = NULL;

        }

    delete iExclusionList;

    delete iSettings;

    delete iInstallObserver;

    delete iWallpaperObserver;

    iFbsSession.Disconnect();

    iFsSession.Close();

    iSknFile.Close();

    delete iDrmHelper;

    delete iBitmapStore;

    delete iChunkMaintainer;

    delete iSkinContentUri;

    delete iIdleWPContentUri;

    delete iSkinContentUri2;

    delete iIdleWPContentUri2;

    delete iWallpaperTimer;

    delete iSlideSetObserver;

    if ( iSlideSetNameArray )

        {

        iSlideSetNameArray->Reset();

        }

    delete iSlideSetNameArray;

    delete iBackupNotifier;

    delete iIconConfigMap;

    iWallpaperCache->ResetAndDestory( );

    iSlidesetEnableAppUidArray.Close();

    }

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

// CAknsSrv::NewSessionL

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

//

CSession2* CAknsSrv::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

    {

    // Check that we're the right version

    TVersion v( KAknSkinSrvMajorVersionNumber,

        KAknSkinSrvMinorVersionNumber,

        KAknSkinSrvBuildVersionNumber);

    if ( !User::QueryVersionSupported(v, aVersion) )

        {

        User::Leave( KErrNotSupported );

        }

    // Make a new session

    return new(ELeave) CAknsSrvSession( );

    }

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

// CAknSkinSrv::ThreadStart()

// The skin server thread.

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

//

EXPORT_C TInt CAknsSrv::ThreadStart()

    {

    // Rename own thread

    User::RenameThread(KAknSkinSrvName);

    CAknsSrv* server = NULL;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    CActiveScheduler* scheduler = new CAknsSrvScheduler;

    TInt err(KErrNone);

	TBool startFailed(EFalse);

    if ( cleanup && scheduler )

        {

        CActiveScheduler::Install( scheduler );

        server = CAknsSrv::New( startFailed );   // Adds server in scheduler

        }

    if ( !cleanup || !scheduler || !server )

        {

        delete cleanup;

        delete scheduler;

        delete server;

        err = KErrNoMemory;

        if(startFailed)

        	{

        	// Server Start call failed (means really that the server already existed)	

        	err = KErrAlreadyExists;

        	}

        }

    if ( err == KErrNone )

        {

        // Prevent killing skin  server from other processes

        User::SetProcessCritical(User::ESystemCritical);

        User::SetCritical(User::ESystemCritical);

        // Signal that we've started

        RProcess::Rendezvous(KErrNone);

        // Start fielding requests from clients

        CActiveScheduler::Start();

        // Comes here if server gets shut down

        delete scheduler;   //lint !e644 Initialized

        delete cleanup;     //lint !e644 Initialized

        delete server;      //lint !e644 Initialized

        }

    // Thread/process exit

    return( err );

    }

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

// CAknsSrv::NotifyBackupOperationEnd

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

//

void CAknsSrv::NotifyBackupOperationEnd()

    {

    RestoreOldSkin();

    }

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

// CAknsSrv::NotifyLayoutChange

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

//

void CAknsSrv::NotifyLayoutChange(TBool aClearScalable)

    {

#ifdef __WINS__

// for emulator only, flush the cache also as

// it is possible to perform "illegal" layout changes

// ie. landscape -> landscape

    if (aClearScalable)

        {

        iChunkMaintainer->ClearScalableGraphics(EAknsSrcScrModeNone);

        }

#endif // __WINS__

    iContentChanged = ETrue;

    if( !iSettings->CachedBackupOperationInProgress() )

        {

        MergeAndBroadcast();

        }

    }

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

// CAknsSrv::NotifySkinChange

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

//

void CAknsSrv::NofifySkinChange()

    {

    if (iUSBAttached)

        {

        return;

        }

    iContentChanged = ETrue;

    if( !iSettings->CachedBackupOperationInProgress() )

        {

        MergeAndBroadcast();

        }

    }

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

// CAknsSrv::NotifyIdleBackgroundChange

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

//

void CAknsSrv::NotifyIdleBackgroundChange()

    {

    iContentChanged = ETrue;

    iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvIdleWp);

    if( !iSettings->CachedBackupOperationInProgress() )

        {

        MergeAndBroadcast();

        }

    }

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

// CAknsSrv::NotifyDRMChange

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

//

void CAknsSrv::NotifyDRMChange()

    {

    TRAP_IGNORE ( NotifyDRMChangeL() );

    }

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

// CAknsSrv::NotifyDRMChangeL

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

//

void CAknsSrv::NotifyDRMChangeL()

    {

    AKNS_TRACE_INFO("CAknsSrv::NofifyDRMChange - DrmHelper notification");

    CheckAndCreateDRMHelper();

    TInt size = 256;

    HBufC* buf = HBufC::NewLC(size);

    TPtr bufPtr = buf->Des();

    TInt error = iSettings->ReadDRMHelperServerNotification( bufPtr );

    AKNS_TRACE_INFO1("CAknsSrv::NofifyDRMChange - ReadDRMHelperServerNotification: %d", error );

    HBufC8* buf8 = HBufC8::New((buf->Length())*2);

    CleanupStack::PushL(buf8);

    const unsigned char* ptr = (const unsigned char*)(buf->Ptr());

    buf8->Des().Copy(ptr,(buf->Length())*2);

    TInt8 count = (TInt8)(*(buf8->Ptr()));

    TChar mark = (TChar)(*(buf8->Ptr()+1));

    TInt8 permtype = (TChar)(*(buf8->Ptr()+2));

    TInt8 automcontenttype = (TChar)(*(buf8->Ptr()+3));

    TBuf8<256> curi = buf8->Right( buf8->Length()-4);

    if (curi.Ptr()[curi.Size()-1] == 0)

        {

        // The last character in the descriptor is 0, which means

        // that the original 16-bit desc was padded so

        // remove the last char...

        curi.SetLength(curi.Size()-1);

        }

    if (mark == 'V')

        {

        AKNS_TRACE_INFO1("CAknsSrv::NotifyDRMChange DrmHelper notification type V received, count=%d",count);

        if (count > 0)

            {

            if (iSkinContentUri && iSkinContentUri->Compare(curi) == 0)

                {

                AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange Skin is valid but about to expire");

                iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeTheme);

                iDrmHelper->CheckRightsAmountL( *iSkinContentUri);

                }

            if ( iIdleWPContentUri && iIdleWPContentUri->Compare(curi) == 0)

                {

                AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange IdleWP is valid but about to expire");

                iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);

                iDrmHelper->CheckRightsAmountL( *iIdleWPContentUri);

                }

            }

        }

    else if (mark == 'E')

        {

        AKNS_TRACE_INFO1("CAknsSrv::NotifyDRMChange DrmHelper notification type E received, count=%d",count);

        if (count == 0)

            {

            // Expire skins here..., no note

            if (iSkinContentUri && iSkinContentUri->Compare(curi) == 0)

                {

                AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange Skin is expired");

                iSkinContentUri2 = (*iSkinContentUri).AllocL();

                delete iSkinContentUri; iSkinContentUri = NULL;

                RestoreDefaultSkin();

                // Merge and broadcast

                iContentChanged = ETrue;

                MergeAndBroadcast();

                // Also notify potential package list update

                ForceNotifySessions(EAknsSCHNPackageListUpdate);

                }

            if (iIdleWPContentUri && iIdleWPContentUri->Compare(curi) == 0)

                {

                AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange IdleWP is expired");

                iIdleWPContentUri2 = (*iIdleWPContentUri).AllocL();

                delete iIdleWPContentUri; 

                iIdleWPContentUri = NULL;

                if ( iWallpaperType == KAknsSkinSrvSlidesetWallpaper )

                    {

                    TBool isProtected = EFalse;

                    if ( iSlideSetNameArray && iSlideSetNameArray->MdcaCount() )

                        {

                        TFileName wallpaper;

                        iSettings->ReadIdleBackgroundFile( wallpaper );

                        CheckImageL( wallpaper, isProtected );

                        }

                    if ( isProtected )

                        {

                        iCurrentSlide = iCurrentSlide ? (iCurrentSlide - 1): (iSlideSetNameArray->MdcaCount() - 1);

                        WallpaperTimerTimeoutL( ETrue );

                        }

                    }

                else

                    {

                    RestoreDefaultIdleWP();

                    // Merge and broadcast

                    iContentChanged = ETrue;

                    MergeAndBroadcast();

                    // Also notify potential package list update

                    ForceNotifySessions(EAknsSCHNPackageListUpdate);

                    }

                }

            }

        else if (count > 0)

            {