Merge branch 'airplane-mode' of https://github.com/evergreen22/InfiniTime into evergreen22-airplane-mode

Apply a few changes that were requested in the PR during the review.

# Conflicts:
#	src/CMakeLists.txt
#	src/displayapp/Apps.h
#	src/displayapp/DisplayApp.cpp
#	src/displayapp/Messages.h
#	src/displayapp/screens/settings/Settings.cpp

src/components/ble/BleController.cpp

@@ -2,12 +2,28 @@
 
 using namespace Pinetime::Controllers;
 
-void Ble::SetConnectState(Ble::ConnectStates newState) {
+bool Ble::IsConnected() const {
-  connectionState = newState;
+  return isConnected;
 }
 
-Ble::ConnectStates Ble::GetConnectState() const {
+void Ble::Connect() {
-  return connectionState;
+  isConnected = true;
+}
+
+void Ble::Disconnect() {
+  isConnected = false;
+}
+
+bool Ble::IsRadioEnabled() const {
+  return isRadioEnabled;
+}
+
+void Ble::EnableRadio() {
+  isRadioEnabled = true;
+}
+
+void Ble::DisableRadio() {
+  isRadioEnabled = false;
 }
 
 void Ble::StartFirmwareUpdate() {

src/components/ble/BleController.h

@@ -10,14 +10,15 @@ namespace Pinetime {
       using BleAddress = std::array<uint8_t, 6>;
       enum class FirmwareUpdateStates { Idle, Running, Validated, Error };
       enum class AddressTypes { Public, Random, RPA_Public, RPA_Random };
-      enum class ConnectStates { Disconnected, Connected, Airplane };
 
       Ble() = default;
-      bool IsConnected() const {
+      bool IsConnected() const;
-        return (connectionState == ConnectStates::Connected);
+      void Connect();
-      }
+      void Disconnect();
-      void SetConnectState(ConnectStates newState);
+
-      ConnectStates GetConnectState() const;
+      bool IsRadioEnabled() const;
+      void EnableRadio();
+      void DisableRadio();
 
       void StartFirmwareUpdate();
       void StopFirmwareUpdate();
@@ -57,7 +58,8 @@ namespace Pinetime {
       }
 
     private:
-      ConnectStates connectionState = ConnectStates::Disconnected;
+      bool isConnected = false;
+      bool isRadioEnabled = true;
       bool isFirmwareUpdating = false;
       uint32_t firmwareUpdateTotalBytes = 0;
       uint32_t firmwareUpdateCurrentBytes = 0;

src/components/ble/NimbleController.cpp

@@ -184,7 +184,7 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
     case BLE_GAP_EVENT_ADV_COMPLETE:
       NRF_LOG_INFO("Advertising event : BLE_GAP_EVENT_ADV_COMPLETE");
       NRF_LOG_INFO("reason=%d; status=%0X", event->adv_complete.reason, event->connect.status);
-      if (bleController.GetConnectState() == Ble::ConnectStates::Disconnected) {
+      if (bleController.IsRadioEnabled() && !bleController.IsConnected()) {
         StartAdvertising();
       }
       break;
@@ -199,12 +199,12 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
         currentTimeClient.Reset();
         alertNotificationClient.Reset();
         connectionHandle = BLE_HS_CONN_HANDLE_NONE;
-        bleController.SetConnectState(Ble::ConnectStates::Disconnected);
+        bleController.Disconnect();
         fastAdvCount = 0;
         StartAdvertising();
       } else {
         connectionHandle = event->connect.conn_handle;
-        bleController.SetConnectState(Ble::ConnectStates::Connected);
+        bleController.Connect();
         systemTask.PushMessage(Pinetime::System::Messages::BleConnected);
         // Service discovery is deferred via systemtask
       }
@@ -222,8 +222,8 @@ int NimbleController::OnGAPEvent(ble_gap_event* event) {
       currentTimeClient.Reset();
       alertNotificationClient.Reset();
       connectionHandle = BLE_HS_CONN_HANDLE_NONE;
-      if (bleController.GetConnectState() == Ble::ConnectStates::Connected) {
+      if(bleController.IsConnected()) {
-        bleController.SetConnectState(Ble::ConnectStates::Disconnected);
+        bleController.Disconnect();
         fastAdvCount = 0;
         StartAdvertising();
       }
@@ -401,19 +401,20 @@ void NimbleController::NotifyBatteryLevel(uint8_t level) {
   }
 }
 
-void NimbleController::SwitchAirplaneMode(bool enabled) {
+void NimbleController::EnableRadio() {
-  if (enabled) {
+  bleController.EnableRadio();
-    if (bleController.IsConnected()) {
+  bleController.Disconnect();
-      bleController.SetConnectState(Ble::ConnectStates::Airplane);
-      ble_gap_terminate(connectionHandle, BLE_ERR_REM_USER_CONN_TERM);
-    } else {
-      bleController.SetConnectState(Ble::ConnectStates::Airplane);
-      ble_gap_adv_stop();
-    }
-  } else {
-    bleController.SetConnectState(Ble::ConnectStates::Disconnected);
   fastAdvCount = 0;
   StartAdvertising();
+}
+
+void NimbleController::DisableRadio() {
+  bleController.DisableRadio();
+  if (bleController.IsConnected()) {
+    ble_gap_terminate(connectionHandle, BLE_ERR_REM_USER_CONN_TERM);
+    bleController.Disconnect();
+  } else {
+    ble_gap_adv_stop();
   }
 }
 

src/components/ble/NimbleController.h

@@ -53,18 +53,6 @@ namespace Pinetime {
       void Init();
       void StartAdvertising();
       int OnGAPEvent(ble_gap_event* event);
-
-      /* these are not implemented yet
-      int OnDiscoveryEvent(uint16_t i, const ble_gatt_error* pError, const ble_gatt_svc* pSvc);
-      int OnCTSCharacteristicDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error* error, const ble_gatt_chr* characteristic);
-      int OnANSCharacteristicDiscoveryEvent(uint16_t connectionHandle, const ble_gatt_error* error, const ble_gatt_chr* characteristic);
-      int OnCurrentTimeReadResult(uint16_t connectionHandle, const ble_gatt_error* error, ble_gatt_attr* attribute);
-      int OnANSDescriptorDiscoveryEventCallback(uint16_t connectionHandle,
-                                                const ble_gatt_error* error,
-                                                uint16_t characteristicValueHandle,
-                                                const ble_gatt_dsc* descriptor);
-      */
-
       void StartDiscovery();
 
       Pinetime::Controllers::MusicService& music() {
@@ -87,7 +75,8 @@ namespace Pinetime {
         fastAdvCount = 0;
       };
 
-      void SwitchAirplaneMode(bool enabled);
+      void EnableRadio();
+      void DisableRadio();
 
     private:
       void PersistBond(struct ble_gap_conn_desc& desc);

src/components/settings/Settings.h

@@ -202,12 +202,12 @@ namespace Pinetime {
         return settings.stepsGoal;
       };
 
-     void SetAirplaneMode(bool mode) {
+     void SetBleRadioEnabled(bool enabled) {
-       airplaneMode = mode;
+       bleRadioEnabled = enabled;
      };
 
-     bool GetAirplaneMode() const {
+     bool GetBleRadioEnabled() const {
-       return airplaneMode;
+       return bleRadioEnabled;
      };
 
     private:
@@ -240,7 +240,7 @@ namespace Pinetime {
       /* airplaneMode is intentionally not saved with the other watch settings and initialized
        * to off (false) on every boot because we always want ble to be enabled on startup
        */
-      bool airplaneMode = false;
+      bool bleRadioEnabled = true;
 
       void LoadSettingsFromFile();
       void SaveSettingsToFile();

src/displayapp/DisplayApp.cpp

@@ -293,8 +293,8 @@ void DisplayApp::Refresh() {
       case Messages::BleFirmwareUpdateStarted:
         LoadApp(Apps::FirmwareUpdate, DisplayApp::FullRefreshDirections::Down);
         break;
-      case Messages::AirplaneModeToggle:
+      case Messages::BleRadioEnableToggle:
-        PushMessageToSystemTask(System::Messages::AirplaneModeToggle);
+        PushMessageToSystemTask(System::Messages::BleRadioEnableToggle);
         break;
       case Messages::UpdateDateTime:
         // Added to remove warning

src/displayapp/Messages.h

@@ -22,7 +22,7 @@ namespace Pinetime {
         ShowPairingKey,
         AlarmTriggered,
         Clock,
-        AirplaneModeToggle
+        BleRadioEnableToggle
       };
     }
   }

src/displayapp/screens/BleIcon.cpp

@@ -2,11 +2,14 @@
 #include "displayapp/screens/Symbols.h"
 using namespace Pinetime::Applications::Screens;
 
-const char* BleIcon::GetIcon(Pinetime::Controllers::Ble::ConnectStates state) {
+const char* BleIcon::GetIcon(bool isRadioEnabled, bool isConnected) {
-  if (state == Pinetime::Controllers::Ble::ConnectStates::Connected)
+  if(!isRadioEnabled) {
-    return Symbols::bluetooth;
-  else if (state == Pinetime::Controllers::Ble::ConnectStates::Airplane)
     return Symbols::airplane;
-  else
+  }
+
+  if (isConnected) {
+    return Symbols::bluetooth;
+  }
+
   return Symbols::none;
 }

src/displayapp/screens/BleIcon.h

@@ -7,7 +7,7 @@ namespace Pinetime {
     namespace Screens {
       class BleIcon {
       public:
-        static const char* GetIcon(Pinetime::Controllers::Ble::ConnectStates state);
+        static const char* GetIcon(bool isRadioEnabled, bool isConnected);
       };
     }
   }

src/displayapp/screens/PineTimeStyle.cpp

@@ -42,6 +42,13 @@ namespace {
     auto* screen = static_cast<PineTimeStyle*>(obj->user_data);
     screen->UpdateSelected(obj, event);
   }
+
+  bool IsBleIconVisible(bool isRadioEnabled, bool isConnected) {
+    if(!isRadioEnabled) {
+      return true;
+    }
+    return isConnected;
+  }
 }
 
 PineTimeStyle::PineTimeStyle(DisplayApp* app,
@@ -336,11 +343,13 @@ void PineTimeStyle::SetBatteryIcon() {
   lv_label_set_text_static(batteryIcon, BatteryIcon::GetBatteryIcon(batteryPercent));
 }
 
+
 void PineTimeStyle::AlignIcons() {
-  if (notificationState.Get() && bleState.Get() != Pinetime::Controllers::Ble::ConnectStates::Disconnected) {
+  bool isBleIconVisible = IsBleIconVisible(bleRadioEnabled.Get(), bleState.Get());
+  if (notificationState.Get() && isBleIconVisible) {
     lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 8, 25);
     lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, -8, 25);
-  } else if (notificationState.Get() && bleState.Get() == Pinetime::Controllers::Ble::ConnectStates::Disconnected) {
+  } else if (notificationState.Get() && !isBleIconVisible) {
     lv_obj_align(notificationIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
   } else {
     lv_obj_align(bleIcon, sidebar, LV_ALIGN_IN_TOP_MID, 0, 25);
@@ -363,9 +372,10 @@ void PineTimeStyle::Refresh() {
     }
   }
 
-  bleState = bleController.GetConnectState();
+  bleState = bleController.IsConnected();
-  if (bleState.IsUpdated()) {
+  bleRadioEnabled = bleController.IsRadioEnabled();
-    lv_label_set_text_static(bleIcon, BleIcon::GetIcon(bleState.Get()));
+  if (bleState.IsUpdated() || bleRadioEnabled.IsUpdated()) {
+    lv_label_set_text(bleIcon, BleIcon::GetIcon(bleRadioEnabled.Get(), bleState.Get()));
     AlignIcons();
   }
 

src/displayapp/screens/PineTimeStyle.h

@@ -51,7 +51,8 @@ namespace Pinetime {
 
         DirtyValue<uint8_t> batteryPercentRemaining {};
         DirtyValue<bool> isCharging {};
-        DirtyValue<Controllers::Ble::ConnectStates> bleState {};
+        DirtyValue<bool> bleState {};
+        DirtyValue<bool> bleRadioEnabled {};
         DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime {};
         DirtyValue<bool> motionSensorOk {};
         DirtyValue<uint32_t> stepCount {};

src/displayapp/screens/WatchFaceDigital.cpp

@@ -119,9 +119,10 @@ void WatchFaceDigital::Refresh() {
     lv_label_set_text_static(batteryIcon, BatteryIcon::GetBatteryIcon(batteryPercent));
   }
 
-  bleState = bleController.GetConnectState();
+  bleState = bleController.IsConnected();
-  if (bleState.IsUpdated()) {
+  bleRadioEnabled = bleController.IsRadioEnabled();
-    lv_label_set_text_static(bleIcon, BleIcon::GetIcon(bleState.Get()));
+  if (bleState.IsUpdated() || bleRadioEnabled.IsUpdated()) {
+    lv_label_set_text(bleIcon, BleIcon::GetIcon(bleRadioEnabled.Get(), bleState.Get()));
   }
   lv_obj_realign(batteryIcon);
   lv_obj_realign(batteryPlug);

src/displayapp/screens/WatchFaceDigital.h

@@ -46,7 +46,8 @@ namespace Pinetime {
 
         DirtyValue<uint8_t> batteryPercentRemaining {};
         DirtyValue<bool> powerPresent {};
-        DirtyValue<Controllers::Ble::ConnectStates> bleState {};
+        DirtyValue<bool> bleState {};
+        DirtyValue<bool> bleRadioEnabled {};
         DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime {};
         DirtyValue<bool> motionSensorOk {};
         DirtyValue<uint32_t> stepCount {};

src/displayapp/screens/WatchFaceTerminal.cpp

@@ -114,13 +114,18 @@ void WatchFaceTerminal::Refresh() {
   }
 
   bleState = bleController.IsConnected();
-  if (bleState.IsUpdated()) {
+  bleRadioEnabled = bleController.IsRadioEnabled();
+  if (bleState.IsUpdated() || bleRadioEnabled.IsUpdated()) {
+    if(!bleRadioEnabled.Get()) {
+      lv_label_set_text_static(connectState, "[STAT]#387b54 Disabled#");
+    } else {
       if (bleState.Get()) {
         lv_label_set_text_static(connectState, "[STAT]#387b54 Connected#");
       } else {
         lv_label_set_text_static(connectState, "[STAT]#387b54 Disconnected#");
       }
     }
+  }
 
   notificationState = notificatioManager.AreNewNotificationsAvailable();
   if (notificationState.IsUpdated()) {

src/displayapp/screens/WatchFaceTerminal.h

@@ -47,6 +47,7 @@ namespace Pinetime {
         DirtyValue<int> batteryPercentRemaining {};
         DirtyValue<bool> powerPresent {};
         DirtyValue<bool> bleState {};
+        DirtyValue<bool> bleRadioEnabled {};
         DirtyValue<std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>> currentDateTime {};
         DirtyValue<bool> motionSensorOk {};
         DirtyValue<uint32_t> stepCount {};

src/displayapp/screens/settings/SettingAirplaneMode.cpp

@@ -9,14 +9,17 @@
 using namespace Pinetime::Applications::Screens;
 
 namespace {
-  static void event_handler(lv_obj_t* obj, lv_event_t event) {
+  static void OnAirplaneModeEnabledEvent(lv_obj_t* obj, lv_event_t event) {
-    SettingAirplaneMode* screen = static_cast<SettingAirplaneMode*>(obj->user_data);
+    auto* screen = static_cast<SettingAirplaneMode*>(obj->user_data);
-    screen->UpdateSelected(obj, event);
+    screen->OnAirplaneModeEnabled(obj, event);
+  }
+
+  static void OnAirplaneModeDisabledEvent(lv_obj_t* obj, lv_event_t event) {
+    auto* screen = static_cast<SettingAirplaneMode*>(obj->user_data);
+    screen->OnAirplaneModeDisabled(obj, event);
   }
 }
 
-constexpr std::array<const char*, 2> SettingAirplaneMode::options;
-
 SettingAirplaneMode::SettingAirplaneMode(Pinetime::Applications::DisplayApp* app, Pinetime::Controllers::Settings& settingsController)
   : Screen(app), settingsController {settingsController} {
 
@@ -43,47 +46,48 @@ SettingAirplaneMode::SettingAirplaneMode(Pinetime::Applications::DisplayApp* app
   lv_label_set_align(icon, LV_LABEL_ALIGN_CENTER);
   lv_obj_align(icon, title, LV_ALIGN_OUT_LEFT_MID, -10, 0);
 
-  for (unsigned int i = 0; i < options.size(); i++) {
+  cbEnabled = lv_checkbox_create(container1, nullptr);
-    cbOption[i] = lv_checkbox_create(container1, nullptr);
+  lv_checkbox_set_text(cbEnabled, " Enable");
-    lv_checkbox_set_text(cbOption[i], options[i]);
+  cbEnabled->user_data = this;
-    cbOption[i]->user_data = this;
+  lv_obj_set_event_cb(cbEnabled, OnAirplaneModeEnabledEvent);
-    lv_obj_set_event_cb(cbOption[i], event_handler);
+  SetRadioButtonStyle(cbEnabled);
-    SetRadioButtonStyle(cbOption[i]);
-  }
 
-  if (settingsController.GetAirplaneMode() == false) {
+  cbDisabled = lv_checkbox_create(container1, nullptr);
-    lv_checkbox_set_checked(cbOption[0], true);
+  lv_checkbox_set_text(cbDisabled, " Disable");
-    priorMode = false;
+  cbDisabled->user_data = this;
-  } else {
+  lv_obj_set_event_cb(cbDisabled, OnAirplaneModeDisabledEvent);
-    lv_checkbox_set_checked(cbOption[1], true);
+  SetRadioButtonStyle(cbDisabled);
+
+  if (settingsController.GetBleRadioEnabled()) {
+    lv_checkbox_set_checked(cbDisabled, true);
     priorMode = true;
+  } else {
+    lv_checkbox_set_checked(cbEnabled, true);
+    priorMode = false;
   }
 }
 
 SettingAirplaneMode::~SettingAirplaneMode() {
   lv_obj_clean(lv_scr_act());
   // Do not call SaveSettings - see src/components/settings/Settings.h
-  if (priorMode != settingsController.GetAirplaneMode()) {
+  if (priorMode != settingsController.GetBleRadioEnabled()) {
-    app->PushMessage(Pinetime::Applications::Display::Messages::AirplaneModeToggle);
+    app->PushMessage(Pinetime::Applications::Display::Messages::BleRadioEnableToggle);
   }
 }
 
-void SettingAirplaneMode::UpdateSelected(lv_obj_t* object, lv_event_t event) {
+void SettingAirplaneMode::OnAirplaneModeEnabled(lv_obj_t* object, lv_event_t event) {
   if (event == LV_EVENT_VALUE_CHANGED) {
-    for (unsigned int i = 0; i < options.size(); i++) {
+    lv_checkbox_set_checked(cbEnabled, true);
-      if (object == cbOption[i]) {
+    lv_checkbox_set_checked(cbDisabled, false);
-        lv_checkbox_set_checked(cbOption[i], true);
+    settingsController.SetBleRadioEnabled(false);
-
-        if (i == 0) {
-          settingsController.SetAirplaneMode(false);
-        };
-        if (i == 1) {
-          settingsController.SetAirplaneMode(true);
-        };
-
-      } else {
-        lv_checkbox_set_checked(cbOption[i], false);
-      }
-    }
   }
 }
+
+void SettingAirplaneMode::OnAirplaneModeDisabled(lv_obj_t* object, lv_event_t event) {
+  if (event == LV_EVENT_VALUE_CHANGED) {
+    lv_checkbox_set_checked(cbEnabled, false);
+    lv_checkbox_set_checked(cbDisabled, true);
+    settingsController.SetBleRadioEnabled(true);
+  }
+}
+

src/displayapp/screens/settings/SettingAirplaneMode.h

@@ -17,12 +17,13 @@ namespace Pinetime {
         SettingAirplaneMode(DisplayApp* app, Pinetime::Controllers::Settings& settingsController);
         ~SettingAirplaneMode() override;
 
-        void UpdateSelected(lv_obj_t* object, lv_event_t event);
+        void OnAirplaneModeEnabled(lv_obj_t* object, lv_event_t event);
+        void OnAirplaneModeDisabled(lv_obj_t* object, lv_event_t event);
 
       private:
-        static constexpr std::array<const char*, 2> options = {" No", " Yes"};
         Controllers::Settings& settingsController;
-        lv_obj_t* cbOption[options.size()];
+        lv_obj_t* cbEnabled;
+        lv_obj_t* cbDisabled;
         bool priorMode;
       };
     }

src/displayapp/screens/settings/Settings.cpp

@@ -21,7 +21,11 @@ Settings::Settings(Pinetime::Applications::DisplayApp* app, Pinetime::Controller
               },
               [this]() -> std::unique_ptr<Screen> {
                 return CreateScreen3();
-              }},
+              },
+              [this]() -> std::unique_ptr<Screen> {
+               return CreateScreen4();
+              },
+             },
              Screens::ScreenListModes::UpDown} {
 }
 
@@ -34,7 +38,6 @@ bool Settings::OnTouchEvent(Pinetime::Applications::TouchEvents event) {
 }
 
 std::unique_ptr<Screen> Settings::CreateScreen1() {
-
   std::array<Screens::List::Applications, 4> applications {{
     {Symbols::sun, "Display", Apps::SettingDisplay},
     {Symbols::eye, "Wake Up", Apps::SettingWakeUp},
@@ -42,17 +45,17 @@ std::unique_ptr<Screen> Settings::CreateScreen1() {
     {Symbols::home, "Watch face", Apps::SettingWatchFace},
   }};
 
-  return std::make_unique<Screens::List>(0, 3, app, settingsController, applications);
+  return std::make_unique<Screens::List>(0, 4, app, settingsController, applications);
 }
 
 std::unique_ptr<Screen> Settings::CreateScreen2() {
-
+  std::array<Screens::List::Applications, 4> applications {{
-  std::array<Screens::List::Applications, 4> applications {{{Symbols::shoe, "Steps", Apps::SettingSteps},
+    {Symbols::shoe, "Steps", Apps::SettingSteps},
     {Symbols::clock, "Set date", Apps::SettingSetDate},
     {Symbols::clock, "Set time", Apps::SettingSetTime},
     {Symbols::batteryHalf, "Battery", Apps::BatteryInfo}}};
 
-  return std::make_unique<Screens::List>(1, 3, app, settingsController, applications);
+  return std::make_unique<Screens::List>(1, 4, app, settingsController, applications);
 }
 
 std::unique_ptr<Screen> Settings::CreateScreen3() {
@@ -61,8 +64,20 @@ std::unique_ptr<Screen> Settings::CreateScreen3() {
     {Symbols::clock, "Chimes", Apps::SettingChimes},
     {Symbols::tachometer, "Shake Calib.", Apps::SettingShakeThreshold},
     {Symbols::check, "Firmware", Apps::FirmwareValidation},
-    {Symbols::list, "About", Apps::SysInfo}
+    {Symbols::list, "Airplane mode", Apps::SettingAirplaneMode}
   }};
 
-  return std::make_unique<Screens::List>(2, 3, app, settingsController, applications);
+  return std::make_unique<Screens::List>(2, 4, app, settingsController, applications);
+}
+
+std::unique_ptr<Screen> Settings::CreateScreen4() {
+
+  std::array<Screens::List::Applications, 4> applications {{
+    {Symbols::list, "About", Apps::SysInfo},
+    {Symbols::none, "None", Apps::None},
+    {Symbols::none, "None", Apps::None},
+    {Symbols::none, "None", Apps::None}
+  }};
+
+  return std::make_unique<Screens::List>(3, 4, app, settingsController, applications);
 }

src/displayapp/screens/settings/Settings.h

@@ -19,11 +19,12 @@ namespace Pinetime {
       private:
         Controllers::Settings& settingsController;
 
-        ScreenList<3> screens;
+        ScreenList<4> screens;
 
         std::unique_ptr<Screen> CreateScreen1();
         std::unique_ptr<Screen> CreateScreen2();
         std::unique_ptr<Screen> CreateScreen3();
+        std::unique_ptr<Screen> CreateScreen4();
       };
     }
   }

src/systemtask/Messages.h

@@ -31,7 +31,7 @@ namespace Pinetime {
         BatteryPercentageUpdated,
         StartFileTransfer,
         StopFileTransfer,
-        AirplaneModeToggle
+        BleRadioEnableToggle
       };
     }
 }

src/systemtask/SystemTask.cpp

@@ -254,7 +254,7 @@ void SystemTask::Work() {
           displayApp.PushMessage(Pinetime::Applications::Display::Messages::GoToRunning);
           heartRateApp.PushMessage(Pinetime::Applications::HeartRateTask::Messages::WakeUp);
 
-          if (bleController.GetConnectState() == Controllers::Ble::ConnectStates::Disconnected) {
+          if (bleController.IsRadioEnabled() && !bleController.IsConnected()) {
             nimbleController.RestartFastAdv();
           }
 
@@ -440,8 +440,12 @@ void SystemTask::Work() {
           motorController.RunForDuration(35);
           displayApp.PushMessage(Pinetime::Applications::Display::Messages::ShowPairingKey);
           break;
-        case Messages::AirplaneModeToggle:
+        case Messages::BleRadioEnableToggle:
-          nimbleController.SwitchAirplaneMode(settingsController.GetAirplaneMode());
+          if(settingsController.GetBleRadioEnabled()) {
+            nimbleController.EnableRadio();
+          } else {
+            nimbleController.DisableRadio();
+          }
           break;
         default:
           break;