/*

* Copyright (c) 2005-2006 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:  State Machine of BTRCC

*

*/

// INCLUDE FILES

#include <remconaddress.h>

#include <remconbeareravrcp.h> //	KRemConBearerAvrcpImplementationUid = 0x1020685f

#include <btaccObserver.h>

#include <remconinterfaceselector.h>  

#include <remconaddress.h> 

#include <remconcoreapitarget.h>

#include <apacmdln.h>

#include <apgcli.h>

#include "btaudioremconpskeys.h"

#include "btrccLegacyVolumeLevelController.h"

#include "btrccAbsoluteVolumeLevelController.h"

#include "btrccLinker.h"

#include "btrccplayerstarter.h"

#include "btrccBrowsingAdapter.h"

#include "debug.h"

#include <btnotif.h>

#include <mmf/server/sounddevice.h>

#include "prjconfig.h"

#ifdef PRJ_MODULETEST_BUILD

const TInt KAvrcpBearerUid = 0xEEEEAAAA;

#else

const TInt KAvrcpBearerUid = KRemConBearerAvrcpImplementationUid;

#endif

const TInt KMaxRetries = 3;

// MODULE DATA STRUCTURES

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

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

// CBTRCCLinker::NewL

// Two-phased constructor.

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

//

CBTRCCLinker* CBTRCCLinker::NewL(MBTAccObserver& aAccObserver)

    {

    CBTRCCLinker* self = new (ELeave) CBTRCCLinker(aAccObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CBTRCCLinker::CBTRCCLinker

// C++ constructor.

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

//

CBTRCCLinker::CBTRCCLinker(MBTAccObserver& aAccObserver)

    : CActive(EPriorityNormal), iAccObserver(aAccObserver)

	{

	CActiveScheduler::Add(this);

	}

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

// CBTRCCLinker::ConstructL

// Symbian 2nd phase constructor.

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

//

void CBTRCCLinker::ConstructL()

	{

    TRACE_FUNC_ENTRY

    iInterfaceSelector = CRemConInterfaceSelector::NewL();

    iVolController = NULL;

    iRegisterVolumeChangeNotificationCounter = 0;

    if (iAccObserver.IsAvrcpVolCTSupported())

        {

        iAbsoluteVolController = CBTRCCAbsoluteVolumeLevelController::NewL(*iInterfaceSelector, *this);

        TRACE_INFO((_L("CBTRCCLinker::ConstructL, absolute volume controller created.")))

        // If also legacy is configured into use, prepare to use it with legacy devices. 

        if(iAccObserver.IsAvrcpLegacyVolCTSupported())

            {

            iLegacyVolController = CBTRCCLegacyVolumeLevelController::NewL(*iInterfaceSelector, *this);

            TRACE_INFO((_L("CBTRCCLinker::ConstructL, legacy volume controller created.")))

        	}

        }

    else 

   		{

        // If volume control is not supported, we'll need another interface selector session for disconnecting. 

        iInterfaceSelectorForDisconnectingTargetSession = CRemConInterfaceSelector::NewL(); 

    	}

    iPlayerStarter = CPlayerStarter::NewL();

    iCoreTarget = CRemConCoreApiTarget::NewL(*iInterfaceSelector, *iPlayerStarter);

    iPlayerStarter->SetCoreTarget(*iCoreTarget);

    iRemConBatteryTgt = CRemConBatteryApiTarget::NewL(*iInterfaceSelector, *this);

    if (iAccObserver.IsAvrcpVolCTSupported()) 

        {

        iInterfaceSelector->OpenControllerL();

        }

    iInterfaceSelector->OpenTargetL(); 

    // The insert order matters

    LEAVE_IF_ERROR(iStateArray.Insert(new (ELeave) TStateIdle(*this), EStateIndexIdle));

    LEAVE_IF_ERROR(iStateArray.Insert(new (ELeave) TStateConnecting(*this), EStateIndexConnecting));

    LEAVE_IF_ERROR(iStateArray.Insert(new (ELeave) TStateConnected(*this), EStateIndexConnected));

    LEAVE_IF_ERROR(iStateArray.Insert(new (ELeave) TStateDisconnect(*this), EStateIndexDisconnect));

    ChangeState(EStateIndexIdle);

	TRACE_FUNC_EXIT

    }

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

// Destructor.

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

//

CBTRCCLinker::~CBTRCCLinker()

	{

	TRACE_FUNC_ENTRY

    if (iClientRequest)

        User::RequestComplete(iClientRequest, KErrAbort);

    delete iAbsoluteVolController;

    delete iLegacyVolController;

	delete iPlayerStarter;

	Cancel();

    iStateArray.ResetAndDestroy();

    iStateArray.Close();

	delete iInterfaceSelector;

	delete iInterfaceSelectorForDisconnectingTargetSession; 

	TRACE_FUNC_EXIT

	}

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

// CBTRCCLinker::Connect

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

//

void CBTRCCLinker::Connect(const TBTDevAddr& aAddr, TRequestStatus& aStatus)

    {

    TRACE_FUNC

    if ( !iAccObserver.IsAvrcpVolCTSupported() )

        {

        aStatus = KRequestPending;

        TRequestStatus* ptr = &aStatus;

        User::RequestComplete( ptr, KErrNotSupported );

        }

    else

        {

        TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

        iStateArray[iCurrentStateIndex]->Connect(aAddr, aStatus);

        }

    }

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

// CBTRCCLinker::CancelConnect

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

//

void CBTRCCLinker::CancelConnect(const TBTDevAddr& aAddr)

    {

    TRACE_FUNC

    TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

    iStateArray[iCurrentStateIndex]->CancelConnect(aAddr);

    }

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

// CBTRCCLinker::Disconnect

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

//

void CBTRCCLinker::Disconnect(TRequestStatus& aStatus, const TBTDevAddr& aAddr)

    {

    TRACE_FUNC

    TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

    iStateArray[iCurrentStateIndex]->Disconnect(aStatus, aAddr);

   	}

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

// CBTRCCLinker::ActivateRemoteVolumeControl

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

//

void CBTRCCLinker::ActivateRemoteVolumeControl()

    {

	TRACE_FUNC

    TRACE_ASSERT(iAccObserver.IsAvrcpVolCTSupported(), EBtrccPanicAvrcpVolCTNotSupported)

    if (!iRvcActivated)

        {

        iRvcActivated = ETrue;

        TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

        iStateArray[iCurrentStateIndex]->UpdateRemoteVolumeControling(iRvcActivated);

        }

    }

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

// CBTRCCLinker::DeActivateRemoteVolumeControl

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

//

void CBTRCCLinker::DeActivateRemoteVolumeControl()

    {

    TRACE_FUNC

    TRACE_ASSERT(iAccObserver.IsAvrcpVolCTSupported(), EBtrccPanicAvrcpVolCTNotSupported)

    if (iRvcActivated)

        {

        iRvcActivated = EFalse;

        TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

        iStateArray[iCurrentStateIndex]->UpdateRemoteVolumeControling(iRvcActivated);

        }

    }

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

// CBTRCCLinker::RunL

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

//

void CBTRCCLinker::RunL()

	{

	TRACE_INFO((_L("CBTRCCLinker::RunL, %d"), iStatus.Int()))

    TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

    iStateArray[iCurrentStateIndex]->RemConRequestCompleted(iStatus.Int());

    }

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

// CBTRCCLinker::RunError

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

//

TInt CBTRCCLinker::RunError(TInt aError)

    {

    TRACE_INFO((_L("CBTRCCLinker::RunError, %d"), aError))

    (void) aError;

    return KErrNone;

    }

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

// CBTRCCLinker::DoCancel

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

//

void CBTRCCLinker::DoCancel()

    {

    TRACE_FUNC

    TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

    iStateArray[iCurrentStateIndex]->DoCancel();

    }

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

// CBTRCCLinker::AccObserver

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

//

MBTAccObserver& CBTRCCLinker::AccObserver()

    {

    return iAccObserver;

    }

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

// CBTRCCLinker::DoConnect

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

//

void CBTRCCLinker::DoConnect()

    {

    TRACE_FUNC

	TRACE_ASSERT(!IsActive(), EBtrccPanicAOIsActive)

	DoRemConOrientation();

	if (iRemConOriented)

		{

    	iInterfaceSelector->ConnectBearer(iStatus);

    	SetActive();

		}

	else

	    {

        TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

        iStateArray[iCurrentStateIndex]->RemConRequestCompleted(KErrCouldNotConnect);	    

	    }

    }

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

// CBTRCCLinker::DoSubscribeConnetionStatus

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

//

void CBTRCCLinker::DoSubscribeConnetionStatus()

    {

    TRACE_FUNC

	TRACE_ASSERT(!IsActive(), EBtrccPanicAOIsActive)

	iInterfaceSelector->NotifyConnectionsChange(iStatus);

	SetActive();

    }

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

// CBTRCCLinker::DoCancelSubscribe

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

//

void CBTRCCLinker::DoCancelSubscribe()

    {

    TRACE_FUNC

    Cancel();

    }

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

// CBTRCCLinker::DoDisconnect

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

//

void CBTRCCLinker::DoDisconnect()

    {

    TRACE_FUNC

	TRACE_ASSERT(!IsActive(), EBtrccPanicAOIsActive)

	TInt err = KErrNone;

    // if AVRCP RVC is supported, we use InterfaceSelector to do disconnect.

	if (iAccObserver.IsAvrcpVolCTSupported())

	    {

	    err = DoRemConOrientation();

	    }

	else

	    {

	    // if AVRCP RVC is not supported, we must be a RemCon Controller for the 

	    // disconnected. Use inner RemCon Controller here for not disturbing 

	    // interfaceSelector.

        TRAP(err, iInterfaceSelectorForDisconnectingTargetSession->OpenControllerL()); 

        TRACE_INFO((_L("open iInterfaceSelectorForDisconnectingTargetSession controller %d"), err))

        if (!err)

            {

            TRemConAddress addr;

            addr.BearerUid() = TUid::Uid( KAvrcpBearerUid );

            addr.Addr() = iRemoteAddr.Des();

            TRAP(err, iInterfaceSelectorForDisconnectingTargetSession->GoConnectionOrientedL(addr));

            TRACE_INFO((_L("InterfaceSelectorForDisconnectingTargetSession GoConnectionOrientedL %d"), err))

            }    

	    }

	if (!err)

		{

		if (iAccObserver.IsAvrcpVolCTSupported())

		    {

		    iInterfaceSelector->DisconnectBearer(iStatus);

		    }

		else

		    {

            iInterfaceSelectorForDisconnectingTargetSession->DisconnectBearer(iStatus);

		    }

    	SetActive();

		}

	else

	    {

        TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

        iStateArray[iCurrentStateIndex]->RemConRequestCompleted(KErrCouldNotConnect);	    

	    }

   	}

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

// CBTRCCLinker::ChangeState

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

//

void CBTRCCLinker::ChangeState(TBTRCCStateIndex aNextState)

    {

	TRACE_INFO((_L("CBTRCCLinker::ChangeState, STATE from %d to %d"), iCurrentStateIndex, aNextState))

    iCurrentStateIndex = aNextState;

	TRACE_ASSERT(iCurrentStateIndex < iStateArray.Count(), EBtrccPanicOutOfRangeState);

    iStateArray[iCurrentStateIndex]->Enter();

    }

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

// CBTRCCLinker::DoRemConOrientation

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

//

TInt CBTRCCLinker::DoRemConOrientation()

    {

    TRACE_FUNC

    TInt err(KErrNone);

	// the oriented remote might be a different device than the currently requested,

    // Go connectionless first.

	if (iRemConOriented)

	    {

	    TRAP(err, iInterfaceSelector->GoConnectionlessL());

    	iRemConOriented = EFalse;

	    if (err)

	        {

	        TRACE_INFO((_L("GoConnectionless ret %d"), err))

            return err;

	        }

	    }

	TRemConAddress addr;

	addr.BearerUid() = TUid::Uid( KAvrcpBearerUid );

	addr.Addr() = iRemoteAddr.Des();

    TRAP(err, iInterfaceSelector->GoConnectionOrientedL(addr));

    TRACE_INFO((_L("GoConnectionOriented ret %d"), err))

    if (!err)

        {

        iRemConOriented = ETrue;

        }

    return err;

    }

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

// CBTRCCLinker::DoGetRemConConnectionStatus

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

//

void CBTRCCLinker::DoGetRemConConnectionStatus(RArray<TBTDevAddr>& aConnects)

    {

	TRACE_FUNC

	TSglQue<TRemConAddress> connections;

	aConnects.Reset();

	if (iInterfaceSelector->GetConnections(connections) == KErrNone)

		{

		TSglQueIter<TRemConAddress> iter(connections);

		TRemConAddress* addr;

		while((addr=iter++) != NULL)

			{

			if(addr->BearerUid() == TUid::Uid( KAvrcpBearerUid ) )

				{

				// We have a BT Connection 

				if ((addr->Addr().Length() == KBTDevAddrSize) && (TBTDevAddr(addr->Addr()) != TBTDevAddr()))

				    {

    				TRACE_INFO(_L("RemCon bearer found from connections list"));

    				aConnects.Append(TBTDevAddr(addr->Addr()));

				    }

				}

			// We've copied the information we need, so delete

			delete addr;

			}

		}

	else

		{

		TRACE_INFO(_L("GetNotificationStatus(): FAILED !!!"));

		}

    }

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

// CBTRCCLinker::StartRemoteVolumeControl

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

//

void CBTRCCLinker::StartRemoteVolumeControl()

    {

    TRACE_FUNC

    if (iAccObserver.IsAvrcpVolCTSupported())

        {

        // Choose based on SDP result whether to create 

        // absolute controller or legacy controller.

        if(!iVolController)

            {

            if (iAccObserver.IsAbsoluteVolumeSupported(iRemoteAddr))

                {

                iVolController = iAbsoluteVolController;

                TRACE_INFO(_L("Absolute volume supported, taking it into use."))

                }

           	else 

                {

                iVolController = iLegacyVolController; // iLegacyVolController may be NULL, depends on the configuration. 

                }

            }

        }

    if (iVolController)

        {

        iVolController->Start();

        }

    }

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

// CBTRCCLinker::StopRemoteVolumeControl

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

//

void CBTRCCLinker::StopRemoteVolumeControl()

    {

    TRACE_FUNC

    if (iVolController)

        {

        iVolController->Stop();

        iVolController = NULL; 

        }

    }

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

// CBTRCCLinker::ResetVolmeControlSetting

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

//

void CBTRCCLinker::ResetVolmeControlSetting()

    {

    TRACE_FUNC

    if (iVolController)

        {

        iVolController->Reset();

        }

    }

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

// CBTRCCLinker::VolumeControlError

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

//

void CBTRCCLinker::VolumeControlError(TInt aError)

    {

    // This is called if there's an error with sending the volume commands out.

    switch(aError)

        {

        case ERegisterNotificationsFailed:

            if (iVolController && iRegisterVolumeChangeNotificationCounter<KMaxRetries)

                {

                iRegisterVolumeChangeNotificationCounter++;

                iVolController->RegisterVolumeChangeNotification();

                }

            else

                {

                iRegisterVolumeChangeNotificationCounter = 0;

                }

            break;

        case EVolumeAdjustmentFailed:

        default:

            {

            StopRemoteVolumeControl();

            StartRemoteVolumeControl();

            break;

            }

        }

    }

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

// CBTRCCLinker::MrcbstoBatteryStatus

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

//

void CBTRCCLinker::MrcbstoBatteryStatus(TControllerBatteryStatus& aBatteryStatus)