/*

* Copyright (c) 2009 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:

*

*

*/

#include <badesca.h>

#include <atextpluginbase.h>

#include <atext.h>

#include "atextsrv.h"

#include "atextclientsrv.h"

#include "atextsession.h"

#include "utils.h"

#include "debug.h"

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

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

// Two-phased constructor.

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

//

CATExtSession* CATExtSession::NewL( CATExtSrv& aServer,

                                    const TVersion& aVersion )

    {

    return new (ELeave) CATExtSession( aServer, aVersion );

    }

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

// Destructor.

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

//

CATExtSession::~CATExtSession()

    {

    TRACE_FUNC_ENTRY

    Destruct( EFalse );

    TRACE_FUNC_EXIT

    }

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

// Handles the servicing of client requests passed to the server

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

//

void CATExtSession::ServiceL( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( iVersion.iMajor==KServerMajorVersionNumber &&

         iVersion.iMinor==KServerMinorVersionNumber &&

         iVersion.iBuild==KServerBuildVersionNumber )

        {

        DoServiceL( aMessage );

        }

    else

        {

        aMessage.Complete( KErrNotSupported );

        }

    TRACE_FUNC_EXIT

    }

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

// Handles the servicing of client requests passed to the server

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

//

void CATExtSession::DoServiceL( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    switch ( aMessage.Function() )

        {

        case EATExtSetExtensionInterface:

            {

            TRAPD( retTrap, IpcSetInterfaceL(aMessage) );

            if ( retTrap != KErrNone )

                {

                aMessage.Complete( retTrap );

                }

            else if ( !iMetadata->SupportExists() )

                {

                aMessage.Complete( KErrNotFound );

                }

            else

                {

                aMessage.Complete( KErrNone );

                }

            break;

            }

        case EATExtSynchronousClose:

            {

            IpcSynchronousClose( aMessage );

            }

            break;

        case EATExtHandleCommand:

            {

            IpcHandleCommand( aMessage );

            break;

            }

        case EATExtCancelHandleCommand:

            {

            IpcCancelHandleCommand( aMessage );

            break;

            }

        case EATExtGetNextPartOfReply:

            {

            IpcGetNextPartOfReply( aMessage );

            break;

            }

        case EATExtNumberOfPlugins:

            {

            IpcNumberOfPlugins( aMessage );

            }

            break;

        case EATExtReceiveUnsolicitedResult:

            {

            IpcReceiveUnsolicitedResult( aMessage );

            break;

            }

        case EATExtCancelReceiveUnsolicitedResult:

            {

            IpcCancelReceiveUrc( aMessage );

            break;

            }

        case EATExtMarkUrcHandlingOwnership:

            {

            IpcMarkUrcHandlingOwnership( aMessage );

            break;

            }

        case EATExtReceiveEcomPluginChange:

            {

            IpcReceiveEcomPluginChange( aMessage );

            }

            break;

        case EATExtCancelReceiveEcomPluginChange:

            {

            IpcCancelReceiveEcomPluginChange( aMessage );

            }

            break;

        case EATExtReportQuietModeChange:

            {

            IpcReportQuietModeChange( aMessage );

            }

            break;

        case EATExtReportVerboseModeChange:

            {

            IpcReportVerboseModeChange( aMessage );

            }

            break;

        case EATExtReportCharacterChange:

            {

            IpcReportCharacterChange( aMessage );

            }

            break;

        case EATExtReportListenerUpdateReady:

            {

            IpcReportListenerUpdateReady( aMessage );

            }

            break;

        case EATExtBroadcastNvramStatusChange:

            {

            IpcBroadcastNvramStatusChange( aMessage );

            }

            break;

        case EATExtReportExternalHandleCommandError:

            {

            IpcReportExternalHandleCommandError( aMessage );

            }

            break;

        case EATExtReportHandleCommandAbort:

            {

            IpcReportHandleCommandAbort( aMessage );

            }

            break;

        case EATExtGetNextSpecialCommand:

            {

            IpcGetNextSpecialCommand( aMessage );

            }

            break;

        default:

            {

            aMessage.Complete( KErrNotSupported );

            break;

            }

        }

    TRACE_FUNC_EXIT

    }

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

// CATExtSession::CATExtSession

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

//

CATExtSession::CATExtSession( CATExtSrv& aServer, const TVersion& aVersion ) :

    iServer( aServer ),

    iListener( NULL ),

    iMetadata( NULL ),

    iVersion( aVersion )

    {

    }

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

// Handles the servicing of setting up interface

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

//

void CATExtSession::IpcSetInterfaceL( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( iMetadata || iListener )

        {

        TRACE_FUNC_EXIT

        User::Leave( KErrGeneral );

        }

    REComSession& ecomSession = REComSession::OpenL();

    CleanupClosePushL( ecomSession );

    TPckgBuf<TUid> ifUidPckgBuf;

    TInt retTemp = ReadStructFromMessage( ifUidPckgBuf,

                                          EATExtConnectParamUid,

                                          aMessage );

    if ( retTemp != KErrNone )

        {

        TRACE_FUNC_EXIT

        User::Leave( retTemp );

        }

    RBuf8 connectionName;

    CleanupClosePushL( connectionName );

    retTemp = ReadStringFromMessage( connectionName,

                                     EATExtConnectParamName,

                                     aMessage );

    if ( retTemp != KErrNone )

        {

        TRACE_FUNC_EXIT

        User::Leave( retTemp );

        }

    // Create listener

    CATExtListen* listener = CATExtListen::NewLC( ecomSession, this );

    listener->AddInterfaceUid( ifUidPckgBuf() );

    // Create metadata. Pass iListener to add the UIDs

    CATExtMetadata* metadata = CATExtMetadata::NewLC( ecomSession,

                                                      listener,

                                                      *this );

    metadata->CreateImplementationMetadataL( ifUidPckgBuf(), connectionName );

    listener->IssueRequest();

    CleanupStack::Pop( metadata );

    CleanupStack::Pop( listener );

    CleanupStack::PopAndDestroy( &connectionName );

    CleanupStack::Pop( &ecomSession );

    iEComSession = ecomSession;

    iListener = listener;

    iMetadata = metadata;

    TRACE_FUNC_EXIT

    }

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

// Synchronously closes the session

// Optional: client can do either Close() or SynchronousClose()

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

//

TInt CATExtSession::IpcSynchronousClose( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    Destruct( ETrue );

    aMessage.Complete( KErrNone );

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Handles the servicing of AT commands

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

//

TInt CATExtSession::IpcHandleCommand( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    if ( aMessage.GetDesMaxLength(EATExtHandleCmdParamReply) !=

         KDefaultCmdBufLength )

        {

        aMessage.Complete( KErrBadDescriptor );

        TRACE_FUNC_EXIT

        return KErrBadDescriptor;

        }

    TATExtCompletionInfo complInfo;

    complInfo.iProcessed = EFalse;

    complInfo.iReplyExpected = EFalse;

    TInt retTemp = iMetadata->HandleCommand( aMessage, complInfo );

    if ( retTemp != KErrNone )

        {

        TRACE_INFO(( _L8("Command handled with failure %d"), retTemp ));

        iMetadata->CompleteCommandMessage( NULL,

                                           retTemp,

                                           EFalse,               // no error reply

                                           EReplyTypeUndefined,  // general error condition

                                           EFalse );             // no multipart

        TRACE_FUNC_EXIT

        return retTemp;

        }

    // Next check the case without support: in this case a reply

    // can't be expected but return the "ERROR" anyway if needed.

    if ( !complInfo.iProcessed )

        {

        // Return "ERROR".

        TRACE_INFO(( _L8("Command handled without support: return \"ERROR\"") ));

        iMetadata->CompleteCommandMessage( NULL,

                                           KErrNone,

                                           ETrue,            // error reply

                                           EReplyTypeError,  // error type

                                           EFalse );         // no multipart

        TRACE_FUNC_EXIT

        return retTemp;

        }

    // Third, check a case where there is support but reply is not

    // expected. In this case "" must be returned to complete processing.

    if ( !complInfo.iReplyExpected )

        {

        // Return ""

        TRACE_INFO(( _L8("Command handled with support but no reply: return \"\"") ));

        iMetadata->CompleteCommandMessage( NULL,

                                           KErrNone,

                                           EFalse,           // no error reply

                                           EReplyTypeOther,  // reply type from plugin

                                           EFalse );         // no multipart

        TRACE_FUNC_EXIT

        return retTemp;

        }

    TRACE_INFO(( _L8("Command handled: wait for asynchronous reply or do nothing") ));

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Handles the servicing of pending AT command cancel

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

//

TInt CATExtSession::IpcCancelHandleCommand( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    TInt retVal = iMetadata->CancelHandleCommand();

    aMessage.Complete( retVal );

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// Handles the servicing of getting the next part of a reply for

// IpcHandleCommand().

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

//

TInt CATExtSession::IpcGetNextPartOfReply( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    TInt retTemp = iMetadata->GetNextPartOfReply( aMessage );

    if ( retTemp != KErrNone )

        {

        aMessage.Complete( retTemp );

        TRACE_FUNC_EXIT

        return retTemp;

        }

    // Note: Completed in metadata if successfull

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Handles the servicing of number of plugins. This information is needed to

// instantiate one or more listeners by the user of the client.

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

//

TInt CATExtSession::IpcNumberOfPlugins( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    TInt retVal = iMetadata->NumberOfPlugins();

    aMessage.Complete( retVal );

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// Handles the servicing of receiving unsolicited result codes. Note that

// IpcMarkUrcHandlingOwnership() must be called immediately after this in

// order for the message to receive their destination.

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

//

TInt CATExtSession::IpcReceiveUnsolicitedResult( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    if ( aMessage.GetDesMaxLength(EATExtReceiveUrcCmdParamBuf) !=

         KDefaultUrcBufLength )

        {

        aMessage.Complete( KErrBadDescriptor );

        TRACE_FUNC_EXIT

        return KErrBadDescriptor;

        }

    TPckgBuf<TUid> pluginUidPckgBuf;

    TInt retTemp = ReadStructFromMessage( pluginUidPckgBuf,

                                          EATExtReceiveUrcCmdParamUid,

                                          aMessage );

    if ( retTemp != KErrNone )

        {

        aMessage.Complete( retTemp );

        TRACE_FUNC_EXIT

        return retTemp;

        }

    TRAPD( retTrap, iMetadata->StartUrcReceivingL(aMessage,pluginUidPckgBuf()) );

    if ( retTrap != KErrNone )

        {

        aMessage.Complete( retTrap );

        TRACE_FUNC_EXIT

        return retTrap;

        }

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Handles the servicing of pending receiving unsolicited result code cancel

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

//

TInt CATExtSession::IpcCancelReceiveUrc( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    TPckgBuf<TUid> pluginUidPckgBuf;

    TInt retTemp = ReadStructFromMessage( pluginUidPckgBuf,

                                          EATExtCancelReceiveUrcCmdParamUid,

                                          aMessage );

    if ( retTemp != KErrNone )

        {

        aMessage.Complete( retTemp );

        TRACE_FUNC_EXIT

        return retTemp;

        }

    TInt retVal = iMetadata->CancelUrcReceiving( pluginUidPckgBuf() );

    aMessage.Complete( retVal );

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// Handles the servicing of marking URC handling ownership. Call to this

// function must be done immediately after the call to

// IpcReceiveUnsolicitedResult().

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

//

TInt CATExtSession::IpcMarkUrcHandlingOwnership( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    TInt retVal = iMetadata->MarkUrcHandlingOwnership( aMessage );

    aMessage.Complete( retVal );

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// Handles the servicing of ECOM plugin change notifications

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

//

TInt CATExtSession::IpcReceiveEcomPluginChange( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iMetadata )

        {

        aMessage.Complete( KErrGeneral );

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    if ( iEcomStatusMessage.Handle() )

        {

        aMessage.Complete( KErrBadHandle );

        TRACE_FUNC_EXIT

        return KErrBadHandle;

        }

    iEcomStatusMessage = aMessage;

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Handles the servicing of pending ECOM plugin change notification cancel