Add iOS platform support (stub implementation)

Author: lijy91

examples/menu_c_example/CMakeLists.txt

@@ -13,7 +13,9 @@ add_executable(menu_c_example main.c)
 target_link_libraries(menu_c_example nativeapi)
 
 # Platform-specific settings
-if(APPLE)
+if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    # iOS uses UIKit, Foundation, CoreGraphics (already linked by nativeapi)
+elseif(APPLE)
     find_library(COCOA_LIBRARY Cocoa)
     target_link_libraries(menu_c_example ${COCOA_LIBRARY})
 elseif(WIN32)

examples/menu_example/CMakeLists.txt

@@ -13,7 +13,9 @@ add_executable(menu_example main.cpp)
 target_link_libraries(menu_example nativeapi)
 
 # Platform-specific settings
-if(APPLE)
+if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    # iOS uses UIKit, Foundation, CoreGraphics (already linked by nativeapi)
+elseif(APPLE)
     find_library(COCOA_LIBRARY Cocoa)
     target_link_libraries(menu_example ${COCOA_LIBRARY})
 elseif(WIN32)

src/CMakeLists.txt

@@ -30,6 +30,8 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     pkg_check_modules(X11 REQUIRED IMPORTED_TARGET x11)
     pkg_check_modules(XI REQUIRED IMPORTED_TARGET xi)
     pkg_check_modules(AYATANA_APPINDICATOR REQUIRED IMPORTED_TARGET ayatana-appindicator3-0.1)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    file(GLOB PLATFORM_SOURCES "platform/ios/*.mm")
 elseif(APPLE)
     file(GLOB PLATFORM_SOURCES "platform/macos/*.mm")
 elseif(WIN32)
@@ -63,7 +65,10 @@ if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
 endif ()
 
 # Link required frameworks and libraries
-if(APPLE)
+if(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+    target_link_libraries(nativeapi PUBLIC "-framework UIKit" "-framework Foundation" "-framework CoreGraphics")
+    target_compile_options(nativeapi PRIVATE "-x" "objective-c++")
+elseif(APPLE)
     target_link_libraries(nativeapi PUBLIC "-framework Cocoa")
     target_compile_options(nativeapi PRIVATE "-x" "objective-c++")
 elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux")

src/platform/ios/accessibility_manager_ios.mm

@@ -0,0 +1,19 @@
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+#include "../../accessibility_manager.h"
+
+namespace nativeapi {
+
+void AccessibilityManager::Enable() {
+  // On iOS, accessibility features are controlled by system settings
+  // This method sets the internal flag
+  enabled_ = true;
+}
+
+bool AccessibilityManager::IsEnabled() {
+  // Return the internal enabled state
+  return enabled_;
+}
+
+}  // namespace nativeapi
+

src/platform/ios/application_ios.mm

@@ -0,0 +1,65 @@
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+#include <string>
+#include "../../application.h"
+
+namespace nativeapi {
+
+class Application::Impl {
+ public:
+  Impl() {}
+};
+
+Application::Application() : pimpl_(std::make_unique<Impl>()) {}
+Application::~Application() {}
+
+int Application::Run() {
+  // On iOS, application lifecycle is managed by UIApplication
+  // This is typically handled in the AppDelegate
+  return 0;
+}
+
+int Application::Run(std::shared_ptr<Window> window) {
+  // iOS manages app lifecycle through UIApplication
+  return 0;
+}
+
+void Application::Quit(int exit_code) {
+  // On iOS, apps don't exit programmatically
+  // The system manages app lifecycle
+}
+
+bool Application::IsRunning() const {
+  UIApplication* app = [UIApplication sharedApplication];
+  return app != nil;
+}
+
+bool Application::IsSingleInstance() const {
+  return true;  // iOS apps are always single instance
+}
+
+bool Application::SetIcon(const std::string& icon_path) {
+  // iOS app icons are set in Info.plist
+  return false;
+}
+
+bool Application::SetDockIconVisible(bool visible) {
+  // Not applicable to iOS
+  return false;
+}
+
+bool Application::SetMenuBar(std::shared_ptr<Menu> menu) {
+  // iOS doesn't have a menu bar
+  return false;
+}
+
+std::shared_ptr<Window> Application::GetPrimaryWindow() const {
+  return nullptr;
+}
+
+void Application::SetPrimaryWindow(std::shared_ptr<Window> window) {
+  // iOS manages primary window through UIApplication
+}
+
+}  // namespace nativeapi
+

src/platform/ios/display_ios.mm

@@ -0,0 +1,132 @@
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+#include <string>
+#include "../../display.h"
+
+namespace nativeapi {
+
+// Private implementation class
+class Display::Impl {
+ public:
+  Impl(UIScreen* screen) : ui_screen_(screen) {}
+  UIScreen* ui_screen_;
+};
+
+Display::Display() : pimpl_(std::make_unique<Impl>([UIScreen mainScreen])) {}
+
+Display::Display(void* display) : pimpl_(std::make_unique<Impl>((__bridge UIScreen*)display)) {}
+
+Display::Display(const Display& other) : pimpl_(std::make_unique<Impl>(other.pimpl_->ui_screen_)) {}
+
+Display& Display::operator=(const Display& other) {
+  if (this != &other) {
+    pimpl_->ui_screen_ = other.pimpl_->ui_screen_;
+  }
+  return *this;
+}
+
+Display::Display(Display&& other) noexcept : pimpl_(std::move(other.pimpl_)) {}
+
+Display& Display::operator=(Display&& other) noexcept {
+  if (this != &other) {
+    pimpl_ = std::move(other.pimpl_);
+  }
+  return *this;
+}
+
+Display::~Display() {}
+
+std::string Display::GetId() const {
+  if (!pimpl_->ui_screen_) {
+    return "";
+  }
+  
+  // Use the screen's bounds as a unique identifier
+  CGRect bounds = pimpl_->ui_screen_.bounds;
+  return std::to_string((int)bounds.origin.x) + "_" + std::to_string((int)bounds.origin.y);
+}
+
+std::string Display::GetName() const {
+  if (!pimpl_->ui_screen_) {
+    return "Unknown";
+  }
+  
+  // iOS doesn't provide a friendly name for screens
+  // Use scale factor and size to differentiate
+  CGFloat scale = pimpl_->ui_screen_.scale;
+  CGRect bounds = pimpl_->ui_screen_.bounds;
+  
+  return std::string("Screen ") + std::to_string((int)bounds.size.width) + "x" + 
+         std::to_string((int)bounds.size.height) + "@" + std::to_string((int)scale) + "x";
+}
+
+Point Display::GetPosition() const {
+  if (!pimpl_->ui_screen_) {
+    return Point{0, 0};
+  }
+  
+  CGRect bounds = pimpl_->ui_screen_.bounds;
+  return Point{static_cast<double>(bounds.origin.x), static_cast<double>(bounds.origin.y)};
+}
+
+Size Display::GetSize() const {
+  if (!pimpl_->ui_screen_) {
+    return Size{0, 0};
+  }
+  
+  CGRect bounds = pimpl_->ui_screen_.bounds;
+  return Size{static_cast<double>(bounds.size.width), static_cast<double>(bounds.size.height)};
+}
+
+Rectangle Display::GetWorkArea() const {
+  if (!pimpl_->ui_screen_) {
+    return Rectangle{0, 0, 0, 0};
+  }
+  
+  CGRect bounds = pimpl_->ui_screen_.bounds;
+  return Rectangle{static_cast<double>(bounds.origin.x), static_cast<double>(bounds.origin.y),
+                   static_cast<double>(bounds.size.width), static_cast<double>(bounds.size.height)};
+}
+
+double Display::GetScaleFactor() const {
+  return pimpl_->ui_screen_ ? static_cast<double>(pimpl_->ui_screen_.scale) : 1.0;
+}
+
+bool Display::IsPrimary() const {
+  return pimpl_->ui_screen_ == [UIScreen mainScreen];
+}
+
+DisplayOrientation Display::GetOrientation() const {
+  if (!pimpl_->ui_screen_) {
+    return DisplayOrientation::kPortrait;
+  }
+  
+  // Check orientation based on screen bounds
+  CGRect bounds = pimpl_->ui_screen_.bounds;
+  if (bounds.size.width > bounds.size.height) {
+    return DisplayOrientation::kLandscape;
+  } else {
+    return DisplayOrientation::kPortrait;
+  }
+}
+
+int Display::GetRefreshRate() const {
+  if (!pimpl_->ui_screen_) {
+    return 60;
+  }
+  
+  // iOS doesn't expose refresh rate directly, return standard 60Hz
+  return 60;
+}
+
+int Display::GetBitDepth() const {
+  // iOS devices typically use 32-bit color depth
+  return 32;
+}
+
+void* Display::GetNativeObjectInternal() const {
+  return (__bridge void*)pimpl_->ui_screen_;
+}
+
+}  // namespace nativeapi
+

src/platform/ios/display_manager_ios.mm

@@ -0,0 +1,46 @@
+#import <UIKit/UIKit.h>
+#import <Foundation/Foundation.h>
+#include "../../display_manager.h"
+#include "../../window.h"
+
+namespace nativeapi {
+
+DisplayManager::DisplayManager() {
+  // Constructor initialization
+}
+
+DisplayManager::~DisplayManager() {}
+
+std::vector<Display> DisplayManager::GetAll() {
+  std::vector<Display> displays;
+  
+  // Get all screens
+  NSArray<UIScreen*>* screens = [UIScreen screens];
+  for (UIScreen* screen in screens) {
+    displays.push_back(Display((__bridge void*)screen));
+  }
+  
+  // If no screens found, add main screen
+  if (displays.empty()) {
+    UIScreen* mainScreen = [UIScreen mainScreen];
+    if (mainScreen) {
+      displays.push_back(Display((__bridge void*)mainScreen));
+    }
+  }
+  
+  return displays;
+}
+
+Display DisplayManager::GetPrimary() {
+  // Get main screen
+  UIScreen* mainScreen = [UIScreen mainScreen];
+  return Display((__bridge void*)mainScreen);
+}
+
+Point DisplayManager::GetCursorPosition() {
+  // iOS doesn't have a cursor position concept
+  return Point{0, 0};
+}
+
+}  // namespace nativeapi
+