Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-04-04 13:02:01 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix: Use metered properly

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-12-13 00:41:14 +01:00
parent 4b09745fce
commit e1b027a68d
18 changed files with 245 additions and 264 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
Cargo.toml
View file

@ -7,8 +7,8 @@ repository = "https://github.com/Xetibo/ReSet"
license = "GPL-3.0-only"
[dependencies]
reset_daemon = "0.5.3"
re_set-lib = "0.8.0"
reset_daemon = "0.5.5"
re_set-lib = "0.8.1"
adw = { version = "0.5.3", package = "libadwaita", features = ["v1_4"] }
dbus = "0.9.7"
gtk = { version = "0.7.3", package = "gtk4", features = ["v4_12"] }

7
src/components/base/card_entry.rs
View file

@ -13,6 +13,7 @@ use components::utils::create_dropdown_label_factory;
use re_set_lib::audio::audio_structures::Card;
use crate::components;
use crate::components::utils::{BASE, DBUS_PATH, AUDIO};
use super::card_entry_impl;
@ -66,12 +67,12 @@ fn set_card_profile_of_device(device_index: u32, profile_name: String) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetCardProfileOfDevice",
(device_index, profile_name),
);

44
src/components/base/utils.rs
View file

@ -20,7 +20,7 @@ use re_set_lib::{
use crate::components::{
input::source_box::{start_input_box_listener, SourceBox},
output::sink_box::{start_output_box_listener, SinkBox},
output::sink_box::{start_output_box_listener, SinkBox}, utils::{BASE, DBUS_PATH, AUDIO, WIRELESS},
};
#[derive(Default, PartialEq, Eq)]
@ -53,12 +53,12 @@ impl Listeners {
thread::spawn(|| {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "StopNetworkListener", ());
proxy.method_call(WIRELESS, "StopNetworkListener", ());
});
}
@ -90,7 +90,7 @@ impl arg::ReadAll for SinkAdded {
impl dbus::message::SignalArgs for SinkAdded {
const NAME: &'static str = "SinkAdded";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(Sink,)> for SinkAdded {
@ -118,7 +118,7 @@ impl arg::ReadAll for SinkChanged {
impl dbus::message::SignalArgs for SinkChanged {
const NAME: &'static str = "SinkChanged";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(Sink,)> for SinkChanged {
@ -146,7 +146,7 @@ impl arg::ReadAll for SinkRemoved {
impl dbus::message::SignalArgs for SinkRemoved {
const NAME: &'static str = "SinkRemoved";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(u32,)> for SinkRemoved {
@ -174,7 +174,7 @@ impl arg::ReadAll for InputStreamAdded {
impl dbus::message::SignalArgs for InputStreamAdded {
const NAME: &'static str = "InputStreamAdded";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(InputStream,)> for InputStreamAdded {
@ -202,7 +202,7 @@ impl arg::ReadAll for InputStreamChanged {
impl dbus::message::SignalArgs for InputStreamChanged {
const NAME: &'static str = "InputStreamChanged";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
#[derive(Debug)]
@ -224,7 +224,7 @@ impl arg::ReadAll for InputStreamRemoved {
impl dbus::message::SignalArgs for InputStreamRemoved {
const NAME: &'static str = "InputStreamRemoved";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(u32,)> for InputStreamRemoved {
@ -252,7 +252,7 @@ impl arg::ReadAll for SourceAdded {
impl dbus::message::SignalArgs for SourceAdded {
const NAME: &'static str = "SourceAdded";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(Source,)> for SourceAdded {
@ -280,7 +280,7 @@ impl arg::ReadAll for SourceChanged {
impl dbus::message::SignalArgs for SourceChanged {
const NAME: &'static str = "SourceChanged";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(Source,)> for SourceChanged {
@ -308,7 +308,7 @@ impl arg::ReadAll for SourceRemoved {
impl dbus::message::SignalArgs for SourceRemoved {
const NAME: &'static str = "SourceRemoved";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(u32,)> for SourceRemoved {
@ -336,7 +336,7 @@ impl arg::ReadAll for OutputStreamAdded {
impl dbus::message::SignalArgs for OutputStreamAdded {
const NAME: &'static str = "OutputStreamAdded";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(OutputStream,)> for OutputStreamAdded {
@ -364,7 +364,7 @@ impl arg::ReadAll for OutputStreamChanged {
impl dbus::message::SignalArgs for OutputStreamChanged {
const NAME: &'static str = "OutputStreamChanged";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
#[derive(Debug)]
@ -386,7 +386,7 @@ impl arg::ReadAll for OutputStreamRemoved {
impl dbus::message::SignalArgs for OutputStreamRemoved {
const NAME: &'static str = "OutputStreamRemoved";
const INTERFACE: &'static str = "org.Xetibo.ReSet.Audio";
const INTERFACE: &'static str = AUDIO;
}
impl GetVal<(u32,)> for OutputStreamRemoved {
@ -431,19 +431,19 @@ pub fn start_audio_listener(
fn start_dbus_audio_listener(conn: Connection) -> Connection {
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call("org.Xetibo.ReSet.Audio", "StartAudioListener", ());
let _: Result<(), Error> = proxy.method_call(AUDIO, "StartAudioListener", ());
conn
}
fn stop_dbus_audio_listener(conn: Connection) {
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call("org.Xetibo.ReSet.Audio", "StopAudioListener", ());
let _: Result<(), Error> = proxy.method_call(AUDIO, "StopAudioListener", ());
}

67
src/components/bluetooth/bluetooth_box.rs
View file

@ -20,6 +20,7 @@ use re_set_lib::signals::{BluetoothDeviceAdded, BluetoothDeviceChanged, Bluetoot
use crate::components::base::utils::Listeners;
use crate::components::bluetooth::bluetooth_box_impl;
use crate::components::bluetooth::bluetooth_entry::BluetoothEntry;
use crate::components::utils::{DBUS_PATH, BASE, BLUETOOTH};
glib::wrapper! {
pub struct BluetoothBox(ObjectSubclass<bluetooth_box_impl::BluetoothBox>)
@ -123,10 +124,8 @@ pub fn populate_conntected_bluetooth_devices(bluetooth_box: Arc<BluetoothBox>) {
let list = imp.reset_model_list.write().unwrap();
let mut model_index = imp.reset_model_index.write().unwrap();
let mut map = imp.reset_bluetooth_adapters.write().unwrap();
{
if imp.reset_bluetooth_adapters.read().unwrap().is_empty() {
return;
}
if adapters.is_empty() {
return;
}
imp.reset_current_bluetooth_adapter
.replace(adapters.last().unwrap().clone());
@ -209,25 +208,25 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Bluetooth", "StartBluetoothListener", ());
proxy.method_call(BLUETOOTH, "StartBluetoothListener", ());
let device_added = BluetoothDeviceAdded::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let device_removed = BluetoothDeviceRemoved::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let device_changed = BluetoothDeviceChanged::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let device_added_box = bluetooth_box.clone();
@ -334,7 +333,7 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
let _ = conn.process(Duration::from_millis(1000));
if !listeners.bluetooth_listener.load(Ordering::SeqCst) {
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Bluetooth", "StopBluetoothListener", ());
proxy.method_call(BLUETOOTH, "StopBluetoothListener", ());
break;
}
if listener_active && time.elapsed().unwrap() > Duration::from_millis(10000) {
@ -349,7 +348,7 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
});
});
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Bluetooth", "StopBluetoothScan", ());
proxy.method_call(BLUETOOTH, "StopBluetoothScan", ());
}
if !listener_active && listeners.bluetooth_scan_requested.load(Ordering::SeqCst) {
listeners
@ -357,7 +356,7 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
.store(false, Ordering::SeqCst);
listener_active = true;
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Bluetooth", "StartBluetoothListener", ());
proxy.method_call(BLUETOOTH, "StartBluetoothListener", ());
time = SystemTime::now();
}
thread::sleep(Duration::from_millis(100));
@ -368,12 +367,12 @@ pub fn start_bluetooth_listener(listeners: Arc<Listeners>, bluetooth_box: Arc<Bl
fn get_connected_devices() -> Vec<BluetoothDevice> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<BluetoothDevice>,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Bluetooth",
BLUETOOTH,
"GetConnectedBluetoothDevices",
(),
);
@ -386,12 +385,12 @@ fn get_connected_devices() -> Vec<BluetoothDevice> {
fn get_bluetooth_adapters() -> Vec<BluetoothAdapter> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<BluetoothAdapter>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Bluetooth", "GetBluetoothAdapters", ());
proxy.method_call(BLUETOOTH, "GetBluetoothAdapters", ());
if res.is_err() {
return Vec::new();
}
@ -401,23 +400,23 @@ fn get_bluetooth_adapters() -> Vec<BluetoothAdapter> {
fn set_bluetooth_adapter(path: Path<'static>) {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(Vec<BluetoothAdapter>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Bluetooth", "SetBluetoothAdapter", (path,));
proxy.method_call(BLUETOOTH, "SetBluetoothAdapter", (path,));
}
fn set_bluetooth_adapter_visibility(path: Path<'static>, visible: bool) {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Bluetooth",
BLUETOOTH,
"SetBluetoothAdapterDiscoverability",
(path, visible),
);
@ -426,12 +425,12 @@ fn set_bluetooth_adapter_visibility(path: Path<'static>, visible: bool) {
fn set_bluetooth_adapter_pairability(path: Path<'static>, visible: bool) {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Bluetooth",
BLUETOOTH,
"SetBluetoothAdapterPairability",
(path, visible),
);
@ -440,12 +439,12 @@ fn set_bluetooth_adapter_pairability(path: Path<'static>, visible: bool) {
fn set_adapter_enabled(path: Path<'static>, enabled: bool) {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(Vec<BluetoothAdapter>,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Bluetooth",
BLUETOOTH,
"SetBluetoothAdapterEnabled",
(path, enabled),
);

25
src/components/bluetooth/bluetooth_entry.rs
View file

@ -3,6 +3,7 @@ use std::sync::Arc;
use std::time::Duration;
use crate::components::bluetooth::bluetooth_entry_impl;
use crate::components::utils::{BASE, DBUS_PATH, BLUETOOTH};
use adw::glib::Object;
use adw::prelude::{ActionRowExt, PreferencesRowExt};
use adw::{glib, ActionRow};
@ -87,12 +88,12 @@ fn connect_to_device(entry: Arc<BluetoothEntry>, path: Path<'static>) {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Bluetooth",
BLUETOOTH,
"ConnectToBluetoothDevice",
(path,),
);
@ -118,12 +119,12 @@ fn connect_to_device(entry: Arc<BluetoothEntry>, path: Path<'static>) {
// gio::spawn_blocking(move || {
// let conn = Connection::new_session().unwrap();
// let proxy = conn.with_proxy(
// "org.Xetibo.ReSet.Daemon",
// "/org/Xetibo/ReSet/Daemon",
// BASE,
// DBUS_PATH,
// Duration::from_millis(1000),
// );
// let _: Result<(bool,), Error> = proxy.method_call(
// "org.Xetibo.ReSet.Bluetooth",
// BLUETOOTH,
// "PairWithBluetoothDevice",
// (path,),
// );
@ -134,12 +135,12 @@ fn disconnect_from_device(entry: Arc<BluetoothEntry>, path: Path<'static>) {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Bluetooth",
BLUETOOTH,
"DisconnectFromBluetoothDevice",
(path,),
);
@ -164,11 +165,11 @@ fn remove_device_pairing(path: Path<'static>) {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> =
proxy.method_call("org.Xetibo.ReSet.Bluetooth", "RemoveDevicePairing", (path,));
proxy.method_call(BLUETOOTH, "RemoveDevicePairing", (path,));
});
}

20
src/components/input/output_stream_entry.rs
View file

@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis, BASE, DBUS_PATH, AUDIO};
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
@ -134,12 +134,12 @@ fn set_outputstream_volume(value: f64, index: u32, channels: u16) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetOutputStreamVolume",
(index, channels, value as u32),
);
@ -155,12 +155,12 @@ fn toggle_output_stream_mute(index: u32, muted: bool) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetOutputStreamMute",
(index, muted),
);
@ -176,12 +176,12 @@ fn set_source_of_output_stream(stream: u32, source: u32) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetSourceOfOutputStream",
(stream, source),
);

56
src/components/input/source_box.rs
View file

@ -24,7 +24,7 @@ use crate::components::base::utils::{
};
use crate::components::input::source_box_impl;
use crate::components::input::source_entry::set_source_volume;
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis, BASE, DBUS_PATH, AUDIO};
use super::output_stream_entry::OutputStreamEntry;
use super::source_entry::{set_default_source, toggle_source_mute, SourceEntry};
@ -312,12 +312,12 @@ pub fn populate_cards(input_box: Arc<SourceBox>) {
fn get_output_streams() -> Vec<OutputStream> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<OutputStream>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "ListOutputStreams", ());
proxy.method_call(AUDIO, "ListOutputStreams", ());
if res.is_err() {
return Vec::new();
}
@ -327,12 +327,12 @@ fn get_output_streams() -> Vec<OutputStream> {
fn get_sources() -> Vec<Source> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<Source>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "ListSources", ());
proxy.method_call(AUDIO, "ListSources", ());
if res.is_err() {
return Vec::new();
}
@ -342,12 +342,12 @@ fn get_sources() -> Vec<Source> {
fn get_cards() -> Vec<Card> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<Card>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "ListCards", ());
proxy.method_call(AUDIO, "ListCards", ());
if res.is_err() {
return Vec::new();
}
@ -357,12 +357,12 @@ fn get_cards() -> Vec<Card> {
fn get_default_source_name() -> String {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(String,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "GetDefaultSourceName", ());
proxy.method_call(AUDIO, "GetDefaultSourceName", ());
if res.is_err() {
return String::from("");
}
@ -372,12 +372,12 @@ fn get_default_source_name() -> String {
fn get_default_source() -> Source {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Source,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "GetDefaultSource", ());
proxy.method_call(AUDIO, "GetDefaultSource", ());
if res.is_err() {
return Source::default();
}
@ -386,33 +386,33 @@ fn get_default_source() -> Source {
pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) -> Connection {
let source_added = SourceAdded::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let source_removed = SourceRemoved::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let source_changed = SourceChanged::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let output_stream_added = OutputStreamAdded::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let output_stream_removed = OutputStreamRemoved::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let output_stream_changed = OutputStreamChanged::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();

20
src/components/input/source_entry.rs
View file

@ -11,6 +11,8 @@ use glib::{clone, Propagation};
use gtk::{gio, CheckButton};
use re_set_lib::audio::audio_structures::Source;
use crate::components::utils::{BASE, DBUS_PATH, AUDIO};
use super::source_box::{refresh_default_source, SourceBox};
use super::source_entry_impl;
@ -105,12 +107,12 @@ pub fn set_source_volume(value: f64, index: u32, channels: u16) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetSourceVolume",
(index, channels, value as u32),
);
@ -126,12 +128,12 @@ pub fn toggle_source_mute(index: u32, muted: bool) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "SetSourceMute", (index, muted));
proxy.method_call(AUDIO, "SetSourceMute", (index, muted));
// if res.is_err() {
// return false;
// }
@ -143,12 +145,12 @@ pub fn toggle_source_mute(index: u32, muted: bool) -> bool {
pub fn set_default_source(name: Arc<String>) -> Option<Source> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Source,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetDefaultSource",
(name.as_str(),),
);

20
src/components/output/input_stream_entry.rs
View file

@ -1,7 +1,7 @@
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis, BASE, DBUS_PATH, AUDIO};
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
@ -161,12 +161,12 @@ fn set_inputstream_volume(value: f64, index: u32, channels: u16) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetInputStreamVolume",
(index, channels, value as u32),
);
@ -182,12 +182,12 @@ fn toggle_input_stream_mute(index: u32, muted: bool) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetInputStreamMute",
(index, muted),
);
@ -203,12 +203,12 @@ fn set_sink_of_input_stream(stream: u32, sink: u32) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetSinkOfInputStream",
(stream, sink),
);

57
src/components/output/sink_box.rs
View file

@ -23,6 +23,9 @@ use crate::components::base::utils::{
InputStreamAdded, InputStreamChanged, InputStreamRemoved, SinkAdded, SinkChanged, SinkRemoved,
};
use crate::components::output::sink_entry::set_sink_volume;
use crate::components::utils::AUDIO;
use crate::components::utils::BASE;
use crate::components::utils::DBUS_PATH;
use crate::components::utils::{create_dropdown_label_factory, set_combo_row_ellipsis};
use super::input_stream_entry::InputStreamEntry;
@ -310,12 +313,12 @@ pub fn populate_cards(output_box: Arc<SinkBox>) {
fn get_input_streams() -> Vec<InputStream> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<InputStream>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "ListInputStreams", ());
proxy.method_call(AUDIO, "ListInputStreams", ());
if res.is_err() {
return Vec::new();
}
@ -325,12 +328,12 @@ fn get_input_streams() -> Vec<InputStream> {
fn get_sinks() -> Vec<Sink> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<Sink>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "ListSinks", ());
proxy.method_call(AUDIO, "ListSinks", ());
if res.is_err() {
return Vec::new();
}
@ -340,12 +343,12 @@ fn get_sinks() -> Vec<Sink> {
fn get_cards() -> Vec<Card> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Vec<Card>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "ListCards", ());
proxy.method_call(AUDIO, "ListCards", ());
if res.is_err() {
return Vec::new();
}
@ -355,12 +358,12 @@ fn get_cards() -> Vec<Card> {
fn get_default_sink_name() -> String {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(String,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "GetDefaultSinkName", ());
proxy.method_call(AUDIO, "GetDefaultSinkName", ());
if res.is_err() {
return String::from("");
}
@ -370,12 +373,12 @@ fn get_default_sink_name() -> String {
fn get_default_sink() -> Sink {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Sink,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "GetDefaultSink", ());
proxy.method_call(AUDIO, "GetDefaultSink", ());
if res.is_err() {
return Sink::default();
}
@ -384,33 +387,33 @@ fn get_default_sink() -> Sink {
pub fn start_output_box_listener(conn: Connection, sink_box: Arc<SinkBox>) -> Connection {
let sink_added = SinkAdded::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let sink_removed = SinkRemoved::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let sink_changed = SinkChanged::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let input_stream_added = InputStreamAdded::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let input_stream_removed = InputStreamRemoved::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();
let input_stream_changed = InputStreamChanged::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
Some(&BASE.into()),
Some(&Path::from(DBUS_PATH)),
)
.static_clone();

20
src/components/output/sink_entry.rs
View file

@ -11,6 +11,8 @@ use glib::{clone, Propagation};
use gtk::{gio, CheckButton};
use re_set_lib::audio::audio_structures::Sink;
use crate::components::utils::{AUDIO, DBUS_PATH, BASE};
use super::sink_box::{refresh_default_sink, SinkBox};
use super::sink_entry_impl;
@ -103,12 +105,12 @@ pub fn set_sink_volume(value: f64, index: u32, channels: u16) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> = proxy.method_call(
"org.Xetibo.ReSet.Audio",
AUDIO,
"SetSinkVolume",
(index, channels, value as u32),
);
@ -124,12 +126,12 @@ pub fn toggle_sink_mute(index: u32, muted: bool) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "SetSinkMute", (index, muted));
proxy.method_call(AUDIO, "SetSinkMute", (index, muted));
// if res.is_err() {
// return false;
// }
@ -141,12 +143,12 @@ pub fn toggle_sink_mute(index: u32, muted: bool) -> bool {
pub fn set_default_sink(name: Arc<String>) -> Option<Sink> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: Result<(Sink,), Error> =
proxy.method_call("org.Xetibo.ReSet.Audio", "SetDefaultSink", (name.as_str(),));
proxy.method_call(AUDIO, "SetDefaultSink", (name.as_str(),));
if res.is_err() {
return None;
}

6
src/components/utils.rs
View file

@ -5,6 +5,12 @@ use glib::{Cast, Object};
use gtk::prelude::{GObjectPropertyExpressionExt, ListBoxRowExt, ListItemExt, WidgetExt};
use gtk::{Align, SignalListItemFactory, StringObject};
pub const DBUS_PATH: &str = "/org/Xetibo/ReSet/Daemon";
pub const WIRELESS: &str = "org.Xetibo.ReSet.Wireless";
pub const BLUETOOTH: &str = "org.Xetibo.ReSet.Bluetooth";
pub const AUDIO: &str = "org.Xetibo.ReSet.Audio";
pub const BASE: &str = "org.Xetibo.ReSet.Daemon";
pub fn create_dropdown_label_factory() -> SignalListItemFactory {
let factory = SignalListItemFactory::new();
factory.connect_setup(|_, item| {

7
src/components/wifi/saved_wifi_entry.rs
View file

@ -1,6 +1,7 @@
use std::rc::Rc;
use std::time::Duration;
use crate::components::utils::{BASE, DBUS_PATH, WIRELESS};
use crate::components::wifi::saved_wifi_entry_impl;
use crate::components::wifi::utils::get_connection_settings;
use crate::components::wifi::wifi_box_impl::WifiBox;
@ -66,11 +67,11 @@ fn delete_connection(path: Path<'static>) {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "DeleteConnection", (path,));
proxy.method_call(WIRELESS, "DeleteConnection", (path,));
});
}

10
src/components/wifi/utils.rs
View file

@ -6,6 +6,10 @@ use re_set_lib::network::connection::Connection as ResetConnection;
use std::collections::HashMap;
use std::time::Duration;
use crate::components::utils::BASE;
use crate::components::utils::DBUS_PATH;
use crate::components::utils::WIRELESS;
#[derive(Default, Copy, Clone)]
pub enum IpProtocol {
#[default]
@ -19,12 +23,12 @@ type ResultType =
pub fn get_connection_settings(path: Path<'static>) -> ResetConnection {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let res: ResultType =
proxy.method_call("org.Xetibo.ReSet.Wireless", "GetConnectionSettings", (path,));
proxy.method_call(WIRELESS, "GetConnectionSettings", (path,));
if res.is_err() {
ResetConnection::default();
}

101
src/components/wifi/wifi_box.rs
View file

@ -5,7 +5,7 @@ use std::sync::Arc;
use std::time::Duration;
use crate::components::base::utils::Listeners;
use crate::components::utils::set_combo_row_ellipsis;
use crate::components::utils::{set_combo_row_ellipsis, BASE, DBUS_PATH, WIRELESS};
use adw::glib;
use adw::glib::Object;
use adw::prelude::{ComboRowExt, ListBoxRowExt, PreferencesGroupExt, PreferencesRowExt};
@ -103,10 +103,8 @@ pub fn scan_for_wifi(wifi_box: Arc<WifiBox>) {
let list = imp.reset_model_list.write().unwrap();
let mut model_index = imp.reset_model_index.write().unwrap();
let mut map = imp.reset_wifi_devices.write().unwrap();
{
if imp.reset_current_wifi_device.borrow().path == Path::from("/") {
return;
}
if devices.is_empty() {
return;
}
imp.reset_current_wifi_device
.replace(devices.last().unwrap().clone());
@ -192,24 +190,15 @@ pub fn show_stored_connections(wifi_box: Arc<WifiBox>) {
pub fn dbus_start_network_events() {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
Duration::from_millis(1000),
);
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "StartNetworkListener", ());
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let _: Result<(), Error> = proxy.method_call(WIRELESS, "StartNetworkListener", ());
}
pub fn get_access_points() -> Vec<AccessPoint> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
Duration::from_millis(1000),
);
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<AccessPoint>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "ListAccessPoints", ());
proxy.method_call(WIRELESS, "ListAccessPoints", ());
if res.is_err() {
return Vec::new();
}
@ -219,24 +208,15 @@ pub fn get_access_points() -> Vec<AccessPoint> {
pub fn set_wifi_device(path: Path<'static>) {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "SetWifiDevice", (path,));
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let _: Result<(bool,), Error> = proxy.method_call(WIRELESS, "SetWifiDevice", (path,));
}
pub fn get_wifi_devices() -> Vec<WifiDevice> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
Duration::from_millis(1000),
);
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<WifiDevice>,), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "GetAllWifiDevices", ());
proxy.method_call(WIRELESS, "GetAllWifiDevices", ());
if res.is_err() {
return Vec::new();
}
@ -246,13 +226,8 @@ pub fn get_wifi_devices() -> Vec<WifiDevice> {
pub fn get_wifi_status() -> bool {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
Duration::from_millis(1000),
);
let res: Result<(bool,), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "GetWifiStatus", ());
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(bool,), Error> = proxy.method_call(WIRELESS, "GetWifiStatus", ());
if res.is_err() {
return false;
}
@ -261,13 +236,8 @@ pub fn get_wifi_status() -> bool {
pub fn get_stored_connections() -> Vec<(Path<'static>, Vec<u8>)> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
Duration::from_millis(1000),
);
let res: ResultMap =
proxy.method_call("org.Xetibo.ReSet.Wireless", "ListStoredConnections", ());
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: ResultMap = proxy.method_call(WIRELESS, "ListStoredConnections", ());
if res.is_err() {
return Vec::new();
}
@ -277,13 +247,8 @@ pub fn get_stored_connections() -> Vec<(Path<'static>, Vec<u8>)> {
pub fn set_wifi_enabled(enabled: bool) {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> =
proxy.method_call("org.Xetibo.ReSet.Wireless", "SetWifiEnabled", (enabled,));
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let _: Result<(bool,), Error> = proxy.method_call(WIRELESS, "SetWifiEnabled", (enabled,));
}
pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
@ -300,26 +265,18 @@ pub fn start_event_listener(listeners: Arc<Listeners>, wifi_box: Arc<WifiBox>) {
let removed_ref = wifi_box.clone();
let changed_ref = wifi_box.clone();
let wifi_changed_ref = wifi_box.clone();
let access_point_added = AccessPointAdded::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
)
.static_clone();
let access_point_removed = AccessPointRemoved::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
)
.static_clone();
let access_point_changed = AccessPointChanged::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
)
.static_clone();
let device_changed = WifiDeviceChanged::match_rule(
Some(&"org.Xetibo.ReSet.Daemon".into()),
Some(&Path::from("/org/Xetibo/ReSet/Daemon")),
)
.static_clone();
let access_point_added =
AccessPointAdded::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH)))
.static_clone();
let access_point_removed =
AccessPointRemoved::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH)))
.static_clone();
let access_point_changed =
AccessPointChanged::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH)))
.static_clone();
let device_changed =
WifiDeviceChanged::match_rule(Some(&BASE.into()), Some(&Path::from(DBUS_PATH)))
.static_clone();
let res = conn.add_match(access_point_added, move |ir: AccessPointAdded, _, _| {
let wifi_box = added_ref.clone();
glib::spawn_future(async move {

19
src/components/wifi/wifi_entry.rs
View file

@ -2,6 +2,7 @@ use std::ops::Deref;
use std::sync::Arc;
use std::time::Duration;
use crate::components::utils::{WIRELESS, DBUS_PATH, BASE};
use crate::components::wifi::utils::get_connection_settings;
use adw::glib;
use adw::glib::{Object, PropertySet};
@ -123,12 +124,12 @@ pub fn click_disconnect(entry: Arc<WifiEntry>) {
let imp = entry_ref.imp();
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(10000),
);
let res: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Wireless",
WIRELESS,
"DisconnectFromCurrentAccessPoint",
(),
);
@ -154,12 +155,12 @@ pub fn click_stored_network(entry: Arc<WifiEntry>) {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(10000),
);
let res: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Wireless",
WIRELESS,
"ConnectToKnownAccessPoint",
(access_point,),
);
@ -197,12 +198,12 @@ pub fn click_new_network(entry: Arc<WifiEntry>) {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(10000),
);
let res: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Wireless",
WIRELESS,
"ConnectToNewAccessPoint",
(access_point, password),
);

9
src/components/wifi/wifi_options.rs
View file

@ -18,6 +18,7 @@ use re_set_lib::network::connection::{
use IpProtocol::{IPv4, IPv6};
use crate::components::utils::{BASE, DBUS_PATH, WIRELESS};
use crate::components::wifi::utils::IpProtocol;
use crate::components::wifi::wifi_address_entry::WifiAddressEntry;
use crate::components::wifi::wifi_options_impl;
@ -59,7 +60,7 @@ impl WifiOptions {
.set_active(conn.settings.autoconnect);
self_imp
.reset_wifi_metered
.set_active(conn.settings.metered != -1);
.set_active(conn.settings.metered != 0);
match &conn.device {
TypeSettings::WIFI(wifi) => {
self_imp.reset_wifi_link_speed.set_visible(false);
@ -389,12 +390,12 @@ fn set_connection_settings(path: Path<'static>, prop: HashMap<String, PropMap>)
gio::spawn_blocking(move || {
let conn = dbus::blocking::Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(1000),
);
let _: Result<(bool,), Error> = proxy.method_call(
"org.Xetibo.ReSet.Wireless",
WIRELESS,
"SetConnectionSettings",
(path, prop),
);

17
src/main.rs
View file

@ -1,6 +1,7 @@
use std::thread;
use std::time::Duration;
use components::utils::{BASE, DBUS_PATH};
use components::window::reset_window::ReSetWindow;
use dbus::blocking::Connection;
use dbus::Error;
@ -9,6 +10,8 @@ use gtk::prelude::*;
use gtk::{gio, Application, CssProvider};
use reset_daemon::run_daemon;
mod components;
const APP_ID: &str = "org.Xetibo.ReSet";
@ -53,12 +56,12 @@ fn shutdown(_: &Application) {
thread::spawn(|| {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(100),
);
let res: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Daemon", "UnregisterClient", ("ReSet",));
proxy.method_call(BASE, "UnregisterClient", ("ReSet",));
res
});
}
@ -67,16 +70,16 @@ async fn daemon_check() {
let handle = thread::spawn(|| {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSet.Daemon",
"/org/Xetibo/ReSet/Daemon",
BASE,
DBUS_PATH,
Duration::from_millis(100),
);
let res: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSet.Daemon", "RegisterClient", ("ReSet",));
proxy.method_call(BASE, "RegisterClient", ("ReSet",));
res
});
let res = handle.join();
if res.unwrap().is_err() {
run_daemon(APP_ID).await;
run_daemon().await;
}
}