124 } |
125 } |
125 |
126 |
126 |
127 |
127 // --------------------------------------------------------------------------- |
128 // --------------------------------------------------------------------------- |
128 // From CMusAvaAvailability. |
129 // From CMusAvaAvailability. |
129 // Executes for the availability. |
130 // Executes for the availability |
130 // --------------------------------------------------------------------------- |
131 // --------------------------------------------------------------------------- |
131 // |
132 // |
|
133 |
132 void CMusAvaConnectionAvailability::DoExecuteL() |
134 void CMusAvaConnectionAvailability::DoExecuteL() |
133 { |
135 { |
134 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::DoExecuteL()" ) |
136 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::DoExecuteL()" ) |
135 MMusAvaObserver::TAvailabilityStatus status; |
137 MMusAvaObserver::TAvailabilityStatus status; |
136 MUS_LOG( "mus: [MUSAVA] Check network mode" ) |
138 MUS_LOG( "mus: [MUSAVA] Check network mode" ) |
137 RMobilePhone::TMobilePhoneNetworkMode networkmode = |
139 RMobilePhone::TMobilePhoneNetworkMode networkmode = |
138 iNetworkModeStatus->PhoneNetworkMode(); |
140 iNetworkModeStatus->PhoneNetworkMode(); |
139 if ( networkmode == RMobilePhone::ENetworkModeWcdma|| |
141 |
140 networkmode == RMobilePhone::ENetworkModeTdcdma || |
142 TBool SupportedNetwork = EFalse; |
141 networkmode == RMobilePhone::ENetworkModeCdma95 || |
143 |
142 networkmode == RMobilePhone::ENetworkModeCdma2000 ) |
144 TRAPD( err, SupportedNetwork = MusFactorySettings::IsSupportedL(networkmode) ); |
143 { |
145 |
144 status = NetworkRegistrationAndSettingsL(); |
146 |
145 if ( status == MMusAvaObserver::EMusAvaStatusAvailable ) |
147 if ( err != KErrNone ) |
146 { |
148 { |
147 MUS_LOG( "mus: [MUSAVA] Network available" ) |
149 MUS_LOG1( "mus: [MUSAVA] Reading activation setting error:%d", err ) |
148 SetState( status ); |
150 SetState( MMusAvaObserver::EMusActivationError ); |
149 } |
151 } |
150 else |
152 |
151 { |
153 else if ( SupportedNetwork ) |
152 MUS_LOG1( "mus: [MUSAVA] Activation error: %d", status ) |
154 { |
153 SetState( status ); |
155 if ( networkmode == RMobilePhone::ENetworkModeGsm ) |
154 } |
156 { |
155 } |
157 MUS_LOG( "mus: [MUSAVA] Edge Network Mode allowed in settings " ) |
156 else if( networkmode == RMobilePhone::ENetworkModeGsm) |
|
157 { |
|
158 TInt edgeDtmSupport = KErrNone; |
|
159 TRAPD( err, edgeDtmSupport = |
|
160 MultimediaSharingSettings::EdgeDtmSupportSettingL() ); |
|
161 if( err != KErrNone ) |
|
162 { |
|
163 MUS_LOG1( "mus: [MUSAVA] Reading activation setting error:%d", err ) |
|
164 SetState( MMusAvaObserver::EMusActivationError ); |
|
165 } |
|
166 else if( edgeDtmSupport == MusSettingsKeys::EDtmModeAllowed ) |
|
167 { |
|
168 MUS_LOG( "mus: [MUSAVA] Edge Network Mode allowed in settings " ) |
|
169 if( iConnectionMonitor->ConnectionCount() > 0) |
158 if( iConnectionMonitor->ConnectionCount() > 0) |
170 { |
159 { |
171 MUS_LOG( "mus: [MUSAVA] Atlease one packect connection exists " ) |
160 MUS_LOG( "mus: [MUSAVA] Atlease one packect connection exists " ) |
172 SetState( NetworkRegistrationAndSettingsL() ); |
161 SetState( NetworkRegistrationAndSettingsL() ); |
173 } |
162 } |
174 else |
163 else |
175 { |
164 { |
176 MUS_LOG( "mus: [MUSAVA] No Packet connection exists now." ) |
165 MUS_LOG( "mus: [MUSAVA] No Packet connection exists now." ) |
177 SetState( MMusAvaObserver::EMusAvaEdgeDtmStatusUnknown ); |
166 SetState( MMusAvaObserver::EMusAvaEdgeDtmStatusUnknown ); |
178 } |
167 } |
179 } |
168 } |
180 else |
169 |
181 { |
170 else |
182 MUS_LOG( "mus: [MUSAVA] Edge Network Mode Not allowed in settings " ) |
171 { |
183 SetState( MMusAvaObserver::EMusAvaNetworkType ); |
172 status = NetworkRegistrationAndSettingsL(); |
184 } |
173 MUS_LOG1( "mus: [MUSAVA] Activation Status: %d", status ) |
185 } |
174 SetState( status ); |
186 else |
175 } |
187 { |
176 } |
|
177 else |
|
178 { |
188 MUS_LOG( "mus: [MUSAVA] Network not available" ) |
179 MUS_LOG( "mus: [MUSAVA] Network not available" ) |
189 SetState( MMusAvaObserver::EMusAvaNetworkType ); |
180 SetState( MMusAvaObserver::EMusAvaNetworkType ); |
190 } |
181 } |
191 |
182 |
192 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::DoExecuteL()" ) |
183 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::DoExecuteL()" ) |
193 } |
184 } |
194 |
185 |
195 |
|
196 // --------------------------------------------------------------------------- |
|
197 // --------------------------------------------------------------------------- |
|
198 // |
|
199 TBool CMusAvaConnectionAvailability::OperatorVariant() |
|
200 { |
|
201 MusSettingsKeys::TOperatorVariant variantValue = MusSettingsKeys::EStandard; |
|
202 TRAPD( error, variantValue = |
|
203 MultimediaSharingSettings::OperatorVariantSettingL() ); |
|
204 |
|
205 return ( variantValue == MusSettingsKeys::EOperatorSpecific && |
|
206 error == KErrNone ); |
|
207 |
|
208 } |
|
209 |
186 |
210 // --------------------------------------------------------------------------- |
187 // --------------------------------------------------------------------------- |
211 // From CMusAvaAvailability. |
188 // From CMusAvaAvailability. |
212 // Stops execution. |
189 // Stops execution. |
213 // --------------------------------------------------------------------------- |
190 // --------------------------------------------------------------------------- |
233 MMusAvaObserver::TAvailabilityName CMusAvaConnectionAvailability::Name() |
210 MMusAvaObserver::TAvailabilityName CMusAvaConnectionAvailability::Name() |
234 { |
211 { |
235 return MMusAvaObserver::EMusAvaBearerStatus; |
212 return MMusAvaObserver::EMusAvaBearerStatus; |
236 } |
213 } |
237 |
214 |
238 |
215 // --------------------------------------------------------------------------- |
239 // --------------------------------------------------------------------------- |
216 // CMusAvaConnectionAvailability::PhoneNetworkModeStatus |
240 // CMusAvaConnectionAvailability::PhoneNetworkModeStatus |
|
241 // |
217 // |
242 // --------------------------------------------------------------------------- |
218 // --------------------------------------------------------------------------- |
243 // |
219 // |
244 void CMusAvaConnectionAvailability::PhoneNetworkModeStatus( |
220 void CMusAvaConnectionAvailability::PhoneNetworkModeStatus( |
245 RMobilePhone::TMobilePhoneNetworkMode aStatus ) |
221 RMobilePhone::TMobilePhoneNetworkMode aStatus ) |
246 { |
222 { |
247 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
223 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
248 PhoneNetworkModeStatus()" ) |
224 PhoneNetworkModeStatus()" ) |
249 MUS_LOG1( "mus: [MUSAVA] Mobile Phone Network Status = ", aStatus ) |
225 MUS_LOG1( "mus: [MUSAVA] Mobile Phone Network Status = ", aStatus ) |
250 |
226 |
251 switch ( aStatus ) |
227 TBool SupportedNetwork = EFalse; |
252 { |
228 |
253 case RMobilePhone::ENetworkModeWcdma : |
229 TRAPD( err, SupportedNetwork = MusFactorySettings::IsSupportedL(aStatus) ); |
254 case RMobilePhone::ENetworkModeTdcdma : |
230 |
255 case RMobilePhone::ENetworkModeCdma95: |
231 if ( err != KErrNone || !SupportedNetwork ) |
256 case RMobilePhone::ENetworkModeCdma2000: |
232 { |
257 { |
233 MUS_LOG( "mus: [MUSAVA] Network not available" ) |
258 MMusAvaObserver::TAvailabilityStatus status = |
234 SetState( MMusAvaObserver::EMusAvaNetworkType ); |
259 MMusAvaObserver::EMusActivationError; |
235 } |
260 TRAP_IGNORE( status = NetworkRegistrationAndSettingsL() ); |
236 else |
261 SetState( status ); |
237 { |
262 break; |
238 MMusAvaObserver::TAvailabilityStatus status = |
263 } |
239 MMusAvaObserver::EMusActivationError; |
264 case RMobilePhone::ENetworkModeGsm : // For EDGE /DTM support |
240 TRAP_IGNORE( status = NetworkRegistrationAndSettingsL() ); |
265 { |
241 SetState( status ); |
266 TInt edgeDtmSupport = 0; |
242 } |
267 TRAPD( err, edgeDtmSupport = |
243 |
268 MultimediaSharingSettings::EdgeDtmSupportSettingL() ); |
|
269 if( err != KErrNone ) |
|
270 { |
|
271 MUS_LOG1( "mus: [MUSAVA] Reading activation setting error:%d", err ) |
|
272 SetState( MMusAvaObserver::EMusActivationError ); |
|
273 } |
|
274 else if( edgeDtmSupport == MusSettingsKeys::EDtmModeAllowed ) |
|
275 { |
|
276 MUS_LOG( "mus: [MUSAVA] Edge Network supported " ) |
|
277 SetState( MMusAvaObserver::EMusAvaEdgeDtmStatusUnknown ); |
|
278 } |
|
279 else |
|
280 { |
|
281 SetState( MMusAvaObserver::EMusAvaNetworkType ); |
|
282 } |
|
283 break; |
|
284 } |
|
285 default : |
|
286 { |
|
287 SetState( MMusAvaObserver::EMusAvaNetworkType ); |
|
288 } |
|
289 } |
|
290 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
244 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
291 PhoneNetworkModeStatus()" ) |
245 PhoneNetworkModeStatus()" ) |
292 } |
246 } |
293 |
247 |
294 |
|
295 // --------------------------------------------------------------------------- |
248 // --------------------------------------------------------------------------- |
296 // CMusAvaConnectionAvailability::NetworkRegistrationStatus |
249 // CMusAvaConnectionAvailability::NetworkRegistrationStatus |
297 // |
250 // |
298 // --------------------------------------------------------------------------- |
251 // --------------------------------------------------------------------------- |
299 // |
252 // |
300 void CMusAvaConnectionAvailability::NetworkRegistrationStatus( |
253 void CMusAvaConnectionAvailability::NetworkRegistrationStatus( |
301 RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus ) |
254 RMobilePhone::TMobilePhoneRegistrationStatus aRegStatus ) |
302 { |
255 { |
303 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
256 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
304 NetworkRegistrationStatus()" ) |
257 NetworkRegistrationStatus()" ) |
305 MUS_LOG1( "Mobile Phone Network Status = ", aRegStatus ) |
258 MUS_LOG1( "Mobile Phone Network Status = ", aRegStatus ) |
306 |
259 |
307 if( OperatorVariant() && |
260 MusSettingsKeys::TActivation activation = MusSettingsKeys::ENever; |
|
261 |
|
262 TRAPD( err, activation = MultimediaSharingSettings::ActivationSettingL() ); |
|
263 if( err != KErrNone ) |
|
264 { |
|
265 MUS_LOG1( "mus: [MUSAVA] Reading activation setting error:%d", err ) |
|
266 SetState( MMusAvaObserver::EMusActivationError ); |
|
267 } |
|
268 else |
|
269 { |
|
270 if( activation == MusSettingsKeys::EActiveInHomeNetworks && |
308 aRegStatus != RMobilePhone::ERegisteredOnHomeNetwork ) |
271 aRegStatus != RMobilePhone::ERegisteredOnHomeNetwork ) |
309 { |
272 { |
310 MUS_LOG( "mus: [MUSAVA] Roaming not allowed" ) |
273 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
311 SetState( MMusAvaObserver::EMusAvaRoamingError ); |
274 NetworkRegistrationStatus()" ) |
|
275 SetState( MMusAvaObserver::EMusAvaRoamingError ); |
|
276 } |
312 } |
277 } |
313 |
278 |
314 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
279 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
315 NetworkRegistrationStatus()" ) |
280 NetworkRegistrationStatus()" ) |
316 } |
281 } |
317 |
282 |
318 |
283 |
319 // --------------------------------------------------------------------------- |
284 // --------------------------------------------------------------------------- |
320 // CMusAvaConnectionAvailability::EventL |
285 // CMusAvaConnectionAvailability::EventL |
347 if ( err == KErrNotFound ) |
312 if ( err == KErrNotFound ) |
348 { |
313 { |
349 SetState( MMusAvaObserver::EMusAvaConnectionErr ); |
314 SetState( MMusAvaObserver::EMusAvaConnectionErr ); |
350 } |
315 } |
351 else |
316 else |
352 { |
317 { |
353 iConnectionMonitor->SetConnectionID( connectionId ); |
318 iConnectionMonitor->SetConnectionID( connectionId ); |
354 } |
319 } |
355 } |
320 } |
356 break; |
321 break; |
357 } |
322 } |
358 case EConnMonDeleteConnection: |
323 case EConnMonDeleteConnection: |
359 { |
324 { |
360 MUS_LOG( "mus: [MUSAVA] Event type = EConnMonDeleteConnection" ) |
325 MUS_LOG( "mus: [MUSAVA] Event type = EConnMonDeleteConnection" ) |
361 if( connId == musConnID ) |
326 if( connId == musConnID ) |
362 { |
327 { |
363 SetState( MMusAvaObserver::EMusAvaConnectionErr ); |
328 SetState( MMusAvaObserver::EMusAvaConnectionErr ); |
364 } |
329 } |
365 break; |
330 break; |
366 } |
331 } |
367 case EConnMonConnectionStatusChange: |
332 |
|
333 case EConnMonConnectionStatusChange: |
368 { |
334 { |
369 MUS_LOG( "mus: [MUSAVA] Event type = \ |
335 MUS_LOG( "mus: [MUSAVA] Event type = \ |
370 EConnMonConnectionStatusChange" ) |
336 EConnMonConnectionStatusChange" ) |
371 const CConnMonConnectionStatusChange* connectionStatusChange |
337 const CConnMonConnectionStatusChange* connectionStatusChange |
372 = (const CConnMonConnectionStatusChange*)(&aConnMonEvent); |
338 = (const CConnMonConnectionStatusChange*)(&aConnMonEvent); |
373 TInt connStatus = connectionStatusChange->ConnectionStatus(); |
339 TInt connStatus = connectionStatusChange->ConnectionStatus(); |
374 MUS_LOG1( "mus: [MUSAVA] ConnectionStatus = %d", connStatus ) |
340 MUS_LOG1( "mus: [MUSAVA] ConnectionStatus = %d", connStatus ) |
375 if ( connId == musConnID ) |
341 if ( connId == musConnID ) |
389 SetState( NetworkRegistrationAndSettingsL() ); |
355 SetState( NetworkRegistrationAndSettingsL() ); |
390 } |
356 } |
391 } |
357 } |
392 break; |
358 break; |
393 } |
359 } |
394 case EConnMonNetworkStatusChange: |
360 case EConnMonNetworkStatusChange: |
395 { |
361 { |
396 MUS_LOG( "mus: [MUSAVA] Event type = EConnMonNetworkStatusChange" ) |
362 MUS_LOG( "mus: [MUSAVA] Event type = EConnMonNetworkStatusChange" ) |
397 const CConnMonNetworkStatusChange* networkStatusChange |
363 const CConnMonNetworkStatusChange* networkStatusChange |
398 = (const CConnMonNetworkStatusChange*)(&aConnMonEvent); |
364 = (const CConnMonNetworkStatusChange*)(&aConnMonEvent); |
399 TInt networkStatus = networkStatusChange->NetworkStatus(); |
365 TInt networkStatus = networkStatusChange->NetworkStatus(); |
400 MUS_LOG1( "mus: [MUSAVA] NetworkStatus = %d", networkStatus ) |
366 MUS_LOG1( "mus: [MUSAVA] NetworkStatus = %d", networkStatus ) |
401 if( connId == EBearerIdWCDMA || connId == EBearerIdWcdmaCSD ) |
367 if( connId == EBearerIdWCDMA || connId == EBearerIdWcdmaCSD ) |
402 { |
368 { |
403 if( EConnMonStatusAttached == networkStatus || |
369 if( EConnMonStatusAttached == networkStatus || |
404 EConnMonStatusActive == networkStatus ) |
370 EConnMonStatusActive == networkStatus ) |
405 { |
371 { |
406 SetState( NetworkRegistrationAndSettingsL() ); |
372 SetState( NetworkRegistrationAndSettingsL() ); |
407 } |
373 } |
408 else |
374 else |
409 { |
375 { |
410 SetState( MMusAvaObserver::EMusAvaConnectionErr ); |
376 SetState( MMusAvaObserver::EMusAvaConnectionErr ); |
411 } |
377 } |
412 } |
378 } |
413 break; |
379 break; |
414 } |
380 } |
415 case EConnMonNetworkRegistrationChange: |
381 case EConnMonNetworkRegistrationChange: |
416 { |
382 { |
417 MUS_LOG( "mus: [MUSAVA] Event type = \ |
383 MUS_LOG( "mus: [MUSAVA] Event type = \ |
418 EConnMonNetworkRegistrationChange" ) |
384 EConnMonNetworkRegistrationChange" ) |
419 const CConnMonNetworkRegistrationChange* registrationChange |
385 const CConnMonNetworkRegistrationChange* registrationChange |
420 = (const CConnMonNetworkRegistrationChange*)(&aConnMonEvent); |
386 = (const CConnMonNetworkRegistrationChange*)(&aConnMonEvent); |
421 TInt registrationStatus = registrationChange->RegistrationStatus(); |
387 TInt registrationStatus = registrationChange->RegistrationStatus(); |
422 MUS_LOG1( "mus: [MUSAVA] RegistrationStatus = %d", |
388 MUS_LOG1( "mus: [MUSAVA] RegistrationStatus = %d", |
423 registrationStatus ) |
389 registrationStatus ) |
424 if( connId == EBearerIdWCDMA || connId == EBearerIdWcdmaCSD ) |
390 if( connId == EBearerIdWCDMA || connId == EBearerIdWcdmaCSD ) |
425 { |
391 { |
426 if ( ENetworkRegistrationRoaming == registrationStatus ) |
392 if ( ENetworkRegistrationRoaming == registrationStatus ) |
427 { |
393 { |
428 SetState( MMusAvaObserver::EMusAvaRoamingError ); |
394 SetState( MMusAvaObserver::EMusAvaRoamingError ); |
429 } |
395 } |
430 else |
396 else |
431 { |
397 { |
432 SetState( NetworkRegistrationAndSettingsL() ); |
398 SetState( NetworkRegistrationAndSettingsL() ); |
433 } |
399 } |
434 } |
400 } |
435 break; |
401 break; |
436 } |
402 } |
437 case EConnMonBearerChange: |
403 case EConnMonBearerChange: |
438 { |
404 { |
439 MUS_LOG( "mus: [MUSAVA] Event type = EConnMonBearerChange" ) |
405 MUS_LOG( "mus: [MUSAVA] Event type = EConnMonBearerChange" ) |
493 // |
468 // |
494 // ------------------------------------------------------------------------- |
469 // ------------------------------------------------------------------------- |
495 // |
470 // |
496 MMusAvaObserver::TAvailabilityStatus CMusAvaConnectionAvailability:: |
471 MMusAvaObserver::TAvailabilityStatus CMusAvaConnectionAvailability:: |
497 ManualActivationL() |
472 ManualActivationL() |
498 { |
473 { |
499 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
474 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
500 ManualActivationL()" ) |
475 ManualActivationL()" ) |
501 |
476 |
502 if( OperatorVariant() ) |
477 MusSettingsKeys::TOperatorVariant operatorVariant = |
|
478 MusSettingsKeys::EStandard; |
|
479 operatorVariant = MultimediaSharingSettings::OperatorVariantSettingL(); |
|
480 |
|
481 if( operatorVariant == MusSettingsKeys::EOperatorSpecific ) |
503 { |
482 { |
504 MUS_LOG( "mus: [MUSAVA] Operator Specific No Manual query" ) |
483 MUS_LOG( "mus: [MUSAVA] Operator Specific No Manual query" ) |
505 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
484 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
506 NetworkRegistrationAndSettingsL()" ) |
485 NetworkRegistrationAndSettingsL()" ) |
507 return MMusAvaObserver::EMusActivationError; |
486 return MMusAvaObserver::EMusActivationError; |
508 } |
487 } |
509 else |
488 else |
510 { |
489 { |
511 if ( iSettings.ManualActivation() == |
490 if ( iSettings.ManualActivation() == |
512 MMusAvaSettings::EActivationAllowed ) |
491 MMusAvaSettings::EActivationAllowed ) |
513 { |
492 { |
514 MUS_LOG( "mus: [MUSAVA] Manual activation allowed" ) |
493 MUS_LOG( "mus: [MUSAVA] Manual activation allowed" ) |
515 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
494 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
516 ManualActivationL()" ) |
495 ManualActivationL()" ) |
517 return MMusAvaObserver::EMusAvaStatusAvailable; |
496 return MMusAvaObserver::EMusAvaStatusAvailable; |
518 } |
497 } |
519 else if ( iSettings.ManualActivation() == |
498 else if ( iSettings.ManualActivation() == |
520 MMusAvaSettings::EActivationNotExecuted ) |
499 MMusAvaSettings::EActivationNotExecuted ) |
521 { |
500 { |
522 MUS_LOG( "mus: [MUSAVA] Manual activation is not executed" ) |
501 MUS_LOG( "mus: [MUSAVA] Manual activation is not executed" ) |
523 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
502 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
524 ManualActivationL()" ) |
503 ManualActivationL()" ) |
525 return MMusAvaObserver::EMusAvaManualActivation; |
504 return MMusAvaObserver::EMusAvaManualActivation; |
526 } |
505 } |
527 else |
506 else |
528 { |
507 { |
529 MUS_LOG( "mus: [MUSAVA] Activation error" ) |
508 MUS_LOG( "mus: [MUSAVA] Activation error" ) |
530 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
509 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
531 ManualActivationL()" ) |
510 ManualActivationL()" ) |
532 return MMusAvaObserver::EMusActivationError; |
511 return MMusAvaObserver::EMusActivationError; |
533 } |
512 } |
534 } |
513 } |
535 } |
514 } |
536 |
515 |
537 // ------------------------------------------------------------------------- |
516 // ------------------------------------------------------------------------- |
538 // CMusAvaConnectionAvailability::NetworkRegistrationAndSettingsL |
517 // CMusAvaConnectionAvailability::NetworkRegistrationAndSettingsL |
539 // |
518 // |
540 // ------------------------------------------------------------------------- |
519 // ------------------------------------------------------------------------- |
541 // |
520 // |
542 MMusAvaObserver::TAvailabilityStatus CMusAvaConnectionAvailability:: |
521 MMusAvaObserver::TAvailabilityStatus CMusAvaConnectionAvailability:: |
543 NetworkRegistrationAndSettingsL() |
522 NetworkRegistrationAndSettingsL() |
544 { |
523 { |
545 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
524 MUS_LOG( "mus: [MUSAVA] -> CMusAvaConnectionAvailability::\ |
546 NetworkRegistrationAndSettingsL()" ) |
525 NetworkRegistrationAndSettingsL()" ) |
547 MUS_LOG( "mus: [MUSAVA] Check registration network status" ) |
526 MUS_LOG( "mus: [MUSAVA] Check registration network status" ) |
548 MUS_LOG( "mus: [MUSAVA] Check roaming" ) |
527 MUS_LOG( "mus: [MUSAVA] Check roaming" ) |
549 |
528 |
550 RMobilePhone::TMobilePhoneRegistrationStatus regStatus; |
529 RMobilePhone::TMobilePhoneRegistrationStatus regStatus; |
551 iNetworkRegistrationStatus->NetworkRegistration( regStatus ); |
530 iNetworkRegistrationStatus->NetworkRegistration( regStatus ); |
554 |
533 |
555 MMusAvaObserver::TAvailabilityStatus status; |
534 MMusAvaObserver::TAvailabilityStatus status; |
556 MusSettingsKeys::TActivation activation = MusSettingsKeys::EAlwaysActive; |
535 MusSettingsKeys::TActivation activation = MusSettingsKeys::EAlwaysActive; |
557 |
536 |
558 activation = MultimediaSharingSettings::ActivationSettingL(); |
537 activation = MultimediaSharingSettings::ActivationSettingL(); |
559 TBool operatorVariant = OperatorVariant(); |
538 |
560 |
|
561 MUS_LOG1( "mus: [MUSAVA] ActivationSetting returned %d", |
539 MUS_LOG1( "mus: [MUSAVA] ActivationSetting returned %d", |
562 activation ) |
540 activation ) |
563 |
541 |
564 //VS off |
542 if ( activation == MusSettingsKeys::EAlwaysActive ) |
565 if ( activation != MusSettingsKeys::EAlwaysActive ) |
543 { |
|
544 status = MMusAvaObserver::EMusAvaStatusAvailable; |
|
545 } |
|
546 else if ( activation == MusSettingsKeys::EActiveInHomeNetworks && |
|
547 regStatus == RMobilePhone::ERegisteredOnHomeNetwork ) |
|
548 { |
|
549 status = MMusAvaObserver::EMusAvaStatusAvailable; |
|
550 } |
|
551 else if( activation == MusSettingsKeys::EActiveInHomeNetworks && |
|
552 regStatus == RMobilePhone::ERegisteredRoaming ) |
|
553 { |
|
554 status = ManualActivationL(); |
|
555 } |
|
556 else |
566 { |
557 { |
567 status = MMusAvaObserver::EMusActivationError; |
558 status = MMusAvaObserver::EMusActivationError; |
568 } |
|
569 //VS on |
|
570 else |
|
571 { |
|
572 //roaming |
|
573 if( regStatus == RMobilePhone::ERegisteredRoaming ) |
|
574 { |
|
575 status = ManualActivationL(); |
|
576 } |
|
577 //other states including also not registered states, thus |
|
578 //failing of PDP context activation will be detected elsewhere |
|
579 else |
|
580 { |
|
581 status = MMusAvaObserver::EMusAvaStatusAvailable; |
|
582 } |
|
583 } |
559 } |
584 |
560 |
585 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
561 MUS_LOG( "mus: [MUSAVA] <- CMusAvaConnectionAvailability::\ |
586 NetworkRegistrationAndSettingsL()" ) |
562 NetworkRegistrationAndSettingsL()" ) |
587 return status; |
563 return status; |
588 } |
564 } |
589 |
565 |
590 |
566 // End of File |
|
567 |