1 // ssyreferencechannel.cpp |
|
2 |
|
3 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
4 // All rights reserved. |
|
5 // This component and the accompanying materials are made available |
|
6 // under the terms of "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 // Initial Contributors: |
|
11 // Nokia Corporation - initial contribution. |
|
12 // |
|
13 // Contributors: |
|
14 // |
|
15 // Description: |
|
16 // |
|
17 |
|
18 |
|
19 |
|
20 #include <sensors/spi/ssycallback.h> // MSsyCallback |
|
21 #include "ssyreferencechannel.h" |
|
22 #include "ssyreferencecontrol.h" // SSY Control |
|
23 #include "ssyreferencepropertyprovider.h" // iChannelPropertyProvider |
|
24 #include "ssyreferencechanneldataprovider.h" // iChannelDataProvider |
|
25 #include "ssyreferencetrace.h" |
|
26 #include "ssyreferencecmdhandler.h" |
|
27 |
|
28 |
|
29 // ======== MEMBER FUNCTIONS ======== |
|
30 |
|
31 // --------------------------------------------------------------------------- |
|
32 // CSsyReferenceChannel C++ constructor |
|
33 // --------------------------------------------------------------------------- |
|
34 // |
|
35 CSsyReferenceChannel::CSsyReferenceChannel( CSsyReferenceControl& aSsyControl, TSensrvChannelInfo aChannelInfo ) : |
|
36 iSsyControl( aSsyControl ), |
|
37 iChannelInfo( aChannelInfo ), |
|
38 iState( ESsyReferenceChannelIdle ) |
|
39 { |
|
40 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::CSsyReferenceChannel()" ) ) ); |
|
41 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::CSsyReferenceChannel() - return" ) ) ); |
|
42 } |
|
43 |
|
44 |
|
45 // --------------------------------------------------------------------------- |
|
46 // Symbian 2nd phase constructor |
|
47 // --------------------------------------------------------------------------- |
|
48 // |
|
49 void CSsyReferenceChannel::ConstructL() |
|
50 { |
|
51 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ConstructL()" ) ) ); |
|
52 |
|
53 // Create command handler |
|
54 iCmdHandler = CSsyReferenceCmdHandler::NewL( *this ); |
|
55 |
|
56 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ConstructL() - return" ) ) ); |
|
57 } |
|
58 |
|
59 // --------------------------------------------------------------------------- |
|
60 // CSsyReferenceChannel::NewL |
|
61 // --------------------------------------------------------------------------- |
|
62 // |
|
63 CSsyReferenceChannel* CSsyReferenceChannel::NewL( CSsyReferenceControl& aSsyControl, TSensrvChannelInfo aChannelInfo ) |
|
64 { |
|
65 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::NewL()" ) ) ); |
|
66 CSsyReferenceChannel* self = new ( ELeave ) CSsyReferenceChannel( aSsyControl, aChannelInfo ); |
|
67 CleanupStack::PushL( self ); |
|
68 self->ConstructL(); |
|
69 CleanupStack::Pop( self ); |
|
70 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::NewL() - return" ) ) ); |
|
71 return self; |
|
72 } |
|
73 |
|
74 // --------------------------------------------------------------------------- |
|
75 // Destructor |
|
76 // --------------------------------------------------------------------------- |
|
77 // |
|
78 CSsyReferenceChannel::~CSsyReferenceChannel() |
|
79 { |
|
80 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::~CSsyReferenceChannel()" ) ) ); |
|
81 |
|
82 // In case channel is not closed before destruction, providers are not deleted |
|
83 if ( iChannelDataProvider ) |
|
84 { |
|
85 delete iChannelDataProvider; |
|
86 iChannelDataProvider = NULL; |
|
87 } |
|
88 |
|
89 if ( iChannelPropertyProvider ) |
|
90 { |
|
91 delete iChannelPropertyProvider; |
|
92 iChannelPropertyProvider = NULL; |
|
93 } |
|
94 |
|
95 if ( iCmdHandler ) |
|
96 { |
|
97 delete iCmdHandler; |
|
98 iCmdHandler = NULL; |
|
99 } |
|
100 |
|
101 iProperties.Reset(); |
|
102 |
|
103 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::~CSsyReferenceChannel() - return" ) ) ); |
|
104 } |
|
105 |
|
106 // --------------------------------------------------------------------------- |
|
107 // CSsyReferenceChannel::ChannelId |
|
108 // --------------------------------------------------------------------------- |
|
109 // |
|
110 TInt CSsyReferenceChannel::ChannelId() |
|
111 { |
|
112 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ChannelId() - %i" ), iChannelInfo.iChannelId ) ); |
|
113 return iChannelInfo.iChannelId; |
|
114 } |
|
115 |
|
116 // --------------------------------------------------------------------------- |
|
117 // CSsyReferenceChannel::SsyControl |
|
118 // --------------------------------------------------------------------------- |
|
119 // |
|
120 CSsyReferenceControl& CSsyReferenceChannel::SsyControl() const |
|
121 { |
|
122 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::SsyControl()" ) ) ); |
|
123 return iSsyControl; |
|
124 } |
|
125 |
|
126 // --------------------------------------------------------------------------- |
|
127 // CSsyReferenceControl::SsyCmdHandler |
|
128 // --------------------------------------------------------------------------- |
|
129 // |
|
130 CSsyReferenceCmdHandler& CSsyReferenceChannel::CommandHandler() const |
|
131 { |
|
132 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::SsyCmdHandler()" ) ) ); |
|
133 return *iCmdHandler; |
|
134 } |
|
135 |
|
136 // --------------------------------------------------------------------------- |
|
137 // CSsyReferenceChannel::FindPropertyL |
|
138 // --------------------------------------------------------------------------- |
|
139 // |
|
140 TSensrvProperty& CSsyReferenceChannel::FindPropertyL( |
|
141 const TSensrvPropertyId aPropertyId, |
|
142 TInt aItemIndex, |
|
143 TInt aArrayIndex ) |
|
144 { |
|
145 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::FindPropertyL()" ) ) ); |
|
146 TSensrvProperty* property = NULL; |
|
147 TBool propertyFound( EFalse ); |
|
148 |
|
149 // Search property |
|
150 for ( TInt i = 0; i < iProperties.Count() && !propertyFound; i++ ) |
|
151 { |
|
152 property = static_cast<TSensrvProperty*>( &iProperties[i] ); |
|
153 |
|
154 // Compare property IDs and array index |
|
155 if ( property->GetPropertyId() == aPropertyId ) |
|
156 { |
|
157 // Compare item index if it is given |
|
158 if ( ( KErrNotFound == aItemIndex ) || ( property->PropertyItemIndex() == aItemIndex ) ) |
|
159 { |
|
160 // Correct property ID is found, now check is it array type of property. |
|
161 // Either array indexes must match or propertys array index has to be array info |
|
162 if ( ( property->GetArrayIndex() == aArrayIndex ) || |
|
163 ( ( property->GetArrayIndex() == ESensrvArrayPropertyInfo ) && |
|
164 ( ESensrvSingleProperty == aArrayIndex ) ) ) |
|
165 { |
|
166 // Correct array index found |
|
167 propertyFound = ETrue; |
|
168 } |
|
169 } |
|
170 } |
|
171 } |
|
172 |
|
173 // Leave if not found |
|
174 if ( !propertyFound ) |
|
175 { |
|
176 iSsyControl.FindPropertyL( aPropertyId, aArrayIndex, *property ); |
|
177 } |
|
178 |
|
179 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::FindPropertyL() - return" ) ) ); |
|
180 return *property; |
|
181 } |
|
182 |
|
183 // --------------------------------------------------------------------------- |
|
184 // CSsyReferenceChannel::FindAndUpdatePropertyL |
|
185 // --------------------------------------------------------------------------- |
|
186 // |
|
187 void CSsyReferenceChannel::FindAndUpdatePropertyL( const TSensrvProperty& aProperty ) |
|
188 { |
|
189 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::FindAndUpdatePropertyL()" ) ) ); |
|
190 TBool propertyFound( EFalse ); |
|
191 |
|
192 // Search property |
|
193 for ( TInt i = 0; i < iProperties.Count() && !propertyFound; i++ ) |
|
194 { |
|
195 // Compare property IDs |
|
196 if ( iProperties[i].GetPropertyId() == aProperty.GetPropertyId() ) |
|
197 { |
|
198 // Compare item index if it is given |
|
199 if ( ( KErrNotFound != aProperty.PropertyItemIndex() ) && |
|
200 ( iProperties[i].PropertyItemIndex() == aProperty.PropertyItemIndex() ) ) |
|
201 { |
|
202 // Property found -> update if possible |
|
203 if ( iProperties[i].ReadOnly() ) |
|
204 { |
|
205 User::Leave( KErrAccessDenied ); |
|
206 } |
|
207 // If modifiable, get type and update value |
|
208 switch ( iProperties[i].PropertyType() ) |
|
209 { |
|
210 case ESensrvIntProperty: |
|
211 { |
|
212 TInt value( 0 ); |
|
213 aProperty.GetValue( value ); |
|
214 iProperties[i].SetValue( value ); |
|
215 break; |
|
216 } |
|
217 case ESensrvRealProperty: |
|
218 { |
|
219 TReal value( 0 ); |
|
220 aProperty.GetValue( value ); |
|
221 iProperties[i].SetValue( (TReal) value ); |
|
222 break; |
|
223 } |
|
224 case ESensrvBufferProperty: |
|
225 { |
|
226 TBuf8<20> propValue; |
|
227 aProperty.GetValue( propValue ); |
|
228 iProperties[i].SetValue( propValue ); |
|
229 break; |
|
230 } |
|
231 default: |
|
232 { |
|
233 break; |
|
234 } |
|
235 } |
|
236 propertyFound = ETrue; |
|
237 } |
|
238 } |
|
239 } |
|
240 |
|
241 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::FindPropertyL() - return" ) ) ); |
|
242 } |
|
243 |
|
244 // --------------------------------------------------------------------------- |
|
245 // CSsyReferenceChannel::GetProperties |
|
246 // --------------------------------------------------------------------------- |
|
247 // |
|
248 void CSsyReferenceChannel::GetProperties( RSensrvPropertyList& aPropertyList ) |
|
249 { |
|
250 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::GetProperties()" ) ) ); |
|
251 // Copy properties one by one to param aPropertyList |
|
252 TInt propCount( iProperties.Count() ); |
|
253 RSensrvPropertyList propList( propCount ); |
|
254 |
|
255 for ( TInt i = 0; i < propCount; i++ ) |
|
256 { |
|
257 propList.Append( iProperties[i] ); |
|
258 } |
|
259 |
|
260 aPropertyList = propList; |
|
261 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::GetProperties() - return" ) ) ); |
|
262 } |
|
263 |
|
264 // --------------------------------------------------------------------------- |
|
265 // CSsyReferenceChannel::UpdateState |
|
266 // --------------------------------------------------------------------------- |
|
267 // |
|
268 void CSsyReferenceChannel::UpdateState( const TSsyReferenceChannelState aNewState ) |
|
269 { |
|
270 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::UpdateState() - %i" ), aNewState ) ); |
|
271 iState = aNewState; |
|
272 } |
|
273 |
|
274 // --------------------------------------------------------------------------- |
|
275 // CSsyReferenceChannel::ProcessResponse |
|
276 // --------------------------------------------------------------------------- |
|
277 // |
|
278 void CSsyReferenceChannel::ProcessResponse( TSsyReferenceMsg* aMessage ) |
|
279 { |
|
280 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ProcessResponse()" ) ) ); |
|
281 |
|
282 if ( aMessage ) |
|
283 { |
|
284 switch ( aMessage->Function() ) |
|
285 { |
|
286 case ESsyReferenceOpenChannelResp: |
|
287 { |
|
288 // Open channel specific handling here |
|
289 TRAPD( err, HandleOpenChannelRespL( aMessage->Error() ) ); |
|
290 if ( KErrNone != err ) |
|
291 { |
|
292 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ProcessResponse() - Error opening channel: %i" ), err ) ); |
|
293 } |
|
294 break; |
|
295 } |
|
296 case ESsyReferenceDataItemReceived: |
|
297 { |
|
298 // Send data item to data provider |
|
299 TRAPD( err, iChannelDataProvider->ChannelDataReceivedL( aMessage ) ); |
|
300 if ( KErrNone != err ) |
|
301 { |
|
302 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ProcessResponse() - Error receiving data: %i" ), err ) ); |
|
303 } |
|
304 break; |
|
305 } |
|
306 case ESsyReferenceCloseChannelResp: |
|
307 { |
|
308 // Close channel specific handling here |
|
309 HandleCloseChannelResp(); |
|
310 break; |
|
311 } |
|
312 default: |
|
313 { |
|
314 // This command was not intended to process here, try Control class |
|
315 iSsyControl.ProcessResponse( aMessage ); |
|
316 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ProcessResponse() - Unknown function" ) ) ); |
|
317 } |
|
318 } |
|
319 } |
|
320 |
|
321 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::ProcessResponse() - return" ) ) ); |
|
322 } |
|
323 |
|
324 // --------------------------------------------------------------------------- |
|
325 // CSsyReferenceChannel::OpenChannel |
|
326 // --------------------------------------------------------------------------- |
|
327 // |
|
328 TInt CSsyReferenceChannel::OpenChannel() |
|
329 { |
|
330 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::OpenChannel()" ) ) ); |
|
331 |
|
332 TInt err( KErrAlreadyExists ); |
|
333 |
|
334 // Check that this channel is not already open |
|
335 if ( ESsyReferenceChannelIdle == iState ) |
|
336 { |
|
337 // Update state and issue request. Will continue in HandleOpenChannelResp |
|
338 UpdateState( ESsyReferenceChannelOpening ); |
|
339 |
|
340 // Create message with function spesific information |
|
341 // and pass it to command handler |
|
342 err = iCmdHandler->ProcessCommand( TSsyReferenceMsg( ChannelId(), ESsyReferenceOpenChannel ) ); |
|
343 } |
|
344 |
|
345 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::OpenChannel() - return" ) ) ); |
|
346 return err; |
|
347 } |
|
348 |
|
349 // --------------------------------------------------------------------------- |
|
350 // CSsyReferenceChannel::HandleOpenChannelResp |
|
351 // --------------------------------------------------------------------------- |
|
352 // |
|
353 void CSsyReferenceChannel::HandleOpenChannelRespL( const TInt aError ) |
|
354 { |
|
355 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::HandleOpenChannelResp()" ) ) ); |
|
356 |
|
357 // Open channel asynhronously and complete request with MSsyCallback::ChannelOpened() when |
|
358 // channel is opened. |
|
359 |
|
360 // Create instance of the data provider of this channel |
|
361 iChannelDataProvider = CSsyReferenceChannelDataProvider::NewL( *this ); |
|
362 // Create instance of the property provider of this channel |
|
363 iChannelPropertyProvider = CSsyReferencePropertyProvider::NewL( *this ); |
|
364 |
|
365 TInt error( aError ); |
|
366 |
|
367 // If channel opening succeeds, update state to Open |
|
368 if ( KErrNone == aError ) |
|
369 { |
|
370 // Update state to Open |
|
371 UpdateState( ESsyReferenceChannelOpen ); |
|
372 // Get channel properties |
|
373 TRAP( error, iSsyControl.SsyConfig().GetChannelPropertiesL( ChannelId(), iProperties ) ); |
|
374 } |
|
375 else |
|
376 { |
|
377 // Channel opening failed, back to idle |
|
378 UpdateState( ESsyReferenceChannelIdle ); |
|
379 } |
|
380 |
|
381 // Complete transaction |
|
382 iSsyControl.SsyCallback().ChannelOpened( ChannelId(), |
|
383 error, |
|
384 iChannelDataProvider, |
|
385 iChannelPropertyProvider ); |
|
386 |
|
387 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::HandleOpenChannelResp() - return" ) ) ); |
|
388 } |
|
389 |
|
390 // --------------------------------------------------------------------------- |
|
391 // CSsyReferenceChannel::CloseChannel |
|
392 // --------------------------------------------------------------------------- |
|
393 // |
|
394 TInt CSsyReferenceChannel::CloseChannel() |
|
395 { |
|
396 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::CloseChannel()" ) ) ); |
|
397 |
|
398 TInt err( KErrNotFound ); |
|
399 |
|
400 // Check that this channel is open |
|
401 if ( ESsyReferenceChannelOpen == iState ) |
|
402 { |
|
403 // Update state and issue request. Will continue in HandleCloseChannelResp |
|
404 UpdateState( ESsyReferenceChannelClosing ); |
|
405 // Create message with function spesific information |
|
406 // and pass it to command handler |
|
407 err = iCmdHandler->ProcessCommand( TSsyReferenceMsg( ChannelId(), ESsyReferenceCloseChannel ) ); |
|
408 } |
|
409 |
|
410 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::CloseChannel() - return" ) ) ); |
|
411 return err; |
|
412 } |
|
413 |
|
414 // --------------------------------------------------------------------------- |
|
415 // CSsyReferenceChannel::HandleCloseChannelResp |
|
416 // --------------------------------------------------------------------------- |
|
417 // |
|
418 void CSsyReferenceChannel::HandleCloseChannelResp() |
|
419 { |
|
420 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::HandleCloseChannelResp()" ) ) ); |
|
421 |
|
422 // Close channel and complete request with MSsyCallback::ChannelClosed() when |
|
423 // channel is closed. |
|
424 |
|
425 // Delete providers |
|
426 delete iChannelDataProvider; |
|
427 iChannelDataProvider = NULL; |
|
428 |
|
429 delete iChannelPropertyProvider; |
|
430 iChannelPropertyProvider = NULL; |
|
431 |
|
432 // Update state to idle |
|
433 UpdateState( ESsyReferenceChannelIdle ); |
|
434 |
|
435 // Reset properties |
|
436 iProperties.Reset(); |
|
437 |
|
438 // Complete transaction |
|
439 iSsyControl.SsyCallback().ChannelClosed( ChannelId() ); |
|
440 |
|
441 COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceChannel::HandleCloseChannelResp() - return" ) ) ); |
|
442 } |
|
443 |
|