| author | mikaruus |
| Tue, 19 Oct 2010 13:16:20 +0300 | |
| changeset 9 | 8486d82aef45 |
| parent 8 | 6295dc2169f3 |
| permissions | -rw-r--r-- |
| 0 | 1 |
/* |
|
7
fa67e03b87df
New release based on our 2010wk08 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
2 |
* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies). |
| 0 | 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 |
||
18 |
||
19 |
||
20 |
#include "modemat_atext.h" |
|
21 |
#include "modemattrace.h" |
|
| 9 | 22 |
#include "OstTraceDefinitions.h" |
23 |
#ifdef OST_TRACE_COMPILER_IN_USE |
|
24 |
#include "modemat_atextTraces.h" |
|
25 |
#endif |
|
26 |
||
27 |
const TInt KReplyTypeEditorStart( 1 ); |
|
28 |
const TInt KReplyTypeEditorEnd( 2 ); |
|
29 |
const TInt KReplyTypeOther( 3 ); |
|
30 |
const TInt KReplyTypeEditor( 4 ); |
|
31 |
const TUint8 KEscChar( 0x1B ); // from ascii table |
|
32 |
const TUint8 KCtrlZChar( 0x1A ); // from ascii table |
|
33 |
const TUint8 KEscDataSize( 2 ); |
|
34 |
const TUint8 KErrorSize( 9 ); |
|
| 0 | 35 |
|
36 |
const char* const atCommands[] = |
|
37 |
{
|
|
38 |
("ATS0"),
|
|
39 |
("ATS1"),
|
|
40 |
("ATS2"),
|
|
41 |
("ATS3"),
|
|
42 |
("ATS4"),
|
|
43 |
("ATS5"),
|
|
44 |
("ATS6"),
|
|
45 |
("ATS7"),
|
|
46 |
("ATS8"),
|
|
47 |
("ATS10"),
|
|
48 |
("ATS12"),
|
|
49 |
("ATS25"),
|
|
50 |
("ATE"),
|
|
51 |
("ATE0"),
|
|
52 |
("ATE1"),
|
|
53 |
("ATQ"),
|
|
54 |
("ATQ0"),
|
|
55 |
("ATQ1"),
|
|
56 |
("ATV"),
|
|
57 |
("ATV0"),
|
|
58 |
("ATV1"),
|
|
59 |
("ATX"),
|
|
60 |
("ATX0"),
|
|
61 |
("ATX1"),
|
|
62 |
("ATX2"),
|
|
63 |
("ATX3"),
|
|
64 |
("ATX4"),
|
|
65 |
("ATX5"),
|
|
66 |
("AT&C"),
|
|
67 |
("AT&C0"),
|
|
68 |
("AT&C1"),
|
|
69 |
("AT&D"),
|
|
70 |
("AT&D0"),
|
|
71 |
("AT&D1"),
|
|
72 |
("AT&D2"),
|
|
73 |
("AT&D3"),
|
|
74 |
("AT+IFC"),
|
|
75 |
("AT+ILRR"),
|
|
76 |
("AT&S"),
|
|
77 |
("AT&S0"),
|
|
78 |
("AT&S1"),
|
|
79 |
("AT&K"),
|
|
80 |
("AT&K0"),
|
|
81 |
("AT&K3"),
|
|
82 |
("AT&K4"),
|
|
83 |
("ATZ"),
|
|
84 |
("ATZ0"),
|
|
85 |
("ATZ1"),
|
|
86 |
("AT&F"),
|
|
87 |
("AT&F0"),
|
|
88 |
("ATI"), //ati0-255 accepted
|
|
89 |
("AT+GMI"),
|
|
90 |
("AT+GMM"),
|
|
91 |
("AT+GMR"),
|
|
92 |
("AT+GSN"),
|
|
93 |
("AT+GCAP"),
|
|
94 |
("AT&V"),
|
|
95 |
("AT&V0"),
|
|
96 |
("AT&V1"),
|
|
97 |
("AT&V2"),
|
|
98 |
("AT&W"),
|
|
99 |
("AT&W0"),
|
|
100 |
("AT&W1"),
|
|
101 |
("AT&Y"),
|
|
102 |
("AT&Y0"),
|
|
103 |
("AT&Y1"),
|
|
104 |
("AT+CGMI"),
|
|
105 |
("AT+CGMM"),
|
|
106 |
("AT+CGMR"),
|
|
107 |
("AT+CGSN"),
|
|
108 |
("AT+CSCS"),
|
|
109 |
("AT+CIMI"),
|
|
110 |
("AT+WS46"),
|
|
111 |
("ATD"),
|
|
112 |
("ATA"),
|
|
113 |
("ATH"),
|
|
114 |
("ATH0"),
|
|
115 |
("ATO"),
|
|
116 |
("ATO0"),
|
|
117 |
("AT+DS"),
|
|
118 |
("AT+DR"),
|
|
119 |
("AT+CSTA"),
|
|
120 |
("AT+CHUP"),
|
|
121 |
("AT+CR"),
|
|
122 |
("AT+CEER"),
|
|
123 |
("AT+CRC"),
|
|
124 |
("AT+CSNS"),
|
|
125 |
("AT+CVHU"),
|
|
126 |
("AT+CREG"),
|
|
127 |
("AT+CLIP"),
|
|
128 |
("AT+CLIR"),
|
|
129 |
("AT+COLP"),
|
|
130 |
("AT+CCFC"),
|
|
131 |
("AT+CCWA"),
|
|
132 |
("AT+CHLD"),
|
|
133 |
("AT+CLCC"),
|
|
134 |
("AT+CSSN"),
|
|
135 |
("AT+CPAS"),
|
|
136 |
("AT+CSQ"),
|
|
137 |
("AT+CMEE"),
|
|
138 |
("AT+CSMS"),
|
|
139 |
("AT+CPMS"),
|
|
140 |
("AT+CMGF"),
|
|
141 |
("AT+CSCA"),
|
|
142 |
("AT+CSMP"),
|
|
143 |
("AT+CSDH"),
|
|
144 |
("AT+CSAS"),
|
|
145 |
("AT+CRES"),
|
|
146 |
("AT+CMGS"),
|
|
147 |
("AT+CMGC"),
|
|
148 |
("AT+CMMS"),
|
|
149 |
("AT+CGSMS"),
|
|
150 |
("AT+FCLASS"),
|
|
151 |
("AT+VTS"),
|
|
152 |
("AT+CGDCONT"),
|
|
153 |
("AT+CGEQREQ"),
|
|
154 |
("AT+CGEQMIN"),
|
|
155 |
("AT+CGEQNEG"),
|
|
156 |
("AT+CGREG"),
|
|
157 |
("AT+CGATT"),
|
|
158 |
("AT+CGACT"),
|
|
159 |
("AT+CGDATA"),
|
|
160 |
("AT+CGDSCONT"),
|
|
161 |
("AT+CGTFT"),
|
|
162 |
("AT+CGCMOD"),
|
|
|
8
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
7
diff
changeset
|
163 |
("AT+CSIM"),
|
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
7
diff
changeset
|
164 |
("AT+CPNET"),
|
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
7
diff
changeset
|
165 |
("AT+CPNSTAT"),
|
|
6295dc2169f3
New release based on our 2010wk15 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
7
diff
changeset
|
166 |
("AT+CGPADDR"),
|
| 0 | 167 |
("AT"),
|
168 |
("LAST")
|
|
169 |
}; |
|
|
7
fa67e03b87df
New release based on our 2010wk08 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
170 |
|
|
fa67e03b87df
New release based on our 2010wk08 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
171 |
const TInt KMaxCommandCount(sizeof(atCommands)/sizeof(const char*)); |
|
fa67e03b87df
New release based on our 2010wk08 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
172 |
|
|
fa67e03b87df
New release based on our 2010wk08 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
173 |
const TInt KPartLength = KDefaultCmdBufLength; |
|
fa67e03b87df
New release based on our 2010wk08 release
mikaruus <mika.a.ruuskanen@nokia.com>
parents:
5
diff
changeset
|
174 |
const TInt KPackets = 10; |
| 0 | 175 |
|
176 |
_LIT8(KATDCommand,"ATD"); |
|
177 |
_LIT8(KATICommand,"ATI"); |
|
178 |
_LIT8(KLastCommand,"LAST"); |
|
179 |
||
180 |
||
181 |
TPtrC8 CModemATExt::GetAtCommand( TInt aNumber ) //list of supported commands for this plugin |
|
182 |
{
|
|
| 9 | 183 |
OstTrace1( TRACE_NORMAL, CMODEMATEXT_GETATCOMMAND, "CModemATExt::GetAtCommand;aNumber=%d", aNumber ); |
| 0 | 184 |
C_TRACE((_L("CModemATExt::GetAtCommand(%d)"), aNumber));
|
185 |
const TUint8 **keys = (const TUint8**) atCommands; |
|
186 |
TPtrC8 keyword( aNumber < KMaxCommandCount ? keys[ aNumber ] : keys[ KMaxCommandCount - 1 ] ); |
|
187 |
return keyword; |
|
188 |
} |
|
189 |
||
190 |
CModemATExt* CModemATExt::NewL() |
|
191 |
{
|
|
| 9 | 192 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_NEWL, "CModemATExt::NewL" ); |
| 0 | 193 |
C_TRACE((_L("CModemATExt::NewL")));
|
194 |
CModemATExt* self = new (ELeave) CModemATExt(); |
|
195 |
CleanupStack::PushL(self); |
|
196 |
self->ConstructL(); |
|
197 |
CleanupStack::Pop(self); |
|
198 |
return self; |
|
199 |
} |
|
200 |
||
201 |
CModemATExt::~CModemATExt() |
|
202 |
{
|
|
| 9 | 203 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_CMODEMATEXT, "CModemATExt::~CModemATExt" ); |
| 0 | 204 |
C_TRACE((_L("CModemATExt::~CModemATExt()")));
|
205 |
if (iReplyBuffer) |
|
206 |
{
|
|
207 |
delete iReplyBuffer; |
|
208 |
iReplyBuffer = NULL; |
|
209 |
} |
|
210 |
||
211 |
if(iUnsolicitedBuffer) |
|
212 |
{
|
|
213 |
delete iUnsolicitedBuffer; |
|
214 |
iUnsolicitedBuffer = NULL; |
|
215 |
} |
|
216 |
if( iCommandBuf ) |
|
217 |
{
|
|
218 |
delete iCommandBuf; |
|
219 |
iCommandBuf = NULL; |
|
220 |
} |
|
221 |
iRModemAt.Disconnect(); |
|
222 |
} |
|
223 |
||
224 |
TBool CModemATExt::IsCommandSupported( const TDesC8& aCmd) |
|
225 |
{
|
|
| 9 | 226 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported" ); |
| 0 | 227 |
C_TRACE((_L("CModemATExt::IsCommandSupported")));
|
228 |
DUMP_MESSAGE((aCmd)); |
|
229 |
||
230 |
if(aCmd.Find( KATDCommand )!=KErrNotFound) |
|
231 |
{
|
|
| 9 | 232 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - ATD" ); |
| 0 | 233 |
C_TRACE((_L("ATD")));
|
234 |
return ETrue; |
|
235 |
} |
|
236 |
if(aCmd.Find(KATICommand)!=KErrNotFound) |
|
237 |
{
|
|
| 9 | 238 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - ATI" ); |
| 0 | 239 |
C_TRACE((_L("ATI")));
|
240 |
return ETrue; |
|
241 |
} |
|
242 |
for ( TInt i = 0; i < KMaxCommandCount; i++ ) |
|
243 |
{
|
|
| 9 | 244 |
OstTrace1( TRACE_NORMAL, DUP3_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - round;i=%d", i ); |
| 0 | 245 |
C_TRACE((_L("round %d"),i));
|
246 |
if( GetAtCommand(i).Find(KLastCommand) != KErrNotFound) |
|
247 |
{
|
|
248 |
// All messages have been searched so the command is not supported |
|
| 9 | 249 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - ********* COMMAND IS NOT SUPPORTED ********* " ); |
250 |
OstTraceExt1( TRACE_NORMAL, DUP5_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported;aCmd=%s", aCmd ); |
|
| 0 | 251 |
C_TRACE((_L("********* COMMAND IS NOT SUPPORTED ********* ")));
|
252 |
DUMP_MESSAGE(aCmd); |
|
253 |
return EFalse; |
|
254 |
} |
|
255 |
||
256 |
if(aCmd.Find(GetAtCommand(i))!=KErrNotFound) |
|
257 |
{
|
|
258 |
//just command |
|
| 9 | 259 |
OstTrace1( TRACE_NORMAL, DUP6_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Command;i=%d", i ); |
| 0 | 260 |
C_TRACE((_L("Command"),i));
|
261 |
if(aCmd.Length()==GetAtCommand(i).Length()) |
|
262 |
{
|
|
| 9 | 263 |
OstTrace1( TRACE_NORMAL, DUP7_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Ok;i=%d", i ); |
| 0 | 264 |
C_TRACE((_L("Ok"),i));
|
265 |
return ETrue; |
|
266 |
} |
|
267 |
||
268 |
if(aCmd.Length()>GetAtCommand(i).Length()) //setting command |
|
269 |
{
|
|
| 9 | 270 |
OstTrace0( TRACE_NORMAL, DUP8_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Setting" ); |
| 0 | 271 |
C_TRACE((_L("Setting")));
|
272 |
if( aCmd[GetAtCommand(i).Length()] == '=' || |
|
273 |
aCmd[GetAtCommand(i).Length()] == '?' ) |
|
274 |
{
|
|
| 9 | 275 |
OstTrace1( TRACE_NORMAL, DUP9_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - Ok;i=%d", i ); |
276 |
C_TRACE((_L("Ok"),i));
|
|
| 0 | 277 |
return ETrue; |
278 |
} |
|
279 |
} |
|
280 |
} |
|
281 |
} |
|
| 9 | 282 |
OstTrace0( TRACE_NORMAL, DUP10_CMODEMATEXT_ISCOMMANDSUPPORTED, "CModemATExt::IsCommandSupported - return EFalse" ); |
| 0 | 283 |
C_TRACE((_L("return EFalse")));
|
284 |
return EFalse; |
|
285 |
} |
|
286 |
||
287 |
void CModemATExt::HandleCommand( const TDesC8& aCmd, RBuf8& aReply, TBool aReplyNeeded ) |
|
288 |
{
|
|
| 9 | 289 |
OstTrace1( TRACE_NORMAL, CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand() - is reply needed;aReplyNeeded=%d", aReplyNeeded ); |
290 |
OstTraceExt1( TRACE_NORMAL, DUP1_CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand - dump;aCmd=%s", aCmd ); |
|
291 |
C_TRACE((_L("CModemATExt::HandleCommand() is reply needed: %d" ), aReplyNeeded));
|
|
| 0 | 292 |
DUMP_MESSAGE(aCmd); |
293 |
||
| 9 | 294 |
if( iIsTextInputMode ) |
295 |
{
|
|
296 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand - text mode on" ); |
|
297 |
C_TRACE((_L("CModemATExt::HandleCommand: text mode on") ));
|
|
298 |
AddDataToBuffer( aCmd, aReply ); |
|
299 |
} |
|
300 |
else |
|
301 |
{
|
|
302 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATEXT_HANDLECOMMAND, "CModemATExt::HandleCommand - normal mode on" ); |
|
303 |
C_TRACE((_L("CModemATExt::HandleCommand: normal mode on") ));
|
|
304 |
iReply = &aReply; |
|
305 |
iReplyNeeded = aReplyNeeded; |
|
306 |
if( iCommandBuf ) |
|
307 |
{
|
|
308 |
delete iCommandBuf; |
|
309 |
iCommandBuf = NULL; |
|
310 |
} |
|
311 |
iCommandBuf = HBufC8::New( aCmd.Length() + 1 ); |
|
312 |
TPtr8 ptr = iCommandBuf->Des(); |
|
313 |
ptr.Append( aCmd ); |
|
314 |
ptr.Append( iCarriageReturn ); |
|
315 |
iRModemAt.HandleATCommand( ptr, iReplyPtr ); |
|
316 |
} |
|
| 0 | 317 |
} |
318 |
||
319 |
void CModemATExt::HandleCommandCancel() |
|
320 |
{
|
|
| 9 | 321 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLECOMMANDCANCEL, "CModemATExt::HandleCommandCancel" ); |
| 0 | 322 |
C_TRACE((_L("CModemATExt::HandleCommandCancel()")));
|
323 |
iRModemAt.HandleATCommandCancel(); |
|
324 |
} |
|
325 |
||
326 |
TInt CModemATExt::NextReplyPartLength() |
|
327 |
{
|
|
| 9 | 328 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_NEXTREPLYPARTLENGTH, "CModemATExt::NextReplyPartLength" ); |
| 0 | 329 |
C_TRACE((_L("CModemATExt::NextReplyPartLength()")));
|
330 |
return Min( iReplyPtr.Length(), KPartLength); |
|
331 |
} |
|
332 |
||
333 |
TInt CModemATExt::GetNextPartOfReply( RBuf8& aNextReply ) |
|
334 |
{
|
|
| 9 | 335 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_GETNEXTPARTOFREPLY, "CModemATExt::GetNextPartOfReply" ); |
| 0 | 336 |
C_TRACE((_L("CModemATExt::GetNextPartOfReply()")));
|
337 |
aNextReply.Create(iReplyPtr,KPartLength); |
|
338 |
iReplyPtr.Delete(0,KPartLength); |
|
339 |
return KErrNone; |
|
340 |
} |
|
341 |
||
342 |
void CModemATExt::ReceiveUnsolicitedResult() |
|
343 |
{
|
|
| 9 | 344 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_RECEIVEUNSOLICITEDRESULT, "CModemATExt::ReceiveUnsolicitedResult" ); |
| 0 | 345 |
C_TRACE((_L("CModemATExt::ReceiveUnsolicitedResult()")));
|
| 9 | 346 |
iRModemAt.ReceiveUnsolicitedResult( iUnsolicitedPtr ); |
| 0 | 347 |
} |
348 |
||
349 |
void CModemATExt::ReceiveUnsolicitedResultCancel() |
|
350 |
{
|
|
| 9 | 351 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_RECEIVEUNSOLICITEDRESULTCANCEL, "CModemATExt::ReceiveUnsolicitedResultCancel" ); |
| 0 | 352 |
C_TRACE((_L("CModemATExt::ReceiveUnsolicitedResultCancel")));
|
353 |
iRModemAt.ReceiveUnsolicitedResultCancel(); |
|
354 |
} |
|
355 |
||
356 |
TBool CModemATExt::HandleEditorModeInput( const TDesC8& /*aInput*/, |
|
357 |
RBuf8& /*aReply*/, |
|
358 |
TBool& /*aEchoOn*/) |
|
359 |
{
|
|
| 9 | 360 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLEEDITORMODEINPUT, "CModemATExt::HandleEditorModeInput" ); |
| 0 | 361 |
C_TRACE((_L("CModemATExt::HandleEditorModeInput()")));
|
362 |
return EFalse; //commands are execute commands, this function is newer called |
|
363 |
} |
|
364 |
||
365 |
void CModemATExt::ReportNvramStatusChange( const TDesC8& /*aNvram*/ ) |
|
366 |
{
|
|
| 9 | 367 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_REPORTNVRAMSTATUSCHANGE, "CModemATExt::ReportNvramStatusChange" ); |
| 0 | 368 |
C_TRACE((_L("CModemATExt::ReportNvramStatusChange()")));
|
369 |
//Ignored in this plugin |
|
370 |
} |
|
371 |
||
372 |
||
373 |
CModemATExt::CModemATExt() : |
|
374 |
iReplyBuffer(NULL), |
|
375 |
iReplyPtr(0, 0), |
|
376 |
iUnsolicitedPtr(0, 0), |
|
377 |
iUnsolicitedBuffer(NULL), |
|
378 |
iReply(NULL), |
|
| 9 | 379 |
iReplyNeeded(EFalse), |
380 |
iIsTextInputMode( EFalse ), |
|
381 |
iDiscardNextReply( EFalse ) |
|
| 0 | 382 |
{
|
| 9 | 383 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_CMODEMATEXT, "CModemATExt::CModemATExt" ); |
| 0 | 384 |
C_TRACE((_L("CModemATExt::CModemATExt()")));
|
385 |
} |
|
386 |
||
387 |
void CModemATExt::ConstructL() |
|
388 |
{
|
|
| 9 | 389 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_CONSTRUCTL, "CModemATExt::ConstructL" ); |
| 0 | 390 |
C_TRACE((_L("CModemATExt::ConstructL()")));
|
391 |
iReplyBuffer = HBufC8::NewL( KDefaultCmdBufLength * KPackets ); |
|
392 |
iReplyPtr.Set( iReplyBuffer->Des() ); |
|
| 9 | 393 |
iUnsolicitedBuffer = HBufC8::NewL( KDefaultCmdBufLength ); |
394 |
iUnsolicitedPtr.Set( iUnsolicitedBuffer->Des() ); |
|
| 0 | 395 |
} |
396 |
||
397 |
void CModemATExt::ReportConnectionName( const TDesC8& aName ) |
|
398 |
{
|
|
| 9 | 399 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_REPORTCONNECTIONNAME, "CModemATExt::ReportConnectionName" ); |
| 0 | 400 |
C_TRACE((_L("CModemATExt::ReportConnectionName()")));
|
401 |
DUMP_MESSAGE((aName)); |
|
402 |
iName.Copy(aName); |
|
403 |
iRModemAt.Connect(EATExtPlugin, iName, this); |
|
404 |
} |
|
405 |
||
406 |
void CModemATExt::HandleATCommandCompleted( TInt aErr ) |
|
407 |
{
|
|
| 9 | 408 |
OstTrace1( TRACE_NORMAL, CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted;aErr=%d", aErr ); |
409 |
C_TRACE((_L("CModemATExt::HandleATCommandCompleted( %d )"), aErr));
|
|
410 |
||
411 |
if( !iDiscardNextReply ) |
|
| 0 | 412 |
{
|
| 9 | 413 |
if(iReplyNeeded) |
414 |
{
|
|
415 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - Reply needed" ); |
|
416 |
C_TRACE((_L("Reply needed")));
|
|
417 |
iReply->Create( iReplyPtr,KPartLength ); |
|
418 |
} |
|
419 |
iReplyPtr.Delete(0, KPartLength); |
|
420 |
||
421 |
if( aErr == KErrNone) |
|
422 |
{
|
|
423 |
OstTrace0( TRACE_NORMAL, DUP2_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - No errors" ); |
|
424 |
C_TRACE((_L("No errors")));
|
|
425 |
if( iIsTextInputMode ) |
|
426 |
{
|
|
427 |
iIsTextInputMode = EFalse; |
|
428 |
} |
|
429 |
HandleCommandCompleted( aErr, EReplyTypeOk); |
|
430 |
} |
|
431 |
else if( aErr == KErrGeneral ) |
|
432 |
{
|
|
433 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - Not supported (EReplyTypeUndefined)" ); |
|
434 |
C_TRACE((_L("Not supported (EReplyTypeUndefined)")));
|
|
435 |
if( iIsTextInputMode ) |
|
436 |
{
|
|
437 |
iIsTextInputMode = EFalse; |
|
438 |
} |
|
439 |
HandleCommandCompleted( aErr, EReplyTypeUndefined ); |
|
440 |
} |
|
441 |
else if( aErr == KReplyTypeOther ) |
|
442 |
{
|
|
443 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - No errors (EReplyTypeOther)" ); |
|
444 |
C_TRACE((_L("No errors (EReplyTypeOther)")));
|
|
445 |
if( iIsTextInputMode ) |
|
446 |
{
|
|
447 |
iIsTextInputMode = EFalse; |
|
448 |
} |
|
449 |
HandleCommandCompleted( KErrNone, EReplyTypeOther); |
|
450 |
} |
|
451 |
else if( aErr == KReplyTypeEditorStart ) |
|
452 |
{
|
|
453 |
OstTrace0( TRACE_NORMAL, DUP5_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - EReplyTypeEditorStart" ); |
|
454 |
C_TRACE((_L("EReplyTypeEditorStart")));
|
|
455 |
if( !iIsTextInputMode ) |
|
456 |
{
|
|
457 |
iIsTextInputMode = ETrue; |
|
458 |
HandleCommandCompleted( KErrNone, static_cast<TATExtensionReplyType>( KReplyTypeEditor ) ); |
|
459 |
} |
|
460 |
} |
|
461 |
else if( aErr == KReplyTypeEditorEnd ) |
|
462 |
{
|
|
463 |
OstTrace0( TRACE_NORMAL, DUP6_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - EReplyTypeEditorEnd" ); |
|
464 |
C_TRACE((_L("EReplyTypeEditorEnd")));
|
|
465 |
iIsTextInputMode = EFalse; |
|
466 |
HandleCommandCompleted( KErrNone, EReplyTypeOk); |
|
467 |
} |
|
468 |
else |
|
469 |
{
|
|
470 |
OstTrace0( TRACE_NORMAL, DUP7_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - Reply Error" ); |
|
471 |
C_TRACE((_L("Reply Error")));
|
|
472 |
if( iIsTextInputMode ) |
|
473 |
{
|
|
474 |
iIsTextInputMode = EFalse; |
|
475 |
} |
|
476 |
HandleCommandCompleted( aErr, EReplyTypeError ); |
|
477 |
} |
|
| 0 | 478 |
} |
| 9 | 479 |
else |
| 0 | 480 |
{
|
| 9 | 481 |
OstTrace0( TRACE_NORMAL, DUP8_CMODEMATEXT_HANDLEATCOMMANDCOMPLETED, "CModemATExt::HandleATCommandCompleted - reply discarded" ); |
482 |
C_TRACE((_L("CModemATExt::HandleATCommandCompleted: reply discarded")));
|
|
483 |
iDiscardNextReply = EFalse; |
|
| 0 | 484 |
} |
485 |
} |
|
486 |
||
| 9 | 487 |
void CModemATExt::HandleUnsolicitedResultReceived( TInt aErr ) |
| 0 | 488 |
{
|
| 9 | 489 |
OstTrace1( TRACE_NORMAL, CMODEMATEXT_HANDLEUNSOLICITEDRESULTRECEIVED, "CModemATExt::HandleUnsolicitedResultReceived;aErr=%d", aErr ); |
490 |
C_TRACE((_L("CModemATExt::HandleUnsolicitedResultReceived > ( %d )"), aErr));
|
|
491 |
if( KErrNone == aErr ) |
|
492 |
{
|
|
493 |
SendUnsolicitedResult( iUnsolicitedPtr ); |
|
494 |
TInt length = iUnsolicitedPtr.Length(); |
|
495 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATEXT_HANDLEUNSOLICITEDRESULTRECEIVED, "CModemATExt::HandleUnsolicitedResultReceived - reply discarded;length=%d", length ); |
|
496 |
C_TRACE((_L("clear unsolicited data buffer, length %d"), length));
|
|
497 |
iUnsolicitedPtr.Delete( 0, length ); |
|
498 |
} |
|
499 |
C_TRACE((_L("CModemATExt::HandleUnsolicitedResultReceived <")));
|
|
| 0 | 500 |
} |
501 |
||
502 |
void CModemATExt::HandleSignalIndication( TInt /*aErr*/ ) |
|
503 |
{
|
|
| 9 | 504 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLESIGNALINDICATION, "CModemATExt::HandleSignalIndication" ); |
| 0 | 505 |
C_TRACE((_L("CModemATExt::HandleSignalIndication")));
|
506 |
//COMMON plugin handles signal indications |
|
507 |
} |
|
508 |
||
509 |
void CModemATExt::ReportExternalHandleCommandError() |
|
510 |
{
|
|
| 9 | 511 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_REPORTEXTERNALHANDLECOMMANDERROR, "CModemATExt::ReportExternalHandleCommandError" ); |
| 0 | 512 |
C_TRACE((_L("CModemATExt::ReportExternalHandleCommandError()")));
|
513 |
//external error occurred, cancel AT-command |
|
514 |
iRModemAt.HandleATCommandCancel(); |
|
515 |
} |
|
516 |
||
517 |
void CModemATExt::HandleCommandModeChanged( TInt /*aErr*/, TCommandMode /*aMode*/ ) |
|
518 |
{
|
|
| 9 | 519 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_HANDLECOMMANDMODECHANGED, "CModemATExt::HandleCommandModeChanged" ); |
| 0 | 520 |
C_TRACE((_L("CModemATExt::HandleCommandModeChanged()")));
|
521 |
//COMMON plugin handles mode change requests |
|
522 |
} |
|
| 9 | 523 |
|
524 |
void CModemATExt::AddDataToBuffer( |
|
525 |
const TDesC8& aCmd, |
|
526 |
RBuf8& aReply ) |
|
527 |
{
|
|
528 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer" ); |
|
529 |
C_TRACE((_L("CModemATExt::AddDataToBuffer()")));
|
|
530 |
||
531 |
TBool bufferingCanEnd( EFalse ); |
|
532 |
TBool bufferExceeded( EFalse ); |
|
533 |
||
534 |
TInt offsetEscChar = aCmd.Locate( KEscChar ); |
|
535 |
TInt offsetCtrlZChar = aCmd.Locate( KCtrlZChar ); |
|
536 |
OstTrace1( TRACE_NORMAL, DUP1_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: offsetEscChar: %d", offsetEscChar ); |
|
537 |
OstTrace1( TRACE_NORMAL, DUP2_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: offsetCtrlZChar: %d", offsetCtrlZChar ); |
|
538 |
C_TRACE(( _L("CModemATExt::AddDataToBuffer: offsets: esc: %d, ctrl-z: %d"), offsetEscChar, offsetCtrlZChar ));
|
|
539 |
||
540 |
if( KErrNotFound != offsetEscChar || |
|
541 |
KErrNotFound != offsetCtrlZChar ) |
|
542 |
{
|
|
543 |
OstTrace0( TRACE_NORMAL, DUP3_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - end char detected" ); |
|
544 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: end char detected") ));
|
|
545 |
bufferingCanEnd = ETrue; |
|
546 |
} |
|
547 |
||
548 |
if( KMaxSmsBufferSize < ( aCmd.Length() + iSmsBuffer.Length() ) ) |
|
549 |
{
|
|
550 |
if( bufferingCanEnd ) |
|
551 |
{
|
|
552 |
TInt offset = 0; |
|
553 |
if( KErrNotFound != offsetEscChar ) |
|
554 |
{
|
|
555 |
OstTrace0( TRACE_NORMAL, DUP4_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: (truncated, esc)" ); |
|
556 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: buffering data (truncated) (esc char detected)") ));
|
|
557 |
offset = offsetEscChar + 1; |
|
558 |
} |
|
559 |
else |
|
560 |
{
|
|
561 |
OstTrace0( TRACE_NORMAL, DUP5_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: (truncated, ctrl-z)" ); |
|
562 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: buffering data (truncated) (ctrl-z detected)") ));
|
|
563 |
offset = offsetCtrlZChar + 1; |
|
564 |
} |
|
565 |
TInt smsBufferSize = iSmsBuffer.Length() + aCmd.Mid( 0, offset ).Length(); |
|
566 |
OstTrace1( TRACE_NORMAL, DUP6_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer: current + received: %d", smsBufferSize ); |
|
567 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: current + received buffer length: %d"), smsBufferSize ));
|
|
568 |
if( KMaxSmsBufferSize >= smsBufferSize ) |
|
569 |
{
|
|
570 |
iSmsBuffer.Append( aCmd.Mid( 0, offset ) ); |
|
571 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: sending data (end char detected)") ));
|
|
572 |
SendSmsBuffer( aReply, ETrue, EFalse ); |
|
573 |
} |
|
574 |
else |
|
575 |
{
|
|
576 |
bufferExceeded = ETrue; |
|
577 |
} |
|
578 |
} |
|
579 |
||
580 |
if( !bufferingCanEnd || |
|
581 |
bufferExceeded ) |
|
582 |
{
|
|
583 |
OstTrace0( TRACE_NORMAL, DUP7_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - too big data or esc" ); |
|
584 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: data is too big to buffer or esc char detected") ));
|
|
585 |
||
586 |
iDiscardNextReply = ETrue; |
|
587 |
iIsTextInputMode = EFalse; |
|
588 |
||
589 |
SendSmsBuffer( aReply, EFalse, ETrue ); |
|
590 |
||
591 |
TBuf8<KErrorSize> reply; |
|
592 |
reply.Append( iCarriageReturn ); |
|
593 |
reply.Append( iLineFeed ); |
|
594 |
reply.Append( _L( "ERROR" ) ); |
|
595 |
reply.Append( iCarriageReturn ); |
|
596 |
reply.Append( iLineFeed ); |
|
597 |
||
598 |
aReply.Create( reply, reply.Length() ); |
|
599 |
HandleCommandCompleted( KErrNone, EReplyTypeOk ); |
|
600 |
} |
|
601 |
} |
|
602 |
else |
|
603 |
{
|
|
604 |
OstTrace0( TRACE_NORMAL, DUP8_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - buffering data" ); |
|
605 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: buffering data") ));
|
|
606 |
iSmsBuffer.Append( aCmd ); |
|
607 |
if( bufferingCanEnd ) |
|
608 |
{
|
|
609 |
OstTrace0( TRACE_NORMAL, DUP9_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - sending data in text mode" ); |
|
610 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: sending data in text mode") ));
|
|
611 |
SendSmsBuffer( aReply, ETrue, EFalse ); |
|
612 |
} |
|
613 |
else |
|
614 |
{
|
|
615 |
OstTrace0( TRACE_NORMAL, DUP10_CMODEMATEXT_ADDDATATOBUFFER, "CModemATExt::AddDataToBuffer - data is not sent yet, completing request" ); |
|
616 |
C_TRACE((_L("CModemATExt::AddDataToBuffer: data is not sent yet, let's complete request") ));
|
|
617 |
HandleCommandCompleted( KErrNone, static_cast<TATExtensionReplyType>( KReplyTypeEditor ) ); |
|
618 |
} |
|
619 |
} |
|
620 |
} |
|
621 |
||
622 |
void CModemATExt::SendSmsBuffer( |
|
623 |
RBuf8& aReply, |
|
624 |
TBool aReplyNeeded, |
|
625 |
TBool aCancel ) |
|
626 |
{
|
|
627 |
OstTrace0( TRACE_NORMAL, CMODEMATEXT_SENDSMSBUFFER, "CModemATExt::SendSmsBuffer()" ); |
|
628 |
C_TRACE((_L("CModemATExt::SendSmsBuffer() replyNeeded: %d, cancel: %d"), (TInt) aReplyNeeded, (TInt) aCancel ));
|
|
629 |
iReply = &aReply; |
|
630 |
iReplyNeeded = aReplyNeeded; |
|
631 |
if( iCommandBuf ) |
|
632 |
{
|
|
633 |
delete iCommandBuf; |
|
634 |
iCommandBuf = NULL; |
|
635 |
} |
|
636 |
if( !aCancel ) |
|
637 |
{
|
|
638 |
iCommandBuf = HBufC8::New( iSmsBuffer.Length() + 1 ); |
|
639 |
TPtr8 ptr = iCommandBuf->Des(); |
|
640 |
ptr.Append( iSmsBuffer ); |
|
641 |
ptr.Append( iCarriageReturn ); |
|
642 |
iRModemAt.HandleATCommand( ptr, iReplyPtr ); |
|
643 |
} |
|
644 |
else |
|
645 |
{
|
|
646 |
iCommandBuf = HBufC8::New( KEscDataSize ); |
|
647 |
TPtr8 ptr = iCommandBuf->Des(); |
|
648 |
ptr.Append( KEscChar ); |
|
649 |
ptr.Append( iCarriageReturn ); |
|
650 |
iRModemAt.HandleATCommand( ptr, iReplyPtr ); |
|
651 |
} |
|
652 |
iSmsBuffer.Zero(); |
|
653 |
OstTrace0( TRACE_NORMAL, DUP1_CMODEMATEXT_SENDSMSBUFFER, "CModemATExt::SendSmsBuffer() done" ); |
|
654 |
} |
|
655 |
||
656 |
// End of File |
|
657 |