实现GPIO的访问

app/src/main/cpp/GPIOControl.cpp

@@ -15,142 +15,116 @@
 
 #include "GPIOControl.h"
 
-#define GPIO_DIRECTION_IN              0
-#define GPIO_DIRECTION_OUT             1
-#define GPIO_VALUE_LOW             0
-#define GPIO_VALUE_HIGH            1
 
-#define BUFFER_MAX    3
-#define DIRECTION_MAX 48
+#define IOT_PARAM_WRITE 0xAE
+#define IOT_PARAM_READ 0xAF
+#define MAX_STRING_LEN 32
 
-int GpioControl::exp(int gpio)
+typedef struct
 {
-    char buffer[BUFFER_MAX];
-    int len;
-    int fd;
-
-    fd = open("/sys/class/gpio/export", O_WRONLY);
-    if (fd < 0)
-    {
-        // LOGE("Failed to open export for writing!\n");
-        return(0);
-    }
-
-    len = snprintf(buffer, BUFFER_MAX, "%d", gpio);
-    if (write(fd, buffer, len) < 0)
+    int cmd;
+    int value;
+    int result;
+    long value2;
+    char str[MAX_STRING_LEN];
+}IOT_PARAM;
+
+void GpioControl::setInt(int cmd, int value)
+{
+    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
+    IOT_PARAM param;
+    param.cmd = cmd;
+    param.value = value;
+    // LOGE("set_int fd=%d,cmd=%d,value=%d\r\n",fd, cmd, value);
+    if( fd > 0 )
     {
-        // LOGE("Fail to export gpio!\n");
-        return 0;
+        int res = ioctl(fd, IOT_PARAM_WRITE, &param);
+        // LOGE("set_int22 cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
+        close(fd);
     }
-
-    close(fd);
-    return 1;
+    return;
 }
 
-int GpioControl::setDirection(int gpio, int direction)
+int GpioControl::getInt(int cmd)
 {
-    static const char dir_str[]  = "in\0out";
-    char path[DIRECTION_MAX];
-    int fd;
-
-    snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/direction", gpio);
-    fd = open(path, O_WRONLY);
-    if (fd < 0)
-    {
-        // LOGE("failed to open gpio direction for writing!\n");
-        return 0;
-    }
-
-    if (write(fd, &dir_str[direction == GPIO_DIRECTION_IN ? 0 : 3], direction == GPIO_DIRECTION_IN ? 2 : 3) < 0)
+    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
+    // LOGE("get_int fd=%d,cmd=%d\r\n",fd, cmd);
+    if( fd > 0 )
     {
-        // LOGE("failed to set direction!\n");
-        return 0;
+        IOT_PARAM param;
+        param.cmd = cmd;
+        ioctl(fd, IOT_PARAM_READ, &param);
+        // LOGE("get_int22 cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
+        close(fd);
+        return param.value;
     }
-
-    close(fd);
-    return 1;
+    return -1;
 }
-int GpioControl::readStatus(int gpio)
-{
-    char path[DIRECTION_MAX];
-    char value_str[3];
-    int fd;
 
-    snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/value", gpio);
-    fd = open(path, O_RDONLY);
-    if (fd < 0)
-    {
-        // LOGE("failed to open gpio value for reading!\n");
-        return -1;
-    }
+void GpioControl::setLong(int cmd, long value)
+{
+    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
+    IOT_PARAM param;
+    param.cmd = cmd;
+    param.value2 = value;
+    // LOGE("set_long fd=%d,cmd=%d,value2=%ld\r\n",fd, param.cmd, param.value2);
 
-    if (read(fd, value_str, 3) < 0)
+    if( fd > 0 )
     {
-        // LOGE("failed to read value!\n");
-        return -1;
+        ioctl(fd, IOT_PARAM_WRITE, &param);
+        // LOGE("set_long22 cmd=%d,value2=%ld,result=%d\r\n",param.cmd, param.value2, param.result);
+        close(fd);
     }
-
-    close(fd);
-    return (atoi(value_str));
 }
 
-int GpioControl::writeStatus(int gpio, int value)
+long GpioControl::getLong(int cmd)
 {
-    static const char values_str[] = "01";
-    char path[DIRECTION_MAX];
-    int fd;
-
-    snprintf(path, DIRECTION_MAX, "/sys/class/gpio/gpio%d/value", gpio);
-    fd = open(path, O_WRONLY);
-    if (fd < 0)
-    {
-        // LOGE("failed to open gpio value for writing!\n");
-        return 0;
-    }
-
-    if (write(fd, &values_str[value == GPIO_VALUE_LOW ? 0 : 1], 1) < 0)
+    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
+    // LOGE("get_long fd=%d,cmd=%d\r\n",fd, cmd);
+    if( fd > 0 )
     {
-        // LOGE("failed to write value!\n");
-        return 0;
+        IOT_PARAM param;
+        param.cmd = cmd;
+        ioctl(fd, IOT_PARAM_READ, &param);
+        // LOGE("get_long22 cmd=%d,value2=%ld,result=%d\r\n",param.cmd, param.value2, param.result);
+        close(fd);
+        return param.value2;
     }
-
-    close(fd);
-    return 1;
+    return -1;
 }
 
-int GpioControl::unexp(int gpio)
+void GpioControl::setString(int cmd, const std::string& value)
 {
-    char buffer[BUFFER_MAX];
-    int len;
-    int fd;
-
-    fd = open("/sys/class/gpio/unexport", O_WRONLY);
-    if (fd < 0)
+    IOT_PARAM param;
+    // char *pval = jstringToChars(env, value);
+    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
+    int len = MAX_STRING_LEN < value.size() ? MAX_STRING_LEN : value.size();
+
+    param.cmd = cmd;
+    memset(param.str, 0, MAX_STRING_LEN);
+    memcpy(param.str, value.c_str(), len);
+    // LOGE("set_string fd=%d,cmd=%d,str=%s\r\n",fd, param.cmd, param.str);
+    if( fd > 0 )
     {
-        // LOGE("Failed to open unexport for writing!\n");
-        return 0;
+        ioctl(fd, IOT_PARAM_WRITE, &param);
+        // LOGE("set_string22 cmd=%d,str=%s,result=%d\r\n",param.cmd, param.str, param.result);
+        close(fd);
     }
-
-    len = snprintf(buffer, BUFFER_MAX, "%d", gpio);
-    if (write(fd, buffer, len) < 0)
-    {
-        // LOGE("Fail to unexport gpio!");
-        return 0;
-    }
-
-    close(fd);
-    return 1;
+    return;
 }
 
-bool GpioControl::EnableGpio(int gpio, bool en)
+std::string GpioControl::getString(int cmd)
 {
-    GpioControl gpioControl;
-    gpioControl.exp(gpio);
-    gpioControl.setDirection(gpio, GPIO_DIRECTION_OUT);
-
-    gpioControl.writeStatus(gpio, en ? GPIO_VALUE_HIGH : GPIO_VALUE_LOW);
-
-    gpioControl.unexp(gpio);
-
-    return true;
+    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
+    // LOGE("get_string fd=%d,cmd=%d\r\n",fd, cmd);
+    if( fd > 0 )
+    {
+        IOT_PARAM param;
+        param.cmd = cmd;
+        ioctl(fd, IOT_PARAM_READ, &param);
+        // LOGE("get_string22 cmd=%d,str=%s,result=%d\r\n",param.cmd, param.str, param.result);
+        close(fd);
+        return std::string(param.str);
+    }
+    return "";
 }

app/src/main/cpp/GPIOControl.h

@@ -5,17 +5,152 @@
 #ifndef MICROPHOTO_GPIOCONTROL_H
 #define MICROPHOTO_GPIOCONTROL_H
 
+#include <string>
+
+#define CMD_GET_LIGHT_ADC                       101
+#define CMD_SET_LIGHT_ADC                       102
+#define CMD_GET_KEY_LOCKSTATE                   103
+#define CMD_GET_BAT_ADC                         104
+#define CMD_SET_FLASH_LED                       105
+#define CMD_SET_NETWORK_STATE                   106
+#define CMD_SET_OTG_STATE                       107
+#define CMD_GET_OTG_STATE                       108
+#define CMD_GET_CHARGING_VOL_STATE              110
+#define CMD_GET_CHARGING_SHUNT_VOLTAGE_STATE    111
+#define CMD_GET_CHARGING_BUS_VOLTAGE_STATE      112
+#define CMD_GET_CHARGING_POWER_STATE            113
+#define CMD_GET_CHARGING_CURRENT_STATE          114
+#define CMD_GET_BAT_VOL_STATE                   115
+#define CMD_GET_BAT_SHUNT_VOLTAGE_STATE         116
+#define CMD_GET_BAT_BUS_VOLTAGE_STATE           117
+#define CMD_GET_BAT_POWER_STATE                 118
+#define CMD_GET_BAT_CURRENT_STATE               119
+#define CMD_SET_485_STATE                       121
+#define CMD_SET_SPI_MODE                        123
+#define CMD_SET_SPI_BITS_PER_WORD               124
+#define CMD_SET_SPI_MAXSPEEDHZ                  125
+#define CMD_SET_PWM_BEE_STATE                   126
+#define CMD_SET_ALM_MODE                        128
+#define CMD_SET_485_EN_STATE					131
+#define CMD_SET_CAM_3V3_EN_STATE				132
+#define CMD_SET_12V_EN_STATE					133
+#define CMD_SET_SYSTEM_RESET  		            202
 
 class GpioControl
 {
 public:
-    int exp(int gpio);
-    int setDirection(int gpio, int direction);
-    int readStatus(int gpio);
-    int writeStatus(int gpio, int value);
-    int unexp(int gpio);
 
-    static bool EnableGpio(int gpio, bool en);
+    static void setInt(int cmd, int value);
+    static int getInt(int cmd);
+    static void setLong(int cmd, long value);
+    static long getLong(int cmd);
+    static void setString(int cmd, const std::string& value);
+    static std::string getString(int cmd);
+
+    static void setOtgState(bool on)
+    {
+        setInt(CMD_SET_OTG_STATE, on ? 1 : 0);
+    }
+
+    static void setCam3V3Enable(bool enabled)
+    {
+        setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
+    }
+
+    static void reboot()
+    {
+        setInt(CMD_SET_SYSTEM_RESET, 1);
+    }
+
+    static void setLightAdc(int i)
+    {
+        setInt(CMD_SET_LIGHT_ADC, i);
+    }
+
+    static int getLightAdc()
+    {
+        return getInt(CMD_GET_LIGHT_ADC);
+    }
+
+    static int getChargingVoltage()
+    {
+        return getInt(CMD_GET_CHARGING_VOL_STATE);
+    }
+
+    static int getChargingShuntVoltage()
+    {
+        return getInt(CMD_GET_CHARGING_SHUNT_VOLTAGE_STATE);
+    }
+
+    static int getChargingBusVoltage() {
+        return getInt(CMD_GET_CHARGING_BUS_VOLTAGE_STATE);
+    }
+
+    static int getChargingPower() {
+        return getInt(CMD_GET_CHARGING_POWER_STATE);
+    }
+
+    static int getChargingCurrent() {
+        return getInt(CMD_GET_CHARGING_CURRENT_STATE);
+    }
+
+    static int getBatteryVoltage() {
+        return getInt(CMD_GET_BAT_VOL_STATE);
+    }
+
+    static int getBatteryShuntVoltage() {
+        return getInt(CMD_GET_BAT_SHUNT_VOLTAGE_STATE);
+    }
+
+    static int getBatteryBusVoltage() {
+        return getInt(CMD_GET_BAT_BUS_VOLTAGE_STATE);
+    }
+
+    static int getBatteryPower() {
+        return getInt(CMD_GET_BAT_POWER_STATE);
+    }
+
+    static int getBatteryCurrent() {
+        return getInt(CMD_GET_BAT_CURRENT_STATE);
+    }
+
+    static void set485WriteMode() {
+        setInt(CMD_SET_485_STATE, 1);
+    }
+
+    static void set485ReadMode() {
+        setInt(CMD_SET_485_STATE, 0);
+    }
+
+    static void setSpiMode(int i) {
+        setInt(CMD_SET_SPI_MODE, i);
+    }
+
+    static void setSpiBitsPerWord(int i) {
+        setInt(CMD_SET_SPI_BITS_PER_WORD, i);
+    }
+
+    static void setSpiMaxSpeedHz(long j) {
+        setLong(CMD_SET_SPI_MAXSPEEDHZ, j);
+    }
+
+    static void setBeeOn(bool z) {
+        setInt(CMD_SET_PWM_BEE_STATE, z ? 1 : 0);
+    }
+
+    static void setJidianqiState(bool z) {
+        setInt(CMD_SET_ALM_MODE, z ? 1 : 0);
+    }
+
+    static void setRS485Enable(bool z) {
+        setInt(CMD_SET_485_EN_STATE, z ? 1 : 0);
+    }
+
+
+    static void set12VEnable(bool z) {
+        setInt(CMD_SET_12V_EN_STATE, z ? 1 : 0);
+    }
+
 };
 
 

app/src/main/cpp/PhoneDevice.cpp

@@ -414,6 +414,13 @@ bool CPhoneDevice::GetNextScheduleItem(uint32_t tsBasedZero, uint32_t scheduleTi
 
 bool CPhoneDevice::Reboot(int resetType)
 {
+    if (resetType == 1)
+    {
+        // reboot the device
+        GpioControl::reboot();
+        return true;
+    }
+
     JNIEnv* env = NULL;
     bool didAttachThread = false;
     bool res = GetJniEnv(m_vm, &env, didAttachThread);
@@ -804,7 +811,7 @@ bool CPhoneDevice::OnImageReady(cv::Mat& mat)
         return false;
     }
 
-    mat = cv::imread("/sdcard/com.xypower.mpapp/ai1.jpg");
+    // mat = cv::imread("/sdcard/com.xypower.mpapp/ai1.jpg");
 
     mPhotoInfo.photoTime = time(NULL);
     int baseline = 0;
@@ -1015,6 +1022,7 @@ void CPhoneDevice::TurnOnCameraPower(JNIEnv* env)
     mCameraPowerLocker.lock();
     if (mCameraPowerCount == 0)
     {
+#if 0
         if(m_sysApiClass != NULL)
         {
 #ifdef _DEBUG
@@ -1022,6 +1030,8 @@ void CPhoneDevice::TurnOnCameraPower(JNIEnv* env)
 #endif
             env->CallStaticVoidMethod(m_sysApiClass, mSetCam3V3EnableMid, JNI_TRUE);
         }
+#endif
+        GpioControl::setCam3V3Enable(true);
     }
     mCameraPowerCount++;
     mCameraPowerLocker.unlock();
@@ -1035,6 +1045,7 @@ void CPhoneDevice::TurnOffCameraPower(JNIEnv* env)
         mCameraPowerCount--;
         if (mCameraPowerCount == 0)
         {
+#if 0
             if(m_sysApiClass != NULL)
             {
 #ifdef _DEBUG
@@ -1042,6 +1053,8 @@ void CPhoneDevice::TurnOffCameraPower(JNIEnv* env)
 #endif
                 env->CallStaticVoidMethod(m_sysApiClass, mSetCam3V3EnableMid, JNI_FALSE);
             }
+#endif  // 0
+            GpioControl::setCam3V3Enable(false);
         }
     }
     mCameraPowerLocker.unlock();
@@ -1052,6 +1065,7 @@ void CPhoneDevice::TurnOnOtg(JNIEnv* env)
     mCameraPowerLocker.lock();
     if (mOtgCount == 0)
     {
+#if 0
         if(m_sysApiClass != NULL)
         {
 #ifdef _DEBUG
@@ -1059,6 +1073,8 @@ void CPhoneDevice::TurnOnOtg(JNIEnv* env)
 #endif
             env->CallStaticVoidMethod(m_sysApiClass, mTurnOtgMid, JNI_TRUE);
         }
+#endif
+        GpioControl::setOtgState(true);
     }
     mOtgCount++;
     mCameraPowerLocker.unlock();
@@ -1072,6 +1088,7 @@ void CPhoneDevice::TurnOffOtg(JNIEnv* env)
         mOtgCount--;
         if (mOtgCount == 0)
         {
+#if 0
             if(m_sysApiClass != NULL)
             {
 #ifdef _DEBUG
@@ -1079,6 +1096,8 @@ void CPhoneDevice::TurnOffOtg(JNIEnv* env)
 #endif
                 env->CallStaticVoidMethod(m_sysApiClass, mTurnOtgMid, JNI_FALSE);
             }
+#endif
+            GpioControl::setOtgState(false);
         }
     }
     mCameraPowerLocker.unlock();

app/src/main/cpp/camera2/ndkcamera.cpp

@@ -70,6 +70,20 @@ void onCaptureSequenceAborted(void* context, ACameraCaptureSession* session, int
     ALOGW("onCaptureSequenceAborted %p %d", session, sequenceId);
 }
 
+void onCaptureProgressed(void* context, ACameraCaptureSession* session, ACaptureRequest* request, const ACameraMetadata* result)
+{
+    ACameraMetadata_const_entry val = { 0 };
+    camera_status_t status = ACAMERA_ERROR_BASE;
+
+    val = { 0 };
+    status = ACameraMetadata_getConstEntry(result, ACAMERA_CONTROL_AF_STATE, &val);
+    uint8_t afState = *(val.data.u8);
+
+    ALOGW("onCaptureProgressed AF_STATE=%u", (unsigned int)afState);
+
+    // ((NdkCamera*)context)->onCaptureProgressed(session, request, result);
+}
+
 void onCaptureCompleted(void* context, ACameraCaptureSession* session, ACaptureRequest* request, const ACameraMetadata* result)
 {
     ((NdkCamera*)context)->onCaptureCompleted(session, request, result);
@@ -102,6 +116,7 @@ NdkCamera::NdkCamera(int32_t width, int32_t height, const NdkCamera::CAMERA_PARA
     capture_session_output_container = 0;
     capture_session_output = 0;
     capture_session = 0;
+    captureSequenceId = 0;
 }
 
 NdkCamera::~NdkCamera()
@@ -340,7 +355,7 @@ int NdkCamera::open(const std::string& cameraId) {
         }
     }
 
-    std::this_thread::sleep_for(std::chrono::milliseconds(128));
+    // std::this_thread::sleep_for(std::chrono::milliseconds(128));
     // capture request
     {
         res = ACameraDevice_createCaptureRequest(camera_device, TEMPLATE_STILL_CAPTURE, &capture_request);
@@ -426,16 +441,15 @@ int NdkCamera::open(const std::string& cameraId) {
         ACameraCaptureSession_captureCallbacks camera_capture_session_capture_callbacks;
         camera_capture_session_capture_callbacks.context = this;
         camera_capture_session_capture_callbacks.onCaptureStarted = 0;
-        camera_capture_session_capture_callbacks.onCaptureProgressed = 0;
+        camera_capture_session_capture_callbacks.onCaptureProgressed = ::onCaptureProgressed;
         camera_capture_session_capture_callbacks.onCaptureCompleted = ::onCaptureCompleted;
         camera_capture_session_capture_callbacks.onCaptureFailed = onCaptureFailed;
         camera_capture_session_capture_callbacks.onCaptureSequenceCompleted = onCaptureSequenceCompleted;
         camera_capture_session_capture_callbacks.onCaptureSequenceAborted = onCaptureSequenceAborted;
         camera_capture_session_capture_callbacks.onCaptureBufferLost = 0;
 
-
-        ACameraCaptureSession_setRepeatingRequest(capture_session, &camera_capture_session_capture_callbacks, 1, &capture_request, nullptr);
-        // ACameraCaptureSession_capture(capture_session, &camera_capture_session_capture_callbacks, 1, &capture_request,nullptr);
+        ACameraCaptureSession_setRepeatingRequest(capture_session, &camera_capture_session_capture_callbacks, 1, &capture_request, &captureSequenceId);
+        // ACameraCaptureSession_capture(capture_session, &camera_capture_session_capture_callbacks, 1, &capture_request, &captureSequenceId);
     }
 
     return 0;
@@ -496,7 +510,6 @@ void NdkCamera::close()
     {
         ACameraManager_delete(camera_manager);
         camera_manager = 0;
-
         ALOGW("DBG::close %s", mCameraId.c_str());
     }
 }
@@ -686,6 +699,7 @@ void NdkCamera::onCaptureCompleted(ACameraCaptureSession* session, ACaptureReque
     // ACameraMetadata_getConstEntry(result, )
     ACameraMetadata_const_entry val = { 0 };
     camera_status_t status = ACAMERA_ERROR_BASE;
+    uint8_t afState = 0;
 
     if (m_imagesCaptured == ~0)
     {
@@ -693,7 +707,7 @@ void NdkCamera::onCaptureCompleted(ACameraCaptureSession* session, ACaptureReque
         {
             val = { 0 };
             status = ACameraMetadata_getConstEntry(result, ACAMERA_CONTROL_AF_STATE, &val);
-            uint8_t afState = *(val.data.u8);
+            afState = *(val.data.u8);
             if (afState == ACAMERA_CONTROL_AF_STATE_PASSIVE_FOCUSED || afState == ACAMERA_CONTROL_AF_STATE_FOCUSED_LOCKED)
                 // if (afState != ACAMERA_CONTROL_AF_STATE_INACTIVE)
             {
@@ -727,7 +741,7 @@ void NdkCamera::onCaptureCompleted(ACameraCaptureSession* session, ACaptureReque
         }
     }
 
-    ALOGD("onCaptureCompleted EXPOSURE_TIME=%lld, FocusDis=%f camera id=%s, AE=%s", exTime, focusDistance, mCameraId.c_str(), ((aeMode == 1) ? "ON" : "OFF"));
+    ALOGD("onCaptureCompleted EXPOSURE_TIME=%lld, FocusDis=%f camera id=%s, AE=%s AF_STATE=%u", exTime, focusDistance, mCameraId.c_str(), ((aeMode == 1) ? "ON" : "OFF"), afState);
 
     // __android_log_print(ANDROID_LOG_WARN, "NdkCamera", "onCaptureCompleted %p %p %p", session, request, result);
 }

app/src/main/cpp/camera2/ndkcamera.h

@@ -105,6 +105,8 @@ private:
     ACaptureSessionOutputContainer* capture_session_output_container;
     ACaptureSessionOutput* capture_session_output;
     ACameraCaptureSession* capture_session;
+
+    int captureSequenceId;
 };
 
 #endif // NDKCAMERA_H

app/src/main/java/com/xypower/mpapp/MicroPhotoService.java

@@ -574,7 +574,7 @@ public class MicroPhotoService extends Service {
         PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, alarmIntent, 0);
 
         AlarmManager alarmManager = (AlarmManager) context.getSystemService(ALARM_SERVICE);
-        alarmManager.setExactAndAllowWhileIdle(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime(), pendingIntent);
+        alarmManager.setExactAndAllowWhileIdle(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + 1000, pendingIntent);
     }
 
     @Override

common/build.gradle

@@ -18,6 +18,9 @@ android {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
         }
+        debug {
+            jniDebuggable true
+        }
     }
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_8

common/src/main/java/com/xypower/common/ViewUtils.java

@@ -1,8 +1,14 @@
 package com.xypower.common;
 
 import android.app.Activity;
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.os.Build;
+import android.text.TextUtils;
 import android.view.inputmethod.InputMethodManager;
 
+import androidx.annotation.RequiresApi;
+
 public class ViewUtils {
     public static void hideSoftKeyboard(Activity activity) {
         InputMethodManager inputMethodManager =
@@ -16,4 +22,5 @@ public class ViewUtils {
         }
     }
 
+
 }

mpmaster/build.gradle

@@ -29,6 +29,9 @@ android {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
         }
+        debug {
+            jniDebuggable true
+        }
     }
 
     compileOptions {