gba/common/GBALogger.cpp
branchRCL_3
changeset 5 3b17fc5c9564
parent 0 164170e6151a
child 8 ece4bbb094df
equal deleted inserted replaced
1:d5423fbb4f29 5:3b17fc5c9564
    20 
    20 
    21 #include    "GBALogger.h"
    21 #include    "GBALogger.h"
    22 #include    <flogger.h>
    22 #include    <flogger.h>
    23 
    23 
    24 const TInt KDebugBufferSize1024 = 1024;
    24 const TInt KDebugBufferSize1024 = 1024;
    25 const TInt KDebugBufferSize240 = 240;
    25 const TInt KDebugBufferSize512  = 512;
    26 const TInt KDebugBufferSize120 = 120;
    26 const TInt KDebugBufferSize240  = 240;
       
    27 const TInt KDebugBufferSize120  = 120;
    27 
    28 
    28 _LIT(KTimeFormat, "%F%D/%M/%Y %J:%T:%S");
    29 _LIT(KTimeFormat, "%F%D/%M/%Y %J:%T:%S");
    29 
    30 
    30 void debuglineL(const char *a, void *arg1, void* arg1b, void *arg2, void *arg3, const char *arg4) 
    31 void debugline(const char *a, void *arg1, void* arg1b, void *arg2, void *arg3, const char *arg4) 
    31     {
    32     {
    32     
    33     TBuf8<KDebugBufferSize1024> logbuffer;
    33     HBufC8* logbuf = HBufC8::NewLC( KDebugBufferSize1024 );
    34     TPtrC8 p((const TUint8 *)a);
    34     TPtr8 ptrlogbuf = logbuf->Des();
    35     TPtrC8 temp_arg4((const TUint8 *)arg4);
    35     
    36     
    36     TPtrC8 p((const unsigned char *)a);
    37     if( temp_arg4.Length() > KDebugBufferSize1024 - KDebugBufferSize120  )
    37     TPtrC8 temp_arg4((TUint8 *)arg4);
    38         return;
    38     ptrlogbuf.Format(p, arg1,arg1b, arg2, arg3);
    39     
    39     ptrlogbuf.Append(temp_arg4);
    40     logbuffer.Format(p, arg1,arg1b, arg2, arg3);
    40     
    41     logbuffer.Append(temp_arg4);
    41     if ( logbuf->Length() <= KDebugBufferSize120 )
    42     
    42         {
    43     if ( logbuffer.Length() <= KDebugBufferSize120 )
    43         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    44         {
    44                                   EFileLoggingModeAppend, 
    45         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    45                                   *logbuf );
    46                                   EFileLoggingModeAppend, 
       
    47                                   logbuffer );
    46         }
    48         }
    47     else
    49     else
    48         {
    50         {
    49         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    51         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    50                                   EFileLoggingModeAppend, 
    52                                   EFileLoggingModeAppend, 
    51                                   logbuf->Left( KDebugBufferSize120 ) );
    53                                   logbuffer.Left( KDebugBufferSize120 ) );
    52         //max length is 150, print another line 
    54         //max length is 150, print another line 
    53         if (logbuf->Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
    55         if (logbuffer.Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
    54             { 
    56             { 
    55             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    57             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    56                                       EFileLoggingModeAppend, 
    58                                       EFileLoggingModeAppend, 
    57                                       logbuf->Mid(KDebugBufferSize120) );
    59                                       logbuffer.Mid(KDebugBufferSize120) );
    58             }
    60             }
    59         else
    61         else
    60             {
    62             {
    61             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    63             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    62                                       EFileLoggingModeAppend, 
    64                                       EFileLoggingModeAppend, 
    63                                       logbuf->Mid(KDebugBufferSize120, KDebugBufferSize120) );
    65                                       logbuffer.Mid(KDebugBufferSize120, KDebugBufferSize120) );
    64             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    66             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    65                                       EFileLoggingModeAppend, 
    67                                       EFileLoggingModeAppend, 
    66                                       logbuf->Mid(KDebugBufferSize240) );                           
    68                                       logbuffer.Mid(KDebugBufferSize240) );                           
    67             }  
    69             }                
    68                                   
    70           }
    69           }     
    71     }
    70     CleanupStack::PopAndDestroy( logbuf );
    72 
    71     }
    73 
    72 
    74 void debugline(const char *a, void *arg1, void* arg1b, void *arg2, void *arg3, const TDesC &arg4) 
    73 
    75     {
    74 void debuglineL(const char *a, void *arg1, void* arg1b, void *arg2, void *arg3, const TDesC &arg4) 
    76     TBuf8<KDebugBufferSize1024> logbuffer;
    75     {
    77     
    76     
    78     if( arg4.Length() > KDebugBufferSize1024 - KDebugBufferSize120  )
    77     HBufC8* logbuf = HBufC8::NewLC( KDebugBufferSize1024 );
    79         return;
    78     TPtr8 ptrlogbuf = logbuf->Des();
    80     
    79     
    81     TPtrC8 p((const TUint8 *)a);
    80     TPtrC8 p((const unsigned char *)a);
    82     logbuffer.Format(p, arg1,arg1b, arg2, arg3);
    81     ptrlogbuf.Format(p, arg1,arg1b, arg2, arg3);
    83     logbuffer.Append(arg4);
    82     ptrlogbuf.Append(arg4);
    84     
    83     
    85     if ( logbuffer.Length() <= KDebugBufferSize120 )
    84     if ( logbuf->Length() <= KDebugBufferSize120 )
    86         {
    85         {
    87         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    86         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    88                                   EFileLoggingModeAppend, 
    87                                   EFileLoggingModeAppend, 
    89                                   logbuffer );
    88                                   *logbuf );
       
    89         }
    90         }
    90     else
    91     else
    91         {
    92         {
    92         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    93         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    93                                   EFileLoggingModeAppend, 
    94                                   EFileLoggingModeAppend, 
    94                                   logbuf->Left( KDebugBufferSize120 ) );
    95                                   logbuffer.Left( KDebugBufferSize120 ) );
    95         //max length is 150, print another line 
    96         //max length is 150, print another line 
    96         if (logbuf->Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
    97         if (logbuffer.Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
    97             { 
    98             { 
    98             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    99             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    99                                       EFileLoggingModeAppend, 
   100                                       EFileLoggingModeAppend, 
   100                                       logbuf->Mid(KDebugBufferSize120) );
   101                                       logbuffer.Mid(KDebugBufferSize120) );
   101             }
   102             }
   102         else
   103         else
   103             {
   104             {
   104             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   105             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   105                                       EFileLoggingModeAppend, 
   106                                       EFileLoggingModeAppend, 
   106                                       logbuf->Mid(KDebugBufferSize120, KDebugBufferSize120) );
   107                                       logbuffer.Mid(KDebugBufferSize120, KDebugBufferSize120) );
   107             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   108             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   108                                       EFileLoggingModeAppend, 
   109                                       EFileLoggingModeAppend, 
   109                                       logbuf->Mid(KDebugBufferSize240) );                          	
   110                                       logbuffer.Mid(KDebugBufferSize240) );                          	
   110             }  
   111             }        
   111                                   
   112     	  }
   112     	  }     
   113     }
   113     CleanupStack::PopAndDestroy( logbuf );
   114 
   114     }
   115 void debugline(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const TDesC8 &arg4) 
   115 
   116     {  
   116 void debuglineL(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const TDesC8 &arg4) 
   117     TBuf8<KDebugBufferSize1024> logbuffer;
   117     {
   118     
   118     HBufC8* logbuf = HBufC8::NewLC( KDebugBufferSize1024 );
   119     if( arg4.Length() > KDebugBufferSize1024 - KDebugBufferSize120)
   119     TPtr8 ptrlogbuf = logbuf->Des();
   120         return;
   120     TPtrC8 p((const unsigned char *)a);
   121     
   121     ptrlogbuf.Format(p, arg1,arg1b, arg2, arg3);
   122     TPtrC8 p((const TUint8 *)a);
   122     ptrlogbuf.Append(arg4);
   123     logbuffer.Format(p, arg1,arg1b, arg2, arg3);
   123     if ( logbuf->Length() <= KDebugBufferSize120 )
   124     logbuffer.Append(arg4); 
   124         {
   125     
   125         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   126     if ( logbuffer.Length() <= KDebugBufferSize120 )
   126                                   EFileLoggingModeAppend, 
   127         {
   127                                   *logbuf );
   128         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
       
   129                                   EFileLoggingModeAppend, 
       
   130                                   logbuffer );
   128         }
   131         }
   129     else
   132     else
   130         {
   133         {
   131         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   134         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   132                                   EFileLoggingModeAppend, 
   135                                   EFileLoggingModeAppend, 
   133                                   logbuf->Left(KDebugBufferSize120) );
   136                                   logbuffer.Left(KDebugBufferSize120) );
   134         //max length is 150, print another line 
   137         //max length is 150, print another line 
   135         
   138         
   136         if (logbuf->Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
   139         if (logbuffer.Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
   137             { 
   140             { 
   138             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   141             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   139                                       EFileLoggingModeAppend, 
   142                                       EFileLoggingModeAppend, 
   140                                       logbuf->Mid(KDebugBufferSize120) );
   143                                       logbuffer.Mid(KDebugBufferSize120) );
   141             }
   144             }
   142         else
   145         else
   143             {
   146             {
   144             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   147             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   145                                       EFileLoggingModeAppend, 
   148                                       EFileLoggingModeAppend, 
   146                                       logbuf->Mid(KDebugBufferSize120, KDebugBufferSize120) );
   149                                       logbuffer.Mid(KDebugBufferSize120, KDebugBufferSize120) );
   147             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   150             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   148                                       EFileLoggingModeAppend, 
   151                                       EFileLoggingModeAppend, 
   149                                       logbuf->Mid(KDebugBufferSize240) );                          	
   152                                       logbuffer.Mid(KDebugBufferSize240) );                          	
   150             }                               
   153             }                               
   151     	  }     
   154     	  }     
   152     CleanupStack::PopAndDestroy( logbuf );     
   155     }
   153     }
   156 
   154 
   157 void debugline(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const char *arg4, const TInt& aNum ) 
   155 void debuglineL(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const char *arg4, const TInt& aNum ) 
   158     {
   156     {
   159     TBuf8<KDebugBufferSize512> logbuf;
   157     HBufC8* logbuf = HBufC8::NewLC( KDebugBufferSize120 );
       
   158     TPtr8 ptrlogbuf = logbuf->Des();
       
   159     TPtrC8 temp_arg4((TUint8 *)arg4);
   160     TPtrC8 temp_arg4((TUint8 *)arg4);
   160     ptrlogbuf.Format( temp_arg4, aNum );
   161     
   161      
   162     if( temp_arg4.Length() > KDebugBufferSize512 - KDebugBufferSize120)
   162     debuglineL(a, arg1, arg1b, arg2, arg3, *logbuf);
   163         return;
   163     CleanupStack::PopAndDestroy( logbuf );
   164     
   164     }
   165     logbuf.Format( temp_arg4, aNum );
   165 
   166     debugline(a, arg1, arg1b, arg2, arg3, logbuf);
   166 void debuglineL(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const TDesC &arg4, const TInt& aNum ) 
   167     }
   167     {
   168 
   168     HBufC* logbuf = HBufC::NewLC(KDebugBufferSize120);
   169 void debugline(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const TDesC &arg4, const TInt& aNum ) 
   169     TPtr ptrlogbuf = logbuf->Des();
   170     {
   170     ptrlogbuf.Format( arg4, aNum );
   171     TBuf<KDebugBufferSize512> logbuf;
   171     
   172     
   172     debuglineL(a, arg1, arg1b, arg2, arg3, *logbuf);
   173     if( arg4.Length() > KDebugBufferSize512 - KDebugBufferSize120 )
   173     CleanupStack::PopAndDestroy( logbuf );
   174         return;
       
   175     
       
   176     logbuf.Format( arg4, aNum );
       
   177     debugline(a, arg1, arg1b, arg2, arg3, logbuf);
   174     }    
   178     }    
   175 
   179 
   176 void DebugBinary( const TDesC8 &buf ) 
   180 void DebugBinary( const TDesC8 &buf ) 
   177     {
   181     {
   178     RFileLogger::HexDump( KGBALogDir, KGBALogFileName,
   182     RFileLogger::HexDump( KGBALogDir, KGBALogFileName,
   179         EFileLoggingModeAppend, 
   183         EFileLoggingModeAppend, 
   180        NULL, NULL , buf.Ptr(), buf.Length() );
   184        NULL, NULL , buf.Ptr(), buf.Length() );
   181     } 
   185     } 
   182 
   186 
   183 void debugTTimeL( TTime& aTime )
   187 void debugTTime( TTime& aTime )
   184     {
   188     {
   185     TBuf<KDebugBufferSize120> buf;
   189     TBuf<KDebugBufferSize120> buf;
   186     aTime.FormatL( buf, KTimeFormat);
   190     TRAPD(error , aTime.FormatL( buf, KTimeFormat));
       
   191     if(error != KErrNone)
       
   192         return;
   187     RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   193     RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   188                              EFileLoggingModeAppend, 
   194                              EFileLoggingModeAppend, 
   189                              buf );
   195                              buf );
   190     }
   196     }
   191 
   197