/*

* 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 Themes List

*

*/

#include "ThemesList.h"

#include <badesca.h>

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

#include <e32def.h>

#include <centralrepository.h>

#include <AknSkinsInternalCRKeys.h>

#include <sisregistrysession.h>

#include <sisregistrypackage.h>

#include "FileCoderB64.h"

#include "aminstalloptions.h"

#include "debug.h"

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVEs

_LIT8( KSlash, "/" );

_LIT8(KCol,":");

const TInt KPostTimeOut = 10000000; // 10 seconds

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

// CThemesList* CThemesList::NewL( )

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

CThemesList* CThemesList::NewL( ) //sf-MSmlDmCallback* aDmCallback )

	{

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

	CThemesList* self = NewLC();

	CleanupStack::Pop();

	return self;

	}

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

// CThemesList* CThemesList::NewLC( )

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

CThemesList* CThemesList::NewLC( ) //sf-MSmlDmCallback* aDmCallback )

	{

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

	CleanupStack::PushL( self );

	self->ConstructL( );

	return self;

	}

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

// CThemesList::CThemesList()

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

CThemesList::CThemesList( ) //sf-MSmlDmCallback* aDmCallback )

//sf-	: iCallBack( aDmCallback )

	: iDirty( ETrue )

    , iAknsSrv( )

    , iSkins( 0 )

	, iInstallOptions()

	{

	GetDefaultInstallOptions( iInstallOptions );

	}

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

// CThemesList::ConstructL()

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

void CThemesList::ConstructL(  )

	{

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

	}

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

// CThemesList::~CThemesList()

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

CThemesList::~CThemesList()

	{

	if (iSkins)

		{

		iSkins->ResetAndDestroy();

		delete iSkins;

		}

	iAknsSrv.Close();

	}

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

//  CThemesList::GetInstalledPIDListL()

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

MSmlDmAdapter::TError CThemesList::GetInstalledPIDListL( const CArrayFix<TSmlDmMappingInfo>& aPreviousList, CDesC8ArrayFlat& themes, CDesC8Array& aNewThemes )

	{

	TInt i = 0;

	TInt pos = 0;

	CheckUpdatesL();

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

	CleanupStack::PushL( luids );

	// Create list of existing themes

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

		{

		themes.AppendL( aPreviousList[i].iURISeg );

		luids->AppendL( aPreviousList[i].iURISegLUID );

		}

	// Find and add missing themes

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

		{

		TAknsPkgIDBuf pidBuf;

		TBuf8<KSmlMaxURISegLen> name;

        TAknsPkgID pid = (*iSkins)[i]->PID();

        pid.CopyToDes( pidBuf );

        name.Copy( pidBuf );

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

			{

			// not found

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

			if (themes.Find( name, pos ) != 0)

				{

				// not found

				// add it to both current and new themes

			//	themes->AppendL( name );

				aNewThemes.AppendL( name );

				}

			}

		}

	// Fill result

#if 0

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

		{

		if (i > 0)

			{

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

			}

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

		}

#endif

	// Cleanup

	CleanupStack::PopAndDestroy( luids );

	//CleanupStack::PopAndDestroy( themes );

	return MSmlDmAdapter::EOk;

	}

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

//  CThemesList::GetThemeIdL()

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

MSmlDmAdapter::TError CThemesList::GetThemeIdL( const TDesC8& aPID, CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CAknsSrvSkinInformationPkg* theme = FindThemeL( aPID );

	if (theme != 0)

		{

		TAknsPkgIDBuf pid;

		theme->PID().CopyToDes( pid );

		TBuf8<KAknsPkgIDDesSize> pid8;

		pid8.Copy( pid );

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

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CThemesList::GetThemeNameL()

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

MSmlDmAdapter::TError CThemesList::GetThemeNameL( const TDesC8& aPID, CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CAknsSrvSkinInformationPkg* theme = FindThemeL( aPID );

	if (theme != 0)

		{

		TDesC& name = theme->Name();

		HBufC8* buf = HBufC8::NewLC( name.Length() );

		buf->Des().Copy( name );

		aResult.InsertL( aResult.Size(), *buf );

		CleanupStack::PopAndDestroy( buf );

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CThemesList::GetThemeVersionL()

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

MSmlDmAdapter::TError CThemesList::GetThemeVersionL( const TDesC8& aPID, CBufBase& /*aResult*/ )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::ENotFound;

	CAknsSrvSkinInformationPkg* theme = FindThemeL( aPID );

	if (theme != 0)

		{

		// Empty version, not supported (yet?)

		ret = MSmlDmAdapter::EOk;

		}

	return ret;

	}

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

//  CThemesList::GetActiveThemeL()

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

MSmlDmAdapter::TError CThemesList::GetActiveThemeL( CBufBase& aResult )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	TInt errCode = KErrNone;

	TAknsPkgID pid = KAknsNullPkgID;

    TAknsPkgIDBuf buf;

    CRepository* skinsRepository = CRepository::NewLC( KCRUidPersonalisation );

    errCode = skinsRepository->Get( KPslnActiveSkinUid, buf );

    if( errCode == KErrNone )

        {

        TRAP( errCode, pid.SetFromDesL( buf ) );

        }

    if( errCode != KErrNone )

        {

//sf-        pid.Set( KAknsPIDDefaultSystemSkin );

//sf- changes to KAknsPIDS60DefaltSystemSkin and

//sf-         to KAknsPIDProductDefaultSystemSkin

//sf- and the product default should be used (because variation might be done).

//sf- Starting from S60 3.1 wk50 or wk52

//sf- But: CenRep key should always hold a value so this code is not necessary.

        }

    pid.CopyToDes( buf );

	CleanupStack::PopAndDestroy( skinsRepository );

	skinsRepository = 0;

	TBuf8<KAknsPkgIDDesSize> buf8;

	buf8.Copy( buf );

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

	return ret;

	}

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

//  CThemesList::SetActiveThemeL()

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

MSmlDmAdapter::TError CThemesList::SetActiveThemeL( const TDesC8& aPID )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	TInt errCode = KErrNone;

	CAknsSrvSkinInformationPkg* theme = FindThemeL( aPID );

	if (theme == 0)

		{

		errCode = KErrNotFound;

		}

	if (errCode == KErrNone)

		{

		errCode = iAknsSrv.SetAllDefinitionSets( theme->PID() );

		}

	if (errCode == KErrNone)

		{

		// Save settings to repository

        TAknsPkgIDBuf pidBuf;

        theme->PID().CopyToDes( pidBuf );

		TAknSkinSrvSkinPackageLocation location =

			LocationFromPath( theme->IniFileDirectory() );

		CRepository* skinsRepository = CRepository::NewLC( KCRUidPersonalisation );

        errCode = skinsRepository->Set( KPslnActiveSkinUid, pidBuf );

        errCode = skinsRepository->Set( KPslnActiveSkinLocation, location );

        CleanupStack::PopAndDestroy( skinsRepository );

		}

	if (errCode != KErrNone)

		{

		ret = MSmlDmAdapter::EError;

		}

	return ret;

	}

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

//  CThemesList::SetInstallOptionsL()

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

MSmlDmAdapter::TError CThemesList::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;

	}

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

//  CThemesList::InstallThemeL()

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

MSmlDmAdapter::TError CThemesList::InstallThemeL( const TDesC& aFileName, TDes8& aSisPkgUid, TDes8& aThemePkgId )

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	TInt errCode = KErrNone;

	CDesC8Array* pkgUidsOrg = InstalledPackagesL( );

	CleanupStack::PushL( pkgUidsOrg );

	CDesC8Array* thmPidsOrg = InstalledThemesL( );

	CleanupStack::PushL( thmPidsOrg );

	// 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 );

	// Retrieve new list of installed packages and themes

	CDesC8Array* pkgUidsNew = InstalledPackagesL( );

	CleanupStack::PushL( pkgUidsNew );

	CDesC8Array* thmPidsNew = InstalledThemesL( );

	CleanupStack::PushL( thmPidsNew );

	// Try to find sis package uid and theme package id

	CDesC8Array* pkgUidsDif = FindNewItemsL( *pkgUidsOrg, *pkgUidsNew );

	CleanupStack::PushL( pkgUidsDif );

	CDesC8Array* thmPidsDif = FindNewItemsL( *thmPidsOrg, *thmPidsNew );

	CleanupStack::PushL( thmPidsDif );

	if (pkgUidsDif->Count() == 1)

		{

		aSisPkgUid = (*pkgUidsDif)[0];

		}

	if (thmPidsDif->Count() > 0)

		{

		aThemePkgId = (*thmPidsDif)[0];

		}

	RDEBUG_2( " CThemesList::InstallThemeL : SISPKGUID %X", &(aSisPkgUid) );

	RDEBUG_2( " CThemesList::InstallThemeL : THEMEPKGUID %X", &(aThemePkgId) );

	// Cleanup

	CleanupStack::PopAndDestroy( thmPidsDif );

	CleanupStack::PopAndDestroy( pkgUidsDif );

	CleanupStack::PopAndDestroy( thmPidsNew );

	CleanupStack::PopAndDestroy( pkgUidsNew );

	CleanupStack::PopAndDestroy( thmPidsOrg );

	CleanupStack::PopAndDestroy( pkgUidsOrg );

	// Convert error code

	if (errCode != KErrNone)

		{

		ret = MSmlDmAdapter::EError;

		}

	return ret;

	}

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

//  CThemesList::DeleteThemeL()

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

MSmlDmAdapter::TError CThemesList::DeleteThemeL( const TDesC8& aThemeId, const TUid& aPkgUid,HBufC8* aLuid)

	{

	MSmlDmAdapter::TError ret = MSmlDmAdapter::EOk;

	TInt errCode = KErrNone;

	CAknsSrvSkinInformationPkg* theme = FindThemeL( aThemeId );

	if (theme != NULL)

		{

		// Save settings to repository

        TAknsPkgIDBuf pidBuf;

        TAknsPkgID themepid = theme->PID();

        themepid.CopyToDes(pidBuf);

        CRepository* skinsRepository = CRepository::NewLC(

                KCRUidPersonalisation);

        TAknsPkgIDBuf repBuf;

        errCode = skinsRepository->Get(KPslnActiveSkinUid, repBuf);

        if (errCode == KErrNone)

            {

            TAknsPkgID activepid = KAknsNullPkgID;

            activepid.SetFromDesL(repBuf);

            //Comparing the UIds of the active theme and the theme to be deleted

            if (themepid.Uid() == activepid.Uid())

                {

                // deleted theme is active theme, deactive it first

                TInt count = iSkins->Count();

                if (count > 1)

                    {

                    pidBuf.Zero();

                    CAknsSrvSkinInformationPkg* defaultTheme = (*iSkins)[0];

                    defaultTheme->PID().CopyToDes(pidBuf);

                    TBuf8<KAknsPkgIDDesSize> pidBuf8;

                    pidBuf8.Copy(pidBuf);

                    errCode = SetActiveThemeL(pidBuf8);

                    if (errCode == KErrNone)

                        {

                        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);

                        }

                    }

                else

                    {

                    errCode = KErrGeneral;

                    }

                }

            CleanupStack::PopAndDestroy(skinsRepository);

            }

        }

    else

        {

        errCode = KErrNotFound;

        }

	if( errCode == KErrNone )

		{

		iDirty = ETrue;

		// Uninstall silent

		SwiUI::RSWInstLauncher installer;

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

		CleanupClosePushL( installer );

		//Silent uninstall not working because of getting wrong package name

		//So we used SilentCustomUninstall which uses  index and pkgUid to get correct package name

		TInt idx( KErrNotFound );

		SwiUI::TOpUninstallIndexParam params;

        params.iUid = aPkgUid;

        TPtrC8 ptr1 = aLuid->Des();

       	idx= ptr1.Find(KCol);

       	if(idx != KErrNotFound)

       		{

        	TPtrC8 ptr = ptr1.Right((ptr1.Length()-idx)-1);

        	TLex8 lex(ptr); 

			lex.Val(params.iIndex); 

       		}

       	else

       		{

       	    ret = MSmlDmAdapter::ENotFound;

			}

        SwiUI::TOpUninstallIndexParamPckg pckg( params );

		SwiUI::TOperation operation( SwiUI::EOperationUninstallIndex );

		SwiUI::TUninstallOptions uninstallOptions;

		SwiUI::TUninstallOptionsPckg optPckg( uninstallOptions );

  		errCode = installer.SilentCustomUninstall( operation, optPckg, pckg,SwiUI::KSisxMimeType() );

		RDEBUG_2("CThemesList::DeleteThemeL Uninstall silent :  errCode %X",errCode );

		CleanupStack::PopAndDestroy( &installer );

		}

	if (errCode == KErrNotFound)

		{

		ret = MSmlDmAdapter::ENotFound;

		}

	else if (errCode != KErrNone)

		{

		ret = MSmlDmAdapter::EError;

		}

	return ret;

	}

///////////////////////////////////////////////////////////////////////////////////////////////////

//

// Internal methods

//

///////////////////////////////////////////////////////////////////////////////////////////////////

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

//  CThemesList::CheckUpdatesL()

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