feat: initial v8 native module setup

Author: triniwiz

packages/canvas/src-native/canvas-ios/CanvasNative.xcodeproj/project.xcworkspace/xcuserdata/triniwiz.xcuserdatad/UserInterfaceState.xcuserstate

@@ -2,7 +2,8 @@
 
 members = [
     "gl-bindings",
-    "canvas-core"
+    "canvas-core",
+    "v8-bindings"
 ]
 
 

packages/canvas/src-native/canvas-native/.idea/canvas-native.iml

@@ -5,6 +5,9 @@ authors = ["Osei Fortune <[email protected]>"]
 edition = "2018"
 build = "build.rs"
 
+[build]
+rustc-wrapper = "sccache"
+
 [build-dependencies]
 bindgen = "0.57.0"
 cmake = "0.1.44"
@@ -16,6 +19,7 @@ base64 = "0.13.0"
 image = "0.23.7"
 encoding_rs = "0.8.24"
 gl-bindings = { version = "0.1.0", path = "../gl-bindings" }
+#v8-bindings = { version = "0.1.0", path = "../v8-bindings" }
 lazy_static = "1.4.0"
 css-color-parser = "0.1.2"
 reqwest = { version = "0.11", features = ["blocking"] }

packages/canvas/src-native/canvas-native/Cargo.toml

@@ -5,6 +5,9 @@ authors = ["triniwiz <[email protected]>"]
 edition = "2018"
 build="build.rs"
 
+[build]
+rustc-wrapper = "sccache"
+
 [build-dependencies]
 bindgen = "0.55.1"
 cmake = "0.1.44"

packages/canvas/src-native/canvas-native/canvas-core/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "v8-bindings"
+version = "0.1.0"
+authors = ["triniwiz <[email protected]>"]
+edition = "2018"
+build = "build.rs"
+
+[build]
+rustc-wrapper = "sccache"
+
+[build-dependencies]
+bindgen = "0.58.1"
+cmake = "0.1.44"
+cc = "1.0.56"
+
+
+[dependencies]

packages/canvas/src-native/canvas-native/gl-bindings/Cargo.toml

@@ -0,0 +1,147 @@
+use std::borrow::Borrow;
+use std::{fmt, env};
+use std::fmt::{Display, Formatter};
+
+#[derive(Clone, Debug)]
+pub struct Target {
+    pub architecture: String,
+    pub vendor: String,
+    pub system: String,
+    pub abi: Option<String>,
+}
+
+impl Target {
+    pub fn as_strs(&self) -> (&str, &str, &str, Option<&str>) {
+        (
+            self.architecture.as_str(),
+            self.vendor.as_str(),
+            self.system.as_str(),
+            self.abi.as_deref(),
+        )
+    }
+}
+
+impl Display for Target {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}-{}-{}",
+            &self.architecture, &self.vendor, &self.system
+        )?;
+
+        if let Some(ref abi) = self.abi {
+            write!(f, "-{}", abi)
+        } else {
+            Result::Ok(())
+        }
+    }
+}
+
+const ROOT_DIR: &str = "./vendor/android/";
+
+fn get_path(path: &str)-> String{
+    format!("{}{}",ROOT_DIR, path)
+}
+
+pub fn env_var(name: impl AsRef<str>) -> Option<String> {
+    let name = name.as_ref();
+    env::var(name).ok()
+}
+
+
+fn main() {
+    let target_str = std::env::var("TARGET").unwrap();
+    let mut include_libs_dir = String::from("");
+    let arm_libs_dir = get_path("armeabi-v7a");
+    let arm_64_libs_dir = get_path("arm64-v8a");
+    let x86_libs_dir = get_path("x86");
+    let x86_64_libs_dir = get_path("x86_64");
+    let ndk = env_var("ANDROID_NDK").expect("ANDROID_NDK variable not set");
+    let mut target_ndk = "";
+    let arm_ndk = "/tmp/ndk_arm";
+    let arm_64_ndk = "/tmp/ndk_arm64";
+    let x86_ndk = "/tmp/ndk_x86";
+    let x86_64_ndk = "/tmp/ndk_x86_64";
+
+    let target: Vec<String> = target_str.split('-').map(|s| s.into()).collect();
+    if target.len() < 3 {
+        panic!("Failed to parse TARGET {}", target_str);
+    }
+
+    let abi = if target.len() > 3 {
+        Some(target[3].clone())
+    } else {
+        None
+    };
+
+    let target = Target {
+        architecture: target[0].clone(),
+        vendor: target[1].clone(),
+        system: target[2].clone(),
+        abi,
+    };
+    println!("cargo:rerun-if-changed=build.rs");
+
+    match target.system.borrow() {
+        "android" | "androideabi" => {
+            let build_target;
+            if target.architecture.eq("armv7") {
+                target_ndk = arm_ndk;
+                build_target = "armv7-linux-androideabi";
+                include_libs_dir.push_str(&arm_libs_dir);
+            } else if target.architecture.eq("aarch64") {
+                build_target = "aarch64-linux-android";
+                target_ndk = arm_64_ndk;
+                include_libs_dir.push_str(&arm_64_libs_dir);
+            } else if target.architecture.eq("i686") {
+                build_target = "i686-linux-android";
+                target_ndk = x86_ndk;
+                include_libs_dir.push_str(&x86_libs_dir);
+            } else if target.architecture.eq("x86_64") {
+                build_target = "x86_64-linux-android";
+                target_ndk = x86_64_ndk;
+                include_libs_dir.push_str(&x86_64_libs_dir);
+            } else {
+                return;
+            }
+
+            println!("target {:?}", build_target);
+            let root_include = format!("--sysroot={}/sysroot",ndk);
+            let cpu_features = format!("-I{}/sources/android/cpufeatures", ndk);
+            let c_lang = format!("-isystem{}/sources/cxx-stl/llvm-libc++/include", ndk);
+
+            //println!("cargo:rustc-link-search=native={}", include_dir);
+           // println!("cargo:rustc-link-search=native={}", cpu_features);
+            //println!("cargo:rustc-link-search=native={}", c_lang);
+            println!("cargo:rustc-link-search=native={}", include_libs_dir);
+            println!("cargo:rustc-link-lib=v8"); // the "-l" flag
+            println!("cargo:rustc-link-lib=zip"); // the "-l" flag
+
+            let bindings = bindgen::Builder::default()
+                .header("wrapper.h")
+                //.clang_arg(format!("--target={}", build_target))
+                .clang_arg("-x")
+                .clang_arg("c++")
+                .clang_arg("-std=c++17")
+                .clang_arg(root_include)
+                .clang_arg(c_lang)
+
+                //.clang_arg(cpu_features)
+               // .clang_arg(include_dir)
+                //.clang_arg(include_libs_dir)
+                // Finish the builder and generate the bindings.
+                .generate()
+                // Unwrap the Result and panic on failure.
+                .expect("Unable to generate bindings");
+
+            // Write the bindings to the $OUT_DIR/bindings.rs file.
+
+            let out_path = std::path::PathBuf::from(std::env::var("OUT_DIR").unwrap());
+            bindings
+                .write_to_file(out_path.join("bindings.rs"))
+                .expect("Couldn't write bindings!");
+
+        }
+        _ => {}
+    }
+}

packages/canvas/src-native/canvas-native/v8-bindings/Cargo.toml

@@ -0,0 +1,7 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}