commit c02885dd51d360febd5d6326965bb32c9823dd4f Author: ZhangJinLong <19357383190@163.com> Date: Fri Aug 29 10:58:21 2025 +0800 first diff --git a/ (2).gitignore b/ (2).gitignore new file mode 100644 index 0000000..9b398b0 --- /dev/null +++ b/ (2).gitignore @@ -0,0 +1,12 @@ +*.o +*.d +*.crf +*.axf +*.elf +*.map +*.lst +*.bak +*.lnp +*.dep +*.uvgui.* +*.uvoptx \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..aa724b7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +*.iml +.gradle +/local.properties +/.idea/caches +/.idea/libraries +/.idea/modules.xml +/.idea/workspace.xml +/.idea/navEditor.xml +/.idea/assetWizardSettings.xml +.DS_Store +/build +/captures +.externalNativeBuild +.cxx +local.properties diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/AndroidProjectSystem.xml b/.idea/AndroidProjectSystem.xml new file mode 100644 index 0000000..4a53bee --- /dev/null +++ b/.idea/AndroidProjectSystem.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/compiler.xml b/.idea/compiler.xml new file mode 100644 index 0000000..b86273d --- /dev/null +++ b/.idea/compiler.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/deploymentTargetSelector.xml b/.idea/deploymentTargetSelector.xml new file mode 100644 index 0000000..b268ef3 --- /dev/null +++ b/.idea/deploymentTargetSelector.xml @@ -0,0 +1,10 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/gradle.xml b/.idea/gradle.xml new file mode 100644 index 0000000..639c779 --- /dev/null +++ b/.idea/gradle.xml @@ -0,0 +1,19 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/migrations.xml b/.idea/migrations.xml new file mode 100644 index 0000000..f8051a6 --- /dev/null +++ b/.idea/migrations.xml @@ -0,0 +1,10 @@ + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..74dd639 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,10 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/runConfigurations.xml b/.idea/runConfigurations.xml new file mode 100644 index 0000000..16660f1 --- /dev/null +++ b/.idea/runConfigurations.xml @@ -0,0 +1,17 @@ + + + + + + \ No newline at end of file diff --git a/.kotlin/errors/errors-1756261657029.log b/.kotlin/errors/errors-1756261657029.log new file mode 100644 index 0000000..1219b50 --- /dev/null +++ b/.kotlin/errors/errors-1756261657029.log @@ -0,0 +1,4 @@ +kotlin version: 2.0.21 +error message: The daemon has terminated unexpectedly on startup attempt #1 with error code: 0. The daemon process output: + 1. Kotlin compile daemon is ready + 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..b2584ef --- /dev/null +++ b/app/build.gradle.kts @@ -0,0 +1,61 @@ +plugins { + alias(libs.plugins.android.application) + alias(libs.plugins.kotlin.android) +} + +android { + namespace = "com.example.cmake_project_test" + compileSdk = 36 + + defaultConfig { + applicationId = "com.example.cmake_project_test" + minSdk = 24 + targetSdk = 36 + 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" + ) + } + } + compileOptions { + sourceCompatibility = JavaVersion.VERSION_11 + targetCompatibility = JavaVersion.VERSION_11 + } + kotlinOptions { + jvmTarget = "11" + } + externalNativeBuild { + cmake { + path = file("src/main/cpp/CMakeLists.txt") + version = "3.22.1" + } + } + buildFeatures { + viewBinding = true + } +} + +dependencies { + + implementation(libs.androidx.core.ktx) + implementation(libs.androidx.appcompat) + implementation(libs.material) + implementation(libs.androidx.constraintlayout) + testImplementation(libs.junit) + androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.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/androidTest/java/com/example/cmake_project_test/ExampleInstrumentedTest.kt b/app/src/androidTest/java/com/example/cmake_project_test/ExampleInstrumentedTest.kt new file mode 100644 index 0000000..85c230a --- /dev/null +++ b/app/src/androidTest/java/com/example/cmake_project_test/ExampleInstrumentedTest.kt @@ -0,0 +1,24 @@ +package com.example.cmake_project_test + +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.ext.junit.runners.AndroidJUnit4 + +import org.junit.Test +import org.junit.runner.RunWith + +import org.junit.Assert.* + +/** + * Instrumented test, which will execute on an Android device. + * + * See [testing documentation](http://d.android.com/tools/testing). + */ +@RunWith(AndroidJUnit4::class) +class ExampleInstrumentedTest { + @Test + fun useAppContext() { + // Context of the app under test. + val appContext = InstrumentationRegistry.getInstrumentation().targetContext + assertEquals("com.example.cmake_project_test", appContext.packageName) + } +} \ 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..7878023 --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/assets/data1.dat b/app/src/main/assets/data1.dat new file mode 100644 index 0000000..ba66912 Binary files /dev/null and b/app/src/main/assets/data1.dat differ diff --git a/app/src/main/cpp/CMakeLists.txt b/app/src/main/cpp/CMakeLists.txt new file mode 100644 index 0000000..0989916 --- /dev/null +++ b/app/src/main/cpp/CMakeLists.txt @@ -0,0 +1,53 @@ +# For more information about using CMake with Android Studio, read the +# documentation: https://d.android.com/studio/projects/add-native-code.html. +# For more examples on how to use CMake, see https://github.com/android/ndk-samples. + +# Sets the minimum CMake version required for this project. +cmake_minimum_required(VERSION 3.22.1) + +# Declares the project name. The project name can be accessed via ${ PROJECT_NAME}, +# Since this is the top level CMakeLists.txt, the project name is also accessible +# with ${CMAKE_PROJECT_NAME} (both CMake variables are in-sync within the top level +# build script scope). +project("cmake_project_test") + +# Creates and names a library, sets it as either STATIC +# or SHARED, and provides the relative paths to its source code. +# You can define multiple libraries, and CMake builds them for you. +# Gradle automatically packages shared libraries with your APK. +# +# In this top level CMakeLists.txt, ${CMAKE_PROJECT_NAME} is used to define +# the target library name; in the sub-module's CMakeLists.txt, ${PROJECT_NAME} +# is preferred for the same purpose. +# +# In order to load a library into your app from Java/Kotlin, you must call +# System.loadLibrary() and pass the name of the library defined here; +# For GameActivity/NativeActivity derived applications, the same library name must be +# used in the AndroidManifest.xml file. + +# Core static library (no JNI, pure C++) +add_library(core_math STATIC + src/add.cpp) + +target_include_directories(core_math PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/include) + +# Data parser static library +add_library(data_parser STATIC + src/data_praser.cpp) + +target_include_directories(data_parser PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/include) + +# JNI shared library: expose only JNI bridge, link against core +add_library(${CMAKE_PROJECT_NAME} SHARED + jni/jni_bridge.cpp) + +# Specifies libraries CMake should link to your target library. You +# can link libraries from various origins, such as libraries defined in this +# build script, prebuilt third-party libraries, or Android system libraries. +target_link_libraries(${CMAKE_PROJECT_NAME} + core_math + data_parser + android + log) \ No newline at end of file diff --git a/app/src/main/cpp/include/cpp/add.h b/app/src/main/cpp/include/cpp/add.h new file mode 100644 index 0000000..1dfed32 --- /dev/null +++ b/app/src/main/cpp/include/cpp/add.h @@ -0,0 +1,11 @@ +#pragma once + +namespace core { +namespace math { + +int add(int a, int b); + +} // namespace math +} // namespace core + + diff --git a/app/src/main/cpp/include/cpp/data_praser.h b/app/src/main/cpp/include/cpp/data_praser.h new file mode 100644 index 0000000..549912e --- /dev/null +++ b/app/src/main/cpp/include/cpp/data_praser.h @@ -0,0 +1,151 @@ +#ifndef DATA_PRASER_H +#define DATA_PRASER_H + +#include +#include +#include +#include +#include +#include + +// 设备类型枚举 +enum class DataType { + EEG, // 脑电 + ECG_2LEAD, // 胸腹心电/肌电 + ECG_12LEAD, // 12导联心电 + PPG, // 血氧 + RESPIRATION, // 呼吸/姿态 + SNORE, // 鼾声 + STETHOSCOPE, // 数字听诊 + MIT_BIH // 添加MIT-BIH心律失常数据集类型 +}; + +// 导联脱落状态 +struct LeadOffStatus { + uint8_t status[2]; // 导联状态字节 +}; + +// 统一传感器数据结构 +struct SensorData { + DataType data_type; + uint16_t packet_sn; // 数据包序列号 + LeadOffStatus lead_status; // 导联状态 + int64_t timestamp; // 系统时间戳(微秒) + float sqi; //信号质量 + + // 通道数据 + std::variant< + std::vector, // 单通道数据 + std::vector> // 多通道数据 + > channel_data; + std::vector raw_data; // 原始二进制数据 + // 附加数据 + struct { + uint16_t movement; // 运动强度 (呼吸设备) + uint8_t posture; // 姿态 (呼吸设备) + uint8_t ambient_light; // 环境光 (呼吸设备) + uint8_t hr; // 心率 (血氧) + uint8_t spo2; // 血氧饱和度 (血氧) + float temperature; // 温度 (修正为浮点类型) + uint8_t gpio_state; // GPIO状态 (12导联心电) + } additional; +}; + +// 前向声明 +struct SensorData; +struct FileManager; +enum class DataType; + +// 辅助函数：从字节数组读取小端整数 +template +T read_le(const uint8_t* data); + +// 脑电设备解析 (0x4230) +SensorData parse_eeg(const uint8_t* data); + +// 心电设备解析 (0x4211) +SensorData parse_ecg_emg(const uint8_t* data); + +// 血氧设备解析(0x4302) +SensorData parse_ppg(const uint8_t* data); + +// 12导联心电解析 (0x4402) +SensorData parse_12lead_ecg(const uint8_t* data); + +// MIT-BIH 212格式解析器 +SensorData parse_mit_bih_212(const uint8_t* data, size_t size); + +// 数字听诊解析 (0x1102) +SensorData parse_stethoscope(const uint8_t* data); + +// 鼾声解析 (0x4212) +SensorData parse_snore(const uint8_t* data); + +// 呼吸/姿态/环境光解析(0x4213) +SensorData parse_respiration(const uint8_t* data); + +// 统一解析入口函数 - 支持多个包头和数据包格式 +std::vector parse_device_data(const std::vector& file_data); + +// 工具函数：将数值转换为十六进制字符串 +std::string to_hex_string(uint16_t value); + +// JNI辅助函数：将C++的SensorData转换为Java对象 +jobject convertSensorDataToJava(JNIEnv* env, const SensorData& sensorData); + +// JNI辅助函数：将Java的byte数组转换为C++的vector +std::vector convertJavaByteArrayToVector(JNIEnv* env, jbyteArray byteArray); + +// JNI辅助函数：将C++的vector转换为Java的List +jobject convertSensorDataVectorToJavaList(JNIEnv* env, const std::vector& sensorDataVector); + + +class StreamParser { + public: + StreamParser(); + ~StreamParser(); + + // 添加新接收到的数据 + void appendData(const uint8_t* data, size_t length); + + // 检查是否有完整的数据包可用 + bool hasCompletePacket() const; + + // 获取下一个完整的数据包 + SensorData getNextPacket(); + + // 获取所有可用数据包 + std::vector getAllPackets(); + + // 设置数据包处理回调函数 + void setPacketCallback(std::function callback); + + // 清空缓冲区 + void clear(); + + // 新增：状态查询方法 + size_t getBufferSize() const; + size_t getTotalPackets() const; + size_t getPendingDataSize() const; + bool isBufferEmpty() const; + size_t getQueuedPacketCount() const; + + private: + std::vector buffer_; + std::queue complete_packets_; + static const size_t PACKET_SIZE = 238; // 固定数据包大小 + std::function packet_callback_; + + // 新增：成员变量 + size_t buffer_size_; // 累计接收的数据大小 + size_t total_packets_; // 累计解析的数据包数量 + + // 内部解析方法 + void parseBuffer(); + + // 新增：数据包验证方法 + bool isValidPacket(const uint8_t* data); + }; + + +#endif // DATA_PRASER_H diff --git a/app/src/main/cpp/jni/jni_bridge.cpp b/app/src/main/cpp/jni/jni_bridge.cpp new file mode 100644 index 0000000..8890820 --- /dev/null +++ b/app/src/main/cpp/jni/jni_bridge.cpp @@ -0,0 +1,146 @@ +#include +#include +#include +#include +#include +#include "../include/cpp/add.h" +#include "../include/cpp/data_praser.h" + +using core::math::add; + +extern "C" JNIEXPORT jstring JNICALL +Java_com_example_cmake_1project_1test_MainActivity_stringFromJNI( + JNIEnv* env, + jobject /* this */) { + std::string hello = "Hello from C++ (multi-file)"; + return env->NewStringUTF(hello.c_str()); +} + +extern "C" JNIEXPORT jint JNICALL +Java_com_example_cmake_1project_1test_MainActivity_addFromJNI( + JNIEnv* env, + jobject /* this */, + jint a, + jint b) { + (void)env; + return static_cast(add(static_cast(a), static_cast(b))); +} + +extern "C" JNIEXPORT jobject JNICALL +Java_com_example_cmake_1project_1test_MainActivity_parseDeviceDataFromJNI( + JNIEnv* env, + jobject /* this */, + jbyteArray fileData) { + + try { + // 将Java的byte数组转换为C++的vector + std::vector cppFileData = convertJavaByteArrayToVector(env, fileData); + + if (cppFileData.empty()) { + __android_log_print(ANDROID_LOG_WARN, "DataParser", "Empty file data received"); + return nullptr; + } + + // 调用C++的解析函数 + std::vector result = parse_device_data(cppFileData); + + // 将结果转换为Java对象 + jobject javaResult = convertSensorDataVectorToJavaList(env, result); + + if (javaResult == nullptr) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Failed to convert result to Java object"); + } else { + __android_log_print(ANDROID_LOG_INFO, "DataParser", "Successfully parsed %zu data packets", result.size()); + } + + return javaResult; + + } catch (const std::exception& e) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Exception during parsing: %s", e.what()); + return nullptr; + } catch (...) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Unknown exception during parsing"); + return nullptr; + } +} + + +// ================= 流式解析 JNI 接口 ================= + +// 创建解析器实例，返回 native 句柄 +extern "C" JNIEXPORT jlong JNICALL +Java_com_example_cmake_1project_1test_MainActivity_createStreamParser( + JNIEnv* env, + jobject /* this */) { + (void)env; + try { + auto* parser = new StreamParser(); + return reinterpret_cast(parser); + } catch (...) { + return 0; + } +} + +// 释放解析器实例 +extern "C" JNIEXPORT void JNICALL +Java_com_example_cmake_1project_1test_MainActivity_destroyStreamParser( + JNIEnv* env, + jobject /* this */, + jlong handle) { + (void)env; + auto* parser = reinterpret_cast(handle); + delete parser; +} + +// 追加一段字节流数据 +extern "C" JNIEXPORT void JNICALL +Java_com_example_cmake_1project_1test_MainActivity_streamParserAppend( + JNIEnv* env, + jobject /* this */, + jlong handle, + jbyteArray chunk) { + auto* parser = reinterpret_cast(handle); + if (!parser || !chunk) return; + + jsize len = env->GetArrayLength(chunk); + if (len <= 0) return; + std::vector buf(static_cast(len)); + env->GetByteArrayRegion(chunk, 0, len, reinterpret_cast(buf.data())); + parser->appendData(buf.data(), buf.size()); +} + +// 拉取已完成的所有数据包，转换为 Java List +extern "C" JNIEXPORT jobject JNICALL +Java_com_example_cmake_1project_1test_MainActivity_streamParserDrainPackets( + JNIEnv* env, + jobject /* this */, + jlong handle) { + auto* parser = reinterpret_cast(handle); + if (!parser) return nullptr; + std::vector packets = parser->getAllPackets(); + return convertSensorDataVectorToJavaList(env, packets); +} + +// 便捷方法：从整块数据按固定块大小模拟流式解析，返回解析到的所有包 +extern "C" JNIEXPORT jobject JNICALL +Java_com_example_cmake_1project_1test_MainActivity_parseStreamFromBytes( + JNIEnv* env, + jobject /* this */, + jbyteArray data, + jint chunkSize) { + if (data == nullptr || chunkSize <= 0) return nullptr; + + std::vector src = convertJavaByteArrayToVector(env, data); + auto* parser = new StreamParser(); + size_t offset = 0; + while (offset < src.size()) { + size_t n = std::min(static_cast(chunkSize), src.size() - offset); + parser->appendData(src.data() + offset, n); + offset += n; + } + std::vector packets = parser->getAllPackets(); + delete parser; + return convertSensorDataVectorToJavaList(env, packets); +} + + diff --git a/app/src/main/cpp/src/add.cpp b/app/src/main/cpp/src/add.cpp new file mode 100644 index 0000000..770ce17 --- /dev/null +++ b/app/src/main/cpp/src/add.cpp @@ -0,0 +1,11 @@ +#include "../include/cpp/add.h" + +namespace core { +namespace math { + +int add(int a, int b) { + return a + b; +} + +} // namespace math +} // namespace core diff --git a/app/src/main/cpp/src/data_praser.cpp b/app/src/main/cpp/src/data_praser.cpp new file mode 100644 index 0000000..f6e92ee --- /dev/null +++ b/app/src/main/cpp/src/data_praser.cpp @@ -0,0 +1,919 @@ +#include "../include/cpp/data_praser.h" +#include // 添加 memcpy 头文件 +#include // 添加 stringstream 头文件 +#include // 添加 iomanip 头文件 +#include +#include +#include + +// 辅助函数：从字节数组读取小端整数 +template +T read_le(const uint8_t* data) { + T value = 0; + for (size_t i = 0; i < sizeof(T); ++i) { + value |= static_cast(data[i]) << (i * 8); + } + return value; +} + +// 脑电设备解析 (0x4230) +SensorData parse_eeg(const uint8_t* data) { + SensorData result; + result.data_type = DataType::EEG; + result.packet_sn = read_le(data); + + // 跳过 DataType(2) 和 data_len(2) + const uint8_t* payload = data + 6; + + // 导联状态 + std::memcpy(result.lead_status.status, payload, 2); + payload += 2; + + // 解析EEG数据 (6通道 × 14采样点) + auto& eeg_data = result.channel_data.emplace>>(); + eeg_data.resize(6); + + for (int ch = 0; ch < 6; ++ch) { + eeg_data[ch].reserve(14); + for (int i = 0; i < 14; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + eeg_data[ch].push_back(adc_value * 0.318f); // 转换为μV + } + } + + // 解析EOG数据 (2通道 × 14采样点) + for (int ch = 0; ch < 2; ++ch) { + eeg_data.push_back({}); // 添加新通道 + for (int i = 0; i < 14; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + eeg_data.back().push_back(adc_value * 0.318f); // 转换为μV + } + } + + // 跳过预留区(6字节) + payload += 6; + + // 赋值原始二进制数据 + result.raw_data.assign(data, data + 6 + 2 + 6 * 14 * 2 + 2 * 14 * 2 + 6); + + return result; +} + +// 心电设备解析 (0x4211) +SensorData parse_ecg_emg(const uint8_t* data) { + SensorData result; + result.data_type = DataType::ECG_2LEAD; + result.packet_sn = read_le(data); + + // 跳过 data_type(2) 和 data_len(2) + const uint8_t* payload = data + 6; + + // 导联状态 + std::memcpy(result.lead_status.status, payload, 2); + payload += 2; + + // 解析数据 (多通道混合) + auto& channels = result.channel_data.emplace>>(); + + // ECG1 (25采样点) + channels.push_back({}); + for (int i = 0; i < 25; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels.back().push_back(adc_value * 0.318f); // μV + } + + // ECG2 (25采样点) + channels.push_back({}); + for (int i = 0; i < 25; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels.back().push_back(adc_value * 0.318f); // μV + } + + // EMG1 (25采样点) + channels.push_back({}); + for (int i = 0; i < 25; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels.back().push_back(adc_value * 0.318f); // μV + } + + // EMG2 (25采样点) + channels.push_back({}); + for (int i = 0; i < 25; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels.back().push_back(adc_value * 0.318f); // μV + } + + // 呼吸温度 (5采样点) + channels.push_back({}); + for (int i = 0; i < 5; ++i) { + int16_t temp_value = read_le(payload); + payload += 2; + channels.back().push_back(temp_value * 0.477f); // 存储所有采样点 + } + + // 呼吸阻抗1 (5采样点) + channels.push_back({}); + for (int i = 0; i < 5; ++i) { + int16_t imp_value = read_le(payload); + payload += 2; + channels.back().push_back(static_cast(imp_value)); // 原始值 + } + + // 呼吸阻抗2 (5采样点) + channels.push_back({}); + for (int i = 0; i < 5; ++i) { + int16_t imp_value = read_le(payload); + payload += 2; + channels.back().push_back(static_cast(imp_value)); // 原始值 + } + + // 赋值原始二进制数据 + result.raw_data.assign(data, data + 238); // 完整238字节 + + return result; +} + +// 血氧设备解析(0x4302) +SensorData parse_ppg(const uint8_t* data) { + SensorData result; + result.data_type = DataType::PPG; + result.packet_sn = read_le(data); + + // 跳过 DataType(2) 和 data_len(2) + const uint8_t* payload = data + 6; + + // 读取生命体征 + result.additional.hr = *payload++; + result.additional.spo2 = *payload++; + + // 注意：温度值放大100倍存储，需要除以100 + int16_t temp_raw = read_le(payload); + result.additional.temperature = static_cast(temp_raw) / 100.0f; + payload += 2; + + // 解析红光数据 (57采样点) + auto& channels = result.channel_data.emplace>>(); + channels.push_back({}); + for (int i = 0; i < 57; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels.back().push_back(adc_value * 0.879f); // mV + } + + // 解析红外光数据(57采样点) + channels.push_back({}); + for (int i = 0; i < 57; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels.back().push_back(adc_value * 0.879f); // mV + } + + // 赋值原始二进制数据 + result.raw_data.assign(data, data + 6 + 4 + 57 * 2 * 2); + + return result; +} + +// 12导联心电解析 (0x4402) +SensorData parse_12lead_ecg(const uint8_t* data) { + SensorData result; + result.data_type = DataType::ECG_12LEAD; + result.packet_sn = read_le(data); + + // 跳过 DataType(2) 和 data_len(2) + const uint8_t* payload = data + 6; + + // 导联状态(按文档说明处理STAT寄存器) + uint8_t stat_dh = payload[0]; // STAT.DH + uint8_t stat_dm = payload[1]; // STAT.DM + + // 正确拼接方式: (STAT.DH << 4) | (STAT.DM >> 4) + result.lead_status.status[0] = (stat_dh << 4) | (stat_dm >> 4) ; + + result.lead_status.status[1] = 0; // 第二个字节未使用 + payload += 2; + + // 解析8通道ECG数据 + auto& channels = result.channel_data.emplace>>(); + channels.resize(8); + + for (int ch = 0; ch < 8; ++ch) { + channels[ch].reserve(14); + for (int i = 0; i < 14; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels[ch].push_back(adc_value * 0.318f); //原始数据进行量纲转换 + } + } + + // GPIO状态(取低4位) + result.additional.gpio_state = *payload & 0x0F; + payload += 1; + + // 跳过预留区(5字节) + payload += 5; + + // 赋值原始二进制数据 + result.raw_data.assign(data, data + 6 + 2 + 8 * 14 * 2 + 1 + 5); + + return result; +} + + +// 数字听诊解析 (0x1102) +SensorData parse_stethoscope(const uint8_t* data) { + SensorData result; + result.data_type = DataType::STETHOSCOPE; + result.packet_sn = read_le(data); + + // 跳过 DataType(2) 和 data_len(2) + const uint8_t* payload = data + 6; + + // 解析双通道音频数据 + auto& channels = result.channel_data.emplace>>(); + channels.resize(2); + + // 通道1数据 (116采样点) + for (int i = 0; i < 116; ++i) { + int8_t sample = static_cast(*payload++); + channels[0].push_back(sample * 0.146f); // mV + } + + // 通道2数据 (116采样点) + for (int i = 0; i < 116; ++i) { + int8_t sample = static_cast(*payload++); + channels[1].push_back(sample * 0.146f); // mV + } + + // 赋值原始二进制数据 + result.raw_data.assign(data, data + 6 + 116 * 2); + + return result; +} + +// 鼾声解析 (0x4212) +SensorData parse_snore(const uint8_t* data) { + SensorData result; + result.data_type = DataType::SNORE; + result.packet_sn = read_le(data); + + // 跳过 data_type(2) + data_len(2) + const uint8_t* payload = data + 6; + + // 解析鼾声数据 (232字节) + auto& channels = result.channel_data.emplace>(); + + // 高效转换: 直接使用 reinterpret_cast + const int8_t* snore_data = reinterpret_cast(payload); + for (int i = 0; i < 232; ++i) { + channels.push_back(static_cast(snore_data[i])); + } + + // 赋值原始二进制数据 + result.raw_data.assign(data, data + 6 + 232); + + return result; +} + +// 呼吸/姿态/环境光解析(0x4213) +SensorData parse_respiration(const uint8_t* data) { + SensorData result; + result.data_type = DataType::RESPIRATION; + result.packet_sn = read_le(data); + + // 跳过 DataType(2) 和 data_len(2) + const uint8_t* payload = data + 6; + + // 解析呼吸气流数据 (114采样点) + auto& channels = result.channel_data.emplace>>(); + channels.push_back({}); + + for (int i = 0; i < 114; ++i) { + int16_t adc_value = read_le(payload); + payload += 2; + channels.back().push_back(adc_value * 0.1f); // 实际单位 + } + + // 解析附加数据 + result.additional.movement = read_le(payload); // 运动强度 + payload += 2; + + result.additional.posture = *payload++; // 姿态数据 + result.additional.ambient_light = *payload++; // 环境光数据 + + // 赋值原始二进制数据 + result.raw_data.assign(data, data + 6 + 114 * 2 + 2 + 1 + 1); + + return result; +} + +// 统一解析入口函数 - 支持多个包头和数据包格式 +std::vector parse_device_data(const std::vector& file_data) { + const size_t PACKET_SIZE = 238; // 每个数据包固定大小 + const size_t RESPONSE_HEADER_SIZE = 10; // 响应包头大小 (2功能码+ 2数据长度 + 4实际采集点数+crc校验) + const uint16_t FUNCTION_CODE = 0x0010; // 获取数据功能码 + + const size_t file_size = file_data.size(); + const uint8_t* ptr = file_data.data(); + const uint8_t* end_ptr = ptr + file_size; + std::map> grouped_data; + std::vector results; + while (ptr < end_ptr) { + // 检查是否有响应包头 + bool has_response_header = false; + size_t remaining = end_ptr - ptr; + + // 确保有足够的空间检查包头 + if (remaining >= RESPONSE_HEADER_SIZE) { + // 读取功能码(小端) + uint16_t func_code = read_le(ptr); + // 读取数据长度 (小端) + uint16_t data_len = read_le(ptr + 2); + + // 检查是否符合0x0010响应包特征 + if (func_code == FUNCTION_CODE && data_len == 0x0004) { + has_response_header = true; + + // 读取实际数据点数 (小端) + uint32_t actual_points = read_le(ptr + 4); + + // 计算期望的数据长度(实际点数 * 包大小) + size_t expected_data_size = actual_points * PACKET_SIZE; + size_t remaining_after_header = remaining - RESPONSE_HEADER_SIZE; + + // 验证数据长度是否匹配 + if (remaining_after_header < expected_data_size) { + std::string error = "包头数据不足: 预期 " + + std::to_string(expected_data_size) + + " 字节, 实际 " + + std::to_string(remaining_after_header) + + " 字节"; + throw std::runtime_error(error); + } + + // 跳过包头 + ptr += RESPONSE_HEADER_SIZE; + + // 处理包头后的数据包 + for (uint32_t i = 0; i < actual_points; i++) { + if (end_ptr - ptr < static_cast(PACKET_SIZE)) { + throw std::runtime_error("数据包不完整"); + } + + // 读取数据类型标识 + const uint16_t data_type = read_le(ptr + 2); + + switch (data_type) { + case 0x4230: + grouped_data[DataType::EEG].push_back(parse_eeg(ptr)); + break; + case 0x4211: + grouped_data[DataType::ECG_2LEAD].push_back(parse_ecg_emg(ptr)); + break; + case 0x4212: + grouped_data[DataType::SNORE].push_back(parse_snore(ptr)); + break; + case 0x4213: + grouped_data[DataType::RESPIRATION].push_back(parse_respiration(ptr)); + break; + case 0x4402: + grouped_data[DataType::ECG_12LEAD].push_back(parse_12lead_ecg(ptr)); + break; + case 0x4302: + grouped_data[DataType::PPG].push_back(parse_ppg(ptr)); + break; + case 0x1102: + grouped_data[DataType::STETHOSCOPE].push_back(parse_stethoscope(ptr)); + break; + default: + throw std::runtime_error("未知设备类型: 0x" + + to_hex_string(data_type)); + } + ptr += PACKET_SIZE; + } + } + } + + // 如果没有检测到响应包头，尝试按线数据包处理 + if (!has_response_header) { + // 检查是否有完整的数据包 + if (remaining >= PACKET_SIZE) { + // 读取数据类型标识 + const uint16_t data_type = read_le(ptr + 2); + + switch (data_type) { + case 0x4230: + grouped_data[DataType::EEG].push_back(parse_eeg(ptr)); + break; + case 0x4211: + grouped_data[DataType::ECG_2LEAD].push_back(parse_ecg_emg(ptr)); + break; + case 0x4212: + grouped_data[DataType::SNORE].push_back(parse_snore(ptr)); + break; + case 0x4213: + grouped_data[DataType::RESPIRATION].push_back(parse_respiration(ptr)); + break; + case 0x4402: + grouped_data[DataType::ECG_12LEAD].push_back(parse_12lead_ecg(ptr)); + break; + case 0x4302: + grouped_data[DataType::PPG].push_back(parse_ppg(ptr)); + break; + case 0x1102: + grouped_data[DataType::STETHOSCOPE].push_back(parse_stethoscope(ptr)); + break; + default: + // 如果不是已知类型，跳过这个包继续处理 + ptr += PACKET_SIZE; + continue; + } + ptr += PACKET_SIZE; + } else { + // 剩余数据不足一个包，但大于0，发出警告 + break; // 结束处理 + } + } + } + + // 直接构建最终结果，避免中间存储 + std::vector final_results; + + // 按数据类型分组处理，合并通道数据 + for (auto& [data_type, packets] : grouped_data) { + if (packets.empty()) continue; + + // 检查第一个数据包的通道数据类型 + bool isMultiChannel = std::holds_alternative>>(packets[0].channel_data); + bool isSingleChannel = std::holds_alternative>(packets[0].channel_data); + + if (isMultiChannel) { + // 处理多通道数据 (vector>) + SensorData full_data = packets[0]; + full_data.channel_data = std::vector>(); + + // 获取通道数量 + size_t num_channels = 0; + if (auto* channels = std::get_if>>(&packets[0].channel_data)) { + num_channels = channels->size(); + full_data.channel_data.emplace>>(num_channels); + } + + // 合并所有数据包中的通道数据 + auto& full_channels = std::get>>(full_data.channel_data); + for (size_t ch = 0; ch < num_channels; ch++) { + for (auto& packet : packets) { + if (auto* channels = std::get_if>>(&packet.channel_data)) { + if (ch < channels->size()) { + full_channels[ch].insert(full_channels[ch].end(), + (*channels)[ch].begin(), + (*channels)[ch].end()); + } + } + } + } + + final_results.push_back(full_data); + + } else if (isSingleChannel) { + // 处理单通道数据 (vector) - 合并所有数据包的单通道数据 + SensorData full_data = packets[0]; + full_data.channel_data = std::vector(); + + auto& full_channel = full_data.channel_data.emplace>(); + + // 合并所有数据包的单通道数据 + for (auto& packet : packets) { + if (auto* channel = std::get_if>(&packet.channel_data)) { + full_channel.insert(full_channel.end(), channel->begin(), channel->end()); + } + } + + final_results.push_back(full_data); + + } else { + // 没有通道数据，直接添加第一个数据包 + final_results.push_back(packets[0]); + } + } + + return final_results; +} + +// 工具函数：将数值转换为十六进制字符串 +std::string to_hex_string(uint16_t value) { + std::stringstream ss; + ss << "0x" << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << value; + return ss.str(); +} + + +// ============================================================================ +// 新的流式解析版本 - 用于蓝牙设备数据包 +// ============================================================================ + +// 流式解析器构造函数 +StreamParser::StreamParser() : packet_callback_(nullptr), buffer_size_(0), total_packets_(0) { + // 预分配缓冲区空间，避免频繁重新分配 + buffer_.reserve(1024); // 预分配1KB空间 +} + +// 流式解析器析构函数 +StreamParser::~StreamParser() { + // 清理资源 + clear(); +} + +// 添加新接收到的蓝牙数据 +void StreamParser::appendData(const uint8_t* data, size_t length) { + if (data == nullptr || length == 0) { + return; + } + + // 将新数据添加到缓冲区 + buffer_.insert(buffer_.end(), data, data + length); + buffer_size_ += length; + + // 尝试解析缓冲区中的数据 + parseBuffer(); +} + +// 检查是否有完整的数据包可用 +bool StreamParser::hasCompletePacket() const { + return !complete_packets_.empty(); +} + +// 获取下一个完整的数据包 +SensorData StreamParser::getNextPacket() { + if (complete_packets_.empty()) { + throw std::runtime_error("没有可用的完整数据包"); + } + + SensorData packet = complete_packets_.front(); + complete_packets_.pop(); + return packet; +} + +// 获取所有可用数据包 +std::vector StreamParser::getAllPackets() { + std::vector result; + while (!complete_packets_.empty()) { + result.push_back(complete_packets_.front()); + complete_packets_.pop(); + } + return result; +} + +// 设置数据包处理回调函数 +void StreamParser::setPacketCallback(std::function callback) { + packet_callback_ = callback; +} + +// 清空缓冲区和队列 +void StreamParser::clear() { + buffer_.clear(); + buffer_size_ = 0; + while (!complete_packets_.empty()) { + complete_packets_.pop(); + } +} + +// 获取缓冲区状态信息 +size_t StreamParser::getBufferSize() const { + return buffer_.size(); +} + +size_t StreamParser::getTotalPackets() const { + return total_packets_; +} + +// 内部解析方法 - 持续处理缓冲区中的数据 +void StreamParser::parseBuffer() { + // 持续处理直到缓冲区中没有完整的数据包 + while (buffer_.size() >= PACKET_SIZE) { + // 验证数据包的有效性 + if (!isValidPacket(buffer_.data())) { + // 无效数据包，跳过第一个字节继续寻找 + buffer_.erase(buffer_.begin()); + continue; + } + + // 提取数据包类型 + uint16_t data_type = read_le(buffer_.data() + 2); + SensorData packet; + + try { + // 根据数据类型调用相应的解析函数 + switch (data_type) { + case 0x4230: + packet = parse_eeg(buffer_.data()); + break; + case 0x4211: + packet = parse_ecg_emg(buffer_.data()); + break; + case 0x4212: + packet = parse_snore(buffer_.data()); + break; + case 0x4213: + packet = parse_respiration(buffer_.data()); + break; + case 0x4402: + packet = parse_12lead_ecg(buffer_.data()); + break; + case 0x4302: + packet = parse_ppg(buffer_.data()); + break; + case 0x1102: + packet = parse_stethoscope(buffer_.data()); + break; + default: + // 未知类型，跳过这个包 + buffer_.erase(buffer_.begin(), buffer_.begin() + PACKET_SIZE); + continue; // 继续处理下一个包 + } + + // 成功解析，添加到完成包队列 + complete_packets_.push(packet); + total_packets_++; + + // 如果有回调函数，调用它 + if (packet_callback_) { + packet_callback_(packet); + } + + // 从缓冲区移除已处理的数据包 + buffer_.erase(buffer_.begin(), buffer_.begin() + PACKET_SIZE); + + } catch (const std::exception& e) { + // 解析错误，跳过这个包 + buffer_.erase(buffer_.begin(), buffer_.begin() + PACKET_SIZE); + } + } +} + +// 验证数据包的有效性 +bool StreamParser::isValidPacket(const uint8_t* data) { + if (data == nullptr) { + return false; + } + + // 检查数据包长度 + uint16_t data_len = read_le(data + 4); + if (data_len != PACKET_SIZE - 6) { // 6字节是头部长度 + return false; + } + + // 检查数据类型是否在有效范围内 + uint16_t data_type = read_le(data + 2); + switch (data_type) { + case 0x4230: // EEG + case 0x4211: // ECG_2LEAD + case 0x4212: // SNORE + case 0x4213: // RESPIRATION + case 0x4402: // ECG_12LEAD + case 0x4302: // PPG + case 0x1102: // STETHOSCOPE + return true; + default: + return false; + } +} + +// 获取缓冲区中等待处理的数据量 +size_t StreamParser::getPendingDataSize() const { + return buffer_.size(); +} + +// 检查缓冲区是否为空 +bool StreamParser::isBufferEmpty() const { + return buffer_.empty(); +} + +// 获取队列中等待处理的数据包数量 +size_t StreamParser::getQueuedPacketCount() const { + return complete_packets_.size(); +} + +// JNI辅助函数：将Java的byte数组转换为C++的vector +std::vector convertJavaByteArrayToVector(JNIEnv* env, jbyteArray byteArray) { + std::vector result; + + if (byteArray == nullptr) { + return result; + } + + jsize length = env->GetArrayLength(byteArray); + if (length <= 0) { + return result; + } + + jbyte* elements = env->GetByteArrayElements(byteArray, nullptr); + if (elements == nullptr) { + return result; + } + + result.resize(length); + for (jsize i = 0; i < length; ++i) { + result[i] = static_cast(elements[i]); + } + + env->ReleaseByteArrayElements(byteArray, elements, JNI_ABORT); + return result; +} + +// JNI辅助函数：将C++的SensorData转换为Java对象 +jobject convertSensorDataToJava(JNIEnv* env, const SensorData& sensorData) { + // 获取Java类的引用 + jclass sensorDataClass = env->FindClass("type/SensorData"); + if (sensorDataClass == nullptr) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Cannot find SensorData class"); + return nullptr; + } + + // 创建Java对象 + jobject javaSensorData = env->AllocObject(sensorDataClass); + if (javaSensorData == nullptr) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Cannot create SensorData object"); + return nullptr; + } + + // 获取字段ID + jfieldID dataTypeField = env->GetFieldID(sensorDataClass, "dataType", "Ltype/SensorData$DataType;"); + jfieldID packetSnField = env->GetFieldID(sensorDataClass, "packetSn", "I"); + jfieldID leadStatusField = env->GetFieldID(sensorDataClass, "leadStatus", "[B"); + jfieldID timestampField = env->GetFieldID(sensorDataClass, "timestamp", "J"); + jfieldID channelDataField = env->GetFieldID(sensorDataClass, "channelData", "Ljava/util/List;"); + jfieldID additionalDataField = env->GetFieldID(sensorDataClass, "additionalData", "Ltype/SensorData$AdditionalData;"); + jfieldID rawDataField = env->GetFieldID(sensorDataClass, "rawData", "[B"); + + if (dataTypeField == nullptr || packetSnField == nullptr || leadStatusField == nullptr || + timestampField == nullptr || channelDataField == nullptr || additionalDataField == nullptr || rawDataField == nullptr) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Cannot find SensorData fields"); + return nullptr; + } + + // 设置基本字段 + env->SetIntField(javaSensorData, packetSnField, static_cast(sensorData.packet_sn)); + env->SetLongField(javaSensorData, timestampField, static_cast(sensorData.timestamp)); + + // 设置数据类型 + jclass dataTypeClass = env->FindClass("type/SensorData$DataType"); + if (dataTypeClass != nullptr) { + // 根据C++的DataType枚举值找到对应的Java枚举值 + const char* enumName = nullptr; + switch (sensorData.data_type) { + case DataType::EEG: enumName = "EEG"; break; + case DataType::ECG_2LEAD: enumName = "ECG_2LEAD"; break; + case DataType::PPG: enumName = "PPG"; break; + case DataType::ECG_12LEAD: enumName = "ECG_12LEAD"; break; + case DataType::MIT_BIH: enumName = "MIT_BIH"; break; + case DataType::STETHOSCOPE: enumName = "STETHOSCOPE"; break; + case DataType::SNORE: enumName = "SNORE"; break; + case DataType::RESPIRATION: enumName = "RESPIRATION"; break; + default: enumName = "EEG"; break; // 默认值 + } + + jfieldID enumField = env->GetStaticFieldID(dataTypeClass, enumName, "Ltype/SensorData$DataType;"); + if (enumField != nullptr) { + jobject enumValue = env->GetStaticObjectField(dataTypeClass, enumField); + if (enumValue != nullptr) { + env->SetObjectField(javaSensorData, dataTypeField, enumValue); + } + } + } + + // 设置导联状态 + jbyteArray leadStatusArray = env->NewByteArray(2); + env->SetByteArrayRegion(leadStatusArray, 0, 2, reinterpret_cast(sensorData.lead_status.status)); + env->SetObjectField(javaSensorData, leadStatusField, leadStatusArray); + + // 设置原始数据 + jbyteArray rawDataArray = env->NewByteArray(static_cast(sensorData.raw_data.size())); + env->SetByteArrayRegion(rawDataArray, 0, static_cast(sensorData.raw_data.size()), + reinterpret_cast(sensorData.raw_data.data())); + env->SetObjectField(javaSensorData, rawDataField, rawDataArray); + + // 设置通道数据（处理两种类型：vector> 和 vector） + if (auto* multiChannels = std::get_if>>(&sensorData.channel_data)) { + // 处理多通道数据 (vector>) + jclass arrayListClass = env->FindClass("java/util/ArrayList"); + jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "", "()V"); + jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z"); + + // 创建外层列表 (List>) + jobject outerList = env->NewObject(arrayListClass, arrayListConstructor); + + for (const auto& channel : *multiChannels) { + // 创建内层列表 (List) + jobject innerList = env->NewObject(arrayListClass, arrayListConstructor); + + // 将浮点数添加到内层列表 + jclass floatClass = env->FindClass("java/lang/Float"); + jmethodID floatConstructor = env->GetMethodID(floatClass, "", "(F)V"); + + for (float value : channel) { + jobject floatObj = env->NewObject(floatClass, floatConstructor, value); + env->CallBooleanMethod(innerList, addMethod, floatObj); + env->DeleteLocalRef(floatObj); // 释放本地引用 + } + + // 将内层列表添加到外层列表 + env->CallBooleanMethod(outerList, addMethod, innerList); + env->DeleteLocalRef(innerList); // 释放本地引用 + } + + env->SetObjectField(javaSensorData, channelDataField, outerList); + + } else if (auto* singleChannel = std::get_if>(&sensorData.channel_data)) { + // 处理单通道数据 (vector) - 将其包装为单通道的多通道格式 + jclass arrayListClass = env->FindClass("java/util/ArrayList"); + jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "", "()V"); + jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z"); + + // 创建外层列表 (List>) + jobject outerList = env->NewObject(arrayListClass, arrayListConstructor); + + // 创建内层列表 (List) + jobject innerList = env->NewObject(arrayListClass, arrayListConstructor); + + // 将浮点数添加到内层列表 + jclass floatClass = env->FindClass("java/lang/Float"); + jmethodID floatConstructor = env->GetMethodID(floatClass, "", "(F)V"); + + for (float value : *singleChannel) { + jobject floatObj = env->NewObject(floatClass, floatConstructor, value); + env->CallBooleanMethod(innerList, addMethod, floatObj); + env->DeleteLocalRef(floatObj); // 释放本地引用 + } + + // 将内层列表添加到外层列表 + env->CallBooleanMethod(outerList, addMethod, innerList); + env->DeleteLocalRef(innerList); // 释放本地引用 + + env->SetObjectField(javaSensorData, channelDataField, outerList); + + } else { + // 没有通道数据，设置为空列表 + jclass arrayListClass = env->FindClass("java/util/ArrayList"); + jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "", "()V"); + jobject emptyList = env->NewObject(arrayListClass, arrayListConstructor); + env->SetObjectField(javaSensorData, channelDataField, emptyList); + } + + // 设置附加数据（简化处理） + jclass additionalDataClass = env->FindClass("type/SensorData$AdditionalData"); + if (additionalDataClass != nullptr) { + jobject additionalData = env->AllocObject(additionalDataClass); + if (additionalData != nullptr) { + // 设置基本字段 + jfieldID hrField = env->GetFieldID(additionalDataClass, "hr", "I"); + jfieldID spo2Field = env->GetFieldID(additionalDataClass, "spo2", "I"); + jfieldID tempField = env->GetFieldID(additionalDataClass, "temperature", "F"); + + if (hrField != nullptr) env->SetIntField(additionalData, hrField, sensorData.additional.hr); + if (spo2Field != nullptr) env->SetIntField(additionalData, spo2Field, sensorData.additional.spo2); + if (tempField != nullptr) env->SetFloatField(additionalData, tempField, sensorData.additional.temperature); + + env->SetObjectField(javaSensorData, additionalDataField, additionalData); + } + } + + return javaSensorData; +} + +// JNI辅助函数：将C++的vector转换为Java的List +jobject convertSensorDataVectorToJavaList(JNIEnv* env, const std::vector& sensorDataVector) { + // 创建ArrayList + jclass arrayListClass = env->FindClass("java/util/ArrayList"); + if (arrayListClass == nullptr) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Cannot find ArrayList class"); + return nullptr; + } + + jmethodID arrayListConstructor = env->GetMethodID(arrayListClass, "", "()V"); + jmethodID addMethod = env->GetMethodID(arrayListClass, "add", "(Ljava/lang/Object;)Z"); + + if (arrayListConstructor == nullptr || addMethod == nullptr) { + __android_log_print(ANDROID_LOG_ERROR, "DataParser", "Cannot find ArrayList methods"); + return nullptr; + } + + jobject resultList = env->NewObject(arrayListClass, arrayListConstructor); + + // 添加每个SensorData对象 + for (const auto& sensorData : sensorDataVector) { + jobject javaSensorData = convertSensorDataToJava(env, sensorData); + if (javaSensorData != nullptr) { + env->CallBooleanMethod(resultList, addMethod, javaSensorData); + } + } + + return resultList; +} + diff --git a/app/src/main/java/com/example/cmake_project_test/MainActivity.kt b/app/src/main/java/com/example/cmake_project_test/MainActivity.kt new file mode 100644 index 0000000..251df89 --- /dev/null +++ b/app/src/main/java/com/example/cmake_project_test/MainActivity.kt @@ -0,0 +1,335 @@ +package com.example.cmake_project_test + +import type.SensorData +import androidx.appcompat.app.AppCompatActivity +import android.os.Bundle +import android.util.Log +import com.example.cmake_project_test.databinding.ActivityMainBinding +import java.io.InputStream +import java.io.ByteArrayOutputStream +import java.io.IOException +import java.util.concurrent.atomic.AtomicBoolean + +class MainActivity : AppCompatActivity() { + + private lateinit var binding: ActivityMainBinding + private var parserHandle: Long = 0L + private val rawStream = ByteArrayOutputStream(4096) + private val uiUpdatePending = AtomicBoolean(false) + private val packetBuffer = mutableListOf() + private var lastUpdateTime = 0L + private val UPDATE_INTERVAL = 500L // 每500毫秒更新一次UI + private var totalPacketsParsed = 0L // 总共解析的数据包数量 + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + + binding = ActivityMainBinding.inflate(layoutInflater) + setContentView(binding.root) + + // 初始化UI + binding.sampleText.text = "正在初始化..." + + // 设置按钮点击事件 + binding.btnReset.setOnClickListener { + resetData() + } + + binding.btnReload.setOnClickListener { + reloadData() + } + + // 在后台线程处理数据加载和解析 + Thread { + try { + // 从 assets 文件夹读取文件 + val fileData = readAssetFile("data1.dat") + + if (fileData != null) { + // 使用真实流式解析路径：按块喂数据 -> drain -> 展示 + ensureParser() + rawStream.reset() + val chunkSize = 64 + var offset = 0 + + while (offset < fileData.size) { + val n = minOf(chunkSize, fileData.size - offset) + val chunk = fileData.copyOfRange(offset, offset + n) + onBleNotify(chunk) // 复用同一流式路径 + offset += n + + // 添加小延迟，模拟真实蓝牙数据传输 + Thread.sleep(10) + } + + // 最后拉取所有剩余包 + val packets = streamParserDrainPackets(parserHandle) + if (!packets.isNullOrEmpty()) { + totalPacketsParsed += packets.size // 更新总计数 + packetBuffer.addAll(packets) + scheduleUiUpdate() + } + } else { + runOnUiThread { + binding.sampleText.text = "读取文件失败" + } + } + } catch (e: Exception) { + Log.e("MainActivity", "Error processing data", e) + runOnUiThread { + binding.sampleText.text = "错误: ${e.message}" + } + } + }.start() + } + + override fun onStart() { + super.onStart() + ensureParser() + } + + override fun onStop() { + super.onStop() + if (parserHandle != 0L) { + destroyStreamParser(parserHandle) + parserHandle = 0L + } + } + + private fun ensureParser() { + if (parserHandle == 0L) { + parserHandle = createStreamParser() + } + } + + // 蓝牙通知回调时调用：将 chunk 追加到解析器并拉取新包 + private fun onBleNotify(chunk: ByteArray) { + if (chunk.isEmpty()) return + ensureParser() + rawStream.write(chunk) + streamParserAppend(parserHandle, chunk) + + // 拉取解析出的数据包，但不立即更新UI + val packets = streamParserDrainPackets(parserHandle) + if (!packets.isNullOrEmpty()) { + totalPacketsParsed += packets.size // 更新总计数 + packetBuffer.addAll(packets) + scheduleUiUpdate() + } + } + + // 计划UI更新，避免频繁刷新 + private fun scheduleUiUpdate() { + val currentTime = System.currentTimeMillis() + if (currentTime - lastUpdateTime >= UPDATE_INTERVAL && uiUpdatePending.compareAndSet(false, true)) { + lastUpdateTime = currentTime + runOnUiThread { + updateUiWithBufferedPackets() + uiUpdatePending.set(false) + } + } + } + + // 使用缓冲的数据包更新UI + private fun updateUiWithBufferedPackets() { + if (packetBuffer.isEmpty()) return + + // 获取设备类型信息 + val deviceTypes = packetBuffer.mapNotNull { it.dataType }.distinct() + val deviceInfo = deviceTypes.joinToString(", ") { getDeviceName(it) } + + // 构建统计信息 + val stats = buildString { + append("=== 设备数据概览 ===\n") + append("当前缓冲区: ${packetBuffer.size} 个数据包\n") + append("总共解析: ${totalPacketsParsed} 个数据包\n") + append("设备类型: $deviceInfo\n") + append("总数据量: ${rawStream.size()} 字节\n\n") + } + + // 只显示最新的一些数据包详情 + val recentPackets = packetBuffer.takeLast(5) // 只显示最后5个包 + val has12Lead = recentPackets.any { it.dataType == SensorData.DataType.ECG_12LEAD } + val channelDetails = if (has12Lead) { + buildChannelDetails(recentPackets, maxPackets = 3, maxChannels = 6, maxSamples = 10) + } else { + buildChannelDetails(recentPackets, maxPackets = 3, maxChannels = 4, maxSamples = 10) + } + + // 更新UI + binding.sampleText.text = stats + channelDetails + + // 智能清理缓冲区：如果数据包数量过多，保留更多用于统计 + if (packetBuffer.size > 50) { + val keepCount = minOf(30, packetBuffer.size / 2) // 保留30个或一半，取较小值 + packetBuffer.subList(0, packetBuffer.size - keepCount).clear() + Log.d("MainActivity", "缓冲区已清理，保留 $keepCount 个数据包") + } + + // 添加调试信息：显示实际的数据包数量变化 + Log.d("MainActivity", "当前缓冲区数据包数量: ${packetBuffer.size}, 总共解析: $totalPacketsParsed") + } + + /** + * 根据数据类型获取设备名称 + */ + private fun getDeviceName(dataType: SensorData.DataType): String { + return when (dataType) { + SensorData.DataType.EEG -> "脑电设备" + SensorData.DataType.ECG_2LEAD -> "胸腹设备" + SensorData.DataType.PPG -> "血氧设备" + SensorData.DataType.ECG_12LEAD -> "12导联心电" + SensorData.DataType.STETHOSCOPE -> "数字听诊" + SensorData.DataType.SNORE -> "鼾声设备" + SensorData.DataType.RESPIRATION -> "呼吸/姿态" + SensorData.DataType.MIT_BIH -> "MIT-BIH" + else -> "未知设备" + } + } + + /** + * 从 assets 文件夹读取文件到字节数组 + */ + private fun readAssetFile(fileName: String): ByteArray? { + return try { + assets.open(fileName).use { inputStream -> + ByteArray(inputStream.available()).also { + inputStream.read(it) + } + } + } catch (e: IOException) { + Log.e("MainActivity", "Error reading asset file", e) + null + } + } + + /** + * 构建通道数据详情字符串 + */ + private fun buildChannelDetails(data: List, maxPackets: Int = 3, maxChannels: Int = 2, maxSamples: Int = 10): String { + if (data.isEmpty()) { + return "无通道数据" + } + + val details = mutableListOf() + + data.take(maxPackets).forEachIndexed { packetIndex, sensorData -> + if (sensorData.channelData.isNullOrEmpty()) { + details.add("数据包 ${packetIndex + 1}: 无通道数据") + return@forEachIndexed + } + + details.add("数据包 ${packetIndex + 1} (${getDeviceName(sensorData.dataType ?: SensorData.DataType.EEG)}):") + + sensorData.channelData.take(maxChannels).forEachIndexed { channelIndex, channel -> + // 只显示前几个采样点 + val sampleCount = minOf(maxSamples, channel.size) + val channelDataStr = channel.take(sampleCount).joinToString(", ") { "%.1f".format(it) } + + details.add(" 通道 ${channelIndex + 1}: ${sampleCount}/${channel.size} 采样点") + details.add(" 示例: $channelDataStr${if (channel.size > sampleCount) "..." else ""}") + } + + if (sensorData.channelData.size > maxChannels) { + details.add(" ... 还有 ${sensorData.channelData.size - maxChannels} 个通道") + } + + // 添加分隔线 + details.add("") + } + + if (data.size > maxPackets) { + details.add("... 还有 ${data.size - maxPackets} 个数据包") + } + + return details.joinToString("\n") + } + + /** + * A native method that is implemented by the 'cmake_project_test' native library, + * which is packaged with this application. + */ + external fun stringFromJNI(): String + external fun addFromJNI(a: Int, b: Int): Int + external fun parseDeviceDataFromJNI(fileData: ByteArray): List? + external fun createStreamParser(): Long + external fun destroyStreamParser(handle: Long) + external fun streamParserAppend(handle: Long, chunk: ByteArray) + external fun streamParserDrainPackets(handle: Long): List? + external fun parseStreamFromBytes(data: ByteArray, chunkSize: Int): List? + + /** + * 重置所有数据 + */ + private fun resetData() { + packetBuffer.clear() + rawStream.reset() + totalPacketsParsed = 0L // 重置总计数 + binding.sampleText.text = "数据已重置" + Log.d("MainActivity", "数据已重置，当前数据包数量: ${packetBuffer.size}, 总计数: $totalPacketsParsed") + } + + /** + * 重新加载数据 + */ + private fun reloadData() { + binding.sampleText.text = "正在重新加载数据..." + + // 重置解析器 + if (parserHandle != 0L) { + destroyStreamParser(parserHandle) + parserHandle = 0L + } + + // 清空缓冲区和重置计数 + packetBuffer.clear() + rawStream.reset() + totalPacketsParsed = 0L + + // 在后台线程重新加载数据 + Thread { + try { + val fileData = readAssetFile("data1.dat") + + if (fileData != null) { + ensureParser() + val chunkSize = 64 + var offset = 0 + + while (offset < fileData.size) { + val n = minOf(chunkSize, fileData.size - offset) + val chunk = fileData.copyOfRange(offset, offset + n) + onBleNotify(chunk) + offset += n + Thread.sleep(10) + } + + // 最后拉取所有剩余包 + val packets = streamParserDrainPackets(parserHandle) + if (!packets.isNullOrEmpty()) { + packetBuffer.addAll(packets) + scheduleUiUpdate() + } + + Log.d("MainActivity", "数据重新加载完成，当前数据包数量: ${packetBuffer.size}") + } else { + runOnUiThread { + binding.sampleText.text = "重新加载失败：文件读取失败" + } + } + } catch (e: Exception) { + Log.e("MainActivity", "Error reloading data", e) + runOnUiThread { + binding.sampleText.text = "重新加载错误: ${e.message}" + } + } + }.start() + } + + companion object { + // Used to load the 'cmake_project_test' library on application startup. + init { + System.loadLibrary("cmake_project_test") + } + } +} \ No newline at end of file diff --git a/app/src/main/java/type/SensorData$AdditionalData.class b/app/src/main/java/type/SensorData$AdditionalData.class new file mode 100644 index 0000000..7268e50 Binary files /dev/null and b/app/src/main/java/type/SensorData$AdditionalData.class differ diff --git a/app/src/main/java/type/SensorData$DataType.class b/app/src/main/java/type/SensorData$DataType.class new file mode 100644 index 0000000..1976257 Binary files /dev/null and b/app/src/main/java/type/SensorData$DataType.class differ diff --git a/app/src/main/java/type/SensorData.class b/app/src/main/java/type/SensorData.class new file mode 100644 index 0000000..2b550f0 Binary files /dev/null and b/app/src/main/java/type/SensorData.class differ diff --git a/app/src/main/java/type/SensorData.java b/app/src/main/java/type/SensorData.java new file mode 100644 index 0000000..d8a05ef --- /dev/null +++ b/app/src/main/java/type/SensorData.java @@ -0,0 +1,78 @@ +package type; +import java.util.List; + +public class SensorData { + public enum DataType { + EEG, ECG_2LEAD, PPG, ECG_12LEAD, MIT_BIH, STETHOSCOPE, SNORE, RESPIRATION + } + + public DataType dataType; + public int packetSn; + public byte[] leadStatus = new byte[2]; + public long timestamp; + public List> channelData; + public AdditionalData additionalData; + public byte[] rawData; + + // 构造函数 + public SensorData() { + this.additionalData = new AdditionalData(); + } + + // Getter和Setter方法 + public DataType getDataType() { return dataType; } + public void setDataType(DataType dataType) { this.dataType = dataType; } + + public int getPacketSn() { return packetSn; } + public void setPacketSn(int packetSn) { this.packetSn = packetSn; } + + public byte[] getLeadStatus() { return leadStatus; } + public void setLeadStatus(byte[] leadStatus) { this.leadStatus = leadStatus; } + + public long getTimestamp() { return timestamp; } + public void setTimestamp(long timestamp) { this.timestamp = timestamp; } + + public List> getChannelData() { return channelData; } + public void setChannelData(List> channelData) { this.channelData = channelData; } + + public AdditionalData getAdditionalData() { return additionalData; } + public void setAdditionalData(AdditionalData additionalData) { this.additionalData = additionalData; } + + public byte[] getRawData() { return rawData; } + public void setRawData(byte[] rawData) { this.rawData = rawData; } + + public static class AdditionalData { + public int hr; + public int spo2; + public float temperature; + public int gpioState; + public int movement; + public int posture; + public int ambientLight; + + // 构造函数 + public AdditionalData() {} + + // Getter和Setter方法 + public int getHr() { return hr; } + public void setHr(int hr) { this.hr = hr; } + + public int getSpo2() { return spo2; } + public void setSpo2(int spo2) { this.spo2 = spo2; } + + public float getTemperature() { return temperature; } + public void setTemperature(float temperature) { this.temperature = temperature; } + + public int getGpioState() { return gpioState; } + public void setGpioState(int gpioState) { this.gpioState = gpioState; } + + public int getMovement() { return movement; } + public void setMovement(int movement) { this.movement = movement; } + + public int getPosture() { return posture; } + public void setPosture(int posture) { this.posture = posture; } + + public int getAmbientLight() { return ambientLight; } + public void setAmbientLight(int ambientLight) { this.ambientLight = ambientLight; } + } +} 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 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml new file mode 100644 index 0000000..97e6cd4 --- /dev/null +++ b/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,50 @@ + + + + + +