/*

* 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:  Video Telephony mediator plugin header

*

*/

// INCLUDE FILES

#include <e32def.h>

#include <w32std.h>

#include <apacmdln.h>

#include <apaflrec.h>

#include <apgcli.h>

#include <MediatorDomainUIDs.h>

#include <eikdll.h>

#include <apgcli.h>

#include <apgwgnam.h>

#include <apgtask.h>

#include <mediatorcommandstotelephonyapi.h>

#include <videotelcontrolmediatorapi.h>

#include <videoteltophonecommandsapi.h>

#include "cvtmediatorplugin.h"

// CONSTANTS

#ifdef _DEBUG

#define TRACE(x) RDebug::Print( _L(x) );

#define TRACE2(x,y) RDebug::Print( _L(x),y );

#else

#define TRACE(x)

#define TRACE2(x,y)

#endif

// This array's values are used in algorithm defining if video telephone

// application should be started. Previous state value is substracted from new 

// state value and if result is greater than zero, app is started.

// This tackles transitions where a state is for some reason skipped,

// e.g. idle -> connected (dialling/ringing/answering states were not detected).

// Negative value indicates call clearing.

static const TInt KVtCallStateActionArray[] = {

    0, //ECallStateUnknown

    0, //ECallStateIdle

    1, // ECallStateDialling

    0, // ECallStateEmergencyDialling (not valid video call state)

    1, // ECallStateRinging

    1, // ECallStateConnecting

    1, // ECallStateConnected

    0, // ECallStateHangingUp

    0, // ECallStateHeld (not valid video call state)

    1, // ECallStateAnswering

    0, // ECallStateRejecting

    0  // ECallStateDisconnecting

    };

static const TInt KVtAppNotReady = 5000;

static const TInt KVtEngMdtrCmdTimeout = 500000;

static const TInt KVtInitCallId = -1000;

// array granularity is 2 (use dataport, release dataport commands)

static const TInt KVtMdtrCmdArrayGranularity = 2;

const TUid KVtCmVideoTelUiUid = { 0x101F8681 };

static const TInt KRamNeededForVideoCalls = 4000000;

// VT application path 

_LIT( KVtCmVideoTelUiPath, "\\sys\\bin\\videotelui.exe" );

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

// CMediatorTestPlugin::CMediatorTestPlugin

// First phase construction.

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

CVtMediatorPlugin::CVtMediatorPlugin() : CMediatorPluginBase(),

    iCommandList( KVtMdtrCmdArrayGranularity ),

    iState( EWaitingAppLaunch ),

    iActiveVideoCallState( ECallStateUnknown ),

    iWaitingVideoCallState( ECallStateUnknown )

	{

	ClearData(iActiveVideoCallInfo, iActiveVideoCallState);

	ClearData(iWaitingVideoCallInfo, iWaitingVideoCallState);

	}

CMediatorPluginBase* CVtMediatorPlugin::NewL()

    {

    TRACE("CVtMediatorPlugin::NewL<")

    CVtMediatorPlugin* self = new (ELeave) CVtMediatorPlugin;

    TRACE("CVtMediatorPlugin::NewL>")

    return self;

    }

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

// Destructor.

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

CVtMediatorPlugin::~CVtMediatorPlugin()

	{

	TRACE("CVtMediatorPlugin::~CVtMediatorPlugin<")

	if ( iMediatorNotifications )

	    {

	    iMediatorNotifications->UnregisterNotificationObserver();

	    delete iMediatorNotifications;

	    }

	// ignore error

	if ( iEventConsumer )

	    {

	    iEventConsumer->UnsubscribeEvent(

	            KMediatorTelephonyDomain,

	            KCatEventsFromTelephony,

	            EPhoneEventCallData );     

	    delete iEventConsumer;

	    }

    // ignore error     

	if ( iEventProvider )

	    {

	    iEventProvider->UnregisterEvent(

	            KMediatorVideoTelephonyDomain,

	            KCatVideotelInternalEvents,

	            EVtMediatorEventVideoCallInformation );   

	    delete iEventProvider;

	    }

    // ignore error

	if ( iCommandResponder )

	    {

	    iCommandResponder->UnregisterCommand(

	                KMediatorVideoTelephonyDomain,

	                KCatPhoneToVideotelCommands,

	                iCommandList );

	    iCommandList.Close();

	    delete iCommandResponder;

	    }

	delete iCommandInitiator;

    if( iAppDeathActive )

        {

        delete iAppDeathActive;

        iAppThread.Close();

        }

    TRACE("CVtMediatorPlugin::~CVtMediatorPlugin>")

	}

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

// StartL.

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

void CVtMediatorPlugin::StartL()

	{

    TRACE("CVtMediatorPlugin.StartL<")

    // for monitoring VT app starting

    iMediatorNotifications = CMediatorNotifications::NewL();

    iMediatorNotifications->RegisterNotificationObserver( this );

    // consumer for call data events

    iEventConsumer = CMediatorEventConsumer::NewL( this );

    iCommandInitiator = CMediatorCommandInitiator::NewL( this );

    RegisterVtInternalEventL();

    RegisterDataportCommandL();       

    TRACE("CVtMediatorPlugin.StartL>")

	}

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

// MediatorEventL.

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

void CVtMediatorPlugin::MediatorEventL( TUid /*aDomain*/,

                             TUid aCategory,

                             TInt aEventId,

                             const TDesC8& aData )

    {

    TRACE("CVtMediatorPlugin.MediatorEventL<")

    if ( aCategory == KCatEventsFromTelephony &&

         aEventId == EPhoneEventCallData )

        {

        TTelephonyCallDataParamPackage pckg;

        pckg.Copy( aData );

        const TTelephonyCallDataParam telCallData = pckg();        

        HandleCallStateChangeL( telCallData );        

        }

    TRACE("CVtMediatorPlugin.MediatorEventL>")

    }

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

// CVtMediatorPlugin::MediatorEventsAddedL

//

// subscribes to CLI event when it is registered

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

//

void CVtMediatorPlugin::MediatorEventsAddedL( TUid aDomain/*aDomain*/,

                                   TUid aCategory,

                                   const REventList& aEvents )

    {

    TRACE("CVtMediatorPlugin.MediatorEventsAddedL<")

    if ( aCategory == KCatEventsFromTelephony )

        {

        ChangeCallDataEventSubscriptionL( aEvents, ETrue );

        }    

    TRACE("CVtMediatorPlugin.MediatorEventsAddedL>")

    }

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

// ?classname::?member_function

//

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

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

//

void CVtMediatorPlugin::MediatorCommandsAddedL( TUid /*aDomain*/,

                                     TUid aCategory,

                                     const RCommandList& /*aCommands*/ )

    {

    TRACE("CVtMediatorPlugin.MediatorCommandsAddedL<")

    if ( aCategory == KCatPhoneToVideotelCommands )

        {

        HandleVtCommandRegistrationL();

        }

    TRACE("CVtMediatorPlugin.MediatorCommandsAddedL>")

    }

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

// ?classname::?member_function

//

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

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

//

void CVtMediatorPlugin::MediatorCategoryRemovedL( TUid /*aDomain*/,

    TUid /*aCategory*/ )

    {

    }

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

// ?classname::?member_function

//

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

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

//

void CVtMediatorPlugin::MediatorEventsRemovedL( TUid /*aDomain*/,

                                     TUid aCategory,

                                     const REventList& aEvents )

    {

    TRACE("CVtMediatorPlugin.MediatorEventsRemovedL<")

    if ( aCategory == KCatEventsFromTelephony )

        {

        ChangeCallDataEventSubscriptionL( aEvents, EFalse );

        }    

    TRACE("CVtMediatorPlugin.MediatorEventsRemovedL>")

    }

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

// ?classname::?member_function

//

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

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

//

void CVtMediatorPlugin::MediatorCommandsRemovedL( TUid /*aDomain*/,

                                       TUid aCategory,

                                       const RCommandList& /*aCommands*/ )

    {

    TRACE("CVtMediatorPlugin.MediatorCommandsRemovedL<")  

    if ( aCategory == KCatPhoneToVideotelCommands )

        {

        // VT has unregistered commands, meaning it is shutting down

        HandleVtCommandUnregistrationL();

        }

    TRACE("CVtMediatorPlugin.MediatorCommandsRemovedL>")

    }

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

// CVtMediatorPlugin::MediatorCommandL

//

// 

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

//

void CVtMediatorPlugin::MediatorCommandL( TUid aDomain,

                                 TUid aCategory, 

                                 TInt aCommandId,

                                 TVersion /*aVersion*/, 

                                 const TDesC8& aData )

    {

    TRACE("CVtMediatorPlugin.MediatorCommandL<") 

    if ( aCategory == KCatPhoneToVideotelCommands )

        {

        if ( aCommandId == EVtCmdUseDataport )

            {

#ifdef _DEBUG           

            // error in responding is ignored but printed on debug build

            const TInt err =

#endif            

            iCommandResponder->IssueResponse( 

                aDomain, aCategory, aCommandId, KErrNone, KNullDesC8() );

            TRACE2("CVtMediatorPlugin.MediatorCommandL EVtCmdUseDataport err=%d", err )

            HandleDataportCommandL( aData );

            }

        else if ( aCommandId == EVtCmdReleaseDataport )

            {

            if ( EReady == iState )

                {

                const TVersion version( 

                        KVideotelMdtrCommandsVersionMajor,

                        KVideotelMdtrCommandsVersionMinor,

                        KVideotelMdtrCommandsVersionBuild );

#ifdef _DEBUG           

            // error in responding is ignored but printed on debug build

            const TInt err =

#endif                          

                iCommandInitiator->IssueCommand(

                        KMediatorVideoTelephonyDomain,

                        KCatVideotelInternalCommands,

                        EVtMediatorReleaseDataport,

                        version,

                        KNullDesC8() );

            TRACE2("CVtMediatorPlugin.MediatorCommandL EVtCmdReleaseDataport, send to VT err=%d", err )

                }

            else

                {

#ifdef _DEBUG           

                // error in responding is ignored but printed on debug build

                const TInt err =

#endif            

                iCommandResponder->IssueResponse( 

                        aDomain, 

                        aCategory, 

                        aCommandId, 

                        KErrNone, 

                        KNullDesC8() );

                TRACE2("CVtMediatorPlugin.MediatorCommandL EVtCmdReleaseDataport, just Resp err=%d", err ) 

                }

            }

        }

    TRACE("CVtMediatorPlugin.MediatorCommandL>")

    }

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

// CVtMediatorPlugin::CommandResponseL

//

// 

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

//

void CVtMediatorPlugin::CommandResponseL( TUid aDomain, TUid aCategory, 

    TInt aCommandId, TInt /*aStatus*/, const TDesC8& /*aData*/ )

    {

    TRACE("CVtMediatorPlugin.CommandResponseL<")

    if( ( aDomain == KMediatorVideoTelephonyDomain ) &&

        ( aCategory == KCatVideotelInternalCommands ) )

        {

        TInt res =

        iCommandResponder->IssueResponse( 

                KMediatorVideoTelephonyDomain,

                KCatPhoneToVideotelCommands,

                EVtCmdReleaseDataport, 

                KErrNone, 

                KNullDesC8() );         

         TRACE2("CVtMediatorPlugin.CommandResponseL, IssueResponse res: %d", res )  

         User::LeaveIfError( res );      

        }

    TRACE("CVtMediatorPlugin.CommandResponseL>")

    }

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

// CVtMediatorPlugin::CancelMediatorCommand

//

// no-op

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

//

void CVtMediatorPlugin::CancelMediatorCommand( TUid /*aDomain*/,

                                      TUid /*aCategory*/, 

                                      TInt /*aCommandId*/ )

    {

    }

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

// CVtMediatorPlugin::ChangeCallDataEventSubscriptionL

//

// Takes care of 'call data' event subscription.

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

//

void CVtMediatorPlugin::ChangeCallDataEventSubscriptionL(

    const REventList& aEvents,

    const TBool aEventRegistered )

    {

    TRACE("CVtMediatorPlugin.ChangeCLIEventSubscription<")

    TInt res( KErrNone );

    TInt eventCount = aEvents.Count();

    while ( eventCount-- )

        {

        const TEvent& aEvent = aEvents[ eventCount ];

        if ( aEvent.iEventId == EPhoneEventCallData )

            {

            if ( aEventRegistered )

                {

                // Phone has registered Call data event => subscribe it                

                const TVersion version(

                    KTelephonyEventsVersionMajor,

                    KTelephonyEventsVersionMinor,

                    KTelephonyEventsVersionBuild );

                res = iEventConsumer->SubscribeEvent(

                    KMediatorTelephonyDomain,

                    KCatEventsFromTelephony,

                    EPhoneEventCallData, version );

                }

            else

                {

                // Phone has unregistered Call data event => unsubscribe it

                res = iEventConsumer->UnsubscribeEvent(

                    KMediatorTelephonyDomain,

                    KCatEventsFromTelephony,

                    EPhoneEventCallData );

                }

            TRACE2("   (un)subscribe result=%d", res )

            eventCount = 0; // break loop

            }

        }

    TRACE2("CVtMediatorPlugin.ChangeCLIEventSubscription result=%d>", res )

    User::LeaveIfError( res );

    }

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

// CVtMediatorPlugin::HandleVtCommandRegistrationL

//

// 

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

//

void CVtMediatorPlugin::HandleVtCommandRegistrationL()

    {

    TRACE("CVtMediatorPlugin.HandleVtCommandRegistrationL<" )

    if ( iState == EWaitingEventRegistration )

        {

        // VT app registered commands => it can also receive events

        // NOTE: it is expected that VT application first subscribes

        // to internal events and only after that registers commands to

        // avoid timing problems.

        iState = EReady;

        delete iCallBack;

        iCallBack = NULL;

        TCallBack cb( &EventRaiserCallback, this );

        iCallBack = new ( ELeave ) CAsyncCallBack( cb, 

            CActive::EPriorityStandard );        

        TRACE("CVtMediatorPlugin enque async callback" )

        iCallBack->CallBack();        

        }

    TRACE("CVtMediatorPlugin.HandleVtCommandRegistrationL>" )

    }

TInt CVtMediatorPlugin::EventRaiserCallback( TAny* aAny )

    {

    TRACE("CVtMediatorPlugin.EventRaiserCallback<" )

    CVtMediatorPlugin* plugin = reinterpret_cast<CVtMediatorPlugin*>( aAny );

    delete plugin->iCallBack;

    plugin->iCallBack = NULL;

    TRAP_IGNORE( plugin->RaiseVtEventL() );

    TRACE("CVtMediatorPlugin.EventRaiserCallback>" )

    return KErrNone;

    }

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

// CVtMediatorPlugin::

//

// 

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

//

void CVtMediatorPlugin::HandleVtCommandUnregistrationL()

    {

    // unregistration means that VT app is shutting down.    

    TRACE("CVtMediatorPlugin.HandleVtCommandUnregistrationL<" )

    ClearData(iActiveVideoCallInfo, iActiveVideoCallState);

    //ClearData(iWaitingVideoCallInfo);

    TRACE("CVtMediatorPlugin.HandleVtCommandUnregistrationL>" )

    }

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

// CVtMediatorPlugin::

//

// 

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

//

void CVtMediatorPlugin::LaunchVtAppL()

    {

    TRACE("CVtMediatorPlugin.LaunchVtAppL<" )

    if ( !IsEnoughMemory() )

        {

        const TVersion KTelephonyCmdVersion(

                KTelephonyCommandsVersionMajor,

                KTelephonyCommandsVersionMinor,

                KTelephonyCommandsVersionBuild );

        const TInt res =

        iCommandInitiator->IssueCommand(

                KMediatorTelephonyDomain,

                KCatVideoTelToPhoneCommands,

                EVtCmdLowMemory,

                KTelephonyCmdVersion,

                KNullDesC8() );

        ClearData(iActiveVideoCallInfo, iActiveVideoCallState);

        ClearData(iWaitingVideoCallInfo, iWaitingVideoCallState);

        TRACE("CVtMediatorPlugin.LaunchVtAppL, Insufficient Memory" )

        return;

        }

    iAppDeathActive = new ( ELeave ) CAppDeathActive( *this, iAppThread );