/*

* Copyright (c) 2002-2004 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: Implementation of customization components

*

*/

// INCLUDE FILES

#include "UISettingsSrvConstants.h"

#include "UISettingsSrv.h"

#include <e32svr.h>

#include <e32math.h>

#include <e32uid.h>

#include    <eikapp.h>

#include    <avkon.hrh>

#include    <akncontext.h>

#include    <aknnavi.h>

#include    <aknnavide.h>

#include    <akntabgrp.h>

#include    <akntitle.h>

#include    <aknnotedialog.h>

#include    <AknWaitDialog.h>

#include    <aknslider.h>

#include    <AknQueryDialog.h>

#include    <aknsettingpage.h>

#include    <aknradiobuttonsettingpage.h>

#include    <aknslidersettingpage.h>

#include    <akntextsettingpage.h>

#include    <AknDateFormatUtils.h>

#include    <AknUtils.h>

#include    <AknsConstants.h>    //for determining skin change

#include    <barsread.h>

#include    <hal.h>

#include <e32property.h>

#include <centralrepository.h>

#include <AknSkinsInternalCRKeys.h>

#include <AknIconSrvClient.h>

#include <startupdomaincrkeys.h>

// #include <ScShortcut.h>

// #include <ScShortcutUids.h>

// #include <ScShortcutBase.h>

// #include <ScShortcutEngine.h>

// #include <ScSelectableShortcutList.h>

// #include <ScShortcutCustomOperations.h>

#include <gsasyncimagehandling.h>

#include <backgroundimage.h>

#include <imageconversion.h>

#include "debug.h"

// Type defintions

typedef TInt TScBookmarkEngineId;	// NOTE ! This is copied from ScBookmarkDbManager.h

									// to avoid illegal userinclude

const TUid KUidIdleApp = { 0x101FD64C };

/******************************************************************************************

    Security policies of this server are defined here:   

*/

/**

    Ranges (inclusive):

        0: EUISettingsSrvSetStartupImage to (EUISettingsSrvLastCmd-1)

        1: EUISettingsSrvLastCmd to KMaxTInt

*/

const TInt CUISettingsSrvServer::iRanges[UISETTINGSSRV_POLICYCOUNT] =

                {EUISettingsSrvSetStartupImage, EUISettingsSrvLastCmd};

/**

    For range 0: Always pass

    For range 1: Not supported

*/

const TUint8 CUISettingsSrvServer::iElementsIndex[UISETTINGSSRV_POLICYCOUNT] = 

                {CPolicyServer::EAlwaysPass, CPolicyServer::ENotSupported};

/**

    The policy

*/

const CPolicyServer::TPolicy CUISettingsSrvServer::iConnectionPolicy =

    {

        CPolicyServer::ECustomCheck, // Check connection

        UISETTINGSSRV_POLICYCOUNT,

        iRanges,

        iElementsIndex,

        0

    };

// MACROS

#define WELCOME_NOTE_MAX_LENGTH 100

//_LIT( KTempFilePath, "c:\\system\\temp\\" );

_LIT( KUISSWelcomeImagePath,    "c:\\system\\data\\welcomedata.mbm");

//_LIT8( KMimeTypeImageMbm, "image/x-epoc-mbm");

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

// CShutDown

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

inline CShutdown::CShutdown()

	:CTimer(-1)

	{

	CActiveScheduler::Add(this);

	}

inline void CShutdown::ConstructL()

	{

	CTimer::ConstructL();

	}

inline void CShutdown::Start()

	{

	RDEBUG( "UiSettingsSrv: Starting shutdown timeout" );

	After( KUISettingsSrvShutdownDelay );

	}

void CShutdown::RunL()

	{

	RDEBUG( "UiSettingsSrv: Timeout ... closing" );

	CEikonEnv::Static()->EikAppUi()->HandleCommandL( EEikCmdExit );

	}

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

// CUISettingsSrvServer

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

CUISettingsSrvServer::CUISettingsSrvServer(TInt aPriority)

	: CPolicyServer (

	    aPriority, // Active object priority

	    iConnectionPolicy,

	    EUnsharableSessions

	  )

	, iActive( 0 )

	, iSessionCount( 0 )

//	, iShortcuts( 0 )

	, iImgHandling( 0 )

	, iAppList( 0 )

	, iIdleBitmapUid( KUidIdleApp )

	, iAIBitmapUid( KUidIdleApp ) 

	{

	}

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

// CTerminalControlServer::CustomSecurityCheckL

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

CPolicyServer::TCustomResult CUISettingsSrvServer::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)

	{

	RDEBUG("CUISettingsSrvServer::CustomSecurityCheckL");

    _LIT_SECURITY_POLICY_C7(

                KRequiredCapabilities1,

                ECapabilityNetworkServices,

                ECapabilityLocalServices,

                ECapabilityLocation,

                ECapabilityReadUserData,

                ECapabilityWriteUserData,

                ECapabilityReadDeviceData,

                ECapabilityWriteDeviceData

                );

    _LIT_SECURITY_POLICY_C3(

                KRequiredCapabilities2,

                ECapabilitySwEvent,

                ECapabilityUserEnvironment,

                ECapabilityNetworkControl

                );

		TInt policy1 = KRequiredCapabilities1().CheckPolicy( aMsg );

		if( !policy1 )

		    {

            RDEBUG("CUISettingsSrvServer::CustomSecurityCheckL Capabilities ERROR");

            return EFail;

		    }

		TInt policy2 = KRequiredCapabilities2().CheckPolicy( aMsg );

		if( !policy2 )

		    {

            RDEBUG("CUISettingsSrvServer::CustomSecurityCheckL Capabilities ERROR");

            return EFail;

		    }

        RDEBUG("CUISettingsSrvServer::CustomSecurityCheckL Capabilities OK");

        return EPass;

	}

CUISettingsSrvServer::~CUISettingsSrvServer()

	{

	iShutdownTimer.Cancel();

//    delete iAppList;

//	delete iShortcuts;

    if( iTemporaryImageFile.Length() > 0 )

        {

        RDEBUG( "CUISettingsSrvServer::~CUISettingsSrvServer() Deleting temporary file" );

        iFs.Delete( iTemporaryImageFile );

        iTemporaryImageFile.Zero();

        }

	iFs.Close();

	iIndeces.Reset();

	iNotifyChanges.Reset();

	delete iImgHandling;

	delete iStartupRep;

	}

void CUISettingsSrvServer::ConstructL()

	{

	RDEBUG( "CUISettingsSrvServer::ConstructL" );

	User::LeaveIfError( iFs.Connect() );

//    iShortcuts = CScShortcutEngine::NewL(iFs, *this);

//    RDEBUG_2( "CUISettingsSrvServer::ConstructL CScShortcutEngine ALLOC %x", iShortcuts );

	iShutdownTimer.ConstructL();

	iShutdownTimer.Start();

	StartL(KUISettingsSrvName);

    iImgHandling = CGSAsyncImageHandling::NewL(

                        iFs, this, KUISSWelcomeImagePath() );

    RDEBUG_2( "CUISettingsSrvServer::ConstructL CGSAsyncImageHandling ALLOC %x", iImgHandling );

    iStartupRep = CRepository::NewL( KCRUidStartupConf );

    RDEBUG_2( "CUISettingsSrvServer::ConstructL CRepository ALLOC %x", iStartupRep );

	}

// Create and start a new count server.

CUISettingsSrvServer* CUISettingsSrvServer::NewL()

	{

	RDEBUG( "CUISettingsSrvServer::NewL" );

	CUISettingsSrvServer *pS = 0;

	pS = new (ELeave) CUISettingsSrvServer( EPriorityStandard );

    RDEBUG_2( "CUISettingsSrvServer::NewL CUISettingsSrvServer ALLOC %x", pS );

	CleanupStack::PushL( pS );

	pS->ConstructL();

	CleanupStack::Pop( pS );

	return pS;

	}

// Create a new server session.

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

	{

	RDEBUG( "CUISettingsSrvServer::NewSessionL" );

	// check we're the right version

	TVersion v(KUISettingsSrvMajorVersionNumber,KUISettingsSrvMinorVersionNumber,KUISettingsSrvBuildVersionNumber);

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

		{

		User::Leave(KErrNotSupported);

		}

	// make new session

	return CUISettingsSrvSession::NewL( ( CUISettingsSrvServer*) this );

	}

void CUISettingsSrvServer::AddSession()

	{

	RDEBUG( "CUISettingsSrvServer::AddSession" );

	iSessionCount++;

	iShutdownTimer.Cancel();

	}

void CUISettingsSrvServer::RemoveSession()

	{

	RDEBUG( "CUISettingsSrvServer::RemoveSession" );

	iSessionCount--;

	if (iSessionCount <= 0)

		{

		iShutdownTimer.Start();

		}

	}

void CUISettingsSrvServer::Shutdown()

	{

	RDEBUG( "CUISettingsSrvServer::Shutdown" );	

	}

// From MScSelectableShortcutListObserver

void CUISettingsSrvServer::ScSSLOHandleListChangedL()

    {

	RDEBUG( "CUISettingsSrvServer::ScSSLOHandleListChangedL" );

	// Shortcut list has changed, notify sessions about the situation!

    for(TInt i=0; i<iNotifyChanges.Count(); i++)

        {

        TInt* flag = iNotifyChanges[ i ];

        if( flag != 0 )

            {

            *flag = 1;

            }

        }

    }

// From MScSelectableShortcutListObserver

void CUISettingsSrvServer::ScSSLOHandleListConstructionComplete(TInt /*aError*/)

    {

	RDEBUG( "CUISettingsSrvServer::ScSSLOHandleListConstructionComplete" );

    if( iASWait.IsStarted() )

    {

        iASWait.AsyncStop();

    }

    }

// From MScEngineObserver

// TBool CUISettingsSrvServer::MScEngineHandleShortcutEvent(

//                    TScShortcutEvent /*aEvent*/,

//                    TScActionType /*aType*/

//                    )

//    {

//	RDEBUG( "CUISettingsSrvServer::MScEngineHandleShortcutEvent" );

//    return EFalse;

//    } */

void CUISettingsSrvServer::GetShortcutTargetListL()

    {

/*	RDEBUG( "CUISettingsSrvServer::GetShortcutTargetListL" );

    if( iASWait.IsStarted() )

        {

        User::Leave( KErrServerBusy );

        }

    // Remember count of previous list

    TInt oldCount = 0;

    if( iAppList != 0 )

        {

        oldCount = iAppList->Count();

        }

    delete iAppList;

    iAppList = 0;

    delete iShortcuts;

    iShortcuts = 0;

    iShortcuts = CScShortcutEngine::NewL(iFs, *this);

    RDEBUG_2( "CUISettingsSrvServer::GetShortcutTargetListL CScShortcutEngine ALLOC %x", iShortcuts );

    const CScSelectableShortcutList::TCaptionType typeSettings = 

                CScSelectableShortcutList::ECaptionTypeSoftkey;

    iAppList = iShortcuts->SelectableApplicationListLC( typeSettings, *this );

    iASWait.Start();

    CleanupStack::Pop( iAppList );

    //

    // If list had already changed (and engine had not notified that to us)

    // set flag to indicate that clients data is most probably outdated

    //

    if( (oldCount > 0) && (oldCount != iAppList->Count()) )

        {

        ScSSLOHandleListChangedL();

        }

    */

    }

void CUISettingsSrvServer::SetShortcutListMaskL(CScSelectableShortcutList& aScAppList, TInt aMask)

    {

/*	RDEBUG( "CUISettingsSrvServer::SetShortcutListMaskL" );

    iIndeces.Reset();

    TInt i, count = aScAppList.Count();

    for(i=0; i<count; i++)

        {

        TScRtType rtType = aScAppList.At( i ).MScRtType();

        TInt rt = EUiSrvRtTypeNul;

        if( aMask == EUiSrvRtTypeNul)

            {

            iIndeces.AppendL( i );

            }

        else

            {

            switch( rtType.iUid )

                {

                case KScRtTypeUidValueNativeApp:

                case KScRtTypeUidValueMailbox:

                case KScRtTypeUidValueMsgEditor:

                case KScRtTypeUidValueNewMessage:

                case KScRtTypeUidValueNoEffect:

                default:

                    rt |= EUiSrvRtTypeApp;

                break;

                case KScRtTypeUidValueBookmark:

                    {

                    rt |= EUiSrvRtTypeBm;

                    TUid uid = TUid::Uid( KScCustomOpValueBookmarkGetURL );

                    HBufC* url = (HBufC*)

                             aScAppList.At( i ).MScCustomOperationL(

                                    uid,

                                    (TAny*)0,

                                    (TAny*)0

                                    );

                    delete url;               

                    }

                break;

                }

            if( (aMask & rt) == rt )

                {

                iIndeces.AppendL( i );

                }

            }

        }

    */

    }

void CUISettingsSrvServer::AddListChangeNotifierL(TInt *aFlag)

    {

	RDEBUG( "CUISettingsSrvServer::AddListChangeNotifierL" );

    iNotifyChanges.AppendL( aFlag );

    }

void CUISettingsSrvServer::RemoveListChangeNotifierL(TInt *aFlag)

    {

	RDEBUG( "CUISettingsSrvServer::RemoveListChangeNotifierL" );

    iNotifyChanges.Remove( iNotifyChanges.FindL(aFlag) );

    }

void CUISettingsSrvServer::GetShortcutTargetCountL(

                            const RMessage2 &aMessage )

    {

	RDEBUG( "CUISettingsSrvServer::GetShortcutTargetCountL" );

    SetShortcutListMaskL( *iAppList, aMessage.Int0() );

    TInt count = iIndeces.Count();

    TPckg<TInt> countp( count );

    aMessage.Write(1, countp);

    }

void CUISettingsSrvServer::GetShortcutTargetTypeL( const RMessage2 &aMessage )

    {

/*	RDEBUG( "CUISettingsSrvServer::GetShortcutTargetTypeL" );

    SetShortcutListMaskL( *iAppList, aMessage.Int0() );

    TInt index = aMessage.Int1();

    TInt type = iAppList->At( iIndeces[ index ] ).MScRtType().iUid;

    TPckg<TInt> typep( type );

    aMessage.Write(2, typep);

*/

    }

void CUISettingsSrvServer::GetShortcutTargetCaptionL( const RMessage2 &aMessage )

    {

/*	RDEBUG( "CUISettingsSrvServer::GetShortcutTargetCaptionL" );

    SetShortcutListMaskL( *iAppList, aMessage.Int0() );

    TInt index = aMessage.Int1();

    TPtrC caption( iAppList->At( iIndeces[ index ] ).MScCaption( MScShortcut::EScCaptionTypeSoftkey ) );

    aMessage.Write(2, caption);

*/

    }

void CUISettingsSrvServer::GetShortcutTargetAppUidL( const RMessage2 &aMessage )

    {

/*	RDEBUG( "CUISettingsSrvServer::GetShortcutTargetAppUidL" );

    SetShortcutListMaskL( *iAppList, aMessage.Int0() );

    TInt index = aMessage.Int1();

    TInt appUid = 0;

    const CScShortcutBase &sc = iAppList->At( iIndeces[ index ] );

    if( sc.MScRtType() == KScRtTypeUidBookmark )

        {

        appUid = (TInt)iAppList->At( iIndeces[ index ] ).CustomOperationL( KScCustomOpBookmarkGetBookmarkId, NULL, NULL );

        }

    else

        {

        appUid = (TInt)iAppList->At( iIndeces[ index ] ).CustomOperationL( KScCustomOpNativeAppGetUid, NULL, NULL );

        }

    TPckg<TInt> uidp( appUid );

    aMessage.Write(2, uidp);

*/

    }

void CUISettingsSrvServer::GetShortcutTargetIndexFromATL( const RMessage2 &aMessage )

    {

/*	RDEBUG( "CUISettingsSrvServer::GetShortcutTargetIndexFromATL" );

    SetShortcutListMaskL( *iAppList, aMessage.Int0() );

    TInt i, index = -1;

    TInt actionType = aMessage.Int1();

    const CScShortcutBase &sc = iShortcuts->ShortcutL( TUid::Uid( actionType ) );

    for(i=0; i<iIndeces.Count(); i++)