/*

* 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:  BT HFP AT extension API

*

*/

// INCLUDE FILES

#include "HfpAtCmdHandler.h"

#include "debug.h"

enum TActiveRequestId

    {

    EHandleCommandRequest = 1,

    EReceiveEventRequest,

    };

CHFPAtCmdHandler* CHFPAtCmdHandler::NewL(MATExtObserver& aObserver)

	{

    CHFPAtCmdHandler* self = new (ELeave) CHFPAtCmdHandler(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

	}

CHFPAtCmdHandler::~CHFPAtCmdHandler()

	{

    TRACE_FUNC

    delete iCommander;

    DeletePluginHandlers();

    delete iEcomListen;

    iEcomListen = NULL;

       if ( iATExtClient.Handle() )

        {

        iATExtClient.Close();

        }

}

void CHFPAtCmdHandler::HandleCommand(const TDesC8& aAT, const TDesC8& aReply)

    {

    TRACE_INFO((_L8("default reply '%S'"), &aReply))

    iCmdBuffer.Copy(aAT);

    if (aReply.Length())

        {

        iSystemReply.Copy(aReply);

    iATExtClient.HandleCommand(iCommander->iStatus, 

    iCommander->GoActive(); 

    }

void CHFPAtCmdHandler::RequestCompletedL(CBtmcActive& aActive, TInt aErr)

    {

    TRACE_FUNC_ENTRY

    TInt err = aErr;

    switch (aActive.ServiceId())

        {

        case EHandleCommandRequest:

            {

            if(err == KErrNone)

                {

                if (iRemainingReplyLengthPckg())

                    {

                    TRACE_INFO((_L8("reply '%S'"), &iReplyBuffer))

                    do 

                        {

                        TRACE_INFO((_L8("iRemainingReplyLength '%d'"), iRemainingReplyLengthPckg()))

                        RBuf8 reply;

                        reply.CreateL(iRemainingReplyLengthPckg());

                        if (!err)

                            {

                            }

                        TRACE_INFO((_L8("reply '%S'"), &reply))

                        iObserver.ATExtHandleReplyReceivedL(err, reply);

                        reply.Close();

                        }

                    while (iRemainingReplyLengthPckg());

                    }

                else

                    {

                    }

                }

            else

                {

                iObserver.ATExtHandleReplyReceivedL(err, iSystemReply);

                }

            break;

            }

        }

    TRACE_FUNC_EXIT

    }

void CHFPAtCmdHandler::CancelRequest(TInt aServiceId)

    {

    switch (aServiceId)

        {

        case EHandleCommandRequest:

            {

            iATExtClient.CancelHandleCommand();

            break;

            }

        }

    }

TInt CHFPAtCmdHandler::HandleRunError(TInt /*aErr*/)

    {

    return KErrNone;

    }

CHFPAtCmdHandler::CHFPAtCmdHandler(MATExtObserver& aObserver) 

    : iObserver(aObserver), 

      iRemainingReplyLengthPckg(iRemainingReplyLength),

      iReplyTypePckg( iReplyType )

	{

	TRACE_FUNC

	}

_LIT8(KHFPAtCmd, "HFP");

void CHFPAtCmdHandler::ConstructL()

    {

    TRACE_FUNC_ENTRY

    CleanupClosePushL( iATExtClient );

    TInt err = iATExtClient.Connect(EHfpATExtension, KHFPAtCmd);

    LEAVE_IF_ERROR(err)

    // Create the plugin handlers

    CreatePluginHandlersL();

    // Create the listeners

    CHFPAtEcomListen* ecomListen = CHFPAtEcomListen::NewLC( &iATExtClient, this );

    ecomListen->IssueRequest();

    CleanupStack::Pop( ecomListen );

    CleanupStack::Pop( &iATExtClient );

    iEcomListen = ecomListen;

    StartUrc();

    iCommander = CBtmcActive::NewL(*this, CActive::EPriorityStandard, EHandleCommandRequest);

    TRACE_FUNC_EXIT

    }

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

// Creates plugin handlers for this class

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

//

void CHFPAtCmdHandler::CreatePluginHandlersL()

    {

    TRACE_INFO( _L("CHFPAtCmdHandler::CreatePluginHandlersL()") );

    if ( !iATExtClient.Handle() )

        {

        TRACE_INFO(_L("CHFPAtCmdHandler::CreatePluginHandlersL() complete") );

        User::Leave( KErrGeneral );

        }

    // Next create the URC handlers

    TInt i;

    TInt numOfPlugins = iATExtClient.NumberOfPlugins();

    for ( i=0; i<numOfPlugins; i++ )

        {

        AddOneUrcHandlerL();

        }

    TRACE_INFO( _L("CHFPAtCmdHandler::CreatePluginHandlersL() complete") );

    }

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

// From class MHFPAtEcomListen.

// Notifies about new plugin installation

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

//

TInt CHFPAtCmdHandler::NotifyPluginInstallation( TUid& /*aPluginUid*/ )

    {

    TRACE_INFO( _L("CHFPAtCmdHandler::NotifyPluginInstallation()" ) );

    CHFPAtUrcHandler* urcHandler = NULL;

    TRAPD( retTrap, urcHandler=AddOneUrcHandlerL() );

    if ( retTrap != KErrNone )

        {

        TRACE_INFO( _L("CHFPAtCmdHandler::NotifyPluginInstallation() (trapped!) complete" ) );

        return retTrap;

        }

    TInt retTemp = urcHandler->IssueRequest();

    if ( retTemp != KErrNone )

        {

        TRACE_INFO( _L("CHFPAtCmdHandler::NotifyPluginInstallation() (issuerequest) complete" ) );

        return retTemp;

        }

    TUid ownerUid = urcHandler->OwnerUid();

    iATExtClient.ReportListenerUpdateReady( ownerUid, EEcomTypeInstall );

    if ( retTemp != KErrNone )

        {

        TRACE_INFO( _L("CHFPAtCmdHandler::NotifyPluginInstallation() (recreate) complete" ));

        return retTemp;

        }

    TRACE_INFO( _L("CHFPAtCmdHandler::NotifyPluginInstallation() complete" ) );

    return KErrNone;

    }

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

// From class MHFPAtEcomListen.

// Notifies about existing plugin uninstallation

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

//

TInt CHFPAtCmdHandler::NotifyPluginUninstallation( TUid& aPluginUid )

    {

    TRACE_INFO( _L("CHFPAtCmdHandler::NotifyPluginUninstallation()" ) );

    TInt i;

    TInt count = iUrcHandlers.Count();

    for ( i=count-1; i>=0; i-- )

        {

        TUid ownerUid = iUrcHandlers[i]->OwnerUid();

        if ( ownerUid == aPluginUid )

            {

            delete iUrcHandlers[i];

            iUrcHandlers.Remove( i );

            iATExtClient.ReportListenerUpdateReady( ownerUid,

                                                 EEcomTypeUninstall );

            }

        }

    TRACE_INFO( _L("CHFPAtCmdHandler::NotifyPluginUninstallation() complete" ) );

    return KErrNone;

    }

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

// Instantiates one URC message handling class instance and adds it to the URC

// message handler array

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

//

CHFPAtUrcHandler* CHFPAtCmdHandler::AddOneUrcHandlerL()

    {

    TRACE_INFO( _L("CHFPAtCmdHandler::AddOneUrcHandlerL()") );

    CHFPAtUrcHandler* urcHandler = CHFPAtUrcHandler::NewLC( &iATExtClient,

                                                            iObserver );

    iUrcHandlers.AppendL( urcHandler );

    CleanupStack::Pop( urcHandler );

    TRACE_INFO( _L("CHFPAtCmdHandler::AddOneUrcHandlerL() complete") );

    return urcHandler;

    }

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

// Starts URC message handling

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

//

TInt CHFPAtCmdHandler::StartUrc()

    {

    TRACE_INFO( _L("CHFPAtCmdHandler::StartUrc()") );

    TInt i;

    TInt count = iUrcHandlers.Count();

    for ( i=0; i<count; i++ )

        {

        TInt retTemp = iUrcHandlers[i]->IssueRequest();

        if ( retTemp!=KErrNone && retTemp!=KErrNotReady )

            {

            TRACE_INFO( _L("CHFPAtCmdHandler::StartUrc() (ERROR) complete") );

            return retTemp;

            }

        }

    TRACE_INFO( _L("CHFPAtCmdHandler::StartUrc() complete") );

    return KErrNone;

    }

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

// Stops URC message handling

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

//

TInt CHFPAtCmdHandler::StopUrc()

    {

    TRACE_INFO( _L("CHFPAtCmdHandler::StopUrc()") );

    TInt i;

    TInt retVal = KErrNone;

    TInt count = iUrcHandlers.Count();

    for ( i=0; i<count; i++ )

        {

        retVal = iUrcHandlers[i]->Stop();

        }

    TRACE_INFO( _L("CHFPAtCmdHandler::StopUrc() complete") );

    return retVal;

    }

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

// Deletes all instantiated URC message handlers

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

//

void CHFPAtCmdHandler::DeletePluginHandlers()

    {

    TRACE_INFO( _L("CHFPAtCmdHandler::DeletePluginHandlers()") );

    TInt i;

    TInt count = iUrcHandlers.Count();

    for ( i=0; i<count; i++ )

        {

        delete iUrcHandlers[i];

        iUrcHandlers[i] = NULL;

        }

    iUrcHandlers.Reset();

    iUrcHandlers.Close();

    TRACE_INFO(  _L("CHFPAtCmdHandler::DeletePluginHandlers() complete") );

    }

//  End of File