mirror of
https://github.com/amnezia-vpn/amnezia-client.git
synced 2026-06-23 02:00:20 +07:00
dranik
868 lines
34 KiB
Plaintext
868 lines
34 KiB
Plaintext
#include "platforms/ios/iosPairingQrOverlayWindow.h"
|
|
|
|
#import <UIKit/UIKit.h>
|
|
#import <AVFoundation/AVFoundation.h>
|
|
#import <QuartzCore/QuartzCore.h>
|
|
#import <math.h>
|
|
|
|
#include <string>
|
|
|
|
/** Qt on iOS may use a high window level; stay clearly above the main QQuick window. */
|
|
static const CGFloat kAmneziaPairingQrOverlayWindowLevel = (CGFloat)UIWindowLevelAlert + 1000.f;
|
|
|
|
static AmneziaPairingQrScannedUtf8Handler gOnScanned;
|
|
static AmneziaPairingQrOverlayBackHandler gOnBack;
|
|
static UIWindow *gPairingQrOverlayWindow = nil;
|
|
static bool gTorchRequested = false;
|
|
/** Last time overlay became key; used to ignore restartCapture during warm-up (see QML kick timer removal). */
|
|
static CFAbsoluteTime gPairingQrOverlayKeySince = -1.0;
|
|
|
|
static UIWindowScene *amneziaForegroundWindowScene(void)
|
|
{
|
|
for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
|
|
if (scene.activationState == UISceneActivationStateForegroundActive
|
|
&& [scene isKindOfClass:[UIWindowScene class]]) {
|
|
return (UIWindowScene *)scene;
|
|
}
|
|
}
|
|
for (UIScene *scene in UIApplication.sharedApplication.connectedScenes) {
|
|
if ([scene isKindOfClass:[UIWindowScene class]]) {
|
|
return (UIWindowScene *)scene;
|
|
}
|
|
}
|
|
return nil;
|
|
}
|
|
|
|
static UIWindow *amneziaPickQtAppWindowToRestore(void)
|
|
{
|
|
UIWindow *best = nil;
|
|
for (UIWindow *cw in UIApplication.sharedApplication.windows) {
|
|
if (cw == gPairingQrOverlayWindow || cw.hidden) {
|
|
continue;
|
|
}
|
|
if (cw.windowScene && cw.windowLevel <= UIWindowLevelNormal + 1) {
|
|
if (!best || cw.isKeyWindow) {
|
|
best = cw;
|
|
}
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
/** Height left uncovered at the bottom so the Qt tab bar on QUIWindow stays visible. */
|
|
static CGFloat amneziaPairingQrBottomTabStripReserve(UIWindowScene *scene)
|
|
{
|
|
Class qios = NSClassFromString(@"QIOSViewController");
|
|
if (!qios) {
|
|
return 83.f;
|
|
}
|
|
for (UIWindow *cw in scene.windows) {
|
|
if (!cw.rootViewController) {
|
|
continue;
|
|
}
|
|
if ([cw.rootViewController isKindOfClass:qios]) {
|
|
const CGFloat inset = cw.safeAreaInsets.bottom;
|
|
const CGFloat reserve = inset + 49.f;
|
|
return MIN(MAX(reserve, 72.f), 140.f);
|
|
}
|
|
}
|
|
return 83.f;
|
|
}
|
|
|
|
static void amneziaApplyReadableOverCameraShadow(UIView *v)
|
|
{
|
|
v.layer.shadowColor = [UIColor blackColor].CGColor;
|
|
v.layer.shadowOffset = CGSizeMake(0, 1);
|
|
v.layer.shadowRadius = 4;
|
|
v.layer.shadowOpacity = 0.9;
|
|
v.layer.masksToBounds = NO;
|
|
}
|
|
|
|
/** AmneziaStyle.color.paleGray — same as BackButtonType / BaseHeaderType on QML pages. */
|
|
static UIColor *amneziaPaleGray(void)
|
|
{
|
|
return [UIColor colorWithRed:(CGFloat)0xD7 / 255.0 green:(CGFloat)0xD8 / 255.0 blue:(CGFloat)0xDB / 255.0 alpha:1.0];
|
|
}
|
|
|
|
/** Quarter circle from S to E on (C, r). Normalizes end angle vs start so Δ∈(−π,π]; clockwise from minor sign (same as working TR/TL). */
|
|
static void amneziaAddCornerMinorArc(UIBezierPath *p, CGPoint C, CGFloat r, CGPoint S, CGPoint E)
|
|
{
|
|
const CGFloat as = atan2f((float)(S.y - C.y), (float)(S.x - C.x));
|
|
CGFloat ae = atan2f((float)(E.y - C.y), (float)(E.x - C.x));
|
|
while (ae - as > (CGFloat)M_PI) {
|
|
ae -= (CGFloat)(2.0 * M_PI);
|
|
}
|
|
while (ae - as < (CGFloat)(-M_PI)) {
|
|
ae += (CGFloat)(2.0 * M_PI);
|
|
}
|
|
const CGFloat minor = ae - as;
|
|
const BOOL cw = minor > 0;
|
|
[p addArcWithCenter:C radius:r startAngle:as endAngle:ae clockwise:cw];
|
|
}
|
|
|
|
/**
|
|
* Stroked L per corner: own geometry + shared minor-arc helper.
|
|
* corner: 0=TL, 1=TR, 2=BL, 3=BR.
|
|
*/
|
|
static UIBezierPath *amneziaScanBracketStrokePath(int corner, CGFloat x0, CGFloat y0, CGFloat s, CGFloat R, CGFloat L, CGFloat t)
|
|
{
|
|
const CGFloat r = MAX(1.5, R - t * 0.5);
|
|
UIBezierPath *p = [UIBezierPath bezierPath];
|
|
const CGFloat yy = y0 + t * 0.5f;
|
|
const CGFloat yyb = y0 + s - t * 0.5f;
|
|
const CGFloat xx = x0 + t * 0.5f;
|
|
const CGFloat xxb = x0 + s - t * 0.5f;
|
|
|
|
switch (corner) {
|
|
case 0: { /* top-left */
|
|
const CGPoint cTL = CGPointMake(x0 + R, y0 + R);
|
|
const CGPoint sTL = CGPointMake(x0 + R, yy);
|
|
const CGPoint eTL = CGPointMake(xx, y0 + R);
|
|
[p moveToPoint:CGPointMake(x0 + R + L, yy)];
|
|
[p addLineToPoint:sTL];
|
|
amneziaAddCornerMinorArc(p, cTL, r, sTL, eTL);
|
|
const CGFloat yEndTL = MIN(y0 + R + L, y0 + s - R - t * 0.5f);
|
|
[p addLineToPoint:CGPointMake(xx, MAX(yEndTL, y0 + R + 2.f))];
|
|
} break;
|
|
case 1: { /* top-right — keep explicit angles (reference for helper tuning). */
|
|
const CGPoint cTR = CGPointMake(x0 + s - R, y0 + R);
|
|
const CGPoint sTR = CGPointMake(x0 + s - R, yy);
|
|
const CGPoint eTR = CGPointMake(xxb, y0 + R);
|
|
[p moveToPoint:CGPointMake(x0 + s - R - L, yy)];
|
|
[p addLineToPoint:sTR];
|
|
amneziaAddCornerMinorArc(p, cTR, r, sTR, eTR);
|
|
const CGFloat yEndTR = MIN(y0 + R + L, y0 + s - R - t * 0.5f);
|
|
[p addLineToPoint:CGPointMake(xxb, MAX(yEndTR, y0 + R + 2.f))];
|
|
} break;
|
|
case 2: { /* bottom-left — mirror TL: approach (R+L,yyb)→(R,yyb) like (R+L,yy)→(R,yy); leg Y = reflect top leg in y_mid=y0+s/2. */
|
|
const CGPoint cBL = CGPointMake(x0 + R, y0 + s - R);
|
|
const CGPoint sBL = CGPointMake(x0 + R, yyb);
|
|
const CGPoint eBL = CGPointMake(xx, y0 + s - R);
|
|
[p moveToPoint:CGPointMake(x0 + R + L, yyb)];
|
|
[p addLineToPoint:sBL];
|
|
amneziaAddCornerMinorArc(p, cBL, r, sBL, eBL);
|
|
const CGFloat yEndTopRef = MAX(MIN(y0 + R + L, y0 + s - R - t * 0.5f), y0 + R + 2.f);
|
|
const CGFloat yLegBL = y0 + s + y0 - yEndTopRef;
|
|
[p addLineToPoint:CGPointMake(xx, yLegBL)];
|
|
} break;
|
|
case 3: { /* bottom-right — mirror TR: (s-R-L,yyb)→(s-R,yyb); leg Y same reflection as BL. */
|
|
const CGPoint cBR = CGPointMake(x0 + s - R, y0 + s - R);
|
|
const CGPoint sBR = CGPointMake(x0 + s - R, yyb);
|
|
const CGPoint eBR = CGPointMake(xxb, y0 + s - R);
|
|
[p moveToPoint:CGPointMake(x0 + s - R - L, yyb)];
|
|
[p addLineToPoint:sBR];
|
|
amneziaAddCornerMinorArc(p, cBR, r, sBR, eBR);
|
|
const CGFloat yEndTopRef = MAX(MIN(y0 + R + L, y0 + s - R - t * 0.5f), y0 + R + 2.f);
|
|
const CGFloat yLegBR = y0 + s + y0 - yEndTopRef;
|
|
[p addLineToPoint:CGPointMake(xxb, yLegBR)];
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
@interface AmneziaPairingQrOverlayViewController : UIViewController
|
|
@end
|
|
|
|
@interface AmneziaPairingQrOverlayViewController () <AVCaptureMetadataOutputObjectsDelegate>
|
|
@property (nonatomic, strong) AVCaptureSession *captureSession;
|
|
@property (nonatomic, strong) AVCaptureMetadataOutput *metadataOutput;
|
|
@property (nonatomic, strong) AVCaptureVideoPreviewLayer *previewLayer;
|
|
@property (nonatomic, strong) AVCaptureDevice *videoDevice;
|
|
@property (nonatomic, strong) dispatch_queue_t sessionQueue;
|
|
@property (nonatomic, strong) UIView *cameraContainer;
|
|
@property (nonatomic, strong) UIView *headerContainer;
|
|
@property (nonatomic, strong) UIButton *backButton;
|
|
@property (nonatomic, strong) UILabel *titleLabel;
|
|
@property (nonatomic, strong) UILabel *subtitleLabel;
|
|
@property (nonatomic, strong) UIButton *torchButton;
|
|
@property (nonatomic, strong) NSLayoutConstraint *torchCenterYConstraint;
|
|
@property (nonatomic, copy) NSString *chromeTitleText;
|
|
@property (nonatomic, copy) NSString *chromeSubtitleText;
|
|
@property (nonatomic, strong) UIView *scanDimView;
|
|
@property (nonatomic, strong) CAShapeLayer *scanDimMaskLayer;
|
|
/** Milky highlight inside the scan hole (below dim), same rounded rect as mask. */
|
|
@property (nonatomic, strong) UIView *scanHoleFillView;
|
|
@property (nonatomic, strong) CAShapeLayer *scanHoleHighlightLayer;
|
|
@property (nonatomic, strong) UIView *bracketContainer;
|
|
/** Four CAShapeLayers: TL, TR, BL, BR — stroked L-brackets following scan hole corner radius. */
|
|
@property (nonatomic, strong) NSMutableArray<CAShapeLayer *> *bracketCornerLayers;
|
|
@end
|
|
|
|
@implementation AmneziaPairingQrOverlayViewController
|
|
|
|
- (void)viewDidLoad
|
|
{
|
|
[super viewDidLoad];
|
|
self.view.backgroundColor = [UIColor clearColor];
|
|
if (!self.sessionQueue) {
|
|
self.sessionQueue = dispatch_queue_create("org.amnezia.pairingqr.overlay", DISPATCH_QUEUE_SERIAL);
|
|
}
|
|
[self buildChromeUi];
|
|
}
|
|
|
|
- (void)buildChromeUi
|
|
{
|
|
if (self.headerContainer) {
|
|
return;
|
|
}
|
|
UIView *cam = [[UIView alloc] init];
|
|
cam.translatesAutoresizingMaskIntoConstraints = NO;
|
|
cam.backgroundColor = [UIColor clearColor];
|
|
cam.clipsToBounds = YES;
|
|
self.cameraContainer = cam;
|
|
[self.view addSubview:cam];
|
|
|
|
UIView *holeFill = [[UIView alloc] init];
|
|
holeFill.translatesAutoresizingMaskIntoConstraints = NO;
|
|
holeFill.backgroundColor = [UIColor clearColor];
|
|
holeFill.opaque = NO;
|
|
holeFill.userInteractionEnabled = NO;
|
|
self.scanHoleFillView = holeFill;
|
|
CAShapeLayer *hi = [CAShapeLayer layer];
|
|
hi.fillColor = [UIColor colorWithWhite:1.0 alpha:0.14].CGColor;
|
|
hi.strokeColor = nil;
|
|
[holeFill.layer addSublayer:hi];
|
|
self.scanHoleHighlightLayer = hi;
|
|
[self.view addSubview:holeFill];
|
|
|
|
UIView *dim = [[UIView alloc] init];
|
|
dim.translatesAutoresizingMaskIntoConstraints = NO;
|
|
dim.backgroundColor = [UIColor colorWithWhite:0.02 alpha:0.55];
|
|
dim.userInteractionEnabled = NO;
|
|
dim.opaque = NO;
|
|
self.scanDimView = dim;
|
|
[self.view addSubview:dim];
|
|
|
|
CAShapeLayer *dimMask = [CAShapeLayer layer];
|
|
dimMask.fillRule = kCAFillRuleEvenOdd;
|
|
dimMask.fillColor = [UIColor blackColor].CGColor;
|
|
dim.layer.mask = dimMask;
|
|
self.scanDimMaskLayer = dimMask;
|
|
|
|
UIView *bracketHost = [[UIView alloc] init];
|
|
bracketHost.translatesAutoresizingMaskIntoConstraints = NO;
|
|
bracketHost.backgroundColor = [UIColor clearColor];
|
|
bracketHost.opaque = NO;
|
|
bracketHost.userInteractionEnabled = NO;
|
|
self.bracketContainer = bracketHost;
|
|
[self.view addSubview:bracketHost];
|
|
|
|
self.bracketCornerLayers = [NSMutableArray arrayWithCapacity:4];
|
|
for (NSInteger i = 0; i < 4; i++) {
|
|
CAShapeLayer *sl = [CAShapeLayer layer];
|
|
sl.fillColor = nil;
|
|
sl.strokeColor = [UIColor colorWithWhite:0.94 alpha:1].CGColor;
|
|
sl.lineWidth = 5.0;
|
|
sl.lineCap = kCALineCapRound;
|
|
sl.lineJoin = kCALineJoinRound;
|
|
[bracketHost.layer addSublayer:sl];
|
|
[self.bracketCornerLayers addObject:sl];
|
|
}
|
|
|
|
UIView *header = [[UIView alloc] init];
|
|
header.translatesAutoresizingMaskIntoConstraints = NO;
|
|
header.backgroundColor = [UIColor clearColor];
|
|
header.opaque = NO;
|
|
header.userInteractionEnabled = YES;
|
|
self.headerContainer = header;
|
|
[self.view addSubview:header];
|
|
|
|
UIButton *back = [UIButton buttonWithType:UIButtonTypeSystem];
|
|
back.translatesAutoresizingMaskIntoConstraints = NO;
|
|
back.tintColor = amneziaPaleGray();
|
|
if (@available(iOS 13.0, *)) {
|
|
const CGFloat kBackArrowPt = 20.0;
|
|
UIImageSymbolConfiguration *sym =
|
|
[UIImageSymbolConfiguration configurationWithPointSize:kBackArrowPt weight:UIImageSymbolWeightMedium
|
|
scale:UIImageSymbolScaleDefault];
|
|
UIImage *img = [UIImage systemImageNamed:@"arrow.left" withConfiguration:sym];
|
|
[back setImage:[img imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate] forState:UIControlStateNormal];
|
|
} else {
|
|
[back setTitle:@"<" forState:UIControlStateNormal];
|
|
}
|
|
[back addTarget:self action:@selector(backTapped) forControlEvents:UIControlEventTouchUpInside];
|
|
self.backButton = back;
|
|
[header addSubview:back];
|
|
|
|
UILabel *title = [[UILabel alloc] init];
|
|
title.translatesAutoresizingMaskIntoConstraints = NO;
|
|
title.textColor = [UIColor colorWithWhite:0.96 alpha:1];
|
|
title.font = [UIFont systemFontOfSize:22 weight:UIFontWeightBold];
|
|
title.numberOfLines = 0;
|
|
title.text = self.chromeTitleText.length ? self.chromeTitleText : @"Add device via QR";
|
|
self.titleLabel = title;
|
|
[header addSubview:title];
|
|
amneziaApplyReadableOverCameraShadow(title);
|
|
|
|
UILabel *sub = [[UILabel alloc] init];
|
|
sub.translatesAutoresizingMaskIntoConstraints = NO;
|
|
sub.textColor = [UIColor colorWithWhite:0.88 alpha:0.95];
|
|
sub.font = [UIFont systemFontOfSize:14 weight:UIFontWeightRegular];
|
|
sub.numberOfLines = 0;
|
|
sub.text = self.chromeSubtitleText.length
|
|
? self.chromeSubtitleText
|
|
: @"Scan the session QR shown on the device you want to add.";
|
|
self.subtitleLabel = sub;
|
|
[header addSubview:sub];
|
|
amneziaApplyReadableOverCameraShadow(sub);
|
|
|
|
UIButton *torch = [UIButton buttonWithType:UIButtonTypeSystem];
|
|
torch.translatesAutoresizingMaskIntoConstraints = NO;
|
|
[torch setTitle:@"🔦" forState:UIControlStateNormal];
|
|
torch.titleLabel.font = [UIFont systemFontOfSize:26];
|
|
torch.backgroundColor = [[UIColor whiteColor] colorWithAlphaComponent:0.22];
|
|
torch.layer.cornerRadius = 28;
|
|
torch.clipsToBounds = YES;
|
|
[torch addTarget:self action:@selector(torchTapped) forControlEvents:UIControlEventTouchUpInside];
|
|
self.torchButton = torch;
|
|
[self.view addSubview:torch];
|
|
|
|
UILayoutGuide *safe = self.view.safeAreaLayoutGuide;
|
|
[NSLayoutConstraint activateConstraints:@[
|
|
[cam.topAnchor constraintEqualToAnchor:self.view.topAnchor],
|
|
[cam.leadingAnchor constraintEqualToAnchor:self.view.leadingAnchor],
|
|
[cam.trailingAnchor constraintEqualToAnchor:self.view.trailingAnchor],
|
|
[cam.bottomAnchor constraintEqualToAnchor:self.view.bottomAnchor],
|
|
|
|
[holeFill.topAnchor constraintEqualToAnchor:self.view.topAnchor],
|
|
[holeFill.leadingAnchor constraintEqualToAnchor:self.view.leadingAnchor],
|
|
[holeFill.trailingAnchor constraintEqualToAnchor:self.view.trailingAnchor],
|
|
[holeFill.bottomAnchor constraintEqualToAnchor:self.view.bottomAnchor],
|
|
|
|
[dim.topAnchor constraintEqualToAnchor:self.view.topAnchor],
|
|
[dim.leadingAnchor constraintEqualToAnchor:self.view.leadingAnchor],
|
|
[dim.trailingAnchor constraintEqualToAnchor:self.view.trailingAnchor],
|
|
[dim.bottomAnchor constraintEqualToAnchor:self.view.bottomAnchor],
|
|
|
|
[bracketHost.topAnchor constraintEqualToAnchor:self.view.topAnchor],
|
|
[bracketHost.leadingAnchor constraintEqualToAnchor:self.view.leadingAnchor],
|
|
[bracketHost.trailingAnchor constraintEqualToAnchor:self.view.trailingAnchor],
|
|
[bracketHost.bottomAnchor constraintEqualToAnchor:self.view.bottomAnchor],
|
|
|
|
[header.topAnchor constraintEqualToAnchor:safe.topAnchor],
|
|
[header.leadingAnchor constraintEqualToAnchor:self.view.leadingAnchor],
|
|
[header.trailingAnchor constraintEqualToAnchor:self.view.trailingAnchor],
|
|
[header.heightAnchor constraintGreaterThanOrEqualToConstant:120],
|
|
|
|
[back.leadingAnchor constraintEqualToAnchor:header.leadingAnchor constant:8],
|
|
[back.topAnchor constraintEqualToAnchor:header.topAnchor constant:20],
|
|
[back.widthAnchor constraintEqualToConstant:40],
|
|
[back.heightAnchor constraintEqualToConstant:40],
|
|
|
|
[title.leadingAnchor constraintEqualToAnchor:header.leadingAnchor constant:16],
|
|
[title.trailingAnchor constraintEqualToAnchor:header.trailingAnchor constant:-16],
|
|
[title.topAnchor constraintEqualToAnchor:back.bottomAnchor],
|
|
|
|
[sub.leadingAnchor constraintEqualToAnchor:title.leadingAnchor],
|
|
[sub.trailingAnchor constraintEqualToAnchor:title.trailingAnchor],
|
|
[sub.topAnchor constraintEqualToAnchor:title.bottomAnchor constant:8],
|
|
[sub.bottomAnchor constraintEqualToAnchor:header.bottomAnchor constant:-10],
|
|
|
|
[torch.topAnchor constraintGreaterThanOrEqualToAnchor:header.bottomAnchor constant:8],
|
|
[torch.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
|
|
[torch.widthAnchor constraintEqualToConstant:56],
|
|
[torch.heightAnchor constraintEqualToConstant:56],
|
|
]];
|
|
NSLayoutConstraint *torchCy = [torch.centerYAnchor constraintEqualToAnchor:self.view.topAnchor constant:200.0];
|
|
self.torchCenterYConstraint = torchCy;
|
|
torchCy.active = YES;
|
|
[header setContentHuggingPriority:UILayoutPriorityRequired forAxis:UILayoutConstraintAxisVertical];
|
|
[header setContentCompressionResistancePriority:UILayoutPriorityRequired forAxis:UILayoutConstraintAxisVertical];
|
|
}
|
|
|
|
/** Maps the on-screen scan hole to `AVCaptureMetadataOutput.rectOfInterest` (normalized), via preview layer. */
|
|
- (void)applyMetadataRectOfInterestForScanHole:(CGRect)holeInScanDimBounds
|
|
{
|
|
if (!self.previewLayer || !self.metadataOutput || !self.scanDimView || !self.cameraContainer) {
|
|
return;
|
|
}
|
|
if (CGRectIsEmpty(holeInScanDimBounds) || holeInScanDimBounds.size.width < 24.0 || holeInScanDimBounds.size.height < 24.0) {
|
|
return;
|
|
}
|
|
|
|
CGRect holeInCam = [self.scanDimView convertRect:holeInScanDimBounds toView:self.cameraContainer];
|
|
holeInCam = CGRectIntersection(holeInCam, self.cameraContainer.bounds);
|
|
if (CGRectIsEmpty(holeInCam)) {
|
|
return;
|
|
}
|
|
|
|
const CGRect plFrame = self.previewLayer.frame;
|
|
CGRect holeInPreview = CGRectOffset(holeInCam, -plFrame.origin.x, -plFrame.origin.y);
|
|
holeInPreview = CGRectIntersection(holeInPreview, self.previewLayer.bounds);
|
|
if (CGRectIsEmpty(holeInPreview)) {
|
|
return;
|
|
}
|
|
|
|
CGRect roi = [self.previewLayer metadataOutputRectOfInterestForRect:holeInPreview];
|
|
roi.origin.x = MAX(0.0, MIN(1.0, roi.origin.x));
|
|
roi.origin.y = MAX(0.0, MIN(1.0, roi.origin.y));
|
|
roi.size.width = MAX(0.02, MIN(1.0 - roi.origin.x, roi.size.width));
|
|
roi.size.height = MAX(0.02, MIN(1.0 - roi.origin.y, roi.size.height));
|
|
|
|
AVCaptureMetadataOutput *mo = self.metadataOutput;
|
|
dispatch_queue_t sq = self.sessionQueue;
|
|
if (!mo || !sq) {
|
|
return;
|
|
}
|
|
dispatch_async(sq, ^{
|
|
mo.rectOfInterest = roi;
|
|
});
|
|
}
|
|
|
|
- (void)layoutScanOverlayGeometry
|
|
{
|
|
if (!self.scanDimView || !self.scanDimMaskLayer || !self.scanHoleHighlightLayer || self.bracketCornerLayers.count != 4) {
|
|
return;
|
|
}
|
|
const CGRect vb = self.scanDimView.bounds;
|
|
if (vb.size.width < 32 || vb.size.height < 32) {
|
|
return;
|
|
}
|
|
|
|
CGFloat sqSz = floor(MIN(vb.size.width, vb.size.height) * 0.72);
|
|
CGFloat sqX = (vb.size.width - sqSz) / 2.0;
|
|
CGFloat sqY = (vb.size.height - sqSz) / 2.0;
|
|
|
|
CGFloat headerBottom = CGRectGetMaxY(self.headerContainer.frame);
|
|
if (headerBottom < 8.0) {
|
|
headerBottom = 132.0 + self.view.safeAreaInsets.top;
|
|
}
|
|
sqY = MAX(sqY, headerBottom + 8.0);
|
|
|
|
/** Keep a band below the scan hole for the torch (avoids coupling hole layout to previous torch frame). */
|
|
const CGFloat kBottomBandForTorch = 80.0;
|
|
const CGFloat maxHoleBottom = vb.size.height - kBottomBandForTorch;
|
|
if (sqY + sqSz > maxHoleBottom) {
|
|
sqY = maxHoleBottom - sqSz;
|
|
sqY = MAX(sqY, headerBottom + 8.0);
|
|
}
|
|
|
|
sqX = MAX(8.0, MIN(sqX, vb.size.width - sqSz - 8.0));
|
|
sqY = MAX(headerBottom + 4.0, MIN(sqY, vb.size.height - sqSz - 8.0));
|
|
|
|
const CGRect hole = CGRectMake(sqX, sqY, sqSz, sqSz);
|
|
/** Corner radius of the scan “window” (dim cut-out + inner highlight); matches reference UI. */
|
|
CGFloat holeR = MIN(28.0, MAX(10.0, sqSz * 0.056));
|
|
{
|
|
const CGFloat half = 0.5 * MIN(hole.size.width, hole.size.height);
|
|
holeR = MIN(holeR, MAX(6.0, half - 2.0));
|
|
}
|
|
UIBezierPath *holeRoundPath = [UIBezierPath bezierPathWithRoundedRect:hole cornerRadius:holeR];
|
|
|
|
UIBezierPath *path = [UIBezierPath bezierPathWithRect:vb];
|
|
[path appendPath:holeRoundPath];
|
|
self.scanDimMaskLayer.frame = vb;
|
|
self.scanDimMaskLayer.path = path.CGPath;
|
|
|
|
self.scanHoleHighlightLayer.frame = CGRectMake(0, 0, vb.size.width, vb.size.height);
|
|
self.scanHoleHighlightLayer.path = holeRoundPath.CGPath;
|
|
|
|
const CGFloat bracketThick = 5.0;
|
|
const CGFloat bracketLen = (CGFloat)MAX(28, (NSInteger)floor(sqSz * 0.13));
|
|
const CGFloat x0 = hole.origin.x;
|
|
const CGFloat y0 = hole.origin.y;
|
|
const CGFloat s = hole.size.width;
|
|
|
|
const CGFloat t = bracketThick;
|
|
const CGFloat L = bracketLen;
|
|
|
|
for (NSUInteger i = 0; i < 4; i++) {
|
|
CAShapeLayer *layer = self.bracketCornerLayers[i];
|
|
layer.lineWidth = t;
|
|
layer.path = amneziaScanBracketStrokePath((int)i, x0, y0, s, holeR, L, t).CGPath;
|
|
}
|
|
|
|
/** Torch vertically centered between scan hole bottom and overlay bottom (top of Qt tab strip below window). */
|
|
if (self.torchCenterYConstraint && self.torchButton) {
|
|
const CGFloat holeBottom = CGRectGetMaxY(hole);
|
|
const CGFloat bandBottom = vb.size.height;
|
|
const CGFloat torchH = 56.0;
|
|
CGFloat torchCenterY = (holeBottom + bandBottom) * 0.5;
|
|
const CGFloat minC = holeBottom + torchH * 0.5 + 6.0;
|
|
const CGFloat maxC = bandBottom - torchH * 0.5 - MAX(6.0, self.view.safeAreaInsets.bottom);
|
|
torchCenterY = MAX(minC, MIN(maxC, torchCenterY));
|
|
if (minC > maxC) {
|
|
torchCenterY = (minC + maxC) * 0.5;
|
|
}
|
|
const CGFloat hdr = headerBottom + torchH * 0.5 + 10.0;
|
|
torchCenterY = MAX(torchCenterY, hdr);
|
|
self.torchCenterYConstraint.constant = torchCenterY;
|
|
}
|
|
|
|
[self applyMetadataRectOfInterestForScanHole:hole];
|
|
}
|
|
|
|
- (void)backTapped
|
|
{
|
|
if (gOnBack) {
|
|
gOnBack();
|
|
}
|
|
}
|
|
|
|
- (void)torchTapped
|
|
{
|
|
gTorchRequested = !gTorchRequested;
|
|
[self applyTorchFromGlobalFlag];
|
|
if (gTorchRequested) {
|
|
self.torchButton.backgroundColor = [[UIColor whiteColor] colorWithAlphaComponent:0.42];
|
|
self.torchButton.layer.borderWidth = 2;
|
|
self.torchButton.layer.borderColor = [UIColor colorWithRed:1 green:0.75 blue:0.45 alpha:1].CGColor;
|
|
} else {
|
|
self.torchButton.backgroundColor = [[UIColor whiteColor] colorWithAlphaComponent:0.22];
|
|
self.torchButton.layer.borderWidth = 0;
|
|
}
|
|
}
|
|
|
|
- (void)viewDidLayoutSubviews
|
|
{
|
|
[super viewDidLayoutSubviews];
|
|
if (self.previewLayer && self.cameraContainer) {
|
|
self.previewLayer.frame = self.cameraContainer.bounds;
|
|
}
|
|
[self layoutScanOverlayGeometry];
|
|
if (self.scanHoleFillView) {
|
|
[self.view bringSubviewToFront:self.scanHoleFillView];
|
|
}
|
|
if (self.scanDimView) {
|
|
[self.view bringSubviewToFront:self.scanDimView];
|
|
}
|
|
if (self.bracketContainer) {
|
|
[self.view bringSubviewToFront:self.bracketContainer];
|
|
}
|
|
if (self.headerContainer) {
|
|
[self.view bringSubviewToFront:self.headerContainer];
|
|
}
|
|
if (self.torchButton) {
|
|
[self.view bringSubviewToFront:self.torchButton];
|
|
}
|
|
}
|
|
|
|
- (void)applyTorchOnMainThread:(BOOL)on
|
|
{
|
|
AVCaptureDevice *device = self.videoDevice;
|
|
if (!device || ![device hasTorch]) {
|
|
if (on && gTorchRequested) {
|
|
__unsafe_unretained AmneziaPairingQrOverlayViewController *unsafeSelf = self;
|
|
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.12 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
|
|
AmneziaPairingQrOverlayViewController *strongSelf = unsafeSelf;
|
|
if (strongSelf && gTorchRequested) {
|
|
[strongSelf applyTorchOnMainThread:YES];
|
|
}
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
AVCaptureSession *session = self.captureSession;
|
|
if (on && session && ![session isRunning]) {
|
|
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.25 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
|
|
if (gTorchRequested) {
|
|
[self applyTorchOnMainThread:YES];
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
NSError *err = nil;
|
|
if (![device lockForConfiguration:&err]) {
|
|
NSLog(@"[PairingQrOverlay] torch lock failed: %@", err.localizedDescription);
|
|
return;
|
|
}
|
|
if (on) {
|
|
err = nil;
|
|
if (![device setTorchModeOnWithLevel:AVCaptureMaxAvailableTorchLevel error:&err]) {
|
|
if ([device isTorchModeSupported:AVCaptureTorchModeOn]) {
|
|
device.torchMode = AVCaptureTorchModeOn;
|
|
}
|
|
}
|
|
} else {
|
|
device.torchMode = AVCaptureTorchModeOff;
|
|
}
|
|
[device unlockForConfiguration];
|
|
}
|
|
|
|
- (void)applyTorchFromGlobalFlag
|
|
{
|
|
[self applyTorchOnMainThread:gTorchRequested ? YES : NO];
|
|
}
|
|
|
|
- (void)stopCapturePipelineOnMainThread
|
|
{
|
|
[self applyTorchOnMainThread:NO];
|
|
self.videoDevice = nil;
|
|
|
|
AVCaptureSession *session = self.captureSession;
|
|
self.captureSession = nil;
|
|
self.metadataOutput = nil;
|
|
|
|
if (self.previewLayer) {
|
|
[self.previewLayer removeFromSuperlayer];
|
|
self.previewLayer = nil;
|
|
}
|
|
|
|
if (session) {
|
|
dispatch_queue_t q = self.sessionQueue;
|
|
if (!q) {
|
|
q = dispatch_queue_create("org.amnezia.pairingqr.overlay", DISPATCH_QUEUE_SERIAL);
|
|
self.sessionQueue = q;
|
|
}
|
|
dispatch_sync(q, ^{
|
|
@try {
|
|
if ([session isRunning]) {
|
|
[session stopRunning];
|
|
}
|
|
} @catch (NSException *ex) {
|
|
NSLog(@"[PairingQrOverlay] stopRunning exception: %@", ex);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
- (BOOL)startCapturePipelineOnMainThread
|
|
{
|
|
|
|
[self stopCapturePipelineOnMainThread];
|
|
|
|
if (!self.cameraContainer) {
|
|
NSLog(@"[PairingQrOverlay] no cameraContainer");
|
|
return NO;
|
|
}
|
|
|
|
NSError *error = nil;
|
|
AVCaptureDevice *device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
|
|
if (!device) {
|
|
NSLog(@"[PairingQrOverlay] no default video device");
|
|
return NO;
|
|
}
|
|
AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
|
|
if (!input) {
|
|
NSLog(@"[PairingQrOverlay] deviceInput failed: %@", error.localizedDescription);
|
|
return NO;
|
|
}
|
|
self.videoDevice = device;
|
|
|
|
AVCaptureSession *session = [[AVCaptureSession alloc] init];
|
|
if ([session canSetSessionPreset:AVCaptureSessionPresetHigh]) {
|
|
session.sessionPreset = AVCaptureSessionPresetHigh;
|
|
}
|
|
|
|
[session addInput:input];
|
|
|
|
AVCaptureMetadataOutput *meta = [[AVCaptureMetadataOutput alloc] init];
|
|
if (![session canAddOutput:meta]) {
|
|
NSLog(@"[PairingQrOverlay] cannot add metadata output");
|
|
return NO;
|
|
}
|
|
[session addOutput:meta];
|
|
dispatch_queue_t q = self.sessionQueue;
|
|
if (!q) {
|
|
q = dispatch_queue_create("org.amnezia.pairingqr.overlay", DISPATCH_QUEUE_SERIAL);
|
|
self.sessionQueue = q;
|
|
}
|
|
[meta setMetadataObjectsDelegate:self queue:q];
|
|
meta.metadataObjectTypes = @[ AVMetadataObjectTypeQRCode ];
|
|
|
|
self.captureSession = session;
|
|
self.metadataOutput = meta;
|
|
|
|
AVCaptureVideoPreviewLayer *preview = [[AVCaptureVideoPreviewLayer alloc] initWithSession:session];
|
|
preview.videoGravity = AVLayerVideoGravityResizeAspectFill;
|
|
self.previewLayer = preview;
|
|
[self.cameraContainer.layer insertSublayer:preview atIndex:0];
|
|
preview.frame = self.cameraContainer.bounds;
|
|
|
|
[self.view layoutIfNeeded];
|
|
[self layoutScanOverlayGeometry];
|
|
|
|
AVCaptureSession *runningSession = session;
|
|
__unsafe_unretained AmneziaPairingQrOverlayViewController *weakSelf = self;
|
|
dispatch_async(q, ^{
|
|
@try {
|
|
[runningSession startRunning];
|
|
} @catch (NSException *ex) {
|
|
NSLog(@"[PairingQrOverlay] startRunning exception: %@", ex);
|
|
}
|
|
const BOOL running = [runningSession isRunning];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
AmneziaPairingQrOverlayViewController *strongSelf = weakSelf;
|
|
if (!strongSelf) {
|
|
return;
|
|
}
|
|
AVCaptureVideoPreviewLayer *pl = strongSelf.previewLayer;
|
|
[strongSelf applyTorchFromGlobalFlag];
|
|
});
|
|
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.35 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
|
|
AmneziaPairingQrOverlayViewController *strongSelf = weakSelf;
|
|
if (!strongSelf) {
|
|
return;
|
|
}
|
|
AVCaptureVideoPreviewLayer *pl = strongSelf.previewLayer;
|
|
});
|
|
});
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (void)captureOutput:(AVCaptureOutput *)output
|
|
didOutputMetadataObjects:(NSArray<__kindof AVMetadataMachineReadableCodeObject *> *)metadataObjects
|
|
fromConnection:(AVCaptureConnection *)connection
|
|
{
|
|
(void)output;
|
|
(void)connection;
|
|
for (AVMetadataMachineReadableCodeObject *obj in metadataObjects) {
|
|
NSString *value = obj.stringValue;
|
|
if (value.length == 0) {
|
|
continue;
|
|
}
|
|
const char *utf8 = value.UTF8String;
|
|
std::string copy(utf8 ? utf8 : "");
|
|
if (copy.empty()) {
|
|
continue;
|
|
}
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
if (gOnScanned) {
|
|
gOnScanned(copy.c_str());
|
|
} else {
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
|
|
@end
|
|
|
|
static void amneziaPairingQrOverlayTeardownOnMain(void)
|
|
{
|
|
UIWindow *w = gPairingQrOverlayWindow;
|
|
gPairingQrOverlayWindow = nil;
|
|
gOnScanned = nullptr;
|
|
gOnBack = nullptr;
|
|
gTorchRequested = false;
|
|
gPairingQrOverlayKeySince = -1.0;
|
|
|
|
if (w) {
|
|
UIViewController *root = w.rootViewController;
|
|
w.rootViewController = nil;
|
|
w.hidden = YES;
|
|
if ([root isKindOfClass:[AmneziaPairingQrOverlayViewController class]]) {
|
|
[(AmneziaPairingQrOverlayViewController *)root stopCapturePipelineOnMainThread];
|
|
}
|
|
}
|
|
|
|
UIWindow *restore = amneziaPickQtAppWindowToRestore();
|
|
if (restore) {
|
|
[restore makeKeyWindow];
|
|
} else {
|
|
}
|
|
}
|
|
|
|
void amneziaIosPairingQrOverlayPresent(AmneziaPairingQrScannedUtf8Handler onScanned, AmneziaPairingQrOverlayBackHandler onBack,
|
|
const std::string &titleUtf8, const std::string &subtitleUtf8)
|
|
{
|
|
const bool hasScan = static_cast<bool>(onScanned);
|
|
const bool hasBack = static_cast<bool>(onBack);
|
|
AmneziaPairingQrScannedUtf8Handler scanH = std::move(onScanned);
|
|
AmneziaPairingQrOverlayBackHandler backH = std::move(onBack);
|
|
const std::string titleCopy = titleUtf8;
|
|
const std::string subCopy = subtitleUtf8;
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
|
|
amneziaPairingQrOverlayTeardownOnMain();
|
|
gOnScanned = std::move(scanH);
|
|
gOnBack = std::move(backH);
|
|
|
|
UIWindowScene *scene = amneziaForegroundWindowScene();
|
|
if (!scene) {
|
|
NSLog(@"[PairingQrOverlay] present: no UIWindowScene");
|
|
gOnScanned = nullptr;
|
|
gOnBack = nullptr;
|
|
return;
|
|
}
|
|
|
|
const CGFloat bottomReserve = amneziaPairingQrBottomTabStripReserve(scene);
|
|
const CGRect sceneBounds = scene.coordinateSpace.bounds;
|
|
const CGRect overlayFrame = CGRectMake(0, 0, sceneBounds.size.width, sceneBounds.size.height - bottomReserve);
|
|
|
|
AmneziaPairingQrOverlayViewController *vc = [[AmneziaPairingQrOverlayViewController alloc] init];
|
|
NSString *nsTitle = titleCopy.empty() ? nil : [NSString stringWithUTF8String:titleCopy.c_str()];
|
|
NSString *nsSub = subCopy.empty() ? nil : [NSString stringWithUTF8String:subCopy.c_str()];
|
|
vc.chromeTitleText = nsTitle;
|
|
vc.chromeSubtitleText = nsSub;
|
|
|
|
UIWindow *w = [[UIWindow alloc] initWithWindowScene:scene];
|
|
w.frame = overlayFrame;
|
|
w.windowLevel = kAmneziaPairingQrOverlayWindowLevel;
|
|
w.backgroundColor = [UIColor blackColor];
|
|
w.rootViewController = vc;
|
|
gPairingQrOverlayWindow = w;
|
|
|
|
[w makeKeyAndVisible];
|
|
[w layoutIfNeeded];
|
|
[vc.view setNeedsLayout];
|
|
[vc.view layoutIfNeeded];
|
|
|
|
gPairingQrOverlayKeySince = CFAbsoluteTimeGetCurrent();
|
|
|
|
if (![vc startCapturePipelineOnMainThread]) {
|
|
NSLog(@"[PairingQrOverlay] startCapture failed");
|
|
}
|
|
});
|
|
}
|
|
|
|
void amneziaIosPairingQrOverlayDismiss()
|
|
{
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
amneziaPairingQrOverlayTeardownOnMain();
|
|
});
|
|
}
|
|
|
|
void amneziaIosPairingQrOverlaySetTorchEnabled(bool on)
|
|
{
|
|
gTorchRequested = on;
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow *win = gPairingQrOverlayWindow;
|
|
if (!win) {
|
|
return;
|
|
}
|
|
UIViewController *root = win.rootViewController;
|
|
if ([root isKindOfClass:[AmneziaPairingQrOverlayViewController class]]) {
|
|
AmneziaPairingQrOverlayViewController *vc = (AmneziaPairingQrOverlayViewController *)root;
|
|
[vc applyTorchFromGlobalFlag];
|
|
if (vc.torchButton) {
|
|
if (on) {
|
|
vc.torchButton.backgroundColor = [[UIColor whiteColor] colorWithAlphaComponent:0.42];
|
|
vc.torchButton.layer.borderWidth = 2;
|
|
vc.torchButton.layer.borderColor = [UIColor colorWithRed:1 green:0.75 blue:0.45 alpha:1].CGColor;
|
|
} else {
|
|
vc.torchButton.backgroundColor = [[UIColor whiteColor] colorWithAlphaComponent:0.18];
|
|
vc.torchButton.layer.borderWidth = 0;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
void amneziaIosPairingQrOverlayRestartCapture()
|
|
{
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
const CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
|
|
if (gPairingQrOverlayKeySince > 0 && (now - gPairingQrOverlayKeySince) < 1.0) {
|
|
return;
|
|
}
|
|
UIWindow *w = gPairingQrOverlayWindow;
|
|
if (!w) {
|
|
return;
|
|
}
|
|
UIViewController *root = w.rootViewController;
|
|
if (![root isKindOfClass:[AmneziaPairingQrOverlayViewController class]]) {
|
|
return;
|
|
}
|
|
AmneziaPairingQrOverlayViewController *vc = (AmneziaPairingQrOverlayViewController *)root;
|
|
[vc stopCapturePipelineOnMainThread];
|
|
if (![vc startCapturePipelineOnMainThread]) {
|
|
NSLog(@"[PairingQrOverlay] restart startCapture failed");
|
|
}
|
|
});
|
|
}
|