Common.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 "LayerSnapshotter.h"

NSString *ZephyrDescriptionForOrientation(UIInterfaceOrientation orientation) {
    switch (orientation) {
        case UIInterfaceOrientationPortrait:
            return @"portrait";
            break;
        case UIInterfaceOrientationPortraitUpsideDown:
            return @"portrait upside-down";
            break;
        case UIInterfaceOrientationLandscapeLeft:
            return @"landscape left";
            break;
        case UIInterfaceOrientationLandscapeRight:
            return @"landscape right";
            break;
    }

    return @"invalid orientation";
}

UIInterfaceOrientation ZephyrOrientationFlip(UIInterfaceOrientation orientation) {
    switch (orientation) {
        case UIInterfaceOrientationPortrait:
            return UIInterfaceOrientationPortraitUpsideDown;
        case UIInterfaceOrientationPortraitUpsideDown:
            return UIInterfaceOrientationPortrait;
        case UIInterfaceOrientationLandscapeLeft:
            return UIInterfaceOrientationLandscapeRight;
        case UIInterfaceOrientationLandscapeRight:
            return UIInterfaceOrientationLandscapeLeft;
    }

    return orientation;
}

void ZephyrRotateViewFromOrientationToOrientation(UIView *view, UIInterfaceOrientation fromOrientation, UIInterfaceOrientation toOrientation, BOOL inPlace) {
    CGAffineTransform transform = [view transform];
    CGRect frame = [view frame];

    CGFloat rotation = 0.0f;
    BOOL perpendicular = NO;
    BOOL clockwise = NO;

    switch (fromOrientation) {
        case UIInterfaceOrientationPortrait:
            switch (toOrientation) {
                case UIInterfaceOrientationPortrait:
                    rotation = 0.0f;
                    break;
                case UIInterfaceOrientationPortraitUpsideDown:
                    rotation = M_PI;
                    break;
                case UIInterfaceOrientationLandscapeLeft:
                    rotation = -(M_PI / 2.0f);
                    clockwise = YES;
                    perpendicular = YES;
                    break;
                case UIInterfaceOrientationLandscapeRight:
                    rotation = (M_PI / 2.0f);
                    perpendicular = YES;
                    break;
            }
            break;
        case UIInterfaceOrientationPortraitUpsideDown:
            switch (toOrientation) {
                case UIInterfaceOrientationPortrait:
                    rotation = M_PI;
                    break;
                case UIInterfaceOrientationPortraitUpsideDown:
                    rotation = 0.0f;
                    break;
                case UIInterfaceOrientationLandscapeLeft:
                    rotation = (M_PI / 2.0f);
                    perpendicular = YES;
                    break;
                case UIInterfaceOrientationLandscapeRight:
                    rotation = -(M_PI / 2.0f);
                    clockwise = YES;
                    perpendicular = YES;
                    break;
            }
            break;
        case UIInterfaceOrientationLandscapeLeft:
            switch (toOrientation) {
                case UIInterfaceOrientationPortrait:
                    rotation = (M_PI / 2.0f);
                    perpendicular = YES;
                    break;
                case UIInterfaceOrientationPortraitUpsideDown:
                    rotation = -(M_PI / 2.0f);
                    clockwise = YES;
                    perpendicular = YES;
                    break;
                case UIInterfaceOrientationLandscapeLeft:
                    rotation = 0.0f;
                    break;
                case UIInterfaceOrientationLandscapeRight:
                    rotation = M_PI;
                    break;
            }
            break;
        case UIInterfaceOrientationLandscapeRight:
            switch (toOrientation) {
                case UIInterfaceOrientationPortrait:
                    rotation = -(M_PI / 2.0f);
                    clockwise = YES;
                    perpendicular = YES;
                    break;
                case UIInterfaceOrientationPortraitUpsideDown:
                    rotation = (M_PI / 2.0f);
                    perpendicular = YES;
                    break;
                case UIInterfaceOrientationLandscapeLeft:
                    rotation = M_PI;
                    break;
                case UIInterfaceOrientationLandscapeRight:
                    rotation = 0.0f;
                    break;
            }
            break;
    }

    transform = CGAffineTransformRotate(transform, rotation);

    if (perpendicular) {
        if (inPlace) {
            CGRect frame = [view frame];
            frame.size.width = [view frame].size.height;
            frame.size.height = [view frame].size.width;
            [view setFrame:frame];
        }

        if (clockwise) {
            transform = CGAffineTransformTranslate(transform, (frame.size.width - frame.size.height) / 2.0f, (frame.size.height - frame.size.width) / -2.0f);
        } else {
            transform = CGAffineTransformTranslate(transform, (frame.size.width - frame.size.height) / -2.0f, (frame.size.height - frame.size.width) / 2.0f);
        }
    }

    [view setTransform:transform];
}

UIView *ZephyrViewForApplication(SBApplication *app) {
    SBGestureViewVendor *vendor = [objc_getClass("SBGestureViewVendor") sharedInstance];

    [vendor clearCacheForApp:app reason:@"SwitchApp"];
    return [vendor viewForApp:app gestureType:kSBGestureTypeSwitchApp includeStatusBar:YES];
}

%group GestureViewStatusBar

// Switch app orientation depends on gestures flag, so hook it and apply it ourselves.
static BOOL switchAppOrientationFlag = NO;

%hook SBApplication

- (UIInterfaceOrientation)launchingInterfaceOrientationForCurrentOrientation {
    if (switchAppOrientationFlag) {
        return ZephyrCurrentInterfaceOrientation();
    } else {
        return %orig;
    }
}

%end

%hook SBUIController

- (id)systemGestureSnapshotForApp:(SBApplication *)app includeStatusBar:(BOOL)include decodeImage:(BOOL)decode {
    switchAppOrientationFlag = YES;
    id result = %orig;
    switchAppOrientationFlag = NO;
    return result;
}

%end

%hook SBGestureViewVendor

- (void)maskViewIfNeeded:(UIView *)view gestureType:(SBGestureType)type viewType:(int)viewType contextHostViewRequester:(NSString *)requester app:(SBApplication *)app {
    switchAppOrientationFlag = YES;
    %orig;
    switchAppOrientationFlag = NO;
}

%end

%end

%ctor {
    %init(GestureViewStatusBar);
}

CGFloat ZephyrScreenRounded(CGFloat value) {
    CGFloat scale = [UIScreen mainScreen].scale;
    return roundf(value * scale) / scale;
}

UIView *ZephyrViewWithScreenshotOfView(UIView *view) {
    dlopen("/usr/lib/liblayersnapshotter.dylib", RTLD_LAZY);

    if ([view respondsToSelector:@selector(renderSnapshot)]) {
        UIImage *viewImage = [view renderSnapshot];
        UIImageView *screenshotView = [[UIImageView alloc] initWithImage:viewImage];
        [screenshotView setFrame:[view frame]];
        return [screenshotView autorelease];
    } else {
        return [[[UIView alloc] initWithFrame:view.frame] autorelease];
    }
}

UIView *ZephyrViewWithScreenshotOfHomeScreen() {
    // XXX: using contentView here isn't necessarily the best option, but it works.
    UIView *homeView = ZephyrViewWithScreenshotOfView([[objc_getClass("SBUIController") sharedInstance] contentView]);
    [homeView setBackgroundColor:[UIColor blackColor]];

    CGRect statusFrame = [homeView bounds];
    statusFrame.size.height = UIStatusBarHeight;
    UIStatusBar *statusView = [[objc_getClass("UIStatusBar") alloc] initWithFrame:statusFrame];
    [statusView requestStyle:UIStatusBarStyleBlackTranslucent animated:NO];
    [homeView addSubview:statusView];
    [statusView release];

    return homeView;
}

CGFloat ZephyrHeightForOrientation(UIInterfaceOrientation orientation) {
    if (UIInterfaceOrientationIsLandscape(orientation)) {
        return [[UIScreen mainScreen] bounds].size.width;
    } else {
        return [[UIScreen mainScreen] bounds].size.height;
    }
}

CGFloat ZephyrWidthForOrientation(UIInterfaceOrientation orientation) {
    if (UIInterfaceOrientationIsLandscape(orientation)) {
        return [[UIScreen mainScreen] bounds].size.height;
    } else {
        return [[UIScreen mainScreen] bounds].size.width;
    }
}

CGFloat ZephyrHeightFromScreenPercentage(CGFloat percentage, UIInterfaceOrientation orientation) {
    return ZephyrHeightForOrientation(orientation) * percentage;
}

UIInterfaceOrientation ZephyrCurrentInterfaceOrientation() {
    UIInterfaceOrientation orientation = [SBApp _frontMostAppOrientation];
    return orientation;
}

UIInterfaceOrientation ZephyrDeviceInterfaceOrientation() {
    return [SBApp interfaceOrientationForCurrentDeviceOrientation];
}

UIInterfaceOrientation ZephyrHomeInterfaceOrientation() {
    UIInterfaceOrientation orientation = ZephyrCurrentInterfaceOrientation();

    // Often, the Current interface orientation is different than the home screen's.
    // In that case, we prefer what the user is seeing: the Current one. However,
    // if that isn't a valid home orientation, then return what we know is valid.
    if (!ZephyrHomeShouldRotateToInterfaceOrientation(orientation)) {
        orientation = [SBApp interfaceOrientation];
    }

    return orientation;
}

BOOL ZephyrHomeShouldRotateToInterfaceOrientation(UIInterfaceOrientation orientation) {
    SBUIController *controller = [objc_getClass("SBUIController") sharedInstance];
    return [controller window:[controller window] shouldAutorotateToInterfaceOrientation:orientation];
}

BOOL ZephyrAssistantIsVisible() {
    Class $SBAssistantController = objc_getClass("SBAssistantController");

    if ([$SBAssistantController respondsToSelector:@selector(isAssistantVisible)]) {
        return [$SBAssistantController isAssistantVisible];
    } else if ([[$SBAssistantController sharedInstance] respondsToSelector:@selector(isAssistantVisible)]) {
        return [[$SBAssistantController sharedInstance] isAssistantVisible];
    } else {
        return NO;
    }
}

BOOL ZephyrMultitaskingSupported() {
    Class $SBApplication = objc_getClass("SBApplication");

    if ([$SBApplication respondsToSelector:@selector(multitaskingIsSupported)]) {
        return [$SBApplication multitaskingIsSupported];
    }

    return YES;

}
static BOOL disableUnscatterFlag = NO;

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

    if (objc_getClass("SBDisplayStack") != nil) {
        // XXX: the "disableIconUnscatter" display flag there does not work, so:
        disableUnscatterFlag = YES;

        // Stolen from SwitchApp.xmi; this is a bad decompliation of
        // what a different function does than the one I am reversing.
        [app setDeactivationSetting:24 flag:YES];
        [app setDeactivationSetting:18 flag:YES];

        /* sub_2C330 */ {
            if ([SBWActiveDisplayStack containsDisplay:app] || [SBWSuspendedEventOnlyDisplayStack containsDisplay:app]) {

                /* sub_2B9B8 */ {
                    // this is a crude approximation of sorta kinda what this gigantic
                    // function does, since I'm waaaaay too lazy to reverse the whole
                    // thing: even just the graph in IDA is quite scary to look at! :(
                    [SBWActiveDisplayStack popDisplay:app];
                    [SBWSuspendingDisplayStack pushDisplay:app];
                }
            } else if (![SBWSuspendingDisplayStack containsDisplay:app]) {
                [app clearDeactivationSettings];
            }
        }
    } else {
        // Force iPhone devices to portrait for the home screen.
        // Should be generalized; the iPhone might be hacked for more orientations.
        if (!ZephyrHomeShouldRotateToInterfaceOrientation(ZephyrCurrentInterfaceOrientation())) {
            UIInterfaceOrientation currentOrientation = ZephyrHomeInterfaceOrientation();
            [[UIDevice currentDevice] setOrientation:currentOrientation animated:NO];
            [SBApp noteInterfaceOrientationChanged:currentOrientation];
        }

        [app setDeactivationSetting:0x15 flag:YES];
        [app setDeactivationSetting:0x16 flag:YES];

        NSString *label = @"ActivateSpringBoard";
        SBWorkspaceEvent *event = [objc_getClass("SBWorkspaceEvent") eventWithLabel:label handler:^{
            BKSWorkspace *workspace = [SBWSharedWorkspace bksWorkspace];
            SBAppToAppWorkspaceTransaction *transaction = [[objc_getClass("SBAppToAppWorkspaceTransaction") alloc] initWithWorkspace:workspace alertManager:nil from:app to:nil];
            [SBWSharedWorkspace setCurrentTransaction:transaction];
            [transaction release];
        }];

        [[objc_getClass("SBWorkspaceEventQueue") sharedInstance] executeOrAppendEvent:event];
    }
}

%group ForceDisableAnimatedRestore

%hook SBUIController

- (void)restoreIconListAnimated:(BOOL)animated animateWallpaper:(BOOL)wallpaper keepSwitcher:(BOOL)switcher {
    if (disableUnscatterFlag) {
        disableUnscatterFlag = NO;
        animated = NO;
    }

    %orig(animated, wallpaper, switcher);
}

%end

%end

%ctor {
    %init(ForceDisableAnimatedRestore);
}

CGFloat ZephyrAppSwitcherHeight() {
    CGFloat bottomBarHeight = [[objc_getClass("SBAppSwitcherController") sharedInstance] bottomBarHeight];
    return bottomBarHeight;
}