/*

* Copyright (c) 2004 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:   Methods for CNcnMsvSessionObserver class.

*

*/

// INCLUDE FILES

#include    <AknUtils.h>                // Avkon Utilities

#include    <AknGlobalNote.h>           // Avkon Global Note

#include    <mtclreg.h>                 // Client MTM

#include    <etel3rdparty.h>			// KMaxTelNumberSize

#include    <SendUiConsts.h>            // For MTM Uids

#include    <msvstd.hrh>                // For Message entry types

#include    <centralrepository.h>

#include 	<telremotepartyinformationpskeys.h>

#include 	<telconfigcrkeys.h>

#include    <settingsinternalcrkeys.h>  // For Autolock status

#include    <smsclnt.h>                 // SMS Client MTM

#include    <smuthdr.h>                 // Sms Header

#include    <StringLoader.h>            // String Loader

#include    <stringresourcereader.h>    // String Resource Reader

#include    <mmsclient.h>

#include    "NcnDebug.h"

#include    "NcnHandlerAudio.h"

#include    "CVoiceMailManager.h"

#include    "NcnMsvSessionObserverBase.h"

#include    "NcnMsvSessionObserver.h"

#include    "NcnModel.h"

#include    "CNcnNotifApiObserver.h"

#include    "CNcnMsvSessionHandler.h"

#include    <NcnListInternalCRKeys.h>

#include    <Ncnlist.rsg>               // New Contacts Note resource

#include	"MNcnMsgWaitingManager.h"

// CONSTANTS

_LIT( KEmptyChar, "" );

_LIT( KSpaceChar, " " );

const TInt KNcnStoreIndicator = 0x80;

const TInt KNcnCphsAddressLength = 4;

const TUint KNcnCphsConstantMask = 0x7E;

const TUint KNcnCphsFirstChar = 2;

const TUint KNcnCphsSecondChar = 3;

const TUint KNcnCphsFirstInfo = 0x10;

const TUint KNcnCphsSecondInfo = 0x00;

const TUint KNcnCphsLineMask    = 0xf0;

const TUint KNcnCphsVmiLine1    = 0x10; // bits 00010000

const TUint KNcnCphsVmiLine2    = 0x90; // bits 10010000

const TUint KNcnCphsSet         = 0x01; // bits 00000001

const TInt KNcnMatchMin = 7;

const TInt KNcnMatchMax = 11;

const TInt KNcnMatchDefault = KNcnMatchMin;

const TInt KNcnMaxTries = 10;

const TInt KNcnTryInterval = 500000;

// ================= LOCAL CONSTANTS =======================

namespace

    {

    // default number of messages waiting to set, if any

    const TUint KNcnDefaultMessagesWaiting = 1;

    //Granularity for the unhandled message que

    const TUint KNcnUnhandledMessageQueGranularity = 5;

    }

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

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

// CNcnMsvSessionObserverBase::NewL

// Protocol specific class factory

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

//

CNcnMsvSessionObserverBase* CNcnMsvSessionObserverBase::NewL(

    CNcnModelBase* aModel, CVoiceMailManager& aVMManager)

    {

    CNcnMsvSessionObserverBase* self =

        CNcnMsvSessionObserver::NewL( aModel, aVMManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

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

// might leave.

//

CNcnMsvSessionObserver::CNcnMsvSessionObserver(

    CNcnModelBase* aModel, CVoiceMailManager& aVMManager ) : 

    CNcnMsvSessionObserverBase( aModel ),

    iUnhandledMessages(NULL),

    iVMManager(aVMManager),

	iUnreadMessages(NULL)

    {

    }

// Two-phased constructor. NewL

CNcnMsvSessionObserverBase* CNcnMsvSessionObserver::NewL(

    CNcnModelBase* aModel, CVoiceMailManager& aVMManager )

    {

    CNcnMsvSessionObserverBase* self = new (ELeave)

		CNcnMsvSessionObserver ( aModel, aVMManager );

    return self;

    }

// Two-phased constructor. ConstructL

void CNcnMsvSessionObserver::ConstructL()

    {

    //Base classes constructor

    CNcnMsvSessionObserverBase::ConstructL();

    //Own constructions

	iUnhandledMessages = new (ELeave)RArray<TInt>(KNcnUnhandledMessageQueGranularity);

	iUnreadMessages = new (ELeave)RArray<TInt>(KNcnUnhandledMessageQueGranularity);

	iUpdateNotifier = ETrue;

    }

// Destructor

CNcnMsvSessionObserver::~CNcnMsvSessionObserver()

    {

    if( iUnhandledMessages != NULL)

	    {

	    delete iUnhandledMessages;

	    iUnhandledMessages = NULL;	

	    }

    if( iUnreadMessages != NULL)

	    {

	    delete iUnreadMessages;

	    iUnreadMessages = NULL;	

	    }

    }         

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

// CNcnMsvSessionObserver::HandleMsvSessionReadyL

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

//

void CNcnMsvSessionObserver::HandleMsvSessionReadyL( CMsvSession& aMsvSession )

	{

	NCN_RDEBUG_INT( _L( "CNcnMsvSessionObserver::HandleMsvSessionReadyL %d >> " ), iInitialized );

	if ( !iInitialized )

		{

		//Most of this is in the base class

		CNcnMsvSessionObserverBase::HandleMsvSessionReadyL(aMsvSession);

		// Add unread and visible entries in Inbox to iUnreadMessages

		// Needed later on to determine which entries are truly new and unread

		// and which are just old unread messages. 

		InitUnreadMessagesArrayL();

		//Additional task is to update the message icon TSW ID: EXTW-6JDBWN

	    UpdateInboxDataNotifiersL();

	    iInitialized = ETrue;

		}

	else

		{

		iUnhandledMessages->Reset();

		}

    NCN_RDEBUG( _L( "CNcnMsvSessionObserver::HandleMsvSessionReadyL <<" ) );

	}

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

// CNcnMsvSessionObserver::HandleMsvSessionClosedL

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

//

void CNcnMsvSessionObserver::HandleMsvSessionClosedL()

	{

	NCN_RDEBUG(_L("CNcnMsvSessionObserver::HandleMsvSessionClosedL >>"));        

	CNcnMsvSessionObserverBase::HandleMsvSessionClosedL();

    NCN_RDEBUG(_L("CNcnMsvSessionObserver::HandleMsvSessionClosedL >>"));        

	}

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

// CNcnMsvSessionObserver::HandleEntryEventL

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

//

void CNcnMsvSessionObserver::HandleEntryEventL(

    TMsvEntryEvent  aEvent,

    TAny*           aArg1,

    TAny*           /*aArg2*/,

    TAny*           /*aArg3*/)

    {

    NCN_RDEBUG_INT(_L("CNcnMsvSessionObserver::HandleEntryEventL: aEvent: %d"), aEvent );        

    // handle event accordingly

    switch( aEvent )

        {

        case EMsvNewChildren:

            {

            NCN_RDEBUG( _L("CNcnMsvSessionObserver::HandleEntryEventL: EMsvNewChildren") );

            const CMsvEntrySelection* msvEntrySelection =

                static_cast<CMsvEntrySelection*>( aArg1 );

            HandleNewChildrenL( *msvEntrySelection );

            break;

            }

        case EMsvChildrenChanged:

            {

            NCN_RDEBUG( _L("CNcnMsvSessionObserver::HandleEntryEventL: EMsvChildrenChanged") );

            const CMsvEntrySelection* msvEntrySelection =

                static_cast<CMsvEntrySelection*>( aArg1 );

            HandleChangedChildrenL( *msvEntrySelection );

            break;

            }

        case EMsvDeletedChildren:

            {

            NCN_RDEBUG( _L("CNcnMsvSessionObserver::HandleEntryEventL: EMsvDeletedChildren") );

            const CMsvEntrySelection* msvEntrySelection =

                static_cast<CMsvEntrySelection*>( aArg1 );

            HandleDeletedChildrenL( *msvEntrySelection );

            break;

            }

        default:

            {

            NCN_RDEBUG_INT( _L("CNcnMsvSessionObserver::HandleEntryEventL: default (%d)"), aEvent );

            break;

            }

        }        

    NCN_RDEBUG( _L( "CNcnMsvSessionObserver::HandleEntryEventL <<" ) );

    }

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

// CNcnMsvSessionObserver::HandleNewChildrenL

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

//    

void CNcnMsvSessionObserver::HandleNewChildrenL(

    const CMsvEntrySelection& aMsvEntrySelection )

    {

    NCN_RDEBUG( _L( "CNcnMsvSessionObserver::HandleNewChildrenL" ) );

    // get session from session handler

    CMsvSession& msvSession = iModel->MsvSessionHandler().MsvSessionL();

	//The received entrys type in ncn list's own definition

    TNcnInboxEntryType receivedEntryType = EUnknown;

    //Zero the phone number that is updated later

    iTelNumber.iTelNumber.Zero();

	//The amount of new children

    const TInt newEntries = aMsvEntrySelection.Count();

    NCN_RDEBUG_INT( _L( "HandleNewChildrenL Count is %d" ), newEntries );

    // Go through all the new children

    for ( TInt index = 0; index < newEntries; index++ )

        {

        // Get the id of new entry and check if it is a sms message.

        // If so, then we have to do a detailed check.

        TMsvId id = aMsvEntrySelection.At( index );

        CMsvEntry* entryToHandlePtr = msvSession.GetEntryL( id );

        CleanupStack::PushL(entryToHandlePtr);

        TMsvEntry entryToHandle = entryToHandlePtr->Entry();

		//Extensive debug information about the new entry

		#ifdef _DEBUG

		PrintEntryDebugInformation(entryToHandle);

		#endif

		//Message is in preparation

        if( entryToHandle.InPreparation() && 

        	( entryToHandle.iMtm.iUid == KSenduiMtmSmsUidValue || 

        	  entryToHandle.iMtm.iUid == KSenduiMtmMmsUidValue ||

        	  entryToHandle.iMtm.iUid == KSenduiMtmBtUidValue ||

        	  entryToHandle.iMtm.iUid == KSenduiMtmIrUidValue ) )

            {

            switch( entryToHandle.iMtm.iUid )

	            {

	            case KSenduiMtmSmsUidValue:

	            	{

	            	NCN_RDEBUG_INT(_L("MsvEntry id: %d is an SMS that is still in preparation!"), entryToHandle.Id() );

	            	break;

	            	}

	            case KSenduiMtmMmsUidValue:

	            	{

	            	NCN_RDEBUG_INT(_L("MsvEntry id: %d is an MMS that is still in preparation!"), entryToHandle.Id() );

	            	break;

	            	}

	            default:

	            	{

	            	NCN_RDEBUG_INT(_L("MsvEntry id: %d is an IR/Bt message that is still in preparation!"), entryToHandle.Id() );

	            	break;

	            	}

	            }

			//Append the message to unhandled que. We handle it when it changes to completed

			iUnhandledMessages->AppendL( entryToHandle.Id() );

            }

        else if( entryToHandle.InPreparation() == EFalse && 

                 entryToHandle.Unread() )

            {

            switch ( entryToHandle.iMtm.iUid )

                {

                //Message is unread and complete SMS

                case KSenduiMtmSmsUidValue:

                    {

                    NCN_RDEBUG_INT(_L("MsvEntry id: %d is an SMS that is complete!"), entryToHandle.Id() );            

        			// CheckAndHandleSmsEntryL takes ownership of the entryToHandlePtr

        			// and deletes it after completion

    		        CleanupStack::Pop(entryToHandlePtr);

                    // If the entry is an unread sms then call handling method...

                    // The method returns the entry type.		

                    TRAPD( err, receivedEntryType = CheckAndHandleSmsEntryL( entryToHandlePtr ) );

                    entryToHandlePtr = NULL;

        	        NCN_RDEBUG_INT(_L("New entry is of Ncn entry type: %d"), receivedEntryType );

                    // Check if message is deleted or message couldn't be

        			// recognized at all because of error

                    if( err != KErrNone )

                        {

                        // Don't react on messages that doesn't exist

        	        	NCN_RDEBUG(_L("Handling of the SMS failed. Changing it as NcnList entry type 'deleted'!") );

                        receivedEntryType = EDeletedMessage;

                        }

        			else                           

                        {

                        TInt err = iUnreadMessages->Append( entryToHandle.Id() );                   

                        if ( err )

                            {

                            NCN_RDEBUG_INT(_L("CNcnMsvSessionObserver::HandleNewChildrenL - APPEND ERROR %d!"), err );

                            }

                        }

                    break;

                    }

                //Message is unread and complete MMS

                case KSenduiMtmMmsUidValue:

                    {

        			NCN_RDEBUG_INT(_L("MsvEntry id: %d is an MMS that is complete!"), entryToHandle.Id() );

        			//This is the MMS entry's type. Notify about its arrival

        			receivedEntryType = EMMSMessage;

                    TInt err = iUnreadMessages->Append( entryToHandle.Id() );

                    if ( err )

                        {

                        NCN_RDEBUG_INT(_L("CNcnMsvSessionObserver::HandleNewChildrenL - APPEND ERROR %d!"), err );

                        }

                    break;

                    }

                 default:

                    {

                    NCN_RDEBUG_INT2(_L("MsvEntry id: %d with unknown MTM: 0x%x is complete!"), entryToHandle.Id(), entryToHandle.iMtm );

                    //The exact type is not known

                   receivedEntryType = EUnknown;

                    TInt err = iUnreadMessages->Append( entryToHandle.Id() );

                    if ( err )

                        {

                        NCN_RDEBUG_INT(_L("CNcnMsvSessionObserver::HandleNewChildrenL 2- APPEND ERROR %d!"), err );

                        }

                    break;

                    }

                }

            // Common for all

            // notify about new child entry

            NotifyAboutNewChildEntryL( entryToHandle, receivedEntryType );

            }

         //Not an SMS/MMS, we don't do anything with it

         else

            {

            //Still in preparation

            // Do not add entry, if it is read. Message server sends all messages from

            // the store as changes messages, when changing message store.

            if ( entryToHandle.Unread() )

                {

                #ifdef _DEBUG

                PrintEntryDebugInformation(entryToHandle);

                #endif

                NCN_RDEBUG_INT2(_L("MsvEntry id: %d with unknown MTM: 0x%x is still in preparation!"), entryToHandle.Id(), entryToHandle.iMtm );    

                TInt err = iUnreadMessages->Append( entryToHandle.Id() );

                if ( err )

                    {

                    NCN_RDEBUG_INT(_L("CNcnMsvSessionObserver::HandleNewChildrenL 3 - APPEND ERROR %d!"), err );

                    }

                }

            }

        if (entryToHandlePtr)

            {

            CleanupStack::PopAndDestroy(entryToHandlePtr);   

            entryToHandlePtr = NULL;

            }

        }

    }

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

// CNcnMsvSessionObserver::HandleChangedChildrenL

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

//        

void CNcnMsvSessionObserver::HandleChangedChildrenL(

    const CMsvEntrySelection& aMsvEntrySelection )

    {

    NCN_RDEBUG( _L( "CNcnMsvSessionObserver::HandleChangedChildrenL >>" ) );

	//Get session from session handler

    CMsvSession& msvSession = iModel->MsvSessionHandler().MsvSessionL();

  	//The amount of changed children

  	const TInt newEntries = aMsvEntrySelection.Count();

    NCN_RDEBUG_INT( _L( "HandleChangedChildrenL Count is %d" ), newEntries );

  	 // Go through the changed children

    TBool completeHandling(EFalse);

    for ( TInt index = 0; index < newEntries; index++ )

	    {

	    //Get the id of the new entry and check if it has been processed

	    //and also check if it can be notifed now

		TMsvId id = aMsvEntrySelection.At( index );

		CMsvEntry* entryToHandlePtr = msvSession.GetEntryL( id );

        CleanupStack::PushL(entryToHandlePtr);

        TMsvEntry entryToHandle = entryToHandlePtr->Entry();

		#ifdef _DEBUG

		PrintEntryDebugInformation( entryToHandle );

		#endif

		//Was this entry handled when it arrived or was it in preparation?

		TInt indexInUnhandledArray = iUnhandledMessages->Find( entryToHandle.Id() );				

		NCN_RDEBUG_INT(_L("HandleChangedChildrenL indexInUnhandledArray [%d]"), indexInUnhandledArray );

        // Did the entry change to unread during preparation?

        if ( indexInUnhandledArray != KErrNotFound 

            && entryToHandle.Unread() ) 

            {

            TInt indexInUnreadArray = iUnreadMessages->Find( entryToHandle.Id() );				

            if ( indexInUnreadArray == KErrNotFound )

                {

                // This entry has changed to Unread(0->1) during preparation. Add it to unread messages cache.

                TInt err = iUnreadMessages->Append( entryToHandle.Id() );

                if ( err )

                    {

                    NCN_RDEBUG_INT(_L("CNcnMsvSessionObserver::HandleNewChildrenL - APPEND ERROR %d!"), err );

                    }

                }

            }

		//Check if the entry is unhandled SMS and it can now be handled

	    TBool entryUnhandled = 

	        indexInUnhandledArray != KErrNotFound &&

	    	entryToHandle.InPreparation() == EFalse &&

	    	entryToHandle.Unread();

        TNcnInboxEntryType handledEntryType = EUnknown;  // default type

        completeHandling = EFalse;

	    if( entryUnhandled )

            {

            switch( entryToHandle.iMtm.iUid )

            	{

	            case KSenduiMtmSmsUidValue:

	    		    {

	      			NCN_RDEBUG(_L("HandleChangedChildrenL Unhandled SMS found! Handling it now!") );

	    			// CheckAndHandleSmsEntryL takes ownership of the entryToHandlePtr

	    			// and deletes it after completion

	    			CleanupStack::Pop(entryToHandlePtr);

	      			// If the entry is an unread sms then call handling method...

	    			// The method returns the entry type.

	    			iUpdateNotifier = ETrue;

	    			TRAPD( err, handledEntryType = CheckAndHandleSmsEntryL( entryToHandlePtr ) );

	                entryToHandlePtr = NULL;

	    	        NCN_RDEBUG_INT(_L("New entry is of Ncn entry type: %d"), handledEntryType );

	    			// Check if message is deleted or message couldn't be

	    			// recognized at all because of error

	    			if( err != KErrNone )

	    			    {

	                    // Don't react on messages that doesn't exist

	    	        	NCN_RDEBUG(_L("Handling of the SMS failed. Changing it as NcnList entry type 'deleted'!") );

	                    handledEntryType = EDeletedMessage;

	    			    }

					break;

	    		    }

            	case KSenduiMtmMmsUidValue: 	            	

	    		    {

	      			NCN_RDEBUG( _L("HandleChangedChildrenL Unhandled MMS found! Handling it now!") );

	      			//This is the unhandled entry's type

	    			handledEntryType = EMMSMessage;

	    			break;

	    		    }

            	default:

            		{

            		NCN_RDEBUG( _L( "CNcnMsvSessionObserver::HandleChangedChildrenL: Completed something else than SMS or MMS. Smart message?" ) );

            		 // Eg. smart messages

            		break;

            		}

            	}

            // common for all messages

            completeHandling = ETrue; 

            }

		 // It is required to update new message notifications after a message entry has been handled (by ncnlist) and

		 // read (by user e.g. in MCE)

		 // 2. If a read message is marked unread (e.g. in MCE), this condition is not true and notification is not displayed

		 // about it. However if a new message arrives, all unread message (despite how they got that way) are treated as a new message.

		 else if( indexInUnhandledArray == KErrNotFound && 

		 		 !entryToHandle.Unread() &&

                 !entryToHandle.InPreparation() )

			{