/*

* Copyright (c) 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:  Handles loading of Calendar customisation plugins

*

*/

#include <vwsdef.h>                     // TVwsViewId

#include <apadef.h>                     // TApaCommand

#include "calendarui_debug.h"

#include <hbwidget.h>

#include <hblabel.h>

#include "calencustomisationmanager.h"

#include "calencommandhandler.h"

#include "calenservices.h"

#include "calencustomisation.h"

#include <ecom/ecom.h>

#include <e32lang.h>

#include "calenservices.h"

#include "calenservicesfactory.h"

#include "CalenUid.h"

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

// CCalenCustomisationManager::NewL

// Two phased constructor

// (other items were commented in a header).

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

//

 CCalenCustomisationManager* CCalenCustomisationManager::NewL( 

                                    MCalenServicesFactory& aFactory,

                                    MCalenServices& aServices

                                    )

    {

    CCalenCustomisationManager* self = new( ELeave ) CCalenCustomisationManager(

                                                                 aFactory,

                                                                 aServices );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCalenCustomisationManager::CCalenCustomisationManager

// C++ constructor

// (other items were commented in a header).

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

//

CCalenCustomisationManager::CCalenCustomisationManager( MCalenServicesFactory& aFactory,

                                                        MCalenServices& aServices )

    : iServicesFactory( aFactory ),       

      iServices( aServices )

    {

    }

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

// CCalenCustomisationManager::ConstructL

// Second stage constructor

// (other items were commented in a header).

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

//

void CCalenCustomisationManager::ConstructL()

    {

    CreateActivePluginListL();

    // Load any enabled plugins

    DoImmediatePluginLoadingL();

    }

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

// CCalenCustomisationManager::~CCalenCustomisationManager

// Destructor

// (other items were commented in a header).

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

//

 CCalenCustomisationManager::~CCalenCustomisationManager()

    {

    // Reset and destroy the contents of the owned arrays,

    // this will delete the plugins.

    iPlugins.ResetAndDestroy();

    iPluginInfo.ResetAndDestroy();

    iActivePlugins.Reset();

    iRomBasedPlugins.Reset();

    // Close the ECOM interface

    REComSession::FinalClose();

    iDefferedUnloadPluginList.Reset();

    }

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

 // CCalenCustomisationManager::GetCommandHandlerL

 // Get a command handler for a specific command.  Ownership remains with the

 // plugin

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

 MCalenCommandHandler* CCalenCustomisationManager::GetCommandHandlerL( TInt aCommand )

     {

     MCalenCommandHandler* handler( NULL );

     // Loop though all the enabled plugins asking for a command handler

     // to handle this command with.  Returns NULL if no plugin wants to 

     // handle the command.

     TInt count = iPlugins.Count();

     for ( TInt index = 0; index < count && !handler; ++index )

         {

         TRAPD( error,

             // Loop though until a command handler is found

             for (; index < count && !handler; ++index )

                 {

                 //if ( !iPlugins[index]->IsDisabled() )

                     {

                     handler = iPlugins[index]->Plugin().CommandHandlerL( aCommand );

                     }

                 }

              );

         if ( error )

             {

             // Report a problem with plugin.

             }

         }

     return handler;

     }

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

// CCalenCustomisationManager::ActivePlugins

// Returns a reference to an array of active plugins uids

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

//

 const RArray<TUid>& CCalenCustomisationManager::ActivePlugins() const

    {

    return iActivePlugins;

    }

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

// CCalenCustomisationManager::CreateActivePluginListL

// Generates the list of active plugins

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

//

void CCalenCustomisationManager::CreateActivePluginListL()

    {

    iPluginInfo.ResetAndDestroy();

    iActivePlugins.Reset();

    iRomBasedPlugins.Reset();

    REComSession::ListImplementationsL( KCalenCustomisationInterfaceUid, iPluginInfo );

    LoadPluginsBasedOnVariantL();

    TInt pluginCount = iPluginInfo.Count();

    if(pluginCount) 

		{

    	for ( TInt pluginIndex(0); pluginIndex < pluginCount; ++pluginIndex )

			{

    		TUid pluginUid = iPluginInfo[pluginIndex]->ImplementationUid();

    		// If the plugin can not be found or if it is enabled

    		// add it to the list of active plugins

    		iActivePlugins.AppendL( pluginUid );

    		// If the plugin is rom-based, store its uid

    		if ( iPluginInfo[pluginIndex]->RomBased() )

				{

    			iRomBasedPlugins.AppendL( pluginUid );

				}

			}

		}

    }

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

// CCalenCustomisationManager::LoadPluginsBasedOnVariantL

// Loads the plugin based on the language variant

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

//

void CCalenCustomisationManager::LoadPluginsBasedOnVariantL()

{

	TLanguage languge = User::Language();

	RArray<TUid> needsToBeRemoved;

	switch(languge) 

		{

		case ELangTaiwanChinese:

		case ELangPrcChinese:

		case ELangHongKongChinese:

			// TODO: Remove the other regional plugins Thai, Vietnamese etc.

			break;

		case ELangThai:

		case ELangEnglish_Thailand:

			needsToBeRemoved.Append(KCalenChineseImplUid);

			// TODO: Remove the other regional plugin Vietnamese.

			break;

		case ELangVietnamese:

			needsToBeRemoved.Append(KCalenChineseImplUid);

			// TODO: Remove the other regional plugin Thai.

			break;

		default:

			needsToBeRemoved.Append(KCalenChineseImplUid);

			// TODO: Remove the other regional plugins Thai, Vietnamese etc.

			break;

		}

	TInt count = needsToBeRemoved.Count();

	if(count) 

		{

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

			{

			TInt index = iPluginInfo.Find(needsToBeRemoved[i],

								CCalenCustomisationManager::PluginInfoFinder);

			if( index != KErrNotFound ) 

				{

				CImplementationInformation* impl = iPluginInfo[index];

				iPluginInfo.Remove(index);

				delete impl;

				}

			}

		}

	needsToBeRemoved.Close();

}

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

// CCalenCustomisationManager::PluginInfoFinder(

// Matches an uid in pluginInfo.

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

//

TBool CCalenCustomisationManager::PluginInfoFinder( const TUid* aUid,

								const CImplementationInformation&  aArrayItem )

{

	return (*aUid  == aArrayItem.ImplementationUid() );

}

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

// CCalenCustomisationManager::SetPluginAvailabilityL

// Enables or disables the given plugin.

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

//

 void CCalenCustomisationManager::SetPluginAvailabilityL( TUid aPluginUid,

                                                                  TBool aEnabled )

    {

    if ( aEnabled )

        {

        EnablePluginL( aPluginUid );

        }

    else

        {

        DisablePluginL( aPluginUid );

        }

    }

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

// CCalenCustomisationManager::DisablePluginL

// Disables the given plugin.

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

//  

 void CCalenCustomisationManager::DisablePluginL( TUid aPluginUid )

    {

    // Find the plugins

    TInt index = iPlugins.Find( aPluginUid, CPluginInfo::Identifier );

    if ( index != KErrNotFound )

        {

        CPluginInfo* pluginInfo = iPlugins[index];

        // Check if the plugin has not already been disabled

        if ( !( pluginInfo->IsDisabled() ) )

            {

            // Mark the plugin as being disabled

            pluginInfo->Disable( ETrue );

            // Remove the plugin from the active plugin list

            TInt position = iActivePlugins.Find( aPluginUid );

            ASSERT( position != KErrNotFound );

            iActivePlugins.Remove( position );         

            // Issue notification of plugin been disabled

            iPluginsEnabledDisabled = ETrue;            

            }

            }

    }

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

// CCalenCustomisationManager::UnloadPluginsL

// When a plugin is disabled it can not be unloaded until

// any views etc it has provided have been deleted. This function

// is called when it is safe to unload the plugin.

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

//

 void CCalenCustomisationManager::UnloadPluginsL( const RArray<TUid>& aPlugins )

    {

    // Check plugin isn't already enabled

    TInt count = aPlugins.Count();

    for (TInt index = 0; index < count; ++index )

        {

        TInt position = iPlugins.Find( aPlugins[index], CPluginInfo::Identifier );

        if ( position != KErrNotFound ) 

	        {

	        	if((iInfoBarProviderUid != iPlugins[position]->Uid()))

		            {

		            CPluginInfo* removedPlugin = iPlugins[ position ];

		            iPlugins.Remove( position );

		            delete removedPlugin;

		            }

	        	else 

		        	{

		        	iPlugins[position]->Disable(ETrue);

					iDefferedUnloadPluginList.AppendL(iPlugins[position]->Uid());

		        	}

		   }

        }

    }

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

// CCalenCustomisationManager::EnablePluginL

// Enables the given plugin. Returns KErrNotFound if

// the plugin can't be found, KErrNone otherwise.

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

//

void CCalenCustomisationManager::EnablePluginL( TUid aPluginUid )

    {

    // Check plugin isn't already enabled

    TInt index = iPlugins.Find( aPluginUid, CPluginInfo::Identifier);

    if ( index == KErrNotFound )

        {

        // Load plugin

        TRAPD( error, LoadPluginL( aPluginUid ) );

        if ( error )

            {

            // report a problem loading the plugin

            }

        iActivePlugins.AppendL( aPluginUid );

        // Issue notification of plugin been added

        iPluginsEnabledDisabled = ETrue;

        iServices.IssueNotificationL( ECalenNotifyPluginEnabledDisabled );

        }

    }

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

// CCalenCustomisationManager::HandleNotificationL

// From MCalenNotificationHandler. Handles notifications.

// (other items were commented in a header).

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

//

void CCalenCustomisationManager::HandleNotification(const TCalenNotification aNotification )

    {

    PIM_TRAPD_HANDLE( HandleNotificationL(aNotification) );

    }

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

// CCalenCustomisationManager::HandleNotificationL

// Handles notifications that the list of available plugins had been changed,

// either by GS or by the ecom registry.

// When plugins are enabled or disabled inside the calendar application, this

// function will be called after the plugin enablement changes have already been 

// made.

// (other items were commented in a header).

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

//

void CCalenCustomisationManager::HandleNotificationL(TCalenNotification aNotification)

	{

	switch( aNotification )

		{

		case ECalenNotifySystemLanguageChanged:

			{

			CreateActivePluginListL();

			DoImmediatePluginLoadingL();

			}

			break;

	}

    }  

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

// CCalenCustomisationManager::PluginInfoArray

// Returns a const reference to the plugin information array.

// (other items were commented in a header).

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

//

 const RImplInfoPtrArray& CCalenCustomisationManager::PluginInfoArray() const

    {

    return iPluginInfo;

    }

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

// CCalenCustomisationManager::DoImmediatePluginLoadingL

// Examines the properties of the plugin list and

// loads those that need to loaded on start-up

// (other items were commented in a header).

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

//

void CCalenCustomisationManager::DoImmediatePluginLoadingL()

    {

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

        {

        RArray<TUid> pluginArray;

        CleanupClosePushL( pluginArray );

        pluginArray.AppendL( iPlugins[i]->Uid() );

        UnloadPluginsL( pluginArray );

        CleanupStack::PopAndDestroy(); // pluginArray

        }

    // Get the number plugins

    TInt pluginCount = iPluginInfo.Count();

    for ( TInt index( 0 ); index < pluginCount; ++index )

        {

        TUid pluginUid = iPluginInfo[index]->ImplementationUid();

        if ( iActivePlugins.Find( pluginUid ) != KErrNotFound )

            {

            TRAPD( error, LoadPluginL( pluginUid ) );

            if ( error )

                {

                // report a problem loading the plugin

                }

            }

        }

    }

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

// CCalenCustomisationManager::LoadPluginL

// Loads a plugin

// (other items were commented in a header).

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

//

void CCalenCustomisationManager::LoadPluginL( TUid aPluginUid )

    {