/*

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

*

* Description:  Metadata for ATEXT

*

*/

/*

 * Here is the plugin managing logic for the AT commands and hopefully also for

 * future needs:

 *

 * Three types of support:

 * 1) Master (M): Does not send to S if support found.

 * 2) Primary (P): Sends to all S if support found.

 * 3) Secondary (S): Process the command and give or not give reply, based on

 *    the following logic:

 *

 * => [If] M found, handle command and send reply, stop, [else]

 * [If] P found, handle command and send reply + send to N S {no reply}, stop, [else]

 * [If] > 1 S found, send to N S {no reply}, stop, [else]

 * [If] only 1 S found, handle command and send reply, stop, [else]

 * Write "ERROR" to client, complete message with KErrNone

 *

 * When incoming reply:

 * => If reply from M, write to client, stop, [else]

 * If reply from P, write to client, stop, [else]

 * If reply from S and M, P nor other S exist, write to client, stop, [else]

 * Complete message with KErrNone and empty string

 *

 * Note: Empty string and "ERROR" string are managed already in HandleCommand()

 */

#include <ecom/ecom.h>

#include <ecom/implementationInformation.h>

#include <atextpluginbase.h>

#include "atextclientsrv.h"

#include "atextmetadata.h"

#include "atextlisten.h"

#include "utils.h"

#include "debug.h"

const TInt  KGranularity           = 4;

const TInt8 KDefaultCarriageReturn = 13;

const TInt8 KDefaultLineFeed       = 10;

const TInt  KErrorMsgLen           = 9;  // 2+"ERROR"+2

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

// Two-phased constructor.

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

//

CATExtMetadata* CATExtMetadata::NewL( REComSession& aEComSession,

                                      CATExtListen* aListener,

                                      MATExtPluginObserver& aObserver )

    {

    CATExtMetadata* self = NewLC( aEComSession, aListener, aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CATExtMetadata* CATExtMetadata::NewLC( REComSession& aEComSession,

                                       CATExtListen* aListener,

                                       MATExtPluginObserver& aObserver )

    {

    CATExtMetadata* self = new (ELeave) CATExtMetadata( aEComSession,

                                                        aListener,

                                                        aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor.

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

//

CATExtMetadata::~CATExtMetadata()

    {

    ResetData();

    }

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

// Resets data to initial values

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

//

void CATExtMetadata::ResetData()

    {

    TRACE_FUNC_ENTRY

    iShutdown = ETrue;

    DestroyPlugindata();

    DestroySupportdata( iSupport );

    DestroySupportdata( iSupportAux );

    iConnectionName.Close();

    iShutdown = EFalse;

    TRACE_FUNC_EXIT

    }

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

// Creates new implementation metadata based on a given interface UID and

// connection. Uses AddImplementationL() to add new implementations for the

// interface and sets connection identification name for reporting it to the

// plugins on instantiation time.

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

//

void CATExtMetadata::CreateImplementationMetadataL( TUid& aIfUid,

                                                    const TDesC8& aName )

    {

    TRACE_FUNC_ENTRY

    if ( iPluginData || iSupport || iSupportAux )

        {

        TRACE_FUNC_EXIT

        User::Leave( KErrGeneral );

        }

    iIfUid = aIfUid;

    iConnectionName.CreateL( aName );

    RImplInfoPtrArray implementations;

    CleanupResetDestroyClosePushL( implementations );

    iEComSession.ListImplementationsL( iIfUid, implementations );

    const TUint implCount = implementations.Count();

    TRACE_INFO((_L("Number of AT Ext: %d"), implCount))

    iSupport = new (ELeave) CArrayFixFlat<TATExtAtCmdSupport>( KGranularity );

    iSupportAux = new (ELeave) CArrayFixFlat<TATExtAtCmdSupport>( KGranularity );

    iPluginData = new (ELeave) CArrayFixFlat<TATExtPluginEntry>( KGranularity );

    // As iSupport, iSupportAux and iPluginData are needed by

    // AddImplementationL(), no ease way to use temporary variables here.

    // If error occurs here then deletion of this class is required.

    for ( TUint i=0; i<implCount; i++ )

        {

        AddImplementationL( implementations[i] );

        }

    CleanupStack::PopAndDestroy( &implementations );

#if defined(_DEBUG) && defined( PRJ_PRINT_SUPPORT_DATA )

    PrintSupportData( iSupport );

    PrintSupportData( iSupportAux );

#endif

    TRACE_FUNC_EXIT

    }

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

// Adds an implementation to the metadata based on a given ECOM implementation

// information. This is used by the function CreateImplementationMetadataL()

// and also by CATExtSession when its ECOM notification listener detects an

// addition for a the same ECOM interface.

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

//

void CATExtMetadata::AddImplementationL( CImplementationInformation* aImplInfo )

    {

    TRACE_FUNC_ENTRY

    if ( !aImplInfo )

        {

        TRACE_FUNC_EXIT

        User::Leave( KErrGeneral );

        }

    DoAddImplementationL( aImplInfo, aImplInfo->DataType() );

    DoAddImplementationL( aImplInfo, aImplInfo->OpaqueData() );

    TRACE_FUNC_EXIT

    }

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

// Removes an implementation from the support data by a given plugin UID.

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

//

TInt CATExtMetadata::RemoveImplementation( TUid& aPluginUid,

                                           TBool aInstanceExists )

    {

    TRACE_FUNC_ENTRY

    if ( iShutdown )

        {

        TRACE_FUNC_EXIT

        return KErrNotReady;

        }

    DoRemoveImplementation( aPluginUid, iSupport );

    DoRemoveImplementation( aPluginUid, iSupportAux );

    TInt retVal = RemoveOnePlugindata( aPluginUid, aInstanceExists );

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// Handles an AT command

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

//

TInt CATExtMetadata::HandleCommand( const RMessage2& aMessage,

                                    TATExtCompletionInfo& aComplInfo )

    {

    TRACE_FUNC_ENTRY

    iCmdData.iCmdMessage = aMessage;

    if ( IsCommandHandling() )

        {

        TRACE_FUNC_EXIT

        return KErrInUse;

        }

    // Next pass the entry to command reader

    TInt retTemp = ReadCommandFromMessage( aMessage );

    if ( retTemp != KErrNone )

        {

        TRACE_FUNC_EXIT

        return retTemp;

        }

    TRACE_INFO(( _L8("Received command '%S'"), &iCmdData.iCmdBuffer ));

    // Now the command exists. Load the plugins for a command and check support.

    TRAPD( retTrap, CreateAndFindSupportL(iCmdData.iCmdBuffer,

                                          aMessage,

                                          aComplInfo ) );

    TRACE_FUNC_EXIT

    return retTrap;

    }

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

// Cancels an active handle command operation. Uses IsCommandHandling() and

// CancelCommandOperation().

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

//

TInt CATExtMetadata::CancelHandleCommand()

    {

    TRACE_FUNC_ENTRY

    if ( !IsCommandHandling() )

        {

        TRACE_FUNC_EXIT

        return KErrNotReady;

        }

    CancelCommandOperation( KErrCancel, ETrue );

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Gets the next part of a reply for HandleCommand(). Length of returned reply

// must be the same as the one reported from NextReplyPartLength() for the

// current reply.

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

//

TInt CATExtMetadata::GetNextPartOfReply( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iCmdData.iHandler || !iCmdData.iHandler->iInstance )

        {

        TRACE_FUNC_EXIT

        return KErrNotReady;

        }

    CATExtPluginBase& plugin = *iCmdData.iHandler->iInstance;

    TInt retTemp = plugin.GetNextPartOfReply( iCmdData.iCmdReplyBuffer );

    if ( retTemp!=KErrNone || iCmdData.iCmdReplyBuffer.Length()<=0 )

        {

        iCmdData.iCmdReplyBuffer.Close();

        TRACE_FUNC_EXIT

        return retTemp;

        }

    retTemp = WriteReplyBufferToClient(

        iCmdData.iCmdReplyBuffer,

        EATExtGetNextPartOfReplyParamReply,

        aMessage,

        ETrue,

        EATExtGetNextPartOfReplyParamLength );

    if ( retTemp != KErrNone )

        {

        iCmdData.iCmdReplyBuffer.Close();

        TRACE_FUNC_EXIT

        return retTemp;

        }

    aMessage.Complete( KErrNone );

    iCmdData.iCmdReplyBuffer.Close();

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Completes an URC processing message by a given plugin UID. Completion code

// for the client message is the return code from a write with

// WriteReplyBufferToClient()

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

//

TInt CATExtMetadata::CompleteUrcMessage( const TDesC8& aAtCmd,

                                         CATExtPluginBase* aPlugin )

    {

    TRACE_FUNC_ENTRY

    TATExtPluginEntry* foundEntry = FindInstanceFromPlugindata( aPlugin );

    if ( !foundEntry )

        {

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    if ( !foundEntry->iUrcMessage.Handle() )

        {

        TRACE_FUNC_EXIT

        return KErrBadHandle;

        }

    TInt retVal = WriteReplyBufferToClient( aAtCmd,

                                            EATExtReceiveUrcCmdParamBuf,

                                            foundEntry->iUrcMessage );

    foundEntry->iUrcMessage.Complete( retVal );

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// Completes an AT command handling message. Also clears internal initialized

// command hanlder data; see ClearInitializedCmdHandlerData().

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

//

TInt CATExtMetadata::CompleteCommandMessage( CATExtPluginBase* aPlugin,

                                             TInt aError,

                                             TBool aErrorReply,

                                             TATExtensionReplyType aReplyType,

                                             TBool aMultiPart )

    {

    TRACE_FUNC_ENTRY

    // First check if aPlugin is set (the call comes from a plugin and not from

    // ATEXT) and if it is the instance is different than the currently

    // operating one.

    if ( aPlugin && iCmdData.iHandler && iCmdData.iHandler->iInstance!=aPlugin )

        {

        TRACE_FUNC_EXIT

        return KErrInUse;

        }

    // Next check if aPlugin is set (the call comes from a plugin and not from

    // ATEXT) and a reply is not needed. In this case do nothing as it is wrong

    // behavior from the plugin (a plugin must not complete messages where no

    // reply is expected; this is done by ATEXT)

    if ( aPlugin && !iCmdData.iReplyExpected )

        {

        TRACE_FUNC_EXIT

        return KErrAlreadyExists;

        }

    if ( !iCmdData.iCmdMessage.Handle() )

        {

        TRACE_FUNC_EXIT

        return KErrBadHandle;

        }

    // Finally write the data and complete the message

    TPckg<TATExtensionReplyType> replyType( aReplyType );

    TInt writeError = iCmdData.iCmdMessage.Write( EATExtHandleCmdParamReplyType,

                                                  replyType );

    TRACE_INFO(( _L("Write returned %d"), writeError ));

    if ( aError==KErrNone && writeError==KErrNone )

        {

        if ( iCmdData.iHandler )  // Can be NULL when invoked from inside ATEXT

            {

            iCmdData.iOldHandler = iCmdData.iHandler->iInstance;

            }

        if ( !aPlugin )

            {

            CreateEmptyOrErrorBuffer( iCmdData.iCmdReplyBuffer, aErrorReply );

            }

        if ( aMultiPart )

            {

            WriteReplyBufferToClient( iCmdData.iCmdReplyBuffer,

                                      EATExtHandleCmdParamReply,

                                      iCmdData.iCmdMessage,

                                      ETrue,

                                      EATExtHandleCmdParamLength );

            }

        else

            {

            WriteReplyBufferToClient( iCmdData.iCmdReplyBuffer,

                                      EATExtHandleCmdParamReply,

                                      iCmdData.iCmdMessage );

            }

        }

    iCmdData.iCmdStarted = EFalse;

    iCmdData.iReplyExpected = EFalse;

    iCmdData.iCmdMessage.Complete( aError );

    ClearInitializedCmdHandlerData( aMultiPart );

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Clears internal initialized command handler data. This is currently used

// only by CompleteCommandMessage() and is called when the data is not needed

// anymore. It also prepares the internal data for a new HandleCommand() call.

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

//

TInt CATExtMetadata::ClearInitializedCmdHandlerData( TBool aMultiPart )

    {

    TRACE_FUNC_ENTRY

    if ( iCmdData.iCmdStarted )

        {

        TRACE_FUNC_EXIT

        return KErrNotReady;

        }

    iCmdData.iCmdBuffer.Close();

    iCmdData.iCmdReplyBuffer.Close();

    if ( !aMultiPart )

        {

        iCmdData.iHandler = NULL;

        }

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Gets the array of supported commands.

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

//

TInt CATExtMetadata::GetSupportedCommands( CATExtPluginBase* aPlugin,

                                           RPointerArray<HBufC8>& aCmds )

    {

    TRACE_FUNC_ENTRY

    if ( !iSupport || !iSupportAux )

        {

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    TATExtPluginEntry* foundEntry = FindInstanceFromPlugindata( aPlugin );

    if ( !foundEntry )

        {

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    // Next create the array of supported commands

    TInt retVal = KErrNone;

    TBool firstSearch = ETrue;

    TInt supportFind = KErrNotFound;

    TBool findInAux = EFalse;

    for ( ;; )

        {

        HBufC8* foundCmd = GetNextSupportedCommand( firstSearch,

                                                    supportFind,

                                                    findInAux );

        if ( !foundCmd )

            {

            break;

            }

        retVal = aCmds.Append( foundCmd );

        if ( retVal != KErrNone )

            {

            break;

            }

        }

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// Starts URC message receiving for plugin. Note that

// MarkUrcHandlingOwnership() must be called immediately after this in order

// for the messages to receive their destination.

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

//

void CATExtMetadata::StartUrcReceivingL( const RMessage2& aMessage,

                                         TUid& aPluginUid )

    {

    TRACE_FUNC_ENTRY

    TATExtPluginEntry* foundEntry = FindUrcProcessingPlugin( aPluginUid );

    if ( !foundEntry )

        {

        TRACE_FUNC_EXIT

        User::Leave( KErrNotFound );

        }

    // Note: Let locked plugin pass here

    InstantiatePluginL( *foundEntry );

    foundEntry->iUrcMessage = aMessage;

    foundEntry->iInstance->ReceiveUnsolicitedResult();

    foundEntry->iUrcStarted = ETrue;

    TRACE_FUNC_EXIT

    }

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

// Cancels an active URC message receiving operation by a given plugin UID.

// Uses CancelOneUrcOperation() to cancel if plugin UID found from plugin

// data.

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

//

TInt CATExtMetadata::CancelUrcReceiving( TUid& aPluginUid )

    {

    TRACE_FUNC_ENTRY

    TInt foundIndex = KErrNotFound;

    TATExtPluginEntry* foundEntry = FindUidFromPlugindata( aPluginUid,

                                                           foundIndex );

    if ( !foundEntry )

        {

        TRACE_FUNC_EXIT

        return KErrNotFound;

        }

    CancelOneUrcOperation( *foundEntry, KErrCancel, ETrue );

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// Marks URC handling ownership for a plugin entry. Call to this function must

// be done immediately after the call to StartUrcReceivingL().

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

//

TInt CATExtMetadata::MarkUrcHandlingOwnership( const RMessage2& aMessage )

    {

    TRACE_FUNC_ENTRY

    if ( !iPluginData )

        {

        TRACE_FUNC_EXIT

        return KErrGeneral;

        }

    TInt i = 0;

    TInt count = iPluginData->Count();

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

        {

        TATExtPluginEntry& entry = (*iPluginData)[i];

        if ( entry.iUrcStarted && !entry.iUrcOwned )

            {

            TPckg<TUid> pluginUid( entry.iPluginUid );

            TInt retTemp = aMessage.Write( EATExtMarkUrcHandlingOwnershipParamUid,

                                           pluginUid );

            TRACE_INFO(( _L("Write returned %d"), retTemp ));

            entry.iUrcOwned = ETrue;

            TRACE_FUNC_EXIT

            return KErrNone;

            }

        }

    TRACE_FUNC_EXIT

    return KErrNotFound;

    }

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