feat: Added visionOS support for Apple Vision Pro

.changes/visionos.md

@@ -0,0 +1,5 @@
+---
+"cargo-mobile2": minor
+---
+
+Added visionOS support for Apple Vision Pro based on https://github.com/rust-lang/rust/pull/121419

src/apple/config/mod.rs

@@ -21,6 +21,7 @@ use thiserror::Error;
 static DEFAULT_PROJECT_DIR: &str = "gen/apple";
 const DEFAULT_BUNDLE_VERSION: VersionNumber = VersionNumber::new(VersionTriple::new(1, 0, 0), None);
 const DEFAULT_IOS_VERSION: VersionDouble = VersionDouble::new(13, 0);
+const DEFAULT_VISIONOS_VERSION: VersionDouble = VersionDouble::new(1, 0);
 const DEFAULT_MACOS_VERSION: VersionDouble = VersionDouble::new(11, 0);
 
 #[derive(Debug, Default, Serialize, Deserialize)]
@@ -151,6 +152,8 @@ pub struct Metadata {
     #[serde(default)]
     pub ios: Platform,
     #[serde(default)]
+    pub visionos: Platform,
+    #[serde(default)]
     pub macos: Platform,
 }
 
@@ -159,6 +162,7 @@ impl Default for Metadata {
         Self {
             supported: true,
             ios: Default::default(),
+            visionos: Default::default(),
             macos: Default::default(),
         }
     }
@@ -173,6 +177,10 @@ impl Metadata {
         &self.ios
     }
 
+    pub fn visionos(&self) -> &Platform {
+        &self.visionos
+    }
+
     pub fn macos(&self) -> &Platform {
         &self.macos
     }
@@ -286,6 +294,7 @@ pub struct Config {
     bundle_version: VersionNumber,
     bundle_version_short: VersionTriple,
     ios_version: VersionDouble,
+    visionos_version: VersionDouble,
     macos_version: VersionDouble,
     use_legacy_build_system: bool,
     plist_pairs: Vec<PListPair>,
@@ -353,6 +362,12 @@ impl Config {
                 .transpose()
                 .map_err(Error::IosVersionInvalid)?
                 .unwrap_or(DEFAULT_IOS_VERSION),
+            visionos_version: raw
+                .visionos_version
+                .map(|str| VersionDouble::from_str(&str))
+                .transpose()
+                .map_err(Error::IosVersionInvalid)?
+                .unwrap_or(DEFAULT_VISIONOS_VERSION),
             macos_version: raw
                 .macos_version
                 .map(|str| VersionDouble::from_str(&str))

src/apple/config/raw.rs

@@ -123,6 +123,7 @@ pub struct Raw {
     pub bundle_version: Option<String>,
     pub bundle_version_short: Option<String>,
     pub ios_version: Option<String>,
+    pub visionos_version: Option<String>,
     pub macos_version: Option<String>,
     pub use_legacy_build_system: Option<bool>,
     pub plist_pairs: Option<Vec<PListPair>>,
@@ -145,6 +146,7 @@ impl Raw {
             bundle_version: None,
             bundle_version_short: None,
             ios_version: None,
+            visionos_version: None,
             macos_version: None,
             use_legacy_build_system: None,
             plist_pairs: None,
@@ -227,6 +229,7 @@ impl Raw {
             bundle_version: None,
             bundle_version_short: None,
             ios_version: None,
+            visionos_version: None,
             macos_version: None,
             use_legacy_build_system: None,
             plist_pairs: None,

src/apple/device/mod.rs

@@ -58,6 +58,7 @@ impl Reportable for RunError {
 pub enum DeviceKind {
     Simulator,
     IosDeployDevice,
+    VisionOsDeployDevice,
     DeviceCtlDevice,
 }
 
@@ -133,7 +134,9 @@ impl<'a> Device<'a> {
         match self.kind {
             DeviceKind::Simulator => simctl::run(config, env, non_interactive, &self.id)
                 .map_err(|e| RunError::DeployFailed(e.to_string())),
-            DeviceKind::IosDeployDevice | DeviceKind::DeviceCtlDevice => {
+            DeviceKind::IosDeployDevice
+            | DeviceKind::VisionOsDeployDevice
+            | DeviceKind::DeviceCtlDevice => {
                 println!("Exporting app...");
                 self.target
                     .export(config, env, noise_level)

src/apple/device/simctl/mod.rs

@@ -27,16 +27,24 @@ impl Display for Device {
 
 impl<'a> From<Device> for AppleDevice<'a> {
     fn from(device: Device) -> AppleDevice<'a> {
+        let name = device.name.clone();
+        let is_visionos = name.contains("Apple Vision Pro");
+        let target = Target::for_triple(if cfg!(target_arch = "aarch64") {
+            match is_visionos {
+                true => "aarch64-apple-visionos",
+                _ => "aarch64-apple-ios", // TODO: figure out how to check for sim here, or probably do this elsewhere, and just add -sim to the triple
+                                          // true => "aarch64-apple-visionos-sim",
+                                          // _ => "aarch64-apple-ios-sim
+            }
+        } else {
+            "x86_64-apple-ios"
+        });
+
         AppleDevice::new(
             device.udid,
             device.name,
             "".into(),
-            Target::for_arch(if cfg!(target_arch = "aarch64") {
-                "arm64-sim"
-            } else {
-                "x86_64"
-            })
-            .unwrap(),
+            target.unwrap(),
             DeviceKind::Simulator,
         )
     }

src/apple/target.rs

@@ -143,24 +143,24 @@ pub struct Target<'a> {
 }
 
 impl<'a> TargetTrait<'a> for Target<'a> {
-    const DEFAULT_KEY: &'static str = "aarch64";
+    const DEFAULT_KEY: &'static str = "aarch64-apple-ios";
 
     fn all() -> &'a BTreeMap<&'a str, Self> {
         static TARGETS: OnceCell<BTreeMap<&'static str, Target<'static>>> = OnceCell::new();
         TARGETS.get_or_init(|| {
             let mut targets = BTreeMap::new();
             targets.insert(
-                "aarch64",
+                "aarch64-apple-ios",
                 Target {
                     triple: "aarch64-apple-ios",
                     arch: "arm64",
                     sdk: "iphoneos",
-                    alias: Some("arm64e"),
+                    alias: Some("arm64e-ios"),
                     min_xcode_version: None,
                 },
             );
             targets.insert(
-                "x86_64",
+                "x86_64-apple-ios",
                 Target {
                     triple: "x86_64-apple-ios",
                     arch: "x86_64",
@@ -175,12 +175,32 @@ impl<'a> TargetTrait<'a> for Target<'a> {
                 },
             );
             targets.insert(
-                "aarch64-sim",
+                "aarch64-apple-ios-sim",
                 Target {
                     triple: "aarch64-apple-ios-sim",
                     arch: "arm64-sim",
                     sdk: "iphonesimulator",
-                    alias: Some("arm64e-sim"),
+                    alias: Some("arm64e-ios-sim"),
+                    min_xcode_version: None,
+                },
+            );
+            targets.insert(
+                "aarch64-apple-visionos",
+                Target {
+                    triple: "aarch64-apple-visionos",
+                    arch: "arm64",
+                    sdk: "xros",
+                    alias: Some("arm64e-xros"),
+                    min_xcode_version: None,
+                },
+            );
+            targets.insert(
+                "aarch64-apple-visionos-sim",
+                Target {
+                    triple: "aarch64-apple-visionos-sim",
+                    arch: "arm64-sim",
+                    sdk: "xrsimulator",
+                    alias: Some("arm64e-xros-sim"),
                     min_xcode_version: None,
                 },
             );
@@ -201,6 +221,13 @@ impl<'a> TargetTrait<'a> for Target<'a> {
     }
 }
 
+pub enum TargetPlatform {
+    MacOS,
+    #[allow(non_camel_case_types)]
+    iOS,
+    VisionOS,
+}
+
 impl<'a> Target<'a> {
     // TODO: Make this cleaner
     pub fn macos() -> Self {
@@ -213,16 +240,44 @@ impl<'a> Target<'a> {
         }
     }
 
+    pub fn get_platform(&self) -> TargetPlatform {
+        let platform = if self.is_macos() {
+            TargetPlatform::MacOS
+        } else if self.is_ios() {
+            TargetPlatform::iOS
+        } else if self.is_visionos() {
+            TargetPlatform::VisionOS
+        } else {
+            TargetPlatform::MacOS
+        };
+
+        platform
+    }
+
     pub fn is_macos(&self) -> bool {
         *self == Self::macos()
     }
 
+    pub fn is_ios(&self) -> bool {
+        self.triple.contains("apple-ios")
+    }
+
+    pub fn is_visionos(&self) -> bool {
+        self.triple.contains("apple-visionos")
+    }
+
     pub fn for_arch(arch: &str) -> Option<&'a Self> {
         Self::all()
             .values()
             .find(|target| target.arch == arch || target.alias == Some(arch))
     }
 
+    pub fn for_triple(triple: &str) -> Option<&'a Self> {
+        Self::all()
+            .values()
+            .find(|target| target.triple == triple || target.alias == Some(triple))
+    }
+
     fn min_xcode_version_satisfied(&self) -> Result<(), VersionCheckError> {
         self.min_xcode_version
             .map(|(min_version, msg)| {
@@ -247,10 +302,10 @@ impl<'a> Target<'a> {
         metadata: &'a Metadata,
         subcommand: &'a str,
     ) -> Result<CargoCommand<'a>, VersionCheckError> {
-        let metadata = if self.is_macos() {
-            metadata.macos()
-        } else {
-            metadata.ios()
+        let metadata = match self.get_platform() {
+            TargetPlatform::MacOS => metadata.macos(),
+            TargetPlatform::iOS => metadata.ios(),
+            TargetPlatform::VisionOS => metadata.visionos(),
         };
         self.min_xcode_version_satisfied().map(|()| {
             CargoCommand::new(subcommand)