/*

* Copyright (c) 2002 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:  DM ScreenSaver List

*

*/

#include "ScreenSaverList.h"

#include <implementationproxy.h> // For TImplementationProxy definition

#include <e32def.h>

#include <centralrepository.h>

#include <ScreensaverpluginIntDef.h>

#include <mmfcontrollerpluginresolver.h> // For CleanupResetAndDestroyPushL

#include "aminstalloptions.h"

#include <ScreensaverInternalCRKeys.h>

#include <ScreensaverInternalPSKeys.h>

#include "debug.h"

#include "ScreenSaverClient.h"

#include <e32property.h>

_LIT8( KSlash, "/" );

#include <e32cmn.h>

_LIT( KPslnScreenSaverTypeDateTime, "DateTime" );

_LIT( KPslnScreenSaverTypeText, "Text" );

const TInt KPslnMaxNumberOfScreenSaverText  = 15;

const TInt KPostTimeOut = 10000000; // 10 seconds

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

// CScreenSaverList* CScreenSaverList::NewL( )

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

CScreenSaverList* CScreenSaverList::NewL( )

	{

	RDEBUG("CScreenSaverList::NewL(): begin");

	CScreenSaverList* self = NewLC( );

	CleanupStack::Pop();

	return self;

	}

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

// CScreenSaverList* CScreenSaverList::NewLC( )

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

CScreenSaverList* CScreenSaverList::NewLC( )

	{

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

	CleanupStack::PushL( self );

	self->ConstructL( );

	return self;

	}

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

// CScreenSaverList::CScreenSaverList()

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

CScreenSaverList::CScreenSaverList(  )

	: iDirty( ETrue )

    , iScreenSavers( 0 )

	, iInstallOptions()

	{

	GetDefaultInstallOptions( iInstallOptions );

	}

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

// CScreenSaverList::ConstructL()

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

void CScreenSaverList::ConstructL(  )

	{

	}

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

// CScreenSaverList::~CScreenSaverList()

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

CScreenSaverList::~CScreenSaverList()

	{

	if (iScreenSavers)

		{

		iScreenSavers->ResetAndDestroy();

		delete iScreenSavers;

		}

	}

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

//  CScreenSaverList::GetScreenSaverListL()

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

MSmlDmAdapter::TError CScreenSaverList::GetScreenSaverListL( const CArrayFix<TSmlDmMappingInfo>& aPreviousList, CBufBase& aList )

	{

	CheckUpdatesL();

	CDesC8ArrayFlat* names = new (ELeave) CDesC8ArrayFlat( 32 );

	CleanupStack::PushL( names );

	CDesC8ArrayFlat* luids = new (ELeave) CDesC8ArrayFlat( 32 );

	CleanupStack::PushL( luids );

	TInt i = 0;

	// Create list of previous screen savers

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

		{

		TPtrC8 screenSaverId = ScreenSaverIdFromLUID( aPreviousList[i].iURISegLUID );

		names->AppendL( aPreviousList[i].iURISeg );

		luids->AppendL( screenSaverId );

		}

	// Find and add missing screen savers

	for (i = 0 ; i < iScreenSavers->Count() ; i++)

		{

		TInt idx = 0;

		TPtrC8 name = (*iScreenSavers)[i]->Id();

		if (luids->Find( name, idx ) != 0)

			{

			// not found

			// Check that current "name" is not in use

			if (names->Find( name, idx ) != 0)

				{

				// not found, add it

				names->AppendL( name );

				}

			}

		}

	// Fill result

	for (i = 0 ; i < names->Count() ; i++)

		{

		if (i > 0)

			{

			aList.InsertL( aList.Size(), KSlash );

			}

		aList.InsertL( aList.Size(), (*names)[i] );

		}

	// Cleanup

	CleanupStack::PopAndDestroy( luids );

	CleanupStack::PopAndDestroy( names );

	return MSmlDmAdapter::EOk;

//sf-	TInt i = 0;

//sf-	for (i = 0 ; i < iScreenSavers->Count() ; i++)

//sf-		{

//sf-		if (i > 0)

//sf-			{

//sf-			aList.InsertL( aList.Size(), KSlash );

//sf-			}

//sf-

//sf-	    CScreenSaverInfo *info = (*iScreenSavers)[i];

//sf-		aList.InsertL( aList.Size(), info->Id() );

//sf-		}

//sf-

//sf-

//sf-	return MSmlDmAdapter::EOk;

	}

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

//  CScreenSaverList::GetIdL()

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

MSmlDmAdapter::TError CScreenSaverList::GetIdL( const TDesC8& aId, CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		aResult.InsertL( aResult.Size(), screenSaverInfo->Id() );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::GetNameL()

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

MSmlDmAdapter::TError CScreenSaverList::GetNameL( const TDesC8& aId, CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		aResult.InsertL( aResult.Size(), screenSaverInfo->Name() );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::SetNameL()

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

MSmlDmAdapter::TError CScreenSaverList::SetNameL( const TDesC8& aId, const TDesC8& aData )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		screenSaverInfo->SetNameL( aData );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::GetDescriptionL()

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

MSmlDmAdapter::TError CScreenSaverList::GetDescriptionL( const TDesC8& aId, CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		aResult.InsertL( aResult.Size(), screenSaverInfo->Description() );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::SetDescriptionL()

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

MSmlDmAdapter::TError CScreenSaverList::SetDescriptionL( const TDesC8& aId, const TDesC8& aData )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		screenSaverInfo->SetDescriptionL( aData );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::GetCustomPropertyL()

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

MSmlDmAdapter::TError CScreenSaverList::GetCustomPropertyL( const TDesC8& aId, CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		aResult.InsertL( aResult.Size(), screenSaverInfo->CustomProperty() );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::SetCustomPropertyL()

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

MSmlDmAdapter::TError CScreenSaverList::SetCustomPropertyL( const TDesC8& aId, const TDesC8& aData )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		screenSaverInfo->SetCustomPropertyL( aData );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::GetVersionL()

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

MSmlDmAdapter::TError CScreenSaverList::GetVersionL( const TDesC8& aId, CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		aResult.InsertL( aResult.Size(), screenSaverInfo->Version() );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::SetVersionL()

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

MSmlDmAdapter::TError CScreenSaverList::SetVersionL( const TDesC8& aId, const TDesC8& aVersion )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		screenSaverInfo->SetVersionL( aVersion );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CScreenSaverList::GetActiveL()

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

MSmlDmAdapter::TError CScreenSaverList::GetActiveL( CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

    TInt screenSaverTypeId = 0; // Text

    TFileName screenSaverFileName;

    CRepository* repository = CRepository::NewLC( KCRUidScreenSaver );

    TInt error = repository->Get( KScreenSaverObject, screenSaverTypeId );

    if( error == KErrNone )

    	{

		if( screenSaverTypeId == 0 ) // Text

	        {

			screenSaverFileName = KPslnScreenSaverTypeText;

	        }

	    else if( screenSaverTypeId == 1 ) // Date&time

	        {

			screenSaverFileName = KPslnScreenSaverTypeDateTime;

	        }

		else if( screenSaverTypeId == 3 )// Object

			{

			error = repository->Get( KScreenSaverPluginName, screenSaverFileName );

			}

		else

			{

			error = KErrUnknown;

			}

    	}

    CleanupStack::PopAndDestroy( repository );

    if( error == KErrNone )

    	{

		TBuf8<KMaxFileName> screenSaverFileName8;

		screenSaverFileName8.Copy( screenSaverFileName );

		aResult.InsertL( aResult.Size(), screenSaverFileName8 );

    	}

    else

    	{

    	ret = MSmlDmAdapter::EError;

    	}

	return ret;

	}

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

//  CScreenSaverList::SetActiveL()

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

MSmlDmAdapter::TError CScreenSaverList::SetActiveL( const TDesC8& aId )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aId );

	if (screenSaverInfo != 0)

		{

		screenSaverInfo->ActivateL();

		}

	else

		{

		ret = MSmlDmAdapter::EError;

		}

	return ret;

	}

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

//  CScreenSaverList::SetInstallOptionsL()

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

MSmlDmAdapter::TError CScreenSaverList::SetInstallOptionsL( const TDesC8& aOptions )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	TInt errCode = KErrNone;

	GetDefaultInstallOptions( iInstallOptions );

	if (aOptions.Length() > 0)

		{

		TRAP( errCode, InstallOptionsParser::ParseOptionsL( aOptions, iInstallOptions ) );

		}

	if (errCode != KErrNone)

		{

		ret = MSmlDmAdapter::EError;

		}

	return ret;

	}

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

//  CScreenSaverList::InstallL()

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

MSmlDmAdapter::TError CScreenSaverList::InstallL( const TDesC& aFileName )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	TInt errCode = KErrNone;

	iDirty = ETrue;

	// Install using options if given and otherwise with default options

	SwiUI::RSWInstLauncher installer;

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

	CleanupClosePushL( installer );

	SwiUI::TInstallOptionsPckg optPckg( iInstallOptions );

	errCode = installer.SilentInstall( aFileName, optPckg );

	CleanupStack::PopAndDestroy( &installer );

	if (errCode != KErrNone)

		{

		ret = MSmlDmAdapter::EError;

		}

	return ret;

	}

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

//  CScreenSaverList::DeleteL()

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

MSmlDmAdapter::TError CScreenSaverList::DeleteL( const TDesC8& aLUID )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	TInt errCode = KErrNone;

	CScreenSaverInfo* screenSaverInfo = FindByIdL( aLUID );

	if( screenSaverInfo != NULL )

		{

	    CRepository* repository = CRepository::NewLC( KCRUidScreenSaver );

	    if( screenSaverInfo->TypeId() == CScreenSaverInfo::EObject )

	        {

		    TFileName screenSaverFileName;

		    screenSaverFileName.Copy( screenSaverInfo->FileName() );

		    TFileName repFileName;

			repository->Get( KScreenSaverPluginName, repFileName );

			if( repFileName == screenSaverFileName )

				{

				TBuf<KPslnMaxNumberOfScreenSaverText> screenText;

				screenText.Copy( screenSaverInfo->CustomProperty() );

		        errCode = repository->Set( KScreenSaverText, screenText );

				errCode = repository->Set( KScreenSaverObject, CScreenSaverInfo::EText );  

				TRequestStatus timeoutStatus /*= KRequestPending*/;

				RTimer timeout;

				User::LeaveIfError( timeout.CreateLocal() );

				CleanupClosePushL( timeout );

				timeout.After( timeoutStatus, KPostTimeOut );

				User::WaitForRequest( timeoutStatus );

				if( timeoutStatus.Int() == KRequestPending)

					{

					timeout.Cancel();

					User::WaitForRequest( timeoutStatus );

					}

				CleanupStack::PopAndDestroy( &timeout );

				}

	        }

	    CleanupStack::PopAndDestroy( repository );

		}

	else

		{

		errCode = KErrNotFound;

		}

	if( errCode == KErrNone )

		{

		iDirty = ETrue;

		TUint pkgUid = 0;

		TLex8 parser( aLUID );

		if ((parser.Get() == '[') &&

			(parser.Val( pkgUid, EHex ) == KErrNone) &&

			(parser.Get() == ']'))

			{

			// Uninstall silent

			SwiUI::RSWInstLauncher installer;

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

			CleanupClosePushL( installer );

			SwiUI::TUninstallOptions uninstallOptions;

			SwiUI::TUninstallOptionsPckg optPckg( uninstallOptions );

			errCode = installer.SilentUninstall( TUid::Uid( pkgUid ), optPckg, SwiUI::KSisxMimeType() );

			CleanupStack::PopAndDestroy( &installer );

			}

		}

	if (errCode == KErrNotFound)

		{

		ret = MSmlDmAdapter::ENotFound;

		}

	else if (errCode != KErrNone)

		{

		ret = MSmlDmAdapter::EError;

		}

	return ret;

	}