diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4618401
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,17 @@
+*.iml
+.gradle
+/local.properties
+/.idea/caches
+/.idea/libraries
+/.idea/modules.xml
+/.idea/workspace.xml
+/.idea/navEditor.xml
+/.idea/assetWizardSettings.xml
+.DS_Store
+/app/build
+/build
+/captures
+.externalNativeBuild
+.cxx
+local.properties
+/.idea
diff --git a/app/.gitignore b/app/.gitignore
new file mode 100644
index 0000000..42afabf
--- /dev/null
+++ b/app/.gitignore
@@ -0,0 +1 @@
+/build
\ No newline at end of file
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
new file mode 100644
index 0000000..7a3eb61
--- /dev/null
+++ b/app/build.gradle.kts
@@ -0,0 +1,53 @@
+plugins {
+ alias(libs.plugins.android.application)
+}
+
+android {
+ namespace = "com.example.usbtest"
+ compileSdk = 34
+
+ defaultConfig {
+ applicationId = "com.example.usbtest"
+ minSdk = 24
+ targetSdk = 34
+ versionCode = 1
+ versionName = "1.0"
+
+ testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+ externalNativeBuild {
+ cmake {
+ cppFlags += "-std=c++17"
+ }
+ }
+ }
+
+ buildTypes {
+ release {
+ isMinifyEnabled = false
+ proguardFiles(
+ getDefaultProguardFile("proguard-android-optimize.txt"),
+ "proguard-rules.pro"
+ )
+ }
+ }
+
+ externalNativeBuild {
+ cmake {
+ path = file("src/main/cpp/CMakeLists.txt")
+ version = "3.22.1"
+ }
+ }
+ buildFeatures {
+ viewBinding = true
+ }
+}
+
+/*dependencies {
+
+ implementation(libs.appcompat)
+ implementation(libs.material)
+ implementation(libs.constraintlayout)
+ testImplementation(libs.junit)
+ androidTestImplementation(libs.ext.junit)
+ androidTestImplementation(libs.espresso.core)
+}*/
\ No newline at end of file
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
new file mode 100644
index 0000000..481bb43
--- /dev/null
+++ b/app/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..94b41a8
--- /dev/null
+++ b/app/src/main/AndroidManifest.xml
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/app/src/main/cpp/AppLog.h b/app/src/main/cpp/AppLog.h
new file mode 100644
index 0000000..3ef845b
--- /dev/null
+++ b/app/src/main/cpp/AppLog.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include
+
+#ifndef LOGI
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "native-activity", __VA_ARGS__))
+#endif
diff --git a/app/src/main/cpp/CMakeLists.txt b/app/src/main/cpp/CMakeLists.txt
new file mode 100644
index 0000000..e6b9534
--- /dev/null
+++ b/app/src/main/cpp/CMakeLists.txt
@@ -0,0 +1,35 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project("native-activity")
+
+add_library(native_app_glue INTERFACE)
+
+
+
+add_library(${CMAKE_PROJECT_NAME} SHARED)
+
+target_sources(native-activity
+PRIVATE
+ native-lib.cpp
+ JniContext.h
+ AppLog.h
+ JActivityThread.h
+ JBindings.h
+ JCollection.h
+ JContext.h
+ JHashMap.h
+ JIntent.h
+ JIterator.h
+ JObject.h
+ JPackageManager.h
+ JUsbManager.h
+ ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c
+)
+
+target_include_directories(${CMAKE_PROJECT_NAME} PRIVATE
+ ${ANDROID_NDK}/sources/android/native_app_glue)
+
+target_link_libraries(${CMAKE_PROJECT_NAME}
+ android
+ log
+ native_app_glue)
diff --git a/app/src/main/cpp/JActivityThread.h b/app/src/main/cpp/JActivityThread.h
new file mode 100644
index 0000000..9ac2639
--- /dev/null
+++ b/app/src/main/cpp/JActivityThread.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "JContext.h"
+
+class JActivityThreadBindings : public JBindings {
+public:
+ JActivityThreadBindings() : JBindings("android/app/ActivityThread") {
+ auto env = JniContext::getJniEnv();
+ _static_currentActivityThread = env->GetStaticMethodID(_class, "currentActivityThread", "()Landroid/app/ActivityThread;");
+ _instance_getApplication = env->GetMethodID(_class, "getApplication", "()Landroid/app/Application;");
+ }
+
+ jobject currentActivityThread() {
+ return JniContext::getJniEnv()->CallStaticObjectMethod(_class, _static_currentActivityThread);
+ }
+
+ jobject getApplication(jobject activityThreadObject) {
+ return JniContext::getJniEnv()->CallObjectMethod(activityThreadObject, _instance_getApplication);
+ }
+
+private:
+ jmethodID _static_currentActivityThread;
+ jmethodID _instance_getApplication;
+};
+
+class JActivityThread : public JObject {
+public:
+ JActivityThread(jobject instance) : JObject(instance) {
+
+ }
+ static JActivityThread currentActivityThread() {
+ return JActivityThread(localToGlobalRef(bindings().currentActivityThread()));
+ }
+ JContext getApplication() {
+ return JContext(localToGlobalRef(bindings().getApplication(_instance)));
+ }
+private:
+ static JActivityThreadBindings& bindings() {
+ static thread_local JActivityThreadBindings b;
+ return b;
+ }
+};
\ No newline at end of file
diff --git a/app/src/main/cpp/JBindings.h b/app/src/main/cpp/JBindings.h
new file mode 100644
index 0000000..9341977
--- /dev/null
+++ b/app/src/main/cpp/JBindings.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "JniContext.h"
+#include
+
+class JBindings {
+protected:
+ JBindings(const char* className) {
+ JNIEnv* env = JniContext::getJniEnv();
+ _class = findClass(env, className);
+ }
+
+ std::optional getStaticFieldID(const char* name, const char* signature) {
+ try{
+ auto result = JniContext::getJniEnv()->GetStaticFieldID(_class, name, signature);
+ JniContext::checkException();
+ return result;
+ }catch(...){
+ return std::nullopt;
+ }
+ }
+ //
+
+ static jclass findClass(JNIEnv* env, const char* className) {
+ auto classLocalRef = env->FindClass(className);
+ if(classLocalRef == nullptr){
+ return nullptr;
+ }
+ auto globalRef = (jclass)env->NewGlobalRef(classLocalRef);
+ env->DeleteLocalRef(classLocalRef);
+ return globalRef;
+ }
+
+ jclass _class;
+};
\ No newline at end of file
diff --git a/app/src/main/cpp/JCollection.h b/app/src/main/cpp/JCollection.h
new file mode 100644
index 0000000..982b17c
--- /dev/null
+++ b/app/src/main/cpp/JCollection.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include "JIterator.h"
+
+class JCollectionBindings : public JBindings {
+public:
+ JCollectionBindings() : JBindings("java/util/Collection") {
+ auto env = JniContext::getJniEnv();
+ _instance_iterator = env->GetMethodID(_class, "iterator", "()Ljava/util/Iterator;");
+ }
+
+ jobject iterator(jobject _this) {
+ return JniContext::getJniEnv()->CallObjectMethod(_this, _instance_iterator);
+ }
+
+private:
+ jmethodID _instance_iterator;
+};
+
+class JCollection : public JObject {
+public:
+ JCollection(jobject instance) : JObject(instance) {
+
+ }
+ JIterator iterator() {
+ return JIterator(localToGlobalRef(bindings().iterator(_instance)));
+ }
+private:
+ static JCollectionBindings& bindings() {
+ static thread_local JCollectionBindings b;
+ return b;
+ }
+};
diff --git a/app/src/main/cpp/JContext.h b/app/src/main/cpp/JContext.h
new file mode 100644
index 0000000..341c058
--- /dev/null
+++ b/app/src/main/cpp/JContext.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "JPackageManager.h"
+
+class JContextBindings : public JBindings {
+public:
+ JContextBindings() : JBindings("android/content/Context") {
+ auto env = JniContext::getJniEnv();
+ _static_field_USB_SERVICE = env->GetStaticFieldID(_class, "USB_SERVICE", "Ljava/lang/String;");
+ _instance_getPackageManager = env->GetMethodID(_class, "getPackageManager","()Landroid/content/pm/PackageManager;");
+ _instance_getSystemService = env->GetMethodID(_class, "getSystemService","(Ljava/lang/String;)Ljava/lang/Object;");
+ }
+
+ jobject get_USB_SERVICE() {
+ return JniContext::getJniEnv()->GetStaticObjectField(_class, _static_field_USB_SERVICE);
+ }
+
+ jobject getPackageManager(jobject context) {
+ return JniContext::getJniEnv()->CallObjectMethod(context, _instance_getPackageManager);
+ }
+
+ jobject getSystemService(jobject context, jobject name) {
+ return JniContext::getJniEnv()->CallObjectMethod(context, _instance_getSystemService, name);
+ }
+
+private:
+ jfieldID _static_field_USB_SERVICE;
+ jmethodID _instance_getPackageManager;
+ jmethodID _instance_getSystemService;
+};
+
+class JContext : public JObject {
+public:
+ JContext(jobject instance) : JObject(instance) {
+
+ }
+ static jobject get_USB_SERVICE() {
+ return localToGlobalRef(bindings().get_USB_SERVICE());
+ }
+ JPackageManager getPackageManager() {
+ return JPackageManager(localToGlobalRef(bindings().getPackageManager(_instance)));
+ }
+ jobject getSystemService(jobject usbService) {
+ return localToGlobalRef(bindings().getSystemService(_instance, usbService));
+ }
+private:
+ static JContextBindings& bindings() {
+ static thread_local JContextBindings b;
+ return b;
+ }
+};
\ No newline at end of file
diff --git a/app/src/main/cpp/JHashMap.h b/app/src/main/cpp/JHashMap.h
new file mode 100644
index 0000000..78b3a54
--- /dev/null
+++ b/app/src/main/cpp/JHashMap.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "JCollection.h"
+
+class JHashMapBindings : public JBindings {
+public:
+ JHashMapBindings() : JBindings("java/util/HashMap") {
+ auto env = JniContext::getJniEnv();
+ _instance_values = env->GetMethodID(_class, "values", "()Ljava/util/Collection;");
+ _instance_keySet = env->GetMethodID(_class, "keySet", "()Ljava/util/Set;");
+ }
+ jobject values(jobject _this) {
+ return JniContext::getJniEnv()->CallObjectMethod(_this, _instance_values);
+ }
+ jobject keySet(jobject _this) {
+ return JniContext::getJniEnv()->CallObjectMethod(_this, _instance_keySet);
+ }
+private:
+ jmethodID _instance_values;
+ jmethodID _instance_keySet;
+};
+
+class JHashMap : public JObject {
+public:
+ JHashMap(jobject instance) : JObject(instance) {
+
+ }
+ JCollection values() { //Collection
+ return JCollection(localToGlobalRef(bindings().values(_instance)));
+ }
+
+ JCollection keySet() { //Set
+ return JCollection(localToGlobalRef(bindings().keySet(_instance)));
+ }
+private:
+ static JHashMapBindings& bindings() {
+ static thread_local JHashMapBindings b;
+ return b;
+ }
+};
\ No newline at end of file
diff --git a/app/src/main/cpp/JIntent.h b/app/src/main/cpp/JIntent.h
new file mode 100644
index 0000000..9f0e6cb
--- /dev/null
+++ b/app/src/main/cpp/JIntent.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "JBindings.h"
+
+class JIntentBindings : public JBindings {
+public:
+ JIntentBindings() : JBindings("android/content/Intent") {
+ auto env = JniContext::getJniEnv();
+ _instance_init = env->GetMethodID(_class, "", "(Ljava/lang/String;)V");
+ }
+
+ jobject construct(jobject permissionAction) {
+ return JniContext::getJniEnv()->NewObject(_class, _instance_init, permissionAction);
+ }
+
+private:
+ jmethodID _instance_init;
+};
+
+
+
diff --git a/app/src/main/cpp/JIterator.h b/app/src/main/cpp/JIterator.h
new file mode 100644
index 0000000..3d98d1b
--- /dev/null
+++ b/app/src/main/cpp/JIterator.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "JObject.h"
+#include "JBindings.h"
+
+class JIteratorBindings : public JBindings {
+public:
+ JIteratorBindings() : JBindings("java/util/Iterator") {
+ auto env = JniContext::getJniEnv();
+ _instance_hasNext = env->GetMethodID(_class, "hasNext", "()Z");
+ _instance_next = env->GetMethodID(_class, "next", "()Ljava/lang/Object;");
+ }
+
+ jboolean hasNext(jobject _this) {
+ return JniContext::getJniEnv()->CallBooleanMethod(_this, _instance_hasNext);
+ }
+ jobject next(jobject _this) {
+ return JniContext::getJniEnv()->CallObjectMethod(_this, _instance_next);
+ }
+
+private:
+ jmethodID _instance_hasNext;
+ jmethodID _instance_next;
+};
+class JIterator : public JObject {
+public:
+ JIterator(jobject instance) : JObject(instance) {
+
+ }
+ jboolean hasNext() {
+ return bindings().hasNext(_instance);
+ }
+ jobject next() {
+ return localToGlobalRef(bindings().next(_instance));
+ }
+private:
+ static JIteratorBindings& bindings() {
+ static thread_local JIteratorBindings b;
+ return b;
+ }
+};
diff --git a/app/src/main/cpp/JObject.h b/app/src/main/cpp/JObject.h
new file mode 100644
index 0000000..b635b6e
--- /dev/null
+++ b/app/src/main/cpp/JObject.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "JniContext.h"
+
+class JObject {
+public:
+ JObject(jobject instance) {
+ _instance = instance;
+ }
+ JObject(const JObject&) = delete;
+ //JObject(const JObject&& src) {
+
+ //}
+ jobject toNativeObject() {
+ return _instance;
+ }
+ ~JObject() {
+ release();
+ }
+protected:
+ static jobject localToGlobalRef(jobject obj){
+ auto result = JniContext::getJniEnv()->NewGlobalRef(obj);
+ JniContext::getJniEnv()->DeleteLocalRef(obj);
+ return result;
+ }
+ jobject _instance = nullptr;
+ void release() {
+ if(_instance != nullptr){
+ JniContext::getJniEnv()->DeleteGlobalRef(_instance);
+ }
+ }
+};
\ No newline at end of file
diff --git a/app/src/main/cpp/JPackageManager.h b/app/src/main/cpp/JPackageManager.h
new file mode 100644
index 0000000..c8c2786
--- /dev/null
+++ b/app/src/main/cpp/JPackageManager.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "JBindings.h"
+#include "JObject.h"
+
+class JPackageManagerBindings : public JBindings {
+public:
+ JPackageManagerBindings() : JBindings("android/content/pm/PackageManager") {
+ auto env = JniContext::getJniEnv();
+ _static_field_FEATURE_USB_HOST = env->GetStaticFieldID(_class, "FEATURE_USB_HOST", "Ljava/lang/String;");
+ _instance_hasSystemFeature = env->GetMethodID(_class, "hasSystemFeature","(Ljava/lang/String;)Z");
+ }
+
+ jobject get_FEATURE_USB_HOST() {
+ return JniContext::getJniEnv()->GetStaticObjectField(_class, _static_field_FEATURE_USB_HOST);
+ }
+
+ jboolean hasSystemFeature(jobject packageManager, jobject name) {
+ return JniContext::getJniEnv()->CallBooleanMethod(packageManager, _instance_hasSystemFeature, name);
+ }
+
+private:
+ jfieldID _static_field_FEATURE_USB_HOST;
+ jmethodID _instance_hasSystemFeature;
+};
+
+class JPackageManager : public JObject {
+public:
+ JPackageManager(jobject instance) : JObject(instance) {
+
+ }
+ static jobject get_FEATURE_USB_HOST() {
+ return localToGlobalRef(bindings().get_FEATURE_USB_HOST());
+ }
+ jboolean hasSystemFeature(jobject name) {
+ return bindings().hasSystemFeature(_instance, name);
+ }
+private:
+ static JPackageManagerBindings& bindings() {
+ static thread_local JPackageManagerBindings b;
+ return b;
+ }
+};
diff --git a/app/src/main/cpp/JPendingIntent.h b/app/src/main/cpp/JPendingIntent.h
new file mode 100644
index 0000000..be4494d
--- /dev/null
+++ b/app/src/main/cpp/JPendingIntent.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include "JBindings.h"
+#include "JObject.h"
+#include "JContext.h"
+#include "JIntent.h"
+#include
+
+class JPendingIntentBindings : public JBindings {
+public:
+ JPendingIntentBindings() : JBindings("android/app/PendingIntent") {
+ auto env = JniContext::getJniEnv();
+ _static_getBroadcast = env->GetStaticMethodID(_class, "getBroadcast", "(Landroid/content/Context;ILandroid/content/Intent;I)Landroid/app/PendingIntent;");
+
+ _static_field_FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT = getStaticFieldID("FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT", "I");
+ _static_field_FLAG_CANCEL_CURRENT = getStaticFieldID("FLAG_CANCEL_CURRENT", "I");
+ _static_field_FLAG_IMMUTABLE = getStaticFieldID("FLAG_IMMUTABLE", "I");
+ _static_field_FLAG_MUTABLE = getStaticFieldID("FLAG_MUTABLE", "I");
+ _static_field_FLAG_NO_CREATE = getStaticFieldID("FLAG_NO_CREATE", "I");
+ _static_field_FLAG_ONE_SHOT = getStaticFieldID("FLAG_ONE_SHOT", "I");
+ _static_field_FLAG_UPDATE_CURRENT = getStaticFieldID("FLAG_UPDATE_CURRENT", "I");
+ }
+
+ jobject getBroadcast(jobject context, jint requestCode, jobject intent, jint flags) { //getBroadcast(Context, int, Intent, int)
+ jobject result = JniContext::getJniEnv()->CallStaticObjectMethod(_class, _static_getBroadcast, context, requestCode, intent, flags);
+ JniContext::checkException();
+ return result;
+ }
+
+ jint get_FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT() {
+ jint result = JniContext::getJniEnv()->GetStaticIntField(_class, _static_field_FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT.value());
+ return result;
+ }
+ jint get_FLAG_CANCEL_CURRENT() {
+ jint result = JniContext::getJniEnv()->GetStaticIntField(_class, _static_field_FLAG_CANCEL_CURRENT.value());
+ return result;
+ }
+ jint get_FLAG_IMMUTABLE() {
+ jint result = JniContext::getJniEnv()->GetStaticIntField(_class, _static_field_FLAG_IMMUTABLE.value());
+ return result;
+ }
+ jint get_FLAG_MUTABLE() {
+ jint result = JniContext::getJniEnv()->GetStaticIntField(_class, _static_field_FLAG_MUTABLE.value());
+ return result;
+ }
+ jint get_FLAG_NO_CREATE() {
+ jint result = JniContext::getJniEnv()->GetStaticIntField(_class, _static_field_FLAG_NO_CREATE.value());
+ return result;
+ }
+ jint get_FLAG_ONE_SHOT() {
+ jint result = JniContext::getJniEnv()->GetStaticIntField(_class, _static_field_FLAG_ONE_SHOT.value());
+ return result;
+ }
+ jint get_FLAG_UPDATE_CURRENT() {
+ jint result = JniContext::getJniEnv()->GetStaticIntField(_class, _static_field_FLAG_UPDATE_CURRENT.value());
+ return result;
+ }
+private:
+ jmethodID _static_getBroadcast;
+
+ std::optional _static_field_FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT;
+ std::optional _static_field_FLAG_CANCEL_CURRENT;
+ std::optional _static_field_FLAG_IMMUTABLE;
+ std::optional _static_field_FLAG_MUTABLE;
+ std::optional _static_field_FLAG_NO_CREATE;
+ std::optional _static_field_FLAG_ONE_SHOT;
+ std::optional _static_field_FLAG_UPDATE_CURRENT;
+};
+
+class JPendingIntent : public JObject {
+public:
+ JPendingIntent(jobject instance) : JObject(instance) {
+
+ }
+ static JPendingIntent getBroadcast(JContext& context, jint requestCode, jobject intent, jint flags) {
+ return JPendingIntent(localToGlobalRef(bindings().getBroadcast(context.toNativeObject(), requestCode, intent, flags)));
+ }
+
+ static jint get_FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT() { return bindings().get_FLAG_ALLOW_UNSAFE_IMPLICIT_INTENT(); }
+ static jint get_FLAG_CANCEL_CURRENT() { return bindings().get_FLAG_CANCEL_CURRENT(); }
+ static jint get_FLAG_IMMUTABLE() { return bindings().get_FLAG_IMMUTABLE(); }
+ static jint get_FLAG_MUTABLE() { return bindings().get_FLAG_MUTABLE(); }
+ static jint get_FLAG_NO_CREATE() { return bindings().get_FLAG_NO_CREATE(); }
+ static jint get_FLAG_ONE_SHOT() { return bindings().get_FLAG_ONE_SHOT(); }
+ static jint get_FLAG_UPDATE_CURRENT() { return bindings().get_FLAG_UPDATE_CURRENT(); }
+private:
+ static JPendingIntentBindings& bindings() {
+ static thread_local JPendingIntentBindings b;
+ return b;
+ }
+};
diff --git a/app/src/main/cpp/JUsbManager.h b/app/src/main/cpp/JUsbManager.h
new file mode 100644
index 0000000..80482e4
--- /dev/null
+++ b/app/src/main/cpp/JUsbManager.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "JHashMap.h"
+#include "JPendingIntent.h"
+
+class JUsbManagerBindings : public JBindings {
+public:
+ JUsbManagerBindings() : JBindings("android/hardware/usb/UsbManager") {
+ auto env = JniContext::getJniEnv();
+ _instance_getDeviceList = env->GetMethodID(_class, "getDeviceList", "()Ljava/util/HashMap;");
+ _instance_hasPermission = env->GetMethodID(_class, "hasPermission", "(Landroid/hardware/usb/UsbDevice;)Z");
+ _instance_openDevice = env->GetMethodID(_class, "openDevice", "(Landroid/hardware/usb/UsbDevice;)Landroid/hardware/usb/UsbDeviceConnection;");
+ _instance_requestPermission = env->GetMethodID(_class, "requestPermission", "(Landroid/hardware/usb/UsbDevice;Landroid/app/PendingIntent;)V");
+ }
+
+ jobject getDeviceList(jobject _this) { //HashMap
+ return JniContext::getJniEnv()->CallObjectMethod(_this, _instance_getDeviceList);
+ }
+ jboolean hasPermission(jobject _this, jobject device) {
+ return JniContext::getJniEnv()->CallBooleanMethod(_this, _instance_hasPermission, device);
+ }
+ jobject openDevice(jobject _this, jobject device) { //UsbDeviceConnection connection = usbManager.openDevice(device);
+ return JniContext::getJniEnv()->CallObjectMethod(_this, _instance_openDevice, device);
+ }
+ void requestPermission(jobject _this, jobject device, jobject permissionIntent) {
+ return JniContext::getJniEnv()->CallVoidMethod(_this, _instance_requestPermission, device, permissionIntent);
+ }
+private:
+ jmethodID _instance_getDeviceList;
+ jmethodID _instance_hasPermission;
+ jmethodID _instance_openDevice;
+ jmethodID _instance_requestPermission;
+};
+
+class JUsbManager : public JObject {
+public:
+ JUsbManager(jobject instance) : JObject(instance) {
+
+ }
+ JHashMap getDeviceList() {
+ return JHashMap(localToGlobalRef(bindings().getDeviceList(_instance)));
+ }
+ jboolean hasPermission(jobject device) {
+ return bindings().hasPermission(_instance, device);
+ }
+ jobject openDevice(jobject device) {
+ return localToGlobalRef(bindings().openDevice(_instance, device));
+ }
+ void requestPermission(jobject device, JPendingIntent& permissionIntent) {
+ bindings().requestPermission(_instance, device, permissionIntent.toNativeObject());
+ }
+private:
+ static JUsbManagerBindings& bindings() {
+ static thread_local JUsbManagerBindings b;
+ return b;
+ }
+};
\ No newline at end of file
diff --git a/app/src/main/cpp/JniContext.h b/app/src/main/cpp/JniContext.h
new file mode 100644
index 0000000..90f66c7
--- /dev/null
+++ b/app/src/main/cpp/JniContext.h
@@ -0,0 +1,70 @@
+#pragma once
+#include
+#include "AppLog.h"
+
+class JniContext {
+public:
+ static void setJavaVM(JavaVM* vm){
+ auto& i = instance();
+ i._vm = vm;
+ }
+
+ static JavaVM* getJavaVM(){
+ auto& i = instance();
+ return i._vm;
+ }
+
+ static void checkException() {
+ auto env = getJniEnv();
+ if(env->ExceptionCheck()){
+ env->ExceptionDescribe(); // print the stack trace
+ env->ExceptionClear();
+ throw std::runtime_error("");
+ }
+ }
+
+
+ static JNIEnv* getJniEnv() {
+ auto& i = instance();
+ if(i._vm == nullptr){
+ return nullptr;
+ }
+
+ if(i._env == nullptr){
+ LOGI("getJniEnv: query Jni Env for thread");
+ int status = i._vm->GetEnv( (void**)&i._env, JNI_VERSION_1_1);
+ if (status == JNI_EDETACHED) {
+ LOGI("getJniEnv: thread Detached! Attaching...");
+ JavaVMAttachArgs thr_args = {
+ .version = JNI_VERSION_1_6,
+ .name = NULL,
+ .group = NULL
+ };
+ status = i._vm->AttachCurrentThread(&i._env, &thr_args);
+ if(status != JNI_OK){
+ LOGI("getJniEnv: thread failed to attach");
+ return nullptr;
+ }
+ LOGI("getJniEnv: thread attached successfully");
+ }else{
+ LOGI("getJniEnv: Something went wrong!!!!!");
+ }
+ }
+
+ return i._env;
+ }
+ ~JniContext() {
+ if(_env != nullptr){
+ LOGI("getJniEnv: detaching current thread...");
+ _vm->DetachCurrentThread();
+ }
+ }
+private:
+ JniContext() = default;
+ static JniContext& instance() {
+ static thread_local JniContext context;
+ return context;
+ }
+ JavaVM* _vm = nullptr;
+ JNIEnv* _env = nullptr;
+};
\ No newline at end of file
diff --git a/app/src/main/cpp/native-lib.cpp b/app/src/main/cpp/native-lib.cpp
new file mode 100644
index 0000000..a6cae47
--- /dev/null
+++ b/app/src/main/cpp/native-lib.cpp
@@ -0,0 +1,79 @@
+#include
+#include
+#include
+#include "AppLog.h"
+#include "JniContext.h"
+#include
+
+#include "JUsbManager.h"
+#include "JIntent.h"
+#include "JActivityThread.h"
+#include "JPendingIntent.h"
+
+#include
+#include
+
+void requestPermission(JContext& context, JUsbManager& usbManager, jobject usbDevice, jobject permissionAction){
+ JIntentBindings b;
+ jobject intent = b.construct(permissionAction);
+ jobject intentRef = JniContext::getJniEnv()->NewGlobalRef(intent);
+ auto permissionIntent = JPendingIntent::getBroadcast(context, 0, intentRef, JPendingIntent::get_FLAG_IMMUTABLE());
+ usbManager.requestPermission(usbDevice, permissionIntent);
+ JniContext::getJniEnv()->DeleteGlobalRef(intentRef);
+}
+
+void android_main(android_app* state) {
+ JniContext::setJavaVM(state->activity->vm);
+
+ auto activityThread = JActivityThread::currentActivityThread();
+ auto application = activityThread.getApplication();
+ auto usbServiceName = application.get_USB_SERVICE();
+ JUsbManager usbManager(application.getSystemService(usbServiceName));
+
+
+ auto packageManager = application.getPackageManager();
+
+ auto featureUsbHost = packageManager.get_FEATURE_USB_HOST();
+ auto hasUsbHost = packageManager.hasSystemFeature(featureUsbHost);
+
+
+
+ jint flagImmutable = JPendingIntent::get_FLAG_IMMUTABLE();
+ LOGI("!!!!Flag immutable: %i", flagImmutable);
+
+
+ jobject permissionActionNameLocal = JniContext::getJniEnv()->NewStringUTF("android.app.USB_PERMISSION");
+ jobject permissionActionName = JniContext::getJniEnv()->NewGlobalRef(permissionActionNameLocal);
+ //JniContext::getJniEnv()->DeleteLocalRef(permissionActionNameLocal);
+
+
+ while(true){
+ LOGI("Enumerating USB devices...");
+ auto usbDeviceHashMap = usbManager.getDeviceList(); //HashMap
+ auto usbDeviceList = usbDeviceHashMap.values();
+ auto usbDeviceIterator = usbDeviceList.iterator();
+
+ int deviceId = 0;
+
+ while(usbDeviceIterator.hasNext()){
+ auto device = usbDeviceIterator.next();
+ auto hasPermission = usbManager.hasPermission(device);
+ LOGI("Found USB device: %i, has permission: %s", deviceId, (hasPermission ? "yes" : "no"));
+
+ if(!hasPermission){
+ LOGI("Requesting permission for device %i", deviceId);
+ requestPermission(application, usbManager, device, permissionActionName);
+ }
+ JniContext::getJniEnv()->DeleteGlobalRef(device);
+
+ deviceId++;
+ }
+ std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+ }
+
+
+
+
+
+ LOGI("App exiting...");
+}
\ No newline at end of file
diff --git a/app/src/main/res/drawable/ic_launcher_background.xml b/app/src/main/res/drawable/ic_launcher_background.xml
new file mode 100644
index 0000000..07d5da9
--- /dev/null
+++ b/app/src/main/res/drawable/ic_launcher_background.xml
@@ -0,0 +1,170 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/app/src/main/res/drawable/ic_launcher_foreground.xml b/app/src/main/res/drawable/ic_launcher_foreground.xml
new file mode 100644
index 0000000..2b068d1
--- /dev/null
+++ b/app/src/main/res/drawable/ic_launcher_foreground.xml
@@ -0,0 +1,30 @@
+
+
+
+
+