/*
* Copyright (c) 2004-2005 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:  Implementation of CallUI plugin.
*
*/



// INCLUDE FILES
#include    "CaUiPlugin.h"  // This class interface.
#include    "cauieng.h"     // CaUiEngine.
#include    <AiwCommon.hrh> // AIW constants.
#include    "CaUI.hrh"      // CallUI constants.
#include    <AiwMenu.h>     // AIW Menu pane.

#include	<AiwServiceHandler.h>
#include    <PhCltTypes.h>  // PhoneClient types.
#include    "cauilogger.h"  // Call Ui Logger
#include    <StringLoader.h>
#include    <CallUI.rsg>
#include    <featmgr.h>      // FeatureManager.

// CONSTANTS

// Empty filename for initialization.
_LIT( KCaUiNullResFile, "" );

// The library to be loaded.
_LIT( KCaUiLoadedLib, "CaUiEngine.dll" );



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

// -----------------------------------------------------------------------------
// CCaUiPlugin::CCaUiPlugin
// 
// C++ constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CCaUiPlugin::CCaUiPlugin()
    {
    }

// -----------------------------------------------------------------------------
// CCaUiPlugin::ConstructL
// 
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCaUiPlugin::ConstructL()
    {
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::ConstructL() Begin");
    User::LeaveIfError( iLibrary.Load( KCaUiLoadedLib ) );

    // Call function CreateCaUiEngFactoryL()
    TInt res = iLibrary.Lookup( 1 )();
    CCaUiEngFactory* caUiEngFactory = 
        reinterpret_cast< CCaUiEngFactory* >( res );

    iCaUiEngine = caUiEngFactory->CCaUiEngApiLD();

    if( !iCaUiEngine )
        {
        // Null returned, so leave.
        User::Leave( KErrNotSupported );
        }
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::ConstructL() End");
    }


// -----------------------------------------------------------------------------
// CCaUiPlugin::NewL
// 
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCaUiPlugin* CCaUiPlugin::NewL()
    {
    CCaUiPlugin* self = new( ELeave ) CCaUiPlugin;
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }


// -----------------------------------------------------------------------------
// CCaUiPlugin::~CCaUiPlugin
// 
// Destructor.
// -----------------------------------------------------------------------------
//
CCaUiPlugin::~CCaUiPlugin()
    {
    delete iCaUiEngine;

    iLibrary.Close();
    }


// -----------------------------------------------------------------------------
// CCaUiPlugin::InitialiseL
// 
// 
// -----------------------------------------------------------------------------
//
void CCaUiPlugin::InitialiseL(
    MAiwNotifyCallback& /*aFrameworkCallback*/,
    const RCriteriaArray& /*aInterest*/)
    {
    // Stub. Not used.
    }


// -----------------------------------------------------------------------------
// CCaUiPlugin::HandleServiceCmdL
// 
// 
// -----------------------------------------------------------------------------
//
void CCaUiPlugin::HandleServiceCmdL(
    const TInt& aCmdId,
    const CAiwGenericParamList& aInParamList,
    CAiwGenericParamList& aOutParamList,
    TUint aCmdOptions,
    const MAiwNotifyCallback* aCallback )
    {
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::HandleServiceCmdL() Begin");
    // Handle only call command.
    if ( aCmdId == KAiwCmdCall )
        {
        if ( aCmdOptions & KAiwOptCancel )
            {
            CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::HandleServiceCmdL() Cancel");
            return;
            }
        // Check if there is CallUI Dialdata parameter.
        TInt index = 0;
        const TAiwGenericParam* genericParam = NULL; 
            
        genericParam = aInParamList.FindFirst( 
            index,
            EGenericParamCallDialData,
            EVariantTypeDesC8 );
            
        if ( index >= 0 && genericParam )
            {
            // Get the data.
            TPtrC8 ptr = genericParam->Value().AsData();

            // If this function was called through HandleMenuCmdL,
            // iMenuCmdId was set, otherwise it is zero.
            TCaUiCallType callType = ECaUiCallTypeUnknown;

            if ( iMenuCmdId == ECallUIVoice )
                {
                callType = ECaUiCallTypeVoice;
                }
            else if ( iMenuCmdId == ECallUIVideo )
                {
                callType = ECaUiCallTypeVideo;
                }
            else if ( iMenuCmdId == ECallUIInternet )
                {
                callType = ECaUiCallTypeInternet;
                }

            iMenuCmdId = 0;

            // Save the parameters given.
            iAiwNotifyCallback = aCallback;
            iInParamList = &aInParamList;
            iOutParamList = &aOutParamList;

            // Perform the dial operation.
            iCaUiEngine->DialL( *this, ptr, callType );
            }
        }
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::HandleServiceCmdL() End");
    }



// -----------------------------------------------------------------------------
// CCaUiPlugin::InitializeMenuPaneL
// 
// 
// -----------------------------------------------------------------------------
//
void CCaUiPlugin::InitializeMenuPaneL(
    CAiwMenuPane& aMenuPane,
    TInt aIndex,
    TInt /* aCascadeId */,
    const CAiwGenericParamList& aInParamList )
    {
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::InitializeMenuPaneL() Begin");

    // By default we want all internet, voice and video call resources
    TBool csVoiceMenuItemAvailable( ETrue );
    TBool csVideoMenuItemAvailable( ETrue );
    TBool voipMenuItemAvailable( ETrue );
    
    // If there is PhoneNumber parameter given, then only voice call 
    // resource is wanted.
    TInt count = aInParamList.Count();
    if ( count )
        {
        TInt index = 0;
        aInParamList.FindFirst(
            index,
            EGenericParamPhoneNumber,
            EVariantTypeAny );

        if ( index >= 0  )
            {
            csVideoMenuItemAvailable = EFalse;
            voipMenuItemAvailable = EFalse;
            }
            
        if ( index == KErrNotFound )
            {
            index = 0;    
            aInParamList.FindFirst(
                index,
                EGenericParamSIPAddress,
                EVariantTypeAny );

            if ( index >= 0  )
                {
                // Internet number parameter was found, 
                csVoiceMenuItemAvailable = EFalse;
                csVideoMenuItemAvailable = EFalse;
                }
            }
        }
    
    if ( csVideoMenuItemAvailable && 
    		!FeatureManager::FeatureSupported( KFeatureIdCsVideoTelephony ) )
    	{
    	csVideoMenuItemAvailable = EFalse;
    	}
    
    // Add menu items

    TInt menuIndex = aIndex;

    if ( csVoiceMenuItemAvailable )
         {
         AddAiwMenuItemL( aMenuPane, menuIndex, ECSVoice );
         menuIndex++;
         }
    
    if ( csVideoMenuItemAvailable )
        {
        AddAiwMenuItemL( aMenuPane, menuIndex, ECSVideo );
        menuIndex++;
        }
    
    if ( voipMenuItemAvailable )
        {
        RIdArray voipServiceIds;
        CleanupClosePushL( voipServiceIds );
        iCaUiEngine->GetVoIPServiceIdsL( voipServiceIds );
        TInt numberOfVoipServices = voipServiceIds.Count();
        
        if ( 1 == numberOfVoipServices )
            {
            // Single VoIP service, use service name in menu item
             AddAiwMenuItemL( aMenuPane, menuIndex, EInternetWithName, voipServiceIds[0] );
             menuIndex++;
            }
        else if ( numberOfVoipServices > 1 )
            {
            // Regular internet call menu
            AddAiwMenuItemL( aMenuPane, menuIndex, EInternet );
            menuIndex++;
            }    

        CleanupStack::PopAndDestroy( &voipServiceIds );
        }

    // Set submenu title
    if ( csVoiceMenuItemAvailable ||
         csVideoMenuItemAvailable || 
         voipMenuItemAvailable )
        {
        HBufC* menuTitle = StringLoader::LoadLC( R_CALLUI_CALL_SUBMENU_TITLE );
        aMenuPane.AddTitleItemL( *menuTitle, aIndex );
        CleanupStack::PopAndDestroy( menuTitle );
        }

    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::InitializeMenuPaneL() End");
    }


// -----------------------------------------------------------------------------
// CCaUiPlugin::HandleMenuCmdL
// 
// 
// -----------------------------------------------------------------------------
//
void CCaUiPlugin::HandleMenuCmdL(
    TInt aMenuCmdId, 
    const CAiwGenericParamList& aInParamList,
    CAiwGenericParamList& aOutParamList,
    TUint aCmdOptions,
    const MAiwNotifyCallback* aCallback )
    {
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::HandleMenuCmdL() Begin");
    // Handle only call commands.
    if ( ( aMenuCmdId == ECallUIVideo ) || 
         ( aMenuCmdId == ECallUIVoice ) ||
         ( aMenuCmdId == ECallUIInternet ) )
        {
        // Save the menu command.
        iMenuCmdId = aMenuCmdId;

        // Menu commands are handled as service commands.
        HandleServiceCmdL(
            KAiwCmdCall,
            aInParamList,
            aOutParamList,
            aCmdOptions,
            aCallback );
        }
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::HandleMenuCmdL() End");
    }


// -----------------------------------------------------------------------------
// CCaUiPlugin::HandleDialResultL
// 
// 
// -----------------------------------------------------------------------------
//
void CCaUiPlugin::HandleDialResultL( const TInt aStatus )
    {
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::HandleDialResultL() Start");
    // If callback exists, inform client of call result.
    if ( iAiwNotifyCallback )
        {
        // Add the call result to the out parameter list.
        TAiwVariant variant( aStatus );
        TAiwGenericParam genericParam( EGenericParamError, variant );
        iOutParamList->AppendL( genericParam);

        // R&D solution: Remove constness.
        MAiwNotifyCallback* callback = 
            const_cast< MAiwNotifyCallback* >( iAiwNotifyCallback );

        // Notify client.
        callback->HandleNotifyL(
            KAiwCmdCall,
            KAiwEventStarted,
            *iOutParamList,
            *iInParamList );
        }

    // Callback not active anymore, make clearing.
    iAiwNotifyCallback = NULL;
    iInParamList = NULL;
    iOutParamList = NULL;
    CAUILOGSTRING("CALLUI: >>>CCaUiPlugin::HandleDialResultL() End");
    }

// -----------------------------------------------------------------------------
// CCaUiPlugin::AddAiwMenuItemL
// 
// 
// -----------------------------------------------------------------------------
//
void CCaUiPlugin::AddAiwMenuItemL( CAiwMenuPane& aMenuPane, TInt aIndex, EMenuItemType aType, TServiceId aServiceId )
    {
    CEikMenuPaneItem::SData data;
    data.iCascadeId = 0;
    data.iFlags = 0;
    data.iExtraText = KNullDesC();

    HBufC* menuItemText = NULL;
    
    switch ( aType )
        {
        case ECSVoice:
            {
            data.iCommandId = ECallUIVoice;
            menuItemText = StringLoader::LoadLC( R_CALLUI_CS_VOICE_CALL );
            data.iText.Copy( *menuItemText );
            break;
            }

        case ECSVideo:
            {
            data.iCommandId = ECallUIVideo;
            menuItemText = StringLoader::LoadLC( R_CALLUI_CS_VIDEO_CALL );
            data.iText.Copy( *menuItemText );
            break;
            }

        case EInternet:
            {
            data.iCommandId = ECallUIInternet;
            menuItemText = StringLoader::LoadLC( R_CALLUI_INTERNET_CALL );
            data.iText.Copy( *menuItemText );
            break;
            }

        case EInternetWithName:
            {
            data.iCommandId = ECallUIInternet;
            
            // Get the service provider name
            TBuf<100> buf;
            iCaUiEngine->GetVoipServiceNameL( aServiceId, buf );
            menuItemText = StringLoader::LoadLC( R_CALLUI_XSP_CALL_WITH_SERVICE_NAME, buf );
            data.iText.Copy( *menuItemText );
            break;
            }

        default:
            break;
        }

    if ( NULL != menuItemText )
        {
        CleanupStack::PopAndDestroy( menuItemText );
        }
    
    aMenuPane.AddMenuItemL(
       KAiwCmdCall,
       data,
       aIndex );
    }

// End of file