minivmac4ios/Mini vMac/ViewController.m

//
//  ViewController.m
//  Mini vMac
//
//  Created by Jesús A. Álvarez on 27/04/2016.
//  Copyright © 2016-2018 namedfork. All rights reserved.
//

#import "ViewController.h"
#import "TouchScreen.h"
#import "TrackPad.h"
#import "AppDelegate.h"
#import "KBKeyboardView.h"
#import "KBKeyboardLayout.h"

@interface ViewController () <UIAdaptivePresentationControllerDelegate, UIPointerInteractionDelegate>

@end

static int8_t usb_to_adb_scancode[] = {
    -1, -1, -1, -1, 0, 11, 8, 2, 14, 3, 5, 4, 34, 38, 40, 37,
    46, 45, 31, 35, 12, 15, 1, 17, 32, 9, 13, 7, 16, 6, 18, 19,
    20, 21, 23, 22, 26, 28, 25, 29, 36, 53, 51, 48, 49, 27, 24, 33,
    30, 42, 42, 41, 39, 10, 43, 47, 44, 57, 122, 120, 99, 118, 96, 97,
    98, 100, 101, 109, 103, 111, 105, 107, 113, 114, 115, 116, 117, 119, 121, 60,
    59, 61, 62, 71, 75, 67, 78, 69, 76, 83, 84, 85, 86, 87, 88, 89,
    91, 92, 82, 65, 50, 55, 126, 81, 105, 107, 113, 106, 64, 79, 80, 90,
    -1, -1, -1, -1, -1, 114, -1, -1, -1, -1, -1, -1, -1, -1, -1, 74,
    72, 73, -1, -1, -1, 95, -1, 94, -1, 93, -1, -1, -1, -1, -1, -1,
    104, 102, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    54, 56, 58, 55, 54, 56, 58, 55, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};

@implementation ViewController
{
    KBKeyboardView *keyboardView;
    UISwipeGestureRecognizer *showKeyboardGesture, *hideKeyboardGesture, *insertDiskGesture, *showSettingsGesture;
    UIControl *pointingDeviceView;
    UIViewController *_keyboardViewController;
    BOOL physicalCapsLocked;
    UIPointerInteraction *pointerInteraction;
}

- (void)viewDidLoad {
    [super viewDidLoad];

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(emulatorDidShutDown:) name:[AppDelegate sharedEmulator].shutdownNotification object:nil];
    
#if defined(TARGET_OS_VISION) && TARGET_OS_VISION == 1
    [self initXr];
#else
    [self scheduleHelpPresentationIfNeededAfterDelay:6.0];
    [self installGestures];
#endif
}

#if defined(TARGET_OS_VISION) && TARGET_OS_VISION == 1
- (UIViewController *)keyboardViewController {
    if (keyboardView == nil) {
        [[NSUserDefaults standardUserDefaults] addObserver:self forKeyPath:@"keyboardLayout" options:0 context:NULL];
        KBKeyboardLayout *layout = [self keyboardLayout];
        CGSize keyboardSize = CGSizeZero;
        for (NSValue *size in layout.availableSizes) {
            if (size.CGSizeValue.width > keyboardSize.width) {
                keyboardSize = size.CGSizeValue;
            }
        }
        keyboardView = [[KBKeyboardView alloc] initWithFrame:CGRectMake(0, 0, keyboardSize.width, keyboardSize.height)];
        keyboardView.layoutMenu = [self keyboardLayoutMenu];
        keyboardView.layout = layout;
        keyboardView.delegate = self;
    }
    if (_keyboardViewController == nil) {
        _keyboardViewController = [UIViewController alloc];
        _keyboardViewController.view = keyboardView;
        _keyboardViewController.preferredContentSize = keyboardView.frame.size;
    } else if (_keyboardViewController.view != keyboardView) {
        _keyboardViewController.view = keyboardView;
    }
    return _keyboardViewController;
}
#endif

- (void)installGestures {
    [self installKeyboardGestures];
    insertDiskGesture = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(showInsertDisk:)];
    insertDiskGesture.direction = UISwipeGestureRecognizerDirectionLeft;
    insertDiskGesture.numberOfTouchesRequired = 2;
    [self.view addGestureRecognizer:insertDiskGesture];

    showSettingsGesture = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(showSettings:)];
    showSettingsGesture.direction = UISwipeGestureRecognizerDirectionRight;
    showSettingsGesture.numberOfTouchesRequired = 2;
    [self.view addGestureRecognizer:showSettingsGesture];

}

- (void)showSettings:(id)sender {
    [self performSegueWithIdentifier:@"settings" sender:sender];
}

- (void)showInsertDisk:(id)sender {
    [self performSegueWithIdentifier:@"disk" sender:sender];
}

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    [self cancelHelpPresentation];
    if ([@[@"disk", @"settings"] containsObject:segue.identifier]) {
        segue.destinationViewController.presentationController.delegate = self;
        if (self.presentedViewController != nil) {
            [self dismissViewControllerAnimated:YES completion:nil];
        }
    }
#if defined(TARGET_OS_VISION) && TARGET_OS_VISION == 1
    if ([segue.identifier isEqualToString:@"disk"]) {
        [(UINavigationController*)segue.destinationViewController setToolbarHidden:YES];
    }
#endif
}

- (void)presentationControllerDidDismiss:(UIPresentationController *)presentationController {
    // hack to fix the presenting view controller not returning back to normal size on iOS 13
    // when the sheet is dismissed interactively (ie dragging it down) after a contextual menu
    // has been shown, which breaks some autolayout constraints. when this happens, the
    // presenting view controller won't resize back to normal during the interactive
    // dismissing of the presented sheet
    if (@available(iOS 14, *)) {
        // it works correctly on iOS 14
    } else {
        self.view.superview.transform = CGAffineTransformIdentity;
    }
}

#if !defined(TARGET_OS_VISION) || TARGET_OS_VISION == 0
- (BOOL)prefersStatusBarHidden {
    UIScreen *screen = self.view.window.screen;
    return CGRectEqualToRect(screen.bounds, self.view.window.bounds);
}

- (UIStatusBarStyle)preferredStatusBarStyle {
    return UIStatusBarStyleLightContent;
}
#endif

- (UIRectEdge)preferredScreenEdgesDeferringSystemGestures {
    return UIRectEdgeAll;
}

- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:animated];
    [self setUpPointingDevice];
    [[NSUserDefaults standardUserDefaults] addObserver:self forKeyPath:@"trackpad" options:0 context:NULL];
}

- (void)viewDidDisappear:(BOOL)animated {
    [[NSUserDefaults standardUserDefaults] removeObserver:self forKeyPath:@"trackpad"];
}

- (BOOL)prefersHomeIndicatorAutoHidden {
    return YES;
}

- (void)motionEnded:(UIEventSubtype)motion withEvent:(UIEvent *)event {
    if (motion == UIEventSubtypeMotionShake) {
        [[AppDelegate sharedInstance] showInsertDisk:self];
    }
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSString *,id> *)change context:(void *)context {
    if (object == [NSUserDefaults standardUserDefaults]) {
        if ([keyPath isEqualToString:@"keyboardLayout"] && keyboardView != nil) {
#if defined(TARGET_OS_VISION) && TARGET_OS_VISION == 1
            // FIXME: do this nicelier
            keyboardView = nil;
            [self keyboardViewController];
#else
            BOOL keyboardWasVisible = self.keyboardVisible;
            [self setKeyboardVisible:NO animated:NO];
            [keyboardView removeFromSuperview];
            keyboardView = nil;
            if (keyboardWasVisible) {
                [self setKeyboardVisible:YES animated:NO];
            }
#endif
        } else if ([keyPath isEqualToString:@"trackpad"]) {
            [self setUpPointingDevice];
        }
    }
}

- (void)viewWillTransitionToSize:(CGSize)size withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
    [super viewWillTransitionToSize:size withTransitionCoordinator:coordinator];
    if (self.keyboardVisible) {
        // willTransitionToTraitCollection... is caled before us, so keyboard will already be hidden here in a trait collection transition
        [self setKeyboardVisible:NO animated:NO];
        [coordinator animateAlongsideTransition:nil completion:^(id<UIViewControllerTransitionCoordinatorContext>  _Nonnull context) {
            [self setKeyboardVisible:YES animated:YES];
        }];
    }
}

- (void)willTransitionToTraitCollection:(UITraitCollection *)newCollection withTransitionCoordinator:(id<UIViewControllerTransitionCoordinator>)coordinator {
    [super willTransitionToTraitCollection:newCollection withTransitionCoordinator:coordinator];
    if (self.keyboardVisible) {
        [self setKeyboardVisible:NO animated:NO];
        [coordinator animateAlongsideTransition:nil completion:^(id<UIViewControllerTransitionCoordinatorContext>  _Nonnull context) {
            [self setKeyboardVisible:YES animated:YES];
        }];
    }
}

- (void)emulatorDidShutDown:(NSNotification*)notification {
    if (notification.object == [AppDelegate sharedEmulator]) {
        UILabel *shutdownLabel = [[UILabel alloc] initWithFrame:self.view.bounds];
        shutdownLabel.text = NSLocalizedString(@"the emulated Mac has shut down\ntap to restart", nil);
        shutdownLabel.textColor = [UIColor whiteColor];
        [self.view addSubview:shutdownLabel];
        shutdownLabel.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
        [shutdownLabel addGestureRecognizer:[[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(restartEmulator:)]];
        shutdownLabel.numberOfLines = -1;
        shutdownLabel.textAlignment = NSTextAlignmentCenter;
        shutdownLabel.userInteractionEnabled = YES;
        [UIView animateWithDuration:0.5 animations:^{
            self.screenView.alpha = 0.5;
        }];
        [self hideKeyboard:notification];
    }
}

- (void)restartEmulator:(UITapGestureRecognizer*)gestureRecognizer {
    if (gestureRecognizer.state == UIGestureRecognizerStateRecognized) {
        [UIView animateWithDuration:0.5 animations:^{
            self.screenView.alpha = 1.0;
        }];
        [gestureRecognizer.view removeFromSuperview];
        id emulator = [AppDelegate sharedEmulator];
        [emulator performSelector:@selector(run) withObject:nil afterDelay:0.1];
    }
}

#pragma mark - Gesture Help

- (void)showGestureHelp:(id)sender {
#if !defined(TARGET_OS_VISION) || TARGET_OS_VISION == 0
    [self setGestureHelpHidden:NO];
#endif
}

- (void)hideGestureHelp:(id)sender {
    [self setGestureHelpHidden:YES];
}

- (void)setGestureHelpHidden:(BOOL)hidden {
    if (self.helpView.hidden == hidden) {
        return;
    } else if (!hidden) {
        // prepare to show
        self.helpView.alpha = 0.0;
        self.helpView.hidden = NO;
    }
    [UIView animateWithDuration:0.2
                     animations:^{
        self.helpView.alpha = hidden ? 0.0 : 1.0;
    }
                     completion:^(BOOL finished) {
        self.helpView.hidden = hidden;
    }];
}

- (void)showGestureHelpIfNeeded:(id)sender {
    // show help if no disks have been inserted
    if (![AppDelegate sharedEmulator].anyDiskInserted) {
        [self showGestureHelp:sender];
    }
}

- (void)scheduleHelpPresentationIfNeededAfterDelay:(NSTimeInterval)delay {
    if ([[NSUserDefaults standardUserDefaults] boolForKey:@"autoShowGestureHelp"]) {
        [self performSelector:@selector(showGestureHelpIfNeeded:) withObject:self afterDelay:delay];
    }
}

- (void)cancelHelpPresentation {
    [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(showGestureHelpIfNeeded:) object:self];
}

#pragma mark - Keyboard

- (void)installKeyboardGestures {
    showKeyboardGesture = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(showKeyboard:)];
    showKeyboardGesture.direction = UISwipeGestureRecognizerDirectionUp;
    showKeyboardGesture.numberOfTouchesRequired = 2;
    [self.view addGestureRecognizer:showKeyboardGesture];
    
    hideKeyboardGesture = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(hideKeyboard:)];
    hideKeyboardGesture.direction = UISwipeGestureRecognizerDirectionDown;
    hideKeyboardGesture.numberOfTouchesRequired = 2;
    [self.view addGestureRecognizer:hideKeyboardGesture];
}

- (BOOL)isKeyboardVisible {
#if defined(TARGET_OS_VISION) && TARGET_OS_VISION == 1
    return _keyboardViewController.view.window != nil;
#else
    return keyboardView != nil && CGRectIntersectsRect(keyboardView.frame, self.view.bounds) && !keyboardView.hidden;
#endif
}

- (void)setKeyboardVisible:(BOOL)keyboardVisible {
    [self setKeyboardVisible:keyboardVisible animated:YES];
}

- (void)showKeyboard:(id)sender {
    [self setKeyboardVisible:YES animated:YES];
}

- (void)hideKeyboard:(id)sender {
    [self setKeyboardVisible:NO animated:YES];
}

- (void)setKeyboardVisible:(BOOL)visible animated:(BOOL)animated {
#if defined(TARGET_OS_VISION) && TARGET_OS_VISION == 1
    if (visible) {
        UISceneSessionActivationRequest *request = [UISceneSessionActivationRequest requestWithRole:UIWindowSceneSessionRoleApplication];
        request.userActivity = [[NSUserActivity alloc] initWithActivityType:@"net.namedfork.keyboard"];
        request.userActivity.targetContentIdentifier = @"net.namedfork.keyboard";
        [[UIApplication sharedApplication] activateSceneSessionForRequest:request errorHandler:^(NSError * _Nonnull error) {
            NSLog(@"Activation error: %@", error);
        }];
    } else {
        UIScene *keyboardScene = [[AppDelegate sharedInstance] sceneWithName:@"Keyboard"];
        if (keyboardScene != nil) {
            [[UIApplication sharedApplication] requestSceneSessionDestruction:keyboardScene.session options:nil errorHandler:nil];
        }
    }
#else
    if (self.keyboardVisible == visible) {
        return;
    }
    if (visible) {
        [[NSUserDefaults standardUserDefaults] addObserver:self forKeyPath:@"keyboardLayout" options:0 context:NULL];
        [self loadKeyboardView];
        if (keyboardView.layout == nil) {
            [keyboardView removeFromSuperview];
            return;
        }
        [self.view addSubview:keyboardView];
        keyboardView.hidden = NO;
        CGRect finalFrame = CGRectMake(0.0, self.view.bounds.size.height - keyboardView.bounds.size.height, keyboardView.bounds.size.width, keyboardView.bounds.size.height);
        if (animated) {
            keyboardView.frame = CGRectOffset(finalFrame, 0.0, finalFrame.size.height);
            [UIView animateWithDuration:0.3 delay:0.0 options:UIViewAnimationOptionCurveEaseOut animations:^{
                self->keyboardView.frame = finalFrame;
            } completion:nil];
        } else {
            keyboardView.frame = finalFrame;
        }
    } else {
        [[NSUserDefaults standardUserDefaults] removeObserver:self forKeyPath:@"keyboardLayout"];
        if (animated) {
            CGRect finalFrame = CGRectMake(0.0, self.view.bounds.size.height, keyboardView.bounds.size.width, keyboardView.bounds.size.height);
            [UIView animateWithDuration:0.3 delay:0.0 options:UIViewAnimationOptionCurveEaseOut animations:^{
                self->keyboardView.frame = finalFrame;
            } completion:^(BOOL finished) {
                if (finished) {
                    self->keyboardView.hidden = YES;
                }
            }];
        } else {
            keyboardView.hidden = YES;
        }
    }
#endif
}

- (void)loadKeyboardView {
    if (keyboardView != nil && keyboardView.bounds.size.width != self.view.bounds.size.width) {
        // keyboard needs resizing
        [keyboardView removeFromSuperview];
        keyboardView = nil;
    }
    
    if (keyboardView == nil) {
        UIEdgeInsets safeAreaInsets = UIEdgeInsetsZero;
        if (@available(iOS 11, *)) {
            safeAreaInsets = self.view.safeAreaInsets;
        }
        keyboardView = [[KBKeyboardView alloc] initWithFrame:self.view.bounds safeAreaInsets:safeAreaInsets];
        keyboardView.layout = [self keyboardLayout];
        keyboardView.delegate = self;
    }
}

- (KBKeyboardLayout*)keyboardLayout {
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    NSString *layoutName = [defaults stringForKey:@"keyboardLayout"];
    NSString *layoutPath = [[[AppDelegate sharedInstance] userKeyboardLayoutsPath] stringByAppendingPathComponent:layoutName];
    if (![[NSFileManager defaultManager] fileExistsAtPath:layoutPath]) {
        layoutPath = [[NSBundle mainBundle] pathForResource:layoutName ofType:nil inDirectory:@"Keyboard Layouts"];
    }
    if (layoutPath == nil) {
        NSLog(@"Layout not found: %@", layoutPath);
    }
    return layoutPath ? [[KBKeyboardLayout alloc] initWithContentsOfFile:layoutPath] : nil;
}

- (void)keyDown:(int)scancode {
    [[AppDelegate sharedEmulator] keyDown:scancode];
}

- (void)keyUp:(int)scancode {
    [[AppDelegate sharedEmulator] keyUp:scancode];
}

- (void)pressesBegan:(NSSet<UIPress *> *)presses withEvent:(UIPressesEvent *)event {
    for (UIPress *press in presses) {
        [self handlePressEvent:press];
    }
}

- (void)pressesChanged:(NSSet<UIPress *> *)presses withEvent:(UIPressesEvent *)event {
    for (UIPress *press in presses) {
        [self handlePressEvent:press];
    }
}

- (void)pressesEnded:(NSSet<UIPress *> *)presses withEvent:(UIPressesEvent *)event {
    for (UIPress *press in presses) {
        [self handlePressEvent:press];
    }
}

- (void)handlePressEvent:(UIPress *)event {
    long keycode = event.key.keyCode;
    int scancode = -1;

    BOOL emulatorIsFrontmost = [AppDelegate sharedEmulator].running && [AppDelegate sharedInstance].window.rootViewController.presentedViewController == nil;
    BOOL isKeyDown = (event.phase == UIPressPhaseBegan);

    if (keycode >= 0 && keycode < sizeof(usb_to_adb_scancode)) {
        scancode = usb_to_adb_scancode[keycode];
    }

    if (scancode == KC_CAPSLOCK) {
        // caps lock
        if (isKeyDown && !physicalCapsLocked) {
            [[AppDelegate sharedEmulator] keyDown:KC_CAPSLOCK];
            physicalCapsLocked = YES;
        } else if (isKeyDown && physicalCapsLocked) {
            [[AppDelegate sharedEmulator] keyUp:KC_CAPSLOCK];
            physicalCapsLocked = NO;
        }
    } else if (scancode >= 0 && emulatorIsFrontmost) {
        [self _updateCapsLockStatus:event];
        if (isKeyDown) {
            [[AppDelegate sharedEmulator] keyDown:scancode];
        } else {
            [[AppDelegate sharedEmulator] keyUp:scancode];
        }
    }
}

- (void)_updateCapsLockStatus:(UIPress *)event {
    BOOL currentCapsLock = (event.key.modifierFlags & UIKeyModifierAlphaShift) != 0;
    if (currentCapsLock != physicalCapsLocked) {
        physicalCapsLocked = currentCapsLock;
        if (physicalCapsLocked) {
            [[AppDelegate sharedEmulator] keyDown:KC_CAPSLOCK];
        } else {
            [[AppDelegate sharedEmulator] keyUp:KC_CAPSLOCK];
        }
    }
}

#pragma mark - Mouse

- (void)setUpPointingDevice {
    if (pointingDeviceView) {
        [pointingDeviceView removeFromSuperview];
        pointingDeviceView = nil;
    }

    if (pointerInteraction == nil) {
        pointerInteraction = [[UIPointerInteraction alloc] initWithDelegate: self];
        [self.view addInteraction:pointerInteraction];
        UIHoverGestureRecognizer *hoverGestureRecognizer = [[UIHoverGestureRecognizer alloc] initWithTarget:self action:@selector(hover:)];
        [self.view addGestureRecognizer:hoverGestureRecognizer];
    }


#if defined(TARGET_OS_VISION) && TARGET_OS_VISION == 1
    Class pointingDeviceClass = [TouchScreen class];
#else
    BOOL useTrackPad = [[NSUserDefaults standardUserDefaults] boolForKey:@"trackpad"];
    Class pointingDeviceClass = useTrackPad ? [TrackPad class] : [TouchScreen class];
#endif
    pointingDeviceView = [[pointingDeviceClass alloc] initWithFrame:self.view.bounds];
    pointingDeviceView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
    [self.view insertSubview:pointingDeviceView aboveSubview:self.screenView];
    if ([UIApplication instancesRespondToSelector:@selector(btcMouseSetRawMode:)]) {
        [[UIApplication sharedApplication] btcMouseSetRawMode:YES];
    }
}

- (Point)mouseLocForCGPoint:(CGPoint)point {
    Point mouseLoc;
    CGRect screenBounds = self.screenView.screenBounds;
    CGSize screenSize = self.screenView.screenSize;
    mouseLoc.h = (point.x - screenBounds.origin.x) * (screenSize.width/screenBounds.size.width);
    mouseLoc.v = (point.y - screenBounds.origin.y) * (screenSize.height/screenBounds.size.height);
    return mouseLoc;
}

- (UIPointerRegion *)pointerInteraction:(UIPointerInteraction *)interaction regionForRequest:(UIPointerRegionRequest *)request defaultRegion:(UIPointerRegion *)defaultRegion {
    return defaultRegion;
}

- (UIPointerStyle *)pointerInteraction:(UIPointerInteraction *)interaction styleForRegion:(UIPointerRegion *)region {
    return [UIPointerStyle hiddenPointerStyle];
}

- (void)hover:(UIHoverGestureRecognizer *)hoverGestureRecognizer {
    Point mouseLoc = [self mouseLocForCGPoint:[hoverGestureRecognizer locationInView:self.screenView]];
    [[AppDelegate sharedEmulator] setMouseX:mouseLoc.h Y:mouseLoc.v];
}

@end