android/JackError.cpp

   1 /*
   2  Copyright (C) 2001 Paul Davis
   3  Copyright (C) 2004-2008 Grame
   4  Copyright (C) 2008 Nedko Arnaudov
   5  Copyright (C) 2013 Samsung Electronics
   6
   7  This program is free software; you can redistribute it and/or modify
   8  it under the terms of the GNU Lesser General Public License as published by
   9  the Free Software Foundation; either version 2.1 of the License, or
  10  (at your option) any later version.
  11
  12  This program is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  GNU Lesser General Public License for more details.
  16
  17  You should have received a copy of the GNU Lesser General Public License
  18  along with this program; if not, write to the Free Software
  19  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20
  21  */
  22
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include "JackError.h"
  26 #include "JackGlobals.h"
  27 #include "JackMessageBuffer.h"
  28
  29 #define LOG_BUF_SIZE 1024
  30 #undef  LOG_TAG
  31 #ifdef SERVER_SIDE
  32 #define LOG_TAG "JackAudioServer"
  33 #else
  34 #define LOG_TAG "JackAudioClient"
  35 #endif
  36 #include <utils/Log.h>
  37
  38 using namespace Jack;
  39
  40 static bool change_thread_log_function(jack_log_function_t log_function)
  41 {
  42     return (jack_tls_get(JackGlobals::fKeyLogFunction) == NULL
  43             && jack_tls_set(JackGlobals::fKeyLogFunction, (void*)log_function));
  44 }
  45
  46 SERVER_EXPORT int set_threaded_log_function()
  47 {
  48     return change_thread_log_function(JackMessageBufferAdd);
  49 }
  50
  51 void jack_log_function(int level, const char *message)
  52 {
  53     void (* log_callback)(const char *);
  54
  55     switch (level)
  56     {
  57     case LOG_LEVEL_INFO:
  58         log_callback = jack_info_callback;
  59         break;
  60     case LOG_LEVEL_ERROR:
  61         log_callback = jack_error_callback;
  62         break;
  63     default:
  64         return;
  65     }
  66
  67     log_callback(message);
  68 }
  69
  70 static void jack_format_and_log(int level, const char *prefix, const char *fmt, va_list ap)
  71 {
  72     char buffer[256];
  73     size_t len;
  74     jack_log_function_t log_function;
  75
  76     if (prefix != NULL) {
  77         len = strlen(prefix);
  78         assert(len < 256);
  79         memcpy(buffer, prefix, len);
  80     } else {
  81         len = 0;
  82     }
  83
  84     vsnprintf(buffer + len, sizeof(buffer) - len, fmt, ap);
  85
  86     log_function = (jack_log_function_t)jack_tls_get(JackGlobals::fKeyLogFunction);
  87
  88     /* if log function is not overridden for thread, use default one */
  89     if (log_function == NULL)
  90     {
  91         log_function = jack_log_function;
  92         //log_function(LOG_LEVEL_INFO, "------ Using default log function");
  93     }
  94     else
  95     {
  96         //log_function(LOG_LEVEL_INFO, "++++++ Using thread-specific log function");
  97     }
  98
  99     log_function(level, buffer);
 100 }
 101
 102 SERVER_EXPORT void jack_error(const char *fmt, ...)
 103 {
 104     va_list ap;
 105     char buf[LOG_BUF_SIZE];
 106     va_start(ap, fmt);
 107     vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
 108     va_end(ap);
 109     __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, buf);
 110 }
 111
 112 SERVER_EXPORT void jack_info(const char *fmt, ...)
 113 {
 114     va_list ap;
 115     char buf[LOG_BUF_SIZE];
 116     va_start(ap, fmt);
 117     vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
 118     va_end(ap);
 119     __android_log_write(ANDROID_LOG_INFO, LOG_TAG, buf);
 120 }
 121
 122 SERVER_EXPORT void jack_log(const char *fmt,...)
 123 {
 124     va_list ap;
 125     char buf[LOG_BUF_SIZE];
 126     if (JackGlobals::fVerbose) {
 127         va_start(ap, fmt);
 128         vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
 129         va_end(ap);
 130         __android_log_write(ANDROID_LOG_VERBOSE, LOG_TAG, buf);
 131     }
 132 }
 133
 134 SERVER_EXPORT void default_jack_error_callback(const char *desc)
 135 {
 136     fprintf(stderr, "%s\n", desc);
 137     fflush(stderr);
 138 }
 139
 140 SERVER_EXPORT void default_jack_info_callback(const char *desc)
 141 {
 142     fprintf(stdout, "%s\n", desc);
 143     fflush(stdout);
 144 }
 145
 146 SERVER_EXPORT void silent_jack_error_callback(const char *desc)
 147 {}
 148
 149 SERVER_EXPORT void silent_jack_info_callback(const char *desc)
 150 {}
 151
 152 SERVER_EXPORT void (*jack_error_callback)(const char *desc) = &default_jack_error_callback;
 153 SERVER_EXPORT void (*jack_info_callback)(const char *desc) = &default_jack_info_callback;