30 |
30 |
31 #ifdef __FLOG_ACTIVE |
31 #ifdef __FLOG_ACTIVE |
32 _LIT8(KLogComponent, LOG_COMPONENT_EIRMANAGER); |
32 _LIT8(KLogComponent, LOG_COMPONENT_EIRMANAGER); |
33 #endif |
33 #endif |
34 |
34 |
35 CEirManSession* CEirManSession::NewL(CEirManServer& aServer) |
35 CEirManSession* CEirManSession::NewL(CEirManServer& aServer, MEirSessionNotifier& aParent, TBool aInternalSession) |
36 { |
36 { |
37 LOG_STATIC_FUNC |
37 LOG_STATIC_FUNC |
38 CEirManSession* self = new(ELeave) CEirManSession(aServer); |
38 CEirManSession* self = new(ELeave) CEirManSession(aServer, aParent, aInternalSession); |
39 CleanupStack::PushL(self); |
39 CleanupStack::PushL(self); |
40 self->ConstructL(); |
40 self->ConstructL(); |
41 CleanupStack::Pop(self); |
41 CleanupStack::Pop(self); |
42 return self; |
42 return self; |
43 } |
43 } |
44 |
44 |
45 CEirManSession::CEirManSession(CEirManServer& aServer) |
45 CEirManSession::CEirManSession(CEirManServer& aServer, MEirSessionNotifier& aParent, TBool aInternalSession) |
46 : iEirManServer(aServer) |
46 : iEirManServer(aServer) |
|
47 , iParent(aParent) |
47 , iEirTag(EEirTagRESERVED) |
48 , iEirTag(EEirTagRESERVED) |
|
49 , iInternalSession(aInternalSession) |
48 { |
50 { |
49 LOG_FUNC |
51 LOG_FUNC |
50 } |
52 } |
51 |
53 |
52 void CEirManSession::ConstructL() |
54 void CEirManSession::ConstructL() |
53 { |
55 { |
54 LOG_FUNC |
56 LOG_FUNC |
55 iEirManServer.AddSession(); |
57 iEirManServer.AddSession(*this, iInternalSession); |
56 } |
58 } |
57 |
59 |
58 CEirManSession::~CEirManSession() |
60 CEirManSession::~CEirManSession() |
59 { |
61 { |
60 LOG_FUNC |
62 LOG_FUNC |
61 // deregister any registered tag that may be registered |
63 // deregister any registered tag that may be registered |
62 DeregisterTag(); |
64 DeregisterTag(); |
63 if(!iDataAvailableListenerMessage.IsNull()) |
65 iLink.Deque(); |
64 { |
66 iEirManServer.DropSession(iInternalSession); |
65 // complete any outstanding messages. |
67 } |
66 iDataAvailableListenerMessage.Complete(KErrCancel); |
68 |
67 } |
69 void CEirManSession::RegisterTag(TEirTag aTag) |
68 iEirManServer.DropSession(); |
70 { |
69 } |
71 LOG_FUNC |
70 |
72 |
71 void CEirManSession::ServiceL(const RMessage2& aMessage) |
73 LOG1(_L("CEirManSession::RegisterTag tag = %d"), aTag); |
72 { |
74 |
73 LOG_FUNC |
75 if(!(aTag >= EEirTagName && aTag < EEirTagRESERVED)) |
74 LOG1(_L("CEirManSession::ServiceL aMessage.Function() = %d"), aMessage.Function()); |
76 { |
75 TBool complete = ETrue; |
77 iParent.MesnRegisterComplete(KErrArgument); |
76 TInt ret = KErrNone; |
|
77 |
|
78 switch (aMessage.Function()) |
|
79 { |
|
80 case EEirManRegisterTag: |
|
81 complete = EFalse; // always async. |
|
82 RegisterTag(aMessage); |
|
83 break; |
|
84 |
|
85 case EEirManSpaceAvailableNotification: |
|
86 ret = RegisterSpaceAvailableListener(aMessage, complete); |
|
87 break; |
|
88 |
|
89 case EEirManCancelSpaceAvailableNotification: |
|
90 ret = CancelSpaceAvailableListener(); |
|
91 break; |
|
92 |
|
93 case EEirManSetData: |
|
94 ret = SetData(aMessage); |
|
95 break; |
|
96 |
|
97 case EEirManNewData: |
|
98 ret = NewData(aMessage); |
|
99 break; |
|
100 |
|
101 default: |
|
102 aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidIPC); |
|
103 break; |
|
104 } |
|
105 |
|
106 if (complete) |
|
107 { |
|
108 aMessage.Complete(ret); |
|
109 } |
|
110 } |
|
111 |
|
112 void CEirManSession::RegisterTag(const RMessage2& aMessage) |
|
113 { |
|
114 LOG_FUNC |
|
115 |
|
116 TEirTag tag = static_cast<TEirTag>(aMessage.Int0()); |
|
117 LOG1(_L("CEirManSession::RegisterTag tag = %d"), tag); |
|
118 |
|
119 if(!(tag >= EEirTagName && tag < EEirTagRESERVED)) |
|
120 { |
|
121 __ASSERT_ALWAYS(EFalse, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag)); |
|
122 } |
78 } |
123 else if(iEirTag != EEirTagRESERVED) |
79 else if(iEirTag != EEirTagRESERVED) |
124 { |
80 { |
125 LOG1(_L("CEirManSession::RegisterTag ERROR, Tag in use: %d"), iEirTag); |
81 LOG1(_L("CEirManSession::RegisterTag ERROR, Tag in use: %d"), iEirTag); |
126 aMessage.Complete(KErrInUse); |
82 iParent.MesnRegisterComplete(KErrInUse); |
127 } |
83 } |
128 else |
84 else |
129 { |
85 { |
130 // Register this tag for callbacks |
86 // Register this tag for callbacks |
131 if(iEirManServer.EirFeatureState() == EEirFeatureReady) |
87 if(iEirManServer.EirFeatureState() == EEirFeatureReady) |
132 { |
88 { |
133 // Eir is supported |
89 // Eir is supported |
134 TInt result = iEirManServer.EirManager().RegisterTag(tag, *this); |
90 TInt result = iEirManServer.EirManager().RegisterTag(aTag, *this); |
135 if(result == KErrNone) |
91 if(result == KErrNone) |
136 { |
92 { |
137 iEirTag = tag; |
93 iEirTag = aTag; |
138 } |
94 } |
139 aMessage.Complete(result); |
95 iParent.MesnRegisterComplete(result); |
140 } |
96 } |
141 else if(iEirManServer.EirFeatureState() == EEirFeaturePending) |
97 else if(iEirManServer.EirFeatureState() == EEirFeaturePending) |
142 { |
98 { |
143 // We don't know if eir is supported or not at this moment |
99 // We don't know if eir is supported or not at this moment |
144 iPendingEirTag = tag; |
100 iRegisterPending = ETrue; |
145 iRegisterMessage = aMessage; |
101 iPendingEirTag = aTag; |
146 } |
102 } |
147 else |
103 else |
148 { |
104 { |
149 // Eir is not supported |
105 // Eir is not supported |
150 aMessage.Complete(KErrNotSupported); |
106 iParent.MesnRegisterComplete(KErrNotSupported); |
151 } |
107 } |
152 } |
108 } |
153 } |
109 } |
154 |
110 |
155 void CEirManSession::DeregisterTag() |
111 void CEirManSession::DeregisterTag() |
167 |
123 |
168 // Eir Server has tried to register tag |
124 // Eir Server has tried to register tag |
169 void CEirManSession::NotifyEirFeatureState(TInt aResult) |
125 void CEirManSession::NotifyEirFeatureState(TInt aResult) |
170 { |
126 { |
171 LOG1(_L("Eir Server has been notified feature ready, result: %d"), aResult); |
127 LOG1(_L("Eir Server has been notified feature ready, result: %d"), aResult); |
172 if(aResult == KErrNone && !iRegisterMessage.IsNull()) |
128 if(aResult == KErrNone && iRegisterPending) |
173 { |
129 { |
174 __ASSERT_DEBUG(iEirManServer.EirFeatureState() == EEirFeatureReady, EIR_SESSION_PANIC(EEirSessionEirFeatureNotSupported)); |
130 __ASSERT_DEBUG(iEirManServer.EirFeatureState() == EEirFeatureReady, EIR_SESSION_PANIC(EEirSessionEirFeatureNotSupported)); |
175 TInt result = iEirManServer.EirManager().RegisterTag(iPendingEirTag, *this); |
131 TInt result = iEirManServer.EirManager().RegisterTag(iPendingEirTag, *this); |
176 if(result == KErrNone) |
132 if(result == KErrNone) |
177 { |
133 { |
178 iEirTag = iPendingEirTag; |
134 iEirTag = iPendingEirTag; |
179 } |
135 } |
180 iRegisterMessage.Complete(result); |
136 iRegisterPending = EFalse; |
181 } |
137 iParent.MesnRegisterComplete(result); |
182 else if(!iRegisterMessage.IsNull()) |
138 } |
183 { |
139 else if(iRegisterPending) |
184 iRegisterMessage.Complete(aResult); |
140 { |
185 } |
141 iRegisterPending = EFalse; |
186 } |
142 iParent.MesnRegisterComplete(aResult); |
187 |
143 } |
188 TInt CEirManSession::RegisterSpaceAvailableListener(const RMessage2& aMessage, TBool& aComplete) |
144 } |
|
145 |
|
146 |
|
147 TInt CEirManSession::NewData(TInt aRequiredLength) |
|
148 { |
|
149 LOG_FUNC |
|
150 return iEirManServer.EirManager().NewData(iEirTag, aRequiredLength); |
|
151 } |
|
152 |
|
153 |
|
154 TInt CEirManSession::SetData(const TDesC8& aData, TEirDataMode aMode) |
|
155 { |
|
156 LOG_FUNC |
|
157 return iEirManServer.EirManager().SetData(iEirTag, aData, aMode); |
|
158 } |
|
159 |
|
160 // Callback from the EIR Manager |
|
161 void CEirManSession::MemnEirBlockAvailable(TEirTag aTag, TUint aSpaceForTag) |
|
162 { |
|
163 LOG_FUNC |
|
164 LOG2(_L("CEirManSession::MemnEirBlockAvailable Tag: %d space: %d"), aTag, aSpaceForTag); |
|
165 |
|
166 // Silently discard callbacks not containing our EIR Tag |
|
167 if(aTag != iEirTag) |
|
168 { |
|
169 __ASSERT_DEBUG(EFalse, EIR_SESSION_PANIC(EEirSessionInvalidEirTag)); |
|
170 LOG3(_L("CEirManSession::MemnEirBlockAvailable early return: aTag: %d iEirTag: %d space: %d"), aTag, iEirTag, aSpaceForTag); |
|
171 return; |
|
172 } |
|
173 |
|
174 iParent.MesnSpaceAvailable(aSpaceForTag); |
|
175 |
|
176 } |
|
177 |
|
178 TEirTag CEirManSession::EirTag() const |
|
179 { |
|
180 return iEirTag; |
|
181 } |
|
182 |
|
183 CEirManExternalSession* CEirManExternalSession::NewL(CEirManServer& aServer) |
|
184 { |
|
185 CEirManExternalSession* self = new(ELeave) CEirManExternalSession(); |
|
186 CleanupStack::PushL(self); |
|
187 self->ConstructL(aServer); |
|
188 CleanupStack::Pop(self); |
|
189 return self; |
|
190 } |
|
191 |
|
192 CEirManExternalSession::CEirManExternalSession() |
|
193 { |
|
194 |
|
195 } |
|
196 |
|
197 void CEirManExternalSession::ConstructL(CEirManServer& aServer) |
|
198 { |
|
199 iSession = CEirManSession::NewL(aServer, *this, EFalse); |
|
200 } |
|
201 |
|
202 CEirManExternalSession::~CEirManExternalSession() |
|
203 { |
|
204 if(!iDataAvailableListenerMessage.IsNull()) |
|
205 { |
|
206 // complete any outstanding messages. |
|
207 iDataAvailableListenerMessage.Complete(KErrCancel); |
|
208 } |
|
209 delete iSession; |
|
210 } |
|
211 |
|
212 void CEirManExternalSession::ServiceL(const RMessage2& aMessage) |
|
213 { |
|
214 LOG_FUNC |
|
215 LOG1(_L("CEirManSession::ServiceL aMessage.Function() = %d"), aMessage.Function()); |
|
216 TBool complete = ETrue; |
|
217 TInt ret = KErrNone; |
|
218 |
|
219 switch (aMessage.Function()) |
|
220 { |
|
221 case EEirManRegisterTag: |
|
222 complete = EFalse; // always async. |
|
223 RegisterTag(aMessage); |
|
224 break; |
|
225 |
|
226 case EEirManSpaceAvailableNotification: |
|
227 ret = RegisterSpaceAvailableListener(aMessage, complete); |
|
228 break; |
|
229 |
|
230 case EEirManCancelSpaceAvailableNotification: |
|
231 ret = CancelSpaceAvailableListener(); |
|
232 break; |
|
233 |
|
234 case EEirManSetData: |
|
235 ret = SetData(aMessage); |
|
236 break; |
|
237 |
|
238 case EEirManNewData: |
|
239 ret = NewData(aMessage); |
|
240 break; |
|
241 |
|
242 default: |
|
243 aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidIPC); |
|
244 break; |
|
245 } |
|
246 |
|
247 if (complete) |
|
248 { |
|
249 aMessage.Complete(ret); |
|
250 } |
|
251 } |
|
252 |
|
253 void CEirManExternalSession::RegisterTag(const RMessage2& aMessage) |
|
254 { |
|
255 LOG_FUNC |
|
256 TEirTag tag = static_cast<TEirTag>(aMessage.Int0()); |
|
257 LOG1(_L("CEirManSession::RegisterTag tag = %d"), tag); |
|
258 |
|
259 iRegisterMessage = aMessage; |
|
260 |
|
261 iSession->RegisterTag(tag); |
|
262 |
|
263 } |
|
264 |
|
265 void CEirManExternalSession::MesnRegisterComplete(TInt aResult) |
|
266 { |
|
267 if (aResult == KErrArgument) |
|
268 { |
|
269 __ASSERT_ALWAYS(EFalse, iRegisterMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag)); |
|
270 } |
|
271 iRegisterMessage.Complete(aResult); |
|
272 } |
|
273 |
|
274 TInt CEirManExternalSession::RegisterSpaceAvailableListener(const RMessage2& aMessage, TBool& aComplete) |
189 { |
275 { |
190 LOG_FUNC |
276 LOG_FUNC |
191 |
277 |
192 if(iDataAvailableListenerMessage.Handle()) |
278 if(iDataAvailableListenerMessage.Handle()) |
193 { |
279 { |
232 iDataAvailableListenerMessage.Complete(KErrCancel); |
318 iDataAvailableListenerMessage.Complete(KErrCancel); |
233 |
319 |
234 return KErrNone; |
320 return KErrNone; |
235 } |
321 } |
236 |
322 |
237 TInt CEirManSession::SetData(const RMessage2& aMessage) |
323 TInt CEirManExternalSession::SetData(const RMessage2& aMessage) |
238 { |
324 { |
239 LOG_FUNC |
325 LOG_FUNC |
240 __ASSERT_ALWAYS(iEirTag != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag)); |
326 __ASSERT_ALWAYS(iSession->EirTag() != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag)); |
241 TEirDataMode eirDataMode = static_cast<TEirDataMode>(aMessage.Int1()); |
327 TEirDataMode eirDataMode = static_cast<TEirDataMode>(aMessage.Int1()); |
242 LOG2(_L("Tag: %d EirDataMode: %d"), iEirTag, eirDataMode); |
328 LOG1(_L("EirDataMode: %d"), eirDataMode); |
243 |
329 |
244 // No need to allocate memory with an expensive malloc() call (via HBuf8::NewL or whatever), |
330 // No need to allocate memory with an expensive malloc() call (via HBuf8::NewL or whatever), |
245 // since the EIR contents fit in the stack, and the EIR Manager will cache the data anyway |
331 // since the EIR contents fit in the stack, and the EIR Manager will cache the data anyway |
246 TBuf8<KHCIExtendedInquiryResponseMaxLength> data; |
332 TBuf8<KHCIExtendedInquiryResponseMaxLength> data; |
247 TInt err = aMessage.Read(0, data); |
333 TInt err = aMessage.Read(0, data); |
248 |
334 |
249 if(err == KErrNone) |
335 if(err == KErrNone) |
250 { |
336 { |
251 err = iEirManServer.EirManager().SetData(iEirTag, data, eirDataMode); |
337 err = iSession->SetData(data, eirDataMode); |
252 } |
338 } |
253 return err; |
339 return err; |
254 } |
340 } |
255 |
341 |
256 // Callback from the EIR Manager |
342 void CEirManExternalSession::MesnSpaceAvailable(TUint aSpaceForTag) |
257 void CEirManSession::MemnEirBlockAvailable(TEirTag aTag, TUint aSpaceForTag) |
343 { |
258 { |
|
259 LOG_FUNC |
|
260 LOG2(_L("CEirManSession::MemnEirBlockAvailable Tag: %d space: %d"), aTag, aSpaceForTag); |
|
261 |
|
262 // Silently discard callbacks not containing our EIR Tag |
|
263 if(aTag != iEirTag) |
|
264 { |
|
265 __ASSERT_DEBUG(EFalse, EIR_SESSION_PANIC(EEirSessionInvalidEirTag)); |
|
266 LOG3(_L("CEirManSession::MemnEirBlockAvailable early return: aTag: %d iEirTag: %d space: %d"), aTag, iEirTag, aSpaceForTag); |
|
267 return; |
|
268 } |
|
269 |
|
270 if(iDataAvailableListenerMessage.Handle()) |
344 if(iDataAvailableListenerMessage.Handle()) |
271 { |
345 { |
272 LOG(_L("Listener outstanding, completing request")); |
346 LOG(_L("Listener outstanding, completing request")); |
273 // Clear stored value |
347 // Clear stored value |
274 iLastSpaceOffered = 0; |
348 iLastSpaceOffered = 0; |
280 // Store in case a client registers later. If this happens multiple times, only the last one will be remembered |
354 // Store in case a client registers later. If this happens multiple times, only the last one will be remembered |
281 iLastSpaceOffered = aSpaceForTag; |
355 iLastSpaceOffered = aSpaceForTag; |
282 } |
356 } |
283 } |
357 } |
284 |
358 |
285 void CEirManSession::CompleteSpaceAvailableRequest(TUint aBytesAvailable) |
359 void CEirManExternalSession::CompleteSpaceAvailableRequest(TUint aBytesAvailable) |
286 { |
360 { |
287 LOG_FUNC |
361 LOG_FUNC |
288 LOG1(_L("CEirManSession::CompleteSpaceAvailableRequest bytes: %d"), aBytesAvailable); |
362 LOG1(_L("CEirManSession::CompleteSpaceAvailableRequest bytes: %d"), aBytesAvailable); |
289 // Offer the space to the client |
363 // Offer the space to the client |
290 TPckg<TUint32> pckg(aBytesAvailable); |
364 TPckgC<TUint32> pckg(aBytesAvailable); |
291 |
365 |
292 TInt err = iDataAvailableListenerMessage.Write(0, pckg); |
366 TInt err = iDataAvailableListenerMessage.Write(0, pckg); |
293 iDataAvailableListenerMessage.Complete(err); |
367 iDataAvailableListenerMessage.Complete(err); |
294 } |
368 } |
295 |
369 |
|
370 CEirManInternalSession* CEirManInternalSession::NewL(CEirManServer& aServer, MEirInternalSessionNotifier& aParent) |
|
371 { |
|
372 LOG_STATIC_FUNC |
|
373 CEirManInternalSession* self = new(ELeave) CEirManInternalSession(aParent); |
|
374 CleanupStack::PushL(self); |
|
375 self->ConstructL(aServer); |
|
376 CleanupStack::Pop(self); |
|
377 return self; |
|
378 } |
|
379 |
|
380 CEirManInternalSession::CEirManInternalSession(MEirInternalSessionNotifier& aParent) |
|
381 : iParent(aParent) |
|
382 { |
|
383 |
|
384 } |
|
385 |
|
386 void CEirManInternalSession::ConstructL(CEirManServer& aServer) |
|
387 { |
|
388 iSession = CEirManSession::NewL(aServer, *this, ETrue); |
|
389 iSetDataCb = new (ELeave) CAsyncCallBack(CActive::EPriorityHigh); |
|
390 TCallBack cb(&SetDataCb, this); |
|
391 iSetDataCb->Set(cb); |
|
392 } |
|
393 |
|
394 CEirManInternalSession::~CEirManInternalSession() |
|
395 { |
|
396 delete iSetDataCb; |
|
397 delete iSession; |
|
398 } |
|
399 |
|
400 void CEirManInternalSession::RegisterTag(TEirTag aTag) |
|
401 { |
|
402 iSession->RegisterTag(aTag); |
|
403 } |
|
404 |
|
405 void CEirManInternalSession::SetData(const TDesC8& aData, TEirDataMode aMode) |
|
406 { |
|
407 delete iPendingData; |
|
408 iPendingData = NULL; |
|
409 iSetDataCb->Cancel(); |
|
410 iPendingData = aData.Alloc(); |
|
411 iPendingMode = aMode; |
|
412 if (iPendingData) |
|
413 { |
|
414 iSetDataCb->CallBack(); |
|
415 } |
|
416 } |
|
417 |
|
418 TInt CEirManInternalSession::SetDataCb(TAny* aThis) |
|
419 { |
|
420 static_cast<CEirManInternalSession*>(aThis)->DoSetData(); |
|
421 return KErrNone; |
|
422 } |
|
423 |
|
424 void CEirManInternalSession::DoSetData() |
|
425 { |
|
426 TInt err = iSession->SetData(*iPendingData, iPendingMode); |
|
427 if (err != KErrNone) |
|
428 { |
|
429 iParent.MeisnSetDataError(err); |
|
430 } |
|
431 } |
|
432 |
|
433 TInt CEirManInternalSession::NewData(TInt aRequiredLength) |
|
434 { |
|
435 return iSession->NewData(aRequiredLength); |
|
436 } |
|
437 |
|
438 |
|
439 void CEirManInternalSession::MesnRegisterComplete(TInt aResult) |
|
440 { |
|
441 iParent.MeisnRegisterComplete(aResult); |
|
442 } |
|
443 |
|
444 void CEirManInternalSession::MesnSpaceAvailable(TUint aSpaceForTag) |
|
445 { |
|
446 iParent.MeisnSpaceAvailable(aSpaceForTag - KEirLengthTagLength); |
|
447 } |