Permission, Building Blocks for Native APIs

Cargo.toml

@@ -62,6 +62,10 @@ members = [
     "packages/rsx-hotreload",
     "packages/const-serialize",
     "packages/const-serialize-macro",
+    "packages/dx-macro-helpers",
+    "packages/permissions/permissions-core",
+    "packages/permissions/permissions-macro",
+    "packages/permissions/permissions",
     "packages/dx-wire-format",
     "packages/logger",
     "packages/config-macros",
@@ -86,6 +90,10 @@ members = [
     "packages/manganis/manganis-core",
     "packages/manganis/manganis-macro",
 
+    # platform-bridge
+    "packages/platform-bridge",
+    "packages/platform-bridge-macro",
+
     # wasm-split
     "packages/wasm-split/wasm-split",
     "packages/wasm-split/wasm-split-macro",
@@ -193,9 +201,22 @@ dioxus-cli-opt = { path = "packages/cli-opt", version = "0.7.1" }
 dioxus-cli-telemetry = { path = "packages/cli-telemetry", version = "0.7.1" }
 dioxus-cli-config = { path = "packages/cli-config", version = "0.7.1" }
 
-# const-serializea
-const-serialize = { path = "packages/const-serialize", version = "0.7.1" }
-const-serialize-macro = { path = "packages/const-serialize-macro", version = "0.7.1" }
+
+dx-macro-helpers = { path = "packages/dx-macro-helpers", version = "0.7.0" }
+
+# permissions
+permissions-core = { path = "packages/permissions/permissions-core", version = "=0.7.0-rc.3" }
+permissions-macro = { path = "packages/permissions/permissions-macro", version = "=0.7.0-rc.3" }
+permissions = { path = "packages/permissions/permissions", version = "=0.7.0-rc.3" }
+
+# platform bridge
+dioxus-platform-bridge = { path = "packages/platform-bridge", version = "=0.7.0-rc.3" }
+# const-serialize
+const-serialize = { path = "packages/const-serialize", version = "0.8.0" }
+const-serialize-macro = { path = "packages/const-serialize-macro", version = "0.8.0" }
+
+# The version of const-serialize published with 0.7.0 and 0.7.1 that the CLI should still support
+const-serialize-07 = { package = "const-serialize", version = "0.7.1" }
 
 # subsecond
 subsecond-types = { path = "packages/subsecond/subsecond-types", version = "0.7.1" }
@@ -206,6 +227,9 @@ manganis = { path = "packages/manganis/manganis", version = "0.7.1" }
 manganis-core = { path = "packages/manganis/manganis-core", version = "0.7.1" }
 manganis-macro = { path = "packages/manganis/manganis-macro", version = "0.7.1" }
 
+# The version of assets published with 0.7.0 and 0.7.1 that the CLI should still support
+manganis-core-07 = { package = "manganis-core", version = "0.7.1" }
+
 # wasm-split
 wasm-splitter = { path = "packages/wasm-split/wasm-split", version = "0.7.1" }
 wasm-split-macro = { path = "packages/wasm-split/wasm-split-macro", version = "0.7.1" }

packages/cli-opt/Cargo.toml

@@ -13,6 +13,7 @@ keywords = ["dom", "ui", "gui", "react"]
 anyhow = { workspace = true }
 manganis = { workspace = true }
 manganis-core = { workspace = true }
+permissions = { path = "../permissions/permissions" }
 object = { workspace = true, features = ["wasm"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }

packages/cli-opt/src/lib.rs

@@ -19,6 +19,9 @@ mod json;
 pub use file::process_file_to;
 pub use hash::add_hash_to_asset;
 
+// Re-export SymbolData from the public permissions crate for convenience
+pub use permissions::SymbolData;
+
 /// A manifest of all assets collected from dependencies
 ///
 /// This will be filled in primarily by incremental compilation artifacts.

packages/cli/Cargo.toml

@@ -28,6 +28,7 @@ depinfo = { workspace = true }
 subsecond-types = { workspace = true }
 dioxus-cli-telemetry = { workspace =  true }
 dioxus-component-manifest = { workspace = true }
+permissions = { workspace = true }
 
 clap = { workspace = true, features = ["derive", "cargo"] }
 convert_case = { workspace = true }
@@ -98,6 +99,7 @@ brotli = "8.0.1"
 ignore = "0.4.23"
 env_logger = { workspace = true }
 const-serialize = { workspace = true, features = ["serde"] }
+const-serialize-07 = { workspace = true, features = ["serde"] }
 
 tracing-subscriber = { version = "0.3.19", features = [
     "std",
@@ -122,6 +124,7 @@ log = { version = "0.4", features = ["max_level_off", "release_max_level_off"] }
 tempfile = "3.19.1"
 manganis = { workspace = true }
 manganis-core = { workspace = true }
+manganis-core-07 = { workspace = true }
 target-lexicon = { version = "0.13.2", features = ["serde", "serde_support"] }
 wasm-encoder = "0.235.0"
 

packages/cli/assets/android/MainActivity.kt.hbs

@@ -1,8 +1,5 @@
-package dev.dioxus.main;
-
-// need to re-export buildconfig down from the parent
-import {{application_id}}.BuildConfig;
-typealias BuildConfig = BuildConfig;
+package dev.dioxus.main
 
+typealias BuildConfig = {{application_id}}.BuildConfig
 
 class MainActivity : WryActivity()

packages/cli/assets/android/gen/app/build.gradle.kts.hbs

@@ -53,6 +53,11 @@ android {
     buildFeatures {
         buildConfig = true
     }
+    sourceSets {
+        getByName("main") {
+            java.srcDirs("src/main/kotlin", "src/main/java")
+        }
+    }
 }
 
 dependencies {

packages/cli/assets/android/gen/app/src/main/AndroidManifest.xml.hbs

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.INTERNET" />
+    <!-- Permissions will be injected here by Dioxus CLI -->
     <application android:hasCode="true" android:supportsRtl="true" android:icon="@mipmap/ic_launcher"
         android:extractNativeLibs="true"
         android:allowNativeHeapPointerTagging="false"

packages/cli/assets/android/gen/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,8 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-bin.zip
+## TODO: Update this before merging
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+# distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

packages/cli/assets/ios/ios.plist.hbs

@@ -57,5 +57,7 @@
 		<string>UIInterfaceOrientationLandscapeLeft</string>
 		<string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
+
+	<!-- Permissions will be injected here by Dioxus CLI -->
 </dict>
 </plist>

packages/cli/src/build/android_java.rs

@@ -0,0 +1,144 @@
+//! Android Java source collection from compiled binaries
+//!
+//! This module extracts Java source metadata from embedded linker symbols,
+//! similar to how permissions and manganis work. It finds `__JAVA_SOURCE__`
+//! symbols in the binary and deserializes them into metadata that can be
+//! used by the Gradle build process.
+
+use std::io::Read;
+use std::path::Path;
+
+use crate::Result;
+
+const JAVA_SOURCE_SYMBOL_PREFIX: &str = "__JAVA_SOURCE__";
+
+use super::linker_symbols;
+
+/// Metadata about Java sources that need to be compiled to DEX
+/// This mirrors the struct from platform-bridge
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct JavaSourceMetadata {
+    /// File paths relative to crate root
+    pub files: Vec<String>,
+    /// Java package name (e.g. "dioxus.mobile.geolocation")
+    pub package_name: String,
+    /// Plugin identifier for organization (e.g. "geolocation")
+    pub plugin_name: String,
+}
+
+impl JavaSourceMetadata {
+    /// Create from the platform-bridge SerializeConst version
+    fn from_const_serialize(
+        package_name: const_serialize::ConstStr,
+        plugin_name: const_serialize::ConstStr,
+        file_count: u8,
+        files: [const_serialize::ConstStr; 8],
+    ) -> Self {
+        Self {
+            package_name: package_name.as_str().to_string(),
+            plugin_name: plugin_name.as_str().to_string(),
+            files: files[..file_count as usize]
+                .iter()
+                .map(|s| s.as_str().to_string())
+                .collect(),
+        }
+    }
+}
+
+/// A manifest of all Java sources found in a binary
+#[derive(Debug, Clone, Default)]
+pub struct JavaSourceManifest {
+    sources: Vec<JavaSourceMetadata>,
+}
+
+impl JavaSourceManifest {
+    pub fn new(sources: Vec<JavaSourceMetadata>) -> Self {
+        Self { sources }
+    }
+
+    pub fn sources(&self) -> &[JavaSourceMetadata] {
+        &self.sources
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.sources.is_empty()
+    }
+}
+
+/// Extract all Java sources from the given file
+pub(crate) fn extract_java_sources_from_file(path: impl AsRef<Path>) -> Result<JavaSourceManifest> {
+    let path = path.as_ref();
+    let offsets = linker_symbols::find_symbol_offsets_from_path(path, JAVA_SOURCE_SYMBOL_PREFIX)?;
+
+    let mut file = std::fs::File::open(path)?;
+    let mut file_contents = Vec::new();
+    file.read_to_end(&mut file_contents)?;
+
+    let mut sources = Vec::new();
+
+    // Parse the metadata from each symbol offset
+    // The format is: (package_name: &str, plugin_name: &str, files: &[&str])
+    for offset in offsets {
+        match parse_java_metadata_at_offset(&file_contents, offset as usize) {
+            Ok(metadata) => {
+                tracing::debug!(
+                    "Extracted Java metadata: plugin={}, package={}, files={:?}",
+                    metadata.plugin_name,
+                    metadata.package_name,
+                    metadata.files
+                );
+                sources.push(metadata);
+            }
+            Err(e) => {
+                tracing::warn!("Failed to parse Java metadata at offset {}: {}", offset, e);
+            }
+        }
+    }
+
+    if !sources.is_empty() {
+        tracing::info!(
+            "Extracted {} Java source declarations from binary",
+            sources.len()
+        );
+    }
+
+    Ok(JavaSourceManifest::new(sources))
+}
+
+/// Parse Java metadata from binary data at the given offset
+///
+/// The data is serialized using const-serialize and contains:
+/// - package_name: ConstStr
+/// - plugin_name: ConstStr  
+/// - file_count: u8
+/// - files: [ConstStr; 8]
+fn parse_java_metadata_at_offset(data: &[u8], offset: usize) -> Result<JavaSourceMetadata> {
+    use const_serialize::ConstStr;
+
+    // Read the serialized data (padded to 4096 bytes like permissions)
+    let end = (offset + 4096).min(data.len());
+    let metadata_bytes = &data[offset..end];
+
+    // Use deserialize_const! directly with the byte slice (new API)
+    // Note: Java sources are being ignored for now per the plan, but we fix compilation errors
+
+    // Deserialize the struct fields
+    // The new API uses deserialize_const! with a byte slice directly
+    if let Some((remaining, package_name)) = const_serialize::deserialize_const!(ConstStr, metadata_bytes) {
+        if let Some((remaining, plugin_name)) = const_serialize::deserialize_const!(ConstStr, remaining) {
+            if let Some((remaining, file_count)) = const_serialize::deserialize_const!(u8, remaining) {
+                if let Some((_, files)) = const_serialize::deserialize_const!([ConstStr; 8], remaining)
+                {
+                    return Ok(JavaSourceMetadata::from_const_serialize(
+                        package_name,
+                        plugin_name,
+                        file_count,
+                        files,
+                    ));
+                }
+            }
+        }
+    }
+
+    anyhow::bail!("Failed to deserialize Java metadata at offset {}", offset)
+}