apple-crates

@@ -5982,9 +5982,7 @@ dependencies = [

  "base64",

  "bytes",

  "encoding_rs",

- "futures-channel",

  "futures-core",

- "futures-util",

  "h2",

  "http",

  "http-body",

@@ -26,7 +26,7 @@ log = "0.4.33"

 plist.workspace = true

 pem-rfc7468 = { version = "0.7", features = ["alloc"] }

 rand = "0.10.2"

-reqwest = { workspace = true, features = ["blocking"] }

+reqwest.workspace = true

 serde = { version = "1.0.228", features = ["derive"] }

 sha1.workspace = true

 thiserror.workspace = true

@@ -0,0 +1,5 @@

+<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">

+  <path d="m21.73 18-8-14a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/>

+  <path d="M12 9v4"/>

+  <path d="M12 17h.01"/>

+</svg>

@@ -21,6 +21,33 @@ pub(crate) struct LoadedSideloaderState {

     pub(crate) should_save_preferences: bool,

 }

+#[derive(Clone, Copy, Debug, Eq, PartialEq)]

+pub(crate) enum SideloadReadiness {

+    Ready,

+    NeedsAdi,

+    NeedsAccount,

+    NeedsTeam,

+    NeedsCertificate,

+    NeedsAppId,

+    NeedsApp,

+    NeedsDevice,

+}

+

+impl SideloadReadiness {

+    pub(crate) fn label(self) -> &'static str {

+        match self {

+            Self::Ready => "Ready",

+            Self::NeedsAdi => "Set up CoreADI",

+            Self::NeedsAccount => "Log in to your account",

+            Self::NeedsTeam => "Select a developer team",

+            Self::NeedsCertificate => "Set up a certificate",

+            Self::NeedsAppId => "Select an App ID",

+            Self::NeedsApp => "Select an IPA",

+            Self::NeedsDevice => "Connect a device",

+        }

+    }

+}

+

 #[derive(Debug)]

 pub(crate) struct SideloaderState {

     pub(crate) theme_preference: ThemePreference,

@@ -161,6 +188,41 @@ impl SideloaderState {

         self.device_selection.selected()

     }

+    pub(crate) fn sideload_readiness(&self) -> SideloadReadiness {

+        if !self

+            .adi_backends

+            .get(self.selected_adi_backend)

+            .is_some_and(|backend| backend.availability.is_ready())

+        {

+            return SideloadReadiness::NeedsAdi;

+        }

+        let Some(account) = self.selected_account() else {

+            return SideloadReadiness::NeedsAccount;

+        };

+        let Some(team) = account.teams.get(self.selected_team) else {

+            return SideloadReadiness::NeedsTeam;

+        };

+        let Some(certificate) = team.certificates.get(self.selected_certificate) else {

+            return SideloadReadiness::NeedsCertificate;

+        };

+        if !certificate.private_key_available

+            || certificate.certificate_fingerprint.is_none()

+            || certificate.public_key_fingerprint.is_none()

+        {

+            return SideloadReadiness::NeedsCertificate;

+        }

+        if !self.auto_app_id && team.app_ids.get(self.selected_app_id).is_none() {

+            return SideloadReadiness::NeedsAppId;

+        }

+        if self.selected_app().is_none() {

+            return SideloadReadiness::NeedsApp;

+        }

+        if self.selected_device().is_none() {

+            return SideloadReadiness::NeedsDevice;

+        }

+        SideloadReadiness::Ready

+    }

+

     pub(crate) fn select_team(&mut self, index: usize) -> Option<String> {

         let team_count = self.accounts.get(self.selected_account)?.teams.len();

         if index >= team_count {

@@ -558,9 +620,12 @@ fn random_android_adi_identifier() -> String {

 mod tests {

     use super::*;

     use crate::app::models::{

-        AdiBackendAvailability, AdiBackendDetail, AdiProvisioningState, AppIdOption,

-        DevelopmentCertificateOption,

+        AdiBackendAvailability, AdiBackendDetail, AdiProvisioningState, AppIdOption, AppMetadata,

+        AppOption, DevelopmentCertificateOption, DeviceOption, EntitlementsSource,

+        SupportedDeviceFamily,

     };

+    use crate::app::AppError;

+    use std::path::Path;

     fn app_id(identifier: &str) -> AppIdOption {

         AppIdOption {

@@ -624,6 +689,104 @@ mod tests {

         }

     }

+    fn empty_state() -> SideloaderState {

+        let identity = MachineIdentity {

+            machine_name: "Mac".to_string(),

+            os_name: "macOS".to_string(),

+            os_version: "15".to_string(),

+            machine_id: "machine-id".to_string(),

+        };

+        SideloaderState {

+            theme_preference: ThemePreference::System,

+            accounts: Vec::new(),

+            app_selection: AppSelection::default(),

+            device_selection: DeviceSelection::default(),

+            adi_backends: Vec::new(),

+            selected_account: 0,

+            selected_team: 0,

+            selected_certificate: 0,

+            auto_app_id: true,

+            selected_app_id: 0,

+            selected_adi_backend: 0,

+            machine_identity: identity.clone(),

+            android_device_identity: identity,

+            android_adi_identifier: "0123456789abcdef".to_string(),

+            enabled_patches: Vec::new(),

+            sideload_operation: SideloadOperation::Idle,

+        }

+    }

+

+    fn sample_app() -> AppOption {

+        AppOption {

+            metadata: AppMetadata::sample(

+                "Example",

+                "com.example.app",

+                "1.0",

+                "1",

+                "Example",

+                "16.0",

+                vec![SupportedDeviceFamily::IPhone],

+            ),

+            nested_bundles: Vec::new(),

+            path: "/tmp/Example.ipa".to_string(),

+            icon_path: None,

+            icon_override_path: None,

+            entitlements: Vec::new(),

+            entitlements_source: EntitlementsSource::GeneratedFallback,

+            entitlement_overrides: None,

+            patches: Vec::new(),

+        }

+    }

+

+    #[test]

+    fn sideload_readiness_reports_the_first_required_setup_step() {

+        let mut state = empty_state();

+        assert_eq!(state.sideload_readiness(), SideloadReadiness::NeedsAdi);

+

+        state.adi_backends = vec![backend(

+            AdiBackendKind::AndroidCoreAdi,

+            AdiBackendAvailability::Ready,

+        )];

+        assert_eq!(state.sideload_readiness(), SideloadReadiness::NeedsAccount);

+

+        state.accounts = vec![account("account", Vec::new())];

+        assert_eq!(state.sideload_readiness(), SideloadReadiness::NeedsTeam);

+

+        state.accounts[0].teams = vec![team("TEAM", Vec::new(), Vec::new())];

+        assert_eq!(

+            state.sideload_readiness(),

+            SideloadReadiness::NeedsCertificate

+        );

+

+        state.accounts[0].teams[0].certificates = vec![certificate("SERIAL")];

+        assert_eq!(state.sideload_readiness(), SideloadReadiness::NeedsApp);

+

+        state.app_selection.finish_loading(

+            Path::new("/tmp/Example.ipa"),

+            Ok::<_, AppError>(sample_app()),

+        );

+        assert_eq!(state.sideload_readiness(), SideloadReadiness::NeedsDevice);

+

+        let generation = state.device_selection.begin_refresh().unwrap();

+        state.device_selection.finish_refresh(

+            generation,

+            Ok(vec![DeviceOption {

+                name: "iPhone".to_string(),

+                model: "iPhone17,1".to_string(),

+                os: "iOS 19".to_string(),

+                udid: "device-udid".to_string(),

+                connection: "USB".to_string(),

+            }]),

+        );

+        assert_eq!(state.sideload_readiness(), SideloadReadiness::Ready);

+

+        state.accounts[0].teams[0].certificates[0].private_key_available = false;

+        assert_eq!(

+            state.sideload_readiness(),

+            SideloadReadiness::NeedsCertificate

+        );

+    }

+

     #[test]

     fn restores_developer_selection_from_preferences() {

         let accounts = vec![

@@ -241,3 +241,10 @@ fn only_shared_backend_runtime_builds_tokio_runtimes() {

         assert_absent(&module, &source, &forbidden);

     }

 }

+

+#[test]

+fn backend_modules_do_not_use_blocking_reqwest() {

+    for (module, source) in rust_files_under("src/backend") {

+        assert_absent(&module, &source, &["reqwest::blocking"]);

+    }

+}

@@ -16,9 +16,10 @@ use grandslam::http_session::AnisetteHTTPSession;

 #[cfg(target_os = "windows")]

 use ouroboros::self_referencing;

 use std::ffi::CString;

-use std::fs::{self, File};

-use std::io::{Read, Write};

+use std::fs;

 use std::path::{Path, PathBuf};

+use tokio::fs::File;

+use tokio::io::AsyncWriteExt as _;

 const ANDROID_COREADI_APK_URL: &str =

     "https://apps.mzstatic.com/content/android-apple-music-apk/applemusic.apk";

@@ -347,7 +348,10 @@ fn android_coreadi_backend(android_adi_identifier: &str) -> AdiBackend {

     };

     let library_path = android_coreadi_library_path();

-    let availability = if library_path.as_ref().is_some_and(|path| path.exists()) {

+    let availability = if library_path

+        .as_ref()

+        .is_some_and(|path| installed_library_exists(path))

+    {

         AdiBackendAvailability::Ready

     } else {

         AdiBackendAvailability::NeedsSetup

@@ -408,7 +412,7 @@ fn android_coreadi_provisioning_path() -> Option<PathBuf> {

     app_data_dir().map(|path| path.join("coreadi"))

 }

-pub(crate) fn download_android_coreadi_apk(

+pub(crate) async fn download_android_coreadi_apk(

     mut progress: impl FnMut(AndroidCoreAdiInstallProgress),

 ) -> BackendResult<PathBuf> {

     let _ = android_coreadi_abi().ok_or_else(|| {

@@ -421,76 +425,125 @@ pub(crate) fn download_android_coreadi_apk(

         BackendError::Unsupported("The application data folder is not available.".to_string())

     })?;

     if let Some(parent) = destination.parent() {

-        fs::create_dir_all(parent).map_err(|error| BackendError::Io {

+        tokio::fs::create_dir_all(parent)

+            .await

+            .map_err(|error| BackendError::Io {

                 action: "Create Apple Music APK folder",

                 path: parent.to_path_buf(),

                 source: error,

             })?;

     }

-    let mut response = reqwest::blocking::Client::new()

+    let mut response = reqwest::Client::new()

         .get(ANDROID_COREADI_APK_URL)

         .send()

+        .await

         .and_then(|response| response.error_for_status())

         .map_err(|error| {

             BackendError::Network(format!("Failed to download Apple Music APK: {error}"))

         })?;

     let total_bytes = response.content_length();

-    let mut file = File::create(&destination).map_err(|error| BackendError::Io {

+    let partial_destination = partial_file_path(&destination);

+    let mut file = File::create(&partial_destination)

+        .await

+        .map_err(|error| BackendError::Io {

             action: "Create Apple Music APK",

-        path: destination.clone(),

+            path: partial_destination.clone(),

             source: error,

         })?;

     let mut downloaded_bytes = 0;

-    let mut buffer = [0; 64 * 1024];

     progress(AndroidCoreAdiInstallProgress {

         downloaded_bytes,

         total_bytes,

     });

-    loop {

-        let read = response.read(&mut buffer).map_err(|error| {

+    while let Some(chunk) = response.chunk().await.map_err(|error| {

         BackendError::Network(format!("Failed to download Apple Music APK: {error}"))

-        })?;

-        if read == 0 {

-            break;

-        }

-

-        file.write_all(&buffer[..read])

+    })? {

+        file.write_all(&chunk)

+            .await

             .map_err(|error| BackendError::Io {

                 action: "Save Apple Music APK",

-                path: destination.clone(),

+                path: partial_destination.clone(),

                 source: error,

             })?;

-        downloaded_bytes += read as u64;

+        downloaded_bytes += chunk.len() as u64;

         progress(AndroidCoreAdiInstallProgress {

             downloaded_bytes,

             total_bytes,

         });

     }

-    file.flush().map_err(|error| BackendError::Io {

+    file.flush().await.map_err(|error| BackendError::Io {

         action: "Flush Apple Music APK",

-        path: destination.clone(),

+        path: partial_destination.clone(),

         source: error,

     })?;

+    drop(file);

     if downloaded_bytes == 0 {

+        let _ = tokio::fs::remove_file(&partial_destination).await;

         return Err(BackendError::Adi(

             "Downloaded Apple Music APK is empty.".to_string(),

         ));

     }

+    publish_partial_file(

+        &partial_destination,

+        &destination,

+        "Publish Apple Music APK",

+    )

+    .await?;

+

     Ok(destination)

 }

+fn installed_library_exists(path: &Path) -> bool {

+    fs::metadata(path).is_ok_and(|metadata| metadata.is_file() && metadata.len() > 0)

+}

+

+fn partial_file_path(destination: &Path) -> PathBuf {

+    let file_name = destination

+        .file_name()

+        .map(|name| name.to_string_lossy())

+        .unwrap_or_default();

+    destination.with_file_name(format!("{file_name}.part"))

+}

+

+async fn publish_partial_file(

+    partial: &Path,

+    destination: &Path,

+    action: &'static str,

+) -> BackendResult<()> {

+    match tokio::fs::remove_file(destination).await {

+        Ok(()) => {}

+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}

+        Err(source) => {

+            return Err(BackendError::Io {

+                action,

+                path: destination.to_path_buf(),

+                source,

+            });

+        }

+    }

+

+    tokio::fs::rename(partial, destination)

+        .await

+        .map_err(|source| BackendError::Io {

+            action,

+            path: destination.to_path_buf(),

+            source,

+        })

+}

+

 pub(crate) async fn download_and_install_android_coreadi(

     mut progress: impl FnMut(AndroidCoreAdiInstallEvent) + Send + 'static,

 ) -> BackendResult<PathBuf> {

     backend_runtime::run_send("CoreADI install", async move {

         let apk_path = download_android_coreadi_apk(|download| {

             progress(AndroidCoreAdiInstallEvent::Downloading(download));

-        })?;

+        })

+        .await?;

         progress(AndroidCoreAdiInstallEvent::Installing);

         install_android_coreadi_from_apk_async(apk_path).await

     })

@@ -540,17 +593,24 @@ async fn install_android_coreadi_from_apk_async(apk_path: PathBuf) -> BackendRes

         BackendError::Unsupported("The application data folder is not available.".to_string())

     })?;

     if let Some(parent) = destination.parent() {

-        fs::create_dir_all(parent).map_err(|error| BackendError::Io {

+        tokio::fs::create_dir_all(parent)

+            .await

+            .map_err(|error| BackendError::Io {

                 action: "Create CoreADI folder",

                 path: parent.to_path_buf(),

                 source: error,

             })?;

     }

-    let mut destination_file = File::create(&destination).map_err(|error| BackendError::Io {

+    let partial_destination = partial_file_path(&destination);

+    let mut destination_file =

+        File::create(&partial_destination)

+            .await

+            .map_err(|error| BackendError::Io {

                 action: "Create CoreADI destination",

-        path: destination.clone(),

+                path: partial_destination.clone(),

                 source: error,

             })?;

+    let mut written_bytes = 0u64;

     let mut buffer = [0u8; 64 * 1024];

     loop {

         let read = entry_reader.read(&mut buffer).await.map_err(|error| {

@@ -559,19 +619,36 @@ async fn install_android_coreadi_from_apk_async(apk_path: PathBuf) -> BackendRes

         if read == 0 {

             break;

         }

+

         destination_file

             .write_all(&buffer[..read])

+            .await

             .map_err(|error| BackendError::Io {

                 action: "Store CoreADI",

-                path: destination.clone(),

+                path: partial_destination.clone(),

                 source: error,

             })?;

+        written_bytes += read as u64;

     }

-    destination_file.flush().map_err(|error| BackendError::Io {

+

+    destination_file

+        .flush()

+        .await

+        .map_err(|error| BackendError::Io {

             action: "Flush CoreADI",

-        path: destination.clone(),

+            path: partial_destination.clone(),

             source: error,

         })?;

+    drop(destination_file);

+

+    if written_bytes == 0 {

+        let _ = tokio::fs::remove_file(&partial_destination).await;

+        return Err(BackendError::Zip(

+            "APK contains an empty CoreADI library.".to_string(),

+        ));

+    }

+

+    publish_partial_file(&partial_destination, &destination, "Publish CoreADI").await?;

     Ok(destination)

 }

@@ -671,4 +748,25 @@ mod tests {

                 .any(|backend| backend.kind == AdiBackendKind::AndroidCoreAdi));

         }

     }

+

+    #[test]

+    fn installed_library_requires_a_nonempty_regular_file() {

+        let temp = tempfile::tempdir().expect("temporary directory should be created");

+        let library = temp.path().join(ANDROID_COREADI_LIBRARY_FILE);

+

+        assert!(!installed_library_exists(&library));

+        fs::write(&library, []).expect("empty library should be created");

+        assert!(!installed_library_exists(&library));

+        fs::write(&library, [1]).expect("nonempty library should be created");

+        assert!(installed_library_exists(&library));

+        assert!(!installed_library_exists(temp.path()));

+    }

+

+    #[test]

+    fn partial_file_is_stored_next_to_its_destination() {

+        assert_eq!(

+            partial_file_path(Path::new("/data/x86_64/libCoreADI.so")),

+            PathBuf::from("/data/x86_64/libCoreADI.so.part")

+        );

+    }

 }

@@ -4,7 +4,7 @@ use crate::app::models::{

     SideloadOperation, SideloadPhase,

 };

 use crate::app::preferences::{apply_app_overrides, AppOverridePreferences};

-use crate::app::state::SideloaderState;

+use crate::app::state::{SideloadReadiness, SideloaderState};

 use crate::app::AppError;

 use crate::constants::*;

 use crate::ui::settings::{show_or_open_settings_window, SettingsMode, SettingsWindowHandle};

@@ -2017,12 +2017,42 @@ fn developer_team_count(account: &AccountOption) -> String {

     }

 }

-fn sideload_top_label(operation: &SideloadOperation) -> &'static str {

-    match operation {

-        SideloadOperation::Idle => "Draft",

-        SideloadOperation::Running { phase, .. } => sideload_phase_label(*phase),

-        SideloadOperation::Finished { .. } => "Done",

-        SideloadOperation::Failed { .. } => "Failed",

+struct HeaderStatus {

+    label: &'static str,

+    color: u32,

+    icon: &'static str,

+}

+

+fn header_status(state: &SideloaderState) -> HeaderStatus {

+    if let SideloadOperation::Running { phase, .. } = &state.sideload_operation {

+        return HeaderStatus {

+            label: sideload_phase_label(*phase),

+            color: 0x173f45,

+            icon: "icons/refresh-cw.svg",

+        };

+    }

+

+    let readiness = state.sideload_readiness();

+    if readiness != SideloadReadiness::Ready {

+        return HeaderStatus {

+            label: readiness.label(),

+            color: 0x9a5b13,

+            icon: "icons/triangle-alert.svg",

+        };

+    }

+

+    match &state.sideload_operation {

+        SideloadOperation::Failed { .. } => HeaderStatus {

+            label: "Action failed",

+            color: 0x9a302b,

+            icon: "icons/triangle-alert.svg",

+        },

+        SideloadOperation::Idle | SideloadOperation::Finished { .. } => HeaderStatus {

+            label: readiness.label(),

+            color: 0x1d6b45,

+            icon: "icons/check.svg",

+        },

+        SideloadOperation::Running { .. } => unreachable!("running status returned above"),

     }

 }

@@ -2185,7 +2215,7 @@ impl Render for SideloaderView {

             self.spinner_turns = 0.;

         }

-        let status_color = sideload_status_color(&self.sideload_operation);

+        let header_status = header_status(&self.state);

         div()

             .track_focus(&self.focus_handle)

@@ -2255,13 +2285,17 @@ impl Render for SideloaderView {

                                     .flex()

                                     .items_center()

                                     .gap_2()

-                                    .child(div().w_2().h_2().rounded_full().bg(rgb(status_color)))

+                                    .child(lucide_icon_tinted(

+                                        header_status.icon,

+                                        header_status.color,

+                                    ))

                                     .child(

                                         div()

                                             .text_sm()

                                             .font_weight(FontWeight::SEMIBOLD)

-                                            .text_color(rgb(status_color))

-                                            .child(sideload_top_label(&self.sideload_operation)),

+                                            .text_color(rgb(header_status.color))

+                                            .whitespace_normal()

+                                            .child(header_status.label),

                                     ),

                             )

                             .child(

@@ -1,4 +1,5 @@

 use super::*;

+use crate::app::models::AdiBackendAvailability;

 pub(super) struct AdiViewProps<'a> {

     pub(super) focus_handle: &'a FocusHandle,

@@ -517,10 +518,7 @@ fn adi_backend_status_section(

                     },

                 )

                 .when(

-                    matches!(

-                        &backend.provisioning_state,

-                        AdiProvisioningState::NotProvisioned | AdiProvisioningState::Error(_)

-                    ),

+                    should_show_provision_action(backend.availability, &backend.provisioning_state),

                     |this| {

                         this.child(adi_provision_button(

                             provisioning_operation,

@@ -548,6 +546,17 @@ fn adi_backend_status_section(

         )

 }

+fn should_show_provision_action(

+    availability: AdiBackendAvailability,

+    provisioning_state: &AdiProvisioningState,

+) -> bool {

+    availability.is_ready()

+        && matches!(

+            provisioning_state,

+            AdiProvisioningState::NotProvisioned | AdiProvisioningState::Error(_)

+        )

+}

+

 fn adi_provision_button(

     provisioning_operation: Option<&AdiOperationState>,

     spinner_turns: f32,

@@ -936,3 +945,30 @@ fn read_only_badge() -> gpui::Div {

         .justify_center()

         .child("Read-only")

 }

+

+#[cfg(test)]

+mod tests {

+    use super::*;

+

+    #[test]

+    fn provisioning_action_requires_a_ready_backend() {

+        let error = AdiProvisioningState::Error("installation failed".to_string());

+

+        assert!(!should_show_provision_action(

+            AdiBackendAvailability::NeedsSetup,

+            &error

+        ));

+        assert!(should_show_provision_action(

+            AdiBackendAvailability::Ready,

+            &error

+        ));

+        assert!(should_show_provision_action(

+            AdiBackendAvailability::Ready,

+            &AdiProvisioningState::NotProvisioned

+        ));

+        assert!(!should_show_provision_action(

+            AdiBackendAvailability::Ready,

+            &AdiProvisioningState::Provisioned

+        ));

+    }

+}