/*

* Copyright (c) 2003-2009 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 module contains the implementation of CCbsReceiverHelper class

*                member functions.

*

*                CCbsReceiverHelper gets the messages from the receiver and

*                sends them to the database. All received messages are

*                sent to CCbsReceiverHelper instance by CCbsRecEtel.

*                This class makes subscription and existence checks

*                to these messages and also implements topic detection feature.

*

*/

// INCLUDE FILES

#include <barsc.h>              // Resource access

#include <barsread.h>           // Resource access

#include <CbsServer.rsg>

#include "CbsCommon.h"

#include "CbsUtils.h"

#include "CbsServerPanic.h"

#include "CCbsServer.h"

#include "CCbsReceiverHelper.h"

#include "CCbsDbImp.H"

#include "CCbsDbImpSettings.H"

#include "CCbsDbImpTopicList.h"

#include "CCbsDbImpTopicMessages.h"

#include "CCbsDbImpTopicCollection.h"

#include "CCbsRecMessage.h"

#include <e32property.h>

#include <coreapplicationuisdomainpskeys.h>

#include <data_caging_path_literals.hrh>

#include "CbsLogger.h"

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

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

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

// CONSTANTS

// UID of CBS UI application

// DATA TYPES

// CbsUi application view ID's

enum TCbsUiViewIds

    {

    ECbsUiTopicViewId = 1,

    ECbsUiTopicListViewId,

    ECbsUiListAppColumnViewId,

    ECbsUiMsgViewId,            //message view id

    ECbsUiAddFromIndexViewId,

    ECbsUiSettingsViewId

    };

// These values specify a range of accepted topic number values (inclusive).

const TUint KMinTopicNumber = 1;     // 000 is not accepted.

const TUint KMaxTopicNumber = 999;

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void ParseMessageFormatL(

    TLex& aLex, CCbsDbImpTopicCollection& aCollection );

LOCAL_C void ParseIndexElementIntroL(

    TLex& aLex, CCbsDbImpTopicCollection& aCollection );

LOCAL_C void ParseServiceIntroL(

    TLex& aLex, CCbsDbImpTopicCollection& aCollection );

LOCAL_C void ParseMessageIdL(

    TLex& aLex, TUint& aMessageId );

LOCAL_C void ParseSubIndexIntroL(

    TLex& aLex );

LOCAL_C void ParseSubIndexIdL(

    TLex& aLex );

LOCAL_C void ParseNameCharactersCrLfL(

    TLex& aLex, TPtrC& aName );

// ==================== LOCAL FUNCTIONS ====================

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

// ParseMessageFormatL

// Parses an index message.

// Returns: None

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

//

LOCAL_C void ParseMessageFormatL(

    TLex& aLex,

    CCbsDbImpTopicCollection& aCollection )

    {

    TInt identitiesCount( 0 );

    while ( !aLex.Eos() )

        {

        ParseIndexElementIntroL( aLex, aCollection );

        identitiesCount++;

        }

    if ( identitiesCount == 0 )

        {

        User::Leave( KErrCorrupt );

        }

    }

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

// ParseIndexElementIntroL

// Parses part of an index message.

// Returns: None

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

//

LOCAL_C void ParseIndexElementIntroL(

    TLex& aLex,

    CCbsDbImpTopicCollection& aCollection )

    {

    TBool hasSubIndexId( EFalse );

    // subindex-id (optional for service-intro)

    if ( aLex.Peek().IsAlpha() )

        {

        hasSubIndexId = ETrue;

        ParseSubIndexIdL( aLex );

        }

    // subindex-intro | service-intro

    // We'll take a peek to discover, which one

    if ( hasSubIndexId && aLex.Peek() == EKeySpace )

        {

        ParseSubIndexIntroL( aLex );

        }

    else

        {

        ParseServiceIntroL( aLex, aCollection );

        }

    }

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

// ParseServiceIntroL

// Parses part of an index message.

// Returns: None

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

//

LOCAL_C void ParseServiceIntroL(

    TLex& aLex,

    CCbsDbImpTopicCollection& aCollection )

    {

    // We'll store the results here

    TCbsDbTopicIdentity identity;

    // message-id

    TUint messageId;

    ParseMessageIdL( aLex, messageId );

    identity.iNumber = TUint16( messageId );

    // delimeter

    TChar delimeter( aLex.Get() );

    if ( delimeter != ' ' && delimeter != '.' )

        {

        User::Leave( KErrCorrupt );

        }

    // service-name

    TPtrC serviceName;

    ParseNameCharactersCrLfL( aLex, serviceName );

    // drop crlf

    serviceName.Set( serviceName.Left( serviceName.Length()-2 ) );

    // If the delimeter is ' ', store the identity. Otherwise

    // it only refers to a subindex page, so we skip it

    if ( delimeter == ' ' )

        {

        // Copy max. KCbsDbTopicNameLength characters

        identity.iName = serviceName.Left( KCbsDbTopicNameLength );

        // Store the topic identity into the database

        aCollection.AddTopicIdentityL( identity );

        }

    }

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

// ParseMessageIdL

// Parses part of an index message.

// Returns: None

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

//

LOCAL_C void ParseMessageIdL(

    TLex& aLex,

    TUint& aMessageId )

    {

    if ( aLex.Val( aMessageId ) != KErrNone

        || aMessageId < KMinTopicNumber

        || aMessageId > KMaxTopicNumber )

        {

        User::Leave( KErrCorrupt );

        }

    }

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

// ParseSubIndexIntroL

// Parses part of an index message.

// subindex-intro = " " subindex-name crlf

// subindex-name  = name-character+

// Returns: None

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

//

LOCAL_C void ParseSubIndexIntroL(

    TLex& aLex )

    {

    if ( aLex.Get() != EKeySpace )

        {

        User::Leave( KErrCorrupt );

        }

    // subindex-name crlf

    TPtrC subIndexName;

    ParseNameCharactersCrLfL( aLex, subIndexName );

    }

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

// ParseSubIndexIdL

// Parses part of an index message.

// subindex-id = subindex-character+

// Returns: None

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

//

LOCAL_C void ParseSubIndexIdL(

    TLex& aLex )

    {

    // check that there is at least one subindex-character

    if ( !aLex.Peek().IsAlpha() )

        {

        User::Leave( KErrCorrupt );

        }

    // subindex-id

    while ( aLex.Peek().IsAlpha() )

        {

        aLex.Inc();

        }

    }

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

// ParseNameCharactersCrLfL

// Parses part of an index message.

// name-character+ crlf

// Returns: None

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

//

LOCAL_C void ParseNameCharactersCrLfL(

    TLex& aLex,

    TPtrC& aName )

    {

    aLex.Mark();

    // check that we have at least one name-character

    TChar currCharacter( aLex.Get() );

    if( currCharacter == EKeyLineFeed

        || currCharacter == EKeyEnter

        || currCharacter == 0 )

        {

        User::Leave( KErrCorrupt );

        }

    // scan until LF or EOS

    while( currCharacter != EKeyLineFeed && currCharacter != 0 )

        {

        currCharacter = aLex.Get();

        }

    // CR-LF is ok, EOS is not

    if( currCharacter == EKeyLineFeed )

        {

        aName.Set( aLex.MarkedToken() );

        }

    else

        {

        User::Leave( KErrCorrupt );

        }

    }

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

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

// CCbsReceiverHelper::CCbsReceiverHelper

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

// might leave.

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

//

CCbsReceiverHelper::CCbsReceiverHelper(

    CCbsDbImp& aDatabase )

    : iDatabase( aDatabase )

    {

    }

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

// CCbsReceiverHelper::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCbsReceiverHelper::ConstructL()

    {

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

    iVwsSession = CVwsSessionWrapper::NewL();

    // Array for SIM Topic numbers. This way we know which topics

    // to delete also from the SIM card (when deleting all topics).

    iSimTopics = new ( ELeave ) CArrayFixFlat<TInt>( 1 );

    // 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: <<< CCbsReceiverHelper::ConstructL()");

    }

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

// CCbsReceiverHelper::NewL

// Two-phased constructor.

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

//

CCbsReceiverHelper* CCbsReceiverHelper::NewL(

    CCbsDbImp& aDatabase )

    {

    // Normal two phase construction.

    CCbsReceiverHelper* self = new ( ELeave ) CCbsReceiverHelper( aDatabase );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CCbsReceiverHelper::~CCbsReceiverHelper()

    {

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

    delete iSimTopics;

    delete iVwsSession;

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

    }

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

// CCbsReceiverHelper::CCbsReceiverHelper

// Processes a message received by the receiver.

//

// This function is called when a message is received.

//

// Assumptions;

// 1.  The message doesn't have it's permanent or read

//     flags raised - method leaves with KErrNotSupported

//     if this is the case.

// 2.  If an index message (root or subindex) is passed as

//     a parameter, the language indication prefix, if any,

//     has been removed before HandleReceivedMessageL() is called.

//

// Assumption (2) holds because language indications are removed

// by Receiver module in an instance of CCbsRecDecoder.

// Message may not be accepted if it is somehow invalid

// or the reception has been disabled.

// This function also handles the detection of new topics

// and the processing of an index message.

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

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

//

void CCbsReceiverHelper::HandleReceivedMessageL(

    CCbsMessage& aMessage )

    {

    CBSLOGSTRING("CBSSERVER: >>> CCbsReceiverHelper::HandleReceivedMessageL()");

    if ( aMessage.IsIndexMessage() )

        {

        CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): Index msg.");

        // It is assumed that a language indication prefix,

        // if any, has already been removed from the message.

        aMessage.RemoveIndexHeaderL();

        TBool isChildSubindex( aMessage.IsChildSubindex() );

        // Parse the index message

        HandleIndexMessageL( aMessage.Contents(), isChildSubindex );

        // Child subindex messages won't be displayed to the user.

        if ( isChildSubindex )

            {

            return;

            }

        }

    TUint16 topicNumber( aMessage.TopicNumber() );

    CBSLOGSTRING2("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): topic number: %d.", topicNumber );

    TCbsDbTopic topic;

    iDatabase.TopicListL().FindTopicByNumberL( topicNumber, topic );

    CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): iDatabase.TopicListL().FindTopicByNumberL(..) called OK." );

    // If subscribed, handle the message

    if ( topic.iSubscribed )

        {

        CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): Topic subscribed, processing." );

        // Create and initialize message

        TCbsDbMessage message;

        TTime now;

        now.UniversalTime();

        message.iDateTime = now.Int64();

        message.iKey = aMessage.Key();

        message.iLanguage = aMessage.Language();

        message.iLength = aMessage.Contents().Length();

        message.iPermanent = EFalse;

        message.iRead = EFalse;

        TPtrC ptr( aMessage.Contents() );

        iDatabase.TopicMessagesL().AddMessageL( topicNumber, message, ptr );

        CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): Msg added OK." );

        if ( aMessage.RequiresImmediateDisplay() )

            {

            CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): Calling LaunchMessageImmediateDisplay()... " );

            // If the operator indicates that this message must be displayed

            // immediately, request a view switch of CBS UI application.

            LaunchMessageImmediateDisplay( message );

            CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): LaunchMessageImmediateDisplay() called OK." );

            }

        else if ( topic.iHotmarked )

            {

            // The message is of a hotmarked topic => Show a soft notification.

            CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): Calling LaunchMessageSoftNotification()... " );

            LaunchMessageSoftNotificationL( ETrue );

            CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): LaunchMessageSoftNotification() called OK." );

            }

        } // if ( topic.iSubscribed )

    else

        {

        CBSLOGSTRING("CBSSERVER: CCbsReceiverHelper::HandleReceivedMessageL(): Topic NOT subscribed, msg not processed." );

        }

    CBSLOGSTRING("CBSSERVER: <<< CCbsReceiverHelper::HandleReceivedMessageL()");

    }

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

// CCbsReceiverHelper::CheckForNewTopicL

// Checks if aMessage's topic is in the topic list.

//

// If the topic detection is enabled and the topic of this

// message is not in the topic list, the topic is added

// to the list. The method will then return ETrue.

// Otherwise EFalse is returned.

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

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

//

TBool CCbsReceiverHelper::CheckForNewTopicL(

    const CCbsMessage& aMessage )

    {

    // Check if the topic detection is on and if so, add topic if the topic

    // is a new topic.

    TBool detection;

    TBool result( EFalse );

    iDatabase.SettingsL().GetTopicDetectionStatus( detection );

    if ( detection && HandleTopicDetectedL( aMessage.TopicNumber() ) )

        {

        // If a new topic added, we do not send the message to

        // the database so return ETrue.

        result = ETrue;

        }

    else

        {

        // Topic detection disabled or topic already in the database

        result = EFalse;

        }

    return result;

    }