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