/*

* 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 <eikmenup.h>

#include <ecom/ecom.h>

#include <Calendar.rsg>

#include <aknsettingitemlist.h>          // CAknSettingItem

#include <calencommandhandler.h>

#include <calencustomisation.h>

#include <calenservices.h>

#include <mcalenpreview.h>

#include "calensend.h"

#include "calenviewinfo.h"

#include "calendarui_debug.h"

#include "calencustomisationmanager.h"

#include "calencontroller.h"

#include "calensetting.h"

#include "CalenUid.h"

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

// CCalenCustomisationManager::NewL

// Two phased constructor

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

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

//

EXPORT_C CCalenCustomisationManager* CCalenCustomisationManager::NewL( 

                                    MCalenServicesFactory& aFactory,

                                    CCalenPluginStatusArray& aPluginSettingsStatus,

                                    MCalenServices& aServices,

                                    RPointerArray<CCalenViewInfo>& aViewArray )

    {

    TRACE_ENTRY_POINT;

    CCalenCustomisationManager* self = new( ELeave ) CCalenCustomisationManager(

                                                                 aFactory,

                                                                 aServices,

                                                                 aViewArray,

                                                                 aPluginSettingsStatus );

    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,

                                                        RPointerArray<CCalenViewInfo>& aViewArray,

                                                        CCalenPluginStatusArray& aPluginSettingsStatus )

    : iServicesFactory( aFactory ),

      iViewInfoArray( aViewArray ),

      iSortOrder( CCalenViewInfo::CyclePositionComparison ), 

      iServices( aServices ),

      iPluginSettingsStatus( aPluginSettingsStatus )

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::ConstructL

// Second stage constructor

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

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

//

void CCalenCustomisationManager::ConstructL()

    {

    TRACE_ENTRY_POINT;

    iInfoBarProviderUid = TUid::Uid(0);

    iPreviewPaneProviderUid = TUid::Uid(0);

    // Get a pointer to the global data and controller

    iGlobalData = CCalenGlobalData::InstanceL();

    // Get the setting singleton. We update it when settings change.

    iSetting = CCalenSetting::InstanceL();

    CreateActivePluginListL();

    // Load any enabled plugins

    DoImmediatePluginLoadingL();

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::~CCalenCustomisationManager

// Destructor

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

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

//

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

    // reset deferred unload plugins list

    iDefferedUnloadPluginList.Reset();

    // Close the ECOM interface

    REComSession::FinalClose();

    // Release the global data and controller

    if ( iGlobalData )

        {

        iGlobalData->Release();

        }

    if(iSetting)

        {

        iSetting->Release();

        }

    iHiddenViews.Reset();

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::GetCommandHandlerL

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

// plugin

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

EXPORT_C 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::GetPluginSettingsL

// Gets custom settings from the specified plugin

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

//

EXPORT_C void CCalenCustomisationManager::GetPluginSettingsL( TUid aPluginUid,

                                                              RPointerArray<CAknSettingItem>& aSettingArray )

    {

    TRACE_ENTRY_POINT;

    CCalenCustomisation* plugin = FindPluginL( aPluginUid );

    User::LeaveIfNull( plugin );

    TRAPD( error, plugin->GetCustomSettingsL( aSettingArray ));

    if ( error )

            {

            // Report a problem with plugin.

            }

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::ActivePlugins

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

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

//

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

    //Added resolver for corolla release

    // Set resolver params

    /*TLanguage lang = User::Language();

    TBuf8<40> langStr;

    langStr.Format( _L8("language(%d)"), lang );

    TEComResolverParams resolverParams;

    resolverParams.SetDataType( langStr );

    resolverParams.SetGenericMatch( ETrue );*/

    REComSession::ListImplementationsL( KCalenCustomisationInterfaceUid,/* resolverParams,*/ iPluginInfo );

    LoadPluginsBasedOnVariantL();

    TInt pluginCount = iPluginInfo.Count();

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

        {

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

        // Find the plugin in the list of known plugins 

        TInt position = iPluginSettingsStatus.Find( pluginUid, PluginAvailabilityFinder );

        if ( ( position == KErrNotFound ) || ( iPluginSettingsStatus[position].iEnabled ) )

            {

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

                }

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::GetCustomViewsL

// GetCustomViews returns custom views info in an array for a given

// plugin. 

// NOTE: The contents of the array are owned by the caller - caller

// must guarantee to call ResetAndDestroy on the array in all cases.

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

//

EXPORT_C void CCalenCustomisationManager::GetCustomViewsL( TUid aPluginUid, 

                                                           RPointerArray<CCalenView>& aViews )

    {

    TRACE_ENTRY_POINT;

    CCalenCustomisation* plugin = FindPluginL( aPluginUid );

    User::LeaveIfNull( plugin );

    TRAPD( error, plugin->GetCustomViewsL( aViews ));

    if ( error )

        {

        // Report a problem with plugin.

        }

    TInt numViews = aViews.Count();

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

        {

        CCalenView* customView = aViews[index];

        // Add to view info array

        const TUid viewId = customView->Id();

         // Check for duplicate view ids. 

        TInt position = iViewInfoArray.Find( viewId , 

                                     CCalenViewInfo::ViewInfoIdentifier );

        if ( position == KErrNotFound )

            {

            const TDesC& menuName = customView->LocalisedViewNameL( CCalenView::EMenuName );

            const TDesC& settingsName = customView->LocalisedViewNameL( CCalenView::ESettingsName );

            const CCalenView::TCyclePosition cyclePos = customView->CyclePosition();

            CCalenViewInfo* viewInfo = CCalenViewInfo::NewL( viewId,

                                                             aPluginUid, 

                                                             menuName,

                                                             settingsName,

                                                             cyclePos );

            // Check if the view has already been hidden.

            TBool hidden = ( iHiddenViews.Find( viewId.iUid ) != KErrNotFound );

            viewInfo->Hide( hidden );                     

            ViewInfoArray().InsertInOrderAllowRepeatsL( viewInfo, iSortOrder );

            }

         else

            {

            // A plugin with the same id already exists. ( It could be a replacement

            // view provided by a rom plugin, as currently preventing rom plugins from

            // being disabled if required is not implemented, it needs to be handled)

            delete customView;

            aViews.Remove( index );

            index--; 

            numViews--;

            // Report a problem with plugin.

            }

         }

	RArray<TInt> hiddenViews;

    CleanupClosePushL( hiddenViews );

    plugin->RemoveViewsFromCycle( hiddenViews );

    TInt hiddenViewCount = hiddenViews.Count();

    if ( hiddenViewCount )

       {

       // Get the default view form the settings to check if it is going to be hidden

       // by the installed plugin

       TUid defaultView = iSetting->DefaultView();

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

           {

           TInt hiddenViewId = hiddenViews[index];

          // iHiddenViews.InsertInOrderAllowRepeatsL( hiddenViewId );

           // If this view is already on the view cycle list it needs

           // to be hidden.

           TUid hiddenViewUid = TUid::Uid( hiddenViewId );

           // If the current default view is hidden, then set the newly

           // installed plugin view as default view

           if(defaultView == hiddenViewUid)

               {

               TInt position = iViewInfoArray.Find( aPluginUid, 

                                                    CCalenViewInfo::ViewPluginIdentifier );

               if(position != -1)

                   {

                   for(TInt i = position; i < iViewInfoArray.Count(); i++)

                       {

                       if((iViewInfoArray[i]->PluginUid() == aPluginUid) &&

                               (iViewInfoArray[i]->CyclePosition() != CCalenView::ENoCyclePosition))

                           {

                           iSetting->SetDefaultView(iViewInfoArray[i]->ViewUid());

                           break;

                           }

                       }

                   }

               }

           }

       }

   CleanupStack::PopAndDestroy(); // removedViews

    TRACE_EXIT_POINT;

    }

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

// CCalenCustomisationManager::SetPluginAvailabilityL

// Enables or disables the given plugin.

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

//

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

            iActivePlugins.Remove( position );

            // Does this plugin hide any views

            RArray<TInt> removedViews;

            CleanupClosePushL( removedViews );

            CCalenCustomisation& plugin = pluginInfo->Plugin();

            plugin.RemoveViewsFromCycle( removedViews );

            TInt hiddenViewsCount = removedViews.Count();

            if ( hiddenViewsCount )

                {

                // Need to recalculate which views have been hidden, as 

                // more than one plugin might have hidden the same view.

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

                    {

                    TUid viewUid = TUid::Uid( removedViews[index] );

                    CheckHiddenViewL( viewUid, aPluginUid );

                    }

                }

            // If the plugin does not offer any views, or the current

            // info or preview bar it can be deleted immediately,

            // otherwise the customisation needs to wait until it

            // is told it is safe to do so.

            // Does this plugin does not offer any views and the plugin

            // doesn't offer the current infobar or preview pane

            // bar it can be deleted immediately

            TInt offerViews = iViewInfoArray.Find( aPluginUid, 

                                       CCalenViewInfo::ViewPluginIdentifier );

            if ( offerViews == KErrNotFound &&

                 iInfoBarProviderUid != aPluginUid

                 && iPreviewPaneProviderUid != aPluginUid )

                {

                RArray<TUid> pluginArray;

                CleanupClosePushL( pluginArray );

                pluginArray.AppendL( aPluginUid );

                UnloadPluginsL( pluginArray );

                CleanupStack::PopAndDestroy(); // pluginArray

                }

            // Issue notification of plugin been disabled

            iPluginsEnabledDisabled = ETrue;

            iServices.IssueNotificationL( ECalenNotifyPluginEnabledDisabled );

            CleanupStack::PopAndDestroy(); // removedViews

            }

        }

    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.

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

//

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

	        {

            TUid pluginUid = iPlugins[ position]->Uid();

                {

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

                        && (iPreviewPaneProviderUid != iPlugins[ position]->Uid()))

                        {

                        CPluginInfo* removedPlugin = iPlugins[ position ];                   

                        iPlugins.Remove( position );

                        delete removedPlugin;

                        }

                    else 

                        {

                        iPlugins[position]->Disable(ETrue);

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

                        iInfoBarProviderUid = KNullUid;

                        iPreviewPaneProviderUid = KNullUid;

                        }

                }     

		   }

        }

    TRACE_EXIT_POINT;

    }