在项目上经常要用到身份证阅读器、护照阅读仪、指纹仪等各种品牌硬件，假如每套系统的都做集成开发那代码的维护成本将变得很高，为此采用rust来调用厂家提供的sdk c++开发包并封装成nodejs包，用fastify来开发成web api独立的服务形式。这样我们开发系统时只需调用web接口即可，跨平台又可共用，方便快捷，话不多说来看代码如何实现。

一、创建项目

安装rust后，打开vs新建一个工程目录，我们通过cargo new创建的一个package项目，加上--lib参数后创建的项目就是库项目（library package）。

cargo new --lib reader

package 就是一个项目，因此它包含有独立的 Cargo.toml 文件，用于项目配置。库项目只能作为三方库被其它项目引用，而不能独立运行，即src/lib.rs。

典型的package

如果一个 package 同时拥有 src/main.rs 和 src/lib.rs，那就意味着它包含两个包：库包和二进制包，这两个包名也都是 test_math —— 都与 package 同名。

一个真实项目中典型的 package，会包含多个二进制包，这些包文件被放在 src/bin 目录下，每一个文件都是独立的二进制包，同时也会包含一个库包，该包只能存在一个 src/lib.rs：

.

├── Cargo.toml

├── Cargo.lock

├── src

│ ├── main.rs

│ ├── lib.rs

│ └── bin

│ └── main1.rs

│ └── main2.rs

├── tests

│ └── some_integration_tests.rs

├── benches

│ └── simple_bench.rs

└── examples

└── simple_example.rs

唯一库包：src/lib.rs

默认二进制包：src/main.rs，编译后生成的可执行文件与package同名

其余二进制包：src/bin/main1.rs 和 src/bin/main2.rs，它们会分别生成一个文件同名的二进制可执行文件

集成测试文件：tests 目录下

性能测试benchmark文件：benches 目录下

项目示例：examples 目录下

这种目录结构基本上是 Rust 的标准目录结构，在 github 的大多数项目上，你都将看到它的身影。

运行Cargo build命令，我们在target\debug目录下可以看到编译后的结果。

二、Cargo.toml

  1. [package]
  2. name = "reader"
  3. version = "0.1.0"
  4. edition = "2018"
  5. exclude = ["reader.node"]
  6. # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
  8. [dependencies]
  9. libc = "0.2.9"
  10. libloading = "0.7"
  11. once_cell = "1.8"
  12. serde = { version = "1.0", features = ["derive"] }
  13. widestring = "0.5.1"
  14. serde_json = "1.0"
  15. base64 = "0.13"
  16. hex="0.4.2"
  17. encoding = "0.2"
  18. tokio={version="1.18.0",features = ["full"]}
  20. [dependencies.neon]
  21. version = "0.9"
  22. default-features = false
  23. features = ["napi-5", "channel-api"]
  25. [lib]
  26. crate-type = ["cdylib"]

三、package.json

  1. {
  2.   "name": "reader",
  3.   "version": "0.1.0",
  4.   "description": "",
  5.   "main": "index.node",
  6.   "scripts": {
  7.     "build": "cargo-cp-artifact -nc index.node -- cargo build --message-format=json-render-diagnostics",
  8.     "build-debug": "npm run build --",
  9.     "build-release": "npm run build -- --release",
  10.     "build_win32": "npm run build -- --release --target=i686-pc-windows-msvc",
  11.     "test": "cargo test",
  12.     "run": "cargo run"
  13.   },
  14.   "author": "",
  15.   "license": "ISC",
  16.   "devDependencies": {
  17.     "cargo-cp-artifact": "^0.1"
  18.   },
  19.   "dependencies": {
  20.     "express": "^4.17.3"
  21.   }
  22. }

我们可以打印rust看看编译输出支持哪些架构

rustc --print target-list

//添加 x86编译链接器

rustup target add i686-pc-windows-msvc

四、代码分析

  1. use std::collections::HashMap;
  2. use std::str;
  3. use std::fmt::Write;
  4. use std::io::{Error};
  6. extern crate encoding;
  7. use encoding::all::GB18030;
  8. use encoding::{DecoderTrap,EncoderTrap,Encoding};
  10. use tokio::time::{sleep, Duration,Instant};
  11. use libc::{c_int, c_void};
  12. use libloading::{Library, Symbol};
  13. use neon::prelude::*;
  14. use once_cell::sync::OnceCell;
  15. use serde::{Deserialize, Serialize};
  17. use widestring::{WideCStr, WideCString, WideChar};
  18. // 编码转换 utf8 -> utf16le
  19. fn encode(source: &str) -> WideCString {
  20.     let string_source = source.to_string() + "\0";
  21.     WideCString::from_str(&string_source).unwrap()
  22. }
  23. // 解码转换 utf16le -> utf8
  24. fn decode(source: &[WideChar]) -> String {
  25.     WideCStr::from_slice_truncate(source)
  26.         .unwrap()
  27.         .to_string()
  28.         .unwrap()
  29. }
  30. // 加载 dll
  31. static LIBRARY: OnceCell<Library> = OnceCell::new();
  33. //指定编译架构
  34. static MACHINE_KIND: &str = if cfg!(target_os = "windows") {
  35.     if cfg!(target_arch = "x86") {
  36.         "win32"
  37.     } else if cfg!(target_arch = "x86_x64") {
  38.         "win64"
  39.     } else {
  40.         "other"
  41.     }
  42. } else if cfg!(target_os = "linux") {
  43.     if cfg!(target_arch = "x86") {
  44.         "linux32"
  45.     } else if cfg!(target_arch = "x86_64") {
  46.         "linux64"
  47.     } else if cfg!(target_arch = "aarch64") {
  48.         "aarch64"
  49.     } else if cfg!(target_arch = "arm") {
  50.         "arm"
  51.     } else {
  52.         "other"
  53.     }
  54. } else {
  55.     "other"
  56. };
  1. //定义函数方法名，这里要根据c++库的函数名和参数来定义，函数名和参数类型务必要一致。
  2. type LPCTSTR = *const WideChar;
  3. type BOOL = c_int;
  4. type INITPTR = *const i8;
  5. type CANRST = *mut WideChar;
  7. // 打开设备
  8. type S2V7_open = unsafe extern "system" fn() -> c_int;
  9. // 关闭设备
  10. type S2V7_close = unsafe extern "system" fn() -> c_int;
  12.  //【set mode  设置读证功能】
  13. type S2V7_set_mode =
  14.     unsafe extern "system" fn(flg_takeColor: c_int, flg_takeUV: c_int, flg_readChipInfo: c_int, flg_readChipFace: c_int) -> c_int; // Type = 0 即可
  16. //【wait Doc. in 等待放卡】
  17. type S2V7_wait_DocIn =
  18. unsafe extern "system" fn(timeout: f64, flg_in: INITPTR) -> c_int; // Type = 0 即可
  20. //【wait Doc. out 等待拿卡】
  21. type S2V7_wait_DocOut =
  22. unsafe extern "system" fn(timeout: f64, flg_out: INITPTR) -> c_int; // Type = 0 即可
  24.  //【process  执行读卡过程】
  25. type S2V7_process = unsafe extern "system" fn() -> c_int;
  27.  //读取卡类型
  28. type S2V7_get_cardType = unsafe extern "system" fn() -> c_int;
  30. //保存彩照
  31. type S2V7_VIS_saveColor = unsafe extern "system" fn(imgPath: LPCTSTR) -> c_int;
  32. //保存红外照
  33. type S2V7_VIS_saveIR = unsafe extern "system" fn(imgPath: LPCTSTR) -> c_int;
  35. //【get MRZ text 获取OCR文字信息】
  36. type S2V7_VIS_getMRZtext = unsafe extern "system" fn(text: LPCTSTR) -> c_int;
  38. //show text information  文字信息
  39. type S2V7_RDO_getBytesByIndex = unsafe extern "system" fn(index: c_int,data: LPCTSTR) -> c_int;
  40. type S2V7_VIS_getBytesByIndex = unsafe extern "system" fn(index: c_int,data: LPCTSTR) -> c_int;
  42. type S2V7_RF_active = unsafe extern "system" fn(antenna: c_int,atr: LPCTSTR, atr_len: c_int) -> c_int;
  44. //构建函数实例
  45. static V7_OPEN: OnceCell<Symbol<S2V7_open>> = OnceCell::new();
  46. static V7_CLOSE: OnceCell<Symbol<S2V7_close>> = OnceCell::new();
  47. static V7_SET_MODE: OnceCell<Symbol<S2V7_set_mode>> = OnceCell::new();
  48. static V7_WAIT_DOCINT: OnceCell<Symbol<S2V7_wait_DocIn>> = OnceCell::new();
  49. static V7_WAIT_DOCOUT: OnceCell<Symbol<S2V7_wait_DocOut>> = OnceCell::new();
  50. static V7_PROCESS: OnceCell<Symbol<S2V7_process>> = OnceCell::new();
  51. static V7_GET_CARDTYPE: OnceCell<Symbol<S2V7_get_cardType>> = OnceCell::new();
  52. static V7_VIS_SAVECOLOR: OnceCell<Symbol<S2V7_VIS_saveColor>> = OnceCell::new();
  53. static V7_VIS_SAVEIR: OnceCell<Symbol<S2V7_VIS_saveIR>> = OnceCell::new();
  54. static V7_VIS_GETMRZTEXT: OnceCell<Symbol<S2V7_VIS_getMRZtext>> = OnceCell::new();
  55. static V7_RDO_getBytesByIndex: OnceCell<Symbol<S2V7_RDO_getBytesByIndex>> = OnceCell::new();
  56. static V7_VIS_getBytesByIndex: OnceCell<Symbol<S2V7_VIS_getBytesByIndex>> = OnceCell::new();
  57. static V7_RF_active: OnceCell<Symbol<S2V7_RF_active>> = OnceCell::new();
  1. // 对外导出函数方法
  2. #[neon::main]
  3. fn main(mut cx: ModuleContext) -> NeonResult<()> {
  4.     cx.export_function("init", init_by_node)?;
  5.     cx.export_function("start", start)?;
  6. }
  8. //加载dll并对函数进行初始化操作
  9. pub fn init_by_node(mut cx: FunctionContext) -> JsResult<JsNumber> {
  10. 	//外部传进来的参数（根据自己的需要来定义）
  11.     let directory = cx.argument::<JsString>(0)?.value(&mut cx);
  12.     let userid = cx.argument::<JsString>(1)?.value(&mut cx);
  13.     unsafe {
  14.         DIRECTORY_PATH.take();
  15.         DIRECTORY_PATH.set(directory).unwrap();
  16.         USER_ID.take();
  17.         USER_ID.set(userid).unwrap();
  18.     };
  19.     let result = init() as f64;
  20.     Ok(cx.number(result))
  21. }
  23. //核心代码，加载dll函数并映射
  24. fn init() -> c_int {
  25.     let directory = unsafe { DIRECTORY_PATH.get().unwrap() };
  26.     let userid = unsafe { USER_ID.get().unwrap() };
  27.     let directory_path = std::path::Path::new(directory).join(MACHINE_KIND);
  28.     if directory_path.exists() {
  29.         let dll_path = directory_path.join(libloading::library_filename("STAR200_V7_DRV"));
  30.         println!("dll_path: {:?}", dll_path);
  31.         if dll_path.exists() {
  32.             match init_dll(dll_path.to_str().unwrap()).is_ok() {
  33.                 true => {
  34.                     // 打开设备
  35.                     let init_result = unsafe {V7_OPEN.get_unchecked()()};
  36.                     if init_result == 0 {
  37.                         println!("设备打开成功");
  38.                         return ResultType::Success as c_int;
  39.                     } else {
  40.                         println!("设备打开失败，代码：{:?}",init_result);
  41.                         return ResultType::DeviceNotFound as c_int;
  42.                     }
  43.                 }
  44.                 false => {
  45.                     return ResultType::INITDLLFail as c_int;
  46.                 }
  47.             }
  48.         } else {
  49.             return ResultType::DllPathNotExist as c_int;
  50.         }
  51.     } else {
  52.         println!("{:?}", directory_path);
  53.         return ResultType::DirectoryPathNotExist as c_int;
  54.     }
  55. }
  57. // 加载dll
  58. fn init_dll(dll_path: &str) -> Result<bool, Box<dyn std::error::Error>> {
  59.     unsafe {
  60.         if INITDLL {
  61.             return Ok(true);
  62.         }
  63.     }
  64.     println!("加载dll");
  65.     println!("dll_path");
  66.     let library = LIBRARY.get_or_init(|| unsafe { Library::new(dll_path).unwrap() });
  67.     println!("S2V7_open");
  68.     V7_OPEN.get_or_init(|| unsafe { library.get::<S2V7_open>(b"S2V7_open").unwrap() });
  69.     println!("S2V7_close");
  70.     V7_CLOSE.get_or_init(|| unsafe { library.get::<S2V7_close>(b"S2V7_close").unwrap() });
  71.     println!("S2V7_set_mode");
  72.     V7_SET_MODE.get_or_init(|| unsafe {library.get::<S2V7_set_mode>(b"S2V7_set_mode").unwrap()});
  73.     println!("S2V7_wait_DocIn");
  74.     V7_WAIT_DOCINT.get_or_init(|| unsafe { library.get::<S2V7_wait_DocIn>(b"S2V7_wait_DocIn").unwrap() });
  75.     println!("S2V7_wait_DocOut");
  76.     V7_WAIT_DOCOUT.get_or_init(|| unsafe { library.get::<S2V7_wait_DocOut>(b"S2V7_wait_DocOut").unwrap() });
  77.     V7_PROCESS.get_or_init(|| unsafe { library.get::<S2V7_process>(b"S2V7_process").unwrap() });
  78.     V7_GET_CARDTYPE.get_or_init(|| unsafe { library.get::<S2V7_get_cardType>(b"S2V7_get_cardType").unwrap() });
  79.     V7_VIS_SAVECOLOR.get_or_init(|| unsafe { library.get::<S2V7_VIS_saveColor>(b"S2V7_VIS_saveColor").unwrap() });
  80.     V7_VIS_SAVEIR.get_or_init(|| unsafe { library.get::<S2V7_VIS_saveIR>(b"S2V7_VIS_saveIR").unwrap() });
  81.     V7_VIS_GETMRZTEXT.get_or_init(|| unsafe { library.get::<S2V7_VIS_getMRZtext>(b"S2V7_VIS_getMRZtext").unwrap() });
  82.     V7_RDO_getBytesByIndex.get_or_init(|| unsafe { library.get::<S2V7_RDO_getBytesByIndex>(b"S2V7_RDO_getBytesByIndex").unwrap() });
  83.     V7_VIS_getBytesByIndex.get_or_init(|| unsafe { library.get::<S2V7_VIS_getBytesByIndex>(b"S2V7_VIS_getBytesByIndex").unwrap() });
  84.     V7_RF_active.get_or_init(|| unsafe { library.get::<S2V7_RF_active>(b"S2V7_RF_active").unwrap() });
  86.     unsafe {
  87.         INITDLL = true;
  88.     }
  89.     Ok(true)
  90. }
  1. //创建新线程来监测设备读证操作
  2. fn start(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  3.     let callback = cx.argument::<JsFunction>(0)?.root(&mut cx);
  4.     let mut channel = cx.channel();
  5.     channel.reference(&mut cx);
  6.     println!("start {}", channel.has_ref());
  7.     let index = unsafe {
  8.         DEVICE_START_INDEX += 1;
  9.         DEVICE_START_INDEX
  10.     };
  11.     std::thread::spawn(move || {
  12.         // Do the heavy lifting inside the background thread.
  13.         device_start(callback, channel, index);
  14.     });
  15.     Ok(cx.undefined())
  16. }
  18. use std::sync::{Arc, Mutex};
  19. fn device_start(callback: Root<JsFunction>, channel: Channel, index: u64) {
  20.     let index = index;
  21.     let callback = Arc::new(Mutex::new(callback));
  23.     //设置读证功能
  24.     unsafe { V7_SET_MODE.get_unchecked()(1,1,1,1) };
  26.     loop {
  27.         if index != unsafe { DEVICE_START_INDEX } {
  28.             break;
  29.         };
  30.         let callback_clone = Arc::clone(&callback);
  31.         let mut result = RecogIDCardEXResult::default();
  32.         let mut flg_in:i8=0;
  33.         match unsafe { V7_WAIT_DOCINT.get_unchecked()(5.0,&mut flg_in) } {
  34.             // 设备正常 检测是否有放入证件
  35.             0 => {
  36.                 if flg_in==0{
  37.                     //检查是否放入超时
  38.                     result.record_type = ResultType::CheckCardNotInOrOut as i32;
  39.                     break;
  40.                 }
  41.                 result.device_online = true;
  42.                 result.device_name =unsafe { DEVCIE_NAME.get_or_init(|| "".to_string()).to_string() };
  44.                 match unsafe { V7_PROCESS.get_unchecked()() } {
  45.                     // 证件有放入
  46.                     0 => {
  47.                         result.record_type = ResultType::CheckCardInput as i32;
  48.                     }
  49.                     // 未检测到OCR区域
  50.                     -1 => {
  51.                         result.record_type = ResultType::OCRFail as i32;
  52.                     }
  53.                     // 设备离线
  54.                     -3 => {
  55.                         result.device_online = false;
  56.                         result.record_type = init();
  57.                     }
  58.                     _ => {
  59.                         result.record_type = ResultType::Unknown as i32;
  60.                     }
  61.                 }
  63.             }
  64.             -3 => {
  65.                 //设备离线
  66.                 let init = init();
  67.                 result.device_online = false;
  68.                 result.record_type = init;
  69.             }
  70.             _ => {
  71.                 //未知错误
  72.                 result.record_type = ResultType::Unknown as i32;
  73.             }
  74.         };
  76.         if unsafe { *NEED_RECORD.get_or_init(|| false) } {
  77.             println!("手工点击识别+1");
  78.             result.record_type = ResultType::CheckCardInput as i32;
  79.         } 
  81.         // let time_now = std::time::Instant::now();
  82.         if result.record_type == ResultType::CheckCardInput as i32 {
  83.             let _result = recog_card();
  84.             result.success = _result.success;
  85.             result.img_base64 = _result.img_base64;
  86.             result.reg_info = _result.reg_info;
  87.             result.card_type = _result.card_type;
  88.             result.card_name = _result.card_name;
  89.         }
  90.         let neet_sendinfo = if Some(true) == unsafe { NEED_RECORD.take() } {
  91.             true
  92.         } else {
  93.             false
  94.         };
  96.         // let elapsed = time_now.elapsed();
  97.         // println!("识别时间结束时间 {:.6?}", elapsed);
  98.         if result.record_type != ResultType::CheckCardNotInOrOut as i32
  99.             && (*unsafe { RESULT_TYPE.get_or_init(|| -10000) } != result.record_type
  100.                 || result.record_type == ResultType::CheckCardInput as i32
  101.                 || neet_sendinfo)
  102.         {
  103.             unsafe {
  104.                 RESULT_TYPE.take();
  105.                 RESULT_TYPE.set(result.record_type).unwrap();
  106.             }
  107.             channel.send(move |mut cx| {
  108.                 let result_json = serde_json::to_string(&result).unwrap();
  109.                 let callback = callback_clone.lock().unwrap().to_inner(&mut cx);
  110.                 let this = cx.undefined();
  111.                 let args = vec![cx.string(&result_json)];
  112.                 callback.call(&mut cx, this, args)?;
  113.                 Ok(())
  114.             });
  115.         }
  116.         std::thread::sleep(std::time::Duration::from_millis(20));
  117.     }
  118. }

完整源码

点击查看代码 
  1. use std::collections::HashMap;
  3. use libc::{c_int, c_void};
  4. use libloading::{Library, Symbol};
  5. use neon::prelude::*;
  6. use once_cell::sync::OnceCell;
  7. use serde::Serialize;
  9. extern crate encoding;
  10. use encoding::all::GB18030;
  11. use encoding::{DecoderTrap,EncoderTrap,Encoding};
  13. use widestring::{WideCStr, WideCString, WideChar};
  14. // 编码转换 utf8 -> utf16le
  15. fn encode(source: &str) -> WideCString {
  16.     let string_source = source.to_string() + "\0";
  17.     WideCString::from_str(&string_source).unwrap()
  18. }
  19. // 解码转换 utf16le -> utf8
  20. fn decode(source: &[WideChar]) -> String {
  21.     WideCStr::from_slice_truncate(source)
  22.         .unwrap()
  23.         .to_string()
  24.         .unwrap()
  25. }
  26. // 加载 dll
  27. static LIBRARY: OnceCell<Library> = OnceCell::new();
  29. static MACHINE_KIND: &str = if cfg!(target_os = "windows") {
  30.     if cfg!(target_arch = "x86") {
  31.         "win32"
  32.     } else if cfg!(target_arch = "x86_x64") {
  33.         "win64"
  34.     } else {
  35.         "other"
  36.     }
  37. } else if cfg!(target_os = "linux") {
  38.     if cfg!(target_arch = "x86") {
  39.         "linux32"
  40.     } else if cfg!(target_arch = "x86_64") {
  41.         "linux64"
  42.     } else if cfg!(target_arch = "aarch64") {
  43.         "aarch64"
  44.     } else if cfg!(target_arch = "arm") {
  45.         "arm"
  46.     } else {
  47.         "other"
  48.     }
  49. } else {
  50.     "other"
  51. };
  53. //设置识别的证件 ID
  54. // 设置当前要识别的证件类型，并将
  55. // 之前已经设置的证件类型清除。
  56. // nMainID 主要识别类型，nSubID 子类型
  57. //  nSubID 头指针，默认将数组
  58. // nSubID 第 一 个 元 素 赋 值 为 0 即
  59. // nSubID[0]=0
  60. // type S = c_int[];
  62. type LPCTSTR = *const WideChar;
  63. type BOOL = c_int;
  64. type INITPTR = *const i8;
  65. type CANRST = *mut WideChar;
  67. // 打开设备
  68. type S2V7_open = unsafe extern "system" fn() -> c_int;
  69. // 关闭设备
  70. type S2V7_close = unsafe extern "system" fn() -> c_int;
  72.  //【set mode  设置读证功能】
  73. type S2V7_set_mode =
  74.     unsafe extern "system" fn(flg_takeColor: c_int, flg_takeUV: c_int, flg_readChipInfo: c_int, flg_readChipFace: c_int) -> c_int; // Type = 0 即可
  76. //【wait Doc. in 等待放卡】
  77. type S2V7_wait_DocIn =
  78. unsafe extern "system" fn(timeout: f64, flg_in: INITPTR) -> c_int; // Type = 0 即可
  80. //【wait Doc. out 等待拿卡】
  81. type S2V7_wait_DocOut =
  82. unsafe extern "system" fn(timeout: f64, flg_out: INITPTR) -> c_int; // Type = 0 即可
  84.  //【process  执行读卡过程】
  85. type S2V7_process = unsafe extern "system" fn() -> c_int;
  87.  //读取卡类型
  88. type S2V7_get_cardType = unsafe extern "system" fn() -> c_int;
  90. //保存彩照
  91. type S2V7_VIS_saveColor = unsafe extern "system" fn(imgPath: LPCTSTR) -> c_int;
  92. //保存红外照
  93. type S2V7_VIS_saveIR = unsafe extern "system" fn(imgPath: LPCTSTR) -> c_int;
  95. //【get MRZ text 获取OCR文字信息】
  96. type S2V7_VIS_getMRZtext = unsafe extern "system" fn(text: LPCTSTR) -> c_int;
  98. //show text information  文字信息
  99. type S2V7_RDO_getBytesByIndex = unsafe extern "system" fn(index: c_int,data: LPCTSTR) -> c_int;
  100. type S2V7_VIS_getBytesByIndex = unsafe extern "system" fn(index: c_int,data: LPCTSTR) -> c_int;
  102. type S2V7_RF_active = unsafe extern "system" fn(antenna: c_int,atr: LPCTSTR, atr_len: c_int) -> c_int;
  104. static V7_OPEN: OnceCell<Symbol<S2V7_open>> = OnceCell::new();
  105. static V7_CLOSE: OnceCell<Symbol<S2V7_close>> = OnceCell::new();
  106. static V7_SET_MODE: OnceCell<Symbol<S2V7_set_mode>> = OnceCell::new();
  107. static V7_WAIT_DOCINT: OnceCell<Symbol<S2V7_wait_DocIn>> = OnceCell::new();
  108. static V7_WAIT_DOCOUT: OnceCell<Symbol<S2V7_wait_DocOut>> = OnceCell::new();
  109. static V7_PROCESS: OnceCell<Symbol<S2V7_process>> = OnceCell::new();
  110. static V7_GET_CARDTYPE: OnceCell<Symbol<S2V7_get_cardType>> = OnceCell::new();
  111. static V7_VIS_SAVECOLOR: OnceCell<Symbol<S2V7_VIS_saveColor>> = OnceCell::new();
  112. static V7_VIS_SAVEIR: OnceCell<Symbol<S2V7_VIS_saveIR>> = OnceCell::new();
  113. static V7_VIS_GETMRZTEXT: OnceCell<Symbol<S2V7_VIS_getMRZtext>> = OnceCell::new();
  114. static V7_RDO_getBytesByIndex: OnceCell<Symbol<S2V7_RDO_getBytesByIndex>> = OnceCell::new();
  115. static V7_VIS_getBytesByIndex: OnceCell<Symbol<S2V7_VIS_getBytesByIndex>> = OnceCell::new();
  116. static V7_RF_active: OnceCell<Symbol<S2V7_RF_active>> = OnceCell::new();
  118. // static
  119. static mut INITDLL: bool = false;
  120. static mut DEVICE_START_INDEX: u64 = 0;
  121. static mut DIRECTORY_PATH: OnceCell<String> = OnceCell::new();
  122. static mut USER_ID: OnceCell<String> = OnceCell::new();
  123. static mut DEVCIE_NAME: OnceCell<String> = OnceCell::new();
  124. static mut RESULT_TYPE: OnceCell<i32> = OnceCell::new();
  125. static mut NEED_RECORD: OnceCell<bool> = OnceCell::new();
  126. // 初始化dll
  127. fn init_dll(dll_path: &str) -> Result<bool, Box<dyn std::error::Error>> {
  128.     unsafe {
  129.         if INITDLL {
  130.             return Ok(true);
  131.         }
  132.     }
  133.     println!("加载dll");
  134.     println!("dll_path");
  135.     let library = LIBRARY.get_or_init(|| unsafe { Library::new(dll_path).unwrap() });
  136.     println!("S2V7_open");
  137.     V7_OPEN.get_or_init(|| unsafe { library.get::<S2V7_open>(b"S2V7_open").unwrap() });
  138.     println!("S2V7_close");
  139.     V7_CLOSE.get_or_init(|| unsafe { library.get::<S2V7_close>(b"S2V7_close").unwrap() });
  140.     println!("S2V7_set_mode");
  141.     V7_SET_MODE.get_or_init(|| unsafe {library.get::<S2V7_set_mode>(b"S2V7_set_mode").unwrap()});
  142.     println!("S2V7_wait_DocIn");
  143.     V7_WAIT_DOCINT.get_or_init(|| unsafe { library.get::<S2V7_wait_DocIn>(b"S2V7_wait_DocIn").unwrap() });
  144.     println!("S2V7_wait_DocOut");
  145.     V7_WAIT_DOCOUT.get_or_init(|| unsafe { library.get::<S2V7_wait_DocOut>(b"S2V7_wait_DocOut").unwrap() });
  146.     V7_PROCESS.get_or_init(|| unsafe { library.get::<S2V7_process>(b"S2V7_process").unwrap() });
  147.     V7_GET_CARDTYPE.get_or_init(|| unsafe { library.get::<S2V7_get_cardType>(b"S2V7_get_cardType").unwrap() });
  148.     V7_VIS_SAVECOLOR.get_or_init(|| unsafe { library.get::<S2V7_VIS_saveColor>(b"S2V7_VIS_saveColor").unwrap() });
  149.     V7_VIS_SAVEIR.get_or_init(|| unsafe { library.get::<S2V7_VIS_saveIR>(b"S2V7_VIS_saveIR").unwrap() });
  150.     V7_VIS_GETMRZTEXT.get_or_init(|| unsafe { library.get::<S2V7_VIS_getMRZtext>(b"S2V7_VIS_getMRZtext").unwrap() });
  151.     V7_RDO_getBytesByIndex.get_or_init(|| unsafe { library.get::<S2V7_RDO_getBytesByIndex>(b"S2V7_RDO_getBytesByIndex").unwrap() });
  152.     V7_VIS_getBytesByIndex.get_or_init(|| unsafe { library.get::<S2V7_VIS_getBytesByIndex>(b"S2V7_VIS_getBytesByIndex").unwrap() });
  153.     V7_RF_active.get_or_init(|| unsafe { library.get::<S2V7_RF_active>(b"S2V7_RF_active").unwrap() });
  155.     unsafe {
  156.         INITDLL = true;
  157.     }
  158.     Ok(true)
  159. }
  160. fn init() -> c_int {
  161.     let directory = unsafe { DIRECTORY_PATH.get().unwrap() };
  162.     let userid = unsafe { USER_ID.get().unwrap() };
  163.     let directory_path = std::path::Path::new(directory).join(MACHINE_KIND);
  164.     if directory_path.exists() {
  165.         let dll_path = directory_path.join(libloading::library_filename("STAR200_V7_DRV"));
  166.         println!("dll_path: {:?}", dll_path);
  167.         if dll_path.exists() {
  168.             match init_dll(dll_path.to_str().unwrap()).is_ok() {
  169.                 true => {
  170.                     // 打开设备
  171.                     let init_result = unsafe {V7_OPEN.get_unchecked()()};
  172.                     if init_result == 0 {
  173.                         println!("设备打开成功");
  174.                         return ResultType::Success as c_int;
  175.                     } else {
  176.                         println!("设备打开失败，代码：{:?}",init_result);
  177.                         return ResultType::DeviceNotFound as c_int;
  178.                     }
  179.                 }
  180.                 false => {
  181.                     return ResultType::INITDLLFail as c_int;
  182.                 }
  183.             }
  184.         } else {
  185.             return ResultType::DllPathNotExist as c_int;
  186.         }
  187.     } else {
  188.         println!("{:?}", directory_path);
  189.         return ResultType::DirectoryPathNotExist as c_int;
  190.     }
  191. }
  192. pub fn init_by_node(mut cx: FunctionContext) -> JsResult<JsNumber> {
  193.     let directory = cx.argument::<JsString>(0)?.value(&mut cx);
  194.     let userid = cx.argument::<JsString>(1)?.value(&mut cx);
  195.     unsafe {
  196.         DIRECTORY_PATH.take();
  197.         DIRECTORY_PATH.set(directory).unwrap();
  198.         USER_ID.take();
  199.         USER_ID.set(userid).unwrap();
  200.     };
  201.     let result = init() as f64;
  202.     Ok(cx.number(result))
  203. }
  204. #[allow(dead_code)] // 允许dead_code
  205. enum ResultType {
  206.     DirectoryPathNotExist = -2003, // 找不到运行目录
  207.     DllPathNotExist = -2001,       // 找不到dll文件
  208.     INITDLLFail = -2000,           // 初始化dll
  209.     Success = 0,                   // 成功
  210.     UserIdFail = 2001,             //用户 ID 错误
  211.     DeviceInitFail = 2002,         //  设备初始化失败
  212.     DeviceKernelInitFail = 2003,   // 初始化核心失败
  213.     DeviceDatInitFail = 2004,      //未找到授权文件
  214.     DeviceNotInit = 2101,          // 设备未初始化
  215.     DeviceNotFound = 2102,         // 没有找到设备
  216.     DeviceReConnect = 2103,        // 重新连接设备
  217.     Unknown = -100,                // 未知错误
  218.     CheckCardInput = 3001,         // 证件放入设备
  219.     CheckCardOut = 3002,           // 证件移出设备
  220.     CheckCardNotInOrOut = 3000,    // 证件无放入或拿出
  221.     CheckCardBarCode = 3003,       // 检测到手机条码
  222.     OCRFail=-1,                    // 未检测到OCR区域
  223. }
  225. type RecogIDCardEXResultItem = HashMap<i32, [String; 2]>;
  226. #[derive(Default, Serialize)]
  227. pub struct RecogIDCardEXResultObject {
  228.     pub viz_result: RecogIDCardEXResultItem,
  229.     pub viz_orc_result: RecogIDCardEXResultItem,
  230.     pub mrz_result: RecogIDCardEXResultItem,
  231.     pub mrz_ocr_result: RecogIDCardEXResultItem,
  232.     pub chip_result: RecogIDCardEXResultItem,
  233. }
  235. #[derive(Default, Serialize)]
  236. pub struct RecogIDCardEXResult {
  237.     pub device_name: String,
  238.     pub device_online: bool,
  239.     pub reg_info: RecogIDCardEXResultObject,
  240.     pub img_base64: HashMap<String, String>,
  241.     pub card_type: i32,
  242.     pub record_type: i32,
  243.     pub card_name: String,
  244.     pub success: bool, // 识别是否成功
  245. }
  247. static SAVE_IMAGE_REUSLT_NAME: [&str; 5] = [
  248.     "tempHeadEC.jpg",
  249.     "tempHead.jpg",
  250.     "tempUV.jpg",
  251.     "tempIR.jpg",
  252.     "temp.jpg",
  253. ];
  255. fn start(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  256.     let callback = cx.argument::<JsFunction>(0)?.root(&mut cx);
  257.     let mut channel = cx.channel();
  258.     channel.reference(&mut cx);
  259.     println!("start {}", channel.has_ref());
  260.     let index = unsafe {
  261.         DEVICE_START_INDEX += 1;
  262.         DEVICE_START_INDEX
  263.     };
  264.     std::thread::spawn(move || {
  265.         // Do the heavy lifting inside the background thread.
  266.         device_start(callback, channel, index);
  267.     });
  268.     Ok(cx.undefined())
  269. }
  271. use std::sync::{Arc, Mutex};
  272. fn device_start(callback: Root<JsFunction>, channel: Channel, index: u64) {
  273.     let index = index;
  274.     let callback = Arc::new(Mutex::new(callback));
  276.     //设置读证功能
  277.     unsafe { V7_SET_MODE.get_unchecked()(1,1,1,1) };
  279.     loop {
  280.         if index != unsafe { DEVICE_START_INDEX } {
  281.             break;
  282.         };
  283.         let callback_clone = Arc::clone(&callback);
  284.         let mut result = RecogIDCardEXResult::default();
  285.         let mut flg_in:i8=0;
  286.         match unsafe { V7_WAIT_DOCINT.get_unchecked()(5.0,&mut flg_in) } {
  287.             // 设备正常 检测是否有放入证件
  288.             0 => {
  289.                 if flg_in==0{
  290.                     //检查是否放入超时
  291.                     result.record_type = ResultType::CheckCardNotInOrOut as i32;
  292.                     break;
  293.                 }
  294.                 result.device_online = true;
  295.                 result.device_name =unsafe { DEVCIE_NAME.get_or_init(|| "".to_string()).to_string() };
  297.                 match unsafe { V7_PROCESS.get_unchecked()() } {
  298.                     // 证件有放入
  299.                     0 => {
  300.                         result.record_type = ResultType::CheckCardInput as i32;
  301.                     }
  302.                     // 未检测到OCR区域
  303.                     -1 => {
  304.                         result.record_type = ResultType::OCRFail as i32;
  305.                     }
  306.                     // 未找到非接卡
  307.                     // v if v/10 == -21 => {
  308.                     //     result.record_type = ResultType::OCRFail as i32;
  309.                     // }
  310.                     // 设备离线
  311.                     -3 => {
  312.                         result.device_online = false;
  313.                         result.record_type = init();
  314.                     }
  315.                     _ => {
  316.                         result.record_type = ResultType::Unknown as i32;
  317.                     }
  318.                 }
  320.             }
  321.             -3 => {
  322.                 //设备离线
  323.                 let init = init();
  324.                 result.device_online = false;
  325.                 result.record_type = init;
  326.             }
  327.             _ => {
  328.                 //未知错误
  329.                 result.record_type = ResultType::Unknown as i32;
  330.             }
  331.         };
  333.         if unsafe { *NEED_RECORD.get_or_init(|| false) } {
  334.             println!("手工点击识别+1");
  335.             result.record_type = ResultType::CheckCardInput as i32;
  336.         } 
  338.         // let time_now = std::time::Instant::now();
  339.         if result.record_type == ResultType::CheckCardInput as i32 {
  340.             let _result = recog_card();
  341.             result.success = _result.success;
  342.             result.img_base64 = _result.img_base64;
  343.             result.reg_info = _result.reg_info;
  344.             result.card_type = _result.card_type;
  345.             result.card_name = _result.card_name;
  346.         }
  347.         let neet_sendinfo = if Some(true) == unsafe { NEED_RECORD.take() } {
  348.             true
  349.         } else {
  350.             false
  351.         };
  353.         // let elapsed = time_now.elapsed();
  354.         // println!("识别时间结束时间 {:.6?}", elapsed);
  355.         if result.record_type != ResultType::CheckCardNotInOrOut as i32
  356.             && (*unsafe { RESULT_TYPE.get_or_init(|| -10000) } != result.record_type
  357.                 || result.record_type == ResultType::CheckCardInput as i32
  358.                 || neet_sendinfo)
  359.         {
  360.             unsafe {
  361.                 RESULT_TYPE.take();
  362.                 RESULT_TYPE.set(result.record_type).unwrap();
  363.             }
  364.             channel.send(move |mut cx| {
  365.                 let result_json = serde_json::to_string(&result).unwrap();
  366.                 let callback = callback_clone.lock().unwrap().to_inner(&mut cx);
  367.                 let this = cx.undefined();
  368.                 let args = vec![cx.string(&result_json)];
  369.                 callback.call(&mut cx, this, args)?;
  370.                 Ok(())
  371.             });
  372.         }
  373.         std::thread::sleep(std::time::Duration::from_millis(20));
  374.     }
  375. }
  377. // 白光图、红外
  378. // 图、紫外图、版面头像和芯片头像
  379. pub fn recog_card() -> RecogIDCardEXResult {
  380.     let time_now = std::time::Instant::now();
  381.     let mut result = RecogIDCardEXResult::default();
  382.     result.device_online = true;
  384.     let img_path_directory = std::path::Path::new(unsafe { DIRECTORY_PATH.get().unwrap() });
  386.     let ir_img_path = img_path_directory.join("ir.jpg");
  387.     let color_img_path = img_path_directory.join("color.jpg");
  389.     //显示红外照
  390.     let irResult = unsafe {V7_VIS_SAVEIR.get_unchecked()(encode(ir_img_path.to_str().unwrap()).as_ptr() as LPCTSTR)};
  391.     //显示彩照
  392.     let colorResult = unsafe {V7_VIS_SAVECOLOR.get_unchecked()(encode(color_img_path.to_str().unwrap()).as_ptr() as LPCTSTR)};
  394.     if irResult==0{
  395.         if ir_img_path.exists() {
  396.             match std::fs::read(&ir_img_path) {
  397.                 Ok(image_data) => {
  398.                     println!("读取照片成功");
  399.                     let image_data = base64::encode(&image_data);
  400.                     let base64_string = String::from("data:image/jpg;base64,");
  401.                     std::fs::remove_file(ir_img_path).unwrap();
  402.                     result.img_base64.insert("0".to_string(), base64_string + &image_data);
  403.                 }
  404.                 Err(e) => {
  405.                     println!("读取照片抛异常");
  406.                     println!(
  407.                         "{:?} {:?}",
  408.                         e,
  409.                         "ir.jpg",
  410.                     );
  411.                 }
  412.             };
  413.         }
  414.     }
  416.     if colorResult==0{
  417.         if color_img_path.exists() {
  418.             match std::fs::read(&color_img_path) {
  419.                 Ok(image_data) => {
  420.                     println!("读取照片成功");
  421.                     let image_data = base64::encode(&image_data);
  422.                     let base64_string = String::from("data:image/jpg;base64,");
  423.                     std::fs::remove_file(color_img_path).unwrap();
  424.                     result.img_base64.insert("1".to_string(), base64_string + &image_data);
  425.                 }
  426.                 Err(e) => {
  427.                     println!("读取照片抛异常");
  428.                     println!(
  429.                         "{:?} {:?}",
  430.                         e,
  431.                         "color.jpg",
  432.                     );
  433.                 }
  434.             };
  435.         }
  436.     }
  438.     let mut ocritem = RecogIDCardEXResultObject::default();
  440.     let mut index: c_int = 0;
  442.     //orc识别文字
  443.     let mut mrztext = [0; 1024];
  444.     let x = unsafe {V7_VIS_GETMRZTEXT.get_unchecked()(mrztext.as_mut_ptr())};
  445.     if x==0{
  446.         let result_item = ["MRZ".to_string(), decode(&mrztext)];
  447.         ocritem.mrz_result.insert(index, result_item);
  448.         index+=1;
  449.     }
  451.     let mut data:[u16; 256] = [0; 256];
  452.     let mut len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(0,data.as_mut_ptr())};
  453.     if len>0{
  454.         ocritem.mrz_result.insert(index, ["编号".to_string(), decode(&data)]);
  455.         index+=1;
  457.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(1,data.as_mut_ptr())};
  458.         ocritem.mrz_result.insert(index, ["国籍".to_string(), decode(&data)]);
  459.         index+=1;
  461.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(2,data.as_mut_ptr())};
  462.         ocritem.mrz_result.insert(index, ["民族".to_string(), decode(&data)]);
  463.         index+=1;
  465.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(3,data.as_mut_ptr())};
  466.         ocritem.mrz_result.insert(index, ["姓名".to_string(), decode(&data)]);
  467.         index+=1;
  469.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(4,data.as_mut_ptr())};
  470.         let cardType= unsafe {V7_GET_CARDTYPE.get_unchecked()()};
  471.         if cardType==101{
  472.             //身份证是UTF8格式
  473.             ocritem.mrz_result.insert(index, ["中文名".to_string(), decode(&data)]);
  474.         }else{
  475.             ocritem.mrz_result.insert(index, ["中文名".to_string(), decode(&data)]);
  476.             // //中国护照的中文姓名 是GBK编码的
  477.             // let name=GB18030.decode(&data, DecoderTrap::Strict).unwrap();
  478.             // ocritem.mrz_result.insert(index, ["中文名".to_string(), name.replace("\u{0}","")]);
  479.         }
  480.         index+=1;
  482.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(5,data.as_mut_ptr())};
  483.         ocritem.mrz_result.insert(index, ["性别".to_string(), decode(&data)]);
  484.         index+=1;
  486.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(6,data.as_mut_ptr())};
  487.         ocritem.mrz_result.insert(index, ["出生日期".to_string(), decode(&data)]);
  488.         index+=1;
  490.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(7,data.as_mut_ptr())};
  491.         ocritem.mrz_result.insert(index, ["地址".to_string(), decode(&data)]);
  492.         index+=1;
  494.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(8,data.as_mut_ptr())};
  495.         ocritem.mrz_result.insert(index, ["签发机关".to_string(), decode(&data)]);
  496.         index+=1;
  498.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(9,data.as_mut_ptr())};
  499.         ocritem.mrz_result.insert(index, ["有效期始".to_string(), decode(&data)]);
  500.         index+=1;
  502.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(10,data.as_mut_ptr())};
  503.         ocritem.mrz_result.insert(index, ["有效期止".to_string(), decode(&data)]);
  504.         index+=1;
  506.         len = unsafe {V7_RDO_getBytesByIndex.get_unchecked()(20,data.as_mut_ptr())};
  507.         ocritem.mrz_result.insert(index, ["港澳台ID".to_string(), decode(&data)]);
  508.         index+=1;
  509.     }
  510.     else{
  511.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(0,data.as_mut_ptr())};
  512.         ocritem.mrz_result.insert(index, ["编号".to_string(), decode(&data)]);
  513.         index+=1;
  515.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(1,data.as_mut_ptr())};
  516.         ocritem.mrz_result.insert(index, ["国籍".to_string(), decode(&data)]);
  517.         index+=1;
  519.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(2,data.as_mut_ptr())};
  520.         ocritem.mrz_result.insert(index, ["民族".to_string(), decode(&data)]);
  521.         index+=1;
  523.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(3,data.as_mut_ptr())};
  524.         ocritem.mrz_result.insert(index, ["姓名".to_string(), decode(&data)]);
  525.         index+=1;
  527.         //中国护照的中文姓名 是GBK编码的, 身份证不会执行到这里
  528.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(4,data.as_mut_ptr())};
  529.         ocritem.mrz_result.insert(index, ["中文名".to_string(), decode(&data)]);
  530.         // let name=GB18030.decode(&data, DecoderTrap::Strict).unwrap();
  531.         // ocritem.mrz_result.insert(index, ["中文名".to_string(), name.replace("\u{0}","")]);
  532.         index+=1;
  534.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(5,data.as_mut_ptr())};
  535.         ocritem.mrz_result.insert(index, ["性别".to_string(), decode(&data)]);
  536.         index+=1;
  538.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(6,data.as_mut_ptr())};
  539.         ocritem.mrz_result.insert(index, ["出生日期".to_string(), decode(&data)]);
  540.         index+=1;
  542.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(7,data.as_mut_ptr())};
  543.         ocritem.mrz_result.insert(index, ["地址".to_string(), decode(&data)]);
  544.         index+=1;
  546.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(8,data.as_mut_ptr())};
  547.         ocritem.mrz_result.insert(index, ["签发机关".to_string(), decode(&data)]);
  548.         index+=1;
  550.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(9,data.as_mut_ptr())};
  551.         ocritem.mrz_result.insert(index, ["有效期始".to_string(), decode(&data)]);
  552.         index+=1;
  554.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(10,data.as_mut_ptr())};
  555.         ocritem.mrz_result.insert(index, ["有效期止".to_string(), decode(&data)]);
  556.         index+=1;
  558.         len = unsafe {V7_VIS_getBytesByIndex.get_unchecked()(20,data.as_mut_ptr())};
  559.         ocritem.mrz_result.insert(index, ["港澳台ID".to_string(), decode(&data)]);
  560.         index+=1;
  561.     }
  563.     result.reg_info=ocritem;
  564.     result.success = true;
  566.     result.card_type = unsafe {V7_GET_CARDTYPE.get_unchecked()()};
  567.     let elapsed = time_now.elapsed();
  568.     println!("{:.6?}", elapsed);
  569.     return result;
  570. }
  572. pub fn regcord_by_node(mut cx: FunctionContext) -> JsResult<JsNull> {
  573.     println!("regcord_by_node");
  574.     unsafe {
  575.         NEED_RECORD.take();
  576.         NEED_RECORD.set(true).unwrap();
  577.     };
  578.     Ok(cx.null())
  579. }
  580. #[neon::main]
  581. fn main(mut cx: ModuleContext) -> NeonResult<()> {
  582.     cx.export_function("init", init_by_node)?;
  583.     cx.export_function("start", start)?;
  584.     cx.export_function("regcord_by_node", regcord_by_node)?;
  585.     Ok(())
  586. }

使用rust调用c++静态库并编译nodejs包的更多相关文章

  1. Python语言、编译解释、动态库静态库、编译过程、头文件

    学习Python这门语言首先要了解 什么是编译与解释,什么是连接,什么是动态库与静态库, 什么是编译: 编译就是先把高级语言设计的程序翻译成二进制的机器语言,然后CPU直接执行机器码就可以了.一把翻译 ...

  2. Android导入第三方静态库.a编译成动态库.so

    http://ikinglai.blog.51cto.com/6220785/1324985 在Android开发的时候,经常会使用到用c或c++编写的第三方的静态库.如果有源码的话,可以直接跟你自己 ...

  3. 使用ar命令删除iOS静态库重复编译的.o文件

    关于 xcode引入第三方静态类库 duplicate symbol _OBJC_XXX 重复编译错误 看这里 http://www.cnblogs.com/cocoajin/p/3917709.ht ...

  4. 6.关于QT中的内存管理，动态的制作，动态库的调用，静态库的制作

     一  QT的内存管理 1  QT中的内存管理是QObject来管理的 2  QT中的内存管理没有cocos2dx中的引用计数 3  组件能够指定父对象 QTimer *timer = QTime ...

  5. linux C 刚初始化后的一个变量在调用一个静态库中函数后被异常修改为乱码

    linux C 中声明并初始化一个变量const char a[512]="test";后,接着调用了一个静态库中的函数函数test(b);,a并没有传入test函数,但在调用这个 ...

  6. iOS导入c++语言的静态库之后编译不过，先要检查是否导入了libstdc++

    iOS项目中引入c++库,编译链接时报如下错: "std::string::_Rep::_M_destroy(std::allocator<char> const&)&q ...

  7. C/C++ 跨平台交叉编译、静态库/动态库编译、MinGW、Cygwin、CodeBlocks使用原理及链接参数选项

    目录 . 引言 . 交叉编译 . Cygwin简介 . 静态库编译及使用 . 动态库编译及使用 . MinGW简介 . CodeBlocks简介 0. 引言 UNIX是一个注册商标,是要满足一大堆条件 ...

  8. Linux上静态库和动态库的编译和使用

    linux上静态库和动态库的编译和使用(附外部符号错误浅谈) 这就是静态库和动态库的显著区别,静态库是编译期间由链接器通过include目录找到并链接到到可执行文件中,而动态库则是运行期间动态调用,只 ...

  9. linux上静态库和动态库的编译和使用（附外部符号错误浅谈）

    主要参考博客gcc创建和使用静态库和动态库 对于熟悉windows的同学,linux上的静态库.a相当于win的.lib,动态库.so相当于win的.dll． 首先简要地解释下这两种函数库的区别,参考 ...

随机推荐

  1. 五、C++运算符重载，使面向对象编程更方便

    复数类CComplex 编译器做对象运算的时候,会调用对象的运算符重载函数(优先调用成员方法):如果没有成员方法,就砸全局作用域找合适的运算符重载函数 ++和--运算符是单目运算符,在参数列表里放上一 ...

  2. 论文阅读 DyREP:Learning Representations Over Dynamic Graphs

    5 DyREP:Learning Representations Over Dynamic Graphs link:https://scholar.google.com/scholar_url?url ...

  3. HttpContext.TraceIdentifier那严谨的设计

    前言 Asp.Net Core中有一个不受人重视的属性HttpContext.TraceIdentifier,它在链路追踪中非常有用,下面是官方的定义: 在项目中一般会将该字段输出到每一条日志中,也可 ...

  4. linux篇-centos7 安装cacti

    1 cacti运行环境准备 cacti需要php+apache+mysql+snmp+RRDTool,以及cacti本身.cacti本体是用php开发的网站,通过snmp对远端设备信息进行采集.apa ...

  5. 137_Power BI 自定义矩阵复刻Beyondsoft Calendar

    博客:www.jiaopengzi.com 焦棚子的文章目录 请点击下载附件 一.背景 前两天我们用PBI原生的视觉制作了自定义的热力图,今天我们来复刻一个Beyondsoft Calendar 1. ...

  6. 121_Power Query之R.Execute的read.xlsx&ODBC

    博客:www.jiaopengzi.com 焦棚子的文章目录 请点击下载附件 一.问题 pq在用 Excel.Workbook 读取一些Excel早期版本(.xls后缀)的文件时候,报错:DataFo ...

  7. P4169 [Violet]天使玩偶

    两种操作:1.加入点(x,y); 2.查询距(x,y)最近的点的曼哈顿距离距离 思路:绝对值拆开通常可以取max,不过这里直接分类讨论4种情况,我们发现如果找\(i\)点左下点\(j\)\((x_j& ...

  8. Eureka属性配置

    一:Eureka Instance实例信息配置   里面的配置以"-"隔开 其实也支持驼峰命名代替"-" 首先是入门时的配置: server: port: 80 ...

  9. while循环、do..while循环

    While循环 While循环呢它是更具条件来判断是否执行大括号里的内容 ,只要条件成立就会一值执行直到不满足条件它的语法格式: while(循环条件){ 执行语句 }那么我们来做一个小测试看看: p ...

  10. 开发工具-PowerShell下载地址

    更新日志 2022年6月10日 初始化链接. https://github.com/PowerShell/PowerShell/releases/