tests/common/rive_ios_app.mm

/*
 * Copyright 2026 Rive
 */

#if defined(RIVE_IOS) || defined(RIVE_IOS_SIMULATOR)

#include "common/rive_ios_app.hpp"

#import <QuartzCore/CAMetalLayer.h>
#import <UIKit/UIKit.h>

#include <atomic>
#include <condition_variable>
#include <mutex>
#include <queue>

static std::mutex s_windowMutex;
static std::condition_variable s_windowReady;
static CAMetalLayer* s_metalLayer = nil;

static std::mutex s_inputMutex;
static std::queue<TestingWindow::InputEventData> s_inputEvents;

static std::mutex s_lifecycleMutex;
static std::condition_variable s_lifecycleChanged;
static bool s_active = true;
static std::atomic<bool> s_shouldQuit{false};

static void push_touch_event(
    UIView* view, UITouch* touch, TestingWindow::InputEvent eventType)
{
  if (touch == nil)
  {
    return;
  }
  CGPoint location = [touch locationInView:view];
  CGFloat scale = view.contentScaleFactor;
  std::lock_guard<std::mutex> lock(s_inputMutex);
  s_inputEvents.push(TestingWindow::InputEventData(
      eventType,
      static_cast<float>(location.x * scale),
      static_cast<float>(location.y * scale)));
}

static void set_active(bool active)
{
  std::lock_guard<std::mutex> lock(s_lifecycleMutex);
  s_active = active;
  s_lifecycleChanged.notify_all();
}

@interface RiveMetalView : UIView
@end

@implementation RiveMetalView

+ (Class)layerClass
{
  return [CAMetalLayer class];
}

- (void)touchesBegan:(NSSet<UITouch*>*)touches withEvent:(UIEvent*)event
{
  push_touch_event(
      self, touches.anyObject, TestingWindow::InputEvent::MouseMove);
  push_touch_event(
      self, touches.anyObject, TestingWindow::InputEvent::MouseDown);
}

- (void)touchesMoved:(NSSet<UITouch*>*)touches withEvent:(UIEvent*)event
{
  push_touch_event(
      self, touches.anyObject, TestingWindow::InputEvent::MouseMove);
}

- (void)touchesEnded:(NSSet<UITouch*>*)touches withEvent:(UIEvent*)event
{
  push_touch_event(self, touches.anyObject, TestingWindow::InputEvent::MouseUp);
}

- (void)touchesCancelled:(NSSet<UITouch*>*)touches withEvent:(UIEvent*)event
{
  push_touch_event(self, touches.anyObject, TestingWindow::InputEvent::MouseUp);
}

@end

@interface GameViewController : UIViewController
@end

@implementation GameViewController

- (void)loadView
{
  self.view = [[RiveMetalView alloc] initWithFrame:UIScreen.mainScreen.bounds];
  self.view.autoresizingMask = UIViewAutoresizingFlexibleWidth |
                               UIViewAutoresizingFlexibleHeight;
}

- (void)viewDidLayoutSubviews
{
  [super viewDidLayoutSubviews];

  if (![self.view.layer isKindOfClass:[CAMetalLayer class]])
  {
    return;
  }

  UIScreen* screen = self.view.window.screen ?: UIScreen.mainScreen;
  CGFloat scale = screen.scale;
  self.view.contentScaleFactor = scale;

  CAMetalLayer* layer = (CAMetalLayer*)self.view.layer;
  CGSize bounds = self.view.bounds.size;
  layer.contentsScale = scale;
  layer.drawableSize = CGSizeMake(bounds.width * scale, bounds.height * scale);

  std::lock_guard<std::mutex> lock(s_windowMutex);
  if (s_metalLayer == nil)
  {
    s_metalLayer = layer;
    s_windowReady.notify_all();
  }
}

@end

@interface RiveAppDelegate : UIResponder <UIApplicationDelegate>
@property(strong, nonatomic) UIWindow* window;
@end

@implementation RiveAppDelegate

- (BOOL)application:(UIApplication*)application
    didFinishLaunchingWithOptions:(NSDictionary*)launchOptions
{
  self.window = [[UIWindow alloc] initWithFrame:UIScreen.mainScreen.bounds];
  self.window.rootViewController = [[GameViewController alloc] init];
  [self.window makeKeyAndVisible];
  return YES;
}

- (void)applicationDidBecomeActive:(UIApplication*)application
{
  set_active(true);
}

- (void)applicationWillResignActive:(UIApplication*)application
{
  set_active(false);
}

- (void)applicationWillTerminate:(UIApplication*)application
{
  s_shouldQuit = true;
  set_active(true);
}

@end

void* rive_ios_app_wait_for_window()
{
  std::unique_lock<std::mutex> lock(s_windowMutex);
  s_windowReady.wait(lock, [] { return s_metalLayer != nil; });
  return (__bridge void*)s_metalLayer;
}

bool rive_ios_app_poll_input_event(TestingWindow::InputEventData& eventData)
{
  std::lock_guard<std::mutex> lock(s_inputMutex);
  if (s_inputEvents.empty())
  {
    return false;
  }
  eventData = s_inputEvents.front();
  s_inputEvents.pop();
  return true;
}

bool rive_ios_app_should_quit() { return s_shouldQuit; }

void rive_ios_app_wait_while_inactive()
{
  std::unique_lock<std::mutex> lock(s_lifecycleMutex);
  s_lifecycleChanged.wait(lock, [] { return s_active || s_shouldQuit; });
}

#endif