/*

* 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 "calenservices.h"

#include "calenservicesfactory.h"

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

// CCalenCustomisationManager::NewL

// Two phased constructor

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

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

//

 CCalenCustomisationManager* CCalenCustomisationManager::NewL( 

                                    MCalenServicesFactory& aFactory,

                                    MCalenServices& aServices

                                    )

    {

    TRACE_ENTRY_POINT;

    CCalenCustomisationManager* self = new( ELeave ) CCalenCustomisationManager(

                                                                 aFactory,

                                                                 aServices );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenCustomisationManager::CCalenCustomisationManager

// C++ constructor

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

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

//

CCalenCustomisationManager::CCalenCustomisationManager( MCalenServicesFactory& aFactory,

                                                        MCalenServices& aServices )

    : iServicesFactory( aFactory ),       

      iServices( aServices )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::ConstructL

// Second stage constructor

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

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

//

void CCalenCustomisationManager::ConstructL()

    {

    TRACE_ENTRY_POINT;

    CreateActivePluginListL();

    // Load any enabled plugins

    DoImmediatePluginLoadingL();

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::~CCalenCustomisationManager

// Destructor

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

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

//

 CCalenCustomisationManager::~CCalenCustomisationManager()

    {

    TRACE_ENTRY_POINT;

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

    TRACE_EXIT_POINT;

    }

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

 // CCalenCustomisationManager::GetCommandHandlerL

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

 // plugin

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

 MCalenCommandHandler* CCalenCustomisationManager::GetCommandHandlerL( TInt aCommand )

     {

     TRACE_ENTRY_POINT;

     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.

             }

         }

     TRACE_EXIT_POINT;

     return handler;

     }

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

// CCalenCustomisationManager::ActivePlugins

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

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

//

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

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iActivePlugins;

    }

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

// CCalenCustomisationManager::CreateActivePluginListL

// Generates the list of active plugins

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

//

void CCalenCustomisationManager::CreateActivePluginListL()

    {

    TRACE_ENTRY_POINT;

    iPluginInfo.ResetAndDestroy();

    iActivePlugins.Reset();

    iRomBasedPlugins.Reset();

    TInt pluginCount = iPluginInfo.Count();

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::SetPluginAvailabilityL

// Enables or disables the given plugin.

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

//

 void CCalenCustomisationManager::SetPluginAvailabilityL( TUid aPluginUid,

                                                                  TBool aEnabled )

    {

    TRACE_ENTRY_POINT;

    if ( aEnabled )

        {

        EnablePluginL( aPluginUid );

        }

    else

        {

        DisablePluginL( aPluginUid );

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::DisablePluginL

// Disables the given plugin.

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

//  

 void CCalenCustomisationManager::DisablePluginL( TUid aPluginUid )

    {

    TRACE_ENTRY_POINT;

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

            }

            }

    TRACE_EXIT_POINT;

    }

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

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

    {

    TRACE_ENTRY_POINT;

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

		        	}

		   }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::EnablePluginL

// Enables the given plugin. Returns KErrNotFound if

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

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

//

void CCalenCustomisationManager::EnablePluginL( TUid aPluginUid )

    {

    TRACE_ENTRY_POINT;

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

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::HandleNotificationL

// From MCalenNotificationHandler. Handles notifications.

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

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

//

void CCalenCustomisationManager::HandleNotification(const TCalenNotification aNotification )

    {

    TRACE_ENTRY_POINT;

    PIM_TRAPD_HANDLE( HandleNotificationL(aNotification) );

    TRACE_EXIT_POINT;

    }

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

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

	TRACE_EXIT_POINT;

    }  

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

// CCalenCustomisationManager::PluginInfoArray

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

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

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

//

 const RImplInfoPtrArray& CCalenCustomisationManager::PluginInfoArray() const

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

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

    {

    TRACE_ENTRY_POINT;

    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

                }

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::LoadPluginL

// Loads a plugin

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

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

//

void CCalenCustomisationManager::LoadPluginL( TUid aPluginUid )

    {

    TRACE_ENTRY_POINT;

    // Get a new services object from global data

    MCalenServices* services = iServicesFactory.NewServicesL();