1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Network info listener

    15 *

    16 */

    17 

    18 #include <NetworkHandlingProxy.h>

    19 #include <CNWSession.h>

    20 #include "ainetworklistener.h"

    21 #include "ainetworkobserver.h"

    22 

    23 /// ======== MEMBER FUNCTIONS ========

    24 

    25 // -----------------------------------------------------------------------------

    26 // Two-phased constructor. Can leave.

    27 // -----------------------------------------------------------------------------

    28 // 

    29 CAiNetworkListener* CAiNetworkListener::NewL(MAiNetworkObserver& aNetworkObserver)

    30     {

    31     CAiNetworkListener* self = new (ELeave) CAiNetworkListener(aNetworkObserver);

    32     CleanupStack::PushL( self );

    33     self->ConstructL();

    34     CleanupStack::Pop();

    35     return self;

    36     }

    37 

    38 CAiNetworkListener::CAiNetworkListener(MAiNetworkObserver& aNetworkObserver)

    39 :iObserver(aNetworkObserver)

    40     {

    41     }

    42 

    43 void CAiNetworkListener::ConstructL()

    44     {

    45     //Create network handling engine session.

    46     iSession = CreateL( *this, iInfo );

    47     iCurrentNwState = MAiNetworkObserver::ENone;

    48     }

    49 

    50 CAiNetworkListener::~CAiNetworkListener()

    51     {

    52     delete iSession;

    53     }

    54 

    55 void CAiNetworkListener::HandleNetworkMessage( const TNWMessages aMessage )

    56     {

    57     TBool hasNetInfoChanged = HasNetworkInfoChanged( aMessage );

    58     if ( !hasNetInfoChanged )

    59         {

    60         return;

    61         }

    62         

    63     // Interpret new nw state

    64     MAiNetworkObserver::TNetworkState newState;

    65     newState= InterpretNWMessage(aMessage,iInfo);

    66 

    67     // Inform observer of only new nw states (TNetworkState)

    68     if (newState != iCurrentNwState)

    69         {

    70         iObserver.HandleNetworkStateChange(newState);

    71         }    

    72     

    73     // Store new nw state

    74     iCurrentNwState= newState;

    75   

    76     }

    77 

    78 MAiNetworkObserver::TNetworkState CAiNetworkListener::InterpretNWMessage(const TNWMessages aMessage, const TNWInfo aNWInfo)

    79     {

    80     MAiNetworkObserver::TNetworkState nwstate = MAiNetworkObserver::ENone;

    81     

    82     switch (aMessage)

    83         {

    84         case MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange:

    85         case MNWMessageObserver::ENWMessageCurrentHomeZoneMessage:

    86             {

    87             switch (aNWInfo.iRegistrationStatus)

    88                 {

    89                 case ENWRegisteredRoaming:

    90                     nwstate = MAiNetworkObserver::ERoaming;

    91                     break;

    92                 case ENWRegisteredOnHomeNetwork:

    93                     nwstate = MAiNetworkObserver::EHomeNetwork;

    94                     break;  

    95                     

    96                 default:

    97                     // unknown state

    98                     break;

    99                 }

   100             }

   101        }

   102     

   103     return nwstate;

   104     }

   105 

   106 void CAiNetworkListener::HandleNetworkError( const TNWOperation aOperation, TInt /*aErrorCode*/ )

   107     {

   108      switch ( aOperation )

   109         {

   110         case MNWMessageObserver::ENWGetNetworkProviderName:

   111             iReceivedMessageFlags |= ENetworkProviderNameReceived;

   112             iReceivedMessageFlags &= ~ENetworkProviderNameOk;

   113             iInfo.iNPName.Zero();

   114             break;

   115         case MNWMessageObserver::ENWGetProgrammableOperatorName:

   116             iReceivedMessageFlags |= EProgrammableOperatorInfoReceived;

   117             iReceivedMessageFlags &= ~EProgrammableOperatorInfoReceivedOk;

   118             iInfo.iOperatorNameInfo.iName.Zero();

   119             break;

   120         case MNWMessageObserver::ENWGetServiceProviderName:

   121             iReceivedMessageFlags |= EServiceProviderNameReceived;

   122             iReceivedMessageFlags &= ~EServiceProviderNameOk;

   123             iInfo.iServiceProviderNameDisplayReq = RMobilePhone::KDisplaySPNNotRequired;

   124             iInfo.iSPName.Zero();

   125             iInfo.iPLMNField.Zero();

   126             break;

   127         default:

   128             break;

   129         }

   130     

   131     HandleNetworkMessage( TNWMessages( KErrGeneral ) );

   132     }

   133 

   134 TBool CAiNetworkListener::HasNetworkInfoChanged( const TNWMessages aMessage )

   135     {

   136     TBool result = ETrue;

   137     

   138     // pass through

   139     if ( aMessage == MNWMessageObserver::ENWMessageCurrentHomeZoneMessage   ||

   140          aMessage == MNWMessageObserver::ENWMessageNetworkConnectionFailure ||

   141          aMessage == MNWMessageObserver::ENWMessageCurrentCellInfoMessage   ||

   142          aMessage == MNWMessageObserver::ENWMessageNetworkRegistrationStatusChange )

   143         {

   144         return result;

   145         }

   146     

   147     result = ( iReceivedMessageFlags != iOldReceivedMessageFlags );

   148     

   149     if ( !result )

   150         {

   151          result = 

   152             iInfo.iRegistrationStatus != iOldInfo.iRegistrationStatus;

   153         }

   154 

   155     iOldReceivedMessageFlags = iReceivedMessageFlags;

   156     iOldInfo = iInfo;

   157 

   158     return result;

   159     }

   160 

   161 MAiNetworkObserver::TNetworkState CAiNetworkListener::NetworkState()

   162     {

   163     return iCurrentNwState;

   164     }

   165