use crate::manifest::{UpdateKind, UpdateManifest};
use crate::{Error, Result, Timestamp};
use serde::{Deserialize, Serialize};
use std::collections::BTreeSet;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ConsentMode {
#[default]
Ask,
Auto,
NotifyOnly,
Off,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Flavor {
Desktop,
Sideload,
Play,
AppStore,
MacAppStore,
FDroid,
}
impl Flavor {
pub fn default_mode(self) -> ConsentMode {
match self {
Self::FDroid => ConsentMode::Off,
_ => ConsentMode::Ask,
}
}
pub fn allows(self, kind: &UpdateKind, dart_patches: bool) -> bool {
match kind {
UpdateKind::StoreNotice { .. } => true,
UpdateKind::Assets | UpdateKind::Wasm { .. } => !matches!(self, Self::MacAppStore),
UpdateKind::Full(_) => matches!(self, Self::Desktop | Self::Sideload),
UpdateKind::DartPatch(_) => dart_patches && matches!(self, Self::Desktop | Self::Sideload | Self::Play),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Policy {
pub flavor: Flavor,
#[serde(default)]
pub dart_patches: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum Choice {
Accepted,
Declined,
Mode(ConsentMode),
FDroidBypassAcknowledged,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConsentRecord {
pub update_id: Option<String>,
pub choice: Choice,
pub at: Timestamp,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConsentLog {
pub records: Vec<ConsentRecord>,
}
impl ConsentLog {
pub fn decide(&mut self, update_id: &str, accepted: bool, at: Timestamp) {
let choice = if accepted { Choice::Accepted } else { Choice::Declined };
self.records.push(ConsentRecord { update_id: Some(update_id.to_owned()), choice, at });
}
pub fn set_mode(&mut self, flavor: Flavor, mode: ConsentMode, at: Timestamp) -> Result<()> {
if flavor == Flavor::FDroid && mode != ConsentMode::Off && !self.fdroid_acknowledged() {
return Err(Error::invalid("consent", "F-Droid builds need the bypass acknowledgement before updates are enabled"));
}
self.records.push(ConsentRecord { update_id: None, choice: Choice::Mode(mode), at });
Ok(())
}
pub fn acknowledge_fdroid(&mut self, at: Timestamp) {
self.records.push(ConsentRecord { update_id: None, choice: Choice::FDroidBypassAcknowledged, at });
}
fn fdroid_acknowledged(&self) -> bool {
self.records.iter().any(|r| r.choice == Choice::FDroidBypassAcknowledged)
}
pub fn mode(&self, flavor: Flavor) -> ConsentMode {
self.records
.iter()
.rev()
.find_map(|r| match r.choice {
Choice::Mode(m) => Some(m),
_ => None,
})
.unwrap_or(flavor.default_mode())
}
pub fn choice_for(&self, update_id: &str) -> Option<bool> {
self.records.iter().rev().find_map(|r| match (&r.update_id, &r.choice) {
(Some(id), Choice::Accepted) if id == update_id => Some(true),
(Some(id), Choice::Declined) if id == update_id => Some(false),
_ => None,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum AskReason {
PerUpdate,
NewCapabilities,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SkipReason {
Off,
Declined,
KindNotAllowed,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Decision {
Install,
Ask {
reason: AskReason,
new_capabilities: Vec<String>,
security: bool,
},
Notify {
security: bool,
},
Skip(SkipReason),
}
pub fn decide(policy: &Policy, log: &ConsentLog, update: &UpdateManifest, granted: &BTreeSet<String>) -> Decision {
if !policy.flavor.allows(&update.kind, policy.dart_patches) {
return Decision::Skip(SkipReason::KindNotAllowed);
}
let mode = log.mode(policy.flavor);
let security = update.labels.security.is_some();
if mode == ConsentMode::Off {
return Decision::Skip(SkipReason::Off);
}
if matches!(update.kind, UpdateKind::StoreNotice { .. }) {
return Decision::Notify { security };
}
match log.choice_for(&update.update_id) {
Some(false) => return Decision::Skip(SkipReason::Declined),
Some(true) => return Decision::Install,
None => {}
}
let new_capabilities: Vec<String> = update.capabilities.iter().filter(|c| !granted.contains(*c)).cloned().collect();
match mode {
ConsentMode::NotifyOnly => Decision::Notify { security },
ConsentMode::Ask => Decision::Ask { reason: AskReason::PerUpdate, new_capabilities, security },
ConsentMode::Auto if new_capabilities.is_empty() => Decision::Install,
ConsentMode::Auto => Decision::Ask { reason: AskReason::NewCapabilities, new_capabilities, security },
ConsentMode::Off => Decision::Skip(SkipReason::Off),
}
}