hongshaorou/rustdesk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove redundent global variables

Browse Source 
Signed-off-by: fufesou <shuanglongchen@yeah.net>
This commit is contained in:
fufesou 2023-11-19 23:48:18 +08:00
parent 7c98bfd363
commit 85ddfc0739
5 changed files with 130 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
src/privacy_mode.rs
View File

@ -61,6 +61,8 @@ pub trait PrivacyMode: Sync + Send {
fn pre_conn_id(&self) -> i32; fn pre_conn_id(&self) -> i32;
fn get_impl_key(&self) -> &str;
#[inline] #[inline]
fn check_on_conn_id(&self, conn_id: i32) -> ResultType<bool> { fn check_on_conn_id(&self, conn_id: i32) -> ResultType<bool> {
let pre_conn_id = self.pre_conn_id(); let pre_conn_id = self.pre_conn_id();
@ -117,24 +119,21 @@ lazy_static::lazy_static! {
} }
}; };
static ref CUR_PRIVACY_MODE_IMPL: Arc<Mutex<String>> = { static ref PRIVACY_MODE: Arc<Mutex<Option<Box<dyn PrivacyMode>>>> = {
let mut cur_impl = get_option("privacy-mode-impl-key".to_owned()); let mut cur_impl = get_option("privacy-mode-impl-key".to_owned());
if !get_supported_privacy_mode_impl().iter().any(|(k, _)| k == &cur_impl) { if !get_supported_privacy_mode_impl().iter().any(|(k, _)| k == &cur_impl) {
cur_impl = DEFAULT_PRIVACY_MODE_IMPL.to_owned(); cur_impl = DEFAULT_PRIVACY_MODE_IMPL.to_owned();
} }
Arc::new(Mutex::new(cur_impl))
};
static ref PRIVACY_MODE: Arc<Mutex<Option<Box<dyn PrivacyMode>>>> = {
let cur_impl = (*CUR_PRIVACY_MODE_IMPL.lock().unwrap()).clone();
let privacy_mode = match PRIVACY_MODE_CREATOR.lock().unwrap().get(&(&cur_impl as &str)) { let privacy_mode = match PRIVACY_MODE_CREATOR.lock().unwrap().get(&(&cur_impl as &str)) {
Some(creator) => Some(creator()), Some(creator) => Some(creator(&cur_impl)),
None => None, None => None,
}; };
Arc::new(Mutex::new(privacy_mode)) Arc::new(Mutex::new(privacy_mode))
}; };
} }
pub type PrivacyModeCreator = fn() -> Box<dyn PrivacyMode>; pub type PrivacyModeCreator = fn(impl_key: &str) -> Box<dyn PrivacyMode>;
lazy_static::lazy_static! { lazy_static::lazy_static! {
static ref PRIVACY_MODE_CREATOR: Arc<Mutex<HashMap<&'static str, PrivacyModeCreator>>> = { static ref PRIVACY_MODE_CREATOR: Arc<Mutex<HashMap<&'static str, PrivacyModeCreator>>> = {
#[cfg(not(windows))] #[cfg(not(windows))]
@ -144,18 +143,18 @@ lazy_static::lazy_static! {
#[cfg(windows)] #[cfg(windows)]
{ {
if win_exclude_from_capture::is_supported() { if win_exclude_from_capture::is_supported() {
map.insert(win_exclude_from_capture::PRIVACY_MODE_IMPL, || { map.insert(win_exclude_from_capture::PRIVACY_MODE_IMPL, |impl_key: &str| {
Box::new(win_exclude_from_capture::PrivacyModeImpl::default()) Box::new(win_exclude_from_capture::PrivacyModeImpl::new(impl_key))
}); });
} else { } else {
map.insert(win_mag::PRIVACY_MODE_IMPL, || { map.insert(win_mag::PRIVACY_MODE_IMPL, |impl_key: &str| {
Box::new(win_mag::PrivacyModeImpl::default()) Box::new(win_mag::PrivacyModeImpl::new(impl_key))
}); });
} }
#[cfg(feature = "virtual_display_driver")] #[cfg(feature = "virtual_display_driver")]
map.insert(win_virtual_display::PRIVACY_MODE_IMPL, || { map.insert(win_virtual_display::PRIVACY_MODE_IMPL, |impl_key: &str| {
Box::new(win_virtual_display::PrivacyModeImpl::default()) Box::new(win_virtual_display::PrivacyModeImpl::new(impl_key))
}); });
} }
Arc::new(Mutex::new(map)) Arc::new(Mutex::new(map))
@ -174,13 +173,15 @@ pub fn clear() -> Option<()> {
#[inline] #[inline]
pub fn switch(impl_key: &str) { pub fn switch(impl_key: &str) {
let mut cur_impl_lock = CUR_PRIVACY_MODE_IMPL.lock().unwrap(); let mut privacy_mode_lock = PRIVACY_MODE.lock().unwrap();
if *cur_impl_lock == impl_key { if let Some(privacy_mode) = privacy_mode_lock.as_ref() {
if privacy_mode.get_impl_key() == impl_key {
return; return;
} }
}
if let Some(creator) = PRIVACY_MODE_CREATOR.lock().unwrap().get(impl_key) { if let Some(creator) = PRIVACY_MODE_CREATOR.lock().unwrap().get(impl_key) {
*PRIVACY_MODE.lock().unwrap() = Some(creator()); *privacy_mode_lock = Some(creator(impl_key));
*cur_impl_lock = impl_key.to_owned();
} }
} }
@ -208,13 +209,15 @@ pub fn turn_on_privacy(impl_key: &str, conn_id: i32) -> Option<ResultType<bool>>
// Check or switch privacy mode implementation // Check or switch privacy mode implementation
let impl_key = get_supported_impl(impl_key); let impl_key = get_supported_impl(impl_key);
let mut cur_impl_lock = CUR_PRIVACY_MODE_IMPL.lock().unwrap();
let mut cur_impl_key = "".to_string();
if let Some(privacy_mode) = privacy_mode_lock.as_ref() { if let Some(privacy_mode) = privacy_mode_lock.as_ref() {
cur_impl_key = privacy_mode.get_impl_key().to_string();
let check_on_conn_id = privacy_mode.check_on_conn_id(conn_id); let check_on_conn_id = privacy_mode.check_on_conn_id(conn_id);
match check_on_conn_id.as_ref() { match check_on_conn_id.as_ref() {
Ok(true) => { Ok(true) => {
if *cur_impl_lock == impl_key { if cur_impl_key == impl_key {
// Same peer, same implementation.
return Some(Ok(true)); return Some(Ok(true));
} else { } else {
// Same peer, switch to new implementation. // Same peer, switch to new implementation.
@ -225,7 +228,7 @@ pub fn turn_on_privacy(impl_key: &str, conn_id: i32) -> Option<ResultType<bool>>
} }
} }
if *cur_impl_lock != impl_key { if cur_impl_key != impl_key {
if let Some(creator) = PRIVACY_MODE_CREATOR if let Some(creator) = PRIVACY_MODE_CREATOR
.lock() .lock()
.unwrap() .unwrap()
@ -235,8 +238,7 @@ pub fn turn_on_privacy(impl_key: &str, conn_id: i32) -> Option<ResultType<bool>>
privacy_mode.clear(); privacy_mode.clear();
} }
*privacy_mode_lock = Some(creator()); *privacy_mode_lock = Some(creator(&impl_key));
*cur_impl_lock = impl_key.to_owned();
} else { } else {
return Some(Err(anyhow!("Unsupported privacy mode: {}", impl_key))); return Some(Err(anyhow!("Unsupported privacy mode: {}", impl_key)));
} }
@ -313,9 +315,23 @@ pub fn get_supported_privacy_mode_impl() -> Vec<(&'static str, &'static str)> {
} }
} }
#[inline]
pub fn get_cur_impl_key() -> Option<String> {
PRIVACY_MODE
.lock()
.unwrap()
.as_ref()
.map(|pm| pm.get_impl_key().to_owned())
}
#[inline] #[inline]
pub fn is_current_privacy_mode_impl(impl_key: &str) -> bool { pub fn is_current_privacy_mode_impl(impl_key: &str) -> bool {
*CUR_PRIVACY_MODE_IMPL.lock().unwrap() == impl_key PRIVACY_MODE
.lock()
.unwrap()
.as_ref()
.map(|pm| pm.get_impl_key() == impl_key)
.unwrap_or(false)
} }
#[inline] #[inline]
@ -347,3 +363,22 @@ pub fn check_privacy_mode_err(
pub fn is_privacy_mode_supported() -> bool { pub fn is_privacy_mode_supported() -> bool {
!DEFAULT_PRIVACY_MODE_IMPL.is_empty() !DEFAULT_PRIVACY_MODE_IMPL.is_empty()
} }
#[inline]
pub fn get_privacy_mode_conn_id() -> Option<i32> {
PRIVACY_MODE
.lock()
.unwrap()
.as_ref()
.map(|pm| pm.pre_conn_id())
}
#[inline]
pub fn is_in_privacy_mode() -> bool {
PRIVACY_MODE
.lock()
.unwrap()
.as_ref()
.map(|pm| pm.pre_conn_id() != INVALID_PRIVACY_MODE_CONN_ID)
.unwrap_or(false)
}

32
src/privacy_mode/win_topmost_window.rs
View File

@ -65,24 +65,12 @@ impl WindowHandlers {
} }
pub struct PrivacyModeImpl { pub struct PrivacyModeImpl {
impl_key: String,
conn_id: i32, conn_id: i32,
handlers: WindowHandlers, handlers: WindowHandlers,
hwnd: u64, hwnd: u64,
} }
impl Default for PrivacyModeImpl {
fn default() -> Self {
Self {
conn_id: INVALID_PRIVACY_MODE_CONN_ID,
handlers: WindowHandlers {
hthread: 0,
hprocess: 0,
},
hwnd: 0,
}
}
}
impl PrivacyMode for PrivacyModeImpl { impl PrivacyMode for PrivacyModeImpl {
fn init(&self) -> ResultType<()> { fn init(&self) -> ResultType<()> {
Ok(()) Ok(())
@ -163,9 +151,26 @@ impl PrivacyMode for PrivacyModeImpl {
fn pre_conn_id(&self) -> i32 { fn pre_conn_id(&self) -> i32 {
self.conn_id self.conn_id
} }
#[inline]
fn get_impl_key(&self) -> &str {
&self.impl_key
}
} }
impl PrivacyModeImpl { impl PrivacyModeImpl {
pub fn new(impl_key: &str) -> Self {
Self {
impl_key: impl_key.to_owned(),
conn_id: INVALID_PRIVACY_MODE_CONN_ID,
handlers: WindowHandlers {
hthread: 0,
hprocess: 0,
},
hwnd: 0,
}
}
#[inline] #[inline]
pub fn get_hwnd(&self) -> u64 { pub fn get_hwnd(&self) -> u64 {
self.hwnd self.hwnd
@ -372,4 +377,3 @@ pub(super) fn wait_find_privacy_hwnd(msecs: u128) -> ResultType<HWND> {
std::thread::sleep(Duration::from_millis(100)); std::thread::sleep(Duration::from_millis(100));
} }
} }

27
src/privacy_mode/win_virtual_display.rs
View File

@ -35,23 +35,13 @@ struct Display {
} }
pub struct PrivacyModeImpl { pub struct PrivacyModeImpl {
impl_key: String,
conn_id: i32, conn_id: i32,
displays: Vec<Display>, displays: Vec<Display>,
virtual_displays: Vec<Display>, virtual_displays: Vec<Display>,
virtual_displays_added: Vec<u32>, virtual_displays_added: Vec<u32>,
} }
impl Default for PrivacyModeImpl {
fn default() -> Self {
Self {
conn_id: INVALID_PRIVACY_MODE_CONN_ID,
displays: Vec::new(),
virtual_displays: Vec::new(),
virtual_displays_added: Vec::new(),
}
}
}
struct TurnOnGuard<'a> { struct TurnOnGuard<'a> {
privacy_mode: &'a mut PrivacyModeImpl, privacy_mode: &'a mut PrivacyModeImpl,
succeeded: bool, succeeded: bool,
@ -82,6 +72,16 @@ impl<'a> Drop for TurnOnGuard<'a> {
} }
impl PrivacyModeImpl { impl PrivacyModeImpl {
pub fn new(impl_key: &str) -> Self {
Self {
impl_key: impl_key.to_owned(),
conn_id: INVALID_PRIVACY_MODE_CONN_ID,
displays: Vec::new(),
virtual_displays: Vec::new(),
virtual_displays_added: Vec::new(),
}
}
// mainly from https://github.com/fufesou/rustdesk/blob/44c3a52ca8502cf53b58b59db130611778d34dbe/libs/scrap/src/dxgi/mod.rs#L365 // mainly from https://github.com/fufesou/rustdesk/blob/44c3a52ca8502cf53b58b59db130611778d34dbe/libs/scrap/src/dxgi/mod.rs#L365
fn set_displays(&mut self) { fn set_displays(&mut self) {
self.displays.clear(); self.displays.clear();
@ -431,6 +431,11 @@ impl PrivacyMode for PrivacyModeImpl {
fn pre_conn_id(&self) -> i32 { fn pre_conn_id(&self) -> i32 {
self.conn_id self.conn_id
} }
#[inline]
fn get_impl_key(&self) -> &str {
&self.impl_key
}
} }
impl Drop for PrivacyModeImpl { impl Drop for PrivacyModeImpl {

36
src/server/connection.rs
View File

@ -508,21 +508,18 @@ impl Connection {
ipc::Data::PrivacyModeState((_, state, impl_key)) => { ipc::Data::PrivacyModeState((_, state, impl_key)) => {
let msg_out = match state { let msg_out = match state {
privacy_mode::PrivacyModeState::OffSucceeded => { privacy_mode::PrivacyModeState::OffSucceeded => {
video_service::set_privacy_mode_conn_id(0);
crate::common::make_privacy_mode_msg( crate::common::make_privacy_mode_msg(
back_notification::PrivacyModeState::PrvOffSucceeded, back_notification::PrivacyModeState::PrvOffSucceeded,
impl_key, impl_key,
) )
} }
privacy_mode::PrivacyModeState::OffByPeer => { privacy_mode::PrivacyModeState::OffByPeer => {
video_service::set_privacy_mode_conn_id(0);
crate::common::make_privacy_mode_msg( crate::common::make_privacy_mode_msg(
back_notification::PrivacyModeState::PrvOffByPeer, back_notification::PrivacyModeState::PrvOffByPeer,
impl_key, impl_key,
) )
} }
privacy_mode::PrivacyModeState::OffUnknown => { privacy_mode::PrivacyModeState::OffUnknown => {
video_service::set_privacy_mode_conn_id(0);
crate::common::make_privacy_mode_msg( crate::common::make_privacy_mode_msg(
back_notification::PrivacyModeState::PrvOffUnknown, back_notification::PrivacyModeState::PrvOffUnknown,
impl_key, impl_key,
@ -682,11 +679,11 @@ impl Connection {
} }
} }
let video_privacy_conn_id = video_service::get_privacy_mode_conn_id(); if let Some(video_privacy_conn_id) = privacy_mode::get_privacy_mode_conn_id() {
if video_privacy_conn_id == id { if video_privacy_conn_id == id {
video_service::set_privacy_mode_conn_id(0);
let _ = Self::turn_off_privacy_to_msg(id); let _ = Self::turn_off_privacy_to_msg(id);
} }
}
#[cfg(all(feature = "flutter", feature = "plugin_framework"))] #[cfg(all(feature = "flutter", feature = "plugin_framework"))]
#[cfg(not(any(target_os = "android", target_os = "ios")))] #[cfg(not(any(target_os = "android", target_os = "ios")))]
crate::plugin::handle_listen_event( crate::plugin::handle_listen_event(
@ -880,7 +877,7 @@ impl Connection {
} }
async fn check_privacy_mode_on(&mut self) -> bool { async fn check_privacy_mode_on(&mut self) -> bool {
if video_service::get_privacy_mode_conn_id() > 0 { if privacy_mode::is_in_privacy_mode() {
self.send_login_error("Someone turns on privacy mode, exit") self.send_login_error("Someone turns on privacy mode, exit")
.await; .await;
false false
@ -2610,7 +2607,23 @@ impl Connection {
impl_key, impl_key,
) )
} else { } else {
match privacy_mode::turn_on_privacy(&impl_key, self.inner.id) { let is_pre_privacy_on = privacy_mode::is_in_privacy_mode();
let pre_impl_key = privacy_mode::get_cur_impl_key();
let turn_on_res = privacy_mode::turn_on_privacy(&impl_key, self.inner.id);
if is_pre_privacy_on {
if let Some(pre_impl_key) = pre_impl_key {
if !privacy_mode::is_current_privacy_mode_impl(&pre_impl_key) {
let off_msg = crate::common::make_privacy_mode_msg(
back_notification::PrivacyModeState::PrvOffSucceeded,
pre_impl_key,
);
self.send(off_msg).await;
}
}
}
match turn_on_res {
Some(Ok(res)) => { Some(Ok(res)) => {
if res { if res {
let err_msg = privacy_mode::check_privacy_mode_err( let err_msg = privacy_mode::check_privacy_mode_err(
@ -2619,7 +2632,6 @@ impl Connection {
5_000, 5_000,
); );
if err_msg.is_empty() { if err_msg.is_empty() {
video_service::set_privacy_mode_conn_id(self.inner.id);
crate::common::make_privacy_mode_msg( crate::common::make_privacy_mode_msg(
back_notification::PrivacyModeState::PrvOnSucceeded, back_notification::PrivacyModeState::PrvOnSucceeded,
impl_key, impl_key,
@ -2629,7 +2641,6 @@ impl Connection {
"Check privacy mode failed: {}, turn off privacy mode.", "Check privacy mode failed: {}, turn off privacy mode.",
&err_msg &err_msg
); );
video_service::set_privacy_mode_conn_id(0);
let _ = Self::turn_off_privacy_to_msg(self.inner.id); let _ = Self::turn_off_privacy_to_msg(self.inner.id);
crate::common::make_privacy_mode_msg_with_details( crate::common::make_privacy_mode_msg_with_details(
back_notification::PrivacyModeState::PrvOnFailed, back_notification::PrivacyModeState::PrvOnFailed,
@ -2646,8 +2657,10 @@ impl Connection {
} }
Some(Err(e)) => { Some(Err(e)) => {
log::error!("Failed to turn on privacy mode. {}", e); log::error!("Failed to turn on privacy mode. {}", e);
if video_service::get_privacy_mode_conn_id() == 0 { if !privacy_mode::is_in_privacy_mode() {
let _ = Self::turn_off_privacy_to_msg(0); let _ = Self::turn_off_privacy_to_msg(
privacy_mode::INVALID_PRIVACY_MODE_CONN_ID,
);
} }
crate::common::make_privacy_mode_msg_with_details( crate::common::make_privacy_mode_msg_with_details(
back_notification::PrivacyModeState::PrvOnFailed, back_notification::PrivacyModeState::PrvOnFailed,
@ -2674,7 +2687,6 @@ impl Connection {
impl_key, impl_key,
) )
} else { } else {
video_service::set_privacy_mode_conn_id(0);
Self::turn_off_privacy_to_msg(self.inner.id) Self::turn_off_privacy_to_msg(self.inner.id)
}; };
self.send(msg_out).await; self.send(msg_out).await;

29
src/server/video_service.rs
View File

@ -28,6 +28,7 @@ use super::{
use crate::common::SimpleCallOnReturn; use crate::common::SimpleCallOnReturn;
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
use crate::platform::linux::is_x11; use crate::platform::linux::is_x11;
use crate::privacy_mode::{get_privacy_mode_conn_id, INVALID_PRIVACY_MODE_CONN_ID};
#[cfg(windows)] #[cfg(windows)]
use crate::{ use crate::{
platform::windows::is_process_consent_running, platform::windows::is_process_consent_running,
@ -68,7 +69,6 @@ lazy_static::lazy_static! {
let (tx, rx) = unbounded_channel(); let (tx, rx) = unbounded_channel();
(tx, Arc::new(TokioMutex::new(rx))) (tx, Arc::new(TokioMutex::new(rx)))
}; };
static ref PRIVACY_MODE_CONN_ID: Mutex<i32> = Mutex::new(0);
pub static ref VIDEO_QOS: Arc<Mutex<VideoQoS>> = Default::default(); pub static ref VIDEO_QOS: Arc<Mutex<VideoQoS>> = Default::default();
pub static ref IS_UAC_RUNNING: Arc<Mutex<bool>> = Default::default(); pub static ref IS_UAC_RUNNING: Arc<Mutex<bool>> = Default::default();
pub static ref IS_FOREGROUND_WINDOW_ELEVATED: Arc<Mutex<bool>> = Default::default(); pub static ref IS_FOREGROUND_WINDOW_ELEVATED: Arc<Mutex<bool>> = Default::default();
@ -79,16 +79,6 @@ pub fn notify_video_frame_fetched(conn_id: i32, frame_tm: Option<Instant>) {
FRAME_FETCHED_NOTIFIER.0.send((conn_id, frame_tm)).ok(); FRAME_FETCHED_NOTIFIER.0.send((conn_id, frame_tm)).ok();
} }
#[inline]
pub fn set_privacy_mode_conn_id(conn_id: i32) {
*PRIVACY_MODE_CONN_ID.lock().unwrap() = conn_id
}
#[inline]
pub fn get_privacy_mode_conn_id() -> i32 {
*PRIVACY_MODE_CONN_ID.lock().unwrap()
}
struct VideoFrameController { struct VideoFrameController {
cur: Instant, cur: Instant,
send_conn_ids: HashSet<i32>, send_conn_ids: HashSet<i32>,
@ -251,7 +241,9 @@ pub fn test_create_capturer(
// Note: This function is extremely expensive, do not call it frequently. // Note: This function is extremely expensive, do not call it frequently.
#[cfg(windows)] #[cfg(windows)]
fn check_uac_switch(privacy_mode_id: i32, capturer_privacy_mode_id: i32) -> ResultType<()> { fn check_uac_switch(privacy_mode_id: i32, capturer_privacy_mode_id: i32) -> ResultType<()> {
if capturer_privacy_mode_id != 0 && is_current_privacy_mode_impl(PRIVACY_MODE_IMPL_WIN_MAG) { if capturer_privacy_mode_id != INVALID_PRIVACY_MODE_CONN_ID
&& is_current_privacy_mode_impl(PRIVACY_MODE_IMPL_WIN_MAG)
{
if !is_installed() { if !is_installed() {
if privacy_mode_id != capturer_privacy_mode_id { if privacy_mode_id != capturer_privacy_mode_id {
if !is_process_consent_running()? { if !is_process_consent_running()? {
@ -323,18 +315,19 @@ fn get_capturer(current: usize, portable_service_running: bool) -> ResultType<Ca
&name, &name,
); );
let privacy_mode_id = *PRIVACY_MODE_CONN_ID.lock().unwrap(); let privacy_mode_id = get_privacy_mode_conn_id().unwrap_or(INVALID_PRIVACY_MODE_CONN_ID);
#[cfg(not(windows))] #[cfg(not(windows))]
let capturer_privacy_mode_id = privacy_mode_id; let capturer_privacy_mode_id = privacy_mode_id;
#[cfg(windows)] #[cfg(windows)]
let mut capturer_privacy_mode_id = privacy_mode_id; let mut capturer_privacy_mode_id = privacy_mode_id;
#[cfg(windows)] #[cfg(windows)]
{ {
if capturer_privacy_mode_id != 0 && is_current_privacy_mode_impl(PRIVACY_MODE_IMPL_WIN_MAG) if capturer_privacy_mode_id != INVALID_PRIVACY_MODE_CONN_ID
&& is_current_privacy_mode_impl(PRIVACY_MODE_IMPL_WIN_MAG)
{ {
if !is_installed() { if !is_installed() {
if is_process_consent_running()? { if is_process_consent_running()? {
capturer_privacy_mode_id = 0; capturer_privacy_mode_id = INVALID_PRIVACY_MODE_CONN_ID;
} }
} }
} }
@ -344,7 +337,7 @@ fn get_capturer(current: usize, portable_service_running: bool) -> ResultType<Ca
capturer_privacy_mode_id, capturer_privacy_mode_id,
); );
if privacy_mode_id != 0 { if privacy_mode_id != INVALID_PRIVACY_MODE_CONN_ID {
if privacy_mode_id != capturer_privacy_mode_id { if privacy_mode_id != capturer_privacy_mode_id {
log::info!("In privacy mode, but show UAC prompt window for now"); log::info!("In privacy mode, but show UAC prompt window for now");
} else { } else {
@ -658,9 +651,9 @@ fn get_recorder(
} }
fn check_privacy_mode_changed(sp: &GenericService, privacy_mode_id: i32) -> ResultType<()> { fn check_privacy_mode_changed(sp: &GenericService, privacy_mode_id: i32) -> ResultType<()> {
let privacy_mode_id_2 = *PRIVACY_MODE_CONN_ID.lock().unwrap(); let privacy_mode_id_2 = get_privacy_mode_conn_id().unwrap_or(INVALID_PRIVACY_MODE_CONN_ID);
if privacy_mode_id != privacy_mode_id_2 { if privacy_mode_id != privacy_mode_id_2 {
if privacy_mode_id_2 != 0 { if privacy_mode_id_2 != INVALID_PRIVACY_MODE_CONN_ID {
let msg_out = crate::common::make_privacy_mode_msg( let msg_out = crate::common::make_privacy_mode_msg(
back_notification::PrivacyModeState::PrvOnByOther, back_notification::PrivacyModeState::PrvOnByOther,
"".to_owned(), "".to_owned(),