528 lines
18 KiB
Objective-C
528 lines
18 KiB
Objective-C
//
|
|
// Copyright (c) 2017 Open Whisper Systems. All rights reserved.
|
|
//
|
|
|
|
#import "FullImageViewController.h"
|
|
#import "AttachmentSharing.h"
|
|
#import "ConversationViewItem.h"
|
|
#import "TSAttachmentStream.h"
|
|
#import "TSInteraction.h"
|
|
#import "UIColor+OWS.h"
|
|
#import "UIUtil.h"
|
|
#import "UIView+OWS.h"
|
|
#import <SignalServiceKit/NSData+Image.h>
|
|
#import <YYImage/YYImage.h>
|
|
|
|
NS_ASSUME_NONNULL_BEGIN
|
|
|
|
#define kMinZoomScale 1.0f
|
|
#define kMaxZoomScale 8.0f
|
|
|
|
#define kBackgroundAlpha 0.6f
|
|
|
|
// In order to use UIMenuController, the view from which it is
|
|
// presented must have certain custom behaviors.
|
|
@interface AttachmentMenuView : UIView
|
|
|
|
@end
|
|
|
|
#pragma mark -
|
|
|
|
@implementation AttachmentMenuView
|
|
|
|
- (BOOL)canBecomeFirstResponder {
|
|
return YES;
|
|
}
|
|
|
|
// We only use custom actions in UIMenuController.
|
|
- (BOOL)canPerformAction:(SEL)action withSender:(nullable id)sender
|
|
{
|
|
return NO;
|
|
}
|
|
|
|
@end
|
|
|
|
#pragma mark -
|
|
|
|
@interface FullImageViewController () <UIScrollViewDelegate, UIGestureRecognizerDelegate>
|
|
|
|
@property (nonatomic) UIView *backgroundView;
|
|
@property (nonatomic) UIScrollView *scrollView;
|
|
@property (nonatomic) UIImageView *imageView;
|
|
@property (nonatomic) UIButton *shareButton;
|
|
@property (nonatomic) UIView *contentView;
|
|
|
|
@property (nonatomic) CGRect originRect;
|
|
@property (nonatomic) BOOL isPresenting;
|
|
@property (nonatomic) NSData *fileData;
|
|
|
|
@property (nonatomic) TSAttachmentStream *attachmentStream;
|
|
@property (nonatomic) ConversationViewItem *viewItem;
|
|
|
|
@property (nonatomic) UIToolbar *footerBar;
|
|
@property (nonatomic) NSArray *oldMenuItems;
|
|
|
|
@end
|
|
|
|
@implementation FullImageViewController
|
|
|
|
|
|
- (instancetype)initWithAttachment:(TSAttachmentStream *)attachmentStream
|
|
fromRect:(CGRect)rect
|
|
viewItem:(ConversationViewItem *)viewItem
|
|
{
|
|
|
|
self = [super initWithNibName:nil bundle:nil];
|
|
|
|
if (self) {
|
|
self.attachmentStream = attachmentStream;
|
|
self.originRect = rect;
|
|
self.viewItem = viewItem;
|
|
self.fileData = [NSData dataWithContentsOfURL:[attachmentStream mediaURL]];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
- (UIImage *)image {
|
|
return self.attachmentStream.image;
|
|
}
|
|
|
|
- (void)loadView {
|
|
self.view = [AttachmentMenuView new];
|
|
self.view.backgroundColor = [UIColor colorWithWhite:0 alpha:kBackgroundAlpha];
|
|
self.view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
|
|
}
|
|
|
|
- (void)viewDidLoad {
|
|
[super viewDidLoad];
|
|
|
|
[self initializeBackground];
|
|
[self initializeContentViewAndFooterBar];
|
|
[self initializeScrollView];
|
|
[self initializeImageView];
|
|
[self initializeGestureRecognizers];
|
|
|
|
[self populateImageView:self.image];
|
|
}
|
|
|
|
- (void)viewWillDisappear:(BOOL)animated {
|
|
[super viewWillDisappear:animated];
|
|
|
|
if ([UIMenuController sharedMenuController].isMenuVisible) {
|
|
[[UIMenuController sharedMenuController] setMenuVisible:NO
|
|
animated:NO];
|
|
}
|
|
}
|
|
|
|
#pragma mark - Initializers
|
|
|
|
- (void)initializeBackground {
|
|
self.imageView.backgroundColor = [UIColor colorWithWhite:0 alpha:kBackgroundAlpha];
|
|
|
|
self.backgroundView = [UIView new];
|
|
self.backgroundView.backgroundColor = [UIColor colorWithWhite:0 alpha:kBackgroundAlpha];
|
|
[self.view addSubview:self.backgroundView];
|
|
[self.backgroundView autoPinEdgesToSuperviewEdges];
|
|
}
|
|
|
|
- (void)initializeContentViewAndFooterBar {
|
|
self.contentView = [UIView new];
|
|
[self.backgroundView addSubview:self.contentView];
|
|
[self.contentView autoPinWidthToSuperview];
|
|
[self.contentView autoPinToTopLayoutGuideOfViewController:self withInset:0];
|
|
|
|
self.footerBar = [UIToolbar new];
|
|
_footerBar.barTintColor = [UIColor ows_signalBrandBlueColor];
|
|
[self.footerBar setItems:@[
|
|
[[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemFlexibleSpace target:nil action:nil],
|
|
[[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemAction
|
|
target:self
|
|
action:@selector(shareWasPressed:)],
|
|
[[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemFlexibleSpace target:nil action:nil],
|
|
]
|
|
animated:NO];
|
|
[self.backgroundView addSubview:self.footerBar];
|
|
[self.footerBar autoPinWidthToSuperview];
|
|
[self.footerBar autoPinToBottomLayoutGuideOfViewController:self withInset:0];
|
|
[self.footerBar autoPinEdge:ALEdgeTop toEdge:ALEdgeBottom ofView:self.contentView];
|
|
}
|
|
|
|
- (void)shareWasPressed:(id)sender {
|
|
DDLogInfo(@"%@: sharing image.", self.tag);
|
|
|
|
[AttachmentSharing showShareUIForURL:[self.attachmentStream mediaURL]];
|
|
}
|
|
|
|
- (void)initializeScrollView {
|
|
self.scrollView = [[UIScrollView alloc] initWithFrame:self.view.bounds];
|
|
self.scrollView.delegate = self;
|
|
self.scrollView.zoomScale = 1.0f;
|
|
self.scrollView.maximumZoomScale = kMaxZoomScale;
|
|
self.scrollView.scrollEnabled = NO;
|
|
[self.contentView addSubview:self.scrollView];
|
|
}
|
|
|
|
- (BOOL)isAnimated
|
|
{
|
|
OWSAssert(self.attachmentStream);
|
|
|
|
return self.attachmentStream.isAnimated;
|
|
}
|
|
|
|
- (void)initializeImageView {
|
|
if (self.isAnimated) {
|
|
if ([self.fileData ows_isValidImage]) {
|
|
YYImage *animatedGif = [YYImage imageWithData:self.fileData];
|
|
YYAnimatedImageView *imageView = [[YYAnimatedImageView alloc] init];
|
|
imageView.image = animatedGif;
|
|
imageView.frame = self.originRect;
|
|
imageView.contentMode = UIViewContentModeScaleAspectFill;
|
|
imageView.clipsToBounds = YES;
|
|
self.imageView = imageView;
|
|
} else {
|
|
self.imageView = [[UIImageView alloc] initWithFrame:self.originRect];
|
|
}
|
|
} else {
|
|
// Present the static image using standard UIImageView
|
|
self.imageView = [[UIImageView alloc] initWithFrame:self.originRect];
|
|
self.imageView.contentMode = UIViewContentModeScaleAspectFill;
|
|
self.imageView.userInteractionEnabled = YES;
|
|
self.imageView.clipsToBounds = YES;
|
|
self.imageView.layer.allowsEdgeAntialiasing = YES;
|
|
// Use trilinear filters for better scaling quality at
|
|
// some performance cost.
|
|
self.imageView.layer.minificationFilter = kCAFilterTrilinear;
|
|
self.imageView.layer.magnificationFilter = kCAFilterTrilinear;
|
|
}
|
|
|
|
[self.scrollView addSubview:self.imageView];
|
|
}
|
|
|
|
- (void)populateImageView:(UIImage *)image {
|
|
if (image && !self.isAnimated) {
|
|
self.imageView.image = image;
|
|
}
|
|
}
|
|
|
|
- (void)initializeGestureRecognizers {
|
|
UITapGestureRecognizer *singleTap = [[UITapGestureRecognizer alloc] initWithTarget:self
|
|
action:@selector(imageDismissGesture:)];
|
|
singleTap.delegate = self;
|
|
[self.view addGestureRecognizer:singleTap];
|
|
|
|
UITapGestureRecognizer *doubleTap = [[UITapGestureRecognizer alloc] initWithTarget:self
|
|
action:@selector(imageDismissGesture:)];
|
|
doubleTap.numberOfTapsRequired = 2;
|
|
doubleTap.delegate = self;
|
|
[self.view addGestureRecognizer:doubleTap];
|
|
|
|
// UISwipeGestureRecognizer supposedly supports multiple directions,
|
|
// but in practice it works better if you use a separate GR for each
|
|
// direction.
|
|
for (NSNumber *direction in @[
|
|
@(UISwipeGestureRecognizerDirectionRight),
|
|
@(UISwipeGestureRecognizerDirectionLeft),
|
|
@(UISwipeGestureRecognizerDirectionUp),
|
|
@(UISwipeGestureRecognizerDirectionDown),
|
|
]) {
|
|
UISwipeGestureRecognizer *swipe = [[UISwipeGestureRecognizer alloc] initWithTarget:self
|
|
action:@selector(imageDismissGesture:)];
|
|
swipe.direction = (UISwipeGestureRecognizerDirection) direction.integerValue;
|
|
swipe.delegate = self;
|
|
[self.view addGestureRecognizer:swipe];
|
|
}
|
|
|
|
UILongPressGestureRecognizer *longPress = [[UILongPressGestureRecognizer alloc] initWithTarget:self
|
|
action:@selector(longPressGesture:)];
|
|
longPress.delegate = self;
|
|
[self.view addGestureRecognizer:longPress];
|
|
}
|
|
|
|
#pragma mark - Gesture Recognizers
|
|
|
|
- (void)imageDismissGesture:(UIGestureRecognizer *)sender {
|
|
if (sender.state == UIGestureRecognizerStateRecognized) {
|
|
[self dismiss];
|
|
}
|
|
}
|
|
|
|
- (void)longPressGesture:(UIGestureRecognizer *)sender {
|
|
// We "eagerly" respond when the long press begins, not when it ends.
|
|
if (sender.state == UIGestureRecognizerStateBegan) {
|
|
|
|
[self.view becomeFirstResponder];
|
|
|
|
if ([UIMenuController sharedMenuController].isMenuVisible) {
|
|
[[UIMenuController sharedMenuController] setMenuVisible:NO
|
|
animated:NO];
|
|
}
|
|
|
|
NSArray *menuItems = self.viewItem.menuControllerItems;
|
|
if (!self.oldMenuItems) {
|
|
self.oldMenuItems = [UIMenuController sharedMenuController].menuItems;
|
|
}
|
|
[UIMenuController sharedMenuController].menuItems = menuItems;
|
|
CGPoint location = [sender locationInView:self.view];
|
|
CGRect targetRect = CGRectMake(location.x,
|
|
location.y,
|
|
1, 1);
|
|
[[UIMenuController sharedMenuController] setTargetRect:targetRect
|
|
inView:self.view];
|
|
[[UIMenuController sharedMenuController] setMenuVisible:YES
|
|
animated:YES];
|
|
}
|
|
}
|
|
|
|
- (BOOL)canPerformAction:(SEL)action withSender:(nullable id)sender
|
|
{
|
|
if (action == self.viewItem.metadataActionSelector) {
|
|
return NO;
|
|
}
|
|
return [self.viewItem canPerformAction:action];
|
|
}
|
|
|
|
- (void)copyAction:(nullable id)sender
|
|
{
|
|
[self.viewItem copyAction];
|
|
}
|
|
|
|
- (void)shareAction:(nullable id)sender
|
|
{
|
|
[self.viewItem shareAction];
|
|
}
|
|
|
|
- (void)saveAction:(nullable id)sender
|
|
{
|
|
[self.viewItem saveAction];
|
|
}
|
|
|
|
- (void)deleteAction:(nullable id)sender
|
|
{
|
|
[self.viewItem deleteAction];
|
|
|
|
[self dismiss];
|
|
}
|
|
|
|
- (BOOL)canBecomeFirstResponder
|
|
{
|
|
return YES;
|
|
}
|
|
|
|
#pragma mark - Presentation
|
|
|
|
- (void)presentFromViewController:(UIViewController *)viewController {
|
|
_isPresenting = YES;
|
|
self.view.userInteractionEnabled = NO;
|
|
[self.view addSubview:self.imageView];
|
|
self.modalPresentationStyle = UIModalPresentationOverCurrentContext;
|
|
self.view.alpha = 0;
|
|
|
|
[viewController
|
|
presentViewController:self
|
|
animated:NO
|
|
completion:^{
|
|
UIWindow *window = [UIApplication sharedApplication].keyWindow;
|
|
// During the presentation animation, we want to seamlessly animate the image
|
|
// from its location in the conversation view. To do so, we need a
|
|
// consistent coordinate system, so we pass the `originRect` in the
|
|
// coordinate system of the window.
|
|
self.imageView.frame = [self.view convertRect:self.originRect
|
|
fromView:window];
|
|
|
|
[UIView animateWithDuration:0.25f
|
|
delay:0
|
|
options:UIViewAnimationOptionBeginFromCurrentState | UIViewAnimationOptionCurveEaseOut
|
|
animations:^() {
|
|
self.view.alpha = 1.0f;
|
|
// During the presentation animation, we want to seamlessly animate the image
|
|
// to its resting location in this view. We use `resizedFrameForImageView`
|
|
// to determine its size "at rest" in the content view, and then convert
|
|
// from the content view's coordinate system to the root view coordinate
|
|
// system because the image view is temporarily hosted by the root view during
|
|
// the presentation animation.
|
|
self.imageView.frame = [self resizedFrameForImageView:self.image.size];
|
|
self.imageView.center = [self.contentView convertPoint:self.contentView.center
|
|
fromView:self.contentView];
|
|
}
|
|
completion:^(BOOL completed) {
|
|
self.scrollView.frame = self.contentView.bounds;
|
|
[self.scrollView addSubview:self.imageView];
|
|
[self updateLayouts];
|
|
self.view.userInteractionEnabled = YES;
|
|
_isPresenting = NO;
|
|
}];
|
|
[UIUtil modalCompletionBlock]();
|
|
}];
|
|
}
|
|
|
|
- (void)dismiss {
|
|
|
|
// Restore the edit menu items if necessary.
|
|
if (self.oldMenuItems) {
|
|
[UIMenuController sharedMenuController].menuItems = self.oldMenuItems;
|
|
}
|
|
|
|
self.view.userInteractionEnabled = NO;
|
|
[UIView animateWithDuration:0.25f
|
|
delay:0
|
|
options:UIViewAnimationOptionBeginFromCurrentState | UIViewAnimationOptionCurveLinear
|
|
animations:^() {
|
|
self.backgroundView.backgroundColor = [UIColor clearColor];
|
|
self.scrollView.alpha = 0;
|
|
self.view.alpha = 0;
|
|
}
|
|
completion:^(BOOL completed) {
|
|
[self.presentingViewController dismissViewControllerAnimated:NO completion:nil];
|
|
}];
|
|
}
|
|
|
|
#pragma mark - Update Layout
|
|
|
|
- (void)viewDidLayoutSubviews {
|
|
[self updateLayouts];
|
|
}
|
|
|
|
- (void)updateLayouts {
|
|
if (_isPresenting) {
|
|
return;
|
|
}
|
|
|
|
self.scrollView.frame = self.contentView.bounds;
|
|
self.imageView.frame = [self resizedFrameForImageView:self.image.size];
|
|
self.scrollView.contentSize = self.imageView.frame.size;
|
|
self.scrollView.contentInset = [self contentInsetForScrollView:self.scrollView.zoomScale];
|
|
}
|
|
|
|
#pragma mark - Resizing
|
|
|
|
- (CGRect)resizedFrameForImageView:(CGSize)imageSize {
|
|
CGRect frame = self.contentView.bounds;
|
|
CGSize screenSize =
|
|
CGSizeMake(frame.size.width * self.scrollView.zoomScale, frame.size.height * self.scrollView.zoomScale);
|
|
CGSize targetSize = screenSize;
|
|
|
|
if ([self isImagePortrait]) {
|
|
if ([self getAspectRatioForCGSize:screenSize] < [self getAspectRatioForCGSize:imageSize]) {
|
|
targetSize.width = screenSize.height / [self getAspectRatioForCGSize:imageSize];
|
|
} else {
|
|
targetSize.height = screenSize.width * [self getAspectRatioForCGSize:imageSize];
|
|
}
|
|
} else {
|
|
if ([self getAspectRatioForCGSize:screenSize] > [self getAspectRatioForCGSize:imageSize]) {
|
|
targetSize.height = screenSize.width * [self getAspectRatioForCGSize:imageSize];
|
|
} else {
|
|
targetSize.width = screenSize.height / [self getAspectRatioForCGSize:imageSize];
|
|
}
|
|
}
|
|
|
|
frame.size = targetSize;
|
|
frame.origin = CGPointMake(0, 0);
|
|
return frame;
|
|
}
|
|
|
|
- (UIEdgeInsets)contentInsetForScrollView:(CGFloat)targetZoomScale {
|
|
UIEdgeInsets inset = UIEdgeInsetsZero;
|
|
|
|
CGSize boundsSize = self.scrollView.bounds.size;
|
|
CGSize contentSize = self.image.size;
|
|
CGSize minSize;
|
|
|
|
if ([self isImagePortrait]) {
|
|
if ([self getAspectRatioForCGSize:boundsSize] < [self getAspectRatioForCGSize:contentSize]) {
|
|
minSize.height = boundsSize.height;
|
|
minSize.width = minSize.height / [self getAspectRatioForCGSize:contentSize];
|
|
} else {
|
|
minSize.width = boundsSize.width;
|
|
minSize.height = minSize.width * [self getAspectRatioForCGSize:contentSize];
|
|
}
|
|
} else {
|
|
if ([self getAspectRatioForCGSize:boundsSize] > [self getAspectRatioForCGSize:contentSize]) {
|
|
minSize.width = boundsSize.width;
|
|
minSize.height = minSize.width * [self getAspectRatioForCGSize:contentSize];
|
|
} else {
|
|
minSize.height = boundsSize.height;
|
|
minSize.width = minSize.height / [self getAspectRatioForCGSize:contentSize];
|
|
}
|
|
}
|
|
|
|
CGSize finalSize = self.view.bounds.size;
|
|
|
|
minSize.width *= targetZoomScale;
|
|
minSize.height *= targetZoomScale;
|
|
|
|
if (minSize.height > finalSize.height && minSize.width > finalSize.width) {
|
|
inset = UIEdgeInsetsZero;
|
|
} else {
|
|
CGFloat dy = boundsSize.height - minSize.height;
|
|
CGFloat dx = boundsSize.width - minSize.width;
|
|
|
|
dy = (dy > 0) ? dy : 0;
|
|
dx = (dx > 0) ? dx : 0;
|
|
|
|
inset.top = dy / 2.0f;
|
|
inset.bottom = dy / 2.0f;
|
|
inset.left = dx / 2.0f;
|
|
inset.right = dx / 2.0f;
|
|
}
|
|
return inset;
|
|
}
|
|
|
|
#pragma mark - UIScrollViewDelegate
|
|
|
|
- (nullable UIView *)viewForZoomingInScrollView:(UIScrollView *)scrollView
|
|
{
|
|
return self.imageView;
|
|
}
|
|
|
|
- (void)scrollViewDidZoom:(UIScrollView *)scrollView {
|
|
scrollView.contentInset = [self contentInsetForScrollView:scrollView.zoomScale];
|
|
|
|
if (self.scrollView.scrollEnabled == NO) {
|
|
self.scrollView.scrollEnabled = YES;
|
|
}
|
|
}
|
|
|
|
- (void)scrollViewDidEndZooming:(UIScrollView *)scrollView withView:(nullable UIView *)view atScale:(CGFloat)scale
|
|
{
|
|
self.scrollView.scrollEnabled = (scale > 1);
|
|
self.scrollView.contentInset = [self contentInsetForScrollView:scale];
|
|
}
|
|
|
|
#pragma mark - Utility
|
|
|
|
- (BOOL)isImagePortrait {
|
|
return ([self getAspectRatioForCGSize:self.image.size] > 1.0f);
|
|
}
|
|
|
|
- (CGFloat)getAspectRatioForCGSize:(CGSize)size {
|
|
return size.height / size.width;
|
|
}
|
|
|
|
|
|
#pragma mark - Saving images to Camera Roll
|
|
|
|
- (void)image:(UIImage *)image didFinishSavingWithError:(NSError *)error contextInfo:(void *)contextInfo {
|
|
if (error) {
|
|
DDLogWarn(@"There was a problem saving <%@> to camera roll from %s ",
|
|
error.localizedDescription,
|
|
__PRETTY_FUNCTION__);
|
|
}
|
|
}
|
|
|
|
#pragma mark - Logging
|
|
|
|
+ (NSString *)tag
|
|
{
|
|
return [NSString stringWithFormat:@"[%@]", self.class];
|
|
}
|
|
|
|
- (NSString *)tag
|
|
{
|
|
return self.class.tag;
|
|
}
|
|
|
|
@end
|
|
|
|
NS_ASSUME_NONNULL_END
|