← Back to branch summary

~mir-team/mir/x11-multi-window

« back to all changes in this revision

Viewing changes to 3rd_party/android-deps/cutils/log.h

Remove android-input

This now also removes the separate thread created for every client window. .

Approved by mir-ci-bot, Daniel van Vugt, Cemil Azizoglu, Brandon Schaefer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rd_party/android-deps/cutils/log.h
1
 
/*
2
 
 * Copyright (C) 2005 The Android Open Source Project
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 express or implied.
13
 
 * See the License for the specific language governing permissions and
14
 
 * limitations under the License.
15
 
 */
16
 
 
17
 
//
18
 
// C/C++ logging functions.  See the logging documentation for API details.
19
 
//
20
 
// We'd like these to be available from C code (in case we import some from
21
 
// somewhere), so this has a C interface.
22
 
//
23
 
// The output will be correct when the log file is shared between multiple
24
 
// threads and/or multiple processes so long as the operating system
25
 
// supports O_APPEND.  These calls have mutex-protected data structures
26
 
// and so are NOT reentrant.  Do not use LOG in a signal handler.
27
 
//
28
 
#ifndef _LIBS_CUTILS_LOG_H
29
 
#define _LIBS_CUTILS_LOG_H
30
 
 
31
 
#include <stdio.h>
32
 
#include <time.h>
33
 
#include <sys/types.h>
34
 
#include <unistd.h>
35
 
#ifdef HAVE_PTHREADS
36
 
#include <pthread.h>
37
 
#endif
38
 
#include <stdarg.h>
39
 
 
40
 
#include <sys/uio.h>
41
 
#include <cutils/logd.h>
42
 
 
43
 
#ifdef __cplusplus
44
 
extern "C" {
45
 
#endif
46
 
 
47
 
// ---------------------------------------------------------------------
48
 
 
49
 
/*
50
 
 * Normally we strip ALOGV (VERBOSE messages) from release builds.
51
 
 * You can modify this (for example with "#define LOG_NDEBUG 0"
52
 
 * at the top of your source file) to change that behavior.
53
 
 */
54
 
#ifndef LOG_NDEBUG
55
 
#ifdef NDEBUG
56
 
#define LOG_NDEBUG 1
57
 
#else
58
 
#define LOG_NDEBUG 0
59
 
#endif
60
 
#endif
61
 
 
62
 
/*
63
 
 * This is the local tag used for the following simplified
64
 
 * logging macros.  You can change this preprocessor definition
65
 
 * before using the other macros to change the tag.
66
 
 */
67
 
#ifndef LOG_TAG
68
 
#define LOG_TAG NULL
69
 
#endif
70
 
 
71
 
// ---------------------------------------------------------------------
72
 
 
73
 
/*
74
 
 * Simplified macro to send a verbose log message using the current LOG_TAG.
75
 
 */
76
 
#ifndef ALOGV
77
 
#if LOG_NDEBUG
78
 
#define ALOGV(...)   ((void)0)
79
 
#else
80
 
#define ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
81
 
#endif
82
 
#endif
83
 
 
84
 
#define CONDITION(cond)     (__builtin_expect((cond)!=0, 0))
85
 
 
86
 
#ifndef ALOGV_IF
87
 
#if LOG_NDEBUG
88
 
#define ALOGV_IF(cond, ...)   ((void)0)
89
 
#else
90
 
#define ALOGV_IF(cond, ...) \
91
 
    ( (CONDITION(cond)) \
92
 
    ? ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \
93
 
    : (void)0 )
94
 
#endif
95
 
#endif
96
 
 
97
 
/*
98
 
 * Simplified macro to send a debug log message using the current LOG_TAG.
99
 
 */
100
 
#ifndef ALOGD
101
 
#define ALOGD(...) ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__))
102
 
#endif
103
 
 
104
 
#ifndef ALOGD_IF
105
 
#define ALOGD_IF(cond, ...) \
106
 
    ( (CONDITION(cond)) \
107
 
    ? ((void)ALOG(LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \
108
 
    : (void)0 )
109
 
#endif
110
 
 
111
 
/*
112
 
 * Simplified macro to send an info log message using the current LOG_TAG.
113
 
 */
114
 
#ifndef ALOGI
115
 
#define ALOGI(...) ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__))
116
 
#endif
117
 
 
118
 
#ifndef ALOGI_IF
119
 
#define ALOGI_IF(cond, ...) \
120
 
    ( (CONDITION(cond)) \
121
 
    ? ((void)ALOG(LOG_INFO, LOG_TAG, __VA_ARGS__)) \
122
 
    : (void)0 )
123
 
#endif
124
 
 
125
 
/*
126
 
 * Simplified macro to send a warning log message using the current LOG_TAG.
127
 
 */
128
 
#ifndef ALOGW
129
 
#define ALOGW(...) ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__))
130
 
#endif
131
 
 
132
 
#ifndef ALOGW_IF
133
 
#define ALOGW_IF(cond, ...) \
134
 
    ( (CONDITION(cond)) \
135
 
    ? ((void)ALOG(LOG_WARN, LOG_TAG, __VA_ARGS__)) \
136
 
    : (void)0 )
137
 
#endif
138
 
 
139
 
/*
140
 
 * Simplified macro to send an error log message using the current LOG_TAG.
141
 
 */
142
 
#ifndef ALOGE
143
 
#define ALOGE(...) ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__))
144
 
#endif
145
 
 
146
 
#ifndef ALOGE_IF
147
 
#define ALOGE_IF(cond, ...) \
148
 
    ( (CONDITION(cond)) \
149
 
    ? ((void)ALOG(LOG_ERROR, LOG_TAG, __VA_ARGS__)) \
150
 
    : (void)0 )
151
 
#endif
152
 
 
153
 
// ---------------------------------------------------------------------
154
 
 
155
 
/*
156
 
 * Conditional based on whether the current LOG_TAG is enabled at
157
 
 * verbose priority.
158
 
 */
159
 
#ifndef IF_ALOGV
160
 
#if LOG_NDEBUG
161
 
#define IF_ALOGV() if (false)
162
 
#else
163
 
#define IF_ALOGV() IF_ALOG(LOG_VERBOSE, LOG_TAG)
164
 
#endif
165
 
#endif
166
 
 
167
 
/*
168
 
 * Conditional based on whether the current LOG_TAG is enabled at
169
 
 * debug priority.
170
 
 */
171
 
#ifndef IF_ALOGD
172
 
#define IF_ALOGD() IF_ALOG(LOG_DEBUG, LOG_TAG)
173
 
#endif
174
 
 
175
 
/*
176
 
 * Conditional based on whether the current LOG_TAG is enabled at
177
 
 * info priority.
178
 
 */
179
 
#ifndef IF_ALOGI
180
 
#define IF_ALOGI() IF_ALOG(LOG_INFO, LOG_TAG)
181
 
#endif
182
 
 
183
 
/*
184
 
 * Conditional based on whether the current LOG_TAG is enabled at
185
 
 * warn priority.
186
 
 */
187
 
#ifndef IF_ALOGW
188
 
#define IF_ALOGW() IF_ALOG(LOG_WARN, LOG_TAG)
189
 
#endif
190
 
 
191
 
/*
192
 
 * Conditional based on whether the current LOG_TAG is enabled at
193
 
 * error priority.
194
 
 */
195
 
#ifndef IF_ALOGE
196
 
#define IF_ALOGE() IF_ALOG(LOG_ERROR, LOG_TAG)
197
 
#endif
198
 
 
199
 
 
200
 
// ---------------------------------------------------------------------
201
 
 
202
 
/*
203
 
 * Simplified macro to send a verbose system log message using the current LOG_TAG.
204
 
 */
205
 
#ifndef SLOGV
206
 
#if LOG_NDEBUG
207
 
#define SLOGV(...)   ((void)0)
208
 
#else
209
 
#define SLOGV(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
210
 
#endif
211
 
#endif
212
 
 
213
 
#define CONDITION(cond)     (__builtin_expect((cond)!=0, 0))
214
 
 
215
 
#ifndef SLOGV_IF
216
 
#if LOG_NDEBUG
217
 
#define SLOGV_IF(cond, ...)   ((void)0)
218
 
#else
219
 
#define SLOGV_IF(cond, ...) \
220
 
    ( (CONDITION(cond)) \
221
 
    ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__)) \
222
 
    : (void)0 )
223
 
#endif
224
 
#endif
225
 
 
226
 
/*
227
 
 * Simplified macro to send a debug system log message using the current LOG_TAG.
228
 
 */
229
 
#ifndef SLOGD
230
 
#define SLOGD(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__))
231
 
#endif
232
 
 
233
 
#ifndef SLOGD_IF
234
 
#define SLOGD_IF(cond, ...) \
235
 
    ( (CONDITION(cond)) \
236
 
    ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)) \
237
 
    : (void)0 )
238
 
#endif
239
 
 
240
 
/*
241
 
 * Simplified macro to send an info system log message using the current LOG_TAG.
242
 
 */
243
 
#ifndef SLOGI
244
 
#define SLOGI(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__))
245
 
#endif
246
 
 
247
 
#ifndef SLOGI_IF
248
 
#define SLOGI_IF(cond, ...) \
249
 
    ( (CONDITION(cond)) \
250
 
    ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)) \
251
 
    : (void)0 )
252
 
#endif
253
 
 
254
 
/*
255
 
 * Simplified macro to send a warning system log message using the current LOG_TAG.
256
 
 */
257
 
#ifndef SLOGW
258
 
#define SLOGW(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__))
259
 
#endif
260
 
 
261
 
#ifndef SLOGW_IF
262
 
#define SLOGW_IF(cond, ...) \
263
 
    ( (CONDITION(cond)) \
264
 
    ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)) \
265
 
    : (void)0 )
266
 
#endif
267
 
 
268
 
/*
269
 
 * Simplified macro to send an error system log message using the current LOG_TAG.
270
 
 */
271
 
#ifndef SLOGE
272
 
#define SLOGE(...) ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__))
273
 
#endif
274
 
 
275
 
#ifndef SLOGE_IF
276
 
#define SLOGE_IF(cond, ...) \
277
 
    ( (CONDITION(cond)) \
278
 
    ? ((void)__android_log_buf_print(LOG_ID_SYSTEM, ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)) \
279
 
    : (void)0 )
280
 
#endif
281
 
 
282
 
    
283
 
 
284
 
// ---------------------------------------------------------------------
285
 
 
286
 
/*
287
 
 * Log a fatal error.  If the given condition fails, this stops program
288
 
 * execution like a normal assertion, but also generating the given message.
289
 
 * It is NOT stripped from release builds.  Note that the condition test
290
 
 * is -inverted- from the normal assert() semantics.
291
 
 */
292
 
#ifndef LOG_ALWAYS_FATAL_IF
293
 
#define LOG_ALWAYS_FATAL_IF(cond, ...) \
294
 
    ( (CONDITION(cond)) \
295
 
    ? ((void)android_printAssert(#cond, LOG_TAG, ## __VA_ARGS__)) \
296
 
    : (void)0 )
297
 
#endif
298
 
 
299
 
#ifndef LOG_ALWAYS_FATAL
300
 
#define LOG_ALWAYS_FATAL(...) \
301
 
    ( ((void)android_printAssert(NULL, LOG_TAG, ## __VA_ARGS__)) )
302
 
#endif
303
 
 
304
 
/*
305
 
 * Versions of LOG_ALWAYS_FATAL_IF and LOG_ALWAYS_FATAL that
306
 
 * are stripped out of release builds.
307
 
 */
308
 
#if LOG_NDEBUG
309
 
 
310
 
#ifndef LOG_FATAL_IF
311
 
#define LOG_FATAL_IF(cond, ...) ((void)0)
312
 
#endif
313
 
#ifndef LOG_FATAL
314
 
#define LOG_FATAL(...) ((void)0)
315
 
#endif
316
 
 
317
 
#else
318
 
 
319
 
#ifndef LOG_FATAL_IF
320
 
#define LOG_FATAL_IF(cond, ...) LOG_ALWAYS_FATAL_IF(cond, ## __VA_ARGS__)
321
 
#endif
322
 
#ifndef LOG_FATAL
323
 
#define LOG_FATAL(...) LOG_ALWAYS_FATAL(__VA_ARGS__)
324
 
#endif
325
 
 
326
 
#endif
327
 
 
328
 
/*
329
 
 * Assertion that generates a log message when the assertion fails.
330
 
 * Stripped out of release builds.  Uses the current LOG_TAG.
331
 
 */
332
 
#ifndef ALOG_ASSERT
333
 
#define ALOG_ASSERT(cond, ...) LOG_FATAL_IF(!(cond), ## __VA_ARGS__)
334
 
//#define ALOG_ASSERT(cond) LOG_FATAL_IF(!(cond), "Assertion failed: " #cond)
335
 
#endif
336
 
 
337
 
// ---------------------------------------------------------------------
338
 
 
339
 
/*
340
 
 * Basic log message macro.
341
 
 *
342
 
 * Example:
343
 
 *  ALOG(LOG_WARN, NULL, "Failed with error %d", errno);
344
 
 *
345
 
 * The second argument may be NULL or "" to indicate the "global" tag.
346
 
 */
347
 
#ifndef ALOG
348
 
#define ALOG(priority, tag, ...) \
349
 
    LOG_PRI(ANDROID_##priority, tag, __VA_ARGS__)
350
 
#endif
351
 
 
352
 
/*
353
 
 * Log macro that allows you to specify a number for the priority.
354
 
 */
355
 
#ifndef LOG_PRI
356
 
#define LOG_PRI(priority, tag, ...) \
357
 
    android_printLog(priority, tag, __VA_ARGS__)
358
 
#endif
359
 
 
360
 
/*
361
 
 * Log macro that allows you to pass in a varargs ("args" is a va_list).
362
 
 */
363
 
#ifndef LOG_PRI_VA
364
 
#define LOG_PRI_VA(priority, tag, fmt, args) \
365
 
    android_vprintLog(priority, NULL, tag, fmt, args)
366
 
#endif
367
 
 
368
 
/*
369
 
 * Conditional given a desired logging priority and tag.
370
 
 */
371
 
#ifndef IF_ALOG
372
 
#define IF_ALOG(priority, tag) \
373
 
    if (android_testLog(ANDROID_##priority, tag))
374
 
#endif
375
 
 
376
 
// ---------------------------------------------------------------------
377
 
 
378
 
/*
379
 
 * Event logging.
380
 
 */
381
 
 
382
 
/*
383
 
 * Event log entry types.  These must match up with the declarations in
384
 
 * java/android/android/util/EventLog.java.
385
 
 */
386
 
typedef enum {
387
 
    EVENT_TYPE_INT      = 0,
388
 
    EVENT_TYPE_LONG     = 1,
389
 
    EVENT_TYPE_STRING   = 2,
390
 
    EVENT_TYPE_LIST     = 3
391
 
} AndroidEventLogType;
392
 
 
393
 
 
394
 
#ifndef LOG_EVENT_INT
395
 
#define LOG_EVENT_INT(_tag, _value) {                                       \
396
 
        int intBuf = _value;                                                \
397
 
        (void) android_btWriteLog(_tag, EVENT_TYPE_INT, &intBuf,            \
398
 
            sizeof(intBuf));                                                \
399
 
    }
400
 
#endif
401
 
#ifndef LOG_EVENT_LONG
402
 
#define LOG_EVENT_LONG(_tag, _value) {                                      \
403
 
        long long longBuf = _value;                                         \
404
 
        (void) android_btWriteLog(_tag, EVENT_TYPE_LONG, &longBuf,          \
405
 
            sizeof(longBuf));                                               \
406
 
    }
407
 
#endif
408
 
#ifndef LOG_EVENT_STRING
409
 
#define LOG_EVENT_STRING(_tag, _value)                                      \
410
 
    ((void) 0)  /* not implemented -- must combine len with string */
411
 
#endif
412
 
/* TODO: something for LIST */
413
 
 
414
 
/*
415
 
 * ===========================================================================
416
 
 *
417
 
 * The stuff in the rest of this file should not be used directly.
418
 
 */
419
 
 
420
 
#define android_printLog(prio, tag, ...) \
421
 
    __android_log_print(prio, tag, __VA_ARGS__)
422
 
 
423
 
#define android_vprintLog(prio, cond, tag, ...) \
424
 
    __android_log_vprint(prio, tag, __VA_ARGS__)
425
 
 
426
 
/* XXX Macros to work around syntax errors in places where format string
427
 
 * arg is not passed to ALOG_ASSERT, LOG_ALWAYS_FATAL or LOG_ALWAYS_FATAL_IF
428
 
 * (happens only in debug builds).
429
 
 */
430
 
 
431
 
/* Returns 2nd arg.  Used to substitute default value if caller's vararg list
432
 
 * is empty.
433
 
 */
434
 
#define __android_second(dummy, second, ...)     second
435
 
 
436
 
/* If passed multiple args, returns ',' followed by all but 1st arg, otherwise
437
 
 * returns nothing.
438
 
 */
439
 
#define __android_rest(first, ...)               , ## __VA_ARGS__
440
 
 
441
 
#ifdef HAVE_ANDROID_OS
442
 
#define android_printAssert(cond, tag, ...)                             \
443
 
    __android_log_assert(cond, tag,                                     \
444
 
                         __android_second(0, ## __VA_ARGS__, NULL) __android_rest(__VA_ARGS__))
445
 
#else
446
 
#include <assert.h>
447
 
#define android_printAssert(cond, tag, ...)     \
448
 
    assert(false && #cond)
449
 
#endif // HAVE_ANDROID_OS
450
 
 
451
 
// TODO: remove these prototypes and their users
452
 
#define android_testLog(prio, tag) (1)
453
 
#define android_writevLog(vec,num) do{}while(0)
454
 
#define android_write1Log(str,len) do{}while (0)
455
 
#define android_setMinPriority(tag, prio) do{}while(0)
456
 
//#define android_logToCallback(func) do{}while(0)
457
 
#define android_logToFile(tag, file) (0)
458
 
#define android_logToFd(tag, fd) (0)
459
 
 
460
 
typedef enum {
461
 
    LOG_ID_MAIN = 0,
462
 
    LOG_ID_RADIO = 1,
463
 
    LOG_ID_EVENTS = 2,
464
 
    LOG_ID_SYSTEM = 3,
465
 
 
466
 
    LOG_ID_MAX
467
 
} log_id_t;
468
 
 
469
 
/*
470
 
 * Send a simple string to the log.
471
 
 */
472
 
int __android_log_buf_print(int bufID, int prio, const char *tag, const char *fmt, ...);
473
 
 
474
 
 
475
 
#ifdef __cplusplus
476
 
}
477
 
#endif
478
 
 
479
 
#endif // _LIBS_CUTILS_LOG_H