android: add logging

src/android/app/src/main/cpp/CMakeLists.txt

@@ -1,6 +1,9 @@
 cmake_minimum_required(VERSION 3.8)
 
 add_library(citra-android SHARED
+            logging/log.cpp
+            logging/logcat_backend.cpp
+            logging/logcat_backend.h
             native_interface.cpp
             native_interface.h
             ui/main/main_activity.cpp

src/android/app/src/main/cpp/logging/log.cpp

@@ -0,0 +1,15 @@
+#include "common/logging/log.h"
+#include "native_interface.h"
+
+namespace Log {
+extern "C" {
+JNICALL void Java_org_citra_1emu_citra_LOG_logEntry(JNIEnv* env, jclass type, jint level,
+                                                    jstring file_name, jint line_number,
+                                                    jstring function, jstring msg) {
+    using CitraJNI::GetJString;
+    FmtLogMessage(Class::Frontend, static_cast<Level>(level), GetJString(env, file_name).data(),
+                  static_cast<unsigned int>(line_number), GetJString(env, function).data(),
+                  GetJString(env, msg).data());
+}
+}
+} // namespace Log

src/android/app/src/main/cpp/logging/logcat_backend.cpp

@@ -0,0 +1,38 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <android/log.h>
+#include "common/assert.h"
+#include "common/logging/text_formatter.h"
+#include "logcat_backend.h"
+
+namespace Log {
+void LogcatBackend::Write(const Entry& entry) {
+    android_LogPriority priority;
+    switch (entry.log_level) {
+    case Level::Trace:
+        priority = ANDROID_LOG_VERBOSE;
+        break;
+    case Level::Debug:
+        priority = ANDROID_LOG_DEBUG;
+        break;
+    case Level::Info:
+        priority = ANDROID_LOG_INFO;
+        break;
+    case Level::Warning:
+        priority = ANDROID_LOG_WARN;
+        break;
+    case Level::Error:
+        priority = ANDROID_LOG_ERROR;
+        break;
+    case Level::Critical:
+        priority = ANDROID_LOG_FATAL;
+        break;
+    case Level::Count:
+        UNREACHABLE();
+    }
+
+    __android_log_print(priority, "citra", "%s\n", FormatLogMessage(entry).c_str());
+}
+} // namespace Log

src/android/app/src/main/cpp/logging/logcat_backend.h

@@ -0,0 +1,22 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/logging/backend.h"
+
+namespace Log {
+class LogcatBackend : public Backend {
+public:
+    static const char* Name() {
+        return "Logcat";
+    }
+
+    const char* GetName() const override {
+        return Name();
+    }
+
+    void Write(const Entry& entry) override;
+};
+} // namespace Log

src/android/app/src/main/cpp/ui/main/main_activity.cpp

@@ -2,14 +2,30 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/common_paths.h"
 #include "common/file_util.h"
+#include "common/logging/filter.h"
+#include "common/logging/log.h"
+#include "core/settings.h"
+#include "logging/logcat_backend.h"
 #include "native_interface.h"
 
 namespace MainActivity {
 extern "C" {
 JNICALL void Java_org_citra_1emu_citra_ui_main_MainActivity_initUserPath(JNIEnv* env, jclass type,
                                                                          jstring path) {
-    FileUtil::SetUserPath(CitraJNI::GetJString(env, path));
+    FileUtil::SetUserPath(CitraJNI::GetJString(env, path) + '/');
+}
+
+JNICALL void Java_org_citra_1emu_citra_ui_main_MainActivity_initLogging(JNIEnv* env, jclass type) {
+    Log::Filter log_filter(Log::Level::Debug);
+    log_filter.ParseFilterString(Settings::values.log_filter);
+    Log::SetGlobalFilter(log_filter);
+
+    const std::string& log_dir = FileUtil::GetUserPath(FileUtil::UserPath::LogDir);
+    FileUtil::CreateFullPath(log_dir);
+    Log::AddBackend(std::make_unique<Log::FileBackend>(log_dir + LOG_FILE));
+    Log::AddBackend(std::make_unique<Log::LogcatBackend>());
 }
 };
 }; // namespace MainActivity

src/android/app/src/main/java/org/citra_emu/citra/LOG.java

@@ -0,0 +1,41 @@
+package org.citra_emu.citra;
+
+public class LOG {
+
+    private interface LOG_LEVEL {
+        int TRACE = 0, DEBUG = 1, INFO = 2, WARNING = 3, ERROR = 4, CRITICAL = 5;
+    }
+
+    public static void TRACE(String msg, Object... args) {
+        LOG(LOG_LEVEL.TRACE, msg, args);
+    }
+
+    public static void DEBUG(String msg, Object... args) {
+        LOG(LOG_LEVEL.DEBUG, msg, args);
+    }
+
+    public static void INFO(String msg, Object... args) {
+        LOG(LOG_LEVEL.INFO, msg, args);
+    }
+
+    public static void WARNING(String msg, Object... args) {
+        LOG(LOG_LEVEL.WARNING, msg, args);
+    }
+
+    public static void ERROR(String msg, Object... args) {
+        LOG(LOG_LEVEL.ERROR, msg, args);
+    }
+
+    public static void CRITICAL(String msg, Object... args) {
+        LOG(LOG_LEVEL.CRITICAL, msg, args);
+    }
+
+    private static void LOG(int level, String msg, Object... args) {
+        StackTraceElement trace = Thread.currentThread().getStackTrace()[4];
+        logEntry(level, trace.getFileName(), trace.getLineNumber(), trace.getMethodName(),
+                 String.format(msg, args));
+    }
+
+    private static native void logEntry(int level, String file_name, int line_number,
+                                        String function, String message);
+}

src/android/app/src/main/java/org/citra_emu/citra/ui/main/MainActivity.java

@@ -18,7 +18,7 @@ import org.citra_emu.citra.utils.PermissionUtil;
 public final class MainActivity extends AppCompatActivity {
 
     // Java enums suck
-    private interface PermissionCodes { int INIT_USER_PATH = 0; }
+    private interface PermissionCodes { int INITIALIZE = 0; }
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -26,16 +26,17 @@ public final class MainActivity extends AppCompatActivity {
         setContentView(R.layout.activity_main);
 
         PermissionUtil.verifyPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE,
-                                        PermissionCodes.INIT_USER_PATH);
+                                        PermissionCodes.INITIALIZE);
     }
 
     @Override
     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                            @NonNull int[] grantResults) {
         switch (requestCode) {
-        case PermissionCodes.INIT_USER_PATH:
+        case PermissionCodes.INITIALIZE:
             if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                 initUserPath(FileUtil.getUserPath().toString());
+                initLogging();
             } else {
                 AlertDialog.Builder dialog =
                     new AlertDialog.Builder(this)
@@ -45,7 +46,7 @@ public final class MainActivity extends AppCompatActivity {
                         .setPositiveButton("OK", (dialogInterface, which) -> {
                             PermissionUtil.verifyPermission(
                                 MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE,
-                                PermissionCodes.INIT_USER_PATH);
+                                PermissionCodes.INITIALIZE);
                         });
                 dialog.show();
             }
@@ -53,4 +54,5 @@ public final class MainActivity extends AppCompatActivity {
     }
 
     private static native void initUserPath(String path);
+    private static native void initLogging();
 }