fix bounds

Author: tornikegomareli

simtouch.zig

@@ -0,0 +1,233 @@
+const std = @import("std");
+const c = @cImport({
+    @cInclude("CoreGraphics/CoreGraphics.h");
+    @cInclude("ApplicationServices/ApplicationServices.h");
+});
+
+const SimulatorBounds = struct {
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
+};
+
+fn findSimulatorWindow() !SimulatorBounds {
+    const window_list = c.CGWindowListCopyWindowInfo(
+        c.kCGWindowListOptionOnScreenOnly | c.kCGWindowListExcludeDesktopElements,
+        c.kCGNullWindowID,
+    );
+    defer c.CFRelease(window_list);
+
+    const count = c.CFArrayGetCount(window_list);
+    var i: usize = 0;
+
+    while (i < count) : (i += 1) {
+        const window = c.CFArrayGetValueAtIndex(window_list, @intCast(i));
+        const window_dict = @as(c.CFDictionaryRef, @ptrCast(window));
+
+        const owner_key = c.kCGWindowOwnerName;
+        const owner_value = c.CFDictionaryGetValue(window_dict, owner_key);
+        if (owner_value == null) continue;
+
+        const owner_str = @as(c.CFStringRef, @ptrCast(owner_value));
+        var buffer: [256]u8 = undefined;
+
+        if (c.CFStringGetCString(owner_str, &buffer, buffer.len, c.kCFStringEncodingUTF8) == 0) {
+            continue;
+        }
+
+        const owner_name = std.mem.sliceTo(&buffer, 0);
+
+        if (std.mem.indexOf(u8, owner_name, "Simulator") != null) {
+            const bounds_key = c.kCGWindowBounds;
+            const bounds_value = c.CFDictionaryGetValue(window_dict, bounds_key);
+            if (bounds_value == null) continue;
+
+            const bounds_dict = @as(c.CFDictionaryRef, @ptrCast(bounds_value));
+
+            const x_key = c.CFStringCreateWithCString(null, "X", c.kCFStringEncodingUTF8);
+            defer c.CFRelease(x_key);
+            const x_value = c.CFDictionaryGetValue(bounds_dict, x_key);
+
+            const y_key = c.CFStringCreateWithCString(null, "Y", c.kCFStringEncodingUTF8);
+            defer c.CFRelease(y_key);
+            const y_value = c.CFDictionaryGetValue(bounds_dict, y_key);
+
+            const width_key = c.CFStringCreateWithCString(null, "Width", c.kCFStringEncodingUTF8);
+            defer c.CFRelease(width_key);
+            const width_value = c.CFDictionaryGetValue(bounds_dict, width_key);
+
+            const height_key = c.CFStringCreateWithCString(null, "Height", c.kCFStringEncodingUTF8);
+            defer c.CFRelease(height_key);
+            const height_value = c.CFDictionaryGetValue(bounds_dict, height_key);
+
+            var x: f64 = 0;
+            var y: f64 = 0;
+            var width: f64 = 0;
+            var height: f64 = 0;
+
+            _ = c.CFNumberGetValue(@as(c.CFNumberRef, @ptrCast(x_value)), c.kCFNumberFloat64Type, &x);
+            _ = c.CFNumberGetValue(@as(c.CFNumberRef, @ptrCast(y_value)), c.kCFNumberFloat64Type, &y);
+            _ = c.CFNumberGetValue(@as(c.CFNumberRef, @ptrCast(width_value)), c.kCFNumberFloat64Type, &width);
+            _ = c.CFNumberGetValue(@as(c.CFNumberRef, @ptrCast(height_value)), c.kCFNumberFloat64Type, &height);
+
+            std.debug.print("Found Simulator at ({d:.0}, {d:.0}) size: {d:.0}x{d:.0}\n", .{ x, y, width, height });
+
+            return SimulatorBounds{
+                .x = @floatCast(x),
+                .y = @floatCast(y),
+                .width = @floatCast(width),
+                .height = @floatCast(height),
+            };
+        }
+    }
+
+    return error.SimulatorNotFound;
+}
+
+fn sendMouseEvent(x: f32, y: f32, event_type: c.CGEventType, button: c.CGMouseButton) void {
+    const point = c.CGPointMake(x, y);
+    const event = c.CGEventCreateMouseEvent(null, event_type, point, button);
+    if (event != null) {
+        c.CGEventPost(c.kCGHIDEventTap, event);
+        c.CFRelease(event);
+    }
+}
+
+fn sendTap(x: f32, y: f32) !void {
+    const bounds = try findSimulatorWindow();
+
+    const absolute_x = bounds.x + x;
+    const absolute_y = bounds.y + y;
+
+    std.debug.print("Sending tap at ({d:.1}, {d:.1})\n", .{ x, y });
+
+    sendMouseEvent(absolute_x, absolute_y, c.kCGEventMouseMoved, c.kCGMouseButtonLeft);
+    std.time.sleep(10_000_000); // 10ms
+
+    sendMouseEvent(absolute_x, absolute_y, c.kCGEventLeftMouseDown, c.kCGMouseButtonLeft);
+    std.time.sleep(50_000_000); // 50ms
+
+    sendMouseEvent(absolute_x, absolute_y, c.kCGEventLeftMouseUp, c.kCGMouseButtonLeft);
+}
+
+fn sendSwipe(x1: f32, y1: f32, x2: f32, y2: f32, steps: u32) !void {
+    const bounds = try findSimulatorWindow();
+
+    const absolute_x1 = bounds.x + x1;
+    const absolute_y1 = bounds.y + y1;
+    const absolute_x2 = bounds.x + x2;
+    const absolute_y2 = bounds.y + y2;
+
+    std.debug.print("Sending swipe from ({d:.1}, {d:.1}) to ({d:.1}, {d:.1})\n", .{ x1, y1, x2, y2 });
+
+    const dx = (absolute_x2 - absolute_x1) / @as(f32, @floatFromInt(steps));
+    const dy = (absolute_y2 - absolute_y1) / @as(f32, @floatFromInt(steps));
+
+    // Move to start
+    sendMouseEvent(absolute_x1, absolute_y1, c.kCGEventMouseMoved, c.kCGMouseButtonLeft);
+    std.time.sleep(20_000_000); // 20ms
+
+    // Mouse down
+    sendMouseEvent(absolute_x1, absolute_y1, c.kCGEventLeftMouseDown, c.kCGMouseButtonLeft);
+    std.time.sleep(20_000_000); // 20ms
+
+    // Drag through points
+    var i: u32 = 1;
+    while (i <= steps) : (i += 1) {
+        const x = absolute_x1 + (dx * @as(f32, @floatFromInt(i)));
+        const y = absolute_y1 + (dy * @as(f32, @floatFromInt(i)));
+        sendMouseEvent(x, y, c.kCGEventLeftMouseDragged, c.kCGMouseButtonLeft);
+        std.time.sleep(10_000_000); // 10ms
+    }
+
+    // Mouse up
+    sendMouseEvent(absolute_x2, absolute_y2, c.kCGEventLeftMouseUp, c.kCGMouseButtonLeft);
+}
+
+fn sendLongPress(x: f32, y: f32, duration_ms: u32) !void {
+    const bounds = try findSimulatorWindow();
+
+    const absolute_x = bounds.x + x;
+    const absolute_y = bounds.y + y;
+
+    std.debug.print("Sending long press at ({d:.1}, {d:.1}) for {d}ms\n", .{ x, y, duration_ms });
+
+    sendMouseEvent(absolute_x, absolute_y, c.kCGEventMouseMoved, c.kCGMouseButtonLeft);
+    std.time.sleep(10_000_000); // 10ms
+
+    sendMouseEvent(absolute_x, absolute_y, c.kCGEventLeftMouseDown, c.kCGMouseButtonLeft);
+
+    std.time.sleep(duration_ms * 1_000_000);
+
+    sendMouseEvent(absolute_x, absolute_y, c.kCGEventLeftMouseUp, c.kCGMouseButtonLeft);
+}
+
+fn printUsage(program_name: []const u8) void {
+    std.debug.print(
+        \\iOS Simulator Touch Injector (Zig Version)
+        \\Usage:
+        \\  {s} tap <x> <y>                    - Send a tap at coordinates
+        \\  {s} swipe <x1> <y1> <x2> <y2>      - Send a swipe gesture
+        \\  {s} longpress <x> <y> <duration>   - Send a long press (duration in ms)
+        \\
+        \\Examples:
+        \\  {s} tap 200 300
+        \\  {s} swipe 100 500 100 100
+        \\  {s} longpress 200 200 2000
+        \\
+    , .{ program_name, program_name, program_name, program_name, program_name, program_name });
+}
+
+pub fn main() !void {
+    const allocator = std.heap.page_allocator;
+    const args = try std.process.argsAlloc(allocator);
+    defer std.process.argsFree(allocator, args);
+
+    if (args.len < 2) {
+        printUsage(args[0]);
+        return;
+    }
+
+    const command = args[1];
+
+    if (std.mem.eql(u8, command, "tap")) {
+        if (args.len != 4) {
+            std.debug.print("Error: tap requires x and y coordinates\n", .{});
+            printUsage(args[0]);
+            return;
+        }
+
+        const x = try std.fmt.parseFloat(f32, args[2]);
+        const y = try std.fmt.parseFloat(f32, args[3]);
+        try sendTap(x, y);
+    } else if (std.mem.eql(u8, command, "swipe")) {
+        if (args.len != 6) {
+            std.debug.print("Error: swipe requires x1, y1, x2, y2 coordinates\n", .{});
+            printUsage(args[0]);
+            return;
+        }
+
+        const x1 = try std.fmt.parseFloat(f32, args[2]);
+        const y1 = try std.fmt.parseFloat(f32, args[3]);
+        const x2 = try std.fmt.parseFloat(f32, args[4]);
+        const y2 = try std.fmt.parseFloat(f32, args[5]);
+        try sendSwipe(x1, y1, x2, y2, 20);
+    } else if (std.mem.eql(u8, command, "longpress")) {
+        if (args.len != 5) {
+            std.debug.print("Error: longpress requires x, y coordinates and duration\n", .{});
+            printUsage(args[0]);
+            return;
+        }
+
+        const x = try std.fmt.parseFloat(f32, args[2]);
+        const y = try std.fmt.parseFloat(f32, args[3]);
+        const duration = try std.fmt.parseInt(u32, args[4], 10);
+        try sendLongPress(x, y, duration);
+    } else {
+        std.debug.print("Unknown command: {s}\n", .{command});
+        printUsage(args[0]);
+    }
+
+    std.debug.print("Touch event sent successfully\n", .{});
+}