/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 logging service handler (This will be part of

*                                   Ecom plugin.

*

*/

#include <liwvariant.h>

#include <logwrap.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logwrap.hrh>

#else

#include <logwrap.hrh>

#include <logengevents.h>

#include <logfilterandeventconstants.hrh>

#endif

#include <logclientchangeobserver.h>

#include "logiter.h"

#include "logginginterface.h"

#include "loggingasyncservice.h"

#include "loggingevent.h"

#include  <utf.h>

#include "liwlogiter.h"

/**

 * Two phase constructor implementation of the

 *  log iterator

 */

CLiwLogIter * CLiwLogIter :: NewL( CLogIter *aIter )

    {

    CLiwLogIter* self = CLiwLogIter :: NewLC( aIter ) ;

    CleanupStack :: Pop( self ) ;

    return self ;

    }

/**

 * Two phase constructor implementation of the

 *  log iterator

 */

CLiwLogIter * CLiwLogIter :: NewLC( CLogIter *aIter )

    {

    CLiwLogIter *self = new ( ELeave ) CLiwLogIter() ;

    CleanupStack :: PushL( self ) ;

    self->ConstructL( aIter ) ;

    return self ;

    }

/**

 * ConstructL , function to construct the members of the CLiwLogIter

 */

void CLiwLogIter :: ConstructL( CLogIter *aIter )

    {

    iLogIter = aIter ;

    }

/**

 * Default constructor

 */

CLiwLogIter :: CLiwLogIter()

    {

    }

/**

 * Default Desturctor

 */

CLiwLogIter :: ~CLiwLogIter()

    {

    delete iLogIter ;

    }

/**

 * Resets the iterator. The service provider should provide a concrete

 * implementation to reset the iterator.

 *

 */

EXPORT_C  void CLiwLogIter :: Reset()

    {

    if( iLogIter )

        {

        iLogIter->Reset();    

        }

    }

/**

 * Iterates over the collection entries to fetch the next data element.

 * The service provider should provide a concrete implementation

 * for this method.

 *

 * @param aEntry contains the next data element and its corresponding data type

 *

 * @return false if there are no more data elements to be fetched;

 * true otherwise

 */

EXPORT_C TBool CLiwLogIter :: NextL(TLiwVariant& aEntry)

    {

    /**

    * In case of empty iterator return false

    */

    if( !iLogIter )

        {

        return EFalse ;

        }

    CLogsEvent *event = iLogIter->NextL() ;

    if( !event )

        {

        return EFalse ;

        }

    CleanupStack::PushL(event);

    CLiwDefaultMap *evntmap = CLiwDefaultMap :: NewL() ;

    CleanupClosePushL( *evntmap );

    /**

    * Extract all the event details form CLogsEvent object

    * and push it to the aEntry

    */

    TInt32 val = 0 ;

    switch( (event->getEventType()).iUid )

        {

        case KLogCallEventType :

            {

            val = CLoggingInterface :: EKLogCallEventType ;

            break ;

            }

        case KLogDataEventType :

            {

            val = CLoggingInterface :: EKLogDataEventType ;

            break ;

            }

        case KLogFaxEventType :

            {

            val = CLoggingInterface :: EKLogFaxEventType ;

            break ;

            }

        case KLogShortMessageEventType :

            {

            val = CLoggingInterface :: EKLogShortMessageEventType ;

            break ;

            }

        case KLogPacketDataEventType :

            {

            val = CLoggingInterface :: EKLogPacketDataEventType ;

            break ;

            }     

        default :

            {

            break ;

            }

        }

    evntmap->InsertL(KEventTypeKey , TLiwVariant((TInt32)val));

    evntmap->InsertL(KRemotePartyKey , TLiwVariant(event->getRemoteParty())) ;

    evntmap->InsertL(KEventDurationKey ,TLiwVariant((TInt32)event->getDuration())) ;

    evntmap->InsertL(KEventTimeKey , TLiwVariant(event->getTime())) ;

    val = 0 ;

    /**

    * Need to convert status to int value

    */

    if( ( ( event->getStatus() ).Compare( KStatusPending ) ) == KErrNone )

        {

        val = CLoggingInterface :: EStatusPending ;

        }

    else if( ( ( event->getStatus() ).Compare( KStatusSent ) ) == KErrNone )

        {

        val =CLoggingInterface :: EStatusSent ;

        }

    else if( ( ( event->getStatus() ).Compare( KStatusFalied ) ) == KErrNone )

        {

        val = CLoggingInterface :: EStatusFalied ;

        }

    else if( ( ( event->getStatus() ).Compare( KStatusNone ) ) == KErrNone )

        {

        val = CLoggingInterface :: EStatusNone;

        }

    else if( ( ( event->getStatus() ).Compare( KStatusDone ) ) == KErrNone )

        {

        val = CLoggingInterface :: EStatusDone;

        }

    else if( ( ( event->getStatus() ).Compare( KStatusNotSent ) ) == KErrNone )

        {

        val = CLoggingInterface :: EStatusNotSent;

        }

    else if( ( ( event->getStatus() ).Compare( KStatusScheduled ) ) == KErrNone )

        {

        val = CLoggingInterface :: EStatusScheduled;

        }

    else

        {

        val = CLoggingInterface :: EStatusNotPresent;

        }

    if( val != -1 )  

        {

        evntmap->InsertL(KDeliveryStatusKey , TLiwVariant((TInt32)val)) ;

        }

    evntmap->InsertL(KSubjectKey , TLiwVariant(event->getSubject())) ;

    evntmap->InsertL(KPhoneNumberKey , TLiwVariant(event->getNumber())) ;

    evntmap->InsertL(KDescriptionKey , TLiwVariant (event->getDescription())) ;

    evntmap->InsertL(KLinkKey , TLiwVariant((TInt32)event->getLink())) ;

    val = 0 ;

    if( event->Flags() & KLogEventContactSearched )

        {

        val = CLoggingInterface :: EKLogEventContactSearched ;

        }

    else if( event->Flags() & KLogEventRead )

        {

        val = CLoggingInterface :: EKLogEventRead ;

        }

    else

        {

        val = CLoggingInterface :: EFlagNotPresent;

        }

    if( val != -1 )  

        {    

        evntmap->InsertL(KFlagsKey , TLiwVariant((TInt32)val) );

        }

    TInt32 ret =  event->Id();

    TBuf<8> des;

    des.Num(ret);

    evntmap->InsertL(KLogId , TLiwVariant( des)) ;

    val = 0 ;

    if( ( ( event->getDirection() ).Compare( KIncomingEvent ) ) == KErrNone )

        {

        val = CLoggingInterface :: EIncomingEvent ;

        }

    else if( ( ( event->getDirection() ).Compare( KOutgoingEvent ) ) == KErrNone )

        {

        val = CLoggingInterface :: EOutgoingEvent ;

        }

    else if( ( ( event->getDirection() ).Compare( KIncomingEventAlternateline ) ) == KErrNone )

        {

        val = CLoggingInterface :: EIncomingEventAlternateline ;

        }

    else if( ( ( event->getDirection() ).Compare( KOutgoingEventAlternateline ) ) == KErrNone )

        {

        val = CLoggingInterface :: EOutgoingEventAlternateline;

        }

    else if( ( ( event->getDirection() ).Compare( KFetchedEvent ) ) == KErrNone )

        {

        val = CLoggingInterface :: EFetchedEvent;

        }

    else if( ( ( event->getDirection() ).Compare( KMissedEvent ) ) == KErrNone )

        {

        val = CLoggingInterface :: EMissedEvent;

        }

    else if( ( ( event->getDirection() ).Compare( KMissedEventAlternateline ) ) == KErrNone )

        {

        val = CLoggingInterface :: EMissedEventAlternateline;

        }

    else

        {

        val = CLoggingInterface :: EDirectionNotPresent;

        }

    if( val != -1 )  

        {    

        evntmap->InsertL(KDirectionKey , TLiwVariant((TInt32)val)) ;

        }

    evntmap->InsertL(KEventDataKey , TLiwVariant(event->getDataL()));

    aEntry.SetL( evntmap ) ;

    CleanupStack :: Pop( evntmap ) ;

    evntmap->DecRef();

    CleanupStack::Pop( event );

    delete event;

    return true ;

    }

/**

 * Default equality operator implementation

 *

 * @param aIterable the iterator instance to be compared

 *

 */

EXPORT_C  TBool CLiwLogIter :: operator==(CLiwIterable&/* aIterable*/)

    {

    /**

     * Currently Not Implemented

     */

    return true ;

    }

 //End of File