[fix] fix dead lock during peer init

scripts/macosx/pkg_arm64.sh

@@ -90,14 +90,51 @@ mkdir -p build_pkg_scripts
 
 cat > build_pkg_scripts/postinstall <<'EOF'
 #!/bin/bash
+set -e
+
+IDENTIFIER="cn.crossdesk.app"
+
+# 获取当前登录用户
 USER_HOME=$( /usr/bin/stat -f "%Su" /dev/console )
 HOME_DIR=$( /usr/bin/dscl . -read /Users/$USER_HOME NFSHomeDirectory | awk '{print $2}' )
 
+# 复制证书文件
 DEST="$HOME_DIR/Library/Application Support/CrossDesk/certs"
-
 mkdir -p "$DEST"
 cp -R "/Library/Application Support/CrossDesk/certs/"* "$DEST/"
 
+# 清除应用的权限授权，以便重新授权
+# 使用 tccutil 重置录屏权限和辅助功能权限
+if command -v tccutil >/dev/null 2>&1; then
+    # 重置录屏权限
+    tccutil reset ScreenCapture "$IDENTIFIER" 2>/dev/null || true
+    # 重置辅助功能权限
+    tccutil reset Accessibility "$IDENTIFIER" 2>/dev/null || true
+    # 重置摄像头权限（如果需要）
+    tccutil reset Camera "$IDENTIFIER" 2>/dev/null || true
+    # 重置麦克风权限（如果需要）
+    tccutil reset Microphone "$IDENTIFIER" 2>/dev/null || true
+fi
+
+# 为所有用户清除权限（可选，如果需要）
+# 遍历所有用户目录并清除权限
+for USER_DIR in /Users/*; do
+    if [ -d "$USER_DIR" ] && [ "$USER_DIR" != "/Users/Shared" ]; then
+        USER_NAME=$(basename "$USER_DIR")
+        # 跳过系统用户
+        if [ "$USER_NAME" != "Shared" ] && [ -d "$USER_DIR/Library" ]; then
+            # 删除 TCC 数据库中的相关条目（需要管理员权限）
+            TCC_DB="$USER_DIR/Library/Application Support/com.apple.TCC/TCC.db"
+            if [ -f "$TCC_DB" ]; then
+                # 使用 sqlite3 删除相关权限记录（如果可用）
+                if command -v sqlite3 >/dev/null 2>&1; then
+                    sqlite3 "$TCC_DB" "DELETE FROM access WHERE client='$IDENTIFIER' AND service IN ('kTCCServiceScreenCapture', 'kTCCServiceAccessibility');" 2>/dev/null || true
+                fi
+            fi
+        fi
+    fi
+done
+
 exit 0
 EOF
 

scripts/macosx/pkg_x64.sh

@@ -90,14 +90,51 @@ mkdir -p build_pkg_scripts
 
 cat > build_pkg_scripts/postinstall <<'EOF'
 #!/bin/bash
+set -e
+
+IDENTIFIER="cn.crossdesk.app"
+
+# 获取当前登录用户
 USER_HOME=$( /usr/bin/stat -f "%Su" /dev/console )
 HOME_DIR=$( /usr/bin/dscl . -read /Users/$USER_HOME NFSHomeDirectory | awk '{print $2}' )
 
+# 复制证书文件
 DEST="$HOME_DIR/Library/Application Support/CrossDesk/certs"
-
 mkdir -p "$DEST"
 cp -R "/Library/Application Support/CrossDesk/certs/"* "$DEST/"
 
+# 清除应用的权限授权，以便重新授权
+# 使用 tccutil 重置录屏权限和辅助功能权限
+if command -v tccutil >/dev/null 2>&1; then
+    # 重置录屏权限
+    tccutil reset ScreenCapture "$IDENTIFIER" 2>/dev/null || true
+    # 重置辅助功能权限
+    tccutil reset Accessibility "$IDENTIFIER" 2>/dev/null || true
+    # 重置摄像头权限（如果需要）
+    tccutil reset Camera "$IDENTIFIER" 2>/dev/null || true
+    # 重置麦克风权限（如果需要）
+    tccutil reset Microphone "$IDENTIFIER" 2>/dev/null || true
+fi
+
+# 为所有用户清除权限（可选，如果需要）
+# 遍历所有用户目录并清除权限
+for USER_DIR in /Users/*; do
+    if [ -d "$USER_DIR" ] && [ "$USER_DIR" != "/Users/Shared" ]; then
+        USER_NAME=$(basename "$USER_DIR")
+        # 跳过系统用户
+        if [ "$USER_NAME" != "Shared" ] && [ -d "$USER_DIR/Library" ]; then
+            # 删除 TCC 数据库中的相关条目（需要管理员权限）
+            TCC_DB="$USER_DIR/Library/Application Support/com.apple.TCC/TCC.db"
+            if [ -f "$TCC_DB" ]; then
+                # 使用 sqlite3 删除相关权限记录（如果可用）
+                if command -v sqlite3 >/dev/null 2>&1; then
+                    sqlite3 "$TCC_DB" "DELETE FROM access WHERE client='$IDENTIFIER' AND service IN ('kTCCServiceScreenCapture', 'kTCCServiceAccessibility');" 2>/dev/null || true
+                fi
+            fi
+        fi
+    fi
+done
+
 exit 0
 EOF
 

src/gui/assets/layouts/layout.h

@@ -75,8 +75,17 @@
 #define SELF_HOSTED_SERVER_CONFIG_OK_BUTTON_PADDING_EN 91
 #define UPDATE_NOTIFICATION_OK_BUTTON_PADDING_CN 162
 #define UPDATE_NOTIFICATION_OK_BUTTON_PADDING_EN 146
-#define REQUEST_PERMISSION_WINDOW_WIDTH_CN 180
+#ifdef _WIN32
-#define REQUEST_PERMISSION_WINDOW_HEIGHT_CN 128
+#define UPDATE_NOTIFICATION_RESERVED_HEIGHT 130
-#define REQUEST_PERMISSION_WINDOW_WIDTH_EN 380
+#elif __APPLE__
-#define REQUEST_PERMISSION_WINDOW_HEIGHT_EN 122
+#define UPDATE_NOTIFICATION_RESERVED_HEIGHT 100
+#else
+#define UPDATE_NOTIFICATION_RESERVED_HEIGHT 100
+#endif
+#define REQUEST_PERMISSION_WINDOW_WIDTH_CN 130
+#define REQUEST_PERMISSION_WINDOW_HEIGHT_CN 125
+#define REQUEST_PERMISSION_WINDOW_WIDTH_EN 260
+#define REQUEST_PERMISSION_WINDOW_HEIGHT_EN 125
+#define REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_CN 90
+#define REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_EN 210
 #endif

src/gui/assets/localization/localization.h

@@ -192,22 +192,14 @@ static std::vector<LPCWSTR> exit_program = {L"退出", L"Exit"};
 static std::vector<std::string> request_permissions = {
     reinterpret_cast<const char*>(u8"权限请求"), "Request Permissions"};
 static std::vector<std::string> screen_recording_permission = {
-    reinterpret_cast<const char*>(u8"录屏权限"), "Screen Recording Permission"};
+    reinterpret_cast<const char*>(u8"屏幕录制权限"),
+    "Screen Recording Permission"};
 static std::vector<std::string> accessibility_permission = {
-    reinterpret_cast<const char*>(u8"键鼠权限"), "Keyboard & Mouse Permission"};
+    reinterpret_cast<const char*>(u8"辅助功能权限"),
-static std::vector<std::string> permission_granted = {
+    "Accessibility Permission"};
-    reinterpret_cast<const char*>(u8"已授权"), "Granted"};
-static std::vector<std::string> permission_denied = {
-    reinterpret_cast<const char*>(u8"未授权"), "Denied"};
-static std::vector<std::string> open_screen_recording_settings = {
-    reinterpret_cast<const char*>(u8"打开录屏设置"),
-    "Open Screen Recording Settings"};
-static std::vector<std::string> open_keyboard_mouse_settings = {
-    reinterpret_cast<const char*>(u8"打开键鼠设置"),
-    "Open Keyboard & Mouse Settings"};
 static std::vector<std::string> permission_required_message = {
-    reinterpret_cast<const char*>(u8"应用需要以下权限才能正常工作:"),
+    reinterpret_cast<const char*>(u8"该应用需要授权以下权限:"),
-    "The application requires the following permissions to work properly:"};
+    "The application requires the following permissions:"};
 #endif
 }  // namespace localization
 }  // namespace crossdesk

src/gui/panels/remote_peer_panel.cpp

@@ -82,6 +82,7 @@ int Render::RemoteWindow() {
         for (auto& [id, props] : recent_connections_) {
           if (id.find(remote_id) != std::string::npos) {
             found = true;
+            std::shared_lock lock(client_properties_mutex_);
             if (client_properties_.find(remote_id) !=
                 client_properties_.end()) {
               if (!client_properties_[remote_id]->connection_established_) {
@@ -101,12 +102,22 @@ int Render::RemoteWindow() {
         }
       }
 
+      // check every 1 second for rejoin
       if (need_to_rejoin_) {
-        need_to_rejoin_ = false;
+        auto now = std::chrono::steady_clock::now();
-        for (const auto& [_, props] : client_properties_) {
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-          if (props->rejoin_) {
+                           now - last_rejoin_check_time_)
-            ConnectTo(props->remote_id_, props->remote_password_,
+                           .count();
-                      props->remember_password_);
+
+        if (elapsed >= 1000) {
+          last_rejoin_check_time_ = now;
+          need_to_rejoin_ = false;
+          std::shared_lock lock(client_properties_mutex_);
+          for (const auto& [_, props] : client_properties_) {
+            if (props->rejoin_) {
+              ConnectTo(props->remote_id_, props->remote_password_,
+                        props->remember_password_);
+            }
           }
         }
       }
@@ -136,33 +147,54 @@ int Render::ConnectTo(const std::string& remote_id, const char* password,
   LOG_INFO("Connect to [{}]", remote_id);
   focused_remote_id_ = remote_id;
 
-  if (client_properties_.find(remote_id) == client_properties_.end()) {
+  std::shared_lock shared_lock(client_properties_mutex_);
-    client_properties_[remote_id] =
+  bool exists =
-        std::make_shared<SubStreamWindowProperties>();
+      (client_properties_.find(remote_id) != client_properties_.end());
-    auto props = client_properties_[remote_id];
+  shared_lock.unlock();
-    props->local_id_ = "C-" + std::string(client_id_);
-    props->remote_id_ = remote_id;
-    memcpy(&props->params_, &params_, sizeof(Params));
-    props->params_.user_id = props->local_id_.c_str();
-    props->peer_ = CreatePeer(&props->params_);
 
-    for (auto& display_info : display_info_list_) {
+  if (!exists) {
-      AddVideoStream(peer_, display_info.name.c_str());
+    PeerPtr* peer_to_init = nullptr;
-    }
+    std::string local_id;
-    AddAudioStream(props->peer_, props->audio_label_.c_str());
-    AddDataStream(props->peer_, props->data_label_.c_str());
 
-    if (props->peer_) {
+    {
-      LOG_INFO("[{}] Create peer instance successful", props->local_id_);
+      std::unique_lock unique_lock(client_properties_mutex_);
-      Init(props->peer_);
+      if (client_properties_.find(remote_id) == client_properties_.end()) {
-      LOG_INFO("[{}] Peer init finish", props->local_id_);
+        client_properties_[remote_id] =
-    } else {
+            std::make_shared<SubStreamWindowProperties>();
-      LOG_INFO("Create peer [{}] instance failed", props->local_id_);
+        auto props = client_properties_[remote_id];
+        props->local_id_ = "C-" + std::string(client_id_);
+        props->remote_id_ = remote_id;
+        memcpy(&props->params_, &params_, sizeof(Params));
+        props->params_.user_id = props->local_id_.c_str();
+        props->peer_ = CreatePeer(&props->params_);
+
+        if (!props->peer_) {
+          LOG_INFO("Create peer [{}] instance failed", props->local_id_);
+          return -1;
+        }
+
+        for (auto& display_info : display_info_list_) {
+          AddVideoStream(props->peer_, display_info.name.c_str());
+        }
+        AddAudioStream(props->peer_, props->audio_label_.c_str());
+        AddDataStream(props->peer_, props->data_label_.c_str());
+
+        props->connection_status_ = ConnectionStatus::Connecting;
+
+        peer_to_init = props->peer_;
+        local_id = props->local_id_;
+      }
     }
 
-    props->connection_status_ = ConnectionStatus::Connecting;
+    if (peer_to_init) {
+      LOG_INFO("[{}] Create peer instance successful", local_id);
+      Init(peer_to_init);
+      LOG_INFO("[{}] Peer init finish", local_id);
+    }
   }
+
   int ret = -1;
+  std::shared_lock read_lock(client_properties_mutex_);
   auto props = client_properties_[remote_id];
   if (!props->connection_established_) {
     props->remember_password_ = remember_password;
@@ -174,14 +206,17 @@ int Render::ConnectTo(const std::string& remote_id, const char* password,
     }
 
     std::string remote_id_with_pwd = remote_id + "@" + password;
-    ret = JoinConnection(props->peer_, remote_id_with_pwd.c_str());
+    if (props->peer_) {
-    if (0 == ret) {
+      ret = JoinConnection(props->peer_, remote_id_with_pwd.c_str());
-      props->rejoin_ = false;
+      if (0 == ret) {
-    } else {
+        props->rejoin_ = false;
-      props->rejoin_ = true;
+      } else {
-      need_to_rejoin_ = true;
+        props->rejoin_ = true;
+        need_to_rejoin_ = true;
+      }
     }
   }
+  read_lock.unlock();
 
   return 0;
 }

src/gui/render.cpp

@@ -168,7 +168,7 @@ SDL_HitTestResult Render::HitTestCallback(SDL_Window* window,
   return SDL_HITTEST_NORMAL;
 }
 
-Render::Render() {}
+Render::Render() : last_rejoin_check_time_(std::chrono::steady_clock::now()) {}
 
 Render::~Render() {}
 
@@ -947,6 +947,7 @@ int Render::DrawStreamWindow() {
   ImGui::Render();
   SDL_RenderClear(stream_renderer_);
 
+  std::shared_lock lock(client_properties_mutex_);
   for (auto& it : client_properties_) {
     auto props = it.second;
     if (props->tab_selected_) {
@@ -1011,6 +1012,8 @@ int Render::Run() {
   }
 
   InitializeLogger();
+  LOG_INFO("CrossDesk version: {}", CROSSDESK_VERSION);
+
   InitializeSettings();
   InitializeSDL();
   InitializeModules();
@@ -1281,12 +1284,18 @@ void Render::CleanupPeers() {
     DestroyPeer(&peer_);
   }
 
-  for (auto& it : client_properties_) {
+  {
-    auto props = it.second;
+    std::shared_lock lock(client_properties_mutex_);
-    CleanupPeer(props);
+    for (auto& it : client_properties_) {
+      auto props = it.second;
+      CleanupPeer(props);
+    }
   }
 
-  client_properties_.clear();
+  {
+    std::unique_lock lock(client_properties_mutex_);
+    client_properties_.clear();
+  }
 }
 
 void Render::CleanSubStreamWindowProperties(
@@ -1303,6 +1312,7 @@ void Render::CleanSubStreamWindowProperties(
 }
 
 void Render::UpdateRenderRect() {
+  std::shared_lock lock(client_properties_mutex_);
   for (auto& [_, props] : client_properties_) {
     if (!props->reset_control_bar_pos_) {
       props->mouse_diff_control_bar_pos_x_ = 0;
@@ -1377,34 +1387,41 @@ void Render::ProcessSdlEvent(const SDL_Event& event) {
         DestroyStreamWindow();
         DestroyStreamWindowContext();
 
-        for (auto& [host_name, props] : client_properties_) {
+        {
-          thumbnail_->SaveToThumbnail(
+          std::shared_lock lock(client_properties_mutex_);
-              (char*)props->dst_buffer_, props->video_width_,
+          for (auto& [host_name, props] : client_properties_) {
-              props->video_height_, host_name, props->remote_host_name_,
+            thumbnail_->SaveToThumbnail(
-              props->remember_password_ ? props->remote_password_ : "");
+                (char*)props->dst_buffer_, props->video_width_,
+                props->video_height_, host_name, props->remote_host_name_,
+                props->remember_password_ ? props->remote_password_ : "");
 
-          if (props->peer_) {
+            if (props->peer_) {
-            std::string client_id = (host_name == client_id_)
+              std::string client_id = (host_name == client_id_)
-                                        ? "C-" + std::string(client_id_)
+                                          ? "C-" + std::string(client_id_)
-                                        : client_id_;
+                                          : client_id_;
-            LOG_INFO("[{}] Leave connection [{}]", client_id, host_name);
+              LOG_INFO("[{}] Leave connection [{}]", client_id, host_name);
-            LeaveConnection(props->peer_, host_name.c_str());
+              LeaveConnection(props->peer_, host_name.c_str());
-            LOG_INFO("Destroy peer [{}]", client_id);
+              LOG_INFO("Destroy peer [{}]", client_id);
-            DestroyPeer(&props->peer_);
+              DestroyPeer(&props->peer_);
+            }
+
+            props->streaming_ = false;
+            props->remember_password_ = false;
+            props->connection_established_ = false;
+            props->audio_capture_button_pressed_ = false;
+
+            memset(&props->net_traffic_stats_, 0,
+                   sizeof(props->net_traffic_stats_));
+            SDL_SetWindowFullscreen(main_window_, false);
+            SDL_FlushEvents(STREAM_REFRESH_EVENT, STREAM_REFRESH_EVENT);
+            memset(audio_buffer_, 0, 720);
           }
-
-          props->streaming_ = false;
-          props->remember_password_ = false;
-          props->connection_established_ = false;
-          props->audio_capture_button_pressed_ = false;
-
-          memset(&props->net_traffic_stats_, 0,
-                 sizeof(props->net_traffic_stats_));
-          SDL_SetWindowFullscreen(main_window_, false);
-          SDL_FlushEvents(STREAM_REFRESH_EVENT, STREAM_REFRESH_EVENT);
-          memset(audio_buffer_, 0, 720);
         }
-        client_properties_.clear();
+
+        {
+          std::unique_lock lock(client_properties_mutex_);
+          client_properties_.clear();
+        }
 
         rejoin_ = false;
         is_client_mode_ = false;

src/gui/render.h

@@ -15,6 +15,7 @@
 #include <mutex>
 #include <nlohmann/json.hpp>
 #include <optional>
+#include <shared_mutex>
 #include <string>
 #include <unordered_map>
 
@@ -30,6 +31,7 @@
 #include "screen_capturer_factory.h"
 #include "speaker_capturer_factory.h"
 #include "thumbnail.h"
+
 #if _WIN32
 #include "win_tray.h"
 #endif
@@ -192,9 +194,9 @@ class Render {
   int RequestPermissionWindow();
   bool CheckScreenRecordingPermission();
   bool CheckAccessibilityPermission();
-  void OpenSystemPreferences();
   void OpenScreenRecordingPreferences();
   void OpenAccessibilityPreferences();
+  bool DrawToggleSwitch(const char* id, bool active, bool enabled);
 #endif
 
  public:
@@ -379,6 +381,7 @@ class Render {
   int audio_len_ = 0;
   bool audio_buffer_fresh_ = false;
   bool need_to_rejoin_ = false;
+  std::chrono::steady_clock::time_point last_rejoin_check_time_;
   bool just_created_ = false;
   std::string controlled_remote_id_ = "";
   std::string focused_remote_id_ = "";
@@ -503,6 +506,7 @@ class Render {
   /* ------ sub stream window property start ------ */
   std::unordered_map<std::string, std::shared_ptr<SubStreamWindowProperties>>
       client_properties_;
+  std::shared_mutex client_properties_mutex_;
   void CloseTab(decltype(client_properties_)::iterator& it);
   /* ------ stream window property end ------ */
 

src/gui/render_callback.cpp

@@ -21,13 +21,16 @@ int Render::SendKeyCommand(int key_code, bool is_down) {
   remote_action.k.key_value = key_code;
 
   if (!controlled_remote_id_.empty()) {
+    std::shared_lock lock(client_properties_mutex_);
     if (client_properties_.find(controlled_remote_id_) !=
         client_properties_.end()) {
       auto props = client_properties_[controlled_remote_id_];
       if (props->connection_status_ == ConnectionStatus::Connected) {
         std::string msg = remote_action.to_json();
-        SendDataFrame(props->peer_, msg.c_str(), msg.size(),
+        if (props->peer_) {
-                      props->data_label_.c_str());
+          SendDataFrame(props->peer_, msg.c_str(), msg.size(),
+                        props->data_label_.c_str());
+        }
       }
     }
   }
@@ -42,6 +45,7 @@ int Render::ProcessMouseEvent(const SDL_Event& event) {
   float ratio_x, ratio_y = 0;
   RemoteAction remote_action;
 
+  std::shared_lock lock(client_properties_mutex_);
   for (auto& it : client_properties_) {
     auto props = it.second;
     if (!props->control_mouse_) {
@@ -94,8 +98,10 @@ int Render::ProcessMouseEvent(const SDL_Event& event) {
       }
 
       std::string msg = remote_action.to_json();
-      SendDataFrame(props->peer_, msg.c_str(), msg.size(),
+      if (props->peer_) {
-                    props->data_label_.c_str());
+        SendDataFrame(props->peer_, msg.c_str(), msg.size(),
+                      props->data_label_.c_str());
+      }
     } else if (SDL_EVENT_MOUSE_WHEEL == event.type &&
                last_mouse_event.button.x >= props->stream_render_rect_.x &&
                last_mouse_event.button.x <= props->stream_render_rect_.x +
@@ -139,8 +145,10 @@ int Render::ProcessMouseEvent(const SDL_Event& event) {
           render_height;
 
       std::string msg = remote_action.to_json();
-      SendDataFrame(props->peer_, msg.c_str(), msg.size(),
+      if (props->peer_) {
-                    props->data_label_.c_str());
+        SendDataFrame(props->peer_, msg.c_str(), msg.size(),
+                      props->data_label_.c_str());
+      }
     }
   }
 
@@ -154,11 +162,14 @@ void Render::SdlCaptureAudioIn(void* userdata, Uint8* stream, int len) {
   }
 
   if (1) {
-    for (auto it : render->client_properties_) {
+    std::shared_lock lock(render->client_properties_mutex_);
+    for (const auto& it : render->client_properties_) {
       auto props = it.second;
       if (props->connection_status_ == ConnectionStatus::Connected) {
-        SendAudioFrame(props->peer_, (const char*)stream, len,
+        if (props->peer_) {
-                       render->audio_label_.c_str());
+          SendAudioFrame(props->peer_, (const char*)stream, len,
+                         render->audio_label_.c_str());
+        }
       }
     }
 
@@ -207,6 +218,7 @@ void Render::OnReceiveVideoBufferCb(const XVideoFrame* video_frame,
   }
 
   std::string remote_id(user_id, user_id_size);
+  std::shared_lock lock(render->client_properties_mutex_);
   if (render->client_properties_.find(remote_id) ==
       render->client_properties_.end()) {
     return;
@@ -302,6 +314,7 @@ void Render::OnReceiveDataBufferCb(const char* data, size_t size,
   }
 
   std::string remote_id(user_id, user_id_size);
+  std::shared_lock lock(render->client_properties_mutex_);
   if (render->client_properties_.find(remote_id) !=
       render->client_properties_.end()) {
     // local
@@ -373,6 +386,7 @@ void Render::OnSignalStatusCb(SignalStatus status, const char* user_id,
     }
 
     std::string remote_id(client_id.begin() + 2, client_id.end());
+    std::shared_lock lock(render->client_properties_mutex_);
     if (render->client_properties_.find(remote_id) ==
         render->client_properties_.end()) {
       return;
@@ -402,6 +416,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
   if (!render) return;
 
   std::string remote_id(user_id, user_id_size);
+  std::shared_lock lock(render->client_properties_mutex_);
   auto it = render->client_properties_.find(remote_id);
   auto props = (it != render->client_properties_.end()) ? it->second : nullptr;
 
@@ -428,7 +443,7 @@ void Render::OnConnectionStatusCb(ConnectionStatus status, const char* user_id,
       case ConnectionStatus::Closed: {
         props->connection_established_ = false;
         props->mouse_control_button_pressed_ = false;
-        if (props->dst_buffer_) {
+        if (props->dst_buffer_ && props->stream_texture_) {
           memset(props->dst_buffer_, 0, props->dst_buffer_capacity_);
           SDL_UpdateTexture(props->stream_texture_, NULL, props->dst_buffer_,
                             props->texture_width_);
@@ -562,6 +577,7 @@ void Render::NetStatusReport(const char* client_id, size_t client_id_size,
   }
 
   std::string remote_id(user_id, user_id_size);
+  std::shared_lock lock(render->client_properties_mutex_);
   if (render->client_properties_.find(remote_id) ==
       render->client_properties_.end()) {
     return;

src/gui/windows/main_window.cpp

@@ -32,6 +32,7 @@ int Render::MainWindow() {
   StatusBar();
 
   if (show_connection_status_window_) {
+    std::unique_lock lock(client_properties_mutex_);
     for (auto it = client_properties_.begin();
          it != client_properties_.end();) {
       auto& props = it->second;

src/gui/windows/request_permission_window.mm

@@ -3,87 +3,111 @@
 #include "rd_log.h"
 #include "render.h"
 
-#ifdef __APPLE__
 #include <ApplicationServices/ApplicationServices.h>
 #include <CoreGraphics/CoreGraphics.h>
 #import <Foundation/Foundation.h>
 #include <unistd.h>
 #include <cstdlib>
-#endif
 
 namespace crossdesk {
 
-#ifdef __APPLE__
+bool Render::DrawToggleSwitch(const char* id, bool active, bool enabled) {
+  const float TRACK_HEIGHT = ImGui::GetFrameHeight();
+  const float TRACK_WIDTH = TRACK_HEIGHT * 1.8f;
+  const float TRACK_RADIUS = TRACK_HEIGHT * 0.5f;
+  const float KNOB_PADDING = 2.0f;
+  const float KNOB_HEIGHT = TRACK_HEIGHT - 4.0f;
+  const float KNOB_WIDTH = KNOB_HEIGHT * 1.2f;
+  const float KNOB_RADIUS = KNOB_HEIGHT * 0.5f;
+  const float DISABLED_ALPHA = 0.6f;
+  const float KNOB_ALPHA_DISABLED = 0.9f;
+
+  const ImVec4 COLOR_ACTIVE = ImVec4(0.0f, 0.0f, 1.0f, 1.0f);
+  const ImVec4 COLOR_ACTIVE_HOVER = ImVec4(0.26f, 0.59f, 0.98f, 1.0f);
+  const ImVec4 COLOR_INACTIVE = ImVec4(0.60f, 0.60f, 0.60f, 1.0f);
+  const ImVec4 COLOR_INACTIVE_HOVER = ImVec4(0.70f, 0.70f, 0.70f, 1.0f);
+  const ImVec4 COLOR_KNOB = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+
+  ImDrawList* draw_list = ImGui::GetWindowDrawList();
+  ImVec2 track_pos = ImGui::GetCursorScreenPos();
+
+  ImGui::InvisibleButton(id, ImVec2(TRACK_WIDTH, TRACK_HEIGHT));
+  bool hovered = ImGui::IsItemHovered();
+  bool clicked = ImGui::IsItemClicked() && enabled;
+
+  ImVec4 track_color = active ? (hovered && enabled ? COLOR_ACTIVE_HOVER : COLOR_ACTIVE)
+                              : (hovered && enabled ? COLOR_INACTIVE_HOVER : COLOR_INACTIVE);
+
+  if (!enabled) {
+    track_color.w *= DISABLED_ALPHA;
+  }
+
+  ImVec2 track_min = ImVec2(track_pos.x, track_pos.y + 0.5f);
+  ImVec2 track_max = ImVec2(track_pos.x + TRACK_WIDTH, track_pos.y + TRACK_HEIGHT - 0.5f);
+  draw_list->AddRectFilled(track_min, track_max, ImGui::GetColorU32(track_color), TRACK_RADIUS);
+
+  float knob_position = active ? 1.0f : 0.0f;
+  float knob_min_x = track_pos.x + KNOB_PADDING;
+  float knob_max_x = track_pos.x + TRACK_WIDTH - KNOB_WIDTH - KNOB_PADDING;
+  float knob_x = knob_min_x + knob_position * (knob_max_x - knob_min_x);
+  float knob_y = track_pos.y + (TRACK_HEIGHT - KNOB_HEIGHT) * 0.5f;
+
+  ImVec4 knob_color = COLOR_KNOB;
+  if (!enabled) {
+    knob_color.w = KNOB_ALPHA_DISABLED;
+  }
+
+  ImVec2 knob_min = ImVec2(knob_x, knob_y);
+  ImVec2 knob_max = ImVec2(knob_x + KNOB_WIDTH, knob_y + KNOB_HEIGHT);
+  draw_list->AddRectFilled(knob_min, knob_max, ImGui::GetColorU32(knob_color), KNOB_RADIUS);
+
+  return clicked;
+}
+
 bool Render::CheckScreenRecordingPermission() {
   // CGPreflightScreenCaptureAccess is available on macOS 10.15+
   if (@available(macOS 10.15, *)) {
     bool granted = CGPreflightScreenCaptureAccess();
-    LOG_INFO("CGPreflightScreenCaptureAccess returned: {}", granted);
     return granted;
   }
-  // For older macOS versions, assume permission is granted
+  // for older macOS versions, assume permission is granted
   return true;
 }
 
 bool Render::CheckAccessibilityPermission() {
-  // Check if the process is trusted for accessibility
-  // Note: This may require app restart to reflect permission changes
   NSDictionary* options = @{(__bridge id)kAXTrustedCheckOptionPrompt : @NO};
   bool trusted = AXIsProcessTrustedWithOptions((__bridge CFDictionaryRef)options);
-  LOG_INFO("AXIsProcessTrustedWithOptions returned: {}", trusted);
   return trusted;
 }
 
-void Render::OpenSystemPreferences() {
-  // Open System Preferences to the Privacy & Security > Screen Recording or
-  // Accessibility section
-  system("open "
-         "\"x-apple.systempreferences:com.apple.preference.security?Privacy_"
-         "ScreenCapture\"");
-}
-
-void Render::OpenScreenRecordingPreferences() {
-  // Request screen recording permission first to ensure app appears in System Settings
-  if (@available(macOS 10.15, *)) {
-    CGRequestScreenCaptureAccess();
-  }
-  // Open System Preferences to the Privacy & Security > Screen Recording section
-  system("open "
-         "\"x-apple.systempreferences:com.apple.preference.security?Privacy_"
-         "ScreenCapture\"");
-}
-
 void Render::OpenAccessibilityPreferences() {
-  // Request accessibility permission first to ensure app appears in System Settings
   NSDictionary* options = @{(__bridge id)kAXTrustedCheckOptionPrompt : @YES};
   AXIsProcessTrustedWithOptions((__bridge CFDictionaryRef)options);
-  // Open System Preferences to the Privacy & Security > Accessibility section
+
   system("open "
          "\"x-apple.systempreferences:com.apple.preference.security?Privacy_"
          "Accessibility\"");
 }
-#endif
+
+void Render::OpenScreenRecordingPreferences() {
+  if (@available(macOS 10.15, *)) {
+    CGRequestScreenCaptureAccess();
+  }
+
+  system("open "
+         "\"x-apple.systempreferences:com.apple.preference.security?Privacy_"
+         "ScreenCapture\"");
+}
 
 int Render::RequestPermissionWindow() {
-#ifdef __APPLE__
-  // Check permissions - recheck every frame to update status immediately after user grants
-  // permission
   bool screen_recording_granted = CheckScreenRecordingPermission();
   bool accessibility_granted = CheckAccessibilityPermission();
 
-  // Update show_request_permission_window_ based on permission status
-  // Keep window visible if any permission is not granted
   show_request_permission_window_ = !screen_recording_granted || !accessibility_granted;
 
-  // Log permission status for debugging
-  LOG_INFO("Screen recording permission: {}, Accessibility permission: {}",
-           screen_recording_granted, accessibility_granted);
-
   if (!show_request_permission_window_) {
-    LOG_INFO("Request permission window is not shown");
     return 0;
   }
-  LOG_INFO("Request permission window is shown");
 
   const ImGuiViewport* viewport = ImGui::GetMainViewport();
   float window_width = localization_language_index_ == 0 ? REQUEST_PERMISSION_WINDOW_WIDTH_CN
@@ -91,32 +115,34 @@ int Render::RequestPermissionWindow() {
   float window_height = localization_language_index_ == 0 ? REQUEST_PERMISSION_WINDOW_HEIGHT_CN
                                                           : REQUEST_PERMISSION_WINDOW_HEIGHT_EN;
 
-  // Center the window on screen
+  float checkbox_padding = localization_language_index_ == 0
+                               ? REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_CN
+                               : REQUEST_PERMISSION_WINDOW_CHECKBOX_PADDING_EN;
+
   ImVec2 center_pos = ImVec2((viewport->WorkSize.x - window_width) * 0.5f + viewport->WorkPos.x,
                              (viewport->WorkSize.y - window_height) * 0.5f + viewport->WorkPos.y);
-  ImGui::SetNextWindowPos(center_pos, ImGuiCond_Always);
+  ImGui::SetNextWindowPos(center_pos, ImGuiCond_Once);
 
   ImGui::SetNextWindowSize(ImVec2(window_width, window_height), ImGuiCond_Always);
 
-  // Make window always on top and modal-like
   ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
   ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
   ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
   ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0f);
-  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(20.0f, 15.0f));
+  ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
 
-  ImGui::Begin(localization::request_permissions[localization_language_index_].c_str(), nullptr,
+  ImGui::Begin(
-               ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoMove |
+      localization::request_permissions[localization_language_index_].c_str(), nullptr,
-                   ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_Modal);
+      ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings);
 
   ImGui::SetWindowFontScale(0.3f);
 
-  // use system Chinese font
+  // use system font
   if (system_chinese_font_ != nullptr) {
     ImGui::PushFont(system_chinese_font_);
   }
 
-  // Message
+  ImGui::SetCursorPosY(ImGui::GetCursorPosY() + ImGui::GetTextLineHeight() + 5.0f);
   ImGui::SetCursorPosX(10.0f);
   ImGui::TextWrapped(
       "%s", localization::permission_required_message[localization_language_index_].c_str());
@@ -125,40 +151,38 @@ int Render::RequestPermissionWindow() {
   ImGui::Spacing();
   ImGui::Spacing();
 
-  // Accessibility Permission
+  // accessibility permission
   ImGui::SetCursorPosX(10.0f);
   ImGui::AlignTextToFramePadding();
   ImGui::Text("1. %s:",
               localization::accessibility_permission[localization_language_index_].c_str());
   ImGui::SameLine();
   ImGui::AlignTextToFramePadding();
+  ImGui::SetCursorPosX(checkbox_padding);
   if (accessibility_granted) {
-    ImGui::Text("%s", localization::permission_granted[localization_language_index_].c_str());
+    DrawToggleSwitch("accessibility_toggle_on", true, false);
   } else {
-    ImGui::Text("%s", localization::permission_denied[localization_language_index_].c_str());
+    if (DrawToggleSwitch("accessibility_toggle", accessibility_granted, !accessibility_granted)) {
-    ImGui::SameLine();
-    if (ImGui::Button(
-            localization::open_keyboard_mouse_settings[localization_language_index_].c_str())) {
       OpenAccessibilityPreferences();
     }
   }
 
   ImGui::Spacing();
 
-  // Screen Recording Permission
+  // screen recording permission
   ImGui::SetCursorPosX(10.0f);
   ImGui::AlignTextToFramePadding();
   ImGui::Text("2. %s:",
               localization::screen_recording_permission[localization_language_index_].c_str());
   ImGui::SameLine();
   ImGui::AlignTextToFramePadding();
+  ImGui::SetCursorPosX(checkbox_padding);
   if (screen_recording_granted) {
-    ImGui::Text("%s", localization::permission_granted[localization_language_index_].c_str());
+    ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 10.0f);
+    DrawToggleSwitch("screen_recording_toggle_on", true, false);
   } else {
-    ImGui::Text("%s", localization::permission_denied[localization_language_index_].c_str());
+    if (DrawToggleSwitch("screen_recording_toggle", screen_recording_granted,
-    ImGui::SameLine();
+                         !screen_recording_granted)) {
-    if (ImGui::Button(
-            localization::open_screen_recording_settings[localization_language_index_].c_str())) {
       OpenScreenRecordingPreferences();
     }
   }
@@ -177,8 +201,5 @@ int Render::RequestPermissionWindow() {
   ImGui::PopStyleColor();
 
   return 0;
-#else
-  return 0;
-#endif
 }
 }  // namespace crossdesk

src/gui/windows/stream_window.cpp

@@ -32,12 +32,15 @@ void Render::DrawConnectionStatusText(
 }
 
 void Render::CloseTab(decltype(client_properties_)::iterator& it) {
-  CleanupPeer(it->second);
+  std::unique_lock lock(client_properties_mutex_);
-  it = client_properties_.erase(it);
+  if (it != client_properties_.end()) {
-  if (client_properties_.empty()) {
+    CleanupPeer(it->second);
-    SDL_Event event;
+    it = client_properties_.erase(it);
-    event.type = SDL_EVENT_QUIT;
+    if (client_properties_.empty()) {
-    SDL_PushEvent(&event);
+      SDL_Event event;
+      event.type = SDL_EVENT_QUIT;
+      SDL_PushEvent(&event);
+    }
   }
 }
 
@@ -79,11 +82,22 @@ int Render::StreamWindow() {
                                ImGuiTabBarFlags_AutoSelectNewTabs)) {
       is_tab_bar_hovered_ = ImGui::IsWindowHovered();
 
+      std::shared_lock lock(client_properties_mutex_);
       for (auto it = client_properties_.begin();
            it != client_properties_.end();) {
         auto& props = it->second;
         if (!props->tab_opened_) {
-          CloseTab(it);
+          std::string remote_id_to_close = props->remote_id_;
+          lock.unlock();
+          {
+            std::unique_lock unique_lock(client_properties_mutex_);
+            auto close_it = client_properties_.find(remote_id_to_close);
+            if (close_it != client_properties_.end()) {
+              CloseTab(close_it);
+            }
+          }
+          lock.lock();
+          it = client_properties_.begin();
           continue;
         }
 
@@ -122,12 +136,23 @@ int Render::StreamWindow() {
           focused_remote_id_ = props->remote_id_;
 
           if (!props->peer_) {
-            it = client_properties_.erase(it);
+            std::string remote_id_to_erase = props->remote_id_;
-            if (client_properties_.empty()) {
+            lock.unlock();
-              SDL_Event event;
+            {
-              event.type = SDL_EVENT_QUIT;
+              std::unique_lock unique_lock(client_properties_mutex_);
-              SDL_PushEvent(&event);
+              auto erase_it = client_properties_.find(remote_id_to_erase);
+              if (erase_it != client_properties_.end()) {
+                erase_it = client_properties_.erase(erase_it);
+                if (client_properties_.empty()) {
+                  SDL_Event event;
+                  event.type = SDL_EVENT_QUIT;
+                  SDL_PushEvent(&event);
+                }
+              }
             }
+            lock.lock();
+            it = client_properties_.begin();
+            continue;
           } else {
             DrawConnectionStatusText(props);
             ++it;
@@ -147,11 +172,22 @@ int Render::StreamWindow() {
 
     ImGui::End();  // End TabBar
   } else {
+    std::shared_lock lock(client_properties_mutex_);
     for (auto it = client_properties_.begin();
          it != client_properties_.end();) {
       auto& props = it->second;
       if (!props->tab_opened_) {
-        CloseTab(it);
+        std::string remote_id_to_close = props->remote_id_;
+        lock.unlock();
+        {
+          std::unique_lock unique_lock(client_properties_mutex_);
+          auto close_it = client_properties_.find(remote_id_to_close);
+          if (close_it != client_properties_.end()) {
+            CloseTab(close_it);
+          }
+        }
+        lock.lock();
+        it = client_properties_.begin();
         continue;
       }
 
@@ -181,12 +217,23 @@ int Render::StreamWindow() {
         if (!props->peer_) {
           fullscreen_button_pressed_ = false;
           SDL_SetWindowFullscreen(stream_window_, false);
-          it = client_properties_.erase(it);
+          std::string remote_id_to_erase = props->remote_id_;
-          if (client_properties_.empty()) {
+          lock.unlock();
-            SDL_Event event;
+          {
-            event.type = SDL_EVENT_QUIT;
+            std::unique_lock unique_lock(client_properties_mutex_);
-            SDL_PushEvent(&event);
+            auto erase_it = client_properties_.find(remote_id_to_erase);
+            if (erase_it != client_properties_.end()) {
+              client_properties_.erase(erase_it);
+              if (client_properties_.empty()) {
+                SDL_Event event;
+                event.type = SDL_EVENT_QUIT;
+                SDL_PushEvent(&event);
+              }
+            }
           }
+          lock.lock();
+          it = client_properties_.begin();
+          continue;
         } else {
           DrawConnectionStatusText(props);
           ++it;

src/gui/windows/update_notification_window.cpp

@@ -58,6 +58,12 @@ int Render::UpdateNotificationWindow() {
     float window_width = update_notification_window_width_;
     float window_height = update_notification_window_height_;
 
+#ifdef __APPLE__
+    float font_scale = 0.3f;
+#else
+    float font_scale = 0.5f;
+#endif
+
     ImGui::SetNextWindowPos(
         ImVec2(
             (viewport->WorkSize.x - viewport->WorkPos.x - window_width) / 2,
@@ -70,29 +76,27 @@ int Render::UpdateNotificationWindow() {
     ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 1.0f);
     ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 5.0f);
     ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0f);
-    ImGui::SetWindowFontScale(0.5f);
     ImGui::Begin(
         localization::notification[localization_language_index_].c_str(),
         nullptr,
         ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
-            ImGuiWindowFlags_NoSavedSettings);
+            ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoTitleBar);
 
-    ImGui::SetWindowFontScale(1.0f);
-    ImGui::SetWindowFontScale(0.5f);
-
-    // use system Chinese font
     if (system_chinese_font_ != nullptr) {
       ImGui::PushFont(system_chinese_font_);
     }
 
+    ImGui::SetCursorPosY(ImGui::GetCursorPosY() + ImGui::GetTextLineHeight() +
+                         5.0f);
+
     // title: new version available
     ImGui::SetCursorPosX(window_width * 0.1f);
-    ImGui::SetWindowFontScale(0.7f);
+    ImGui::SetWindowFontScale(font_scale + 0.2f);
     std::string title =
         localization::new_version_available[localization_language_index_] +
         ": v" + latest_version_;
     ImGui::Text("%s", title.c_str());
-    ImGui::SetWindowFontScale(0.5f);
+    ImGui::SetWindowFontScale(font_scale);
 
     ImGui::Spacing();
 
@@ -104,8 +108,8 @@ int Render::UpdateNotificationWindow() {
 
     ImGui::Spacing();
 
-    float reserved_height = 140.0f;
+    float scrollable_height =
-    float scrollable_height = window_height - reserved_height;
+        window_height - UPDATE_NOTIFICATION_RESERVED_HEIGHT;
 
     // scrollable content area
     ImGui::SetCursorPosX(window_width * 0.05f);
@@ -187,7 +191,7 @@ int Render::UpdateNotificationWindow() {
     }
 
     ImGui::SetWindowFontScale(1.0f);
-    ImGui::SetWindowFontScale(0.5f);
+    ImGui::SetWindowFontScale(font_scale);
 
     // pop system font
     if (system_chinese_font_ != nullptr) {

src/path_manager/path_manager.cpp

@@ -36,7 +36,7 @@ std::filesystem::path PathManager::GetLogPath() {
 #elif __APPLE__
   return GetHome() + "/Library/Logs/" + app_name_;
 #else
-  return GetCachePath() / app_name_ / "logs";
+  return GetCachePath() / "logs";
 #endif
 }
 

src/screen_capturer/macosx/screen_capturer_sck_impl.mm

@@ -196,14 +196,26 @@ ScreenCapturerSckImpl::~ScreenCapturerSckImpl() {
 
 int ScreenCapturerSckImpl::Init(const int fps, cb_desktop_data cb) {
   _on_data = cb;
+  fps_ = fps;
+
+  if (@available(macOS 10.15, *)) {
+    bool has_permission = CGPreflightScreenCaptureAccess();
+    if (!has_permission) {
+      LOG_ERROR("Screen recording permission not granted");
+      return -1;
+    }
+  }
 
   dispatch_semaphore_t sema = dispatch_semaphore_create(0);
   __block SCShareableContent *content = nil;
+  __block NSError *capture_error = nil;
 
   [SCShareableContent
       getShareableContentWithCompletionHandler:^(SCShareableContent *result, NSError *error) {
         if (error) {
-          NSLog(@"Failed to get shareable content: %@", error);
+          capture_error = error;
+          LOG_ERROR("Failed to get shareable content: {}",
+                    std::string([error.localizedDescription UTF8String]));
         } else {
           content = result;
         }
@@ -211,9 +223,10 @@ int ScreenCapturerSckImpl::Init(const int fps, cb_desktop_data cb) {
       }];
   dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
 
-  if (!content || content.displays.count == 0) {
+  if (capture_error || !content || content.displays.count == 0) {
-    LOG_ERROR("Failed to get display info");
+    LOG_ERROR("Failed to get display info, error: {}",
-    return 0;
+              std::string([capture_error.localizedDescription UTF8String]));
+    return -1;
   }
 
   CGDirectDisplayID displays[10];
@@ -252,6 +265,16 @@ int ScreenCapturerSckImpl::Init(const int fps, cb_desktop_data cb) {
 }
 
 int ScreenCapturerSckImpl::Start(bool show_cursor) {
+  if (permanent_error_) {
+    LOG_ERROR("Cannot start capturer: permanent error occurred");
+    return -1;
+  }
+
+  if (display_info_list_.empty()) {
+    LOG_ERROR("Cannot start capturer: display info not initialized");
+    return -1;
+  }
+
   show_cursor_ = show_cursor;
   StartOrReconfigureCapturer();
   return 0;
@@ -307,17 +330,17 @@ void ScreenCapturerSckImpl::OnShareableContentCreated(SCShareableContent *conten
     return;
   }
 
-  if (!content.displays.count) {
+  if (!content.displays || content.displays.count == 0) {
     LOG_ERROR("getShareableContent returned no displays");
     permanent_error_ = true;
     return;
   }
 
-  SCDisplay *captured_display;
+  SCDisplay *captured_display = nil;
   {
     std::lock_guard<std::mutex> lock(lock_);
     for (SCDisplay *display in content.displays) {
-      if (current_display_ == display.displayID) {
+      if (current_display_ != 0 && current_display_ == display.displayID) {
         LOG_WARN("current display: {}, name: {}", current_display_,
                  display_id_name_map_[current_display_]);
         captured_display = display;
@@ -326,13 +349,33 @@ void ScreenCapturerSckImpl::OnShareableContentCreated(SCShareableContent *conten
     }
     if (!captured_display) {
       captured_display = content.displays.firstObject;
-      current_display_ = captured_display.displayID;
+      if (captured_display) {
+        current_display_ = captured_display.displayID;
+      }
     }
   }
 
+  if (!captured_display) {
+    LOG_ERROR("Failed to find valid display");
+    permanent_error_ = true;
+    return;
+  }
+
   SCContentFilter *filter = [[SCContentFilter alloc] initWithDisplay:captured_display
                                                     excludingWindows:@[]];
+  if (!filter) {
+    LOG_ERROR("Failed to create SCContentFilter");
+    permanent_error_ = true;
+    return;
+  }
+
   SCStreamConfiguration *config = [[SCStreamConfiguration alloc] init];
+  if (!config) {
+    LOG_ERROR("Failed to create SCStreamConfiguration");
+    permanent_error_ = true;
+    return;
+  }
+
   config.pixelFormat = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
   config.showsCursor = show_cursor_;
   config.width = filter.contentRect.size.width * filter.pointPixelScale;
@@ -423,11 +466,28 @@ void ScreenCapturerSckImpl::OnNewCVPixelBuffer(CVPixelBufferRef pixelBuffer,
 }
 
 void ScreenCapturerSckImpl::StartOrReconfigureCapturer() {
-  // The copy is needed to avoid capturing `this` in the Objective-C block. Accessing `helper_`
+  if (permanent_error_) {
-  // inside the block is equivalent to `this->helper_` and would crash (UAF) if `this` is
+    LOG_ERROR("Cannot reconfigure capturer: permanent error occurred");
-  // deleted before the block is executed.
+    return;
+  }
+
+  if (@available(macOS 10.15, *)) {
+    bool has_permission = CGPreflightScreenCaptureAccess();
+    if (!has_permission) {
+      LOG_ERROR("Screen recording permission not granted");
+      permanent_error_ = true;
+      return;
+    }
+  }
+
   SckHelper *local_helper = helper_;
   auto handler = ^(SCShareableContent *content, NSError *error) {
+    if (error) {
+      LOG_ERROR("getShareableContent failed: {}",
+                std::string([error.localizedDescription UTF8String]));
+      [local_helper onShareableContentCreated:nil];
+      return;
+    }
     [local_helper onShareableContentCreated:content];
   };
   [SCShareableContent getShareableContentWithCompletionHandler:handler];