Switcher.xmi

/*
 * Copyright (c) 2011-2013, Xuzz Productions, LLC
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#import "Common.h"
#import "Switcher.h"
#import "ActivateSwitcher.h"
#import "Preferences.h"
#import "NSTimer+Blocks.h"

#import "SwitchApp.h"

#include <dlfcn.h>

static SwipeUpKeyboardAction KeyboardAction() {
    SwipeUpKeyboardAction keyboardAction = (SwipeUpKeyboardAction) [(NSNumber *) ZephyrPreferencesGet(@"BottomDisableKeyboard", [NSNumber numberWithInt:kSwipeUpKeyboardActionDisabled]) intValue];
    return keyboardAction;
}

static BOOL UseGrabber() {
    return [(NSNumber *) ZephyrPreferencesGet(@"BottomGrabberEnabled", [NSNumber numberWithBool:NO]) boolValue];
}

@implementation ZephyrSwitcherGesture

- (BOOL)shouldActivateAtEdge:(SBOffscreenEdge)edge {
    SBApplication *topApplication = [SBApp _accessibilityFrontMostApplication];
    if (topApplication == nil) topApplication = MSHookIvar<SBApplication *>([objc_getClass("SBUIController") sharedInstance], "_pendingAppActivatedByGesture");

    if (KeyboardAction() == kSwipeUpKeyboardActionDisabled && [UIKeyboard isOnScreen]) return NO;

    BOOL displayFlagsAllowed = YES;

    // Ensure topApplication is properly launched and ready.
    if (topApplication != nil) {
        if ([topApplication displayFlag:0x3]) displayFlagsAllowed = NO;
        if (![topApplication displayFlag:0x1]) displayFlagsAllowed = NO;
    }

    NSString *topIdentifier = [topApplication displayIdentifier];
    BOOL disableIdentifier = [(NSNumber *) ZephyrPreferencesGet([NSString stringWithFormat:@"BottomDisable-%@", topIdentifier], (id)kCFBooleanFalse) boolValue];
    if (disableIdentifier) return NO;

    SwipeUpAction action = (SwipeUpAction) [(NSNumber *) ZephyrPreferencesGet(@"SwipeUpAction", [NSNumber numberWithInt:kSwipeUpActionCloseApp]) intValue];

    // This is needed to prevent re-activation before the animation completes, crashing.
    BOOL currentlyPendingSwitcherActivationsExist = (pendingSwitcherActivations != nil);

    return YES
        // Our configuration allows this.
        && (action == kSwipeUpActionSwitcher || action == kSwipeUpActionCloseApp)
        && [self currentOrientationIsSupported]
        // No other gesture is in the way (including our switch app).
        && ![SBApp _accessibilityIsSystemGestureActive]
        && !currentlyPendingSwitcherActivationsExist
        // We aren't in some disallowed state.
        && !ZephyrAssistantIsVisible()
        && (topApplication == nil || displayFlagsAllowed)
        && ![[objc_getClass("SBIconController") sharedInstance] isEditing]
        && ![[objc_getClass("SBAwayController") sharedAwayController] isLocked]
        && ![[objc_getClass("SBUIController") sharedInstance] isSwitcherShowing]
        && ![[objc_getClass("SBBulletinWindowController") sharedInstance] isBusy]
        && ![[objc_getClass("SBBulletinListController") sharedInstanceIfExists] listViewIsActive];
}

- (BOOL)shouldUseGrabberAtEdge:(SBOffscreenEdge)edge {
    BOOL grabberAlways = (UseGrabber() && [SBApp _accessibilityFrontMostApplication] != nil);
    BOOL grabberKeyboard = (KeyboardAction() == kSwipeUpKeyboardActionGrabber && [UIKeyboard isOnScreen]);

    return grabberAlways || grabberKeyboard;
}

- (BOOL)currentOrientationIsSupported {
    return YES;
}

- (SwipeUpAction)effectiveSwipeUpAction {
    SwipeUpAction action = (SwipeUpAction) [(NSNumber *) ZephyrPreferencesGet(@"SwipeUpAction", [NSNumber numberWithInt:kSwipeUpActionCloseApp]) intValue];
    SBApplication *topApplication = [SBApp _accessibilityFrontMostApplication];

    if (action == kSwipeUpActionCloseApp && topApplication == nil) {
        action = kSwipeUpActionSwitcher;
    }

    return action;
}

- (void)cleanupViews {
    SBApplication *app = [SBApp _accessibilityFrontMostApplication];

    if (app != nil) {
        [app disableContextHostingForRequester:(CFStringRef) @"SwitchApp"];
    } else {
        [SBApp showSpringBoardStatusBar];
    }


    [switcherView removeFromSuperview];
    [switcherView release];
    switcherView = nil;

    [shadowView removeFromSuperview];
    [shadowView release];
    shadowView = nil;

    [appView removeFromSuperview];
    [appView release];
    appView = nil;

    [wrapperView removeFromSuperview];
    [wrapperView release];
    wrapperView = nil;


    for (NSArray *locationAndTimer in pendingSwitcherActivations) {
        NSTimer *timer = [locationAndTimer objectAtIndex:1];
        [timer invalidate];
    }

    [pendingSwitcherActivations release];
    pendingSwitcherActivations = nil;


    [[objc_getClass("SBOrientationLockManager") sharedInstance] setLockOverrideEnabled:NO forReason:@"ZephyrSwitcher"];
    if ([SBApp _accessibilityFrontMostApplication] != nil) [[[objc_getClass("SBUIController") sharedInstance] rootView] setAlpha:0.0f];
}

- (void)handleGestureCanceled:(SBGestureRecognizer *)recognizer {
    // XXX: implement this correctly
}

- (void)positionAtLocation:(CGFloat)location {
    CGRect appFrame = [appView frame];
    CGRect shadowFrame = [shadowView frame];
    appFrame.origin.y = location;
    shadowFrame.origin.y = appFrame.size.height + location;
    [appView setFrame:appFrame];
    [shadowView setFrame:shadowFrame];
}

- (void)handleGestureBegan:(SBGestureRecognizer *)recognizer withLocation:(CGFloat)location {
    pendingSwitcherActivations = [[NSMutableSet alloc] init];
    [[objc_getClass("SBOrientationLockManager") sharedInstance] setLockOverrideEnabled:YES forReason:@"ZephyrSwitcher"];
    if ([SBApp _accessibilityFrontMostApplication] != nil) [[[objc_getClass("SBUIController") sharedInstance] rootView] setAlpha:1.0f];

    if (ZephyrHomeShouldRotateToInterfaceOrientation(ZephyrCurrentInterfaceOrientation())) {
        UIInterfaceOrientation currentOrientation = ZephyrCurrentInterfaceOrientation();
        [[UIDevice currentDevice] setOrientation:currentOrientation animated:NO];
        [SBApp noteInterfaceOrientationChanged:currentOrientation];
    }

    location = ZephyrHeightFromScreenPercentage(location, ZephyrCurrentInterfaceOrientation());

    UIView *rootView = [[objc_getClass("SBUIController") sharedInstance] contentView];
    wrapperView = [[UIView alloc] initWithFrame:[rootView bounds]];
    ZephyrRotateViewFromOrientationToOrientation(wrapperView, ZephyrHomeInterfaceOrientation(), ZephyrCurrentInterfaceOrientation(), YES);
    [rootView addSubview:wrapperView];

    appView = [[UIView alloc] initWithFrame:[wrapperView bounds]];
    [appView setClipsToBounds:NO];
    [wrapperView addSubview:appView];

    SBApplication *app = [SBApp _accessibilityFrontMostApplication];

    if (app != nil) {
        UIView *gestureView = ZephyrViewForApplication(app);

        UIView *gestureWrapperView = [[UIView alloc] initWithFrame:[appView bounds]];
        [gestureWrapperView addSubview:gestureView];
        [appView addSubview:gestureWrapperView];

        if (UIInterfaceOrientationIsLandscape(ZephyrCurrentInterfaceOrientation())) {
            ZephyrRotateViewFromOrientationToOrientation(gestureWrapperView, UIInterfaceOrientationPortrait, ZephyrOrientationFlip(ZephyrCurrentInterfaceOrientation()), YES);
        } else if (ZephyrCurrentInterfaceOrientation() == UIInterfaceOrientationPortraitUpsideDown) {
            ZephyrRotateViewFromOrientationToOrientation(gestureWrapperView, UIInterfaceOrientationPortrait, ZephyrCurrentInterfaceOrientation(), YES);
        }
    } else {
        UIView *homeView = ZephyrViewWithScreenshotOfHomeScreen();
        [appView addSubview:homeView];

        [SBApp hideSpringBoardStatusBar];

        // Call private UIKit API to cancel touches on the icon lists while swiping.
        // This fixes the bug where swiping up on an icon would start editing mode.
        if ([SBApp respondsToSelector:@selector(_cancelAllTouches)])
            [SBApp performSelector:@selector(_cancelAllTouches)];
    }

    shadowView = [[UIImageView alloc] initWithImage:[UIImage imageNamed:@"SwitcherShadowTop.png"]];
    CGRect shadowFrame = [shadowView frame];
    shadowFrame.size = [[shadowView image] size];
    shadowFrame.origin.y = [appView bounds].size.height;
    shadowFrame.size.width = [appView bounds].size.width;
    [shadowView setFrame:shadowFrame];
    [wrapperView addSubview:shadowView];

    [[objc_getClass("SBAppSwitcherController") sharedInstance] setupForApp:app orientation:ZephyrCurrentInterfaceOrientation()];
    switcherView = [[objc_getClass("SBAppSwitcherController") sharedInstance] view];
    CGFloat bottomBarHeight = ZephyrAppSwitcherHeight();
    CGRect switcherFrame = [switcherView frame];
    switcherFrame.origin.y = [appView bounds].size.height - bottomBarHeight;
    [switcherView setFrame:switcherFrame];
    [switcherView retain];

    if ([self effectiveSwipeUpAction] == kSwipeUpActionCloseApp) {
        [[objc_getClass("SBUIController") sharedInstance] restoreIconListAnimated:NO animateWallpaper:NO keepSwitcher:NO];
        [[objc_getClass("SBUIController") sharedInstance] notifyAppResignActive:app];
    } else if ([self effectiveSwipeUpAction] == kSwipeUpActionSwitcher) {
        [wrapperView addSubview:switcherView];
        [wrapperView sendSubviewToBack:switcherView];
    }

    [UIView animateWithDuration:0.08f animations:^{
        CGFloat loc = ZephyrHeightFromScreenPercentage(location, ZephyrCurrentInterfaceOrientation());
        [self positionAtLocation:loc];
    }];
}

- (void)handleGestureChanged:(SBGestureRecognizer *)recognizer withLocation:(CGFloat)location velocity:(CGPoint)velocity {
    location = [self screenLocationFromLocation:location];

    [self positionAtLocation:location];

    // If we are closing the app, support switcher activation.
    CGFloat delay = [ZephyrPreferencesGet(@"BottomSwitcherActivationDelay", [NSNumber numberWithFloat:0.8f]) floatValue];
    if ([self effectiveSwipeUpAction] == kSwipeUpActionCloseApp && delay != 0.0) {
        [self cancelTimersForMovementToLocation:location];

        // No need to clear this from the timer list when done because the pendingSwitcherActiavtions is cleared when it fires.
        [pendingSwitcherActivations addObject:[NSArray arrayWithObjects:[NSNumber numberWithFloat:location], [NSTimer zephyrScheduledTimerWithTimeInterval:delay block:^(NSTimer *timer) {
            if (![self isActive]) return; // prevent double activations

            [self animateSwitcherFromDismissGesture];
            [self cancelGesture];
        } repeats:NO], nil]];
    }
}

- (void)resetAfterCancelDismissGesture {
    SBApplication *app = [SBApp _accessibilityFrontMostApplication];
    SBUIController *controller = [objc_getClass("SBUIController") sharedInstance];
    [controller notifyAppResumeActive:app];
    [controller stopRestoringIconList];
    [controller tearDownIconListAndBar];
}

- (void)handleGestureEnded:(SBGestureRecognizer *)recognizer withLocation:(CGFloat)location velocity:(CGPoint)velocity completionType:(int)type {
    location = [self screenLocationFromLocation:location];

    if ([self effectiveSwipeUpAction] == kSwipeUpActionSwitcher) {
        if (velocity.y < 0) {
            [self animateSwitcherFromSwitcherGestureLocation:location];
        } else {
            [self animateResetWithCompletion:NULL];
        }
    } else {
        if (type == 1) {
            [self animateDismissFromDismissGestureLocation:location];
        } else {
            [self animateResetWithCompletion:^{
                [self resetAfterCancelDismissGesture];
            }];
        }
    }
}

- (void)cancelTimersForMovementToLocation:(CGFloat)location {
    // Remove pending switcher activations outside range.
    NSMutableSet *pendingSwitcherActivationsToRemove = [NSMutableSet set];

    for (NSArray *locationAndTimer in pendingSwitcherActivations) {
        CGFloat originalLocation = [[locationAndTimer objectAtIndex:0] floatValue];
        NSTimer *timer = [locationAndTimer objectAtIndex:1];

        CGFloat allowableMovementDistance = 5.0f;
        if (fabsf(originalLocation - location) > allowableMovementDistance) {
            [timer invalidate];
            [pendingSwitcherActivationsToRemove addObject:locationAndTimer];
        }
    }

    [pendingSwitcherActivations minusSet:pendingSwitcherActivationsToRemove];
}

- (CGFloat)screenLocationFromLocation:(CGFloat)location {
    location = ZephyrHeightFromScreenPercentage(location, ZephyrCurrentInterfaceOrientation());

    // constrain to not going way off the screen
    if (location > 20.0f) location = 20.0f;

    // constrain to top of switcher
    if ([self effectiveSwipeUpAction] == kSwipeUpActionSwitcher) {
        CGFloat bottomBarHeight = ZephyrAppSwitcherHeight();

        if (-location > bottomBarHeight) {
            location = ZephyrScreenRounded((location + bottomBarHeight) * 0.2f - bottomBarHeight);
        }
    }

    return location;
}

- (void)animateResetWithCompletion:(void (^)())completion {
    [UIView animateWithDuration:0.3f animations:^{
        [self positionAtLocation:0];
    } completion:^(BOOL completed) {
        [self cleanupViews];

        if (completion != NULL) {
            completion();
        }
    }];
}

- (void)animateDismissFromDismissGestureLocation:(CGFloat)location {
    [SBApp showSpringBoardStatusBar];

    UIViewAnimationOptions options = (UIViewAnimationOptionCurveEaseOut | UIViewAnimationOptionBeginFromCurrentState);
    [UIView animateWithDuration:0.3f delay:0.0f options:options animations:^{
        CGFloat completedLocation = -[wrapperView bounds].size.height;
        [self positionAtLocation:completedLocation];
    } completion:^(BOOL completed) {
        [self cleanupViews];

        // In this case, we definitely do not want to hide this.
        [[[objc_getClass("SBUIController") sharedInstance] rootView] setAlpha:1.0f];

        ZephyrDeactivateFrontmostApplication();
    }];
}

- (void)animateSwitcherFromSwitcherGestureLocation:(CGFloat)location {
    CGFloat bottomBarHeight = ZephyrAppSwitcherHeight();

    CGFloat from = -location;
    CGFloat to = bottomBarHeight;
    CGFloat duration = 0.3f;

    if ([[objc_getClass("SBIconController") sharedInstance] openFolder] != nil) {
        [UIView animateWithDuration:duration animations:^{
            [self positionAtLocation:-to];
        } completion:^(BOOL completed) {
            [self cleanupViews];

            ZephyrActivateSwitcherFromToDuration(to, to, duration);
        }];
    } else {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self cleanupViews];

            ZephyrActivateSwitcherFromToDuration(from, to, duration);
        });
    }
}

- (void)animateSwitcherFromDismissGesture {
    CGFloat bottomBarHeight = ZephyrAppSwitcherHeight();

    UIView *homeView = ZephyrViewWithScreenshotOfHomeScreen();
    [homeView setFrame:[wrapperView bounds]];

    if (!ZephyrHomeShouldRotateToInterfaceOrientation(ZephyrCurrentInterfaceOrientation())) {
        // Disable rotation on the iPad as the view behind is already rotated, so rotating it again is unnecessary.
        if (UIInterfaceOrientationIsLandscape(ZephyrCurrentInterfaceOrientation())) {
            ZephyrRotateViewFromOrientationToOrientation(homeView, UIInterfaceOrientationPortrait, ZephyrOrientationFlip(ZephyrCurrentInterfaceOrientation()), YES);
        } else if (ZephyrCurrentInterfaceOrientation() == UIInterfaceOrientationPortraitUpsideDown) {
            ZephyrRotateViewFromOrientationToOrientation(homeView, UIInterfaceOrientationPortrait, ZephyrCurrentInterfaceOrientation(), YES);
        }
    }

    // XXX: this is a horrible hack
    UIImageView *switcherShadowView = [[UIImageView alloc] initWithImage:[UIImage imageNamed:@"SwitcherShadowTop.png"]];
    CGRect shadowFrame = [switcherShadowView frame];
    shadowFrame.size = [[switcherShadowView image] size];
    shadowFrame.size.width = [wrapperView bounds].size.width;
    shadowFrame.origin.y = [wrapperView bounds].size.height;
    [switcherShadowView setFrame:shadowFrame];
    [switcherShadowView autorelease];

    CGRect switcherFrame = [switcherView frame];
    switcherFrame.origin.y = [wrapperView bounds].size.height - bottomBarHeight;
    [switcherView setFrame:switcherFrame];

    [wrapperView addSubview:switcherView];
    [wrapperView addSubview:switcherShadowView];
    [wrapperView addSubview:homeView];
    [wrapperView addSubview:shadowView];
    [wrapperView addSubview:appView];

    [UIView animateWithDuration:0.4f animations:^{
        [self positionAtLocation:-bottomBarHeight];

        [shadowView setAlpha:0.0f];

        CGRect switcherShadowFrame = [switcherShadowView frame];
        CGRect homeFrame = [homeView frame];
        switcherShadowFrame.origin.y = [wrapperView bounds].size.height + -bottomBarHeight;
        homeFrame.origin.y = -bottomBarHeight;
        [switcherShadowView setFrame:switcherShadowFrame];
        [homeView setFrame:homeFrame];
    } completion:^(BOOL finished) {
        [self cleanupViews];

        [self resetAfterCancelDismissGesture];

        [homeView removeFromSuperview];
        [switcherShadowView removeFromSuperview];

        ZephyrActivateSwitcherFromToDuration(bottomBarHeight, bottomBarHeight, 0.0f);
    }];
}

@end

%group Switcher

%hook SBAppSwitcherBarView

- (id)initWithFrame:(CGRect)frame {
    if ((self = %orig)) {
        // this stupidiy is necessary because Apple limits SBLinenView to 320px wide on iPhone
        SBLinenView *linen = nil;

        CGFloat height = 320.0f;
        CGFloat width = ZephyrWidthForOrientation(UIInterfaceOrientationPortrait);

        UIView *backgroundView = MSHookIvar<UIView *>(self, "_backgroundView");
        ZephyrRotateViewFromOrientationToOrientation(backgroundView, UIInterfaceOrientationPortrait, UIInterfaceOrientationPortraitUpsideDown, YES);

        linen = [[objc_getClass("SBLinenView") alloc] initWithFrame:CGRectMake(0, [self bounds].size.height - height, width, height)];
        [linen setAutoresizingMask:UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleTopMargin];
        ZephyrRotateViewFromOrientationToOrientation(linen, UIInterfaceOrientationPortrait, UIInterfaceOrientationPortraitUpsideDown, YES);
        [self addSubview:linen];
        [self sendSubviewToBack:linen];
        [linen release];

        linen = [[objc_getClass("SBLinenView") alloc] initWithFrame:CGRectMake(ZephyrScreenRounded(([self bounds].size.width - width) / 2.0f), [self bounds].size.height - height, width, height)];
        [linen setAutoresizingMask:UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleTopMargin];
        ZephyrRotateViewFromOrientationToOrientation(linen, UIInterfaceOrientationPortrait, UIInterfaceOrientationPortraitUpsideDown, YES);
        [self addSubview:linen];
        [self sendSubviewToBack:linen];
        [linen release];

        linen = [[objc_getClass("SBLinenView") alloc] initWithFrame:CGRectMake([self bounds].size.width - width, [self bounds].size.height - height, width, height)];
        [linen setAutoresizingMask:UIViewAutoresizingFlexibleLeftMargin | UIViewAutoresizingFlexibleTopMargin];
        ZephyrRotateViewFromOrientationToOrientation(linen, UIInterfaceOrientationPortrait, UIInterfaceOrientationPortraitUpsideDown, YES);
        [self addSubview:linen];
        [self sendSubviewToBack:linen];
        [linen release];
    }

    return self;
}

%end

%hook SBUIController

static ZephyrSwitcherGesture *gesture = nil;

- (void)finishLaunching {
    %orig;

    NSInteger touches = [(NSNumber *) ZephyrPreferencesGet(@"BottomMinimumTouchCount", ZephyrPreferencesGet(@"MinimumTouchCount", [NSNumber numberWithInt:1])) intValue];
    CGFloat edgeMargin = [(NSNumber *) ZephyrPreferencesGet(@"BottomSensitivityDistance", [NSNumber numberWithFloat:30.0f]) floatValue];

    gesture = [[ZephyrSwitcherGesture alloc] init];
    [gesture addOffscreenEdge:kSBOffscreenEdgeBottom minimumTouchCount:touches edgeMargin:edgeMargin];

    ZephyrPreferencesApplyActionRegister(^{
        NSInteger touches = [(NSNumber *) ZephyrPreferencesGet(@"BottomMinimumTouchCount", ZephyrPreferencesGet(@"MinimumTouchCount", [NSNumber numberWithInt:1])) intValue];
        CGFloat edgeMargin = [(NSNumber *) ZephyrPreferencesGet(@"BottomSensitivityDistance", [NSNumber numberWithFloat:30.0f]) floatValue];

        for (SBOffscreenSwipeGestureRecognizer *recognizer in [gesture gestureRecognizers]) {
            [recognizer setMinTouches:touches];
            [recognizer setEdgeMargin:edgeMargin];
        }
    });
}

- (void)handleFluidVerticalSystemGesture:(SBFluidSlideGestureRecognizer *)recognizer {
    if ([gesture isActive]) return;

    BOOL enabled = [ZephyrPreferencesGet(@"SystemSwitcherEnabled", [NSNumber numberWithBool:YES]) boolValue];
    if (!enabled) return;

    %orig;
}

- (void)handleFluidScaleSystemGesture:(SBFluidSlideGestureRecognizer *)recognizer {
    if ([gesture isActive]) return;

    BOOL enabled = [ZephyrPreferencesGet(@"SystemSuspendEnabled", [NSNumber numberWithBool:YES]) boolValue];
    if (!enabled) return;

    MSHookIvar<BOOL>(self, "_switcherVisibleWhenSuspendGestureStarted") = NO;

    %orig;
}

- (void)_suspendGestureEndedWithCompletionType:(int)completionType {
    if (completionType == 1) {
        // The spotlight keyboard will otherwise come up in landscape if we exit the app there.
        if (!ZephyrHomeShouldRotateToInterfaceOrientation(ZephyrCurrentInterfaceOrientation())) {
            UIInterfaceOrientation currentOrientation = ZephyrHomeInterfaceOrientation();
            [[UIDevice currentDevice] setOrientation:currentOrientation animated:NO];
            [SBApp noteInterfaceOrientationChanged:currentOrientation];
        }
    }

    %orig;
}

%end

%hook SBTouchTemplate

- (id)initWithPoints:(CGPoint *)points count:(NSUInteger)count {
    if (count == 5 && [ZephyrPreferencesGet(@"SystemSuspendThreeFingers", [NSNumber numberWithBool:NO]) boolValue]) {
        count = 3;

        // rearrange points
        points[0] = points[0];
        points[1] = points[2];
        points[2] = points[4];
    }

    return %orig;
}

%end

%end

%ctor {
    %init(Switcher);
}