| author | mikaruus |
| Tue, 19 Oct 2010 13:16:20 +0300 | |
| changeset 9 | 8486d82aef45 |
| parent 8 | 6295dc2169f3 |
| permissions | -rw-r--r-- |
| 0 | 1 |
/* |
2 |
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 |
* All rights reserved. |
|
4 |
* This component and the accompanying materials are made available |
|
5 |
* under the terms of the License "Eclipse Public License v1.0" |
|
6 |
* which accompanies this distribution, and is available |
|
7 |
* at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 |
* |
|
9 |
* Initial Contributors: |
|
10 |
* Nokia Corporation - initial contribution. |
|
11 |
* |
|
12 |
* Contributors: |
|
13 |
* |
|
14 |
* Description: |
|
15 |
* |
|
16 |
*/ |
|
17 |
||
| 9 | 18 |
#include <pn_const.h> |
19 |
#include <iscnokiadefinitions.h> |
|
| 0 | 20 |
#include "cmodematsrv.h" |
21 |
#include "modematclientsrv.h" |
|
22 |
#include "modematsecpolicy.h" |
|
23 |
#include "cmodematsession.h" |
|
24 |
#include "cmodemathandler.h" |
|
25 |
#include "modemattrace.h" |
|
26 |
#include "catmessage.h" |
|
| 9 | 27 |
#include "cmodematpipecontroller.h" |
28 |
#include "OstTraceDefinitions.h" |
|
29 |
#ifdef OST_TRACE_COMPILER_IN_USE |
|
30 |
#include "cmodematsrvTraces.h" |
|
31 |
#endif |
|
| 0 | 32 |
|
| 9 | 33 |
_LIT8( KCursor, ">" ); |
34 |
_LIT8( KOkResponse, "OK" ); |
|
35 |
_LIT8( KErrorResponse, "ERROR" ); |
|
36 |
_LIT8( KOkResponseNoVerbose, "0" ); |
|
37 |
_LIT8( KErrorResponseNoVerbose, "4" ); |
|
38 |
||
39 |
_LIT8( KAtv, "ATV" ); |
|
40 |
_LIT8( KAtv1, "ATV1" ); |
|
41 |
_LIT8( KAtv0, "ATV0" ); |
|
42 |
_LIT8( KAtq, "ATQ" ); |
|
43 |
_LIT8( KAtq1, "ATQ1" ); |
|
44 |
_LIT8( KAtq0, "ATQ0" ); |
|
45 |
_LIT8( KAte, "ATE" ); |
|
46 |
_LIT8( KAte1, "ATE1" ); |
|
47 |
_LIT8( KAte0, "ATE0" ); |
|
48 |
||
49 |
_LIT8( KCmgs, "+CMGS" ); |
|
50 |
_LIT8( KCmgc, "+CMGC" ); |
|
51 |
_LIT8( KCmgsQuery, "+CMGS=?" ); |
|
52 |
_LIT8( KCmgcQuery, "+CMGC=?" ); |
|
53 |
||
54 |
// Carriage return needs to be checked from ATS3, or the following AT&V |
|
55 |
// fails, because its not yet informed to upper layers. |
|
56 |
_LIT8( KAts3, "ATS3=" ); |
|
57 |
const TUint8 KDefaultCarriageChar( 0xd ); // 13 |
|
58 |
||
59 |
const TUint8 KOff( 0x00 ); |
|
60 |
const TUint8 KOn( 0x01 ); |
|
61 |
||
62 |
const TInt KEchoOn( 1 ); |
|
63 |
const TInt KEchoOff( 2 ); |
|
64 |
const TInt KVerboseOn( 3 ); |
|
65 |
const TInt KVerboseOff( 4 ); |
|
66 |
const TInt KQuietOn( 5 ); |
|
67 |
const TInt KQuietOff( 6 ); |
|
68 |
const TInt KReplyTypeEditorStart( 1 ); |
|
69 |
const TInt KReplyTypeEditorEnd( 2 ); |
|
| 0 | 70 |
|
71 |
CModemAtSrv::CModemAtSrv( TInt aPriority ) : |
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
72 |
CPolicyServer( aPriority, KSrvPolicy ), |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
73 |
iHandler(NULL), |
| 9 | 74 |
iEcho( KOn ), |
75 |
iEchoNotified( KInitialValue ), |
|
76 |
iEchoQueryIsOngoing( EFalse ), |
|
77 |
iVerbose( KOff ), |
|
78 |
iVerboseNotified( KInitialValue ), |
|
79 |
iVerboseQueryIsOngoing( EFalse ), |
|
80 |
iQuiet( KOff ), |
|
81 |
iQuietNotified( KInitialValue ), |
|
82 |
iQuietQueryIsOngoing( EFalse ), |
|
83 |
iCarriageReturn( KDefaultCarriageChar ), |
|
84 |
iCarriageReturnFound( EFalse ) |
|
| 0 | 85 |
{
|
| 9 | 86 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_CMODEMATSRV, "CModemAtSrv::CModemAtSrv" ); |
| 0 | 87 |
} |
88 |
||
89 |
CModemAtSrv::~CModemAtSrv() |
|
90 |
{
|
|
| 9 | 91 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_CMODEMATSRV, "CModemAtSrv::~CModemAtSrv" ); |
| 0 | 92 |
C_TRACE (( _L(">>CModemAtSrv::~CModemAtSrv()") ));
|
93 |
iAtMessageArray.ResetAndDestroy(); |
|
94 |
iAtMessageArray.Close(); |
|
95 |
C_TRACE (( _L("<<CModemAtSrv::~CModemAtSrv()") ));
|
|
96 |
} |
|
97 |
||
98 |
CModemAtSrv* CModemAtSrv::NewLC() |
|
99 |
{
|
|
| 9 | 100 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_NEWLC, "CModemAtSrv::NewLC" ); |
| 0 | 101 |
CModemAtSrv* self = new (ELeave) CModemAtSrv( EPriorityNormal ); |
102 |
CleanupStack::PushL( self ); |
|
103 |
self->ConstructL(); |
|
104 |
self->StartL( KATExtSrvName ); |
|
105 |
RThread().SetPriority( EPriorityNormal ); |
|
106 |
return self; |
|
107 |
} |
|
108 |
||
| 9 | 109 |
void CModemAtSrv::RemovePipe( CModemAtHandler* aHandler ) |
| 0 | 110 |
{
|
| 9 | 111 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_REMOVEPIPE, "CModemAtSrv::RemovePipe" ); |
| 0 | 112 |
C_TRACE((_L("CModemAtSrv::RemovePipe()") ));
|
| 9 | 113 |
ASSERT_PANIC_ALWAYS( NULL != aHandler ); |
114 |
aHandler->RemovePipe(); |
|
| 0 | 115 |
} |
116 |
||
117 |
void CModemAtSrv::ClientClosed( CModemAtSession* aSession ) |
|
118 |
{
|
|
| 9 | 119 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_CLIENTCLOSED, "CModemAtSrv::ClientClosed" ); |
120 |
C_TRACE (( _L(">>CModemAtSrv::ClientClosed()") ));
|
|
| 0 | 121 |
TInt index = iSessions.Find( aSession ); |
122 |
if( index >= 0 ) |
|
123 |
{
|
|
| 9 | 124 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSRV_CLIENTCLOSED, "CModemAtSrv::ClientClosed - Removing session;iSessions[index]->GetPluginType()=%d", iSessions[index]->GetPluginType() ); |
125 |
C_TRACE((_L("Removing session (plugin type %d)"), iSessions[index]->GetPluginType() ));
|
|
126 |
iSessions.Remove( index ); |
|
127 |
||
128 |
if( ECommonPlugin == aSession->GetPluginType() ) |
|
| 0 | 129 |
{
|
| 9 | 130 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_CLIENTCLOSED, "CModemAtSrv::ClientClosed - Disconnecting ISI message handler" ); |
| 0 | 131 |
C_TRACE((_L("Disconnecting ISI message handler ") ));
|
| 9 | 132 |
aSession->GetHandler()->Disconnect(); |
| 0 | 133 |
} |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
134 |
|
| 9 | 135 |
for( int i = 0; i < iDteInfo.Count(); i++ ) |
136 |
{
|
|
137 |
if( aSession == iDteInfo[i].iSession ) |
|
138 |
{
|
|
139 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSRV_CLIENTCLOSED, "CModemAtSrv::ClientClosed - removing dte info" ); |
|
140 |
C_TRACE((_T("CModemAtSrv::ClientClosed() removing dte info") ));
|
|
141 |
iDteInfo.Remove( i ); |
|
142 |
} |
|
143 |
} |
|
144 |
||
145 |
TBool pluginsFound( EFalse ); |
|
146 |
for( int i = 0; i < iSessions.Count(); i++ ) |
|
147 |
{
|
|
148 |
if( 0 == iSessions[i]->GetName().Compare( aSession->GetName() ) ) |
|
149 |
{
|
|
150 |
pluginsFound = ETrue; |
|
151 |
break; |
|
152 |
} |
|
153 |
} |
|
154 |
||
155 |
if( !pluginsFound && |
|
156 |
iHandler != aSession->GetHandler() ) |
|
157 |
{
|
|
158 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSRV_CLIENTCLOSED, "CModemAtSrv::ClientClosed - Deleting handler" ); |
|
159 |
C_TRACE((_L("Deleting handler") ));
|
|
160 |
iFreeChannels.Append( aSession->GetHandler()->GetChannelId() ); |
|
161 |
delete aSession->GetHandler(); |
|
162 |
} |
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
163 |
|
| 0 | 164 |
C_TRACE((_T("<<CModemAtSrv::ClientClosed()") ));
|
165 |
} |
|
166 |
} |
|
167 |
||
168 |
CSession2* CModemAtSrv::NewSessionL( const TVersion& aVersion, |
|
169 |
const RMessage2& /*aMessage*/ ) const |
|
170 |
{
|
|
| 9 | 171 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_NEWSESSIONL, "CModemAtSrv::NewSessionL" ); |
| 0 | 172 |
C_TRACE (( _T("CModemAtSrv::NewSessionL()") ));
|
173 |
CModemAtSrv& thisServer = const_cast<CModemAtSrv&>( *this ); |
|
174 |
CModemAtSession* session = CModemAtSession::NewL( thisServer, aVersion ); |
|
175 |
CleanupStack::PushL( session ); |
|
176 |
thisServer.iSessions.AppendL( session ); |
|
177 |
CleanupStack::Pop( session ); |
|
178 |
return session; |
|
179 |
} |
|
180 |
||
181 |
void CModemAtSrv::ConstructL() |
|
182 |
{
|
|
| 9 | 183 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_CONSTRUCTL, "CModemAtSrv::ConstructL" ); |
| 0 | 184 |
C_TRACE (( _T("CModemAtSrv::ConstructL()") ));
|
| 9 | 185 |
iHandler = CModemAtHandler::NewL( *this, EIscNokiaAtController ); |
| 0 | 186 |
|
| 9 | 187 |
iFreeChannels.Append( EIscNokiaAtController2 ); |
188 |
iFreeChannels.Append( EIscNokiaAtController3 ); |
|
189 |
} |
|
190 |
||
191 |
void CModemAtSrv::HandleSignalInd( const TUint8 aDteId, const TInt aCompleteCode ) |
|
| 0 | 192 |
{
|
| 9 | 193 |
C_TRACE((_T("CModemAtSrv::HandleSignalInd aDteId = %d sessions = %d, code = %d"), aDteId, iSessions.Count(), aCompleteCode ));
|
| 0 | 194 |
for( TInt i = 0; i < iSessions.Count(); i++ ) |
195 |
{
|
|
| 9 | 196 |
if( iSessions[i]->GetDteId() == aDteId && iSessions[i]->IsSignalIndReqActive() ) |
| 0 | 197 |
{
|
198 |
C_TRACE (( _T("CModemAtSrv::HandleSignalInd() session found") ));
|
|
| 9 | 199 |
iSessions[i]->SignalIndReceived( aCompleteCode ); |
| 0 | 200 |
} |
201 |
} |
|
202 |
} |
|
203 |
||
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
204 |
void CModemAtSrv::HandleUnsolicitedData( const TUint8 aDteId, const TDesC8& aData ) |
| 0 | 205 |
{
|
| 9 | 206 |
OstTraceExt2( TRACE_NORMAL, CMODEMATSRV_HANDLEUNSOLICITEDDATA, "CModemAtSrv::HandleUnsolicitedData;aDteId=%d;iSessions.Count()=%d", aDteId, iSessions.Count() ); |
| 0 | 207 |
C_TRACE ((_T("CModemAtSrv::HandleUnsolicitedData aDteId = %d sessions = %d"), aDteId, iSessions.Count() ));
|
| 9 | 208 |
TBool unsolicitedDataHandled( EFalse ); |
209 |
||
210 |
_LIT8( KNoCarrier, "NO CARRIER" ); |
|
211 |
if( aData.Find( KNoCarrier ) != KErrNotFound ) |
|
212 |
{
|
|
213 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_HANDLEUNSOLICITEDDATA, "CModemAtSrv::HandleUnsolicitedData - NO CARRIER -> COMMAND MODE" ); |
|
214 |
C_TRACE(_L("NO CARRIER -> COMMAND MODE"));
|
|
215 |
HandleCommandModeChange( aDteId, ECommandMode ); |
|
216 |
} |
|
217 |
||
| 0 | 218 |
for( TInt i = 0; i < iSessions.Count(); i++ ) |
219 |
{
|
|
| 9 | 220 |
if( ( iSessions[i]->GetDteId() == aDteId || aDteId == KUnsolicitedDataDteId )&& |
| 0 | 221 |
iSessions[i]->IsUnsolicitedDataReqActive() && |
222 |
iSessions[i]->GetPluginType() == EATExtPlugin ) |
|
223 |
{
|
|
| 9 | 224 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_HANDLEUNSOLICITEDDATA, "CModemAtSrv::HandleUnsolicitedData - session found" ); |
| 0 | 225 |
C_TRACE (( _T("CModemAtSrv::HandleUnsolicitedData() session found") ));
|
226 |
iSessions[i]->UnsolicitedData( aData ); |
|
| 9 | 227 |
unsolicitedDataHandled = ETrue; |
228 |
return; |
|
| 0 | 229 |
} |
230 |
} |
|
| 9 | 231 |
if( ! unsolicitedDataHandled ) |
232 |
{
|
|
233 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSRV_HANDLEUNSOLICITEDDATA, "CModemAtSrv::HandleUnsolicitedData - request is not active yet so save message to the server" ); |
|
234 |
C_TRACE (( _T("CModemAtSrv::HandleSignalInd() request is not active yet so save message to the server") ));
|
|
235 |
||
236 |
// Note: If call is received with unsolicited "RING", it will not be sent, because request is not active in data mode. |
|
237 |
// After that "NO CARRIER" will copy over the "RING", and it will be sent, when returning to command mode. |
|
238 |
iTemporaryUnsolicitedData = aData; |
|
239 |
} |
|
| 0 | 240 |
} |
241 |
||
| 9 | 242 |
TBool CModemAtSrv::IsUnsolicitedDataInBuffer() |
243 |
{
|
|
244 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_ISUNSOLICITEDDATAINBUFFER, "CModemAtSrv::IsUnsolicitedDataInBuffer;%d", (TInt) iTemporaryUnsolicitedData.Length() ); |
|
245 |
C_TRACE ((_T("CModemAtSrv::IsUnsolicitedDataInBuffer %d"), (TInt) iTemporaryUnsolicitedData.Length() ));
|
|
246 |
if( iTemporaryUnsolicitedData.Length() > 0) |
|
247 |
{
|
|
248 |
return ETrue; |
|
249 |
} |
|
250 |
else |
|
251 |
{
|
|
252 |
return EFalse; |
|
253 |
} |
|
254 |
} |
|
255 |
||
256 |
void CModemAtSrv::ResetUnsolicitedDataInBuffer() |
|
| 0 | 257 |
{
|
| 9 | 258 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_RESETUNSOLICITEDDATAINBUFFER, "CModemAtSrv::ResetUnsolicitedDataInBuffer" ); |
259 |
C_TRACE (( _T("CModemAtSrv::ResetUnsolicitedDataInBuffer()") ));
|
|
260 |
iTemporaryUnsolicitedData.Zero(); |
|
261 |
} |
|
262 |
||
263 |
void CModemAtSrv::GetUnsolicitedDataInBuffer( TDes8& aData ) |
|
264 |
{
|
|
265 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_GETUNSOLICITEDDATAINBUFFER, "CModemAtSrv::GetUnsolicitedDataInBuffer" ); |
|
266 |
C_TRACE (( _T("CModemAtSrv::GetUnsolicitedDataInBuffer()") ));
|
|
267 |
aData.Copy( iTemporaryUnsolicitedData ); |
|
268 |
} |
|
269 |
||
270 |
||
271 |
void CModemAtSrv::HandleCommandModeChange( TUint8 aDteId, TCommandMode aMode ) |
|
272 |
{
|
|
273 |
OstTraceExt2( TRACE_NORMAL, CMODEMATSRV_HANDLECOMMANDMODECHANGE, "CModemAtSrv::HandleCommandModeChange;iSessions.Count()=%d;aMode=%d", iSessions.Count(), (TInt)aMode ); |
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
274 |
C_TRACE ((_T("CModemAtSrv::HandleCommandModeChange sessions = %d mode = %d"), iSessions.Count(), (TInt) aMode ));
|
| 0 | 275 |
for( TInt i = 0; i < iSessions.Count(); i++ ) |
276 |
{
|
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
277 |
if( iSessions[i]->IsCommandModeReqActive() && |
| 9 | 278 |
ECommonPlugin == iSessions[i]->GetPluginType() && |
279 |
aDteId == iSessions[i]->GetDteId() ) |
|
| 0 | 280 |
{
|
| 9 | 281 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_HANDLECOMMANDMODECHANGE, "CModemAtSrv::HandleCommandModeChange - session found" ); |
| 0 | 282 |
C_TRACE (( _T("CModemAtSrv::HandleCommandModeChange() session found") ));
|
283 |
iSessions[i]->CommandModeChanged( aMode ); |
|
284 |
} |
|
285 |
} |
|
286 |
} |
|
287 |
||
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
288 |
void CModemAtSrv::HandleIntermediateDataInd( const TUint8 aDteId, |
| 0 | 289 |
const TATPluginInterface aPluginType, |
290 |
const TDesC8& aResponse, |
|
291 |
const TUint8 aCommand ) |
|
292 |
{
|
|
| 9 | 293 |
OstTraceExt2( TRACE_NORMAL, CMODEMATSRV_HANDLEINTERMEDIATEDATAIND, "CModemAtSrv::HandleIntermediateDataInd;aDteId=%d;iSessions.Count()=%d", aDteId, iSessions.Count() ); |
| 0 | 294 |
C_TRACE ((_T("CModemAtSrv::HandleIntermediateDataInd aDteId = %d sessions = %d "), aDteId, iSessions.Count() ));
|
295 |
C_TRACE ((_T("plugintype = %d command = %d"), (TInt)aPluginType, aCommand ));
|
|
296 |
||
297 |
if ( iAtMessageArray.Count() > 0 ) |
|
298 |
{
|
|
| 9 | 299 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_HANDLEINTERMEDIATEDATAIND, "CModemAtSrv::HandleIntermediateDataInd - iAtMessageArray[0]->ReceiveATResponse Intermediate data" ); |
| 0 | 300 |
C_TRACE((_L("iAtMessageArray[0]->ReceiveATResponse Intermediate data")));
|
| 9 | 301 |
iAtMessageArray[0]->ReceiveATResponse( aResponse, EFalse, KErrNone ); |
| 0 | 302 |
} |
303 |
else |
|
304 |
{
|
|
| 9 | 305 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_HANDLEINTERMEDIATEDATAIND, "CModemAtSrv::HandleIntermediateDataInd - INTERMEDIATE DATA received but no request active" ); |
| 0 | 306 |
C_TRACE ((_T("CModemAtSrv::HandleIntermediateDataInd INTERMEDIATE DATA received but no request active") ));
|
| 9 | 307 |
HandleUnsolicitedData( aDteId, aResponse); |
| 0 | 308 |
} |
309 |
} |
|
310 |
||
| 9 | 311 |
void CModemAtSrv::HandleATResponse( |
312 |
const TUint8 aDteId, |
|
313 |
CModemAtHandler* aHandler, |
|
314 |
const TDesC8& aResponse, |
|
315 |
const TUint8 aCommand ) |
|
| 0 | 316 |
{
|
| 9 | 317 |
OstTraceExt2( TRACE_NORMAL, CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse;aDteId=%d;iSessions.Count()=%d", aDteId, iSessions.Count() ); |
| 0 | 318 |
C_TRACE ((_T(">>CModemAtSrv::HandleATResponse aDteId = %d sessions = %d "), aDteId, iSessions.Count() ));
|
319 |
C_TRACE ((_T("CModemAtSrv::HandleATResponse command = %d"), aCommand ));
|
|
| 9 | 320 |
TRACE_ASSERT( NULL != aHandler ) |
321 |
TInt completeCode( KErrNone ); |
|
322 |
if( IsTextMessageMode( aHandler ) ) |
|
323 |
{
|
|
324 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Text message mode is on" ); |
|
325 |
C_TRACE(_L("Text message mode is on"));
|
|
326 |
if( aResponse.Find( KCursor ) != KErrNotFound ) |
|
327 |
{
|
|
328 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - detected during text message mode" ); |
|
329 |
C_TRACE(_L("> detected during text message mode"));
|
|
330 |
completeCode = KReplyTypeEditorStart; // replace later with EReplyTypeEditorStart |
|
331 |
} |
|
332 |
else if( aResponse.Find( KOkResponse ) != KErrNotFound || |
|
333 |
aResponse.Find( KErrorResponse ) != KErrNotFound || |
|
334 |
aResponse.Find( KOkResponseNoVerbose ) != KErrNotFound || |
|
335 |
aResponse.Find( KErrorResponseNoVerbose ) != KErrNotFound ) |
|
336 |
{
|
|
337 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Response detected after text message mode" ); |
|
338 |
C_TRACE(_L("Response detected after text message mode"));
|
|
339 |
aHandler->SetTextMessageMode( EFalse ); |
|
340 |
completeCode = KReplyTypeEditorEnd; // replace later with EReplyTypeEditorEnd |
|
341 |
} |
|
342 |
if( completeCode == KErrNone ) |
|
343 |
{
|
|
344 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Response detected after text message mode (quiet mode)" ); |
|
345 |
C_TRACE(_L("Response detected after text message mode (quiet mode)"));
|
|
346 |
aHandler->SetTextMessageMode( EFalse ); |
|
347 |
completeCode = KReplyTypeEditorEnd; |
|
348 |
} |
|
349 |
} |
|
350 |
||
351 |
if( iEchoQueryIsOngoing ) |
|
352 |
{
|
|
353 |
OstTraceExt2( TRACE_NORMAL, DUP5_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Echo query ongoing.;iEcho=%d;iEchoNitified=%d", iEcho, iEchoNotified ); |
|
354 |
C_TRACE((_L("Echo query ongoing. current: %d, notified %d"), iEcho, iEchoNotified ));
|
|
355 |
if( iEcho == KOff && iEchoNotified != KOff ) |
|
356 |
{
|
|
357 |
OstTrace0( TRACE_NORMAL, DUP7_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Echo off, notify common plug-in." ); |
|
358 |
C_TRACE(_L("Echo off, notify common plug-in."));
|
|
359 |
HandleSignalInd( aDteId, KEchoOff ); |
|
360 |
iEchoNotified = KOff; |
|
361 |
} |
|
362 |
else if( iEcho == KOn && iEchoNotified != KOn ) |
|
363 |
{
|
|
364 |
OstTrace0( TRACE_NORMAL, DUP8_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Echo on, notify common plug-in." ); |
|
365 |
C_TRACE(_L("Echo on, notify common plug-in."));
|
|
366 |
HandleSignalInd( aDteId, KEchoOn ); |
|
367 |
iEchoNotified = KOn; |
|
368 |
} |
|
369 |
iEchoQueryIsOngoing = EFalse; |
|
370 |
} |
|
371 |
else if( iVerboseQueryIsOngoing ) |
|
372 |
{
|
|
373 |
OstTraceExt2( TRACE_NORMAL, DUP9_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Verbose query ongoing.;iVerbose=%d;iVerboseNotified=%d", iVerbose, iVerboseNotified ); |
|
374 |
C_TRACE((_L("Verbose query ongoing. current: %d, notified %d"), iVerbose, iVerboseNotified ));
|
|
375 |
if( iVerbose == KOff && iVerboseNotified != KOff ) |
|
376 |
{
|
|
377 |
OstTrace0( TRACE_NORMAL, DUP10_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Verbose off received, notify common plug-in." ); |
|
378 |
C_TRACE(_L("Verbose off received, notify common plug-in."));
|
|
379 |
HandleSignalInd( aDteId, KVerboseOff ); |
|
380 |
iVerboseNotified = KOff; |
|
381 |
} |
|
382 |
else if( iVerbose == KOn && iVerboseNotified != KOn ) |
|
383 |
{
|
|
384 |
OstTrace0( TRACE_NORMAL, DUP11_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Verbose on received, notify common plug-in." ); |
|
385 |
C_TRACE(_L("Verbose on received, notify common plug-in."));
|
|
386 |
HandleSignalInd( aDteId, KVerboseOn ); |
|
387 |
iVerboseNotified = KOn; |
|
388 |
} |
|
389 |
iVerboseQueryIsOngoing = EFalse; |
|
390 |
} |
|
391 |
else if( iQuietQueryIsOngoing ) |
|
392 |
{
|
|
393 |
OstTraceExt2( TRACE_NORMAL, DUP12_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Quiet query ongoing.;iQuiet=%d;iQuietNotified=%d", iQuiet, iQuietNotified ); |
|
394 |
C_TRACE((_L("Quiet query ongoing. current: %d, notified %d"), iQuiet, iQuietNotified ));
|
|
395 |
if( iQuiet == KOff && iQuietNotified != KOff ) |
|
396 |
{
|
|
397 |
OstTrace0( TRACE_NORMAL, DUP13_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Quiet off, notify common plug-in." ); |
|
398 |
C_TRACE(_L("Quiet off, notify common plug-in."));
|
|
399 |
HandleSignalInd( aDteId, KQuietOff ); |
|
400 |
iQuietNotified = KOff; |
|
401 |
} |
|
402 |
else if( iQuiet == KOn && iQuietNotified != KOn ) |
|
403 |
{
|
|
404 |
OstTrace0( TRACE_NORMAL, DUP14_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Quiet on, notify common plug-in." ); |
|
405 |
C_TRACE(_L("Quiet on, notify common plug-in."));
|
|
406 |
HandleSignalInd( aDteId, KQuietOn ); |
|
407 |
iQuietNotified = KOn; |
|
408 |
} |
|
409 |
iQuietQueryIsOngoing = EFalse; |
|
410 |
} |
|
411 |
||
| 0 | 412 |
if ( iAtMessageArray.Count() > 0 ) |
413 |
{
|
|
414 |
CAtMessage* tmp = iAtMessageArray[0]; |
|
| 9 | 415 |
OstTrace1( TRACE_NORMAL, DUP15_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - iAtMessageArray[0]->ReceiveATResponse;tmp=%x", tmp ); |
| 0 | 416 |
C_TRACE((_L("iAtMessageArray[0]->ReceiveATResponse 0x%x"), tmp ));
|
| 9 | 417 |
tmp->ReceiveATResponse( aResponse, ETrue, completeCode ); |
418 |
OstTrace0( TRACE_NORMAL, DUP16_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - Remove the first message in Fifo" ); |
|
| 0 | 419 |
C_TRACE((_L("CModemAtSrv::HandleATResponse Remove the first message in Fifo")));
|
420 |
RemoveFirstFromSendFifo(); |
|
| 9 | 421 |
OstTrace0( TRACE_NORMAL, DUP17_CMODEMATSRV_HANDLEATRESPONSE, "CModemAtSrv::HandleATResponse - SendNextFromFifo" ); |
| 0 | 422 |
C_TRACE((_L("CModemAtSrv::HandleATResponse SendNextFromFifo")));
|
423 |
SendNextFromFifo(); |
|
424 |
} |
|
425 |
else |
|
426 |
{
|
|
427 |
HandleUnsolicitedData( aDteId, aResponse); |
|
428 |
} |
|
429 |
C_TRACE ((_T("<<CModemAtSrv::HandleATResponse()") ));
|
|
430 |
} |
|
431 |
||
| 9 | 432 |
TInt CModemAtSrv::ConnectToModemL( CModemAtSession* aSession, TATPluginInterface aPluginType ) |
| 0 | 433 |
{
|
| 9 | 434 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL;aSession=%x", aSession ); |
| 0 | 435 |
C_TRACE ((_T(">>CModemAtSrv::ConnectToModem 0x%x"), aSession));
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
436 |
|
| 9 | 437 |
OstTraceExt2( TRACE_NORMAL, DUP1_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL;iSessions.Count()=%d;aPluginType=%d", iSessions.Count(), (TInt)aPluginType ); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
438 |
C_TRACE(( _L("session count: %d, type: %d"), iSessions.Count(), (TInt) aPluginType ));
|
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
439 |
|
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
440 |
if( aPluginType == ECommonPlugin ) |
| 0 | 441 |
{
|
| 9 | 442 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Common plug-in connecting;aSession=%x", aSession ); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
443 |
C_TRACE ((_T("Common plug-in connecting")));
|
| 9 | 444 |
C_TRACE ((_T("<<CModemAtSrv::ConnectToModem session: 0x%x"), aSession));
|
445 |
||
446 |
if( KMaxDteCount >= GetDteCount() ) |
|
447 |
{
|
|
448 |
TBool handlerAttached( EFalse ); |
|
449 |
for( TInt i = 0; i < iSessions.Count(); i++ ) |
|
450 |
{
|
|
451 |
if( iHandler == iSessions[i]->GetHandler() ) |
|
452 |
{
|
|
453 |
handlerAttached = ETrue; |
|
454 |
break; |
|
455 |
} |
|
456 |
} |
|
457 |
||
458 |
TUint8 devId( 0 ); |
|
459 |
TUint8 objId( 0 ); |
|
460 |
TBool dteFound( EFalse ); |
|
461 |
OstTrace1( TRACE_NORMAL, DUP3_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL;iDteInfo.Count()=%d", iDteInfo.Count() ); |
|
462 |
C_TRACE ((_T("iDteInfo.Count(): %d"), iDteInfo.Count()));
|
|
463 |
for( TInt j = 0; j < iDteInfo.Count(); j++ ) |
|
464 |
{
|
|
465 |
if( NULL == iDteInfo[j].iSession ) |
|
466 |
{
|
|
467 |
dteFound = ETrue; |
|
468 |
CModemAtHandler* handler( NULL ); |
|
469 |
devId = iDteInfo[j].iDevId; |
|
470 |
objId = iDteInfo[j].iObjId; |
|
471 |
if( handlerAttached ) |
|
472 |
{
|
|
473 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Creating new handler" ); |
|
474 |
C_TRACE ((_T("Creating new handler")));
|
|
475 |
TUint8 channelId( 0 ); |
|
476 |
if( KErrNone == GetFreeChannelId( channelId ) ) |
|
477 |
{
|
|
478 |
handler = CModemAtHandler::NewL( |
|
479 |
*this, |
|
480 |
channelId ); |
|
481 |
iDteInfo[j].iSession = aSession; |
|
482 |
aSession->SetHandler( handler ); |
|
483 |
} |
|
484 |
else |
|
485 |
{
|
|
486 |
TRACE_ASSERT_ALWAYS; |
|
487 |
aSession->ModemConnected( KErrGeneral ); |
|
488 |
OstTrace0( TRACE_NORMAL, DUP14_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL No free channel id" ); |
|
489 |
C_TRACE ((_T("No free channel id")));
|
|
490 |
return KErrGeneral; |
|
491 |
} |
|
492 |
} |
|
493 |
else |
|
494 |
{
|
|
495 |
OstTrace0( TRACE_NORMAL, DUP5_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Using already created handler" ); |
|
496 |
C_TRACE ((_T("Using already created handler")));
|
|
497 |
iDteInfo[j].iSession = aSession; |
|
498 |
aSession->SetHandler( iHandler ); |
|
499 |
} |
|
500 |
break; |
|
501 |
} |
|
502 |
} |
|
503 |
if( dteFound ) |
|
504 |
{
|
|
505 |
return aSession->GetHandler()->Connect( devId, objId ); |
|
506 |
} |
|
507 |
else |
|
508 |
{
|
|
509 |
OstTrace0( TRACE_NORMAL, DUP6_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - No dte info found. Possibly PNS_NAME_ADD_IND not received -> creating default pipe." ); |
|
510 |
C_TRACE ((_T("No dte info found. Possibly PNS_NAME_ADD_IND not received -> creating default pipe.")));
|
|
511 |
||
512 |
CModemAtHandler* handler( NULL ); |
|
513 |
||
514 |
TUint KInitialDpObjId( 0x2f ); |
|
515 |
TUint dataportObjectid( KInitialDpObjId ); |
|
516 |
TBool found( EFalse ); |
|
517 |
||
518 |
if( !handlerAttached ) |
|
519 |
{
|
|
520 |
OstTrace0( TRACE_NORMAL, DUP7_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Using already created handler" ); |
|
521 |
C_TRACE ((_T("Using already created handler")));
|
|
522 |
aSession->SetHandler( iHandler ); |
|
523 |
||
524 |
OstTrace0( TRACE_NORMAL, DUP8_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Calling GetDataportObjectId()" ); |
|
525 |
C_TRACE ((_T("Calling GetDataportObjectId()")));
|
|
526 |
aSession->GetHandler()->GetDataportObjectId( dataportObjectid ); |
|
527 |
||
528 |
OstTrace0( TRACE_NORMAL, DUP9_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Calling AddDevice()" ); |
|
529 |
C_TRACE ((_T("Calling AddDevice()")));
|
|
530 |
AddDevice( THIS_DEVICE, (TUint8)dataportObjectid ); |
|
531 |
||
532 |
OstTrace0( TRACE_NORMAL, DUP10_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Set session to this device" ); |
|
533 |
C_TRACE ((_T("Set session to this device")));
|
|
534 |
for( TInt j = 0; j < iDteInfo.Count(); j++ ) |
|
535 |
{
|
|
536 |
if( NULL == iDteInfo[j].iSession ) // if iSession is NULL, the device handler is not attached |
|
537 |
{
|
|
538 |
OstTrace0( TRACE_NORMAL, DUP11_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Device session found" ); |
|
539 |
C_TRACE ((_T("Device session found")));
|
|
540 |
iDteInfo[j].iSession = aSession; |
|
541 |
found = ETrue; |
|
542 |
} |
|
543 |
} |
|
544 |
if( !found ) |
|
545 |
{
|
|
546 |
OstTrace0( TRACE_NORMAL, DUP12_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Device session not found" ); |
|
547 |
C_TRACE ((_T("Device session not found")));
|
|
548 |
if( iDteInfo.Count() == 1 ) |
|
549 |
{
|
|
550 |
OstTrace0( TRACE_NORMAL, DUP13_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Set session to first device" ); |
|
551 |
C_TRACE ((_T("Set session to first device")));
|
|
552 |
iDteInfo[0].iSession = aSession; |
|
553 |
} |
|
554 |
} |
|
555 |
} |
|
556 |
else |
|
557 |
{
|
|
558 |
// NOTE: It might be possible to have second device attached and then no pipe has been created |
|
559 |
// before this, EIscNokiaDataport2 has been used with first device. Now we need use |
|
560 |
// EIscNokiaDataport4. EIscNokiaDataport5 is not currently supported without PNS_NAME_ADD_IND. |
|
561 |
TUint8 channelId( 0 ); |
|
562 |
if( KErrNone == GetFreeChannelId( channelId ) ) |
|
563 |
{
|
|
564 |
C_TRACE ((_T("Creating new handler")));
|
|
565 |
handler = CModemAtHandler::NewL( |
|
566 |
*this, |
|
567 |
channelId ); |
|
568 |
OstTrace0( TRACE_NORMAL, DUP15_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Using just created handler" ); |
|
569 |
C_TRACE ((_T("Using just created handler")));
|
|
570 |
aSession->SetHandler( handler ); |
|
571 |
||
572 |
OstTrace0( TRACE_NORMAL, DUP16_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Calling GetDataportObjectId()" ); |
|
573 |
C_TRACE ((_T("Calling GetDataportObjectId()")));
|
|
574 |
||
575 |
// Get dataport 4 |
|
576 |
aSession->GetHandler()->GetSecondaryDataportObjectId( dataportObjectid ); |
|
577 |
||
578 |
OstTrace0( TRACE_NORMAL, DUP17_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Calling AddDevice()" ); |
|
579 |
C_TRACE ((_T("Calling AddDevice()")));
|
|
580 |
AddDevice( THIS_DEVICE, (TUint8)dataportObjectid ); |
|
581 |
||
582 |
||
583 |
OstTrace0( TRACE_NORMAL, DUP18_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Set session to the second device" ); |
|
584 |
C_TRACE ((_T("Set session to the second device")));
|
|
585 |
||
586 |
for( TInt j = 0; j < iDteInfo.Count(); j++ ) |
|
587 |
{
|
|
588 |
if( NULL == iDteInfo[j].iSession ) |
|
589 |
{
|
|
590 |
OstTrace0( TRACE_NORMAL, DUP19_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Device session found" ); |
|
591 |
C_TRACE ((_T("Device session found")));
|
|
592 |
iDteInfo[j].iSession = aSession; |
|
593 |
found = ETrue; |
|
594 |
} |
|
595 |
} |
|
596 |
if( !found ) |
|
597 |
{
|
|
598 |
OstTrace0( TRACE_NORMAL, DUP20_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Device 2 session not found" ); |
|
599 |
C_TRACE ((_T("Device 2 session not found")));
|
|
600 |
if( iDteInfo.Count() == 2 ) |
|
601 |
{
|
|
602 |
OstTrace0( TRACE_NORMAL, DUP21_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Set session to second device" ); |
|
603 |
C_TRACE ((_T("Set session to second device")));
|
|
604 |
iDteInfo[1].iSession = aSession; |
|
605 |
} |
|
606 |
} |
|
607 |
} |
|
608 |
else |
|
609 |
{
|
|
610 |
TRACE_ASSERT_ALWAYS; |
|
611 |
aSession->ModemConnected( KErrGeneral ); |
|
612 |
OstTrace0( TRACE_NORMAL, DUP26_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL No free channel id" ); |
|
613 |
C_TRACE ((_T("No free channel id")));
|
|
614 |
} |
|
615 |
} |
|
616 |
if( found ) |
|
617 |
{
|
|
618 |
OstTrace0( TRACE_NORMAL, DUP22_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Calling Connect( THIS_DEVICE, dataportObjectid )" ); |
|
619 |
C_TRACE ((_T("Calling Connect( THIS_DEVICE, dataportObjectid )")));
|
|
620 |
return aSession->GetHandler()->Connect( THIS_DEVICE, dataportObjectid ); |
|
621 |
} |
|
622 |
else |
|
623 |
{
|
|
624 |
C_TRACE ((_T("no dte info found, connect failed")));
|
|
625 |
OstTrace0( TRACE_NORMAL, DUP27_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL no dte info found, connect failed" ); |
|
626 |
aSession->ModemConnected( KErrGeneral ); |
|
627 |
} |
|
628 |
} |
|
629 |
} |
|
630 |
else |
|
631 |
{
|
|
632 |
OstTrace0( TRACE_NORMAL, DUP23_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Too many connections, connect failed" ); |
|
633 |
C_TRACE ((_T("Too many connections, connect failed")));
|
|
634 |
aSession->ModemConnected( KErrGeneral ); |
|
635 |
} |
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
636 |
} |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
637 |
else |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
638 |
{
|
| 9 | 639 |
OstTrace0( TRACE_NORMAL, DUP24_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL - Atext plug-in connecting" ); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
640 |
C_TRACE ((_T("Atext plug-in connecting")));
|
|
5
8ccc39f9d787
New release based on our 2010wk02 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
0
diff
changeset
|
641 |
|
| 9 | 642 |
for( TInt i = 0; i < iSessions.Count(); i++ ) |
643 |
{
|
|
644 |
if( ECommonPlugin == iSessions[i]->GetPluginType() && |
|
645 |
0 == iSessions[i]->GetName().Compare( aSession->GetName() ) ) |
|
646 |
{
|
|
647 |
aSession->SetDteId( iSessions[i]->GetDteId() ); |
|
648 |
aSession->SetHandler( iSessions[i]->GetHandler() ); |
|
649 |
break; |
|
650 |
} |
|
651 |
} |
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
652 |
aSession->ModemConnected( KErrNone ); |
| 9 | 653 |
|
654 |
OstTrace1( TRACE_NORMAL, DUP25_CMODEMATSRV_CONNECTTOMODEML, "CModemAtSrv::ConnectToModemL;aSession=%x", aSession ); |
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
655 |
C_TRACE ((_T("<<CModemAtSrv::ConnectToModem 0x%x"), aSession));
|
| 0 | 656 |
} |
| 9 | 657 |
return KErrNone; |
| 0 | 658 |
} |
659 |
||
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
660 |
void CModemAtSrv::AddToSendFifo( const TATPluginInterface aPluginType, CAtMessage* aMessage ) |
| 0 | 661 |
{
|
| 9 | 662 |
OstTraceExt2( TRACE_NORMAL, CMODEMATSRV_ADDTOSENDFIFO, "CModemAtSrv::AddToSendFifo;aPluginType=%d;aMessage=%p", (TInt)aPluginType, aMessage ); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
663 |
C_TRACE (( _T("CModemAtSrv::AddToSendFifo( aPluginType: %d, aMessage: 0x%x)"), (TInt)aPluginType, aMessage));
|
| 0 | 664 |
|
665 |
iAtMessageArray.Append( aMessage ); // only one AT command at the time in modem |
|
666 |
||
667 |
if( iAtMessageArray.Count() == 1 ) //if empty Fifo send immediately |
|
668 |
{
|
|
| 9 | 669 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_ADDTOSENDFIFO, "CModemAtSrv::AddToSendFifo - Sending message immediately" ); |
| 0 | 670 |
C_TRACE((_L("Sending message immediately")));
|
| 9 | 671 |
CModemAtSession* session = aMessage->GetSession(); |
672 |
if( session ) |
|
673 |
{
|
|
674 |
CModemAtHandler* handler( session->GetHandler() ); |
|
675 |
PeekAtCommand( handler, aMessage->GetBuffer() ); |
|
676 |
||
677 |
handler->SendATCommand( |
|
678 |
aPluginType, |
|
679 |
aMessage->GetMessageType(), |
|
680 |
aMessage->GetBuffer() ); |
|
681 |
} |
|
682 |
else |
|
683 |
{
|
|
684 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_ADDTOSENDFIFO, "CModemAtSrv::AddToSendFifo - Session NULL" ); |
|
685 |
C_TRACE((_L("Session NULL")));
|
|
686 |
TRACE_ASSERT_ALWAYS; |
|
687 |
} |
|
| 0 | 688 |
} |
689 |
} |
|
690 |
||
691 |
void CModemAtSrv::RemoveFirstFromSendFifo() |
|
692 |
{
|
|
| 9 | 693 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_REMOVEFIRSTFROMSENDFIFO, "CModemAtSrv::RemoveFirstFromSendFifo;iAtMessageArray.Count()=%d", iAtMessageArray.Count() ); |
| 0 | 694 |
C_TRACE(( _T("CModemAtSrv::RemoveFirstFromSendFifo iAtMessageArray.Count = %d"), iAtMessageArray.Count() ));
|
695 |
if( iAtMessageArray.Count( ) > 0 ) |
|
696 |
{
|
|
| 9 | 697 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_REMOVEFIRSTFROMSENDFIFO, "CModemAtSrv::RemoveFirstFromSendFifo - 1" ); |
| 0 | 698 |
C_TRACE (( _T("CModemAtSrv::RemoveFirstFromSendFifo 1") ));
|
699 |
CAtMessage* msg = iAtMessageArray[0]; |
|
| 9 | 700 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATSRV_REMOVEFIRSTFROMSENDFIFO, "CModemAtSrv::RemoveFirstFromSendFifo - 2;msg=%x", msg ); |
| 0 | 701 |
C_TRACE (( _T("CModemAtSrv::RemoveFirstFromSendFifo 2 0x%x"), msg ));
|
702 |
iAtMessageArray.Remove(0); |
|
703 |
if( msg ) |
|
704 |
{
|
|
| 9 | 705 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSRV_REMOVEFIRSTFROMSENDFIFO, "CModemAtSrv::RemoveFirstFromSendFifo - 3" ); |
| 0 | 706 |
C_TRACE (( _T("CModemAtSrv::RemoveFirstFromSendFifo 3") ));
|
707 |
delete msg; |
|
708 |
} |
|
709 |
else |
|
710 |
{
|
|
711 |
TRACE_ASSERT_ALWAYS; |
|
712 |
} |
|
| 9 | 713 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSRV_REMOVEFIRSTFROMSENDFIFO, "CModemAtSrv::RemoveFirstFromSendFifo - 4" ); |
| 0 | 714 |
C_TRACE (( _T("CModemAtSrv::RemoveFirstFromSendFifo 4") ));
|
715 |
} |
|
| 9 | 716 |
OstTrace0( TRACE_NORMAL, DUP5_CMODEMATSRV_REMOVEFIRSTFROMSENDFIFO, "CModemAtSrv::RemoveFirstFromSendFifo - 5" ); |
| 0 | 717 |
C_TRACE (( _T("CModemAtSrv::RemoveFirstFromSendFifo 5") ));
|
718 |
} |
|
719 |
||
720 |
void CModemAtSrv::SendNextFromFifo() |
|
721 |
{
|
|
| 9 | 722 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_SENDNEXTFROMFIFO, "CModemAtSrv::SendNextFromFifo - fifo message count;iAtMessageArray.Count()=%d", iAtMessageArray.Count() ); |
| 0 | 723 |
C_TRACE ((_T("CModemAtSrv::SendNextFromFifo fifo has %d message(s)"), iAtMessageArray.Count() ));
|
724 |
||
| 9 | 725 |
TPtr8 ptr( 0, 0 ); |
| 0 | 726 |
if( iAtMessageArray.Count() > 0 ) |
727 |
{
|
|
| 9 | 728 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_SENDNEXTFROMFIFO, "CModemAtSrv::SendNextFromFifo - Messages in buffer... Sending message" ); |
| 0 | 729 |
C_TRACE((_L("Messages in buffer... Sending message")));
|
730 |
ptr.Set( iAtMessageArray[0]->GetBuffer() ); |
|
| 9 | 731 |
|
732 |
CModemAtHandler* handler( iAtMessageArray[0]->GetSession()->GetHandler() ); |
|
733 |
if( handler ) |
|
734 |
{
|
|
735 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_SENDNEXTFROMFIFO, "CModemAtSrv::SendNextFromFifo - iHandler->SendATCommand()" ); |
|
736 |
C_TRACE (( _T("iHandler->SendATCommand()") ));
|
|
737 |
PeekAtCommand( handler, ptr ); |
|
738 |
handler->SendATCommand( |
|
739 |
iAtMessageArray[0]->GetSession()->GetPluginType(), |
|
740 |
iAtMessageArray[0]->GetMessageType(), |
|
741 |
ptr ); |
|
742 |
} |
|
743 |
else |
|
744 |
{
|
|
745 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSRV_SENDNEXTFROMFIFO, "CModemAtSrv::SendNextFromFifo - Handler NULL" ); |
|
746 |
C_TRACE((_L("Handler NULL")));
|
|
747 |
TRACE_ASSERT_ALWAYS; |
|
748 |
} |
|
| 0 | 749 |
} |
750 |
} |
|
751 |
||
752 |
void CModemAtSrv::CancelFifoRequests( const CModemAtSession* aSession ) |
|
753 |
{
|
|
| 9 | 754 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_CANCELFIFOREQUESTS, "CModemAtSrv::CancelFifoRequests;iAtMessageArray.Count()=%d", iAtMessageArray.Count() ); |
| 0 | 755 |
C_TRACE((_T(">>CModemAtSrv::CancelFifoRequests count: %d"), iAtMessageArray.Count() ));
|
756 |
TInt messageCount = iAtMessageArray.Count(); |
|
757 |
for( TInt i = 0; i < messageCount; i++ ) |
|
758 |
{
|
|
| 9 | 759 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSRV_CANCELFIFOREQUESTS, "CModemAtSrv::CancelFifoRequests - ;i=%d", i ); |
| 0 | 760 |
C_TRACE((_T("CancelFifoRequests %d"), i ));
|
761 |
CAtMessage* msg = iAtMessageArray[ i ]; |
|
762 |
if( msg ) |
|
763 |
{
|
|
| 9 | 764 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATSRV_CANCELFIFOREQUESTS, "CModemAtSrv::CancelFifoRequests - Found Request:;msg=%x", msg ); |
| 0 | 765 |
C_TRACE((_T("Found Request: 0x%x"),msg ));
|
766 |
if( msg->GetSession() == aSession) |
|
767 |
{
|
|
| 9 | 768 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSRV_CANCELFIFOREQUESTS, "CModemAtSrv::CancelFifoRequests - canceling request" ); |
| 0 | 769 |
C_TRACE((_T("CancelFifoRequests - canceling request") ));
|
770 |
msg->CancelRequest(); |
|
| 9 | 771 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSRV_CANCELFIFOREQUESTS, "CModemAtSrv::CancelFifoRequests - delete msg" ); |
| 0 | 772 |
C_TRACE (( _T("CModemAtSrv::CancelFifoRequest delete msg") ));
|
773 |
delete msg; |
|
774 |
} |
|
775 |
} |
|
776 |
} |
|
| 9 | 777 |
OstTrace1( TRACE_NORMAL, DUP5_CMODEMATSRV_CANCELFIFOREQUESTS, "CModemAtSrv::CancelFifoRequests - iAtMessageArray.Remove;messageCount=%d", messageCount ); |
| 0 | 778 |
C_TRACE (( _T("CModemAtSrv::CancelFifoRequest iAtMessageArray.Remove %d messages"), messageCount ));
|
779 |
for( TInt j = 0; j < messageCount && iAtMessageArray.Count() > 0; j++ ) |
|
780 |
{
|
|
781 |
iAtMessageArray.Remove( 0 ); |
|
782 |
} |
|
783 |
C_TRACE(( _T("<<CModemAtSrv::CancelFifoRequests()") ));
|
|
784 |
} |
|
785 |
||
786 |
TInt CModemAtSrv::SessionCount() |
|
787 |
{
|
|
| 9 | 788 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_SESSIONCOUNT, "CModemAtSrv::SessionCount;iSessions.Count()=%d", iSessions.Count() ); |
| 0 | 789 |
C_TRACE(( _T("CModemAtSrv::SessionCount() %d"), iSessions.Count() ));
|
790 |
return iSessions.Count(); |
|
791 |
} |
|
792 |
||
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
793 |
void CModemAtSrv::SetDteIdAndConnect( const TUint8 aDteId, const TInt aConnectionError ) |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
794 |
{
|
| 9 | 795 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_SETDTEIDANDCONNECT, "CModemAtSrv::SetDteIdAndConnect;aDteId=%d", aDteId ); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
796 |
C_TRACE(( _T("CModemAtSrv::SetDteIdAndConnect( %d )"), aDteId ));
|
| 9 | 797 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSRV_SETDTEIDANDCONNECT, "CModemAtSrv::SetDteIdAndConnect;iSessions.Count()=%d", iSessions.Count() ); |
798 |
C_TRACE ((_T("sessions = %d"), iSessions.Count() ));
|
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
799 |
|
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
800 |
for( TInt i = 0; i < iSessions.Count(); i++ ) |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
801 |
{
|
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
802 |
if( iSessions[i]->IsConnectReqActive() ) |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
803 |
{
|
| 9 | 804 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_SETDTEIDANDCONNECT, "CModemAtSrv::SetDteIdAndConnect - set sessions to connected" ); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
805 |
C_TRACE (( _T("set sessions to connected") ));
|
| 9 | 806 |
iSessions[i]->SetDteId( aDteId ); |
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
807 |
iSessions[i]->ModemConnected( aConnectionError ); |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
808 |
} |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
809 |
} |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
810 |
} |
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
811 |
|
| 9 | 812 |
TBool CModemAtSrv::IsPipeInDataMode( CModemAtHandler* aHandler ) |
813 |
{
|
|
814 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_ISPIPEINDATAMODE, "CModemAtSrv::IsPipeInDataMode;aHandler=%x", aHandler ); |
|
815 |
C_TRACE(( _T("CModemAtSrv::IsPipeInDataMode() handler: 0x%x"), aHandler ));
|
|
816 |
TRACE_ASSERT( NULL != aHandler ) |
|
817 |
return aHandler->IsPipeInDataMode(); |
|
818 |
} |
|
819 |
||
820 |
TBool CModemAtSrv::IsTextMessageMode( CModemAtHandler* aHandler ) |
|
821 |
{
|
|
822 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_ISTEXTMESSAGEMODE, "CModemAtSrv::IsTextMessageMode;aHandler=%x", aHandler ); |
|
823 |
C_TRACE(( _T("CModemAtSrv::IsTextMessageMode() handler: 0x%x"), aHandler ));
|
|
824 |
TRACE_ASSERT( NULL != aHandler ) |
|
825 |
return aHandler->IsTextMessageMode(); |
|
826 |
} |
|
827 |
||
828 |
void CModemAtSrv::PeekAtCommand( CModemAtHandler* aHandler, TDes8& aCmd ) |
|
829 |
{
|
|
830 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand;aHandler=%x", aHandler ); |
|
831 |
C_TRACE(( _T("CModemAtSrv::PeekAtCommand() handler: 0x%x"), aHandler ));
|
|
832 |
TRACE_ASSERT( NULL != aHandler ) |
|
833 |
||
834 |
if( ( aCmd.Find( KCmgs ) != KErrNotFound || |
|
835 |
aCmd.Find( KCmgc ) != KErrNotFound ) && |
|
836 |
aCmd.Find( KCmgsQuery ) == KErrNotFound && |
|
837 |
aCmd.Find( KCmgcQuery ) == KErrNotFound ) |
|
838 |
{
|
|
839 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - +CMGS or +CMGC detected. The indications after this will be ignored." ); |
|
840 |
C_TRACE(_L("+CMGS or +CMGC detected. The indications after this will be ignored."));
|
|
841 |
aHandler->SetTextMessageMode( ETrue ); |
|
842 |
} |
|
843 |
// no else |
|
844 |
||
845 |
if( aCmd.Find( KAtv1 ) != KErrNotFound ) |
|
846 |
{
|
|
847 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATV1 received" ); |
|
848 |
C_TRACE(( _T("ATV1 received") ));
|
|
849 |
iVerbose = KOn; |
|
850 |
iVerboseQueryIsOngoing = ETrue; |
|
851 |
} |
|
852 |
else if( aCmd.Find( KAtv0 ) != KErrNotFound || |
|
853 |
aCmd.Find( KAtv ) != KErrNotFound ) |
|
854 |
{
|
|
855 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATV0 received" ); |
|
856 |
C_TRACE(( _T("ATV(0) received") ));
|
|
857 |
iVerbose = KOff; |
|
858 |
iVerboseQueryIsOngoing = ETrue; |
|
859 |
} |
|
860 |
else if( aCmd.Find( KAtq1 ) != KErrNotFound ) |
|
861 |
{
|
|
862 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATQ1 received" ); |
|
863 |
C_TRACE(( _T("ATQ1 received") ));
|
|
864 |
iQuiet = KOn; |
|
865 |
iQuietQueryIsOngoing = ETrue; |
|
866 |
} |
|
867 |
else if( aCmd.Find( KAtq0 ) != KErrNotFound || |
|
868 |
aCmd.Find( KAtq ) != KErrNotFound ) |
|
869 |
{
|
|
870 |
OstTrace0( TRACE_NORMAL, DUP5_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATQ0 received" ); |
|
871 |
C_TRACE(( _T("ATQ(0) received") ));
|
|
872 |
iQuiet = KOff; |
|
873 |
iQuietQueryIsOngoing = ETrue; |
|
874 |
} |
|
875 |
else if( aCmd.Find( KAte1 ) != KErrNotFound ) |
|
876 |
{
|
|
877 |
OstTrace0( TRACE_NORMAL, DUP6_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATE1 received" ); |
|
878 |
C_TRACE(( _T("ATE(1) received") ));
|
|
879 |
iEcho = KOn; |
|
880 |
iEchoQueryIsOngoing = ETrue; |
|
881 |
} |
|
882 |
else if( aCmd.Find( KAte0 ) != KErrNotFound || |
|
883 |
aCmd.Find( KAte ) != KErrNotFound ) |
|
884 |
{
|
|
885 |
OstTrace0( TRACE_NORMAL, DUP7_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATE0 received" ); |
|
886 |
C_TRACE(( _T("ATE(0) received") ));
|
|
887 |
iEcho = KOff; |
|
888 |
iEchoQueryIsOngoing = ETrue; |
|
889 |
} |
|
890 |
else if( aCmd.Find( KAts3 ) != KErrNotFound ) |
|
891 |
{
|
|
892 |
OstTrace0( TRACE_NORMAL, DUP8_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATS3 received" ); |
|
893 |
C_TRACE(( _T("ATS3= received, saving it for the next profile query") ));
|
|
894 |
||
895 |
TInt valueLength = aCmd.Length() - KAts3().Length() - 1; |
|
896 |
OstTrace1( TRACE_NORMAL, DUP9_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand;valueLength=%d", valueLength ); |
|
897 |
OstTrace1( TRACE_NORMAL, DUP10_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand;KAts3Length=%d", KAts3().Length() ); |
|
898 |
C_TRACE(( _T("Reading %d char's starting from %d."), valueLength, KAts3().Length() ));
|
|
899 |
if( valueLength > 0 ) |
|
900 |
{
|
|
901 |
TLex8 lex( aCmd.Mid( KAts3().Length(), valueLength ) ); |
|
902 |
TInt value; |
|
903 |
if( lex.Val(value) == KErrNone ) |
|
904 |
{
|
|
905 |
C_TRACE(( _T("iCarriageReturn 0x%x "), value ));
|
|
906 |
iCarriageReturn = (TUint8)value; |
|
907 |
iCarriageReturnFound = ETrue; |
|
908 |
} |
|
909 |
} |
|
910 |
// no else |
|
911 |
} |
|
912 |
||
913 |
if( aCmd.Find( KAts3 ) == KErrNotFound && |
|
914 |
iCarriageReturnFound ) |
|
915 |
{
|
|
916 |
OstTrace0( TRACE_NORMAL, DUP11_CMODEMATSRV_PEEKATCOMMAND, "CModemAtSrv::PeekAtCommand - ATE=? received" ); |
|
917 |
C_TRACE(( _T("ATS3 has set the carriage return, using it once for profile query that will notify it to upper layers") ));
|
|
918 |
aCmd.Copy( aCmd.Mid( 0, aCmd.Length() - 1 ) ); |
|
919 |
aCmd.Append( iCarriageReturn ); |
|
920 |
iCarriageReturnFound = EFalse; |
|
921 |
} |
|
922 |
||
923 |
} |
|
924 |
||
925 |
TBool CModemAtSrv::IsEchoNotified( const TUint8 aEchoValue ) |
|
926 |
{
|
|
927 |
OstTrace1( TRACE_NORMAL, CMODEMATSRV_ISECHONOTIFIED, "CModemAtSrv::IsEchoNotified;aEchoValue=%d", aEchoValue ); |
|
928 |
C_TRACE(( _T("CModemAtSrv::IsEchoNotified( %d )"), aEchoValue ));
|
|
929 |
if( aEchoValue != iEchoNotified ) |
|
930 |
{
|
|
931 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_ISECHONOTIFIED, "CModemAtSrv::IsEchoNotified - Echo value is not notified yet." ); |
|
932 |
C_TRACE(( _T("Echo value is not notified yet.") ));
|
|
933 |
return EFalse; |
|
934 |
} |
|
935 |
else |
|
936 |
{
|
|
937 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_ISECHONOTIFIED, "CModemAtSrv::IsEchoNotified - Echo value is the same as before" ); |
|
938 |
C_TRACE(( _T("Echo value is the same as before") ));
|
|
939 |
return ETrue; |
|
940 |
} |
|
941 |
} |
|
942 |
||
943 |
TBool CModemAtSrv::IsSettingQueryOngoing() |
|
944 |
{
|
|
945 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_ISSETTINGQUERYONGOING, "CModemAtSrv::IsSettingQueryOngoing" ); |
|
946 |
C_TRACE(( _T("CModemAtSrv::IsSettingQueryOngoing()") ));
|
|
947 |
if ( iEchoQueryIsOngoing || iVerboseQueryIsOngoing || iQuietQueryIsOngoing ) |
|
948 |
{
|
|
949 |
return ETrue; |
|
950 |
} |
|
951 |
else |
|
952 |
{
|
|
953 |
return EFalse; |
|
954 |
} |
|
955 |
} |
|
956 |
||
957 |
||
958 |
void CModemAtSrv::AddDevice( TUint8 aDevId, TUint8 aObjId ) |
|
959 |
{
|
|
960 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_ADDDEVICE, "CModemAtSrv::AddDevice" ); |
|
961 |
C_TRACE(( _T("CModemAtSrv::AddDevice()") ));
|
|
962 |
TBool alreadyFound( EFalse ); |
|
963 |
||
964 |
for( int i = 0; i < iDteInfo.Count(); i++ ) |
|
965 |
{
|
|
966 |
if( aDevId == iDteInfo[i].iDevId && aObjId == iDteInfo[i].iObjId ) |
|
967 |
{
|
|
968 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_ADDDEVICE, "CModemAtSrv::AddDevice - dte already found" ); |
|
969 |
C_TRACE(( _T("CModemAtSrv::AddDevice() dte already found") ));
|
|
970 |
alreadyFound = ETrue; |
|
971 |
break; |
|
972 |
} |
|
973 |
} |
|
974 |
if( !alreadyFound ) |
|
975 |
{
|
|
976 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATSRV_ADDDEVICE, "CModemAtSrv::AddDevice - adding dte" ); |
|
977 |
C_TRACE(( _T("CModemAtSrv::AddDevice() adding dte") ));
|
|
978 |
TDteInfo devInfo; |
|
979 |
devInfo.iDevId = aDevId; |
|
980 |
devInfo.iObjId = aObjId; |
|
981 |
devInfo.iSession = NULL; |
|
982 |
iDteInfo.Append( devInfo ); |
|
983 |
} |
|
984 |
} |
|
985 |
||
986 |
||
987 |
void CModemAtSrv::RemoveDevice( TUint8 aDevId, TUint8 aObjId ) |
|
988 |
{
|
|
989 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_REMOVEDEVICE, "CModemAtSrv::RemoveDevice" ); |
|
990 |
C_TRACE(( _T("CModemAtSrv::RemoveDevice()") ));
|
|
991 |
||
992 |
for( int i = 0; i < iDteInfo.Count(); i++ ) |
|
993 |
{
|
|
994 |
if( aDevId == iDteInfo[i].iDevId && aObjId == iDteInfo[i].iObjId ) |
|
995 |
{
|
|
996 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATSRV_REMOVEDEVICE, "CModemAtSrv::RemoveDevice - CModemAtSrv::RemoveDevice() device found" ); |
|
997 |
C_TRACE(( _T("CModemAtSrv::RemoveDevice() device found") ));
|
|
998 |
iDteInfo.Remove( i ); |
|
999 |
break; |
|
1000 |
} |
|
1001 |
} |
|
1002 |
} |
|
1003 |
||
1004 |
TUint8 CModemAtSrv::GetDteCount() |
|
1005 |
{
|
|
1006 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_GETDTECOUNT, "CModemAtSrv::GetDteCount" ); |
|
1007 |
C_TRACE(( _T("CModemAtSrv::GetDteCount()") ));
|
|
1008 |
TUint8 count( 0 ); |
|
1009 |
for( int i = 0; i < iSessions.Count(); i++ ) |
|
1010 |
{
|
|
1011 |
if( ECommonPlugin == iSessions[i]->GetPluginType() ) |
|
1012 |
{
|
|
1013 |
count++; |
|
1014 |
} |
|
1015 |
} |
|
1016 |
return count; |
|
1017 |
} |
|
1018 |
||
1019 |
// ----------------------------------------------------------------------------- |
|
1020 |
// CModemAtSrv::GetFreeChannelId |
|
1021 |
// Gets free ISC channel id for new connection |
|
1022 |
// ----------------------------------------------------------------------------- |
|
1023 |
// |
|
1024 |
TInt CModemAtSrv::GetFreeChannelId( TUint8& aChannel ) |
|
1025 |
{
|
|
1026 |
OstTrace0( TRACE_NORMAL, CMODEMATSRV_GETFREECHANNELID, "CModemAtSrv::GetFreeChannelId" ); |
|
1027 |
C_TRACE(( _T("CModemAtSrv::GetFreeChannelId()") ));
|
|
1028 |
TInt ret( KErrNotFound ); |
|
1029 |
||
1030 |
if( 0 < iFreeChannels.Size() ) |
|
1031 |
{
|
|
1032 |
ret = KErrNone; |
|
1033 |
aChannel = iFreeChannels[0]; |
|
1034 |
iFreeChannels.Delete( 0, 1 ); |
|
1035 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATSRV_GETFREECHANNELID, "CModemAtSrv::GetFreeChannelId free channel found: 0x%x", aChannel ); |
|
1036 |
C_TRACE(( _T("CModemAtSrv::GetFreeChannelId: free channel found: 0x%x"), aChannel ));
|
|
1037 |
} |
|
1038 |
return ret; |
|
1039 |
} |