/*

* 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 interface class for logging sapi

*

*/

#include <e32base.h>

#include <e32def.h>

#include <f32file.h>

#include <cntdef.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logwrap.h>

#else

#include <logwrap.h>

#include <logengevents.h>

#include <logwraplimits.h>

#include <logfilterandeventconstants.hrh>

#include <logengdurations.h>

#endif

#include <liwserviceifbase.h>

#include <liwcommon.h>

#include <ecom/implementationproxy.h>

#include  <utf.h>

#include "loggingasyncservice.h"

#include "logclientchangeobserver.h"

#include "logiter.h"

#include "loggingservice.h"

#include "loggingasyncservice.h"

#include "loggingsyncservice.h"

#include "loggingevent.h"

#include "loggingfilter.h"

#include "loggingcallbackslot.h"

#include "logobserver.h"

#include "logginginterface.h"

#include "liwlogiter.h"

#include "loggingcallback.h"

/**

 * Default Constructor Method

 */

CLoggingInterface :: CLoggingInterface()

    {

    }

/**

 * Default Destructor

 */

CLoggingInterface :: ~CLoggingInterface()

    {

    delete iErrorString;

    delete iLogService;

    }

/**

 * Two phased constructor implementation

 */

CLoggingInterface* CLoggingInterface :: NewL()

    {

    CLoggingInterface* self = CLoggingInterface::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

/**

 * Two phased constructor implementation

 */

CLoggingInterface* CLoggingInterface :: NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

/**

 * This function constructs the member elements of CLoggingInterface Class

 */

void CLoggingInterface :: ConstructL()

    {

    iLogService = CLoggingService::NewL();

    }

/**

 * closes the interface

 */

void CLoggingInterface::Close()

    {

    delete this;

    }

/**

 * Convert to sapiError Function

 */

TInt  CLoggingInterface::ConvertToSapiError( TInt aSymbianErr )

    {

    TInt sapiErr( SErrGeneralError );

    switch ( aSymbianErr )

        {

        case KErrArgument:

            {

            sapiErr = SErrBadArgumentType;

            break;

            }

        case KErrNotSupported:

            {

            sapiErr = SErrServiceNotSupported;

            break;

            }

        case KErrServerBusy:

            {

            sapiErr = SErrServerBusy;

            break;

            }

        case KErrGeneral:

            {

            sapiErr = SErrGeneralError;

            break;

            }

        case KErrCancel:

            {

            sapiErr = SErrCancelSuccess;

            break;

            }

        case KErrNone:

            {

            sapiErr= SErrNone;

            break;

            }

        case KErrNotFound:

            {

            sapiErr= SErrNotFound;

            break;

            }

        case KErrNoMemory:

            {

            sapiErr = SErrNoMemory;

            break;

            }

        case KErrInUse:

            {

            sapiErr = SErrServiceInUse;

            break;

            }

        case KErrNotReady:

            {

            sapiErr = SErrServiceNotReady;

            break;

            }

        case SErrMissingArgument:

            {

            sapiErr = SErrMissingArgument;

            break;

            }

        case SErrInvalidServiceArgument :

            {

            sapiErr = SErrInvalidServiceArgument;

            break;    

            } 

        }

    return sapiErr;

    }

void CLoggingInterface::CheckInputTypeL( const TLiwVariant* aSource, LIW::TVariantTypeId aExpectedtype, const TDesC8* aErrorArgument )

    {

    if( aSource->TypeId() != aExpectedtype )

        {

        iErrorString = HBufC::NewL(KMaxMsgSize);

        TPtr ptr(iErrorString->Des());

        TBuf<KMaxKeySize> buf;

        buf.Copy( *aErrorArgument );

        ptr.Append(buf);

        ptr.Append( KInvalid.operator()());

        ((TLiwVariant*)aSource)->Reset();

        User::Leave( KErrArgument );

        }

    }

void CLoggingInterface::IncorrectValueL( const TDesC8* aErrorArgument )

    {

    iErrorString = HBufC::NewL(KMaxMsgSize);

    TPtr ptr(iErrorString->Des());

    TBuf<KMaxKeySize> buf;

    buf.Copy( *aErrorArgument );

    ptr.Append(buf);

    ptr.Append( KInvalid.operator()());

    }

void CLoggingInterface::MissingValueL( const TDesC8* aErrorArgument )

    {

    iErrorString = HBufC::NewL(KMaxMsgSize);

    TPtr ptr(iErrorString->Des());

    TBuf<KMaxKeySize> buf;

    buf.Copy( *aErrorArgument );

    ptr.Append(buf);

    ptr.Append( KMissing.operator()());

    User::Leave( SErrMissingArgument );

    }

/**

 * Function : ExecuteCmdL , called directly by consumer, parses the input parameters and

 * then calls appropriate method on iLocationService object

 */

void CLoggingInterface :: ExecuteCmdL( const TDesC8& aCmdName,

                                       const CLiwGenericParamList& aInParamList,

                                       CLiwGenericParamList& aOutParamList,

                                       TUint aCmdOptions,

                                       MLiwNotifyCallback* aCallback )

    {

    TRAPD( error , CmdExecuteL( aCmdName , aInParamList , aOutParamList , aCmdOptions , aCallback ) ) ;

    if( error != KErrNone )

        {

        if( iErrorString )

            {

            TBuf<150> errorMessage;

            errorMessage.Append( KMsgErr.operator()() );

            TBuf<40> commandName;

            commandName.Copy( aCmdName );

            errorMessage.Append( commandName );

            errorMessage.Append( KColon.operator()());

            errorMessage.Append( iErrorString->Des() );

            aOutParamList.AppendL(TLiwGenericParam( KErrorMessage,

                        TLiwVariant( errorMessage )));

            delete iErrorString;

            iErrorString = NULL;

            }

        }

    TInt sapierror = ConvertToSapiError( error );

    aOutParamList.AppendL(TLiwGenericParam(KErrorCode , TLiwVariant((TInt32)sapierror))) ;

    }

/**

 * CLoggingInterface::CmdExecuteL, this method is called by CLoggingInterface::HandleCmdL()

 * to catch any leaves that might occur during execution of a LiwCommand.

 *

 * @param aCmdName the name of the service command which the consumer wants to invoke

 * @param aInParamList the input parameter list, can be empty list

 * @param [in,out] aOutParamList the output parameter list, can be empty lis. The

 * service provider can use the output parameter list to fill in necessary return values

 * @param aCmdOptions Options for the command, see TLiwServiceCmdOptions in LiwCommon.hrh.

 * @param aCallback callback to be registered by consumer application

 * @see TLiwServiceCmdOptions

 * @see CLiwGenericParamList

 * @see MLiwNotifyCallback

 */

void CLoggingInterface :: CmdExecuteL( const TDesC8& aCmdName,

                                       const CLiwGenericParamList& aInParamList,

                                       CLiwGenericParamList& aOutParamList,

                                       TUint aCmdOptions,

                                       MLiwNotifyCallback* aCallback )

    {

    aOutParamList.Reset() ;

    if(!aCmdName.CompareF( KCmdCancel ))

        {

        if( aCmdOptions & KLiwOptCancel )

            {

            TInt ret = 0 ;

            const TLiwGenericParam *transidparam = aInParamList.FindFirst( ret , KTransactionId ) ;

            if(!transidparam && ( aInParamList.Count() > 0 ) )

                {

                transidparam  = &(aInParamList[EIndex0])  ;

                if( transidparam->Name().Compare( KNullDesC8 ) )

                    {

                    MissingValueL( KTransactionId.operator&() );

                    }

                }

            if( !transidparam )

                {

                MissingValueL( KTransactionId.operator&() );

                }

            CheckInputTypeL( &transidparam->Value(), LIW::EVariantTypeTInt32, KTransactionId.operator&() );  

            TInt32 transid = (transidparam->Value()).AsTInt32() ;

            if( transid<0 )

                {

                IncorrectValueL( KTransactionId.operator&() );

                User::Leave( KErrNotFound );

                }

            ret = iLogService->CancelServiceL( transid ) ;

            if( ret == KErrNotFound )

                {

                IncorrectValueL( KTransactionId.operator&() );

                User::Leave( KErrNotFound );

                }

            return ;

            }

        }

    else if(!aCmdName.CompareF( KCmdAdd ))

        {

        TBool indexBaseInp = ETrue;

        TInt Index = 0 ;

        const TLiwGenericParam *contentType = aInParamList.FindFirst( Index , KContentTypeKey ) ;

        if( !contentType && ( aInParamList.Count() > 0 ) )

            {

            contentType = &(aInParamList[EIndex0]) ;

            if( contentType->Name().Compare( KNullDesC8 ) )

                {

                MissingValueL( KContentTypeKey.operator&() );

                }

            }

        else

            {

            indexBaseInp = EFalse ;

            }

        if( !contentType )

            {

            MissingValueL( KContentTypeKey.operator&() );

            }

        CheckInputTypeL( &contentType->Value(), LIW::EVariantTypeDesC, KContentTypeKey.operator&() );

        TPtrC content = (contentType->Value()).AsDes() ;

        if(content.CompareF( KContentType ))

            {

            IncorrectValueL( KContentTypeKey.operator&() );

            User::Leave( SErrInvalidServiceArgument );

            }

        TInt index = 0 ;

        const TLiwGenericParam *eventdetails = NULL ;

        TUint transid ;

        if ( indexBaseInp ) 

            {

            if( aInParamList.Count() > 1 )

                {

                eventdetails  = &(aInParamList[EIndex1]) ;

                }

            }

        else

            {

            eventdetails = aInParamList.FindFirst( index , KEventDetails );

            }    

        if( !eventdetails )

            {

            MissingValueL( KEventDetails.operator&() );

            }

        TInt32  ret = AddEventL( eventdetails, transid, aCmdOptions, aCallback ) ;

        if( aCallback )

            {

            aOutParamList.AppendL( TLiwGenericParam( KTransactionId , TLiwVariant ( ( TInt32 )transid ) ) ) ;

            }

        else

            {

            TBuf<8> des;

            des.Num( ret );

            aOutParamList.AppendL( TLiwGenericParam( KResponse , TLiwVariant( des ) ) ) ;

            }

        }

    else if(!aCmdName.CompareF( KCmdGetList ))

        {

        TBool indexBaseInp = ETrue;

        TInt Index = 0 ;

        const TLiwGenericParam *contentType = aInParamList.FindFirst(Index , KContentTypeKey) ;

        if( !contentType && ( aInParamList.Count() > 0 ) )

            {

            contentType = &(aInParamList[EIndex0]) ;

            if( contentType->Name().Compare( KNullDesC8 ) )

                {

                MissingValueL( KContentTypeKey.operator&() );

                }

            }

         else

            {

            indexBaseInp = EFalse ;

            }    

        if( !contentType )

            {

            MissingValueL( KContentTypeKey.operator&() );

            }

        CheckInputTypeL( &contentType->Value(), LIW::EVariantTypeDesC ,KContentTypeKey.operator&() );

        TPtrC content = (contentType->Value()).AsDes() ;

        if( content.CompareF( KContentType ) )

            {

            IncorrectValueL( KContentTypeKey.operator&() );

            User::Leave( SErrInvalidServiceArgument );

            }

        TInt index = 0 ;

        const TLiwGenericParam *flrParam = NULL ;

        TUint transid ;

        if ( indexBaseInp ) 

            {

            if( aInParamList.Count() > 1 )

                {

                flrParam = &aInParamList[EIndex1] ;

                }

            }

        else

            {

            flrParam = aInParamList.FindFirst( index , KFilter ) ; 

            }    

       CLogIter *iter = this->GetListL(flrParam , transid ,aCmdOptions, aCallback) ;

        /*Ownership of logiter will be with the consumer*/

        if( aCallback )

            {

            aOutParamList.AppendL( TLiwGenericParam( KTransactionId , TLiwVariant( ( TInt32 )transid ) ) ) ;

            }

        else

            {

            CLiwLogIter *logiter = CLiwLogIter :: NewL( iter ) ;

            CleanupClosePushL( *logiter );

            aOutParamList.AppendL( TLiwGenericParam( KResponse , TLiwVariant( logiter ) ) ) ;

            CleanupStack :: Pop( logiter ) ;

            logiter->DecRef() ;

            }

        }

    else if(!aCmdName.CompareF( KCmdRequestNotification ))

        {

        TBool indexBaseInp = ETrue;

        TInt Index = 0 ;

        const TLiwGenericParam *contentType = aInParamList.FindFirst( Index , KContentTypeKey ) ;

        if( !contentType && ( aInParamList.Count() > 0 ) )

            {

            contentType = &(aInParamList[EIndex0]) ;

            if( contentType->Name().Compare( KNullDesC8 ) )

                {

                MissingValueL( KContentTypeKey.operator&() );

                }

            }

        else

            {

            indexBaseInp = EFalse ;

            }    

        if( !contentType )

            {

            MissingValueL( KContentTypeKey.operator&() );

            }

        CheckInputTypeL( &contentType->Value(), LIW::EVariantTypeDesC, KContentTypeKey.operator&() );

        TPtrC content = (contentType->Value()).AsDes() ;

        if(content.CompareF( KContentType ))

            {

            IncorrectValueL( KContentTypeKey.operator&() );

            User::Leave( SErrInvalidServiceArgument );

            }

        TInt index = 0 ;

        TUint transid ;

        const TLiwGenericParam *interval = NULL ;

        if ( indexBaseInp ) 

            {

            if( aInParamList.Count() > 1 )

                {

                interval = &(aInParamList[EIndex1]) ;

                }

            }

        else

            {

            interval = aInParamList.FindFirst( index , KFilter ) ;

            }    

       if( !interval )

            {

            MissingValueL( KFilter.operator&() );

            }

        this->RequestNotificationsL( interval, aCallback, transid, aCmdOptions ) ;

        aOutParamList.AppendL( TLiwGenericParam( KTransactionId , TLiwVariant( ( TInt32 )transid ) ) ) ;

        }

    else if(!aCmdName.CompareF( KCmdDelete ))

        {

        TBool indexBaseInp = ETrue;

        TInt Index = 0 ;

        const TLiwGenericParam *contentType = aInParamList.FindFirst( Index , KContentTypeKey ) ;

        if( !contentType && ( aInParamList.Count() > 0 ))

            {

            contentType = &(aInParamList[EIndex0]) ;