237 lines
11 KiB
Rust
237 lines
11 KiB
Rust
use crate::{display, models};
|
|
use image::EncodableLayout;
|
|
use paris::{warn, info, error};
|
|
use rumqttc::{
|
|
AsyncClient, ConnectReturnCode, Event, EventLoop, Incoming, MqttOptions, Outgoing, QoS,
|
|
};
|
|
use std::{borrow::Borrow, rc::Rc, sync::Arc, time::Duration};
|
|
use tauri::async_runtime::{Mutex, TokioJoinHandle};
|
|
use time::{format_description, OffsetDateTime};
|
|
use tokio::{sync::broadcast, task, time::sleep};
|
|
|
|
const DISPLAY_TOPIC: &'static str = "display-ambient-light/display";
|
|
const DISPLAY_BRIGHTNESS_TOPIC: &'static str = "display-ambient-light/board/brightness";
|
|
const BOARD_SEND_CMD: &'static str = "display-ambient-light/board/cmd";
|
|
const DESKTOP_SEND_CMD: &'static str = "display-ambient-light/desktop/cmd";
|
|
|
|
pub struct MqttRpc {
|
|
client: AsyncClient,
|
|
change_display_brightness_tx: broadcast::Sender<display::DisplayBrightness>,
|
|
message_tx: broadcast::Sender<models::MqMessage>,
|
|
eventloop: Arc<Mutex<EventLoop>>,
|
|
}
|
|
|
|
impl MqttRpc {
|
|
pub fn new() -> Self {
|
|
let mut options = MqttOptions::new("rumqtt-async", "192.168.31.11", 1883);
|
|
options.set_keep_alive(Duration::from_secs(5));
|
|
options.set_clean_session(false);
|
|
|
|
let (client, mut eventloop) = AsyncClient::new(options, 10);
|
|
|
|
let (change_display_brightness_tx, _) =
|
|
broadcast::channel::<display::DisplayBrightness>(16);
|
|
let (message_tx, _) = broadcast::channel::<models::MqMessage>(32);
|
|
|
|
Self {
|
|
client,
|
|
change_display_brightness_tx,
|
|
message_tx,
|
|
eventloop: Arc::new(Mutex::new(eventloop)),
|
|
}
|
|
}
|
|
|
|
pub async fn listen(&self) {
|
|
let change_display_brightness_tx2 = self.change_display_brightness_tx.clone();
|
|
let message_tx_cloned = self.message_tx.clone();
|
|
|
|
let mut eventloop = self.eventloop.clone().lock_owned().await;
|
|
|
|
loop {
|
|
match eventloop.poll().await {
|
|
Ok(notification) => {
|
|
if let Event::Incoming(notification) = notification {
|
|
if let Incoming::Publish(notification) = notification {
|
|
match notification.topic.as_str() {
|
|
DISPLAY_BRIGHTNESS_TOPIC => {
|
|
let payload_text = String::from_utf8(
|
|
notification.payload.as_bytes().to_owned(),
|
|
);
|
|
match payload_text {
|
|
Ok(payload_text) => {
|
|
let display_brightness: Result<
|
|
display::DisplayBrightness,
|
|
_,
|
|
> = serde_json::from_str(payload_text.as_str());
|
|
match display_brightness {
|
|
Ok(display_brightness) => {
|
|
match change_display_brightness_tx2
|
|
.send(display_brightness)
|
|
{
|
|
Ok(_) => {}
|
|
Err(err) => {
|
|
warn!(
|
|
"can not broadcast display brightness. {:?}",
|
|
err
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
warn!(
|
|
"can not deserialize display brightness. {:?}",
|
|
err
|
|
);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
warn!(
|
|
"can not decode display brightness message. {:?}",
|
|
err
|
|
);
|
|
}
|
|
};
|
|
}
|
|
BOARD_SEND_CMD => {
|
|
let payload_text = String::from_utf8(
|
|
notification.payload.as_bytes().to_owned(),
|
|
);
|
|
match payload_text {
|
|
Ok(payload_text) => {
|
|
let message: Result<models::MqMessage, _> =
|
|
serde_json::from_str(payload_text.as_str());
|
|
match message {
|
|
Ok(message) => {
|
|
match message_tx_cloned.send(message) {
|
|
Ok(_) => {}
|
|
Err(err) => {
|
|
warn!(
|
|
"can not broadcast mq message. {:?}",
|
|
err
|
|
);
|
|
}
|
|
};
|
|
}
|
|
Err(err) => {
|
|
warn!(
|
|
"can not deserialize mq message. {:?}",
|
|
err
|
|
);
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
warn!("can not decode mq message message. {:?}", err);
|
|
}
|
|
};
|
|
}
|
|
&_ => {}
|
|
};
|
|
} else if let Incoming::ConnAck(connAck) = notification {
|
|
if connAck.code == ConnectReturnCode::Success {
|
|
match self.initialize().await {
|
|
Ok(_) => {
|
|
info!("resubscribe topics!");
|
|
}
|
|
Err(err) => {
|
|
info!("resubscribe topics failed! {:?}", err);
|
|
}
|
|
};
|
|
}
|
|
} else if let Incoming::Disconnect = notification {
|
|
error!("MQTT Disconnected!");
|
|
}
|
|
}
|
|
}
|
|
Err(err) => {
|
|
println!("MQTT Error Event = {:?}", err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn initialize(&self) -> anyhow::Result<()> {
|
|
self.subscribe_board().await?;
|
|
self.subscribe_display().await?;
|
|
self.broadcast_desktop_online();
|
|
anyhow::Ok(())
|
|
}
|
|
|
|
async fn subscribe_board(&self) -> anyhow::Result<()> {
|
|
self.client
|
|
.subscribe("display-ambient-light/board/#", QoS::AtMostOnce)
|
|
.await
|
|
.map_err(|err| anyhow::anyhow!("subscribe board failed. {:?}", err))
|
|
}
|
|
async fn subscribe_display(&self) -> anyhow::Result<()> {
|
|
self.client
|
|
.subscribe(format!("{}/#", DISPLAY_TOPIC), QoS::AtMostOnce)
|
|
.await
|
|
.map_err(|err| anyhow::anyhow!("subscribe board failed. {:?}", err))
|
|
}
|
|
|
|
fn broadcast_desktop_online(&self) {
|
|
let client = self.client.to_owned();
|
|
task::spawn(async move {
|
|
loop {
|
|
match OffsetDateTime::now_utc()
|
|
.format(&format_description::well_known::Iso8601::DEFAULT)
|
|
{
|
|
Ok(now_str) => {
|
|
match client
|
|
.publish(
|
|
"display-ambient-light/desktop/online",
|
|
QoS::AtLeastOnce,
|
|
false,
|
|
now_str.as_bytes(),
|
|
)
|
|
.await
|
|
{
|
|
Ok(_) => {}
|
|
Err(error) => {
|
|
warn!("can not publish last online time. {}", error)
|
|
}
|
|
}
|
|
}
|
|
Err(error) => {
|
|
warn!("can not get time for now. {}", error);
|
|
}
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(1000)).await;
|
|
}
|
|
});
|
|
}
|
|
|
|
pub async fn publish_led_sub_pixels(&self, payload: Vec<u8>) -> anyhow::Result<()> {
|
|
self.client
|
|
.publish(
|
|
"display-ambient-light/desktop/colors",
|
|
rumqttc::QoS::AtLeastOnce,
|
|
false,
|
|
payload,
|
|
)
|
|
.await
|
|
.map_err(|error| anyhow::anyhow!("mqtt publish failed. {}", error))
|
|
}
|
|
|
|
pub fn subscribe_change_display_brightness_rx(
|
|
&self,
|
|
) -> broadcast::Receiver<display::DisplayBrightness> {
|
|
self.change_display_brightness_tx.subscribe()
|
|
}
|
|
pub async fn publish_desktop_cmd(&self, msg: models::MqMessage) -> anyhow::Result<()> {
|
|
let str = serde_json::to_string(&msg)
|
|
.map_err(|err| anyhow::anyhow!("can not serialize {:?}. {:?}", msg, err))?;
|
|
self.client
|
|
.publish(
|
|
DESKTOP_SEND_CMD,
|
|
rumqttc::QoS::AtLeastOnce,
|
|
false,
|
|
str.as_bytes(),
|
|
)
|
|
.await
|
|
.map_err(|error| anyhow::anyhow!("mqtt publish failed. {}", error))
|
|
}
|
|
}
|