phoneengine/networkhandlingstarter/src/cnetworklistener.cpp
changeset 64 6aaf0276100e
parent 56 5bcb308bd24d
child 65 2a5d4ab426d3
equal deleted inserted replaced
56:5bcb308bd24d 64:6aaf0276100e
    16  */
    16  */
    17 #include <networkhandlingproxy.h>
    17 #include <networkhandlingproxy.h>
    18 #include <cnwsession.h>
    18 #include <cnwsession.h>
    19 #include <BTSapDomainPSKeys.h>
    19 #include <BTSapDomainPSKeys.h>
    20 #include <startupdomainpskeys.h>
    20 #include <startupdomainpskeys.h>
       
    21 #include <PsetContainer.h>
       
    22 #include <PsetNetwork.h>
       
    23 #include <PsetSAObserver.h>
    21 
    24 
    22 #include "cnetworklistener.h"
    25 #include "cnetworklistener.h"
    23 #include "mnetworklistenerobserver.h"
    26 #include "mnetworklistenerobserver.h"
    24 #include "networkhandlingstarterlogging.h"
    27 #include "networkhandlingstarterlogging.h"
    25 
    28 
    26 // Constants
    29 // Constants
    27 
    30 
    28 // 1-minute timeout before showing soft notification
    31 // 1-minute timeout before showing soft notification
    29 const TInt KNetworkLostTimeout = 60*1000000;
    32 const TInt KNetworkLostTimeout = 60*1000000;
       
    33 const TInt KSimRefreshAsynronationTimeout = 1000000;
    30 
    34 
    31 // ======== MEMBER FUNCTIONS ========
    35 // ======== MEMBER FUNCTIONS ========
    32 
    36 
    33 /*!
    37 /*!
    34     Constructor of CNetworkListener.
    38     Constructor of CNetworkListener.
    53     //Create network handling engine session.
    57     //Create network handling engine session.
    54     iSession = CreateL(*this, iInfo);
    58     iSession = CreateL(*this, iInfo);
    55     iTimer = CPeriodic::NewL(CActive::EPriorityStandard);
    59     iTimer = CPeriodic::NewL(CActive::EPriorityStandard);
    56     QT_TRYCATCH_LEAVING(iDeviceInfo = new QSystemDeviceInfo())
    60     QT_TRYCATCH_LEAVING(iDeviceInfo = new QSystemDeviceInfo())
    57     
    61     
       
    62     iContainer = CPsetContainer::NewL();
       
    63     iRefreshHandler = iContainer->CreateRefreshHandlerL();
       
    64     iRefreshHandler->NotifyFileChangeL(
       
    65             *this,
       
    66             KCsp1Ef,
       
    67             EFileChangeNotification );
       
    68     iSettingsEngine = iContainer->CreateNetworkObjectL(*this);
       
    69     
    58     DPRINT << ": OUT";
    70     DPRINT << ": OUT";
    59 }
    71 }
    60 
    72 
    61 /*!
    73 /*!
    62     Constructor of CNetworkListener.
    74     Constructor of CNetworkListener.
    82     DPRINT << ": IN";
    94     DPRINT << ": IN";
    83     
    95     
    84     delete iSession;
    96     delete iSession;
    85     delete iTimer;
    97     delete iTimer;
    86     delete iDeviceInfo;
    98     delete iDeviceInfo;
       
    99     delete iSettingsEngine;
       
   100     delete iRefreshHandler;
       
   101     delete iContainer;    
    87     
   102     
    88     DPRINT << ": OUT";
   103     DPRINT << ": OUT";
    89 }
   104 }
    90 
   105 
    91 /*!
   106 /*!
   245     DPRINT << ": OUT";
   260     DPRINT << ": OUT";
   246     
   261     
   247     return simState == ESimUsable && err == KErrNone;
   262     return simState == ESimUsable && err == KErrNone;
   248 }
   263 }
   249 
   264 
       
   265 /*!
       
   266     CNetworkListener::AllowRefresh
       
   267  */
       
   268 TBool CNetworkListener::AllowRefresh(
       
   269                 const TSatRefreshType aType,
       
   270                 const TSatElementaryFiles aFiles )
       
   271 {
       
   272     DPRINT << "aType: " << aType;
       
   273     DPRINT << "aFiles: " << aFiles;
       
   274     
       
   275     TBool allowRefresh = ETrue;
       
   276     if ( iSettingsEngine->IsCallActive() == CPsetSAObserver::EPSetCallActive )
       
   277         {
       
   278         allowRefresh = EFalse;
       
   279         }
       
   280 
       
   281     DPRINT << ": OUT allowRefresh " << allowRefresh;
       
   282     
       
   283     return allowRefresh;
       
   284 }
       
   285 
       
   286 /*!
       
   287     CNetworkListener::Refresh
       
   288  */
       
   289 void CNetworkListener::Refresh(
       
   290                 const TSatRefreshType aType,
       
   291                 const TSatElementaryFiles aFiles )
       
   292 {
       
   293     DPRINT << ": IN";
       
   294     
       
   295     if ((aType != EFileChangeNotification) ||
       
   296         ((aType == EFileChangeNotification) &&
       
   297         (aFiles & KCsp1Ef)))
       
   298         {
       
   299         MPsetNetworkSelect::TSelectMode mode;
       
   300         iSettingsEngine->GetNetworkSelectMode(mode);
       
   301         DPRINT << "mode " << mode;
       
   302         if (mode == MPsetNetworkSelect::ENetSelectModeManual) {
       
   303             TPSetChangedCspSetting changedCspSettings;
       
   304             TPSetChangedCspSetting newValues;
       
   305             TInt err = iRefreshHandler->ChangedCspSettings(changedCspSettings, newValues);
       
   306             if ((changedCspSettings & EPSetNetSelSup) && 
       
   307                 !(newValues & EPSetNetSelSup) &&
       
   308                 (err == KErrNone)) {
       
   309                 DPRINT << "Network selection not supported ";
       
   310                 // Network selection mode can't change during SIM refresh,
       
   311                 // start 1 second timer.
       
   312                 iTimer->Cancel();
       
   313                 iTimer->Start(KSimRefreshAsynronationTimeout,
       
   314                               KSimRefreshAsynronationTimeout,
       
   315                               TCallBack( NWSimRefreshCallBack, this ));
       
   316             }
       
   317         }
       
   318     }
       
   319     
       
   320     DPRINT << ": OUT";
       
   321 }
       
   322 
       
   323 /*!
       
   324     CNetworkListener::HandleNetworkInfoReceivedL
       
   325  */
       
   326 void CNetworkListener::HandleNetworkInfoReceivedL( 
       
   327         const CNetworkInfoArray* /*aInfoArray*/, const TInt /*aResult*/ )
       
   328 {
       
   329     DPRINT;
       
   330 }
       
   331 
       
   332 /*!
       
   333     CNetworkListener::HandleCurrentNetworkInfoL
       
   334  */
       
   335 void CNetworkListener::HandleCurrentNetworkInfoL( 
       
   336         const MPsetNetworkSelect::TCurrentNetworkInfo& /*aCurrentInfo*/, 
       
   337         const TInt /*aResult*/ )
       
   338 {
       
   339     DPRINT;
       
   340 }
       
   341 
       
   342 /*!
       
   343     CNetworkListener::HandleNetworkChangedL
       
   344  */
       
   345 void CNetworkListener::HandleNetworkChangedL( 
       
   346         const MPsetNetworkSelect::TNetworkInfo& /*aCurrentInfo*/,
       
   347         const MPsetNetworkSelect::TCurrentNetworkStatus /*aStatus*/, 
       
   348         const TInt /*aResult*/ )
       
   349 {
       
   350     /**
       
   351     *  DEPRECATED.
       
   352     */
       
   353 }
       
   354 
       
   355 /*!
       
   356     CNetworkListener::HandleNetworkChangedL
       
   357  */
       
   358 void CNetworkListener::HandleNetworkChangedL( 
       
   359         const MPsetNetworkSelect::TNetworkInfo& /*aCurrentInfo*/,
       
   360         const RMobilePhone::TMobilePhoneRegistrationStatus& /*aStatus*/, 
       
   361         const TInt /*aResult*/ )
       
   362 {
       
   363     DPRINT;
       
   364 }
       
   365 
       
   366 /*!
       
   367     CNetworkListener::HandleSearchingNetworksL
       
   368  */
       
   369 void CNetworkListener::HandleSearchingNetworksL( TServiceRequest /*aRequest*/ )
       
   370 {
       
   371     DPRINT;
       
   372 }
       
   373 
       
   374 /*!
       
   375     CNetworkListener::HandleRequestingSelectedNetworkL
       
   376  */
       
   377 void CNetworkListener::HandleRequestingSelectedNetworkL( TBool /*aOngoing*/ )
       
   378 {
       
   379     DPRINT; 
       
   380 }
       
   381 
       
   382 /*!
       
   383     CNetworkListener::HandleCallActivatedL
       
   384  */
       
   385 void CNetworkListener::HandleCallActivatedL()
       
   386 {
       
   387     DPRINT;
       
   388 }
       
   389 
       
   390 /*!
       
   391     CNetworkListener::HandleNetworkErrorL
       
   392  */
       
   393 void CNetworkListener::HandleNetworkErrorL( 
       
   394         const MPsetNetworkInfoObserver::TServiceRequest /*aRequest*/,
       
   395         const TInt /*aError*/ )
       
   396 {
       
   397     DPRINT;
       
   398 }
       
   399 
       
   400 /*!
       
   401     CNetworkListener::NWSimRefreshCallBack.
       
   402  */
       
   403 TInt CNetworkListener::NWSimRefreshCallBack(TAny* aParam)
       
   404 {
       
   405     DPRINT << ": IN";
       
   406     
       
   407     CNetworkListener* self = 
       
   408         reinterpret_cast< CNetworkListener* >( aParam );
       
   409     
       
   410     if ( self ) {
       
   411         self->iTimer->Cancel();
       
   412         //Change the network mode to Automatic.
       
   413         MPsetNetworkSelect::TNetworkInfo info;
       
   414         info.iMode = MPsetNetworkSelect::ENetSelectModeAutomatic;
       
   415         DPRINT << ": set network mode to automatic";
       
   416         TRAP_IGNORE(self->iSettingsEngine->SelectNetworkL(info));
       
   417     }
       
   418     
       
   419     DPRINT << ": OUT";
       
   420     return KErrNone;
       
   421 }
       
   422 
   250 // End of file
   423 // End of file
   251     
   424