/*

* Copyright (c) 2008 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:  Manages the call bubble extension plugins.

*

*/

#include <badesca.h>

#include <ecom.h>

#include <telbubbleextension.h>

#include "phonebubbleextension.h"

#include "phonebubbleextensionmanager.h"

#include "phonebubbleextensiondata.h"

const TUint8 KDefaultPriority(255);

/**

* This is a support class that is used to carry relation of plugin UId and the

* assigned priority. Used inside an ordered array only. 

*/

class TPriorityItem

{

public:

    TPriorityItem( const TUid aUid, const TUint8 aPriority )

            : iUid(aUid),iPriority(aPriority){};

    const TUid Uid() const

            { return iUid; };

    TUint8 Priority() const

            { return iPriority; };

    TBool operator==( const TPriorityItem& aOther ) const

            { return iUid == aOther.Uid(); };

    TBool operator<( const TPriorityItem& aOther ) const

            { return iUid.iUid < aOther.Uid().iUid; };

    static TInt Compare( const TPriorityItem& aFirst, 

            const TPriorityItem& aSecond )

            {

            if( aFirst < aSecond )

                {

                return -1;

                }

            if( aFirst == aSecond )

                {

                return 0;

                }

            return 1;

            };

private:

    TPriorityItem();

private:

    const TUid iUid;

    const TUint8 iPriority;

};

// ======== LOCAL FUNCTIONS ========

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

// ECOM array cleanupstack support function

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

//

void CleanupEComArray(TAny* aArray)

    {

    (static_cast<RImplInfoPtrArray*> (aArray))->ResetAndDestroy();

    (static_cast<RImplInfoPtrArray*> (aArray))->Close();

    }

// ======== MEMBER FUNCTIONS ========

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

// Two-phase constructor

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

//

CPhoneBubbleExtensionManager* CPhoneBubbleExtensionManager::NewL(

    CBubbleManager& aBubbleManager )

    {

    CPhoneBubbleExtensionManager* self = 

        CPhoneBubbleExtensionManager::NewLC( aBubbleManager );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phase constructor

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

//

CPhoneBubbleExtensionManager* CPhoneBubbleExtensionManager::NewLC(

    CBubbleManager& aBubbleManager )

    {

    CPhoneBubbleExtensionManager* self = 

        new( ELeave ) CPhoneBubbleExtensionManager( aBubbleManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// destructor

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

//

CPhoneBubbleExtensionManager::~CPhoneBubbleExtensionManager()

    {

    Reset();

    iPriorityArray.Close();

    }

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

// Notifies the plugin framework about a new call.

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

//

void CPhoneBubbleExtensionManager::StartCallL( 

    TInt aBubbleId, 

    TPhoneCmdParamCallHeaderData* aParams )

    {

    if ( !iInitialized )

        {

        // Load plugins (happens on first call)

        InitializeL();

        }

    if ( iPlugins.Count() > 0 ) // Call added only if any plugins

        {

        // create call data

        CPhoneBubbleExtensionData* callData = CPhoneBubbleExtensionData::NewLC( 

                aBubbleId,

                aParams,

                ( iCalls.Count() == 0 ) );

        // insert to array

        iCalls.AppendL( callData ); // ownership transferred

        CleanupStack::Pop( callData );

        // notify all plugins

        const TUint pluginCount = iPlugins.Count();

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

            {

            iPlugins[index]->StartCustomizedBubble( *callData );

            }

        }

    }

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

// Notifies the plugin framework about cleared call.

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

//

void CPhoneBubbleExtensionManager::StopCall( TInt aBubbleId)

    {

    // find call data

    TBool found(EFalse);

    TUint callIndex(0);

    const TUint callCount = iCalls.Count();

    while ( callIndex < callCount && !found )

        {

        found = ( iCalls[callIndex]->BubbleId() == aBubbleId );

        if ( !found )

            {

            callIndex++;

            }

        }

    if ( found )

        {

        // notify all plugins

        const TUint pluginCount = iPlugins.Count();

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

            {

            iPlugins[index]->StopCustomizedBubble( *iCalls[callIndex] );

            }

        // destroy call data

        delete iCalls[callIndex];

        iCalls.Remove( callIndex );

        }

    }

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

// Notifies the plugin framework about changed call state.

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

//

void CPhoneBubbleExtensionManager::UpdateCallState( 

    TInt aBubbleId, 

    TInt aNewState )

    {

    // find call data

    TBool found(EFalse);

    TUint callIndex(0);

    const TUint callCount = iCalls.Count();

    while ( callIndex < callCount && !found )

        {

        found = ( iCalls[callIndex]->BubbleId() == aBubbleId );

        if ( !found )

            {

            callIndex++;

            }

        }

    if ( found )

        {

        // modify call data

        iCalls[callIndex]->SetState( aNewState, ( iCalls.Count() == 0 ) );

        // notify all plugins

        const TUint pluginCount = iPlugins.Count();

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

            {

            iPlugins[index]->BubbleUpdating();

            }

        }

    }

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

// Loads all plugins

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

//

void CPhoneBubbleExtensionManager::InitializeL()

    {

    if ( !iInitialized )

        {

        // load list of plugins

        RImplInfoPtrArray pluginArray;

        TCleanupItem cleanup( CleanupEComArray, &pluginArray );

        CleanupStack::PushL( cleanup );

        REComSession::ListImplementationsL(

                KTelBubbleExtensionInterfaceUid, 

                pluginArray);

        // loop through the list, load plugin and insert to array 

        CPhoneBubbleExtension* plugin;

        const TUint count( pluginArray.Count() );

        for ( TUint index(0); index < count; index++ )

            {

            // Plugin UID

            TUid uid = pluginArray[index]->ImplementationUid();

            // Plugin priority

            TUint8 priority( KDefaultPriority ); // for unknown plugins 

            TInt priorityIndex = iPriorityArray.FindInOrder(

                    TPriorityItem( uid, 0 ),

                    TLinearOrder<TPriorityItem>( TPriorityItem::Compare ));

            if ( priorityIndex >= 0)

                {

                // Priority for this plugin found.

                priority = iPriorityArray[priorityIndex].Priority();

                }

            // Load plugin:

            TRAP_IGNORE( 

                plugin = CPhoneBubbleExtension::NewLC( iBubbleManager, 

                                                       uid, 

                                                       priority );

                // Plugin was loaded successfully

                iPlugins.AppendL( plugin ); // ownership trasferred

                CleanupStack::Pop( plugin );

                );

            }

        // Clean up

        CleanupStack::PopAndDestroy(); // pluginArray

        iInitialized = ETrue;

        }

    }

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

// First phase constructor

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

//

CPhoneBubbleExtensionManager::CPhoneBubbleExtensionManager(

    CBubbleManager& aBubbleManager )

    :iBubbleManager( aBubbleManager ), iInitialized(EFalse)

    {

    // no implementation needed

    }

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

// Second phase constructor

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

//

void CPhoneBubbleExtensionManager::ConstructL()

    {

    // Load priorities

    LoadPrioritiesL();

    // Currently, the plugins are loaded when the first call happens,

    // not during construction. This avoids the situation where phone might

    // panic during boot up if there's a bad plugin which panics when loaded.

    }

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

// Loads plugin priorities.

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

//

void CPhoneBubbleExtensionManager::LoadPrioritiesL()

    {

    // Currently plugin priorities are not in use. No array is loaded,

    // therefore all plugins get default priority as the priority is not

    // found during the loading.

    // Here's an example implementation how to insert loaded priority data

    // (UID + priority pairs) into the array:

    // iPriorityArray.InsertInOrderL(

    //        TPriorityItem( TUid::Uid(0x12345789), 5 ),

    //        TLinearOrder<TPriorityItem>( TPriorityItem::Compare ));

    }

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

// Unloads all plugins, closes all calls

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

//

void CPhoneBubbleExtensionManager::Reset()

    {

    // Close all calls

    for ( TInt callIndex(0); callIndex < iCalls.Count(); callIndex++ )

        {

        // notify all plugins

        const TUint pluginCount = iPlugins.Count();

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

            {

            iPlugins[index]->StopCustomizedBubble( *iCalls[callIndex] );

            }

        // destroy call data

        delete iCalls[callIndex];

        }

    iCalls.Close();

    // Unload plugins

    for ( TInt index(0); index < iPlugins.Count(); index++ )

        {

        delete iPlugins[index];

        }

    iPlugins.Close();

    iInitialized = EFalse;

    }