swift/Beam
swift/Beam
1
0
Fork 0
mirror of https://github.com/element-hq/element-x-ios.git synced 2025-03-10 21:39:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove unused ScreenshotDetector

Browse Source
This commit is contained in:
Stefan Ceriu 2023-04-21 09:40:09 +03:00 committed by Stefan Ceriu
parent 7a1cbdf6b1
commit 1815b0a7ac
2 changed files with 0 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
ElementX/Sources/Services/BugReport/ScreenshotDetector.swift
View File

@ -1,114 +0,0 @@
//
// Copyright 2022 New Vector Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
import Foundation
import Photos
import UIKit
enum ScreenshotDetectorError: String, Error {
case loadFailed
case notAuthorized
}
@MainActor
class ScreenshotDetector {
var callback: (@MainActor (UIImage?, Error?) -> Void)?
/// Flag to whether ask for photos authorization by default if needed.
var autoRequestPHAuthorization = false
init() {
startObservingScreenshots()
}
private func startObservingScreenshots() {
NotificationCenter.default.addObserver(self,
selector: #selector(userDidTakeScreenshot),
name: UIApplication.userDidTakeScreenshotNotification,
object: nil)
}
@objc private func userDidTakeScreenshot() {
let authStatus = PHPhotoLibrary.authorizationStatus(for: .readWrite)
if authStatus == .authorized {
findScreenshot()
} else if authStatus == .notDetermined, autoRequestPHAuthorization {
Task {
await self.handleAuthStatus(PHPhotoLibrary.requestAuthorization(for: .readWrite))
}
} else {
fail(withError: ScreenshotDetectorError.notAuthorized)
}
}
private func handleAuthStatus(_ status: PHAuthorizationStatus) {
if status == .authorized {
findScreenshot()
} else {
fail(withError: ScreenshotDetectorError.notAuthorized)
}
}
private func findScreenshot() {
if let asset = PHAsset.fetchLastScreenshot() {
let imageManager = PHImageManager()
imageManager.requestImage(for: asset,
targetSize: PHImageManagerMaximumSize,
contentMode: .default,
options: PHImageRequestOptions.highQualitySyncLocal) { [weak self] image, _ in
guard let image else {
self?.fail(withError: ScreenshotDetectorError.loadFailed)
return
}
self?.succeed(withImage: image)
}
} else {
fail(withError: ScreenshotDetectorError.loadFailed)
}
}
func succeed(withImage image: UIImage) {
callback?(image, nil)
}
func fail(withError error: Error) {
callback?(nil, error)
}
}
extension PHAsset {
static func fetchLastScreenshot() -> PHAsset? {
let options = PHFetchOptions()
options.fetchLimit = 1
options.includeAssetSourceTypes = [.typeUserLibrary]
options.wantsIncrementalChangeDetails = false
options.predicate = NSPredicate(format: "(mediaSubtype & %d) != 0", PHAssetMediaSubtype.photoScreenshot.rawValue)
options.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
return PHAsset.fetchAssets(with: .image, options: options).firstObject
}
}
private extension PHImageRequestOptions {
static var highQualitySyncLocal: PHImageRequestOptions {
let options = PHImageRequestOptions()
options.deliveryMode = .highQualityFormat
options.isNetworkAccessAllowed = false
options.isSynchronous = true
return options
}
}

89
UnitTests/Sources/ScreenshotDetectorTests.swift
View File

@ -1,89 +0,0 @@
//
// Copyright 2022 New Vector Ltd
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
@testable import ElementX
import Foundation
import Photos
import XCTest
class ScreenshotDetectorTests: XCTestCase {
@MainActor func testDetection() async {
async { expectation in
let detector = ScreenshotDetector()
// disable auto request authorization
detector.autoRequestPHAuthorization = false
detector.callback = { image, error in
defer {
expectation.fulfill()
}
if PHPhotoLibrary.authorizationStatus(for: .readWrite) == .authorized {
// if Photos already authorized on the simulator
if PHAsset.fetchLastScreenshot() != nil {
// we should get an image
XCTAssertNotNil(image)
// we should not get an error
XCTAssertNil(error)
} else {
// otherwise we should not get an image
XCTAssertNil(image)
// and get an error
guard let error else {
XCTFail("Should get an error")
return
}
switch error {
case ScreenshotDetectorError.loadFailed:
break
default:
XCTFail("Unknown error")
}
}
} else {
// otherwise we should not get an image
XCTAssertNil(image)
// and get an error
guard let error else {
XCTFail("Should get an error")
return
}
switch error {
case ScreenshotDetectorError.notAuthorized:
break
default:
XCTFail("Unknown error")
}
}
}
NotificationCenter.default.post(name: UIApplication.userDidTakeScreenshotNotification, object: nil)
}
}
private func async(_ timeout: TimeInterval = 0.5, _ block: @escaping (XCTestExpectation) -> Void) {
let waiter = XCTWaiter()
let expectation = XCTestExpectation(description: "Async operation expectation")
block(expectation)
waiter.wait(for: [expectation], timeout: timeout)
}
}