[Android] 013. Logger

// String型は""
var text = "text"

var num = 0
val test = "test"

// 変数を挿入するときは$をつける
text = "$test text $num"
// NG 変数testtextと解釈されて存在してないからエラー
//text = "$testtext $num"
// OK 英数字以外で区切る
text = "$test:text$num"
// OK または${}で囲う
text = "${test}text$num"

// 式を代入するときは${}で囲う
text = "${++num} ${num + 1}"

// 結合は+フォーマット指定はString.format()
text += String.format(" %s %04d", test, num)

// 数値の桁あわせは以下でも
//text = "${num.toString().padStart(4, '0')}"
text = num.toString().padStart(4, '0')

// 16進数表示(大文字)
text = Integer.toHexString(num.toInt()).uppercase()

// Java同様Kotlinもkotlin.text.StringBuilderが使える
val text_ = StringBuilder(text)
text_.append(test)
text_.append(num)
text = text_.toString()

// I/System.out: (ログの内容)
println("...")

// V/(TAG): (ログの内容)
Log.v("TAG","...")
// D/(TAG): (ログの内容)
Log.d("TAG","...")
// I/(TAG): (ログの内容)
Log.i("TAG","...")
// W/(TAG): (ログの内容)
Log.w("TAG","...")
// E/(TAG): (ログの内容)Timber
Log.e("TAG","...")
// E/(TAG): (ログの内容)
Log.wtf("TAG","...")

val threadId = Integer.toHexString(Thread.currentThread().id.toInt()).uppercase().padStart(4, '0')
val threadName = Thread.currentThread().name ?: ""
// Thread.currentThread().getStackTrace().forEach {
Throwable().stackTrace.forEach {
    val text = String.format("%s[%s] L%04d %s %s", threadName, threadId , it.lineNumber, it.className, it.methodName)
    println(text)
}

/**
 * アプリ全体でthrowしたExceptionをハンドリングします
 *
 * ApplicationクラスのonCreateなどで呼び出してください
 *
 * 例.
 * ```kotlin
 * setUncaughtExceptionHandler(isExit = true) { thread, throwable ->
 *     println(thread.toString())
 *     throwable.printStackTrace()
 * }
 * ```
 *
 * @param isExit 意図しないException発生時はアプリが不安定になることが多いためアプリ終了をサポートしています
 */
fun setUncaughtExceptionHandler(isExit: Boolean = true, process: (thread: Thread, throwable: Throwable) -> Unit) {
    val handler = Thread.UncaughtExceptionHandler { thread, throwable ->
        process(thread, throwable)

        //TODO: ApplicationやActivityのonCreate()完了前にハンドリングしてしまった場合無限ループになる
        if (isExit) android.os.Process.killProcess(android.os.Process.myPid())
    }
    Thread.setDefaultUncaughtExceptionHandler(handler)
}

/**
 * getCallMethodElement()を実行したメソッドを呼び出したメソッドのStackTraceElementを返します
 *
 * ```kotlin
 * val element = getCallMethodElement()
 * element?.let {
 *     println(String.format("line:%04d class:%s method:%s", it.lineNumber, it.className, it.methodName))
 * }
 * ```
 */
fun getCallMethodElement(): StackTraceElement? {
    val element: StackTraceElement = Throwable().stackTrace[1]
    var find = false
    Thread.currentThread().stackTrace.forEach {
        if (find) {
            val target: String = it.methodName.split("$")[0]
            if (target != element.methodName) return it
        }
        if (it.className.equals(element.className) && it.methodName.equals(element.methodName)) find = true
    }

    return null
}

class Logger {
    enum class LogLevel(val value: Int) {
        VERBOSE(Log.VERBOSE),
        DEBUG(Log.DEBUG),
        INFO(Log.VERBOSE),
        WARN(Log.WARN),
        ERROR(Log.ERROR),
        ASSERT(Log.ASSERT);
    }

    companion object {
        private var TAG: String = ""
        private var fileName: String? = null
        @Volatile private var queue: ArrayDeque<String>? = null
        private var scope: CoroutineScope? = null

        fun initialize(tag: String = "", fileName: String? = null) {
            TAG = tag
            this.fileName = fileName
            if (fileName != null) {
                queue = ArrayDeque()
                scope = MainScope()
            }
        }

        private fun output(context: Context) {
            queue?.let {
                while (it.isNotEmpty()) {
                    val text: String = it.first()
                    it.removeFirst()

                    context.openFileOutput(fileName, Context.MODE_PRIVATE or Context.MODE_APPEND).use { stream ->
                        stream.write(text.toByteArray())
                    }
                }
            }
        }

        private fun write(context: Context, text: String) {
            queue?.let {
                val now = LocalDateTime.now()
                val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")
                val line = String.format("%s %s\n", now.format(formatter), text)

                it.add(line)
                scope?.launch {
                    output(context)
                }
            }
        }

        private fun log(level: Int, tag: String, message: String, element: StackTraceElement?, context: Context? = null) {
            var text = message
            element?.let {
                text = String.format("[%04x] L%04d %s#%s: %s", Thread.currentThread().id, it.lineNumber, it.className, it.methodName, message)
            }

            when (level) {
                LogLevel.VERBOSE.value -> Log.v(tag, text)
                LogLevel.DEBUG.value -> Log.d(tag, text)
                LogLevel.INFO.value -> Log.i(tag, text)
                LogLevel.WARN.value -> Log.w(tag, text)
                LogLevel.ERROR.value -> Log.e(tag, text)
                LogLevel.ASSERT.value -> Log.wtf(tag, text)
                else -> Log.v(tag, text)
            }

            context?.let {
                val lv = when (level) {
                    LogLevel.VERBOSE.value -> "V"
                    LogLevel.DEBUG.value -> "E"
                    LogLevel.INFO.value -> "I"
                    LogLevel.WARN.value -> "W"
                    LogLevel.ERROR.value -> "E"
                    LogLevel.ASSERT.value -> "C"
                    else -> "V"
                }

                write(it, String.format("%s %s", lv, text))
            }
        }
        private fun log(level: LogLevel, tag: String, message: String, element: StackTraceElement?, context: Context? = null) {
            log(level.value, tag, message, element, context)
        }

        fun v(message: String, context: Context? = null) {
            log(LogLevel.VERBOSE, TAG, message, getCallMethodElement(), context)
        }
        fun d(message: String, context: Context? = null) {
            log(LogLevel.DEBUG, TAG, message, getCallMethodElement(), context)
        }
        fun i(message: String, context: Context? = null) {
            log(LogLevel.INFO, TAG, message, getCallMethodElement(), context)
        }
        fun w(message: String, context: Context? = null) {
            log(LogLevel.WARN, TAG, message, getCallMethodElement(), context)
        }
        fun e(message: String, context: Context? = null) {
            log(LogLevel.ERROR, TAG, message, getCallMethodElement(), context)
        }
        fun wtf(message: String, context: Context? = null) {
            log(LogLevel.ASSERT, TAG, message, getCallMethodElement(), context)
        }
    }
}

class TimberDebugTree(private val context: Context, private val tag: String): Timber.DebugTree() {
    override fun log(priority: Int, tag: String?, message: String, t: Throwable?) {
        super.log(priority, String.format("%s: %s", this.tag, tag), message, t)
    }

    override fun createStackElementTag(element: StackTraceElement): String {
        return String.format("%s@%s[%04x] L%d", element.className, element.methodName, Thread.currentThread().id, element.lineNumber)
    }
}

fun initializeTimber(context: Context, tag: String, isDebug: Boolean) {
    if (isDebug) {
        Timber.plant(TimberDebugTree(context, tag))
    }
}

class MainActivity : ComponentActivity() {
    ...
    initializeTimber(this, "TAG", BuildConfig.DEBUG)
    Timber.v("...")
    Timber.d("...")
    Timber.i("...")
    Timber.w("...")
    Timber.e("...")
    Timber.wtf("...")
}

android {
    packagingOptions {
        resources {
            excludes += '/META-INF/DEPENDENCIES'
        }
    }
}

dependencies {
    implementation 'org.apache.logging.log4j:log4j-api-kotlin:1.2.0'
    implementation 'org.apache.logging.log4j:log4j-api:2.19.0'
    implementation 'org.apache.logging.log4j:log4j-core:2.19.0'
}

import org.apache.logging.log4j.kotlin.Logging

class MainActivity : ComponentActivity(), Logging {
   ...
   logger.debug("...")
   logger.info("...")
   logger.warn("...")
   logger.error("...")
   logger.fatal("...")
}

val xml = assets.open("log4j2.xml").reader(charset=Charsets.UTF_8).use{ it.readText() }
val stream: InputStream = ByteArrayInputStream(xml.toByteArray())

val source: ConfigurationSource? = ConfigurationSource(stream)
source?.let {
    val context = LogManager.getContext(false)
    val factory = org.apache.logging.log4j.core.config.xml.XmlConfigurationFactory.getInstance()
    // Castできずエラー
    val config = factory.getConfiguration(context as LoggerContext?, it)
    Configurator.initialize(config)
    config.start()
}
val logger = LogManager.getLogger("test")
logger.debug("...")