1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  implements interface class for logging sapi

    15 *

    16 */

    17 

    18 

    19 #include <e32base.h>

    20 #include <e32def.h>

    21 #include <f32file.h>

    22 #include <cntdef.h>

    23 #include <logwrap.h>

    24 #include <logwrap.hrh>

    25 #include <liwserviceifbase.h>

    26 #include <LiwCommon.h>

    27 #include <ecom/ImplementationProxy.h>

    28 #include  <utf.h>

    29 #include "loggingasyncservice.h"

    30 

    31 

    32 #include "LOGCLIENTCHANGEOBSERVER.H"

    33 #include "logiter.h"

    34 #include "loggingservice.h"

    35 #include "loggingasyncservice.h"

    36 #include "loggingsyncservice.h"

    37 #include "loggingevent.h"

    38 #include "loggingfilter.h"

    39 #include "loggingcallbackslot.h"

    40 #include "logobserver.h"

    41 #include "logginginterface.h"

    42 #include "liwlogiter.h"

    43 #include "loggingcallback.h"

    44 

    45 

    46 

    47 /**

    48  * Default Constructor Method

    49  */

    50 CLoggingInterface :: CLoggingInterface()

    51     {

    52     }

    53     

    54 /**

    55  * Default Destructor

    56  */

    57 CLoggingInterface :: ~CLoggingInterface()

    58     {

    59     delete iErrorString;

    60     delete iLogService;

    61     }

    62 

    63 /**

    64  * Two phased constructor implementation

    65  */

    66 CLoggingInterface* CLoggingInterface :: NewL()

    67     {

    68     CLoggingInterface* self = CLoggingInterface::NewLC();

    69     CleanupStack::Pop( self );

    70     return self;

    71     }

    72 

    73 /**

    74  * Two phased constructor implementation

    75  */

    76 CLoggingInterface* CLoggingInterface :: NewLC()

    77     {

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

    79     CleanupStack::PushL( self );

    80     self->ConstructL();

    81     return self;

    82     }

    83 

    84 /**

    85  * This function constructs the member elements of CLoggingInterface Class

    86  */

    87 void CLoggingInterface :: ConstructL()

    88     {

    89     iLogService = CLoggingService::NewL();

    90     }

    91 

    92 /**

    93  * closes the interface

    94  */

    95 void CLoggingInterface::Close()

    96     {

    97     delete this;

    98     }

    99 

   100 /**

   101  * Convert to sapiError Function

   102  */

   103 TInt  CLoggingInterface::ConvertToSapiError( TInt aSymbianErr )

   104     {

   105     TInt sapiErr( SErrGeneralError );

   106 

   107     switch ( aSymbianErr )

   108         {

   109         case KErrArgument:

   110             {

   111             sapiErr = SErrBadArgumentType;

   112             break;

   113             }

   114         case KErrNotSupported:

   115             {

   116             sapiErr = SErrServiceNotSupported;

   117             break;

   118             }

   119         case KErrServerBusy:

   120             {

   121             sapiErr = SErrServerBusy;

   122             break;

   123             }

   124         case KErrGeneral:

   125             {

   126             sapiErr = SErrGeneralError;

   127             break;

   128             }

   129         case KErrCancel:

   130             {

   131             sapiErr = SErrCancelSuccess;

   132             break;

   133             }

   134         case KErrNone:

   135             {

   136             sapiErr= SErrNone;

   137             break;

   138             }

   139         case KErrNotFound:

   140             {

   141             sapiErr= SErrNotFound;

   142             break;

   143             }

   144         case KErrNoMemory:

   145             {

   146             sapiErr = SErrNoMemory;

   147             break;

   148             }

   149         case KErrInUse:

   150             {

   151             sapiErr = SErrServiceInUse;

   152             break;

   153             }

   154         case KErrNotReady:

   155             {

   156             sapiErr = SErrServiceNotReady;

   157             break;

   158             }

   159         case SErrMissingArgument:

   160             {

   161             sapiErr = SErrMissingArgument;

   162             break;

   163             }

   164         case SErrInvalidServiceArgument :

   165             {

   166             sapiErr = SErrInvalidServiceArgument;

   167             break;    

   168             } 

   169         }

   170     return sapiErr;

   171     }

   172 

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

   174     {

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

   176         {

   177         iErrorString = HBufC::NewL(KMaxMsgSize);

   178         TPtr ptr(iErrorString->Des());

   179         TBuf<KMaxKeySize> buf;

   180         buf.Copy( *aErrorArgument );

   181         ptr.Append(buf);

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

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

   184         User::Leave( KErrArgument );

   185         }

   186     }

   187 

   188 void CLoggingInterface::IncorrectValueL( const TDesC8* aErrorArgument )

   189     {

   190     iErrorString = HBufC::NewL(KMaxMsgSize);

   191     TPtr ptr(iErrorString->Des());

   192     TBuf<KMaxKeySize> buf;

   193     buf.Copy( *aErrorArgument );

   194     ptr.Append(buf);

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

   196     }

   197 

   198 void CLoggingInterface::MissingValueL( const TDesC8* aErrorArgument )

   199     {

   200     iErrorString = HBufC::NewL(KMaxMsgSize);

   201     TPtr ptr(iErrorString->Des());

   202     TBuf<KMaxKeySize> buf;

   203     buf.Copy( *aErrorArgument );

   204     ptr.Append(buf);

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

   206     User::Leave( SErrMissingArgument );

   207     }

   208 

   209 /**

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

   211  * then calls appropriate method on iLocationService object

   212  */

   213 void CLoggingInterface :: ExecuteCmdL( const TDesC8& aCmdName,

   214                                        const CLiwGenericParamList& aInParamList,

   215                                        CLiwGenericParamList& aOutParamList,

   216                                        TUint aCmdOptions,

   217                                        MLiwNotifyCallback* aCallback )

   218     {

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

   220     if( error != KErrNone )

   221         {

   222         if( iErrorString )

   223             {

   224             TBuf<150> errorMessage;

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

   226             TBuf<40> commandName;

   227             commandName.Copy( aCmdName );

   228             errorMessage.Append( commandName );

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

   230             

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

   232             

   233             aOutParamList.AppendL(TLiwGenericParam( KErrorMessage,

   234                         TLiwVariant( errorMessage )));

   235             delete iErrorString;

   236             iErrorString = NULL;

   237             }

   238         }

   239     TInt sapierror = ConvertToSapiError( error );

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

   241     }

   242 

   243 /**

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

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

   246  *

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

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

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

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

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

   252  * @param aCallback callback to be registered by consumer application

   253  * @see TLiwServiceCmdOptions

   254  * @see CLiwGenericParamList

   255  * @see MLiwNotifyCallback

   256  */

   257 void CLoggingInterface :: CmdExecuteL( const TDesC8& aCmdName,

   258                                        const CLiwGenericParamList& aInParamList,

   259                                        CLiwGenericParamList& aOutParamList,

   260                                        TUint aCmdOptions,

   261                                        MLiwNotifyCallback* aCallback )

   262     {

   263     aOutParamList.Reset() ;

   264     

   265     if(!aCmdName.CompareF( KCmdCancel ))

   266         {

   267         if( aCmdOptions & KLiwOptCancel )

   268             {

   269             TInt ret = 0 ;

   270             

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

   272             

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

   274                 {

   275                 transidparam  = &(aInParamList[EIndex0])  ;

   276                 

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

   278                     {

   279                     MissingValueL( KTransactionId.operator&() );

   280                     }

   281                 }

   282                 

   283             if( !transidparam )

   284                 {

   285                 MissingValueL( KTransactionId.operator&() );

   286                 }

   287                 

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

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

   290             

   291             if( transid<0 )

   292                 {

   293                 IncorrectValueL( KTransactionId.operator&() );

   294                 User::Leave( KErrNotFound );

   295                 }

   296                 

   297             ret = iLogService->CancelServiceL( transid ) ;

   298             

   299             if( ret == KErrNotFound )

   300                 {

   301                 IncorrectValueL( KTransactionId.operator&() );

   302                 User::Leave( KErrNotFound );

   303                 }

   304                 

   305             return ;

   306             }

   307         }

   308         

   309     else if(!aCmdName.CompareF( KCmdAdd ))

   310         {

   311         TBool indexBaseInp = ETrue;

   312         TInt Index = 0 ;

   313         

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

   315         

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

   317             {

   318             contentType = &(aInParamList[EIndex0]) ;

   319             

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

   321                 {

   322                 MissingValueL( KContentTypeKey.operator&() );

   323                 }

   324             }

   325         else

   326             {

   327             indexBaseInp = EFalse ;

   328             }

   329            

   330         if( !contentType )

   331             {

   332             MissingValueL( KContentTypeKey.operator&() );

   333             }

   334         

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

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

   337         

   338         if(content.CompareF( KContentType ))

   339             {

   340             IncorrectValueL( KContentTypeKey.operator&() );

   341             User::Leave( SErrInvalidServiceArgument );

   342             }

   343         

   344         TInt index = 0 ;

   345         const TLiwGenericParam *eventdetails = NULL ;

   346         TUint transid ;

   347         

   348         if ( indexBaseInp ) 

   349             {

   350             if( aInParamList.Count() > 1 )

   351                 {

   352                 eventdetails  = &(aInParamList[EIndex1]) ;

   353                 }

   354             }

   355         else

   356             {

   357             eventdetails = aInParamList.FindFirst( index , KEventDetails );

   358             }    

   359         

   360         if( !eventdetails )

   361             {

   362             MissingValueL( KEventDetails.operator&() );

   363             }

   364         

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

   366         

   367         if( aCallback )

   368             {

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

   370             }

   371         else

   372             {

   373             TBuf<8> des;

   374             des.Num( ret );

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

   376             }

   377         }

   378     

   379     else if(!aCmdName.CompareF( KCmdGetList ))

   380         {

   381         TBool indexBaseInp = ETrue;

   382         TInt Index = 0 ;

   383         

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

   385         

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

   387             {

   388             contentType = &(aInParamList[EIndex0]) ;

   389             

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

   391                 {

   392                 MissingValueL( KContentTypeKey.operator&() );

   393                 }

   394             }

   395          else

   396             {

   397             indexBaseInp = EFalse ;

   398             }    

   399         

   400         if( !contentType )

   401             {

   402             MissingValueL( KContentTypeKey.operator&() );

   403             }

   404         

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

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

   407         

   408         if( content.CompareF( KContentType ) )

   409             {

   410             IncorrectValueL( KContentTypeKey.operator&() );

   411             User::Leave( SErrInvalidServiceArgument );

   412             }

   413         

   414         TInt index = 0 ;

   415         const TLiwGenericParam *flrParam = NULL ;

   416         TUint transid ;

   417        

   418         if ( indexBaseInp ) 

   419             {

   420             if( aInParamList.Count() > 1 )

   421                 {

   422                 flrParam = &aInParamList[EIndex1] ;

   423                 }

   424             }

   425         else

   426             {

   427             flrParam = aInParamList.FindFirst( index , KFilter ) ; 

   428             }    

   429         

   430        

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

   432               

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

   434         if( aCallback )

   435             {

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

   437             }

   438         else

   439             {

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

   441             CleanupClosePushL( *logiter );

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

   443             CleanupStack :: Pop( logiter ) ;

   444             logiter->DecRef() ;

   445             }

   446         }

   447      

   448     else if(!aCmdName.CompareF( KCmdRequestNotification ))

   449         {

   450         TBool indexBaseInp = ETrue;

   451         TInt Index = 0 ;

   452         

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

   454         

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

   456             {

   457             contentType = &(aInParamList[EIndex0]) ;

   458             

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

   460                 {

   461                 MissingValueL( KContentTypeKey.operator&() );

   462                 }

   463             }

   464         else

   465             {

   466             indexBaseInp = EFalse ;

   467             }    

   468         

   469         if( !contentType )

   470             {

   471             MissingValueL( KContentTypeKey.operator&() );

   472             }

   473         

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

   475         

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

   477         

   478         if(content.CompareF( KContentType ))

   479             {

   480             IncorrectValueL( KContentTypeKey.operator&() );

   481             User::Leave( SErrInvalidServiceArgument );

   482             }

   483                 

   484         TInt index = 0 ;

   485         TUint transid ;

   486         const TLiwGenericParam *interval = NULL ;

   487         

   488         if ( indexBaseInp ) 

   489             {

   490             if( aInParamList.Count() > 1 )

   491                 {

   492                 interval = &(aInParamList[EIndex1]) ;

   493                 }

   494             }

   495         else

   496             {

   497             interval = aInParamList.FindFirst( index , KFilter ) ;

   498             }    

   499         

   500        if( !interval )

   501             {

   502             MissingValueL( KFilter.operator&() );

   503             }

   504         

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

   506         

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

   508         }

   509     

   510     else if(!aCmdName.CompareF( KCmdDelete ))

   511         {

   512         TBool indexBaseInp = ETrue;

   513         TInt Index = 0 ;

   514         

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

   516         

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

   518             {

   519             contentType = &(aInParamList[EIndex0]) ;

   520             

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

   522                 {

   523                 MissingValueL( KContentTypeKey.operator&() );

   524                 }

   525             }

   526         else

   527             {

   528             indexBaseInp = EFalse ;

   529             }        

   530         

   531         if( !contentType )

   532             {

   533             MissingValueL( KContentTypeKey.operator&() );

   534             }

   535         

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

   537         

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

   539         

   540         if(content.CompareF(KContentType))

   541             {

   542             IncorrectValueL( KContentTypeKey.operator&() );

   543             User::Leave( SErrInvalidServiceArgument );

   544             }

   545         

   546         TInt index = 0;

   547         TUint transid;

   548         const TLiwGenericParam *logid = NULL ;

   549         

   550         if ( indexBaseInp ) 

   551             {

   552             if( aInParamList.Count() > 1 )

   553                 {

   554                 logid = &aInParamList[EIndex1] ;

   555                 }

   556             }

   557         else

   558             {

   559             logid = aInParamList.FindFirst( index , KData ) ;

   560             }    

   561         

   562         if( !logid )

   563             {

   564             MissingValueL( KData.operator&() );

   565             }

   566         

   567         TInt ret = DeleteEventL( logid, transid, aCmdOptions, aCallback );

   568         

   569         if( ret != KErrNone )

   570             {

   571             IncorrectValueL( KLogId.operator&() );

   572             User::Leave( KErrNotFound );

   573             }

   574         

   575         if( aCallback )

   576              {

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

   578              }

   579         }

   580     

   581     else

   582         {

   583         iErrorString = KErrLogCmdName.operator()().Alloc();

   584         User :: Leave( KErrNotSupported ) ;

   585         }

   586     }

   587 

   588 /**

   589  * Internal utility method, used to Add from the core class

   590  *

   591  * @param aeventdetails,

   592  * @param aTransId,

   593  * @param aCallback, callback method for async events

   594  */

   595 TInt32 CLoggingInterface::AddEventL( const TLiwGenericParam *eventdetails ,

   596                                      TUint& aTansId ,

   597                                      TUint aCmdOptions,

   598                                      MLiwNotifyCallback* aCallback )

   599     {

   600     CheckInputTypeL( &eventdetails->Value(), LIW::EVariantTypeMap, KEventDetails.operator&() );

   601     

   602     CLogsEvent *event  = CLogsEvent :: NewL() ;

   603     

   604     CleanupStack :: PushL( event ) ;

   605     

   606     const CLiwMap *evtmap = (eventdetails->Value()).AsMap() ;

   607     

   608     if( !evtmap )

   609         {

   610         MissingValueL( KEventDetails.operator&() );

   611         }

   612     

   613     TLiwVariant mapVar;

   614     

   615     CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &mapVar) );

   616     

   617     /**

   618     * Extract the contents of Add Event Details

   619     * and issue request to the core class  accordingly

   620     */

   621     if( evtmap->FindL( KEventTypeKey , mapVar ) )

   622         {

   623         CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KEventTypeKey.operator&() );

   624         TUid val = TUid::Null() ;

   625         

   626         switch( mapVar.AsTInt32() )

   627             {

   628             case EKLogCallEventType :

   629                 {

   630                 val =  TUid :: Uid( KLogCallEventType );

   631                 break ;

   632                 }

   633             

   634             case EKLogDataEventType :

   635                 {

   636                 val = TUid :: Uid ( KLogDataEventType );

   637                 break ;

   638                 }

   639             

   640             case EKLogFaxEventType :

   641                 {

   642                 val = TUid :: Uid ( KLogFaxEventType );

   643                 break ;

   644                 }

   645             

   646             case EKLogShortMessageEventType :

   647                 {

   648                 val = TUid :: Uid ( KLogShortMessageEventType );

   649                 break ;

   650                 }

   651                 

   652             case EKLogPacketDataEventType :

   653                 {

   654                 val = TUid :: Uid ( KLogPacketDataEventType ) ;

   655                 break ;

   656                 }     

   657             

   658             default :

   659                 {

   660                 mapVar.Reset();

   661                 IncorrectValueL( KEventTypeKey.operator&() ); 

   662                 User::Leave( SErrInvalidServiceArgument );

   663                 }

   664             }

   665         event->SetEventType( val ) ;

   666         }

   667     else

   668         {

   669         mapVar.Reset();

   670         MissingValueL( KEventTypeKey.operator&() );

   671         }

   672     

   673     if( evtmap->FindL( KRemotePartyKey , mapVar ) )

   674         {

   675         CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC, KRemotePartyKey.operator&() );

   676         event->SetRemoteParty(mapVar.AsDes()) ;

   677         }

   678     

   679     if(evtmap->FindL( KDirectionKey , mapVar ))

   680         {

   681         CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KDirectionKey.operator&() );

   682         TInt val = 0 ;

   683         

   684         switch(mapVar.AsTInt32())

   685             {

   686             case EIncomingEvent :

   687                 {

   688                 val = R_LOG_DIR_IN ;

   689                 break ;

   690                 }

   691         

   692             case EOutgoingEvent :

   693                 {

   694                 val = R_LOG_DIR_OUT ;

   695                 break ;

   696                 }

   697         

   698             case EIncomingEventAlternateline :

   699                 {

   700                 val = R_LOG_DIR_IN_ALT ;

   701                 break ;

   702                 }

   703         

   704             case EOutgoingEventAlternateline :

   705                 {

   706                 val = R_LOG_DIR_OUT_ALT  ;

   707                 break ;

   708                 }

   709         

   710             case  EFetchedEvent :

   711                 {

   712                 val = R_LOG_DIR_FETCHED ;

   713                 break ;

   714                 }

   715         

   716             case EMissedEvent :

   717                 {

   718                 val = R_LOG_DIR_MISSED ;

   719                 break ;

   720                 }

   721         

   722             case EMissedEventAlternateline :

   723                 {

   724                 val = R_LOG_DIR_MISSED_ALT ;

   725                 break ;

   726                 }

   727                 

   728             default :

   729                 {

   730                 mapVar.Reset();

   731                 IncorrectValueL( KDirectionKey.operator&() );  

   732                 User::Leave( SErrInvalidServiceArgument );

   733                 }

   734             }

   735         

   736         if( val )

   737             {

   738             event->SetDirection( val ) ;

   739             }

   740         }

   741     

   742     

   743     if(evtmap->FindL(KEventDurationKey , mapVar))

   744         {

   745         CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KEventDurationKey.operator&() );

   746         

   747         if( mapVar.AsTInt32()<0 )

   748               {

   749               mapVar.Reset();

   750               IncorrectValueL( KEventDurationKey.operator&() );

   751               User::Leave( SErrInvalidServiceArgument );

   752               }

   753         event->SetDurationType( KLogDurationValid ) ;

   754         event->SetDuration( mapVar.AsTInt32() ) ;

   755         }

   756     

   757     if(evtmap->FindL( KDeliveryStatusKey , mapVar ))

   758         {

   759         CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KDeliveryStatusKey.operator&() );

   760         TInt val = 0 ;

   761         

   762         switch( mapVar.AsTInt32() )

   763             {

   764             case EStatusPending :

   765                 {

   766                 val =  R_LOG_DEL_PENDING ;

   767                 break ;

   768                 }

   769         

   770             case EStatusSent :

   771                 {

   772                 val = R_LOG_DEL_SENT ;

   773                 break ;

   774                 }

   775         

   776             case EStatusFalied :

   777                 {

   778                 val = R_LOG_DEL_FAILED ;

   779                 break ;

   780                 }

   781         

   782             case EStatusNone :

   783                 {

   784                 val = R_LOG_DEL_NONE  ;

   785                 break ;

   786                 }

   787         

   788             case  EStatusDone :

   789                 {

   790                 val = R_LOG_DEL_DONE ;

   791                 break ;

   792                 }

   793         

   794             case EStatusNotSent :

   795                 {

   796                 val = R_LOG_DEL_NOT_SENT ;

   797                 break ;

   798                 }

   799         

   800             case EStatusScheduled :

   801                 {

   802                 val = R_LOG_DEL_SCHEDULED ;

   803                 break ;

   804                 }

   805                 

   806             default :

   807                 {

   808                 mapVar.Reset();

   809                 IncorrectValueL( KDeliveryStatusKey.operator&() );  

   810                 User::Leave( SErrInvalidServiceArgument );

   811                 }

   812             }

   813         

   814         if( val )

   815             {

   816             event->SetStatus( val ) ;

   817             }

   818         }

   819     

   820     if(evtmap->FindL(KFlagsKey , mapVar))

   821         {

   822         CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KFlagsKey.operator&() );

   823         TUint8 val = 0 ;

   824         

   825         switch(mapVar.AsTInt32())

   826             {

   827             case EKLogEventContactSearched :

   828                 {

   829                 val = KLogEventContactSearched ;

   830                 break ;

   831                 }

   832             

   833             case EKLogEventRead :

   834                 {

   835                 val = KLogEventRead ;

   836                 break ;

   837                 }

   838             

   839             default :

   840                 {

   841                 mapVar.Reset();

   842                 IncorrectValueL( KFlagsKey.operator&() );  

   843                 User::Leave( SErrInvalidServiceArgument );

   844                 }

   845             }

   846         

   847         if( val )

   848             {

   849             event->SetFlags( val ) ;

   850             }

   851         }

   852     

   853     if(evtmap->FindL( KSubjectKey , mapVar ))

   854         {

   855         CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC, KSubjectKey.operator&() );

   856         event->SetSubject( mapVar.AsDes() ) ;

   857         }

   858     

   859     if(evtmap->FindL( KPhoneNumberKey , mapVar ))

   860         {

   861         CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC, KPhoneNumberKey.operator&() );

   862         event->SetNumber( mapVar.AsDes() ) ;

   863         }

   864         

   865     if(evtmap->FindL( KEventDataKey , mapVar ))

   866         {

   867         CheckInputTypeL( &mapVar, LIW::EVariantTypeDesC8, KEventDataKey.operator&() );

   868         event->SetDataL( mapVar.AsData() ) ;

   869         }

   870     

   871     if(evtmap->FindL( KLinkKey , mapVar ))

   872         {

   873         CheckInputTypeL( &mapVar, LIW::EVariantTypeTInt32, KLinkKey.operator&() );

   874         

   875         if( mapVar.AsTInt32()<0 )

   876           {

   877            mapVar.Reset();

   878            IncorrectValueL( KLinkKey.operator&() );

   879            User::Leave( SErrInvalidServiceArgument );

   880           }

   881          event->SetLink( mapVar.AsTInt32() ) ;

   882         }

   883     

   884     CleanupStack::Pop( &mapVar );

   885     

   886     mapVar.Reset();

   887         

   888     if( KLiwOptASyncronous & aCmdOptions )

   889         {

   890         if( aCallback!=NULL )

   891             {

   892             aTansId = MLiwNotifyCallback :: GetTransactionID() ;

   893             LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;

   894             CleanupStack :: PushL( cb ) ;

   895             cb->SetRequestType( EAddEvent ) ;

   896             iLogService->AddEventL( aTansId, event, cb );

   897             CleanupStack::Pop( cb );

   898             CleanupStack::Pop( event );

   899             delete event ;

   900             return 0;

   901             }

   902         else

   903             {

   904             iErrorString = KErrMissingCallback.operator()().Alloc();

   905             User::Leave( SErrInvalidServiceArgument );

   906             }

   907         }

   908     else

   909         {

   910         TInt32 logid = iLogService->AddEventL(event) ;

   911         

   912         if(logid<0)

   913             {

   914             IncorrectValueL( KLogId.operator&() );

   915             User::Leave( SErrInvalidServiceArgument );

   916             }

   917             

   918         CleanupStack::Pop(event);

   919         delete event ;

   920         return  logid ;

   921         }

   922     

   923     return 0;

   924     }

   925 

   926 /**

   927  * Internal utility method, used to getlist from the core class

   928  *

   929  * @param aFilter, filter for getlist on core class

   930  * @param aTransid , value/result argument(TransactionId

   931  * @param aCallback, callback method for async events

   932  */

   933 CLogIter*  CLoggingInterface :: GetListL(  const TLiwGenericParam  *aFilter,

   934                                            TUint& aTansId,

   935                                            TUint aCmdOptions,

   936                                            MLiwNotifyCallback  *aCallback )

   937     {

   938     if( aFilter && (aFilter->Value().TypeId() != LIW::EVariantTypeNull) )

   939         {

   940         CheckInputTypeL( &aFilter->Value(), LIW::EVariantTypeMap ,KFilter.operator&() );

   941         

   942         CLogsFilter *filter = CLogsFilter :: NewL() ;

   943         

   944         filter->SetRequestType( EReadEvents ) ;

   945         

   946         CleanupStack :: PushL( filter ) ;

   947         

   948         const CLiwMap *mapParam = (aFilter->Value()).AsMap() ;

   949         

   950         TLiwVariant var ;

   951         

   952         CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , &var) );

   953         

   954         /**

   955         * Extract the contents of getlist filter

   956         * and issue request to the core class  accordingly

   957         */

   958         

   959         if( mapParam->FindL( KLogId ,var ) )

   960             {

   961             TInt32 logid;

   962             CheckInputTypeL( &var, LIW::EVariantTypeDesC, KLogId.operator&() );

   963             if( var.AsDes()!=KNullDesC16 )

   964                 {

   965                 if( var.AsDes().Length() < 256 )

   966                     {

   967                     TBuf<256> Val2 = var.AsDes();

   968                     TLex lex(Val2);

   969                     TInt32 error = lex.Val( logid );

   970                     if( error!=KErrNone )

   971                         {

   972                         var.Reset();

   973                         IncorrectValueL( KLogId.operator&() );

   974                         User::Leave( SErrInvalidServiceArgument );

   975                         }

   976                     }

   977                 else

   978                     {

   979                     var.Reset();

   980                     IncorrectValueL( KLogId.operator&() );

   981                     User::Leave( SErrInvalidServiceArgument );

   982                     }

   983                     

   984                 if( logid>-1 )

   985                     {

   986                     CleanupStack::Pop( &var );

   987                     var.Reset();

   988                     CLogsEvent *event =  CLogsEvent :: NewL();

   989                     CleanupStack :: PushL( event ) ;

   990                     event->SetId( logid );

   991                     filter->SetEventL( event ) ;

   992                     CleanupStack :: Pop( event ) ;

   993                     delete event ;

   994                     filter->SetRequestType( EGetEvent ) ;

   995         

   996                     if( KLiwOptASyncronous & aCmdOptions )

   997                         {

   998                         if( aCallback!=NULL )

   999                             {

  1000                             aTansId = MLiwNotifyCallback :: GetTransactionID() ;

  1001                             LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL(aCallback) ;

  1002                             CleanupStack :: PushL( cb ) ;

  1003                             cb->SetRequestType( EGetEvent ) ;

  1004                             iLogService->GetListL( aTansId, filter, cb) ;

  1005                             CleanupStack :: Pop( cb ) ;

  1006                             CleanupStack :: Pop( filter ) ;

  1007                             delete filter ;

  1008                             return NULL;

  1009                             }

  1010                         else

  1011                             {

  1012                             iErrorString = KErrMissingCallback.operator()().Alloc();

  1013                             User::Leave( SErrInvalidServiceArgument );

  1014                             }

  1015                         }

  1016                      else

  1017                         {

  1018                         CLogIter *Iter = iLogService->GetListL( filter ) ;

  1019                         CleanupStack :: Pop( filter ) ;

  1020                         delete filter;

  1021                         return Iter ;

  1022                         }

  1023                     }

  1024                   else

  1025                       {

  1026                       var.Reset();

  1027                       User::Leave( SErrInvalidServiceArgument );

  1028                       }

  1029                 }

  1030             }

  1031                 

  1032         if( mapParam->FindL(KRecentListKey , var) )

  1033             {

  1034             CheckInputTypeL( &var, LIW::EVariantTypeTInt32, KRecentListKey.operator&() );

  1035         

  1036             TInt Val3 = var.AsTInt32();

  1037         

  1038             switch( Val3 )

  1039                 {

  1040                 case EKLogNullRecentList :

  1041                     {

  1042                     filter->SetRecentList( KLogNullRecentList ) ;

  1043                     break;

  1044                     }

  1045         

  1046                 case EKLogRecentIncomingCalls :

  1047                     {

  1048                     filter->SetRecentList( KLogRecentIncomingCalls );

  1049                     break;

  1050                     }

  1051     

  1052                 case EKLogRecentOutgoingCalls :

  1053                     {

  1054                     filter->SetRecentList( KLogRecentOutgoingCalls );

  1055                     break;

  1056                     }

  1057     

  1058                 case EKLogRecentMissedCalls :

  1059                     {

  1060                     filter->SetRecentList( KLogRecentMissedCalls );

  1061                     break;

  1062                     }

  1063                     

  1064                 default :

  1065                     {

  1066                     var.Reset();

  1067                     IncorrectValueL( KRecentListKey.operator&() );  

  1068                     User::Leave( SErrInvalidServiceArgument );

  1069                     break ;

  1070                     }

  1071                 }

  1072                     

  1073                 

  1074             CleanupStack::Pop( &var );

  1075             var.Reset();    

  1076             

  1077             filter->SetRequestType(EGetRecent) ;

  1078         

  1079             if ( KLiwOptASyncronous & aCmdOptions )

  1080                  {

  1081                  if( aCallback!=NULL )

  1082                      {

  1083                      aTansId = MLiwNotifyCallback :: GetTransactionID() ;

  1084                      LoggingInterfaceCB *cb = LoggingInterfaceCB :: NewL( aCallback ) ;

  1085                      CleanupStack :: PushL( cb ) ;

  1086                      cb->SetRequestType( EGetRecent ) ;

  1087                      iLogService->GetListL( aTansId, filter, cb) ;

  1088                      CleanupStack :: Pop( cb ) ;

  1089                      CleanupStack :: Pop( filter ) ;

  1090                      delete filter ;

  1091                      return NULL;

  1092                      }

  1093                  else

  1094                      {

  1095                      iErrorString = KErrMissingCallback.operator()().Alloc();

  1096                      User::Leave( SErrInvalidServiceArgument );

  1097                      }

  1098                  }

  1099              else

  1100                  {

  1101                  CLogIter *Iter = iLogService->GetListL( filter ) ;

  1102                  CleanupStack :: Pop( filter ) ;

  1103                  delete filter;

  1104                  return Iter;

  1105                  }

  1106                     

  1107             }

  1108         

  1109         if( mapParam->FindL( KPhoneNumberKey ,var ) )

  1110             {

  1111             CheckInputTypeL( &var, LIW::EVariantTypeDesC, KPhoneNumberKey.operator&() );

  1112             filter->SetNumber( var.AsDes() ) ;

  1113             }

  1114         

  1115         if( mapParam->FindL( KDirectionKey ,var ) )

  1116             {

  1117             CheckInputTypeL( &var, LIW::EVariantTypeTInt32, KDirectionKey.operator&() );

  1118             TInt val = 0 ;

  1119         

  1120             switch( var.AsTInt32() )

  1121                 {

  1122                 case EIncomingEvent:

  1123                     {

  1124                     val = R_LOG_DIR_IN ;

  1125                     break ;

  1126                     }

  1127         

  1128                 case EOutgoingEvent :

  1129                     {

  1130                     val = R_LOG_DIR_OUT ;

  1131                     break ;

  1132                     }

  1133         

  1134                 case EIncomingEventAlternateline :