|
1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 |
|
17 #include "lbsnetworkgatewayhandler.h" |
|
18 #include "lbsassistancedatacacheapi.h" |
|
19 #include <lbs/lbsassistancealmanac.h> |
|
20 #include <lbs/lbsassistancebadsatlist.h> |
|
21 #include <lbs/lbsassistanceaquisitionassistance.h> |
|
22 #include <lbs/lbsassistancenavigationmodel.h> |
|
23 #include <lbs/lbsassistancereferencetime.h> |
|
24 #include <lbs/lbsassistanceionosphericmodel.h> |
|
25 #include <lbs/lbsassistanceutcmodel.h> |
|
26 #include <lbs/lbsassistancereferencelocation.h> |
|
27 #include "lbscommoninternaldatatypes.h" |
|
28 #include "lbsagpsngmsgs.h" |
|
29 #include "lbsdevloggermacros.h" |
|
30 #include <lbs/lbslocerrors.h> |
|
31 |
|
32 |
|
33 // We can queue up to 4 messages |
|
34 const TInt KNetworkGatewayHandlerQSize = 4; |
|
35 |
|
36 |
|
37 CNetworkGatewayHandler * CNetworkGatewayHandler::NewL |
|
38 ( |
|
39 MNetworkGatewayHandlerObserver* aObserver |
|
40 ) |
|
41 { |
|
42 LBSLOG(ELogP1, "CNetworkGatewayHandler::NewL()"); |
|
43 CNetworkGatewayHandler * self = new(ELeave) CNetworkGatewayHandler (aObserver); |
|
44 CleanupStack::PushL(self); |
|
45 self->ConstructL(); |
|
46 CleanupStack::Pop(); |
|
47 return self; |
|
48 } |
|
49 |
|
50 CNetworkGatewayHandler::CNetworkGatewayHandler(MNetworkGatewayHandlerObserver* aObserver) : |
|
51 CActive(EPriorityStandard), |
|
52 iObserver(aObserver), |
|
53 iQ(KNetworkGatewayHandlerQSize) |
|
54 { |
|
55 LBSLOG(ELogP1, "CNetworkGatewayHandler::CNetworkGatewayHandler()"); |
|
56 } |
|
57 |
|
58 void CNetworkGatewayHandler::ConstructL() |
|
59 { |
|
60 LBSLOG(ELogP1, "CNetworkGatewayHandler::ConstructL()"); |
|
61 CActiveScheduler::Add(this); |
|
62 iAssistanceDataCache.OpenL(); |
|
63 iNGChannel.OpenL(RLbsNetChannel::EChannelAGPS2NG, *this); |
|
64 iQ.OpenL(); |
|
65 } |
|
66 |
|
67 //------------------------------------------------------------------------------------------------------------ |
|
68 CNetworkGatewayHandler::~CNetworkGatewayHandler() |
|
69 { |
|
70 LBSLOG(ELogP1, "CNetworkGatewayHandler::~CNetworkGatewayHandler()"); |
|
71 iAssistanceDataCache.Close(); |
|
72 iNGChannel.Close(); |
|
73 iQ.Close(); |
|
74 } |
|
75 |
|
76 // request from integration module to read a particular assistance data item |
|
77 TInt CNetworkGatewayHandler::GetAssistanceDataItem(TLbsAssistanceDataItem aItem,RDataReaderRootBase& aDataRoot, TTime& aTimeStamp) |
|
78 { |
|
79 LBSLOG(ELogP1, "CNetworkGatewayHandler::GetAssistanceDataItem()"); |
|
80 TInt error = iAssistanceDataCache.GetAssistDataItem(aItem,aDataRoot); |
|
81 if (KErrNone == error) |
|
82 { |
|
83 TBool dataAvailable = EFalse; |
|
84 switch(aItem) |
|
85 { |
|
86 case EAssistanceDataAquisitionAssistance: |
|
87 dataAvailable = reinterpret_cast<RUEPositioningGpsAcquisitionAssistanceReader*>(&aDataRoot)->IsDataAvailable(); |
|
88 break; |
|
89 case EAssistanceDataBadSatList: |
|
90 dataAvailable = reinterpret_cast<RBadSatListReader*>(&aDataRoot)->IsDataAvailable(); |
|
91 break; |
|
92 case EAssistanceDataNavigationModel: |
|
93 dataAvailable = reinterpret_cast<RUEPositioningGpsNavigationModelReader*>(&aDataRoot)->IsDataAvailable(); |
|
94 break; |
|
95 case EAssistanceDataReferenceTime: |
|
96 dataAvailable = reinterpret_cast<RUEPositioningGpsReferenceTimeReader*>(&aDataRoot)->IsDataAvailable(); |
|
97 break; |
|
98 case EAssistanceDataIonosphericModel: |
|
99 dataAvailable = reinterpret_cast<RUEPositioningGpsIonosphericModelReader*>(&aDataRoot)->IsDataAvailable(); |
|
100 break; |
|
101 case EAssistanceDataReferenceLocation: |
|
102 dataAvailable = reinterpret_cast<RReferenceLocationReader*>(&aDataRoot)->IsDataAvailable(); |
|
103 break; |
|
104 case EAssistanceDataAlmanac: |
|
105 dataAvailable = reinterpret_cast<RUEPositioningGpsAlmanacReader*>(&aDataRoot)->IsDataAvailable(); |
|
106 break; |
|
107 case EAssistanceDataPositioningGpsUtcModel: |
|
108 dataAvailable = reinterpret_cast<RUEPositioningGpsUtcModelReader*>(&aDataRoot)->IsDataAvailable(); |
|
109 break; |
|
110 default: |
|
111 //Intentionally empty. dataAvailable remains EFalse. |
|
112 break; |
|
113 } |
|
114 |
|
115 if (!dataAvailable) |
|
116 { |
|
117 error = KErrNotFound; |
|
118 } |
|
119 else |
|
120 { |
|
121 aTimeStamp = aDataRoot.TimeStamp(); |
|
122 } |
|
123 } |
|
124 return error; |
|
125 } |
|
126 |
|
127 // request from integration module to read a particular assistance data item time stamp only |
|
128 TInt CNetworkGatewayHandler::GetAssistanceDataItemTimeStamp(TLbsAssistanceDataItem aItem, TTime& aTimeStamp) |
|
129 { |
|
130 LBSLOG(ELogP1, "CNetworkGatewayHandler::GetAssistanceDataItemTimeStamp()"); |
|
131 TInt error = KErrNone; |
|
132 TTime timeStamp; |
|
133 |
|
134 switch(aItem) |
|
135 { |
|
136 case EAssistanceDataAquisitionAssistance: |
|
137 { |
|
138 RUEPositioningGpsAcquisitionAssistanceReader reader; |
|
139 TRAP(error, reader.OpenL()); |
|
140 if (KErrNone == error) |
|
141 { |
|
142 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
143 reader.Close(); |
|
144 } |
|
145 break; |
|
146 } |
|
147 case EAssistanceDataBadSatList: |
|
148 { |
|
149 RBadSatListReader reader; |
|
150 TRAP(error, reader.OpenL()); |
|
151 if (KErrNone == error) |
|
152 { |
|
153 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
154 reader.Close(); |
|
155 } |
|
156 break; |
|
157 } |
|
158 case EAssistanceDataNavigationModel: |
|
159 { |
|
160 RUEPositioningGpsNavigationModelReader reader; |
|
161 TRAP(error, reader.OpenL()); |
|
162 if (KErrNone == error) |
|
163 { |
|
164 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
165 reader.Close(); |
|
166 } |
|
167 break; |
|
168 } |
|
169 case EAssistanceDataReferenceTime: |
|
170 { |
|
171 RUEPositioningGpsReferenceTimeReader reader; |
|
172 TRAP(error, reader.OpenL()); |
|
173 if (KErrNone == error) |
|
174 { |
|
175 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
176 reader.Close(); |
|
177 } |
|
178 break; |
|
179 } |
|
180 case EAssistanceDataIonosphericModel: |
|
181 { |
|
182 RUEPositioningGpsIonosphericModelReader reader; |
|
183 TRAP(error, reader.OpenL()); |
|
184 if (KErrNone == error) |
|
185 { |
|
186 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
187 reader.Close(); |
|
188 } |
|
189 break; |
|
190 } |
|
191 case EAssistanceDataReferenceLocation: |
|
192 { |
|
193 RReferenceLocationReader reader; |
|
194 TRAP(error, reader.OpenL()); |
|
195 if (KErrNone == error) |
|
196 { |
|
197 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
198 reader.Close(); |
|
199 } |
|
200 break; |
|
201 } |
|
202 case EAssistanceDataAlmanac: |
|
203 { |
|
204 RUEPositioningGpsAlmanacReader reader; |
|
205 TRAP(error, reader.OpenL()); |
|
206 if (KErrNone == error) |
|
207 { |
|
208 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
209 reader.Close(); |
|
210 } |
|
211 break; |
|
212 } |
|
213 case EAssistanceDataPositioningGpsUtcModel: |
|
214 { |
|
215 RUEPositioningGpsUtcModelReader reader; |
|
216 TRAP(error, reader.OpenL()); |
|
217 if (KErrNone == error) |
|
218 { |
|
219 error = GetAssistanceDataItem(aItem, reader, timeStamp); |
|
220 reader.Close(); |
|
221 } |
|
222 break; |
|
223 } |
|
224 default: |
|
225 { |
|
226 error = KErrNotFound; |
|
227 break; |
|
228 } |
|
229 } |
|
230 |
|
231 if (KErrNone == error) |
|
232 { |
|
233 aTimeStamp = timeStamp; |
|
234 } |
|
235 |
|
236 return error; |
|
237 } |
|
238 |
|
239 |
|
240 // request from integration module to request a new set of assistance data from network |
|
241 void CNetworkGatewayHandler::SendAssistanceDataRequest(TLbsAsistanceDataGroup aDataItemMask) |
|
242 { |
|
243 LBSLOG(ELogP1, "CNetworkGatewayHandler::SendAssistanceDataRequest()"); |
|
244 TLbsNetAssistanceDataRequestMsg msg(aDataItemMask); |
|
245 SendOrQueueMessage(msg); |
|
246 } |
|
247 |
|
248 void CNetworkGatewayHandler::SendSelfLocationRequest(const TLbsNetSessionIdInt& aSessionId, |
|
249 const TLbsNetPosRequestOptionsAssistanceInt& aOptions) |
|
250 { |
|
251 LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSelfLocationRequest()"); |
|
252 TLbsNetSelfLocationRequestMsg msg(aSessionId, aOptions); |
|
253 SendOrQueueMessage(msg); |
|
254 } |
|
255 |
|
256 void CNetworkGatewayHandler::SendSelfLocationCancel(const TLbsNetSessionIdInt& aSessionId, TInt aReason) |
|
257 { |
|
258 LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSelfLocationCancel()"); |
|
259 TLbsNetSelfLocationCancelMsg msg(aSessionId, aReason); |
|
260 SendOrQueueMessage(msg); |
|
261 } |
|
262 |
|
263 void CNetworkGatewayHandler::SendSystemStatusAdvice(TBool aTracking) |
|
264 { |
|
265 LBSLOG(ELogP1, "CNetworkGatewayHandler::SendSystemStatusAdvice()"); |
|
266 TLbsNetSystemStatusAdviceMsg msg(aTracking); |
|
267 SendOrQueueMessage(msg); |
|
268 } |
|
269 |
|
270 void CNetworkGatewayHandler::RunL() |
|
271 { |
|
272 LBSLOG2(ELogP1, "CNetworkGatewayHandler::RunL() Begin. Status: %d\n", iStatus.Int()); |
|
273 __ASSERT_DEBUG(iStatus.Int() == KErrNone, User::Panic(KLbsAGPSManFault, iStatus.Int())); |
|
274 |
|
275 // Check if more queued messages await sending |
|
276 if (!iQ.IsEmpty()) |
|
277 { |
|
278 iNGChannel.SendMessage(iQ.Read(), iStatus); |
|
279 SetActive(); |
|
280 } |
|
281 LBSLOG(ELogP1, "CNetworkGatewayHandler::RunL() End\n"); |
|
282 } |
|
283 |
|
284 void CNetworkGatewayHandler::DoCancel() |
|
285 { |
|
286 LBSLOG(ELogP1, "CNetworkGatewayHandler::DoCancel()"); |
|
287 iNGChannel.CancelSendMessageNotification(); |
|
288 } |
|
289 |
|
290 TInt CNetworkGatewayHandler::RunError(TInt aError) |
|
291 { |
|
292 LBSLOG(ELogP1, "CNetworkGatewayHandler::RunError()\n"); |
|
293 LBSLOG_ERR2(ELogP2, " %d \n", aError); |
|
294 return aError; |
|
295 } |
|
296 |
|
297 void CNetworkGatewayHandler::SendOrQueueMessage(TLbsNetInternalMsgBase& aMsg) |
|
298 { |
|
299 LBSLOG(ELogP1, "CNetworkGatewayHandler::SendOrQueueMessage()\n"); |
|
300 if (!IsActive()) |
|
301 { |
|
302 iNGChannel.SendMessage(aMsg, iStatus); |
|
303 SetActive(); |
|
304 } |
|
305 else |
|
306 { |
|
307 QueueMessage(aMsg); |
|
308 } |
|
309 } |
|
310 /** |
|
311 Queues messages. |
|
312 Performs implicit cancels if the queue not empty. |
|
313 Supports only one self location session at a time. |
|
314 */ |
|
315 void CNetworkGatewayHandler::QueueMessage(TLbsNetInternalMsgBase& aMsg) |
|
316 { |
|
317 LBSLOG(ELogP1, "CNetworkGatewayHandler::QueueMessage()\n"); |
|
318 TBool removed; |
|
319 |
|
320 switch (aMsg.Type()) |
|
321 { |
|
322 case TLbsNetInternalMsgBase::ESelfLocationRequest: |
|
323 // A new request implicitly cancels a previous request and/or cancel |
|
324 iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationRequest); |
|
325 iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationCancel); |
|
326 iQ.Write(aMsg); |
|
327 break; |
|
328 |
|
329 case TLbsNetInternalMsgBase::ESelfLocationCancel: |
|
330 // The AGPS manager should not send a Cancel twice |
|
331 removed = iQ.FindAndRemove(TLbsNetInternalMsgBase::ESelfLocationCancel); |
|
332 __ASSERT_DEBUG(removed == EFalse, User::Panic(KLbsAGPSManFault, KErrAlreadyExists)); |
|
333 removed = removed == removed; //dummy for UREL |
|
334 iQ.Write(aMsg); |
|
335 break; |
|
336 |
|
337 case TLbsNetInternalMsgBase::EAssistanceDataRequest: |
|
338 // It is an implicit cancel of a previous Assistance Data Request |
|
339 iQ.FindAndRemove(TLbsNetInternalMsgBase::EAssistanceDataRequest); |
|
340 iQ.Write(aMsg); |
|
341 break; |
|
342 |
|
343 case TLbsNetInternalMsgBase::ESystemStatusAdvice: |
|
344 // It is an implicit cancel of a previous System Status Advice |
|
345 iQ.FindAndRemove(TLbsNetInternalMsgBase::ESystemStatusAdvice); |
|
346 iQ.Write(aMsg); |
|
347 break; |
|
348 |
|
349 default: |
|
350 break; |
|
351 |
|
352 } |
|
353 } |
|
354 |
|
355 //--------------------------------------------------------------------------------------------------- |
|
356 void CNetworkGatewayHandler::ProcessNetChannelMessage(RLbsNetChannel::TLbsNetChannelId aChannelId, |
|
357 const TLbsNetInternalMsgBase& aMessage) |
|
358 { |
|
359 LBSLOG(ELogP1, "CNetworkGatewayHandler::ProcessNetChannelMessage()\n"); |
|
360 __ASSERT_DEBUG(aChannelId == RLbsNetChannel::EChannelAGPS2NG, User::Panic(KLbsAGPSManFault, EAGPSManUnexpectedNetChannelId)); |
|
361 (void) aChannelId; |
|
362 |
|
363 const TLbsNetSessionCompleteAgpsMsg& msgComp = static_cast<const TLbsNetSessionCompleteAgpsMsg&>(aMessage); |
|
364 const TLbsNetAssistanceDataResponseMsg& msgAss = static_cast<const TLbsNetAssistanceDataResponseMsg&>(aMessage); |
|
365 |
|
366 switch (aMessage.Type()) |
|
367 { |
|
368 case TLbsNetInternalMsgBase::ESessionComplete: |
|
369 iObserver->OnSessionComplete(msgComp.Reason(), msgComp.SessionId()); |
|
370 break; |
|
371 |
|
372 case TLbsNetInternalMsgBase::EAssistanceDataResponse: |
|
373 iObserver->OnAssistanceDataResponse(msgAss.Reason(), msgAss.DataResponseMask()); |
|
374 break; |
|
375 |
|
376 default: |
|
377 LBSLOG_ERR2(ELogP2, "Unexpected message type: %d \n", aMessage.Type()); |
|
378 __ASSERT_DEBUG(EFalse, User::Panic(KLbsAGPSManFault, KErrArgument)); |
|
379 break; |
|
380 } |
|
381 } |