/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  This class creates the ETEL receiver package subcomponents, handles

*                incoming CBS messages and communicates with the server interface.

*      

*

*/

// INCLUDE FILES

		/*****************************************************

		*	Series 60 Customer / ETel

		*	Series 60  ETel API

		*****************************************************/

#include <etelmm.h>

#include <mmlist.h> // CMobilePhoneBroadcastIdList

#include <mmtsy_names.h>

#include "CbsServerConstants.h"

#include "CbsServerPanic.h"

#include "CCbsDbImp.H"

#include "CCbsDbImpTopicList.h"

#include "CCbsDbImpSettings.H"

#include "CCbsRecCollector.h"

#include "CCbsRecDecoder.h"

#include "CCbsRecEtel.h"

#include "CCbsRecEtelMonitor.h"

#include "CCbsRecNetworkListener.h"

#include "CCbsRecMessage.h"

#include "CCbsReceiverHelper.h"

#include "CbsUtils.h"

#include "CCbsEtelMessaging.h"

#include "MCbsEtelMessaging.h"

#include "MCbsMcnSubscriptionsProvider.h"

#include "CCbsSetFilterSettingHandler.h"

#include "CCbsRecWcdmaMessage.h"

#include "CCbsMessageFactory.h"

#include "CCbsLivecastHandler.h"

#include "CbsLogger.h"

#include <centralrepository.h>  // for local variation

#include "cbsinternalcrkeys.h"  // for local variation

#include "cbsvariant.hrh"       // for local variation

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

// -----------------------------------------------------------------------------

// CCbsRecEtel::CCbsRecEtel

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

		/*****************************************************

		*	Series 60 Customer / ETel

		*	Series 60  ETel API

		*****************************************************/

CCbsRecEtel::CCbsRecEtel()

    : iReception( RMobileBroadcastMessaging::EBroadcastAcceptAll ), 

      iCellInfoReceived( EFalse ),

      iReceptionEnabled( EFalse ),

      iLimitedReception( EFalse ),

      iStartTime( 0 ),

      iEndTime( 0 ),

      iHomeZoneReceived( EFalse ),

      iNewSimTopicsAdded( EFalse )

    {

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CCbsRecEtel::ConstructL()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsRecEtel::ConstructL()");

    iSubscriptionProviders = new ( ELeave ) 

        CArrayFixFlat< MCbsMcnSubscriptionsProvider* >( 1 );

    iDecoder = CCbsRecDecoder::NewL();

    // Establish a session with the ETel server. 

    ConnectToEtelL();

    // Create a listener to monitor network state changes,

    iNetworkListener = CCbsRecNetworkListener::NewL( iGsmPhone );

    // Construct the command handlers

    iFilterSettingHandler = CCbsSetFilterSettingHandler::NewL( *this, *iMessaging );

    // Create the message factory

    iFactory = CCbsMessageFactory::NewL( *this );    

    // Message page collector

    iCollector = CCbsRecCollector::NewL( *iFactory );

    // LC message handler

    iLivecastHandler = CCbsLivecastHandler::NewL( *this );

    // Message monitor

    iEtelMonitor = CCbsRecEtelMonitor::NewL( *this, *iMessaging, *iFactory, *iLivecastHandler );    

    // Fetch local variation bits from CenRep    

    CRepository* repository = CRepository::NewL( KCRUidCbsVariation );    

    TInt err = repository->Get( KCbsVariationFlags, iLVBits );  

    if ( err )

        {

        iLVBits = 0;

        }  

    CBSLOGSTRING2("CBSSERVER: CCbsRecEtel::ConstructL(): CenRep error: %d", err );   

    delete repository;

    CBSLOGSTRING("CBSSERVER: <<< CCbsRecEtel::ConstructL()");

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CCbsRecEtel* CCbsRecEtel::NewL()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsRecEtel::NewL()");

    CCbsRecEtel* self = new ( ELeave ) CCbsRecEtel;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    CBSLOGSTRING("CBSSERVER: <<< CCbsRecEtel::NewL()");

    return self;

    }

// Destructor 

		/*****************************************************

		*	Series 60 Customer / ETel

		*	Series 60  ETel API

		*****************************************************/

CCbsRecEtel::~CCbsRecEtel()

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsRecEtel::~CCbsRecEtel()");

    // Disable CB reception, ignore result    

    TRAP_IGNORE( SetReceptionStatusL( 

        RMobileBroadcastMessaging::EBroadcastAcceptNone ) );

    delete iNetworkListener;

    delete iEtelMonitor;

    delete iFilterSettingHandler;

    delete iLivecastHandler;

    if ( iMessaging )

        {

        iMessaging->Close(); // owned by CCbsEtelFactory

        }        

    delete iMessaging;

    delete iCollector;

    delete iDecoder;    

    delete iFactory;

    delete iSubscriptionProviders;

    iCustomPhone.Close();

    iGsmPhone.Close();

    iEtelServer.Close();

    CBSLOGSTRING("CBSSERVER: <<< CCbsRecEtel::~CCbsRecEtel()");

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::HandleMessageReceivedL

// Handles a received CBS message page. 

//  

// The message have

// to be decoded, uncompressed and collected only if

// certain conditions hold. These are checked first.

//

// The handling sequence is as follows:    

// 1.  If the reception is off, reject this message.

// 2.  If the user has set a time limit for receiving messages,

//     check if the current time is such that the message

//     should not be received.

// 3.  Check whether message's language has been subscribed.

//     Reject the message if not. If message id a Class 0 message,

//     do not reject, since the msg should be shown.

// 4.  If the topic detection is enabled and this message

//     is of an unknown topic, add the new topic and

//     reject this message (since the new topic cannot

//     be subscribed at this point).

// 5.  If the same message exists in the database, this

//     message is ignored.

// 6.  The decoder decodes the page.

// 7.  If the message is multipaged, it is given to 

//     the message collector.

// 8.  A complete message is forwarded to CCbsReceiverHelper,

//     which either stores the message into the database

//     or handles it as an index message.

//

// This function is called from CCbsRecEtelMonitor::RunL().

//

// Note: Message reception status check may be unnecessary,

//       if the ETel Monitor instance handles the check.

//

// Note: Message subscription check is necessary here.

//       UI client's subscriptions might differ from MCN client's

//       subscriptions.

//

// Note: Language cannot be read from the header if the

//       language information is stored in the content of

//       the message. This is particulary troublesome, if 

//       the message is compressed. 

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsRecEtel::HandleMessageReceivedL( 

    CCbsMessage* aMessage )

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsRecEtel::HandleMessageReceivedL()");

    CleanupStack::PushL( aMessage ); // take ownership

    // Decode a message. Language indication prefix, if any, is also

    // removed here. A leave occurs if the message is compressed.

    iDecoder->DecodeL( *aMessage );

    // Add network information to message.

    TInt error = AddNetworkInfo( *aMessage );

    // If the message is a cell info, extract the information.

    if ( aMessage->TopicNumber() == KCellInfoTopic )

        {

        if ( KErrNone == error )

            {

            ExtractCellInformation( *aMessage );

            }

        else

            {

            iCellInfoReceived = EFalse;

            }

        }

    else if ( aMessage->TopicNumber() == KHomeZoneTopic )

        {

        if ( KErrNone == error )

            {

            ExtractHomeZoneInformation( *aMessage );

            }

        else

            {

            iHomeZoneReceived = EFalse;

            }

        }

    // Route the message to all MCN client session-objects.

    RouteMessageL( *aMessage );

    // 1. If the reception is off, reject this message.

    // 2. If the time of the day is such that the user has decided

    //    not to receive any messages, reject this message.

    // 3. Check whether message's language has been subscribed

    // 4. Check if the topic of this message is not in the topic list

    //    and the topic detection is enabled.

    // 5. Check if the topic of this message has been subscribed.

    // 6. Check if this message already exists in the database.    

    // This variable must be local, since if the common reception status

    // is used, this check can mess it up.

    TBool uiReceptionEnabled( EFalse );

    iInterface->Database().SettingsL().GetReceptionStatus( uiReceptionEnabled );

    if ( !uiReceptionEnabled ||

        ( iInterface->LanguageOfMessageSubscribedL( *aMessage ) == EFalse &&

        aMessage->RequiresImmediateDisplay() == EFalse ) ||

        iInterface->CheckForNewTopicL( *aMessage ) ||

        iInterface->CheckForSubscriptionAndExistenceL( *aMessage ) == EFalse )

        {

        CBSLOGSTRING("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): Rejecting msg, PopAndDestroy().");

        CleanupStack::PopAndDestroy( aMessage );

        }  

    else

        {

        // Check if this message is multipaged and if it is, 

        // give it to the message collector. If it isn't,

        // forward the message to the receiver helper

        if ( aMessage->TotalPages() > 1 )

            {

            CBSLOGSTRING2("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): Multipaged msg, total pages: %d.", aMessage->TotalPages() );

            // Ensure that the network info is available. 

            // If not, reject the message, because info is required to collect

            // pages of a multipaged message.

            if ( KErrNone != error )

                {

                CBSLOGSTRING2("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): AddNetworkInfo error: %d, PopAndDestroy().", error );

                CleanupStack::PopAndDestroy( aMessage );

                }

            else

                {

                // Ownership of aMessage transferred to iCollector with

                // aMessage left on the cleanup stack.

                CBSLOGSTRING("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): Calling iCollector->CollectL()...");                

                CCbsMessage* completedMsg = iCollector->CollectL( aMessage, ECbsMessageTypeUnspecified );

                CBSLOGSTRING("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): iCollector->CollectL() finished OK.");

                if ( completedMsg )

                    {

                    // Message pages combined => Handle like a single-paged msg.

                    // Result code ignored.

                    CleanupStack::PushL( completedMsg );

                    CBSLOGSTRING("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): MULTIPAGED: Calling iInterface->HandleReceivedMessageL()...");

                    iInterface->HandleReceivedMessageL( *completedMsg );

                    CBSLOGSTRING("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): MULTIPAGED: iInterface->HandleReceivedMessageL() finished OK.");

                    CleanupStack::PopAndDestroy( completedMsg );

                    }

                }            

            }

        else

            {

            // single page    

            CBSLOGSTRING("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): SINGLEPAGED: Calling iInterface->HandleReceivedMessageL()...");

            iInterface->HandleReceivedMessageL( *aMessage );

            CBSLOGSTRING("CBSSERVER: CCbsRecEtel::HandleMessageReceivedL(): SINGLEPAGED: iInterface->HandleReceivedMessageL() finished OK.");

            CleanupStack::PopAndDestroy( aMessage );

            }

        }

    CBSLOGSTRING("CBSSERVER: <<< CCbsRecEtel::HandleMessageReceivedL()");                                

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::AddNetworkInfo

// This method blocks if no current network info is 

// available and the call to retrieve information blocks.

//  

// Augments aMessage with current network information (i.e., PLMN, LAC

// and Cell ID). Does nothing if the network listener iListener

// is unavailable.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

		/*****************************************************

		*	Series 60 Customer / ETel

		*	Series 60  ETel API

		*****************************************************/

TInt CCbsRecEtel::AddNetworkInfo( 

    CCbsMessage& aMessage ) const

    {

    TInt result( KErrNone );

    RMobilePhone::TMobilePhoneNetworkInfoV1 info;

    RMobilePhone::TMobilePhoneLocationAreaV1 area;

    result = iNetworkListener->GetCurrentNetworkInfo( info, area );

    if ( result == KErrNone )

        {

        aMessage.SetNetworkInfo( info, area );

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::SetInterface

// Sets the interface to which all accepted messages are given.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsRecEtel::SetInterface( 

    CCbsReceiverHelper* aInterface )

    {

    __ASSERT_DEBUG( aInterface != 0, User::Panic( _L( "InterfaceNull" ), 0 ) );

    iInterface = aInterface;

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::AddSubscriptionProviderL

// MCN client sessions register to CCbsRecEtel using this function.

// 

// When topic subscriptions are gathered during execution of

// ApplyStateChangesL(), subscriptions of each registered subscription

// provider are added to the CBMI list that determines which

// topics are received.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsRecEtel::AddSubscriptionProviderL( 

    MCbsMcnSubscriptionsProvider* aProvider )

    {

    __TEST_INVARIANT;

    if ( !aProvider )

        {

        User::Leave( KErrArgument );

        }

    iSubscriptionProviders->AppendL( aProvider );

    __TEST_INVARIANT;

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::RemoveSubscriptionProviderL

// Removes a MCN topic subscription provider.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CCbsRecEtel::RemoveSubscriptionProviderL(

    const MCbsMcnSubscriptionsProvider* aProvider )

    {

    __TEST_INVARIANT;

    if ( !aProvider )

        {

        User::Leave( KErrArgument );

        }

    TInt count( iSubscriptionProviders->Count() );

    for ( TInt i( 0 ); i < count; i++ )

        {

        if ( iSubscriptionProviders->At( i ) == aProvider )

            {

            iSubscriptionProviders->Delete( i );

            ApplyStateChangesL();

            __TEST_INVARIANT;

            return;

            }

        }

#ifdef _DEBUG

    CbsServerPanic( EMcnProviderNotFound );

#endif

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::ApplyStateChangesL

// Retrieves current subscriptions and settings from DB.

// 

// Reception should be enabled if:

// 1) User has enabled it or

// 2) There are MCN clients with outstanding message routing

// requests or

// 3) New topics were found from SIM card and they were added to Topic list

//

// If the reception is enabled, all topics and languages

// are subscribed from ETel. Filtering is done in CbsServer

// on receival of a CB message (see HandleMessageReceivedL()).

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

		/*****************************************************

		*	Series 60 Customer / ETel

		*	Series 60  ETel API

		*****************************************************/

void CCbsRecEtel::ApplyStateChangesL()

    {

	CBSLOGSTRING("CBSSERVER: >>> CCbsRecEtel::ApplyStateChangesL()");

    // Determine reception status: If any MCN client requests messages or new

    // SIM Topics have just been addded, then reception should be enabled. 

    // Otherwise UI client reception setting is used.

    TUint numberOfMcnSubscriptions( NumberOfMcnSubscriptions() );

    CBSLOGSTRING2("CBSSERVER: CCbsRecEtel::ApplyStateChangesL(): numberOfMcnSubscriptions: %d", numberOfMcnSubscriptions );

    TBool receptionStatus( EFalse );

    TInt errorCode( KErrNone );

    TRAP( errorCode, iInterface->Database().SettingsL().GetReceptionStatus( receptionStatus ) );

    CBSLOGSTRING2("CBSSERVER: CCbsRecEtel::ApplyStateChangesL(): Database reception status: %d", receptionStatus );

    TBool receptionEnabled( EFalse );

    // Variated feature    

    if ( iLVBits & KCbsLVFlagTopicSubscription )

        {

        receptionEnabled = ( receptionStatus || numberOfMcnSubscriptions > 0 || iNewSimTopicsAdded );

        }

    else

        {

        receptionEnabled = ( receptionStatus || numberOfMcnSubscriptions > 0 );

        }

    CBSLOGSTRING2("CBSSERVER: CCbsRecEtel::ApplyStateChangesL(): Should reception be enabled: %d", receptionEnabled );

    // Check if the reception status should be changed

    if ( receptionEnabled != iReceptionEnabled )

        {

        CBSLOGSTRING("CBSSERVER: CCbsRecEtel::ApplyStateChangesL(): Changing reception status.");

        if ( !receptionEnabled )

            {

            // Set reception off

            SetReceptionStatusL( RMobileBroadcastMessaging::EBroadcastAcceptNone );

            CBSLOGSTRING("CBSSERVER: CCbsRecEtel::ApplyStateChangesL(): Changing reception status, status set OFF.");

            }

        else

            {

            // Set reception on

            SetReceptionStatusL( RMobileBroadcastMessaging::EBroadcastAcceptAll );

            CBSLOGSTRING("CBSSERVER: CCbsRecEtel::ApplyStateChangesL(): Changing reception status, status set ON.");

            }

        }

	CBSLOGSTRING("CBSSERVER: <<< CCbsRecEtel::ApplyStateChangesL()");

    }

// -----------------------------------------------------------------------------

// CCbsRecEtel::GetCurrentMessage

// Returns the current information message.

// The information is retrieved from the last cell information or HomeZone

// message.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CCbsRecEtel::GetCurrentMessage( 

    TDes& aInfoMessage,

    TInt aTopicNumber )

    {

    // Handle the cell info message (topic 50)

    if ( aTopicNumber == KCellInfoTopic && iCellInfoReceived )