phoneengine/phonemodel/inc/talogger.h
changeset 0 5f000ab63145
child 65 2a5d4ab426d3
equal deleted inserted replaced
-1:000000000000 0:5f000ab63145
       
     1 /*
       
     2 * Copyright (c) 2004 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 "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:  Provides macros for logging
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 #ifndef __TALOGGER_H__
       
    21 #define __TALOGGER_H__
       
    22 
       
    23 //  INCLUDES
       
    24 #include <e32def.h>
       
    25 
       
    26 /* 
       
    27 -----------------------------------------------------------------------------
       
    28 
       
    29     USER LOG SELECTION
       
    30 
       
    31 -----------------------------------------------------------------------------
       
    32 */
       
    33 
       
    34 inline TUint KTALOGMASK()
       
    35     {
       
    36     return 0x8fffffff;          // This is default mask value.    
       
    37     }                           // User can change mask value to get different king of logging.
       
    38 
       
    39 #ifndef _DEBUG
       
    40 
       
    41 /***************************
       
    42 * Logging method variants:
       
    43 * 0 = No logging
       
    44 * 1 = Flogger
       
    45 * 2 = RDebug
       
    46 ***************************/ 
       
    47 
       
    48 #define TEF_LOGGING_METHOD      0   // UREL BUILD
       
    49 
       
    50 #else
       
    51 
       
    52 #ifdef __WINS__
       
    53 #define TEF_LOGGING_METHOD      2   // UDEB BUILD, WINS
       
    54 #else
       
    55 #define TEF_LOGGING_METHOD      2   // UDEB BUILD, HW
       
    56 #endif // __WINS__
       
    57 
       
    58 #endif // _DEBUG
       
    59 
       
    60 
       
    61 // Next is for backward compatibility
       
    62 #if TEF_LOGGING_METHOD > 0
       
    63 #define TEF_LOGGING_ENABLED     
       
    64 #define TF_LOGGING_ENABLED
       
    65 #endif
       
    66 
       
    67 
       
    68 /* 
       
    69 -----------------------------------------------------------------------------
       
    70 
       
    71     LOGGING OPTIONS
       
    72 
       
    73 -----------------------------------------------------------------------------
       
    74 */
       
    75 
       
    76 #define KTAOBJECT  0x00000001   // Construction and destruction
       
    77 
       
    78 #define KTAERROR   0x00000002   // Error that can be handled. Describe reason for error situation.
       
    79 #define KTAPANIC   0x00000004   // Critical error: Panic.
       
    80 
       
    81 #define KTAMESIN   0x00000008   // From client to TELE message
       
    82 #define KTAMESOUT  0x00000010   // From TELE to client message
       
    83 #define KTAMESINT  0x00000020   // TELE internal message
       
    84 
       
    85 #define KTAREQIN   0x00000040   // Public interface methods
       
    86 #define KTAREQOUT  0x00000080   // Set outgoing request
       
    87 #define KTAREQEND  0x00000100   // Complete request
       
    88 
       
    89 #define KTAINT     0x00000200   // Internal activity
       
    90 
       
    91 #define KTAMSTATE  0x00000400   // Component state changes
       
    92 
       
    93 #define KTAGENERAL 0x00000800   // For deprecated TFLOGxxx-macros and for temporary usage
       
    94 
       
    95 
       
    96 /* 
       
    97 -----------------------------------------------------------------------------
       
    98 
       
    99     LOG SETTINGS
       
   100 
       
   101 -----------------------------------------------------------------------------
       
   102 */
       
   103 
       
   104 #if TEF_LOGGING_METHOD == 1      // Flogger
       
   105 
       
   106 #include <flogger.h>
       
   107 _LIT(KTfLogFolder,"PE");
       
   108 _LIT(KTfLogFile,"TALOG.TXT");
       
   109 
       
   110 #elif TEF_LOGGING_METHOD == 2    // RDebug
       
   111 
       
   112 #include <e32svr.h>
       
   113 
       
   114 #endif
       
   115 
       
   116 
       
   117 /*
       
   118 -----------------------------------------------------------------------------
       
   119 
       
   120     LOGGING MACROs
       
   121 
       
   122     USE THESE MACROS IN YOUR CODE !
       
   123 
       
   124 -----------------------------------------------------------------------------
       
   125 */
       
   126 #define MESSAGE(A)                        _L(A)
       
   127 
       
   128 #if TEF_LOGGING_METHOD == 1      // Flogger
       
   129 
       
   130 #define TEFLOGTEXT(Type,AAA)            { \
       
   131                                         if((KTALOGMASK()&(Type))==(Type)) \
       
   132                                             { \
       
   133                                             RFileLogger::Write(KTfLogFolder(),KTfLogFile(), \
       
   134                                             EFileLoggingModeAppend, AAA); \
       
   135                                             } \
       
   136                                         }
       
   137 #define TEFLOGSTRING(Type,AAA)          { \
       
   138                                         if((KTALOGMASK()&(Type))==(Type)) \
       
   139                                             { \
       
   140                                             _LIT(tempLogDes,AAA); \
       
   141                                             RFileLogger::Write(KTfLogFolder(),KTfLogFile(), \
       
   142                                             EFileLoggingModeAppend,tempLogDes()); \
       
   143                                             } \
       
   144                                         }
       
   145 #define TEFLOGSTRING2(Type,AAA,BBB)     { \
       
   146                                         if((KTALOGMASK()&(Type))==(Type)) \
       
   147                                             { \
       
   148                                             _LIT(tempLogDes,AAA); \
       
   149                                             RFileLogger::WriteFormat(KTfLogFolder(),KTfLogFile(), \
       
   150                                             EFileLoggingModeAppend, \
       
   151                                             TRefByValue<const TDesC>(tempLogDes()),BBB); \
       
   152                                             } \
       
   153                                         }
       
   154 #define TEFLOGSTRING3(Type,AAA,BBB,CCC) { \
       
   155                                         if((KTALOGMASK()&(Type))==(Type)) \
       
   156                                             { \
       
   157                                             _LIT(tempLogDes,AAA); \
       
   158                                             RFileLogger::WriteFormat(KTfLogFolder(),KTfLogFile(), \
       
   159                                             EFileLoggingModeAppend, \
       
   160                                             TRefByValue<const TDesC>(tempLogDes()),BBB,CCC); \
       
   161                                             } \
       
   162                                         }
       
   163 #define TEFLOGSTRING4(Type,AAA,BBB,CCC,DDD) { \
       
   164                                             if((KTALOGMASK()&(Type))==(Type)) \
       
   165                                                 { \
       
   166                                                 _LIT(tempLogDes,AAA); \
       
   167                                                 RFileLogger::WriteFormat(KTfLogFolder(), \
       
   168                                                 KTfLogFile(),EFileLoggingModeAppend, \
       
   169                                                 TRefByValue<const TDesC>(tempLogDes()), \
       
   170                                                 BBB,CCC,DDD); \
       
   171                                                 } \
       
   172                                             }
       
   173 
       
   174 #elif TEF_LOGGING_METHOD == 2    // RDebug
       
   175 
       
   176 #define TEFLOGTEXT(Type,AAA)                { \
       
   177                                             if((KTALOGMASK()&(Type))==(Type)) RDebug::Print(AAA); \
       
   178                                             }
       
   179 #define TEFLOGSTRING(Type,AAA)              { \
       
   180                                             if((KTALOGMASK()&(Type))== \
       
   181                                             (Type)) RDebug::Print(_L(AAA)); \
       
   182                                             }
       
   183 #define TEFLOGSTRING2(Type,AAA,BBB)         { \
       
   184                                             if((KTALOGMASK()&(Type))== \
       
   185                                             (Type)) RDebug::Print(_L(AAA),BBB); \
       
   186                                             }
       
   187 #define TEFLOGSTRING3(Type,AAA,BBB,CCC)     { \
       
   188                                             if((KTALOGMASK()&(Type))== \
       
   189                                             (Type)) RDebug::Print(_L(AAA),BBB,CCC); \
       
   190                                             }
       
   191 #define TEFLOGSTRING4(Type,AAA,BBB,CCC,DDD) { \
       
   192                                             if((KTALOGMASK()&(Type))== \
       
   193                                             (Type)) RDebug::Print(_L(AAA),BBB,CCC,DDD); \
       
   194                                             }
       
   195 
       
   196 #else   // TEF_LOGGING_METHOD == 0 or invalid
       
   197 
       
   198 #define TEFLOGTEXT(Type,AAA)              // Example: TFLOGTEXT(KTAMESOUT, own_desc)
       
   199 #define TEFLOGSTRING(Type,AAA)            // Example: TFLOGSTRING(KTAMESIN, "Test")
       
   200 #define TEFLOGSTRING2(Type,AAA,BBB)       // Example: TFLOGSTRING(KTAMESINT, "Test %i", aValue)
       
   201 #define TEFLOGSTRING3(Type,AAA,BBB,CCC)   // Example: TFLOGSTRING(KTAMESOUT, "Test %i %i", aValue1, aValue2)
       
   202 #define TEFLOGSTRING4(Type,AAA,BBB,CCC,DDD)   // Example: TFLOGSTRING(KTAMESOUT, "Test %i %i %i", aValue1, aValue2, aValue3)
       
   203 
       
   204 #endif  // TEF_LOGGING_METHOD
       
   205 
       
   206 
       
   207 /*
       
   208 -----------------------------------------------------------------------------
       
   209 
       
   210     DEPRECATED LOGGING MACROs
       
   211 
       
   212     DON'T USE THESE MACROS IN YOUR CODE ANYMORE!
       
   213 
       
   214 -----------------------------------------------------------------------------
       
   215 */
       
   216 
       
   217 #define TFLOGTEXT(AAA)              TEFLOGTEXT(KTAGENERAL,AAA);
       
   218 #define TFLOGSTRING(AAA)            TEFLOGSTRING(KTAGENERAL,AAA);
       
   219 #define TFLOGSTRING2(AAA,BBB)       TEFLOGSTRING2(KTAGENERAL,AAA,BBB);
       
   220 #define TFLOGSTRING3(AAA,BBB,CCC)   TEFLOGSTRING3(KTAGENERAL,AAA,BBB,CCC);
       
   221 #define TFLOGSTRING4(AAA,BBB,CCC,DDD)   TEFLOGSTRING4(KTAGENERAL,AAA,BBB,CCC,DDD);
       
   222 
       
   223 #endif  // TALOGGER_H