Struct Permissions 

#[non_exhaustive]
pub struct Permissions {
    pub accessibility: bool,
    pub screen_recording: bool,
}

Which OS permissions the current process holds.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

accessibility: bool

Accessibility / UI automation access.

screen_recording: bool

Screen capture access.

Implementations

impl Permissions

pub const GRANTED: Self

Every permission granted.

pub const fn new(accessibility: bool, screen_recording: bool) -> Self

Creates a permission report.

pub const fn all_granted(&self) -> bool

True when nothing is missing.

Examples found in repository

examples/inspect.rs (line 26)

fn main() -> ExitCode {
    use computer_use::{CaptureOptions, Computer};

    let mut args = std::env::args().skip(1);
    let Some(app) = args.next() else {
        eprintln!("usage: inspect <app name | bundle id | pid:N> [screenshot.png]");
        return ExitCode::FAILURE;
    };
    let output = args.next();

    let run = || -> computer_use::Result<()> {
        let mut computer = Computer::new()?;
        let permissions = computer.permissions();
        if !permissions.all_granted() {
            eprintln!("warning: missing permissions: {permissions:?}");
        }
        let started = std::time::Instant::now();
        let state = computer.get_app_state(&app, &CaptureOptions::default())?;
        println!("{state}");
        eprintln!("\ncaptured {} elements in {:?}", state.elements.len(), started.elapsed());
        if let (Some(path), Some(shot)) = (output, &state.screenshot) {
            std::fs::write(&path, shot.png())?;
            eprintln!("saved {}x{} screenshot to {path}", shot.width(), shot.height());
        }
        Ok(())
    };
    match run() {
        Ok(()) => ExitCode::SUCCESS,
        Err(e) => {
            eprintln!("error: {e}");
            ExitCode::FAILURE
        }
    }
}

Trait Implementations

impl Clone for Permissions

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Permissions

impl Debug for Permissions

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

Formats the value using the given formatter.

impl Eq for Permissions

impl Hash for Permissions

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Permissions

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Permissions