/*

* Copyright (c) 2002 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: 

*     Implements interface for Logs event

*

*/

// INCLUDE FILES

#include <logwrap.hrh>

#include <AiwPoCParameters.h>  //EPoCAdhocDialoutGroupMO etc...

#include <CPhCltEmergencyCall.h>

#include "CLogsEvent.h"

#include "CLogsEventData.h"

#include "LogsEngConsts.h"

#include "LogsApiConsts.h"     //Additional event UIDs

// CONSTANTS

const TInt KMaxDuplicates = 99;

#ifdef _DEBUG

_LIT(KPanicMsg,"CLogsEvent");

#endif

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

// CLogsEvent::NewLC

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

//

CLogsEvent* CLogsEvent::NewLC()

    {

    CLogsEvent* self = new (ELeave) CLogsEvent;

    CleanupStack::PushL( self );

    return self;

    }

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

// CLogsEvent::CLogsEvent

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

//

CLogsEvent::CLogsEvent() 

    {

    iRemoteParty = 0;  

    iNumber = 0;  

    iLogsEventData = 0;

    iRingDuration = 0;

    iNumberFieldType = -1;

    }

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

// CLogsEvent::~CLogsEvent

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

//

CLogsEvent::~CLogsEvent() 

    {

    delete iRemoteParty;

    delete iNumber;

    delete iLogsEventData;

    }

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

// CLogsEvent::InitializeEventL

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

//

void CLogsEvent::InitializeEventL( 

    const CLogEvent& aSource, 

    TLogsEventStrings aStrings,

    TLogsModel aModel )

    {

    delete iRemoteParty;

    iRemoteParty = 0;

    delete iNumber;

    iNumber = 0;

    delete iLogsEventData;

    iLogsEventData = 0;

    SetDuplicates( 0 );

    SetDirection( EDirUndefined );

    SetEventType( ETypeUsual );

    SetALS(EFalse);

    SetNumberFieldType(-1);

    //For SMS'es part data is packed into data field (by sms stack), so in this case there is no 

    //need to try to parse S60 specific data from it). Later this parsing can be move here from

    TBool readMessageParts = ( 

        aSource.EventType() == KLogShortMessageEventTypeUid ||

        aSource.EventType() == KLogsEngMmsEventTypeUid );

    MLogsEventData* logsEventData = CLogsEventData::NewL( aSource.Data(), readMessageParts ) ;  

    SetLogsEventData( logsEventData );  //Ownership transferred to this object

    // TIME NOT needed in event list view (skip to optimise performance of event list view)

    if( aModel != ELogsMainModel )

        {

        TTime universal;

        TTime home;

        TTimeIntervalMinutes interval;

        universal.UniversalTime();

        home.HomeTime();

        TInt err = home.MinutesFrom( universal, interval );

        if( err )

            {

            SetTime( aSource.Time() );

            }

        else

            {

            SetTime( aSource.Time() + interval );

            }

        }

    else

        {

        iTimeSet = EFalse;    

        }

    // LOG ID

    SetLogId( aSource.Id() );

    // DIRECTION

    if( aSource.Direction() == aStrings.iInDirection ||

        aSource.Direction() == aStrings.iInDirectionAlt )

        {

        SetDirection( EDirIn );

        }

    else if( aSource.Direction() == aStrings.iOutDirection ||

        aSource.Direction() == aStrings.iOutDirectionAlt )

        {

        SetDirection( EDirOut );

        }

    else if( aSource.Direction() == aStrings.iMissedDirection )

        {

        SetDirection( EDirMissed );

        }

    // UID

    SetEventUid( aSource.EventType() );

    // EVENT TYPE

    TUid uid = aSource.EventType();

    // Private, unknown or payphone call

    if( aSource.RemoteParty().Length() > 0 ) 					

        {

        // if "Unknown" in remote party and no number/url, type of event is unknown

        if( aSource.RemoteParty() == aStrings.iUnKnownNumber &&

            aSource.Number().Length() == 0 &&

            LogsEventData()->Url().Length() == 0 ) 		

            {

            SetEventType( ETypeUnknown );

            }

        // if "Private" in remote party and no number/url, type of event is private

        else if( aSource.RemoteParty() == KLogsPrivateText && 

                 aSource.Number().Length() == 0 &&

                 LogsEventData()->Url().Length() == 0 )  //"Private" LogsEngConsts.h

            {

            SetEventType( ETypePrivate );

            }

        // if "Payphone" in remote party and no number/url, type of event is payphone

        else if( aSource.RemoteParty() == KLogsPayphoneText && 

                 aSource.Number().Length() == 0 &&

                 LogsEventData()->Url().Length() == 0 )	//"Payphone" LogsEngConsts.h

            {

            SetEventType( ETypePayphone );

            }

        }              

    // Poc group call        

    else if( LogsEventData()->PoC() &&         //EventData initialised already (above), so we can use dest here

        ( TPoCOperationTypeId( LogsEventData()->Type() ) == EPoCAdhocDialoutGroupMO   ||    //See TPoCOperationTypeId in 

          TPoCOperationTypeId( LogsEventData()->Type() ) == EPoCAdhocDialoutGroupMT   ||    //AiwPoCParameters.h

          TPoCOperationTypeId( LogsEventData()->Type() ) == EPoCPredefDialoutGroupMO  ||    

          TPoCOperationTypeId( LogsEventData()->Type() ) == EPoCPredefDialoutGroupMT ) )    

          //Dialin groups (EPoCDialinGroupMO) are NOT group calls 

        {

        SetEventType( ETypePoCGroupCall );            

        }

    // SAT event (SIM application toolkit)

    else if( ( uid == KLogCallEventTypeUid || 

               uid == KLogDataEventTypeUid ||

               uid == KLogShortMessageEventTypeUid ) && 

               aSource.Number().Length() == 0 &&

               LogsEventData()->Url().Length() == 0 &&      //Url set above so we can use it here: If URL,

                                                            // then not SAT event but normal Voip or PoC call

             ( aSource.Direction() == aStrings.iOutDirection ||

               aSource.Direction() == aStrings.iOutDirectionAlt ) )

        {

        SetEventType( ETypeSAT );

        }

    // Fallback in case entry wrongly written (is unknown but no "unknown" in remote party)

    else if ( ( aSource.RemoteParty().Length() == 0 ) &&

              ( aSource.Number().Length() == 0 ) && 

                LogsEventData()->Url().Length() == 0 )        //Url set above so we can use it here

        {

        SetEventType( ETypeUnknown );

        }     

    // Emergency call. 

    if( aSource.Number().Length() > 0 ) 

        {

        if( IsEmergencyNumberL( aSource.Number()) )  // The new Emergency call API tells this is an emergency number                                       

            {                                                                      

            SetEventType( ETypeEmerg ); 

            }

        }    

    // NUMBER

    if( EventType() == ETypeUsual || EventType() == ETypeEmerg )

        {

        if( aSource.Number().Length() )

            {

            SetNumber( aSource.Number().AllocL() );   

            }

        }

    // REMOTE PARTY

    if( EventType() == ETypeUsual || EventType() == ETypePoCGroupCall )

        {

        if( aSource.RemoteParty().Length() )

            {

            SetRemoteParty( aSource.RemoteParty().AllocL() );   

            }

        }

    //NUMBER FIELD TYEP

    if( EventType() == ETypeUsual )

        {

        if( aSource.Subject().Length() )

            {

            TLex lex( aSource.Subject() );

            TInt tmp;

            TInt err = lex.Val( tmp );

            if( KErrNone == err )

                {

                SetNumberFieldType( tmp );

                }

            }

        }

    // Set ALS on/off. A logical AND of KLogEventALS and the event flags passed in.

    SetALS( (aSource.Flags() & KLogEventALS ) );

    // We set iIsRead on/off according to flags for indicate new missed calls feature.

    // Used in missed calls view only. 

    if (aSource.Direction() == aStrings.iMissedDirection)		

   		{

   		// A logical AND of KLogEventRead and the event flags passed in.

    	SetIsRead(aSource.Flags() & KLogEventRead);	            

    	}

    else 													    // Otherwise set to already read

    	{													    // so dialled and received views  

    	SetIsRead(ETrue);										// wont show the icon

   		}

    //For ring duation feature

    if ( aSource.Direction() == aStrings.iMissedDirection )

        {

        SetDirection( EDirMissed );

        SetRingDuration( aSource.Duration() );

        }

    }

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

// CLogsEvent::IsEmergencyNumber

// Checks wether the number is an emergency number

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

TBool CLogsEvent::IsEmergencyNumberL(const TDesC& aNumber)

    {

    TBool isEmergencyNumber(EFalse);

    // Check first the hardcoded values "112" and "911"

    // plus the possible tag Phone app might have set

    if ( aNumber.Compare( KLogsEmergencyCall ) == 0 ||                //112 (however,not in e.g cdma (iStaticEmerg is false))

         aNumber.Compare( KLogsEmergencyCall911 ) == 0 ||              //911

         LogsEventData()->Emerg())          //Other emergency numbers that Phone app logs using data tag EMERG

        {

        isEmergencyNumber = ETrue;

        }

    // If the above does not prove the number to be an emergency number

    // check number using phoneclient emergencycall API

    else if (aNumber.Length() <= KPhCltEmergencyNumberSize)

        {

        CPhCltEmergencyCall* emergencyCallAPI = CPhCltEmergencyCall::NewL(NULL);

        TPhCltEmergencyNumber emergNumber = aNumber;

        if (emergencyCallAPI)

            {

            TInt result = emergencyCallAPI->IsEmergencyPhoneNumber(emergNumber, 

                                                                   isEmergencyNumber );

            delete emergencyCallAPI;                                                

            if ( result != KErrNone ) 

                {

        	    return EFalse; 

                }

            }  

        }

    return isEmergencyNumber;             

    }

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

// CLogsEvent::SetALS()

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

//

void CLogsEvent::SetALS( TBool aALS ) 

	{

	iALS = aALS;	

	}

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

// CLogsEvent::SetLogId

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

//

void CLogsEvent::SetLogId( const TLogId aLogId )

    {

    iLogId = aLogId;

    }

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

// CLogsEvent::SetNumber

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

//

void CLogsEvent::SetNumber( HBufC* aNumber )

    {

    delete iNumber;    

    iNumber = 0;

    iNumber = aNumber;

    }

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

// CLogsEvent::SetRemoteParty

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

//

void CLogsEvent::SetRemoteParty( HBufC* aRemoteParty )

    {

    delete iRemoteParty;   

    iRemoteParty = 0;

    iRemoteParty = aRemoteParty;

    }

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

// CLogsEvent::SetDirection

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

//

void CLogsEvent::SetDirection( const TLogsDirection aDirection )

    {

    iDirection = static_cast<TInt8>( aDirection );

    }

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

// CLogsEvent::SetEventUid

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

//

void CLogsEvent::SetEventUid( const TUid aUid )

    {

    iUid = aUid;

    }

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

// CLogsEvent::SetEventType

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

//

void CLogsEvent::SetEventType( const TLogsEventType aEventType )

    {

    iEventType = static_cast<TInt8>( aEventType );

    }

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

// CLogsEvent::ALS()

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

//

TBool CLogsEvent::ALS() const

	{

	return iALS;

	}

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

// CLogsEvent::LogId

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

//

TLogId CLogsEvent::LogId() const

    {

    return iLogId;

    }

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

// CLogsEvent::SetIsRead

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

void CLogsEvent::SetIsRead(const TBool aIsRead)

    {

    iIsRead = aIsRead;

    }

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

// CLogsEvent::Number

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

//

HBufC* CLogsEvent::Number() 

    {

    return iNumber;

    }

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

// CLogsEvent::RemoteParty

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

//

HBufC* CLogsEvent::RemoteParty() 

    {

    return iRemoteParty;

    }

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

// CLogsEvent::Direction

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

//

TLogsDirection CLogsEvent::Direction() const

    {

    return static_cast<TLogsDirection>( iDirection );

    }

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

// CLogsEvent::EventUid

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

//

TUid CLogsEvent::EventUid() const

    {

    return iUid;

    }

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

// CLogsEvent::EventType

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

//

TLogsEventType CLogsEvent::EventType() const

    {

    return static_cast<TLogsEventType>( iEventType );

    }

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

// CLogsEvent::IsRead

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

 TBool CLogsEvent::IsRead() const

	{

	return iIsRead;

	}

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

// CLogsEvent::RingDuration

//

// For ring duation feature

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

//

TLogDuration CLogsEvent::RingDuration() const

    {

    return iRingDuration;

    }

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

// CLogsEvent::SetRingDuration

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

//

void CLogsEvent::SetRingDuration( TLogDuration aRingDuration )

    {

    iRingDuration = aRingDuration;

    }

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

// CLogsEvent::LogsEventData

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

//

MLogsEventData* CLogsEvent::LogsEventData() const

    {

    return iLogsEventData;

    }

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

// CLogsEvent::SetLogsEventData

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

//

void CLogsEvent::SetLogsEventData( MLogsEventData* aLogsEventData )

    {

    delete iLogsEventData;    

    iLogsEventData = 0;

    iLogsEventData = aLogsEventData;

    }

///////////////////////////////////////////////////////////////////////////////

//

// Additional data that is only needed in specific views

//

///////////////////////////////////////////////////////////////////////////////

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

// CLogsEvent::SetTime

//

// Time needed in recent views and in detail view (not needed in event view)

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

//

void CLogsEvent::SetTime( const TTime aTime )

    {

    iTime = aTime;

    iTimeSet = ETrue;  

    }