Struct XcRunSimctlInstance 

pub struct XcRunSimctlInstance<'src> { /* private fields */ }

Implementations

impl XcRunSimctlInstance<'_>

pub fn boot(&self, device_name: impl Into<DeviceName>) -> Result<BootOutput>

This will not fail if the device is already booted, but will return BootOutput::AlreadyBooted in that case.

Examples found in repository

examples/simctl.rs (line 48)

fn main() -> Result<(), apple_clis::error::Error> {
	let xcrun_instance = xcrun::XcRunInstance::new()?;
	let simctl_instance = xcrun_instance.simctl();

	let output = simctl_instance.list()?;
	let devices: Vec<&simctl::list::ListDevice> = output.success()?.devices().collect();
	for device in devices {
		println!(
			"Simulator device {name} is {state:?} and is ready = {ready:?}",
			name = device.name,
			state = device.state,
			ready = device.ready()
		);
	}

	// the .names() and .ipads() are implemented on extension traits imported with
	// use apple_clis::prelude::*;
	// to make finding devices easier and more ergonomic
	let ipad_simulator: &IPadVariant = output
		.get_success()
		.expect("to succeed")
		.devices()
		.names()
		.ipads()
		.max()
		.expect("an iPad simulator to be available");
	println!("Found an {} simulator", ipad_simulator);

	if let IPadVariant::Pro {
		size, generation, ..
	} = ipad_simulator
	{
		let inches: f32 = size.inches();
		let gen: u8 = match generation {
			// generations can be M1 or gen 6
			Generation::Num(num) => num.get(),	
			Generation::M(m_gen) => m_gen.get_u8(),
		};
		println!(
			"Ooh, its a pro size {} {:?} generation {} {:?}",
			size, inches, generation, gen,
		);
	}

	// boot the simulator
	let boot_result = simctl_instance.boot(DeviceName::from(*ipad_simulator))?;
	match boot_result {
		simctl::boot::BootOutput::SuccessUnImplemented { .. } => println!("Booted the simulator"),
		simctl::boot::BootOutput::AlreadyBooted => println!("Simulator was already booted"),
		_ => println!("PRs welcome to cover more cases"),
	}

	// open the simulator
	let open_instance = open::OpenCLIInstance::new()?;
	open_instance.open_well_known(&open::well_known::WellKnown::Simulator)?;

	Ok(())
}

impl XcRunSimctlInstance<'_>

pub fn install_booted( &self, app_path: impl AsRef<Utf8Path>, ) -> Result<InstallOutput>

pub fn install( &self, app_path: impl AsRef<Utf8Path>, booted_simulator: &DeviceName, ) -> Result<InstallOutput>

impl<'src> XcRunSimctlInstance<'src>

pub fn list(&self) -> Result<ListOutput>

Examples found in repository

examples/xcrun-simctl-list.rs (line 7)

fn main() -> Result<(), apple_clis::error::Error> {
	let xcrun_instance = apple_clis::xcrun::XcRunInstance::new()?;
	let simctl_instance = xcrun_instance.simctl();

	let output = simctl_instance.list()?;
	println!("Output: {:#?}", output);

	let devices = output.success()?.devices();
	for device in devices {
		println!("Device: {:#?}", device);
	}

	Ok(())
}

examples/simctl.rs (line 7)

fn main() -> Result<(), apple_clis::error::Error> {
	let xcrun_instance = xcrun::XcRunInstance::new()?;
	let simctl_instance = xcrun_instance.simctl();

	let output = simctl_instance.list()?;
	let devices: Vec<&simctl::list::ListDevice> = output.success()?.devices().collect();
	for device in devices {
		println!(
			"Simulator device {name} is {state:?} and is ready = {ready:?}",
			name = device.name,
			state = device.state,
			ready = device.ready()
		);
	}

	// the .names() and .ipads() are implemented on extension traits imported with
	// use apple_clis::prelude::*;
	// to make finding devices easier and more ergonomic
	let ipad_simulator: &IPadVariant = output
		.get_success()
		.expect("to succeed")
		.devices()
		.names()
		.ipads()
		.max()
		.expect("an iPad simulator to be available");
	println!("Found an {} simulator", ipad_simulator);

	if let IPadVariant::Pro {
		size, generation, ..
	} = ipad_simulator
	{
		let inches: f32 = size.inches();
		let gen: u8 = match generation {
			// generations can be M1 or gen 6
			Generation::Num(num) => num.get(),	
			Generation::M(m_gen) => m_gen.get_u8(),
		};
		println!(
			"Ooh, its a pro size {} {:?} generation {} {:?}",
			size, inches, generation, gen,
		);
	}

	// boot the simulator
	let boot_result = simctl_instance.boot(DeviceName::from(*ipad_simulator))?;
	match boot_result {
		simctl::boot::BootOutput::SuccessUnImplemented { .. } => println!("Booted the simulator"),
		simctl::boot::BootOutput::AlreadyBooted => println!("Simulator was already booted"),
		_ => println!("PRs welcome to cover more cases"),
	}

	// open the simulator
	let open_instance = open::OpenCLIInstance::new()?;
	open_instance.open_well_known(&open::well_known::WellKnown::Simulator)?;

	Ok(())
}

impl XcRunSimctlInstance<'_>

pub fn launch( &self, config: &LaunchConfig, simulator_name: DeviceName, ) -> Result<LaunchOutput>

pub fn launch_piped( &self, config: &LaunchConfig, simulator_name: DeviceName, ) -> Result<ExitStatus>

Like Self::launch, but pipes the console of the launched process to the current process’s console.

The upshot of this is you can see your programs logs in the console!

Not setting LaunchConfig::console to true will result in a warning, since presumably you are calling this function over Self::launch to see logs in the console.

impl<'src> XcRunSimctlInstance<'src>

pub fn new(parent: &'src <Self as ExecChild<'src>>::Parent) -> Result<Self>

Constructs an instance of Self using which.

Trait Implementations

impl<'src> Debug for XcRunSimctlInstance<'src>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.