use std::sync::mpsc::{channel, Receiver};
use std::sync::{Arc, Mutex};
use bevy::prelude::*;
use bevy::tasks::{block_on, IoTaskPool, Task};
use crate::core::config::LicenseConfig;
use crate::core::engine::{resolve, run_check};
use crate::core::error::CheckErr;
use crate::core::state::{now_secs, LicenseState};
use crate::core::status::LicenseStatus;
use crate::provider::{KeygenProvider, LicenseProvider};
pub use crate::open_url;
#[derive(Resource, Default)]
pub struct License(pub LicenseState);
#[derive(Resource, Clone, Copy, PartialEq, Eq, Default)]
pub struct Licensed(pub LicenseStatus);
impl Licensed {
pub fn unlocked(&self) -> bool {
self.0.unlocked()
}
}
#[derive(Resource, Default)]
pub struct LicenseLog(pub Vec<String>);
#[derive(Resource, Clone)]
pub struct LicenseSettings(pub LicenseConfig);
#[derive(Resource, Clone)]
struct LicenseBackend(Arc<dyn LicenseProvider>);
#[derive(Resource, Default)]
pub struct LicenseJob(Option<LicenseTask>);
struct LicenseTask {
task: Task<Result<bool, CheckErr>>,
rx: Mutex<Receiver<String>>,
}
#[derive(Message)]
pub struct ActivateLicense;
#[derive(Message)]
pub struct ClearLicense;
pub struct LicensingPlugin {
config: LicenseConfig,
provider: Arc<dyn LicenseProvider>,
}
impl LicensingPlugin {
pub fn new(config: LicenseConfig, provider: Arc<dyn LicenseProvider>) -> Self {
Self { config, provider }
}
pub fn keygen(config: LicenseConfig) -> Self {
let provider = Arc::new(KeygenProvider::from_config(&config));
Self::new(config, provider)
}
}
impl Plugin for LicensingPlugin {
fn build(&self, app: &mut App) {
let state = LicenseState::load(&self.config.storage);
app.insert_resource(License(state))
.insert_resource(Licensed::default())
.init_resource::<LicenseLog>()
.init_resource::<LicenseJob>()
.insert_resource(LicenseSettings(self.config.clone()))
.insert_resource(LicenseBackend(self.provider.clone()))
.add_message::<ActivateLicense>()
.add_message::<ClearLicense>()
.add_systems(Startup, start_license_check)
.add_systems(Update, (handle_activate, handle_clear, poll_license_job));
}
}
fn log_line(log: &mut LicenseLog, line: impl Into<String>) {
log.0.push(line.into());
}
fn spawn_check(state: &LicenseState, provider: &Arc<dyn LicenseProvider>, job: &mut LicenseJob) {
let (tx, rx) = channel();
let probe = LicenseState {
key: state.key.trim().to_string(),
fingerprint: state.fingerprint.clone(),
last_validated: state.last_validated,
};
let provider = provider.clone();
let task = IoTaskPool::get().spawn(async move {
let mut progress = |m: String| {
let _ = tx.send(m);
};
run_check(provider.as_ref(), &probe, &mut progress)
});
job.0 = Some(LicenseTask {
task,
rx: Mutex::new(rx),
});
}
fn start_license_check(
license: Res<License>,
backend: Res<LicenseBackend>,
mut job: ResMut<LicenseJob>,
mut status: ResMut<Licensed>,
) {
if license.0.key.trim().is_empty() {
status.0 = LicenseStatus::Locked;
} else {
spawn_check(&license.0, &backend.0, &mut job); }
}
fn handle_activate(
mut messages: MessageReader<ActivateLicense>,
license: Res<License>,
backend: Res<LicenseBackend>,
mut job: ResMut<LicenseJob>,
mut status: ResMut<Licensed>,
mut log: ResMut<LicenseLog>,
) {
if messages.read().count() == 0 {
return;
}
if license.0.key.trim().is_empty() {
log_line(&mut log, "paste a license key first");
} else if job.0.is_none() {
status.0 = LicenseStatus::Unknown;
spawn_check(&license.0, &backend.0, &mut job);
}
}
fn handle_clear(mut messages: MessageReader<ClearLicense>, mut license: ResMut<License>) {
if messages.read().count() > 0 {
license.0.key.clear();
}
}
fn poll_license_job(
mut job: ResMut<LicenseJob>,
mut license: ResMut<License>,
settings: Res<LicenseSettings>,
mut status: ResMut<Licensed>,
mut log: ResMut<LicenseLog>,
) {
let mut finished = false;
if let Some(j) = job.0.as_mut() {
while let Ok(line) = j.rx.lock().unwrap().try_recv() {
log_line(&mut log, line);
}
finished = j.task.is_finished();
}
if !finished {
return;
}
let j = job.0.take().unwrap();
let result = block_on(j.task);
let res = resolve(result, &mut license.0, now_secs(), settings.0.grace_secs);
status.0 = res.status;
if status.0 == LicenseStatus::Active {
license.0.save(&settings.0.storage);
}
if let Some(msg) = res.message {
log_line(&mut log, msg);
}
}