FCL/sf/incubator/modemadaptation: comparison adaptationlayer/modematadaptation/modematcontroller

equal deleted inserted replaced

-:6295dc2169f3
+:8486d82aef45
 /*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of the License "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #include <e32std.h>
 #include <iscapi.h>
 #include <iscnokiadefinitions.h>
 #include <pn_const.h>
-#ifndef NCP_COMMON_BRIDGE_FAMILY
 #include <nsisi.h>
 #include <pipeisi.h>
 #include <pipe_sharedisi.h>
-#endif
 #include <tisi.h>
 #include <at_modemisi.h>
 #include "cmodemathandler.h"
 #include "cmodematpipecontroller.h"
 #include "modemattrace.h"
 #include "cmodematsrv.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cmodemathandlerTraces.h"
+#endif
 #define KCommandBits 0x0f
-#define KMaxBufferLength 1024
 #define KTransactionIdBitsShift 4
 #define KFiller 0
 #define KIndicationOrderMsgLength 14
 #define KObjectIdLength 2
 #define KEightBits 8
 #define KDefaultTId 0
 const TInt KUnsubscribeFourEvents(4);
 const TInt KAlignToFourBytes(4);
+const TInt KSessionIndLimit(1);        // AT_MODEM_SIGNAL_IND is not handled if only one session is connected
+const TInt KEscapeDataLength(2);
+const TInt KFlowCtrlDataLength(3);
+const TUint8 KReservedDteId( 255 );
 #ifdef __WINSCW__
 #define KEmulatedReplyMsgLength 50
 #endif
-CModemAtHandler* CModemAtHandler::NewL( CModemAtSrv& aServer )
+CModemAtHandler* CModemAtHandler::NewL(
-{
+CModemAtSrv& aServer,
-CModemAtHandler* self = new (ELeave) CModemAtHandler( aServer );
+TInt aChannel )
+{
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_NEWL, "CModemAtHandler::NewL" );
+CModemAtHandler* self = new (ELeave) CModemAtHandler( aServer, aChannel );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop( self );
 return self;
 }
 CModemAtHandler::~CModemAtHandler()
 {
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_CMODEMATHANDLER, "CModemAtHandler::~CModemAtHandler" );
 C_TRACE(( _T("CModemAtHandler::~CModemAtHandler()") ));
 TBuf8<KUnsubscribeFourEvents> events;
 events.Append( KFiller );
 events.Append( KFiller );
 events.Append( KFiller );
 }
 Cancel();
 if( iIscApi )
 {
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_CMODEMATHANDLER, "CModemAtHandler::~CModemAtHandler - closing isc api" );
+C_TRACE(( _T("CModemAtHandler::~CModemAtHandler() closing isc api") ));
 iIscApi->Close();
 delete iIscApi;
 }
 }
-CModemAtHandler::CModemAtHandler( CModemAtSrv& aServer )
+CModemAtHandler::CModemAtHandler( CModemAtSrv& aServer, TInt aChannel )
 : CActive( EPriorityHigh ),
 iServer( aServer ),
 iIscApi( NULL ),
 iReceivedMessageBuffer( NULL ),
 iMessageBufferSize( KMaxBufferLength ),
 iReceivePtr( 0, 0 ),
 iReceiveMessageLength( 0 ),
 iReceivedMessage( NULL ),
 iPepObjId(0),
+iDataportObjId(0),
 iPipeController(NULL),
 iLastTransactionId( 0 ),
 iDisconnected( EFalse ),
-iModemAtExistInCmt( EFalse )
+iModemAtExistInCmt( EFalse ),
-{
+iTextMessageMode( EFalse ),
+iChannel( aChannel )
+{
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_CMODEMATHANDLER, "CModemAtHandler::CModemAtHandler" );
 C_TRACE (( _T("CModemAtHandler::CModemAtHandler") ));
 }
 void CModemAtHandler::DoCancel()
 {
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_DOCANCEL, "CModemAtHandler::DoCancel" );
 C_TRACE (( _T("CModemAtHandler::DoCancel()") ));
 iIscApi->ReceiveCancel();
 }
 void CModemAtHandler::RunL()
 {
-C_TRACE (( _T("CModemAtHandler::RunL()") ));
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL" );
+C_TRACE (( _T("CModemAtHandler::RunL() %d"), iDteId ));
 if( iStatus == KErrNone )
 {
 TIsiReceiveC receiveMessage = TIsiReceiveC( *iReceivedMessageBuffer );
+OstTraceExt1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - message dump;iReceivePtr=%s", iReceivePtr );
 DUMP_MESSAGE( iReceivePtr );
 if( iReceivedMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID )
 {
 switch(receiveMessage.Get8bit(ISI_HEADER_OFFSET_RESOURCEID))
 {
 case PN_AT_MODEM: //AT MODEM COMMANDS
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - PN_AT_MODEM" );
 C_TRACE(_L("PN_AT_MODEM"));
 switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )
 {
 case AT_MODEM_CONNECT_RESP:
 HandleModemConnectResp( receiveMessage );
 break;
 case AT_MODEM_DISCONNECT_RESP:
+OstTrace0( TRACE_NORMAL, DUP3_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_DISCONNECT_RESP" );
 C_TRACE(_L("AT_MODEM_DISCONNECT_RESP"));
 break;
 case AT_MODEM_CMD_RESP:
 HandleATResponse( receiveMessage );
 case AT_MODEM_SIGNAL_IND:
 HandleSignalInd( receiveMessage );
 break;
 case AT_MODEM_UNSOLICITED_DATA_IND:
+OstTrace0( TRACE_NORMAL, DUP4_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_UNSOLICITED_DATA_IND" );
+C_TRACE(_L("AT_MODEM_UNSOLICITED_DATA_IND"));
 HandleUnsolicitedData( receiveMessage );
 break;
 case AT_MODEM_INTERMEDIATE_DATA_IND:
 HandleIntermediateDataInd( receiveMessage );
 case AT_MODEM_DATA_REDIRECT_IND:
 HandleRedirectInd( receiveMessage );
 break;
 case AT_MODEM_DATA_REDIRECT_RESULT_RESP:
+OstTrace0( TRACE_NORMAL, DUP5_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_DATA_REDIRECT_RESULT_RESP" );
 C_TRACE((_L("AT_MODEM_DATA_REDIRECT_RESULT_RESP")));
 HandleRedirectResultResp( receiveMessage );
 break;
 case AT_MODEM_SIGNAL_DETECTED_RESP:
+OstTrace0( TRACE_NORMAL, DUP6_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - AT_MODEM_SIGNAL_DETECTED_RESP" );
 C_TRACE((_L("AT_MODEM_SIGNAL_DETECTED_RESP")));
 HandleSignalDetectedResp(  receiveMessage  );
 break;
 default:
+OstTrace0( TRACE_NORMAL, DUP7_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - Not a valid message" );
 C_TRACE(_L("CModemAtHandler::RunL: Not a valid message"))  ;
 TRACE_ASSERT_ALWAYS;
 break;
 } //switch( receiveMessage.Get8bit( ISI_HEADER_OFFSET_MESSAGEID ) )
 break;  //case PN_AT_MODEM: //AT MODEM COMMANDS
-#ifndef NCP_COMMON_BRIDGE_FAMILY
+case PN_NAMESERVICE:
-case PN_NAME_SERVICE:
+OstTrace0( TRACE_NORMAL, DUP8_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - PN_NAMESERVICE" );
-C_TRACE(_L("PN_NAME_SERVICE"));
+C_TRACE(_L("PN_NAMESERVICE"));
-iPipeController->HandleNameServiceMessage(receiveMessage);
+iPipeController->HandleNameServiceMessage( receiveMessage );
 break;
 case PN_PIPE:
-C_TRACE(_L("Pipe message"));
+OstTrace0( TRACE_NORMAL, DUP9_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - PN_PIPE" );
-iPipeController->HandlePipeServiceMessage(receiveMessage);
+C_TRACE(_L("PN_PIPE"));
+iPipeController->HandlePipeServiceMessage( receiveMessage );
 break;
-#endif
 default:
+OstTrace0( TRACE_NORMAL, DUP10_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - Unknown resource id" );
 C_TRACE((_L("Unknown resource id")));
 TRACE_ASSERT_ALWAYS;
 break;
 }
 } //if( receiveMessageBuffer->Length() > ISI_HEADER_OFFSET_MESSAGEID )
 else
 {
+OstTrace0( TRACE_NORMAL, DUP11_CMODEMATHANDLER_RUNL, "CModemAtHandler::RunL - ISI message is too short" );
 C_TRACE(_L("ISI message is too short"));
 TRACE_ASSERT_ALWAYS;
 }
 //Start receiving ISI messages again
 }
 void CModemAtHandler::ConstructL()
 {
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_CONSTRUCTL, "CModemAtHandler::ConstructL" );
 C_TRACE (( _T("CModemAtHandler::ConstructL()") ));
 CActiveScheduler::Add( this );
 iIscApi = new ( ELeave ) RIscApi;
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_CONSTRUCTL, "CModemAtHandler::ConstructL - RIscApi created" );
 C_TRACE(_L("RIscApi created"));
 #ifndef __WINSCW__
 OpenChannelL();
-#ifndef NCP_COMMON_BRIDGE_FAMILY
+if( iChannel == EIscNokiaAtController )
-iPipeController->QueryModemAtFromNameService();
+{
-#endif
+iPipeController->QueryModemAtFromNameService();
+}
+else
+{
+SetModemAtExistsInCmt( ETrue );
+}
 #else
 iEmulatedValue = 0;
 #endif
 }
-TInt CModemAtHandler::SendATCommand(const TUint8 aDteId,
+TInt CModemAtHandler::SendATCommand(
 const TATPluginInterface aPluginType,
 const TUint8 aMessageType,
 const TDesC8& aCmd)
 {
-C_TRACE (( _T(">>CModemAtHandler::SendATCommand()") ));
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand;iDteId=%d", iDteId );
+C_TRACE (( _T(">>CModemAtHandler::SendATCommand() %d"), iDteId ));
 TInt err = KErrNone;
 // aMessageType contains normal AT-cmd (0) or Nvram-query (1)
 TUint transactionId = ( aPluginType << KTransactionIdBitsShift ) | aMessageType;
 // used with intermediate data ind
 // can be removed, when AT_MODEM_INTERMEDIATE_DATA_IND supports transactionid
 iLastTransactionId = transactionId;  //messages are routed to correct plugin by transaction id
+OstTraceExt4( TRACE_NORMAL, DUP1_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand;transactionId=%d;aPluginType=%d;aMessageType=%d;iLastTransactionId=%d", transactionId, aPluginType, aMessageType, iLastTransactionId );
 C_TRACE((_L("transaction id %d, plugintype %d, aMessageType %d"), transactionId, aPluginType, aMessageType));
 C_TRACE((_L("iLastTransctionId = %d "), iLastTransactionId ));
-#ifdef __WINSCW__
-iDteId = aDteId;
-iChannel = aMessageType;
-iPluginType = aPluginType;
-HandleATResponse();
-return KErrNone;
-#endif
 TInt size = ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + aCmd.Length();
 TInt sizeWithFillers = size;
 while( sizeWithFillers % KAlignToFourBytes )
 {
 sizeWithFillers++;
 }
+OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - Message length;sizeWithFillers=%d", sizeWithFillers );
 C_TRACE((_L("Message length %d"), sizeWithFillers));
 HBufC8* message = HBufC8::New( sizeWithFillers );
 if( message )
 {
 TPtr8 messageptr = message->Des();
 TIsiSend isimessage( messageptr, sizeWithFillers );
 isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_TID, transactionId );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_MESSAGEID, AT_MODEM_CMD_REQ );
-isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_DTEID, aDteId );
+isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_DTEID, iDteId );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_FILLERBYTE1, 0 );
+OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - AT command length:;aCmd.Length()=%d", aCmd.Length() );
 C_TRACE((_L("AT command length: %d"), aCmd.Length()));
 isimessage.Set16bit( ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_LENGTH, (TUint16) aCmd.Length() );
 const TUint8* ptr = aCmd.Ptr();
 for ( TInt i = 0; i < aCmd.Length(); i++ )
 {
+OstTraceExt3( TRACE_NORMAL, DUP4_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - message;i=%d;ptr[i]=%x;charptr[i]=%c", i, ptr[i], ptr[i] );
 C_TRACE((_L("message %d, 0x%x '%c'"), i, ptr[i], ptr[i]));
 isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CMD_REQ_OFFSET_CMDLINEBUFFER + i, ptr[i]);
 }
 for( TInt j = sizeWithFillers; j < size; j++ )
 {
+OstTrace1( TRACE_NORMAL, DUP5_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - Add filler;j=%d", j );
 C_TRACE((_L("Add filler [%d]"), j));
 isimessage.Set8bit( j , KFiller );
 }
 isimessage.Complete();
+OstTraceExt1( TRACE_NORMAL, DUP6_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - Created ISI-message;messageptr=%s", messageptr );
 C_TRACE(_L("Created ISI-message"));
 DUMP_MESSAGE( messageptr );
 err = iIscApi->Send( messageptr );
 TRACE_ASSERT( err == KErrNone );
 delete message;
 message = NULL;
 }
 else
 {
+OstTrace0( TRACE_NORMAL, DUP7_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand - No memory - error in sending ISI message from heap" );
 C_TRACE(_L("No memory - error in sending ISI message from heap"));
 TRACE_ASSERT_ALWAYS;
 }
+OstTrace1( TRACE_NORMAL, DUP8_CMODEMATHANDLER_SENDATCOMMAND, "CModemAtHandler::SendATCommand;err=%d", err );
 C_TRACE (( _T("<<CModemAtHandler::SendATCommand() err: %d"), err ));
 return err;
 }
 void CModemAtHandler::OpenChannelL()
 {
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL" );
 C_TRACE (( _T("CModemAtHandler::OpenChannelL()") ));
 TRequestStatus openStatus;
-iIscApi->Open( EIscNokiaAtController, openStatus, EOwnerThread );
+iIscApi->Open( iChannel, openStatus, EOwnerThread );
 User::WaitForRequest( openStatus );
 TRACE_ASSERT( !openStatus.Int());
 if( iReceivedMessageBuffer )
 iReceivedMessageBuffer = HBufC8::NewL(iMessageBufferSize);
 TRACE_ASSERT(iReceivedMessageBuffer);
 iReceivePtr.Set( iReceivedMessageBuffer->Des() );
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - Start receive ISI messages" );
 C_TRACE(_L("Start receive ISI messages"));
 iIscApi->Receive( iStatus, iReceivePtr, iReceiveMessageLength );
 SetActive();
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - Start receive indications" );
 C_TRACE(_L("Start receive indications"));
 TBuf8<KIndicationOrderMsgLength> events;
 events.Append( PN_AT_MODEM );
 events.Append( AT_MODEM_INTERMEDIATE_DATA_IND );
 events.Append( PN_AT_MODEM );
 events.Append( PN_AT_MODEM );
 events.Append( AT_MODEM_UNSOLICITED_DATA_IND );
 events.Append( PN_AT_MODEM );
 events.Append( AT_MODEM_DATA_REDIRECT_IND );
-#ifndef NCP_COMMON_BRIDGE_FAMILY
+#ifndef PIPECAMP_UNSUBSCRIBE_PNS_PEP_STATUS_IND
+events.Append( PN_PIPE );
+events.Append( PNS_PEP_STATUS_IND );
+#endif
 //name add ind
 events.Append( PN_NAMESERVICE );
 events.Append( PNS_NAME_ADD_IND );
 events.Append( PN_NAMESERVICE );
 events.Append( PNS_NAME_REMOVE_IND );
-events.Append( PN_PIPE );
-events.Append( PNS_PEP_STATUS_IND );
+iIscApi->CustomFunction( EIscNokiaEventSubscribe, &events );
-#else
-events.Append( 0 );
-events.Append( 0 );
-events.Append( 0 );
-events.Append( 0 );
-events.Append( 0 );
-events.Append( 0 );
-#endif
-iIscApi->CustomFunction(EIscNokiaEventSubscribe,&events);
 TBuf8<KObjectIdLength> objId;
-iIscApi->GetChannelInfo(EIscNokiaAtController, objId);
+iIscApi->GetChannelInfo( iChannel, objId );
 iPepObjId = (((TUint16)(objId[0]))<<KEightBits) + objId[1];
+OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL;iPepObjId=%x", iPepObjId );
 C_TRACE((_L("PepObjId 0x%x"),iPepObjId));
 iPipeController = CModemAtPipeController::NewL(*iIscApi, iPepObjId, *this);
+OstTraceExt1( TRACE_NORMAL, DUP4_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL;iPipeController=%p", iPipeController );
 C_TRACE((_L("iPipeController 0x%x"),iPipeController ));
 ASSERT_PANIC_ALWAYS( iPipeController );
+TBuf8<KObjectIdLength> dpObjId;
+OstTrace0( TRACE_NORMAL, DUP5_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - GetChannelInfo(EIscNokiaDataport2)" );
+C_TRACE(( _T("GetChannelInfo() EIscNokiaDataport2") ));
+iIscApi->GetChannelInfo( EIscNokiaDataport2, dpObjId );
+OstTrace0( TRACE_NORMAL, DUP6_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL - GetChannelInfo() done" );
+C_TRACE(( _T("GetChannelInfo() done") ));
+iDataportObjId = (((TUint16)(dpObjId[0])) << KEightBits) + dpObjId[1];
+OstTrace1( TRACE_NORMAL, DUP7_CMODEMATHANDLER_OPENCHANNELL, "CModemAtHandler::OpenChannelL;iDataportObjId=%x", iDataportObjId );
+C_TRACE((_L("DataportObjId 0x%x"), iDataportObjId));
 }
 void CModemAtHandler::HandleATResponse( const TIsiReceiveC& aMessage )
 {
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse" );
 C_TRACE (( _T("CModemAtHandler::HandleATResponse()") ));
 TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_DTEID ) ;
 TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_TID );
 TUint8 command = transactionId & KCommandBits; //normal AT-cmd or Nvram-query
-TInt length = aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_CMD_RESP_OFFSET_LENGTH );
+TInt length = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_LENGTH );
+OstTraceExt3( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse;dteId=%d;AT (0) or nvram command (1):;command=%d;Response length;length=%d", dteId, command, length );
 C_TRACE(( _L("DteId: %d AT (0) or nvram command (1): %d Response length %d"), dteId, command, length ));
 /**
 * Plugintype can be read from transaction id:
 * TUint8 pluginType = transactionId >> KTransactionIdBitsShift;
 * (TATPluginInterface) pluginType
 *
 * Current implementation uses first in first out response completion
 * so plugintype is not needed.
 */
+OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse - ;Plugintype=%d", transactionId >> KTransactionIdBitsShift );
 C_TRACE(( _L("Plugintype: %d"), transactionId >> KTransactionIdBitsShift ));
-iServer.HandleATResponse( dteId,
+iServer.HandleATResponse(
+dteId,
+this,
 aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_CMDLINEBUFFER, length),
 command );
 }
 #ifdef __WINSCW__
 void CModemAtHandler::HandleATResponse( )
 {
-C_TRACE (( _T("CModemAtHandler::HandleATResponse()") ));
+OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEATRESPONSE, "CModemAtHandler::HandleATResponse;iDteId=%d", iDteId );
+C_TRACE (( _T("CModemAtHandler::HandleATResponse() %d"), iDteId ));
 //reply back immediately
 const TInt KReplyLength(50);
 TBuf8<KReplyLength> replyEmulated = _L8("\r\nAT TEST REPLY");
 replyEmulated.AppendNum(iEmulatedValue++);
 replyEmulated.Append(_L8("\r\n"));
-iServer.HandleATResponse( iDteId, replyEmulated, 0 /* 0 = AT-cmd, 1 = nvram */);
+iServer.HandleATResponse( iDteId, this, replyEmulated, 0 /* 0 = AT-cmd, 1 = nvram */);
 }
 #endif
-TInt CModemAtHandler::Connect( const TUint8 aDteId )
+TInt CModemAtHandler::Connect( TUint8 aDevId, TUint8 aObjId )
 {
-C_TRACE (( _T("CModemAtHandler::Connect()") ));
+OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_CONNECT, "CModemAtHandler::Connect;aDevId=%hhx;aObjId=%hhx", aDevId, aObjId );
+C_TRACE (( _T("CModemAtHandler::Connect() dev id: 0x%x, obj id: 0x%x"), aDevId, aObjId ));
 if( !iModemAtExistInCmt )
 {
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_CONNECT, "CModemAtHandler::Connect - Connection failed, PN_AT_MODEM is not in CMT" );
 C_TRACE((_T("Connection failed, PN_AT_MODEM is not in CMT")));
 TRACE_ASSERT_ALWAYS;
 return KErrNotFound;
 }
 SetDisconnected( EFalse );
-#ifdef __WINSCW__
+iPipeController->SendCreatePipeMessage( aDevId, aObjId );
 return KErrNone;
-#endif
-TInt err( KErrNone );
-	TUint8 pipeHandle( KInvalidPipeHandle );
-#ifndef NCP_COMMON_BRIDGE_FAMILY
-pipeHandle = iPipeController->GetPipeHandle();
-#endif
-if( pipeHandle == KInvalidPipeHandle )
-{
-C_TRACE(( _L("Connecting with dteId %d. (RComm was not used before connecting the plug-ins)."), aDteId ));
-err = SendAtModemConnectReq( aDteId );
-}
-else
-{
-C_TRACE(( _L("Connecting with pipehandle %d."), pipeHandle ));
-err = SendAtModemConnectReq( pipeHandle );
-}
-if( err != KErrNone )
-{
-TRACE_ASSERT_ALWAYS;
-return KErrNotFound;
-}
-return KErrNone;
 }
 void CModemAtHandler::SetDisconnected( TBool aIsDisconnected )
 {
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SETDISCONNECTED, "CModemAtHandler::SetDisconnected;aIsDisconnected=%d", aIsDisconnected );
 C_TRACE (( _T("CModemAtHandler::SetDisconnected(%d)"),aIsDisconnected ));
 iDisconnected = aIsDisconnected;
 }
 TBool CModemAtHandler::IsDisconnected()
 {
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_ISDISCONNECTED, "CModemAtHandler::IsDisconnected;iDisconnected=%d", iDisconnected );
 C_TRACE (( _T("CModemAtHandler::IsDisconnected(%d)"),iDisconnected ));
 return iDisconnected;
 }
 TBool CModemAtHandler::IsPluginConnected()
 {
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_ISPLUGINCONNECTED, "CModemAtHandler::IsPluginConnected;iServer.SessionCount()=%d", iServer.SessionCount() );
 C_TRACE (( _T("CModemAtHandler::IsPluginConnected() sessions: %d"), iServer.SessionCount() ));
 return iServer.SessionCount() > 0;
 }
-void CModemAtHandler::RemovePipe( const TUint8 aDteId )
+void CModemAtHandler::RemovePipe()
 {
-C_TRACE(( _T("CModemAtHandler::RemovePipe()")));
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_REMOVEPIPE, "CModemAtHandler::RemovePipe;iDteId=%d", iDteId );
+C_TRACE(( _T("CModemAtHandler::RemovePipe() %d"), iDteId ));
 iDisconnected = ETrue;
-#ifndef NCP_COMMON_BRIDGE_FAMILY
+iPipeController->RemovePipe();
-iPipeController->RemovePipe( aDteId );
+}
-#endif
-}
+TInt CModemAtHandler::Disconnect()
+{
-TInt CModemAtHandler::Disconnect( const TUint8 aDteId )
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_DISCONNECT, "CModemAtHandler::Disconnect;iDteId=%d", iDteId );
-{
+C_TRACE (( _T("CModemAtHandler::Disconnect(%d)"),iDteId ));
-C_TRACE (( _T("CModemAtHandler::Disconnect(%d)"),aDteId ));
-#ifdef __WINSCW__
-iDteId = aDteId;
-return KErrNone;
-#endif
 TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_DISCONNECT_REQ;
 HBufC8* message = HBufC8::New( size );
 TRACE_ASSERT( message );
 TPtr8 messageptr = message->Des();
 TIsiSend isimessage( messageptr, size );
 isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID,PN_AT_MODEM);
 isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_TID, 0);
 isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_MESSAGEID,
 AT_MODEM_DISCONNECT_REQ);
-isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_DTEID, aDteId);
+isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_DTEID, iDteId);
 isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_DISCONNECT_REQ_OFFSET_FILLERBYTE1, KFiller);
 isimessage.Complete();
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_DISCONNECT, "CModemAtHandler::Disconnect - Sending AT_MODEM_DISCONNECT_REQ" );
 C_TRACE (( _T("CModemAtHandler::Disconnect Sending AT_MODEM_DISCONNECT_REQ")));
 TInt err = iIscApi->Send(messageptr);
 TRACE_ASSERT( err == KErrNone );
 delete message;
 return err;
 void CModemAtHandler::HandleModemConnectResp( const TIsiReceiveC& aMessage )
 {
-C_TRACE (( _T("CModemAtHandler::HandleModemConnectResp()") ));
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEMODEMCONNECTRESP, "CModemAtHandler::HandleModemConnectResp;iDteId=%d", iDteId );
+C_TRACE (( _T("CModemAtHandler::HandleModemConnectResp() %d"), iDteId ));
 TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CONNECT_RESP_OFFSET_DTEID );
 TInt status = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CONNECT_RESP_OFFSET_RESULT );
 TInt err = KErrGeneral;
 if( status == AT_MODEM_RESULT_OK )
 {
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEMODEMCONNECTRESP, "CModemAtHandler::HandleModemConnectResp - Connected ok, AT_MODEM_RESULT_OK received" );
 C_TRACE(_L("Connected ok, AT_MODEM_RESULT_OK received"));
 err = KErrNone;
 }
 else
 {
+OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEMODEMCONNECTRESP, "CModemAtHandler::HandleModemConnectResp - Connection failed, AT_MODEM_RESULT_ERROR received;status=%d", status );
 C_TRACE((_L("Connection failed, AT_MODEM_RESULT_ERROR received (%d)"), status));
-TRACE_ASSERT_ALWAYS;
 }
 iServer.SetDteIdAndConnect( dteId, err );
 }
 void CModemAtHandler::HandleSignalInd( const TIsiReceiveC& aMessage )
 {
-C_TRACE (( _T("CModemAtHandler::HandleSignalInd()") ));
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;iDteId=%d", iDteId );
+C_TRACE (( _T("CModemAtHandler::HandleSignalInd() (%d)"), iDteId ));
 TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_IND_OFFSET_DTEID );
-iServer.HandleSignalInd( dteId );
+OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;dteId=%x", dteId );
+C_TRACE(( _L("dteId: 0x%x"), dteId ));
+if( iDteId != dteId )
+{
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND is ignored because of it's received from diffrent dte." );
+C_TRACE (( _T("AT_MODEM_SIGNAL_IND is ignored because of it's received from diffrent dte.") ));
+return;
+}
+if( IsTextMessageMode() )
+{
+OstTrace0( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND is ignored during text message mode." );
+C_TRACE (( _T("AT_MODEM_SIGNAL_IND is ignored during text message mode.") ));
+return;
+}
+// Go through indications. Note that common plugin handles only these:
+// echo, verbose, quiet, escape char, linefeed char and backspace char.
+TUint8 count = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_IND_OFFSET_NOOFSUBBLOCKS );
+OstTrace1( TRACE_NORMAL, DUP4_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - subblock;count=%d", count );
+C_TRACE(( _L("subblock count: 0x%x"), count ));
+if( count > 0 )
+{
+TInt length( ISI_HEADER_SIZE + SIZE_AT_MODEM_SIGNAL_IND );
+TUint8 messageId( 0 );
+TUint8 echoValue( KInitialValue );
+TUint8 escapeChar( KInitialValue );
+TUint8 flowControlOutward( AT_MODEM_FLOW_CONTROL_SW );
+TUint8 flowControlInward( AT_MODEM_FLOW_CONTROL_SW );
+TUint8 flowControlExtract( AT_MODEM_WITH_EXTRACT );
+TUint8 dcdValue( AT_MODEM_DCD_OFF );
+TUint8 dsrValue( AT_MODEM_DSR_OFF );
+for( TInt i = 0; i < count; i++ )
+{
+messageId = aMessage.Get8bit( length );
+OstTrace1( TRACE_NORMAL, DUP5_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;messageId=%x", messageId );
+C_TRACE((_L("messageId: 0x%x"), messageId));
+switch( messageId )
+{
+case AT_MODEM_SB_ECHO_VALUE:
+{
+echoValue = aMessage.Get8bit( length +
+AT_MODEM_SB_ECHO_VALUE_OFFSET_ECHOVALUE );
+OstTrace1( TRACE_NORMAL, DUP6_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;echoValue=%x", echoValue );
+C_TRACE(( _L("echo value: 0x%x"), echoValue));
+length += SIZE_AT_MODEM_SB_ECHO_VALUE;
+break;
+}
+case AT_MODEM_SB_DTE_PARAMS:
+{
+length += SIZE_AT_MODEM_SB_DTE_PARAMS;
+break;
+}
+case AT_MODEM_SB_FLOW_CTRL:
+{
+flowControlOutward = aMessage.Get8bit( length +
+AT_MODEM_SB_FLOW_CTRL_OFFSET_FLOWCTRLOUTWARDDCE );
+C_TRACE(( _L("Flow control outward used by DCE towards DTE: 0x%x"), flowControlOutward ));
+flowControlInward = aMessage.Get8bit( length +
+AT_MODEM_SB_FLOW_CTRL_OFFSET_FLOWCTRLINWARDDTE );
+C_TRACE(( _L("Flow control inward from DTE: 0x%x"), flowControlInward ));
+flowControlExtract = aMessage.Get8bit( length +
+AT_MODEM_SB_FLOW_CTRL_OFFSET_EXTRACT );
+C_TRACE(( _L("extract: 0x%x"), flowControlExtract ));
+TBuf8<KFlowCtrlDataLength> data;
+switch( flowControlOutward )
+{
+case AT_MODEM_FLOW_CONTROL_SW:
+data.Append( PEP_COMM_FLOW_CTRL_SW );
+break;
+case AT_MODEM_FLOW_CONTROL_NONE:
+data.Append( PEP_COMM_FLOW_CTRL_NONE );
+break;
+case AT_MODEM_FLOW_CONTROL_HW:
+data.Append( PEP_COMM_FLOW_CTRL_HW );
+break;
+default:
+data.Append( PEP_COMM_FLOW_CTRL_SW );
+break;
+}
+switch( flowControlInward )
+{
+case AT_MODEM_FLOW_CONTROL_SW:
+data.Append( PEP_COMM_FLOW_CTRL_SW );
+break;
+case AT_MODEM_FLOW_CONTROL_NONE:
+data.Append( PEP_COMM_FLOW_CTRL_NONE );
+break;
+case AT_MODEM_FLOW_CONTROL_HW:
+data.Append( PEP_COMM_FLOW_CTRL_HW );
+break;
+default:
+data.Append( PEP_COMM_FLOW_CTRL_SW );
+break;
+}
+switch( flowControlExtract )
+{
+case AT_MODEM_NO_EXTRACT:
+data.Append( PEP_COMM_FLOW_CTRL_NO_EXTRACT );
+break;
+case AT_MODEM_WITH_EXTRACT:
+data.Append( PEP_COMM_FLOW_CTRL_EXTRACT );
+break;
+default:
+data.Append( PEP_COMM_FLOW_CTRL_EXTRACT );
+break;
+}
+TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState();
+if( pipeState != TPipeInfo::EPipeNoPipe &&
+pipeState != TPipeInfo::EPipeRemoving )
+{
+iPipeController->SendPepCtrlReq( PEP_COMM_CTRL_ID_FLOW_CTRL, data );
+}
+length += SIZE_AT_MODEM_SB_FLOW_CTRL;
+break;
+}
+case AT_MODEM_SB_ESCAPE_PARAMS:
+{
+escapeChar = aMessage.Get8bit( length +
+AT_MODEM_SB_ESCAPE_PARAMS_OFFSET_ESCAPECHAR );
+OstTrace1( TRACE_NORMAL, DUP7_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;escapeChar=%x", escapeChar );
+C_TRACE(( _L("escape character: 0x%x"),  escapeChar ));
+length += SIZE_AT_MODEM_SB_ESCAPE_PARAMS;
+break;
+}
+case AT_MODEM_SB_AUTOBAUD:
+{
+length += SIZE_AT_MODEM_SB_AUTOBAUD;
+break;
+}
+case AT_MODEM_SB_DTE_SIGNALS:
+{
+dcdValue = aMessage.Get8bit( length +
+AT_MODEM_SB_DTE_SIGNALS_OFFSET_DCDSIGNAL );
+OstTrace1( TRACE_NORMAL, DUP8_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;dcdValue=%x", dcdValue );
+					C_TRACE(( _L("DCD value: 0x%x"), dcdValue));
+dsrValue = aMessage.Get8bit( length +
+AT_MODEM_SB_DTE_SIGNALS_OFFSET_DSRSIGNAL );
+OstTrace1( TRACE_NORMAL, DUP9_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd;dsrValue=%x", dsrValue );
+					C_TRACE(( _L("DSR value: 0x%x"), dsrValue));
+TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState();
+if( pipeState != TPipeInfo::EPipeNoPipe &&
+pipeState != TPipeInfo::EPipeRemoving )
+{
+if( AT_MODEM_DCD_OFF == dcdValue )
+{
+iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DCD_OFF );
+}
+else if( AT_MODEM_DCD_ON == dcdValue )
+{
+iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DCD_ON );
+}
+if( AT_MODEM_DSR_OFF == dsrValue )
+{
+iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DSR_OFF );
+}
+else if( AT_MODEM_DSR_ON == dsrValue )
+{
+iPipeController->SendPepStatusIndSignal( PEP_COMM_SIGNAL_DSR_ON );
+}
+}
+length += SIZE_AT_MODEM_SB_DTE_SIGNALS;
+break;
+}
+default:
+{
+TRACE_ASSERT_ALWAYS;
+break;
+}
+}
+}
+if( escapeChar != KInitialValue )
+{
+OstTrace0( TRACE_NORMAL, DUP10_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - Escape char received, it will be sent to dataport." );
+C_TRACE(( _T("Escape char received, it will be sent to dataport.") ));
+// Dataport should have the pipehandle and escape character. It defaults to handle 0xff and escape char '+'.
+TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState();
+if( pipeState != TPipeInfo::EPipeNoPipe &&
+pipeState != TPipeInfo::EPipeRemoving )
+{
+TBuf8<KEscapeDataLength> data;
+data.Append( escapeChar );
+data.Append( KEscapeTime );
+iPipeController->SendPepCtrlReq( PEP_COMM_CTRL_ID_ESCAPE, data );
+}
+}
+if( IsPipeInDataMode() )
+{
+OstTrace0( TRACE_NORMAL, DUP11_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND is ignored during data mode (exception: escape char is allowed)" );
+C_TRACE (( _T("AT_MODEM_SIGNAL_IND is ignored during data mode (exception: escape char is allowed)") ));
+return;
+}
+if( echoValue == KInitialValue )
+{
+OstTrace0( TRACE_NORMAL, DUP12_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled (no echo changes)" );
+C_TRACE(( _T("AT_MODEM_SIGNAL_IND not handled (no echo changes)") ));
+return;
+}
+TInt sessionCount = iServer.SessionCount();
+if( sessionCount == KSessionIndLimit )
+{
+OstTrace0( TRACE_NORMAL, DUP13_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled (connect ongoing)" );
+C_TRACE(( _T("AT_MODEM_SIGNAL_IND not handled (connect ongoing)") ));
+return;
+}
+if( iServer.IsSettingQueryOngoing() )
+{
+// V, Q or E command is not ongoing, handle AT_MODEM_SIGNAL_IND always.
+OstTrace0( TRACE_NORMAL, DUP14_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled (Q, V or E query ongoing)" );
+C_TRACE(( _T("AT_MODEM_SIGNAL_IND not handled (Q, V or E query ongoing)") ));
+return;
+}
+if( !iServer.IsEchoNotified( echoValue ) )
+{
+OstTrace0( TRACE_NORMAL, DUP15_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - Handling AT_MODEM_SIGNAL_IND (new echo value received, more than 1 session open)" );
+C_TRACE(( _T("Handling AT_MODEM_SIGNAL_IND (new echo value received, more than 1 session open)") ));
+iServer.HandleSignalInd( dteId, KErrNone );
+return;
+}
+OstTrace1( TRACE_NORMAL, DUP16_CMODEMATHANDLER_HANDLESIGNALIND, "CModemAtHandler::HandleSignalInd - AT_MODEM_SIGNAL_IND not handled.;sessionCount=%d", sessionCount );
+C_TRACE(( _L("AT_MODEM_SIGNAL_IND not handled. sessionCount: %d"),  sessionCount ));
+}
+// no else
 }
 void CModemAtHandler::HandleUnsolicitedData( const TIsiReceiveC& aMessage )
 {
-C_TRACE (( _T("CModemAtHandler::HandleUnsolicitedData()") ));
+TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE+AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_DTEID );
-TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE+ AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_LENGTH );
 TInt length = aMessage.Get16bit( ISI_HEADER_SIZE+AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_LENGTH );
+OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_HANDLEUNSOLICITEDDATA, "CModemAtHandler::HandleUnsolicitedData;dteId=%d;iDteId=%d", dteId, iDteId );
-iServer.HandleUnsolicitedData( dteId,
+C_TRACE (( _T("CModemAtHandler::HandleUnsolicitedData() %d %d"), dteId, iDteId ));
-aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_UNSOLICITEDDATABUFFER,
+if( iDteId == dteId ||
-length ) );
+KReservedDteId == dteId )
+{
+iServer.HandleUnsolicitedData( dteId,
+aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_UNSOLICITED_DATA_IND_OFFSET_UNSOLICITEDDATABUFFER,
+length ) );
+}
+// no else
 }
 void CModemAtHandler::HandleIntermediateDataInd( const TIsiReceiveC& aMessage )
 {
-C_TRACE (( _T("CModemAtHandler::HandleIntermediateDataInd()") ));
 TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_DTEID );
 TInt length = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_LENGTH );
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd;iDteId=%d", iDteId );
-TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_TID );
+C_TRACE (( _T("CModemAtHandler::HandleIntermediateDataInd() %d"), iDteId ));
-C_TRACE((_L("transactionId from %d"), transactionId));
+if( iDteId == dteId )
-transactionId = iLastTransactionId;
+{
-C_TRACE((_L("transactionId after setting it to iLastTransactionId: %d"), transactionId));
+TUint transactionId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_CMD_RESP_OFFSET_TID );
-TUint8 command = transactionId & KCommandBits; //normal AT-cmd or Nvram-query
+OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd - transactionId from;transactionId=%d", transactionId );
-TUint8 pluginType = transactionId >> KTransactionIdBitsShift;
+C_TRACE((_L("transactionId from %d"), transactionId));
-C_TRACE((_L("dteId %d, command %d (AT=0,NVRAM=1), pluginType = %d (atext=0,common=1)"), dteId, command, pluginType));
+transactionId = iLastTransactionId;
+OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd - transactionId after setting it to iLastTransactionId:;transactionId=%d", transactionId );
-iServer.HandleIntermediateDataInd( dteId,
+C_TRACE((_L("transactionId after setting it to iLastTransactionId: %d"), transactionId));
-(TATPluginInterface) pluginType,
-aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_INTERMEDIATEDATABUFFER,
+TUint8 command = transactionId & KCommandBits; //normal AT-cmd or Nvram-query
-length),
+TUint8 pluginType = transactionId >> KTransactionIdBitsShift;
-command );
+OstTraceExt4( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLEINTERMEDIATEDATAIND, "CModemAtHandler::HandleIntermediateDataInd;dteId=%d;command=%d;(AT=0,NVRAM=1);pluginType=%d;(atext=0,common=1);iDteId=%d", dteId, command, pluginType, iDteId );
+C_TRACE((_L("dteId %d, command %d (AT=0,NVRAM=1), pluginType = %d (atext=0,common=1)"), dteId, command, pluginType));
+iServer.HandleIntermediateDataInd( dteId,
+(TATPluginInterface) pluginType,
+aMessage.GetData( ISI_HEADER_SIZE + AT_MODEM_INTERMEDIATE_DATA_IND_OFFSET_INTERMEDIATEDATABUFFER,
+length),
+command );
+}
 }
 void CModemAtHandler::HandleRedirectInd( const TIsiReceiveC& aMessage )
 {
-C_TRACE (( _T("CModemAtHandler::HandleRedirectInd()") ));
 TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_DTEID );
-TInt newSecondDevId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_DEVICEID );
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEREDIRECTIND, "CModemAtHandler::HandleRedirectInd;iChannel=%d", iChannel );
-TInt newSecondObjId = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_SERVERID );
+C_TRACE (( _T("CModemAtHandler::HandleRedirectInd() %d %d"), iDteId, iChannel ));
-#ifndef NCP_COMMON_BRIDGE_FAMILY
+if( iDteId == dteId )
-iPipeController->RedirectPipe( dteId, newSecondDevId, newSecondObjId );
+{
-#endif
+TInt newSecondDevId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_DEVICEID );
-}
+TInt newSecondObjId = aMessage.Get16bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_IND_OFFSET_SERVERID );
+iPipeController->RedirectPipe( newSecondDevId, newSecondObjId );
-void CModemAtHandler::SendAtModemDataRedirectResultReq( const TUint8 aDteId, const TUint aResult )
+}
-{
+else
+{
+TRACE_ASSERT_ALWAYS;
+}
+}
+void CModemAtHandler::SendAtModemDataRedirectResultReq( const TUint aResult )
+{
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler::SendAtModemDataRedirectResultReq" );
 C_TRACE (( _T("CModemAtHandler::SendAtModemDataRedirectResultReq()") ));
 HBufC8* message = HBufC8::New( ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ );
-C_TRACE((_L("Sending AT_MODEM_DATA_REDIRECT_RESULT_REQ dteid %d result %d"), aDteId, aResult));
+OstTraceExt2( TRACE_NORMAL, DUP1_CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler::SendAtModemDataRedirectResultReq - Sending AT_MODEM_DATA_REDIRECT_RESULT_REQ;iDteId=%d;aResult=%d", (TUint)iDteId, aResult );
+C_TRACE((_L("Sending AT_MODEM_DATA_REDIRECT_RESULT_REQ dteid %d result %d"), iDteId, aResult));
 TPtr8 messageptr = message->Des();
 TIsiSend isimessage( messageptr, ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ );
 isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM);
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_TID, 0 );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_MESSAGEID,
 AT_MODEM_DATA_REDIRECT_RESULT_REQ );
-isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_DTEID ,aDteId );
+isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_DTEID ,iDteId );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_REQ_OFFSET_RESULT ,aResult );
 isimessage.Complete();
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler::SendAtModemDataRedirectResultReq - Created ISI-message" );
 C_TRACE(_L("Created ISI-message"));
 for( TInt i = 0 ; i < (ISI_HEADER_SIZE + SIZE_AT_MODEM_DATA_REDIRECT_RESULT_REQ); i++ )
 {
+OstTraceExt2( TRACE_NORMAL, DUP3_CMODEMATHANDLER_SENDATMODEMDATAREDIRECTRESULTREQ, "CModemAtHandler - ;i=%d;%x", (TUint)i, (TUint)((*message)[i]) );
 C_TRACE((_L("[%d] 0x%x"),i ,(*message)[i]) );
 }
 TInt err = iIscApi->Send( messageptr );
 TRACE_ASSERT( err == KErrNone );
 }
 void CModemAtHandler::HandleRedirectResultResp(const TIsiReceiveC& aMessage)
 {
-C_TRACE (( _T("CModemAtHandler::HandleRedirectResultResp()") ));
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp;iDteId=%d", iDteId );
+C_TRACE (( _T("CModemAtHandler::HandleRedirectResultResp() %d"), iDteId ));
 TUint8 dteId = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_DTEID );
 TInt error = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_DATA_REDIRECT_RESULT_RESP_OFFSET_RESULT );
+OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp;dteId=%d", dteId );
 C_TRACE((_L("CModemAtHandler::HandleRedirectResultResp() dte %d"), dteId));
 if( error == AT_MODEM_RESULT_ERROR )
 {
-C_TRACE(_L("CModemAtHandler::HandleRedirectResultResp() AT_MODEM_RESULT_ERROR received, redirect failed"));
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp - AT_MODEM_RESULT_ERROR -> COMMAND MODE" );
-TRACE_ASSERT_ALWAYS;
+C_TRACE(_L("AT_MODEM_RESULT_ERROR -> COMMAND MODE"));
+iServer.HandleCommandModeChange( dteId, ECommandMode );
 }
 else
 {
+OstTrace0( TRACE_NORMAL, DUP3_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp - redirect OK, enable pipe" );
 C_TRACE(_L("CModemAtHandler::HandleRedirectResultResp() redirect OK"));
-}
+TPipeInfo::EPipeState pipeState = iPipeController->GetPipeState();
+OstTrace1( TRACE_NORMAL, DUP4_CMODEMATHANDLER_HANDLEREDIRECTRESULTRESP, "CModemAtHandler::HandleRedirectResultResp;pipeState=%d", pipeState );
-}
+C_TRACE((_L("CModemAtHandler::HandleRedirectResultResp() pipe state %d"), pipeState));
+if( pipeState != TPipeInfo::EPipeDisabled )
+{
+iPipeController->SendEnablePipeReq();
+}
+}
+}
 void CModemAtHandler::HandleCommandModeChange( TCommandMode aMode )
 {
-C_TRACE(( _T("CModemAtHandler::HandleCommandModeChange() aMode: %d"), (TInt) aMode ));
+OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_HANDLECOMMANDMODECHANGE, "CModemAtHandler::HandleCommandModeChange;aMode=%d;iDteId=%d", (TUint)aMode, (TUint)iDteId );
-iServer.HandleCommandModeChange( aMode );
+C_TRACE(( _T("CModemAtHandler::HandleCommandModeChange() aMode: %d dteId: %d"), (TInt) aMode, iDteId ));
-}
+iServer.HandleCommandModeChange( iDteId, aMode );
+}
-TInt CModemAtHandler::SendEscapeSignalDetection( const TUint8 aDteId )
-{
+TInt CModemAtHandler::SendSignalDetection( const TUint8 aSignal )
-C_TRACE((_T("CModemAtHandler::SendEscapeSignalDetection(%d)"), aDteId));
+{
-#ifdef __WINSCW__
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SENDSIGNALDETECTION, "CModemAtHandler::SendSignalDetection;iDteId=%d", iDteId );
-iDteId = aDteId;
+C_TRACE((_T("CModemAtHandler::SendSignalDetection( dteId: %d, aSignal: 0x%x)"), iDteId, aSignal ));
-return KErrNone;
-#endif
 TInt error( KErrGeneral );
 TUint msgSize( ISI_HEADER_SIZE + SIZE_AT_MODEM_SIGNAL_DETECTED_REQ );
 TUint size( msgSize + SIZE_AT_MODEM_SB_SIGNAL_DETECTED );
 HBufC8* message = HBufC8::New( size );
 if( message )
 {
 TPtr8 messageptr = message->Des();
 TIsiSend isimessage( messageptr, size );
 isimessage.Set8bit( ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_TID, 0x00 );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_MESSAGEID,
 AT_MODEM_SIGNAL_DETECTED_REQ );
-isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_DTEID, aDteId );
+isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_DTEID, iDteId );
 isimessage.Set8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_REQ_OFFSET_NOOFSUBBLOCKS, 0x01 );
 isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKID,
 AT_MODEM_SB_SIGNAL_DETECTED );
 isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_SUBBLOCKLENGTH,
 SIZE_AT_MODEM_SB_SIGNAL_DETECTED );
 isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_TYPEOFSIGNALDETECTED,
-AT_MODEM_SIGNAL_ESCAPE_DETECTED );
+aSignal );
 isimessage.Set8bit( msgSize + AT_MODEM_SB_SIGNAL_DETECTED_OFFSET_FILLERBYTE1, 0x00 );
 isimessage.Complete();
 error = iIscApi->Send(messageptr);
-C_TRACE((_L("escape send result %d"), error ));
+TRACE_ASSERT( error == KErrNone );
 delete message;
 message = NULL;
 }
 else
 {
 ASSERT_ALWAYS;
 error = KErrNoMemory;
 }
 return error;
 }
 void CModemAtHandler::HandleSignalDetectedResp( const TIsiReceiveC& aMessage )
 {
-C_TRACE (( _T("CModemAtHandler::HandleSignalDetectedResp() escape sequence detect response received from cellmo") ));
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_HANDLESIGNALDETECTEDRESP, "CModemAtHandler::HandleSignalDetectedResp() - escape sequence detect response received from cellmo" );
+C_TRACE (( _T("CModemAtHandler::HandleSignalDetectedResp()") ));
 TUint8 dteId( aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_DTEID ) );
 TInt result = aMessage.Get8bit( ISI_HEADER_SIZE + AT_MODEM_SIGNAL_DETECTED_RESP_OFFSET_RESULT );
+OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_HANDLESIGNALDETECTEDRESP, "CModemAtHandler::HandleSignalDetectedResp;dteId=%d", dteId );
 C_TRACE((_L("CModemAtHandler::HandleSignalDetectedResp() dteId %d"), dteId));
 TRACE_ASSERT( result == AT_MODEM_RESULT_OK );
 }
 void CModemAtHandler::SetModemAtExistsInCmt( TBool aModemAtExistsInCmt )
 {
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SETMODEMATEXISTSINCMT, "CModemAtHandler::SetModemAtExistsInCmt;aModemAtExistsInCmt=%d", (TInt)aModemAtExistsInCmt );
 C_TRACE((_T("CModemAtHandler::SetModemAtExistsInCmt(%d)"), (TInt)aModemAtExistsInCmt));
 iModemAtExistInCmt = aModemAtExistsInCmt;
 }
-TInt CModemAtHandler::SendAtModemConnectReq( const TUint8 aDteId )
+TInt CModemAtHandler::SendAtModemConnectReq()
 {
-C_TRACE (( _T("CModemAtHandler::SendAtModemConnectReq()") ));
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_SENDATMODEMCONNECTREQ, "CModemAtHandler::SendAtModemConnectReq;iDteId=%d", iDteId );
+C_TRACE (( _T("CModemAtHandler::SendAtModemConnectReq() %d"), iDteId ));
 TInt size = ISI_HEADER_SIZE + SIZE_AT_MODEM_CONNECT_REQ;
 HBufC8* message = HBufC8::New( size );
 TRACE_ASSERT( message );
 TPtr8 messageptr = message->Des();
 TIsiSend isimessage( messageptr, size );
 isimessage.Set8bit(ISI_HEADER_OFFSET_RESOURCEID, PN_AT_MODEM);
 isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_TID, KDefaultTId);
 isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_MESSAGEID, AT_MODEM_CONNECT_REQ);
-isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_DTEID, aDteId);
+isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_DTEID, iDteId);
 isimessage.Set8bit(ISI_HEADER_SIZE + AT_MODEM_CONNECT_REQ_OFFSET_FILLERBYTE1, KFiller);
 isimessage.Complete();
+OstTraceExt1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_SENDATMODEMCONNECTREQ, "CModemAtHandler::SendAtModemConnectReq - message dump;messageptr=%s", messageptr );
 DUMP_MESSAGE( messageptr );
 TInt err = iIscApi->Send( messageptr );
 TRACE_ASSERT( err == KErrNone );
 delete message;
 message = NULL;
+OstTrace1( TRACE_NORMAL, DUP2_CMODEMATHANDLER_SENDATMODEMCONNECTREQ, "CModemAtHandler::SendAtModemConnectReq - return;err=%d", err );
 C_TRACE (( _T("CModemAtHandler::SendAtModemConnectReq()<< returned: %d"), err ));
 return err;
 }
+TBool CModemAtHandler::IsPipeInDataMode()
+{
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_ISPIPEINDATAMODE, "CModemAtHandler::IsPipeInDataMode;iDteId=%d", iDteId );
+C_TRACE(( _T("CModemAtHandler::IsPipeInDataMode() dteId: %d"), iDteId ));
+TPipeInfo::EPipeState pipeState( iPipeController->GetPipeState() );
+if( pipeState == TPipeInfo::EPipeEnabled ||
+pipeState == TPipeInfo::EPipeRedirected )
+{
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_ISPIPEINDATAMODE, "CModemAtHandler::IsPipeInDataMode - True" );
+C_TRACE(( _T("CModemAtHandler::IsPipeInDataMode() True") ));
+return ETrue;
+}
+else
+{
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_ISPIPEINDATAMODE, "CModemAtHandler::IsPipeInDataMode - False" );
+C_TRACE(( _T("CModemAtHandler::IsPipeInDataMode() False") ));
+return EFalse;
+}
+}
+void CModemAtHandler::SetTextMessageMode( TBool aTextMode )
+{
+OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_SETTEXTMESSAGEMODE, "CModemAtHandler::SetTextMessageMode(;aTextMode=%d;);iDteId=%d", (TUint)aTextMode, (TUint)iDteId );
+C_TRACE (( _T("CModemAtHandler::SetTextMessageMode( aTextMode: %d ) dte id: %d"), (TInt) aTextMode, iDteId ));
+iTextMessageMode = aTextMode;
+}
+TBool CModemAtHandler::IsTextMessageMode()
+{
+OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_ISTEXTMESSAGEMODE, "CModemAtHandler::IsTextMessageMode;iTextMessageMode=%d;iDteId=%d", (TUint)iTextMessageMode, (TUint)iDteId );
+C_TRACE (( _T("CModemAtHandler::IsTextMessageMode() iTextMessageMode: %d dte id: %d"), (TInt) iTextMessageMode, iDteId ));
+return iTextMessageMode;
+}
+void CModemAtHandler::PipeCreated( TUint8 aPipeHandle, TInt aError )
+{
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_PIPECREATED, "CModemAtHandler::PipeCreated;aPipeHandle=%d", aPipeHandle );
+C_TRACE(( _T("CModemAtHandler::PipeCreated() pipehandle: %d"), aPipeHandle ));
+iDteId = aPipeHandle;
+if( KErrNone == aError )
+{
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_PIPECREATED, "CModemAtHandler::PipeCreated - pipe created, let's connect to modem" );
+C_TRACE(( _T("CModemAtHandler::pipeCreated(): pipe created, let's connect to modem") ));
+SendAtModemConnectReq();
+}
+else
+{
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_PIPECREATED, "CModemAtHandler::PipeCreated - pipe creation has failed, connect is aborted" );
+C_TRACE(( _T("CModemAtHandler::pipeCreated(): pipe creation has failed, connect is aborted") ));
+iServer.SetDteIdAndConnect( KInvalidPipeHandle, aError );
+}
+}
+void CModemAtHandler::AddDevice( TUint8 aDevId, TUint8 aObjId )
+{
+	OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_ADDDEVICE, "CModemAtHandler::AddDevice;aDevId=%x;aObjId=%x", aDevId, aObjId );
+	C_TRACE(( _T("CModemAtHandler::AddDevice() aDevId: 0x%x, aObjId: 0x%x"), aDevId, aObjId ));
+iServer.AddDevice( aDevId, aObjId );
+}
+void CModemAtHandler::RemoveDevice( TUint8 aDevId, TUint8 aObjId )
+{
+OstTraceExt2( TRACE_NORMAL, CMODEMATHANDLER_REMOVEDEVICE, "CModemAtHandler::RemoveDevice;aDevId=%hhu;aObjId=%hhu", aDevId, aObjId );
+C_TRACE(( _T("CModemAtHandler::RemoveDevice() aDevId: 0x%x, aObjId: 0x%x"), aDevId, aObjId ));
+iServer.RemoveDevice( aDevId, aObjId );
+}
+void CModemAtHandler::GetDataportObjectId( TUint& aObjId )
+{
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_GETDATAPORTOBJECTID, "CModemAtHandler::GetDataportObjectId" );
+C_TRACE(( _T("CModemAtHandler::GetDataportObjectId()") ));
+aObjId = iDataportObjId;
+}
+void CModemAtHandler::GetSecondaryDataportObjectId( TUint& aObjId )
+{
+OstTrace0( TRACE_NORMAL, CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId" );
+C_TRACE(( _T("CModemAtHandler::GetScondaryDataportObjectId()") ));
+TBuf8<KObjectIdLength> dpObjId;
+if( iIscApi )
+{
+OstTrace0( TRACE_NORMAL, DUP1_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId - call GetChannelInfo(EIscNokiaDataport4) " );
+C_TRACE(( _T("GetChannelInfo() EIscNokiaDataport4") ));
+iIscApi->GetChannelInfo( EIscNokiaDataport4, dpObjId );
+OstTrace0( TRACE_NORMAL, DUP2_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId - GetChannelInfo() done" );
+C_TRACE(( _T("GetChannelInfo() done") ));
+aObjId = (((TUint16)(dpObjId[0])) << KEightBits) + dpObjId[1];
+OstTrace1( TRACE_NORMAL, DUP3_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId;aObjId=%d", aObjId );
+C_TRACE((_L("DataportObjId 0x%x"), aObjId ));
+}
+else
+{
+OstTrace0( TRACE_NORMAL, DUP4_CMODEMATHANDLER_GETSECONDARYDATAPORTOBJECTID, "CModemAtHandler::GetSecondaryDataportObjectId - No IscApi found, using default dataport object id" );
+C_TRACE(( _T("No IscApi found, using default dataport object id") ));
+}
+}
+TInt CModemAtHandler::GetChannelId()
+{
+OstTrace1( TRACE_NORMAL, DUP1_CMODEMATHANDLER_GETCHANNELID, "CModemAtHandler::GetChannelId;iChannel=%x", iChannel );
+OstTrace1( TRACE_NORMAL, CMODEMATHANDLER_GETCHANNELID, "CModemAtHandler::GetChannelId;this=%x", this );
+C_TRACE(( _T("CModemAtHandler::GetChannelId() handler: 0x%x, channel id: 0x%x"), this, iChannel ));
+return iChannel;
+}

changeset 9	8486d82aef45
parent 8	6295dc2169f3