android/android_logger_config.h

   1 /* ------------------------------------------------------------------
   2  * Copyright (C) 2009 PacketVideo
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  13  * express or implied.
  14  * See the License for the specific language governing permissions
  15  * and limitations under the License.
  16  * -------------------------------------------------------------------
  17  */
  18
  19 #ifndef ANDROID_LOGGER_CONFIG_H
  20 #define ANDROID_LOGGER_CONFIG_H
  21
  22 #include "author/authordriver.h"
  23 #include "android_log_appender.h"
  24
  25 #define MAX_STRING_LEN  255
  26
  27 class PVLoggerConfigFile{
  28 /** By default:
  29  *    - An Instrumentation level (defined by PVLOGGER_INST_LEVEL in external/opencore/oscl/oscl/config/android/osclconfig.h) is set to 1.
  30  *    - Logging in all components is enabled.
  31  */
  32
  33 /*  To enable debug level logs for all components, change PVLOGGER_INST_LEVEL to 5.
  34
  35     To configure logging at runtime, a file pvlogger.txt must be located in the sdcard.
  36     The format for log level and logger tag in the file should be: "level,node".
  37     For example, pvlogger.txt can look like:
  38     1,PVPlayerEngine
  39     8,PVSocketNode
  40     Above example means log the message level PVLOGMSG_ALERT for PVPlayerEngine and PVLOGMSG_DEBUG for PVSocketNode.  See pvlogger.h for log level values.
  41     NOTE: There should be no space between log level and logger tag.
  42 */
  43 public:
  44     PVLoggerConfigFile():iLogFileRead(false)
  45     {
  46         iFileServer.Connect();
  47         iLogFileName[MAX_STRING_LEN] = '\0';
  48         oscl_strncpy(iLogFileName,"/sdcard/pvlogger.txt", MAX_STRING_LEN);
  49         oscl_memset(ibuffer, 0, sizeof(ibuffer));
  50     }
  51
  52     ~PVLoggerConfigFile()
  53     {
  54         iFileServer.Close();
  55     }
  56
  57     //Read and parse the config file
  58     //retval = -1 if the config file doesnt exist
  59     void ReadAndParseLoggerConfigFile()
  60     {
  61         bool isRTSAvailable = false;
  62
  63         if(0 != iLogFile.Open(iLogFileName,Oscl_File::MODE_READ, iFileServer))
  64         {
  65             isRTSAvailable = false;
  66         }
  67         else
  68         {
  69             if(!iLogFileRead)
  70             {
  71                 int32 nCharRead = iLogFile.Read(ibuffer,1, sizeof(ibuffer));
  72                 //Parse the buffer for \n chars
  73                 Oscl_Vector<char*,OsclMemAllocator> LogConfigStrings;
  74
  75                 //Get the logger strings
  76                 const char* const lnFd = "\n";
  77                 const int8 lnFdLen = oscl_strlen(lnFd);
  78                 int16 offset = 0;
  79                 char* lastValidBffrAddr = ibuffer + oscl_strlen(ibuffer);
  80                 const char* lnFdIndx = oscl_strstr(ibuffer, lnFd);
  81                 while(lnFdIndx!=NULL && lnFdIndx < lastValidBffrAddr)
  82                 {
  83                     oscl_memset((char*)lnFdIndx, '\0', lnFdLen);
  84                     LogConfigStrings.push_back(ibuffer + offset);
  85                     offset = (lnFdIndx + lnFdLen) - ibuffer;
  86                     lnFdIndx = oscl_strstr(ibuffer + offset, lnFd);
  87                 }
  88                 if(NULL == lnFdIndx && ((ibuffer + offset) < lastValidBffrAddr))
  89                 {
  90                     LogConfigStrings.push_back(ibuffer + offset);
  91                 }
  92
  93                 //Populate the  LoggerConfigElements vector
  94                 {
  95                     if(!LogConfigStrings.empty())
  96                     {
  97                         Oscl_Vector<char*,OsclMemAllocator>::iterator it;
  98                         if(LogConfigStrings.size() > 0)
  99                         {
 100                             for (it = LogConfigStrings.begin(); it!= LogConfigStrings.end(); it++)
 101                             {
 102                                 char* hashIndex = OSCL_CONST_CAST(char*, oscl_strstr(*it, "#"));
 103                                 char* CommaIndex = OSCL_CONST_CAST(char*, oscl_strstr(*it, ","));
 104                                 // Skip lines with hash
 105                                 if (hashIndex == NULL)
 106                                 {
 107                                     if(CommaIndex != NULL)
 108                                     {
 109                                         *CommaIndex = '\0';
 110                                         LoggerConfigElement obj;
 111                                         uint32 logLevel;
 112                                         PV_atoi(*it,'d',oscl_strlen(*it),logLevel);
 113                                         obj.iLogLevel = logLevel;
 114                                         obj.iLoggerString= CommaIndex +1;
 115                                         iLoggerConfigElements.push_back(obj);
 116                                     }
 117                                     else
 118                                     {
 119                                         //Add the config element for logging all the modules with specified log level
 120                                         LoggerConfigElement obj;
 121                                         uint32 logLevel;
 122                                         PV_atoi(*it,'d',oscl_strlen(*it),logLevel);
 123                                         obj.iLoggerString = "";
 124                                         obj.iLogLevel = logLevel;
 125                                         iLoggerConfigElements.push_back(obj);
 126                                     }
 127                                 }
 128                             }
 129                         }
 130                     }
 131                     else
 132                     {
 133                         //Add the config element for complete logging for all the modules
 134                         LoggerConfigElement obj;
 135                         obj.iLoggerString = "";
 136                         obj.iLogLevel = 8;
 137                         iLoggerConfigElements.push_back(obj);
 138                     }
 139                 }
 140                 iLogFile.Close();
 141                 iLogFileRead = true;
 142                 isRTSAvailable = true;
 143             }
 144         }
 145         SetLoggerSettings(isRTSAvailable);
 146     }
 147
 148     void SetLoggerSettings(bool isRTSAvailable)
 149     {
 150         PVLoggerAppender *appender=NULL;
 151         OsclRefCounter *refCounter=NULL;
 152
 153         appender = new AndroidLogAppender<TimeAndIdLayout,1024>();
 154         OsclRefCounterSA<LogAppenderDestructDealloc<AndroidLogAppender<TimeAndIdLayout,1024> > > *appenderRefCounter =
 155             new OsclRefCounterSA<LogAppenderDestructDealloc<AndroidLogAppender<TimeAndIdLayout,1024> > >(appender);
 156         refCounter = appenderRefCounter;
 157
 158         OsclSharedPtr<PVLoggerAppender> appenderPtr(appender,refCounter);
 159
 160         if (isRTSAvailable == false) {
 161             PVLogger *node = NULL;
 162             node = PVLogger::GetLoggerObject(""); // All modules
 163             node->AddAppender(appenderPtr);       // Using AndroidLogAppender
 164             node->SetLogLevel(PVLOGMSG_DEBUG);    // Debug level
 165
 166         } else {
 167             Oscl_Vector<LoggerConfigElement, OsclMemAllocator>::iterator it;
 168
 169             if(iLoggerConfigElements.empty())
 170             {
 171                 return;
 172             }
 173
 174             for (it = iLoggerConfigElements.begin(); it!= iLoggerConfigElements.end(); it++)
 175             {
 176                 PVLogger *node = NULL;
 177                 node = PVLogger::GetLoggerObject(it->iLoggerString);
 178                 node->AddAppender(appenderPtr);
 179                 node->SetLogLevel(it->iLogLevel);
 180             }
 181         }
 182     }
 183
 184 private:
 185     class LoggerConfigElement{
 186         public:
 187         LoggerConfigElement()
 188         {
 189             iLoggerString = NULL;
 190             iLogLevel = 8;
 191         }
 192         const char *iLoggerString;
 193         int8 iLogLevel;
 194     };
 195     bool iLogFileRead;
 196     Oscl_File iLogFile;
 197     Oscl_FileServer iFileServer;
 198     char iLogFileName[MAX_STRING_LEN+1];
 199     char ibuffer[1024];
 200     Oscl_Vector<LoggerConfigElement, OsclMemAllocator> iLoggerConfigElements;
 201 };
 202
 203 #endif
 204