1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
//! # Examples
//!
//! How to monitor if there's a new update and install it.
//! Only available for Flatpak applications.
//!
//! ```rust,no_run
//! use ashpd::{flatpak::FlatpakProxy, WindowIdentifier};
//!
//! async fn run() -> ashpd::Result<()> {
//! let connection = zbus::Connection::session().await?;
//! let proxy = FlatpakProxy::new(&connection).await?;
//!
//! let monitor = proxy.create_update_monitor().await?;
//! let info = monitor.receive_update_available().await?;
//!
//! monitor.update(&WindowIdentifier::default()).await?;
//! let progress = monitor.receive_progress().await?;
//! println!("{:#?}", progress);
//!
//! Ok(())
//! }
//! ```
use serde_repr::{Deserialize_repr, Serialize_repr};
use zbus::zvariant::{DeserializeDict, ObjectPath, SerializeDict, Type};
use super::DESTINATION;
use crate::{
helpers::{call_method, receive_signal},
Error, WindowIdentifier,
};
#[derive(SerializeDict, DeserializeDict, Type, Debug, Default)]
/// Specified options for a [`UpdateMonitorProxy::update`] request.
///
/// Currently there are no possible options yet.
#[zvariant(signature = "dict")]
struct UpdateOptions {}
#[derive(SerializeDict, DeserializeDict, Type, Debug)]
/// A response containing the update information when an update is available.
#[zvariant(signature = "dict")]
pub struct UpdateInfo {
#[zvariant(rename = "running-commit")]
/// The currently running OSTree commit.
running_commit: String,
#[zvariant(rename = "local-commit")]
/// The locally installed OSTree commit.
local_commit: String,
#[zvariant(rename = "remote-commit")]
/// The available commit to install.
remote_commit: String,
}
impl UpdateInfo {
pub fn running_commit(&self) -> &str {
&self.running_commit
}
pub fn local_commit(&self) -> &str {
&self.local_commit
}
pub fn remote_commit(&self) -> &str {
&self.remote_commit
}
}
#[derive(Serialize_repr, Deserialize_repr, PartialEq, Copy, Clone, Debug, Type)]
#[repr(u32)]
/// The update status.
pub enum UpdateStatus {
#[doc(alias = "XDP_UPDATE_STATUS_RUNNING")]
/// Running.
Running = 0,
#[doc(alias = "XDP_UPDATE_STATUS_EMPTY")]
/// No update to install.
Empty = 1,
#[doc(alias = "XDP_UPDATE_STATUS_DONE")]
/// Done.
Done = 2,
#[doc(alias = "XDP_UPDATE_STATUS_FAILED")]
/// Failed.
Failed = 3,
}
#[derive(SerializeDict, DeserializeDict, Type, Debug)]
/// A response of the update progress signal.
#[zvariant(signature = "dict")]
pub struct UpdateProgress {
/// The number of operations that the update consists of.
pub n_ops: Option<u32>,
/// The position of the currently active operation.
pub op: Option<u32>,
/// The progress of the currently active operation, as a number between 0
/// and 100.
pub progress: Option<u32>,
/// The overall status of the update.
pub status: Option<UpdateStatus>,
/// The error name, sent when status is `UpdateStatus::Failed`.
pub error: Option<String>,
/// The error message, sent when status is `UpdateStatus::Failed`.
pub error_message: Option<String>,
}
/// The interface exposes some interactions with Flatpak on the host to the
/// sandbox. For example, it allows you to restart the applications or start a
/// more sandboxed instance.
///
/// Wrapper of the DBus interface: [`org.freedesktop.portal.Flatpak.UpdateMonitor`](https://flatpak.github.io/xdg-desktop-portal/index.html#gdbus-org.freedesktop.portal.Flatpak.UpdateMonitor).
#[derive(Debug)]
#[doc(alias = "org.freedesktop.portal.Flatpak.UpdateMonitor")]
pub struct UpdateMonitorProxy<'a>(zbus::Proxy<'a>);
impl<'a> UpdateMonitorProxy<'a> {
/// Create a new instance of [`UpdateMonitorProxy`].
///
/// **Note** A [`UpdateMonitorProxy`] is not supposed to be created
/// manually.
pub(crate) async fn new(
connection: &zbus::Connection,
path: ObjectPath<'a>,
) -> Result<UpdateMonitorProxy<'a>, Error> {
let proxy = zbus::ProxyBuilder::new_bare(connection)
.interface("org.freedesktop.portal.Flatpak.UpdateMonitor")?
.path(path)?
.destination(DESTINATION)?
.build()
.await?;
Ok(Self(proxy))
}
/// Get a reference to the underlying Proxy.
pub fn inner(&self) -> &zbus::Proxy<'_> {
&self.0
}
/// A signal received when there's progress during the application update.
///
/// # Specifications
///
/// See also [`Progress`](https://flatpak.github.io/xdg-desktop-portal/index.html#gdbus-signal-org-freedesktop-portal-Flatpak-UpdateMonitor.Progress).
#[doc(alias = "Progress")]
#[doc(alias = "XdpPortal::update-progress")]
pub async fn receive_progress(&self) -> Result<UpdateProgress, Error> {
receive_signal(self.inner(), "Progress").await
}
/// A signal received when there's an application update.
///
/// # Specifications
///
/// See also [`UpdateAvailable`](https://flatpak.github.io/xdg-desktop-portal/index.html#gdbus-signal-org-freedesktop-portal-Flatpak-UpdateMonitor.UpdateAvailable).
#[doc(alias = "UpdateAvailable")]
#[doc(alias = "XdpPortal::update-available")]
pub async fn receive_update_available(&self) -> Result<UpdateInfo, Error> {
receive_signal(self.inner(), "UpdateAvailable").await
}
/// Asks to install an update of the calling app.
///
/// **Note** updates are only allowed if the new version has the same
/// permissions (or less) than the currently installed version.
///
/// # Specifications
///
/// See also [`Update`](https://flatpak.github.io/xdg-desktop-portal/index.html#gdbus-method-org-freedesktop-portal-Flatpak-UpdateMonitor.Update).
#[doc(alias = "Update")]
#[doc(alias = "xdp_portal_update_install")]
pub async fn update(&self, identifier: &WindowIdentifier) -> Result<(), Error> {
let options = UpdateOptions::default();
call_method(self.inner(), "Update", &(&identifier, options)).await
}
/// Ends the update monitoring and cancels any ongoing installation.
///
/// # Specifications
///
/// See also [`Close`](https://flatpak.github.io/xdg-desktop-portal/index.html#gdbus-method-org-freedesktop-portal-Flatpak-UpdateMonitor.Close).
#[doc(alias = "Close")]
pub async fn close(&self) -> Result<(), Error> {
call_method(self.inner(), "Close", &()).await
}
}