206 // complete any outstanding messages. |
206 // complete any outstanding messages. |
207 iDataAvailableListenerMessage.Complete(KErrCancel); |
207 iDataAvailableListenerMessage.Complete(KErrCancel); |
208 } |
208 } |
209 delete iSession; |
209 delete iSession; |
210 } |
210 } |
211 |
211 /* |
|
212 * Each of the individual methods is responsible for completing the message. |
|
213 * All 'leaves' are processed in CSession2::ServiceError() resulting in message completion |
|
214 * with the appropriate error code. |
|
215 * RegisterTagL() and RegisterSpaceAvailableListenerL() store aMessage parameter for the future use |
|
216 * when the callbacks are called. |
|
217 */ |
212 void CEirManExternalSession::ServiceL(const RMessage2& aMessage) |
218 void CEirManExternalSession::ServiceL(const RMessage2& aMessage) |
213 { |
219 { |
214 LOG_FUNC |
220 LOG_FUNC |
215 LOG1(_L("CEirManSession::ServiceL aMessage.Function() = %d"), aMessage.Function()); |
221 LOG1(_L("CEirManSession::ServiceL aMessage.Function() = %d"), aMessage.Function()); |
216 TBool complete = ETrue; |
|
217 TInt ret = KErrNone; |
|
218 |
222 |
219 switch (aMessage.Function()) |
223 switch (aMessage.Function()) |
220 { |
224 { |
221 case EEirManRegisterTag: |
225 case EEirManRegisterTag: |
222 complete = EFalse; // always async. |
226 RegisterTagL(aMessage); |
223 RegisterTag(aMessage); |
|
224 break; |
227 break; |
225 |
228 |
226 case EEirManSpaceAvailableNotification: |
229 case EEirManSpaceAvailableNotification: |
227 ret = RegisterSpaceAvailableListener(aMessage, complete); |
230 RegisterSpaceAvailableListenerL(aMessage); |
228 break; |
231 break; |
229 |
232 |
230 case EEirManCancelSpaceAvailableNotification: |
233 case EEirManCancelSpaceAvailableNotification: |
231 ret = CancelSpaceAvailableListener(); |
234 CancelSpaceAvailableListenerL(aMessage); |
232 break; |
235 break; |
233 |
236 |
234 case EEirManSetData: |
237 case EEirManSetData: |
235 ret = SetData(aMessage); |
238 SetDataL(aMessage); |
236 break; |
239 break; |
237 |
240 |
238 case EEirManNewData: |
241 case EEirManNewData: |
239 ret = NewData(aMessage); |
242 NewDataL(aMessage); |
240 break; |
243 break; |
241 |
244 |
242 default: |
245 default: |
243 aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidIPC); |
246 aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidIPC); |
244 break; |
247 break; |
245 } |
248 } |
246 |
249 } |
247 if (complete) |
250 |
248 { |
251 void CEirManExternalSession::RegisterTagL(const RMessage2& aMessage) |
249 aMessage.Complete(ret); |
|
250 } |
|
251 } |
|
252 |
|
253 void CEirManExternalSession::RegisterTag(const RMessage2& aMessage) |
|
254 { |
252 { |
255 LOG_FUNC |
253 LOG_FUNC |
256 TEirTag tag = static_cast<TEirTag>(aMessage.Int0()); |
254 TEirTag tag = static_cast<TEirTag>(aMessage.Int0()); |
257 LOG1(_L("CEirManSession::RegisterTag tag = %d"), tag); |
255 LOG1(_L("CEirManSession::RegisterTag tag = %d"), tag); |
258 |
256 |
259 iRegisterMessage = aMessage; |
257 iRegisterMessage = aMessage; |
260 |
258 |
261 iSession->RegisterTag(tag); |
259 iSession->RegisterTag(tag); |
262 |
|
263 } |
260 } |
264 |
261 |
265 void CEirManExternalSession::MesnRegisterComplete(TInt aResult) |
262 void CEirManExternalSession::MesnRegisterComplete(TInt aResult) |
266 { |
263 { |
267 if (aResult == KErrArgument) |
264 if (aResult == KErrArgument) |
268 { |
265 { |
269 __ASSERT_ALWAYS(EFalse, iRegisterMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag)); |
266 iRegisterMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag); |
270 } |
267 } |
271 iRegisterMessage.Complete(aResult); |
268 else |
272 } |
269 { |
273 |
270 iRegisterMessage.Complete(aResult); |
274 TInt CEirManExternalSession::RegisterSpaceAvailableListener(const RMessage2& aMessage, TBool& aComplete) |
271 } |
|
272 } |
|
273 |
|
274 void CEirManExternalSession::RegisterSpaceAvailableListenerL(const RMessage2& aMessage) |
275 { |
275 { |
276 LOG_FUNC |
276 LOG_FUNC |
277 |
277 |
278 if(iDataAvailableListenerMessage.Handle()) |
278 if(iDataAvailableListenerMessage.Handle()) |
279 { |
279 { |
280 LOG(_L("CEirManSession:::RegisterSpaceAvailableListener ERROR IN USE")); |
280 LOG(_L("CEirManSession:::RegisterSpaceAvailableListener ERROR IN USE")); |
281 return KErrInUse; |
281 LEAVEL(KErrInUse); |
282 } |
282 } |
283 |
283 |
284 iDataAvailableListenerMessage = aMessage; |
284 iDataAvailableListenerMessage = aMessage; |
285 |
|
286 aComplete = EFalse; |
|
287 |
285 |
288 if(iLastSpaceOffered != 0) |
286 if(iLastSpaceOffered != 0) |
289 { |
287 { |
290 LOG(_L("cached space present, completing immediately")); |
288 LOG(_L("cached space present, completing immediately")); |
291 CompleteSpaceAvailableRequest(iLastSpaceOffered); |
289 CompleteSpaceAvailableRequest(iLastSpaceOffered); |
292 iLastSpaceOffered = 0; |
290 iLastSpaceOffered = 0; |
293 return KErrNone; |
291 return; |
294 } |
292 } |
295 |
293 |
296 LOG(_L("waiting for callback...")); |
294 LOG(_L("waiting for callback...")); |
297 return KErrNone; |
295 } |
298 } |
296 |
299 |
297 void CEirManExternalSession::NewDataL(const RMessage2& aMessage) |
300 TInt CEirManExternalSession::NewData(const RMessage2& aMessage) |
298 { |
301 { |
299 LOG_FUNC |
302 LOG_FUNC |
300 |
303 __ASSERT_ALWAYS(iSession->EirTag() != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag)); |
301 if (iSession->EirTag() == EEirTagRESERVED) |
|
302 { |
|
303 aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag); |
|
304 return; |
|
305 } |
|
306 |
304 TInt requiredLength = static_cast<TInt>(aMessage.Int0()); |
307 TInt requiredLength = static_cast<TInt>(aMessage.Int0()); |
305 |
308 |
306 return iSession->NewData(requiredLength); |
309 LEAVEIFERRORL(iSession->NewData(requiredLength)); |
307 } |
310 aMessage.Complete(KErrNone); |
308 |
311 } |
309 TInt CEirManExternalSession::CancelSpaceAvailableListener() |
312 |
|
313 void CEirManExternalSession::CancelSpaceAvailableListenerL(const RMessage2& aMessage) |
310 { |
314 { |
311 LOG_FUNC |
315 LOG_FUNC |
312 |
316 |
313 if(!iDataAvailableListenerMessage.Handle()) |
317 if(!iDataAvailableListenerMessage.Handle()) |
314 { |
318 { |
315 return KErrNotFound; |
319 LEAVEL(KErrNotFound); |
316 } |
320 } |
317 |
321 |
318 iDataAvailableListenerMessage.Complete(KErrCancel); |
322 iDataAvailableListenerMessage.Complete(KErrCancel); |
319 |
323 aMessage.Complete(KErrNone); |
320 return KErrNone; |
324 } |
321 } |
325 |
322 |
326 void CEirManExternalSession::SetDataL(const RMessage2& aMessage) |
323 TInt CEirManExternalSession::SetData(const RMessage2& aMessage) |
327 { |
324 { |
328 LOG_FUNC |
325 LOG_FUNC |
329 if (iSession->EirTag() == EEirTagRESERVED) |
326 __ASSERT_ALWAYS(iSession->EirTag() != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag)); |
330 { |
|
331 aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag); |
|
332 return; |
|
333 } |
|
334 |
327 TEirDataMode eirDataMode = static_cast<TEirDataMode>(aMessage.Int1()); |
335 TEirDataMode eirDataMode = static_cast<TEirDataMode>(aMessage.Int1()); |
328 LOG1(_L("EirDataMode: %d"), eirDataMode); |
336 LOG1(_L("EirDataMode: %d"), eirDataMode); |
329 |
337 |
330 // No need to allocate memory with an expensive malloc() call (via HBuf8::NewL or whatever), |
338 // No need to allocate memory with an expensive malloc() call (via HBuf8::NewL or whatever), |
331 // since the EIR contents fit in the stack, and the EIR Manager will cache the data anyway |
339 // since the EIR contents fit in the stack, and the EIR Manager will cache the data anyway |
332 TBuf8<KHCIExtendedInquiryResponseMaxLength> data; |
340 TBuf8<KHCIExtendedInquiryResponseMaxLength> data; |
333 TInt err = aMessage.Read(0, data); |
341 LEAVEIFERRORL(aMessage.Read(0, data)); |
334 |
342 |
335 if(err == KErrNone) |
343 LEAVEIFERRORL(iSession->SetData(data, eirDataMode)); |
336 { |
344 aMessage.Complete(KErrNone); |
337 err = iSession->SetData(data, eirDataMode); |
|
338 } |
|
339 return err; |
|
340 } |
345 } |
341 |
346 |
342 void CEirManExternalSession::MesnSpaceAvailable(TUint aSpaceForTag) |
347 void CEirManExternalSession::MesnSpaceAvailable(TUint aSpaceForTag) |
343 { |
348 { |
344 if(iDataAvailableListenerMessage.Handle()) |
349 if(iDataAvailableListenerMessage.Handle()) |