|
1 /* |
|
2 * |
|
3 * Copyright (c) <2010> Comarch S.A. and/or its subsidiary(-ies). |
|
4 * All rights reserved. |
|
5 * This component and the accompanying materials are made available |
|
6 * under the terms of the License "Eclipse Public License v1.0" |
|
7 * which accompanies this distribution, and is available |
|
8 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
9 * |
|
10 * Original Contributors: |
|
11 * Comarch S.A. - original contribution. |
|
12 * |
|
13 * Contributors: |
|
14 * |
|
15 * Description: |
|
16 * |
|
17 */ |
|
18 |
|
19 #include <badesca.h> |
|
20 |
|
21 #include "hspcommandparser.h" |
|
22 #include "debug.h" |
|
23 |
|
24 CHsHSPParser* CHsHSPParser::NewL() |
|
25 { |
|
26 CHsHSPParser *self = CHsHSPParser::NewLC(); |
|
27 CleanupStack::Pop( self ); |
|
28 |
|
29 return self; |
|
30 } |
|
31 |
|
32 CHsHSPParser* CHsHSPParser::NewLC() |
|
33 { |
|
34 |
|
35 CHsHSPParser *self = new ( ELeave ) CHsHSPParser(); |
|
36 CleanupStack::PushL( self ); |
|
37 self->ConstructL(); |
|
38 return self; |
|
39 } |
|
40 |
|
41 CHsHSPParser::~CHsHSPParser() |
|
42 { |
|
43 |
|
44 } |
|
45 |
|
46 void CHsHSPParser::ParseL( const TDesC8& aBufCommand, const TBool aFromAG, |
|
47 CHsHSPCommand& aCommand ) |
|
48 { |
|
49 TRACE_FUNC_ENTRY |
|
50 |
|
51 aCommand.SetSource( aFromAG ); |
|
52 |
|
53 THsHSPCommandType type = EHSPCmdUnknown; |
|
54 |
|
55 type = RetrieveTypeL( aBufCommand ); |
|
56 |
|
57 User::LeaveIfError( aCommand.SetType( type ) ); |
|
58 |
|
59 if ( type == EHSPCmdOK || type == EHSPCmdERROR || type == EHSPCmdRING ) |
|
60 { |
|
61 User::LeaveIfError( aCommand.SetMode( ECmdModeNormal ) ); |
|
62 RATParamArray params( 1 ); |
|
63 User::LeaveIfError( aCommand.SetParams( params ) ); |
|
64 |
|
65 } |
|
66 else |
|
67 { |
|
68 THsHSPCommandMode mode = ECmdUnknownMode; |
|
69 mode = RetrieveModeL( aBufCommand, aFromAG ); |
|
70 User::LeaveIfError( aCommand.SetMode( mode ) ); |
|
71 |
|
72 RATParamArray params( 4 ); |
|
73 |
|
74 RetrieveParamsL( aBufCommand, mode, params ); |
|
75 User::LeaveIfError( aCommand.SetParams( params ) ); |
|
76 |
|
77 } |
|
78 |
|
79 TRACE_FUNC_EXIT |
|
80 |
|
81 } |
|
82 |
|
83 CHsHSPParser::CHsHSPParser() |
|
84 { |
|
85 |
|
86 } |
|
87 |
|
88 void CHsHSPParser::ConstructL() |
|
89 { |
|
90 |
|
91 } |
|
92 |
|
93 THsHSPCommandMode CHsHSPParser::RetrieveModeL( const TDesC8 &aCommand, |
|
94 const TBool aFromAG ) |
|
95 { |
|
96 TRACE_FUNC_ENTRY |
|
97 |
|
98 THsHSPCommandMode res = ECmdUnknownMode; |
|
99 |
|
100 if ( aFromAG ) |
|
101 { |
|
102 if ( aCommand.Find( KHsHSPATTestModeDesAG ) != KErrNotFound ) |
|
103 { |
|
104 res = ECmdModeTest; |
|
105 } |
|
106 else if ( aCommand.Find( KHsHSPATReadModeDesAG ) != KErrNotFound ) |
|
107 { |
|
108 res = ECmdModeRead; |
|
109 } |
|
110 else if ( aCommand.Find( KHsHSPATWriteModeDesAG ) != KErrNotFound ) |
|
111 { |
|
112 res = ECmdModeWrite; |
|
113 } |
|
114 |
|
115 } |
|
116 else |
|
117 { |
|
118 if ( aCommand.Find( KHsHSPATTestModeDes ) != KErrNotFound ) |
|
119 { |
|
120 res = ECmdModeTest; |
|
121 } |
|
122 else if ( aCommand.Find( KHsHSPATReadModeDes ) != KErrNotFound ) |
|
123 { |
|
124 res = ECmdModeRead; |
|
125 } |
|
126 else if ( aCommand.Find( KHsHSPATWriteModeDes ) != KErrNotFound ) |
|
127 { |
|
128 res = ECmdModeWrite; |
|
129 } |
|
130 |
|
131 } |
|
132 |
|
133 if ( res == ECmdUnknownMode ) |
|
134 { |
|
135 |
|
136 User::Leave( KErrArgument ); |
|
137 } |
|
138 TRACE_FUNC_EXIT |
|
139 return res; |
|
140 |
|
141 } |
|
142 |
|
143 THsHSPCommandType CHsHSPParser::RetrieveTypeL( const TDesC8 &aCommand ) |
|
144 { |
|
145 TRACE_FUNC_ENTRY |
|
146 THsHSPCommandType res = EHSPCmdUnknown; |
|
147 if ( aCommand.Find( KHsHSPOKCommand ) != KErrNotFound ) |
|
148 { |
|
149 res = EHSPCmdOK; |
|
150 } |
|
151 else if ( aCommand.Find( KHsHSPERRORCommand ) != KErrNotFound ) |
|
152 { |
|
153 res = EHSPCmdERROR; |
|
154 } |
|
155 else if ( aCommand.Find( KHsHSPRINGCommand ) != KErrNotFound ) |
|
156 { |
|
157 res = EHSPCmdRING; |
|
158 } |
|
159 else if ( aCommand.Find( KHsHSPVGSCommand ) != KErrNotFound ) |
|
160 { |
|
161 res = EHSPCmdVGS; |
|
162 } |
|
163 else if ( aCommand.Find( KHsHSPVGMCommand ) != KErrNotFound ) |
|
164 { |
|
165 res = EHSPCmdVGM; |
|
166 } |
|
167 else if ( aCommand.Find( KHsHSPCKPDCommand ) != KErrNotFound ) |
|
168 { |
|
169 res = EHSPCmdCKPD; |
|
170 } |
|
171 |
|
172 if ( res == EHSPCmdUnknown ) |
|
173 User::Leave( KErrArgument ); |
|
174 |
|
175 TRACE_FUNC_EXIT |
|
176 return res; |
|
177 } |
|
178 |
|
179 void CHsHSPParser::RetrieveParamsL( const TDesC8 &aCommand, |
|
180 const THsHSPCommandMode aCmdMode, RATParamArray& aParams ) |
|
181 { |
|
182 TRACE_FUNC_ENTRY |
|
183 |
|
184 RBuf8 buf; |
|
185 buf.CreateL( aCommand ); |
|
186 buf.CleanupClosePushL(); |
|
187 |
|
188 TInt prefixLength = 0; |
|
189 TInt suffixLength = 0; |
|
190 |
|
191 TInt modeLength = 0; |
|
192 |
|
193 TInt leftOffset = 0; |
|
194 TInt rightOffset = 0; |
|
195 |
|
196 TInt startPos = 0; |
|
197 TBool indicatorsFound = EFalse; |
|
198 |
|
199 if ( buf.Find( KHsHSPIndicatorParamsSeparator ) != KErrNotFound ) |
|
200 { |
|
201 indicatorsFound = ETrue; |
|
202 } |
|
203 |
|
204 if ( indicatorsFound ) |
|
205 { |
|
206 prefixLength = 9; |
|
207 suffixLength = 2; |
|
208 rightOffset = 2; |
|
209 leftOffset = 1; |
|
210 } |
|
211 else |
|
212 { |
|
213 |
|
214 rightOffset = 1; |
|
215 suffixLength = 2; |
|
216 |
|
217 switch ( aCmdMode ) |
|
218 |
|
219 { |
|
220 case ECmdModeTest: |
|
221 { |
|
222 startPos = buf.Find( KHsHSPATTestModeDes ); |
|
223 modeLength = 2; |
|
224 } |
|
225 break; |
|
226 case ECmdModeRead: |
|
227 { |
|
228 startPos = buf.Find( KHsHSPATReadModeDes ); |
|
229 modeLength = 1; |
|
230 } |
|
231 break; |
|
232 case ECmdModeWrite: |
|
233 { |
|
234 startPos = buf.Find( KHsHSPATWriteModeDes ); |
|
235 modeLength = 1; |
|
236 |
|
237 if ( startPos == KErrNotFound ) |
|
238 { |
|
239 startPos = buf.Find( KHsHSPATWriteModeDesAG ); |
|
240 modeLength = 2; |
|
241 } |
|
242 |
|
243 } |
|
244 break; |
|
245 default: |
|
246 |
|
247 User::Leave( KErrArgument ); |
|
248 break; |
|
249 } |
|
250 } |
|
251 |
|
252 if ( startPos != KErrNotFound ) |
|
253 { |
|
254 //strip command's prefix |
|
255 buf.Delete( 0, prefixLength + startPos + modeLength ); |
|
256 |
|
257 //strip command's suffix |
|
258 buf.Delete( buf.Length() - suffixLength, suffixLength ); |
|
259 } |
|
260 else |
|
261 User::Leave( KErrArgument ); |
|
262 |
|
263 while ( buf.Size() > 0 ) |
|
264 { |
|
265 TInt pos = 0; |
|
266 |
|
267 if ( indicatorsFound ) |
|
268 { |
|
269 pos = buf.Find( KHsHSPIndicatorParamsSeparator ); |
|
270 } |
|
271 else |
|
272 { |
|
273 pos = buf.Find( KHsHSPParamsSeparator ); |
|
274 } |
|
275 |
|
276 if ( pos == KErrNotFound ) |
|
277 { |
|
278 aParams.AppendL( buf ); |
|
279 buf.Zero(); |
|
280 |
|
281 } |
|
282 else |
|
283 { |
|
284 TPtrC8 ptr = ( buf.Left( pos + leftOffset ) ); |
|
285 aParams.AppendL( ptr ); |
|
286 buf.Delete( 0, pos + rightOffset ); |
|
287 } |
|
288 } |
|
289 |
|
290 CleanupStack::PopAndDestroy( &buf ); |
|
291 TRACE_FUNC_EXIT |
|
292 } |
|
293 |