647 lines
21 KiB
Swift
647 lines
21 KiB
Swift
//
|
|
// PigeonWatermarkCameraView.swift
|
|
// QuickLocation
|
|
//
|
|
|
|
import UIKit
|
|
import AVFoundation
|
|
|
|
final class PigeonWatermarkCameraView: UIView {
|
|
|
|
var onClose: (() -> Void)?
|
|
var onConfirm: ((UIImage) -> Void)?
|
|
|
|
private let session = AVCaptureSession()
|
|
private let sessionQueue = DispatchQueue(label: "pigeon.watermark.camera")
|
|
private var previewLayer: AVCaptureVideoPreviewLayer?
|
|
private var videoInput: AVCaptureDeviceInput?
|
|
private var photoOutput: AVCapturePhotoOutput?
|
|
|
|
private var cameraPosition: AVCaptureDevice.Position = .back
|
|
private var isTorchOn = false
|
|
private var isReviewing = false
|
|
private var isCapturing = false
|
|
private var didConfigureSession = false
|
|
private var capturedImage: UIImage?
|
|
private var captureDate = Date()
|
|
private var addressText = ""
|
|
|
|
override init(frame: CGRect) {
|
|
super.init(frame: frame)
|
|
backgroundColor = UIColor(hexStr: "#F9F9F9")
|
|
setupUI()
|
|
applyReviewState(false)
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
deinit {
|
|
let session = self.session
|
|
sessionQueue.async {
|
|
if session.isRunning {
|
|
session.stopRunning()
|
|
}
|
|
}
|
|
}
|
|
|
|
func startSession() {
|
|
requestAccessAndConfigure()
|
|
}
|
|
|
|
func stopSession() {
|
|
let session = self.session
|
|
sessionQueue.async {
|
|
if session.isRunning {
|
|
session.stopRunning()
|
|
}
|
|
}
|
|
}
|
|
|
|
func updateAddress(_ address: String) {
|
|
addressText = address
|
|
if isReviewing {
|
|
refreshWatermark(at: captureDate)
|
|
}
|
|
}
|
|
|
|
override func layoutSubviews() {
|
|
super.layoutSubviews()
|
|
previewLayer?.frame = previewHost.bounds
|
|
shutterButton.setNeedsDisplay()
|
|
}
|
|
|
|
private func setupUI() {
|
|
addSubview(gradientView)
|
|
addSubview(navView)
|
|
addSubview(previewContainer)
|
|
previewContainer.addSubview(previewHost)
|
|
previewContainer.addSubview(capturedImageView)
|
|
previewContainer.addSubview(watermarkView)
|
|
addSubview(flashButton)
|
|
addSubview(shutterButton)
|
|
addSubview(switchButton)
|
|
addSubview(retakeButton)
|
|
addSubview(confirmButton)
|
|
|
|
gradientView.layoutChain
|
|
.top()
|
|
.edgesHorzontal()
|
|
.height(135)
|
|
|
|
navView.layoutChain.edges(excludingEdge: .bottom).height(kNaviHeight)
|
|
navView.onBackTapped = { [weak self] in
|
|
self?.onClose?()
|
|
}
|
|
|
|
previewContainer.layoutChain
|
|
.top(kNaviHeight + 73)
|
|
.edgesHorzontal(30)
|
|
.heightToWidth(424/315)
|
|
|
|
previewHost.layoutChain.edges()
|
|
capturedImageView.layoutChain.edges()
|
|
|
|
watermarkView.layoutChain
|
|
.left(12)
|
|
.top(12)
|
|
watermarkView.rightAnchor.constraint(
|
|
lessThanOrEqualTo: previewContainer.rightAnchor,
|
|
constant: -12
|
|
).isActive = true
|
|
|
|
shutterButton.layoutChain
|
|
.centerX()
|
|
.bottom(kSafeBottomMargin + 18)
|
|
.width(84)
|
|
.height(84)
|
|
|
|
flashButton.layoutChain
|
|
.centerY(shutterButton)
|
|
.rightToLeftOfView(shutterButton, offset: -52)
|
|
.width(50)
|
|
.height(50)
|
|
|
|
switchButton.layoutChain
|
|
.centerY(shutterButton)
|
|
.leftToRightOfView(shutterButton, offset: 52)
|
|
.width(50)
|
|
.height(50)
|
|
|
|
retakeButton.layoutChain
|
|
.left(30)
|
|
.bottom(kSafeBottomMargin + 24)
|
|
.height(50)
|
|
.width(110)
|
|
|
|
confirmButton.layoutChain
|
|
.leftToRightOfView(retakeButton, offset: 16)
|
|
.right(30)
|
|
.bottomToView(retakeButton)
|
|
.height(50)
|
|
}
|
|
|
|
func requestAccessAndConfigure() {
|
|
switch AVCaptureDevice.authorizationStatus(for: .video) {
|
|
case .authorized:
|
|
configureSession()
|
|
case .notDetermined:
|
|
AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
|
|
DispatchQueue.main.async {
|
|
if granted {
|
|
self?.configureSession()
|
|
} else {
|
|
DLToast.show(text: "请在设置中开启相机权限")
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
DLToast.show(text: "请在设置中开启相机权限")
|
|
}
|
|
}
|
|
|
|
private func configureSession() {
|
|
sessionQueue.async { [weak self] in
|
|
guard let self else { return }
|
|
if !self.didConfigureSession {
|
|
self.session.beginConfiguration()
|
|
self.session.sessionPreset = .photo
|
|
_ = self.attachVideoInput(position: self.cameraPosition)
|
|
let output = AVCapturePhotoOutput()
|
|
if self.session.canAddOutput(output) {
|
|
self.session.addOutput(output)
|
|
self.photoOutput = output
|
|
}
|
|
self.session.commitConfiguration()
|
|
self.didConfigureSession = true
|
|
DispatchQueue.main.async {
|
|
let layer = AVCaptureVideoPreviewLayer(session: self.session)
|
|
layer.videoGravity = .resizeAspectFill
|
|
layer.frame = self.previewHost.bounds
|
|
self.previewHost.layer.insertSublayer(layer, at: 0)
|
|
self.previewLayer = layer
|
|
self.applyVideoOrientation()
|
|
}
|
|
}
|
|
self.applyVideoOrientation()
|
|
if !self.session.isRunning {
|
|
self.session.startRunning()
|
|
}
|
|
}
|
|
}
|
|
|
|
@discardableResult
|
|
private func attachVideoInput(position: AVCaptureDevice.Position) -> Bool {
|
|
if let videoInput {
|
|
session.removeInput(videoInput)
|
|
self.videoInput = nil
|
|
}
|
|
guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: position),
|
|
let input = try? AVCaptureDeviceInput(device: device),
|
|
session.canAddInput(input) else { return false }
|
|
session.addInput(input)
|
|
videoInput = input
|
|
cameraPosition = position
|
|
return true
|
|
}
|
|
|
|
private func applyVideoOrientation() {
|
|
if let conn = photoOutput?.connection(with: .video), conn.isVideoOrientationSupported {
|
|
conn.videoOrientation = .portrait
|
|
if conn.isVideoMirroringSupported {
|
|
conn.automaticallyAdjustsVideoMirroring = false
|
|
conn.isVideoMirrored = cameraPosition == .front
|
|
}
|
|
}
|
|
DispatchQueue.main.async { [weak self] in
|
|
guard let self, let conn = self.previewLayer?.connection, conn.isVideoOrientationSupported else { return }
|
|
conn.videoOrientation = .portrait
|
|
}
|
|
}
|
|
|
|
@objc private func tapFlash() {
|
|
guard !isReviewing else { return }
|
|
guard cameraPosition == .back, let device = videoInput?.device, device.hasTorch else {
|
|
DLToast.show(text: "当前镜头不支持闪光灯")
|
|
return
|
|
}
|
|
do {
|
|
try device.lockForConfiguration()
|
|
isTorchOn.toggle()
|
|
device.torchMode = isTorchOn ? .on : .off
|
|
device.unlockForConfiguration()
|
|
flashButton.alpha = isTorchOn ? 1 : 0.72
|
|
} catch {
|
|
DLToast.show(text: "闪光灯开启失败")
|
|
}
|
|
}
|
|
|
|
@objc private func tapSwitch() {
|
|
guard !isReviewing else { return }
|
|
let next: AVCaptureDevice.Position = cameraPosition == .back ? .front : .back
|
|
sessionQueue.async { [weak self] in
|
|
guard let self else { return }
|
|
self.session.beginConfiguration()
|
|
_ = self.attachVideoInput(position: next)
|
|
if self.isTorchOn, next == .front {
|
|
self.isTorchOn = false
|
|
}
|
|
self.applyVideoOrientation()
|
|
self.session.commitConfiguration()
|
|
DispatchQueue.main.async {
|
|
self.flashButton.alpha = self.isTorchOn ? 1 : 0.72
|
|
}
|
|
}
|
|
}
|
|
|
|
@objc private func tapShutter() {
|
|
guard !isReviewing, !isCapturing, let photoOutput else { return }
|
|
isCapturing = true
|
|
let settings = AVCapturePhotoSettings()
|
|
if let device = videoInput?.device, device.hasFlash, cameraPosition == .back {
|
|
settings.flashMode = isTorchOn ? .on : .off
|
|
}
|
|
photoOutput.capturePhoto(with: settings, delegate: self)
|
|
}
|
|
|
|
@objc private func tapRetake() {
|
|
capturedImage = nil
|
|
capturedImageView.image = nil
|
|
isReviewing = false
|
|
isCapturing = false
|
|
applyReviewState(false)
|
|
}
|
|
|
|
@objc private func tapConfirm() {
|
|
guard let image = makeWatermarkedImage() else { return }
|
|
onConfirm?(image)
|
|
}
|
|
|
|
private func applyReviewState(_ reviewing: Bool) {
|
|
capturedImageView.isHidden = !reviewing
|
|
watermarkView.isHidden = !reviewing
|
|
flashButton.isHidden = reviewing
|
|
shutterButton.isHidden = reviewing
|
|
switchButton.isHidden = reviewing
|
|
retakeButton.isHidden = !reviewing
|
|
confirmButton.isHidden = !reviewing
|
|
}
|
|
|
|
private func refreshWatermark(at date: Date) {
|
|
let timeFormatter = DateFormatter()
|
|
timeFormatter.locale = Locale(identifier: "zh_CN")
|
|
timeFormatter.dateFormat = "HH:mm"
|
|
timeLabel.text = timeFormatter.string(from: date)
|
|
|
|
let dateFormatter = DateFormatter()
|
|
dateFormatter.locale = Locale(identifier: "zh_CN")
|
|
dateFormatter.dateFormat = "yyyy-M-d"
|
|
dateLabel.text = dateFormatter.string(from: date)
|
|
|
|
let weekday = Calendar(identifier: .gregorian).component(.weekday, from: date)
|
|
let names = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"]
|
|
weekdayLabel.text = names[max(0, min(6, weekday - 1))]
|
|
|
|
let hasAddress = !addressText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
|
|
locationRow.isHidden = !hasAddress
|
|
addressLabel.text = addressText
|
|
}
|
|
|
|
private func makeWatermarkedImage() -> UIImage? {
|
|
guard let capturedImage else { return nil }
|
|
layoutIfNeeded()
|
|
let target = previewContainer.bounds.size
|
|
let watermarkSize = watermarkView.bounds.size
|
|
let watermarkFrame = watermarkView.frame
|
|
guard target.width > 1, target.height > 1, watermarkSize.width > 1 else { return capturedImage }
|
|
|
|
watermarkBlurView.isHidden = true
|
|
watermarkTintView.isHidden = true
|
|
let borderWidth = watermarkView.layer.borderWidth
|
|
watermarkView.layer.borderWidth = 0
|
|
layoutIfNeeded()
|
|
|
|
let scale = UIScreen.main.scale
|
|
let clearFormat = UIGraphicsImageRendererFormat.default()
|
|
clearFormat.scale = scale
|
|
clearFormat.opaque = false
|
|
let contentImage = UIGraphicsImageRenderer(size: watermarkSize, format: clearFormat).image { ctx in
|
|
ctx.cgContext.clear(CGRect(origin: .zero, size: watermarkSize))
|
|
watermarkView.drawHierarchy(
|
|
in: CGRect(origin: .zero, size: watermarkSize),
|
|
afterScreenUpdates: true
|
|
)
|
|
}
|
|
|
|
watermarkBlurView.isHidden = false
|
|
watermarkTintView.isHidden = false
|
|
watermarkView.layer.borderWidth = borderWidth
|
|
|
|
let photoFormat = UIGraphicsImageRendererFormat.default()
|
|
photoFormat.scale = scale
|
|
photoFormat.opaque = true
|
|
return UIGraphicsImageRenderer(size: target, format: photoFormat).image { _ in
|
|
Self.drawAspectFill(capturedImage, in: CGRect(origin: .zero, size: target))
|
|
let card = UIBezierPath(roundedRect: watermarkFrame, cornerRadius: 14)
|
|
UIColor.white.withAlphaComponent(0.28).setFill()
|
|
card.fill()
|
|
UIColor.white.setStroke()
|
|
card.lineWidth = 1
|
|
card.stroke()
|
|
contentImage.draw(in: watermarkFrame)
|
|
}
|
|
}
|
|
|
|
private static func drawAspectFill(_ image: UIImage, in rect: CGRect) {
|
|
let imgSize = image.size
|
|
guard imgSize.width > 0, imgSize.height > 0 else { return }
|
|
let scale = max(rect.width / imgSize.width, rect.height / imgSize.height)
|
|
let scaled = CGSize(width: imgSize.width * scale, height: imgSize.height * scale)
|
|
let origin = CGPoint(
|
|
x: rect.midX - scaled.width / 2,
|
|
y: rect.midY - scaled.height / 2
|
|
)
|
|
image.draw(in: CGRect(origin: origin, size: scaled))
|
|
}
|
|
|
|
private lazy var gradientView: PigeonCameraGradientView = {
|
|
let view = PigeonCameraGradientView()
|
|
view.isUserInteractionEnabled = false
|
|
return view
|
|
}()
|
|
|
|
private lazy var navView: BaseNavigationView = {
|
|
BaseNavigationView(title: "水印拍照")
|
|
}()
|
|
|
|
private lazy var previewContainer: UIView = {
|
|
let view = UIView()
|
|
view.backgroundColor = UIColor(hexStr: "#DDE1E5")
|
|
view.layer.cornerRadius = 24
|
|
view.clipsToBounds = true
|
|
return view
|
|
}()
|
|
|
|
private lazy var previewHost: UIView = {
|
|
let view = UIView()
|
|
view.backgroundColor = .black
|
|
return view
|
|
}()
|
|
|
|
private lazy var capturedImageView: UIImageView = {
|
|
let view = UIImageView()
|
|
view.contentMode = .scaleAspectFill
|
|
view.clipsToBounds = true
|
|
view.isHidden = true
|
|
return view
|
|
}()
|
|
|
|
private lazy var watermarkBlurView: UIVisualEffectView = {
|
|
let view = UIVisualEffectView(effect: UIBlurEffect(style: .systemUltraThinMaterialLight))
|
|
view.isUserInteractionEnabled = false
|
|
return view
|
|
}()
|
|
|
|
private lazy var watermarkTintView: UIView = {
|
|
let view = UIView()
|
|
view.backgroundColor = UIColor.white.withAlphaComponent(0.08)
|
|
view.isOpaque = false
|
|
view.isUserInteractionEnabled = false
|
|
return view
|
|
}()
|
|
|
|
private lazy var timeChipView: UIView = {
|
|
let view = UIView()
|
|
view.backgroundColor = UIColor(hexStr: "#00ADFE")
|
|
view.layer.cornerRadius = 10
|
|
|
|
let logo = UIView()
|
|
logo.backgroundColor = .white
|
|
logo.layer.cornerRadius = 6
|
|
|
|
timeLabel.setContentHuggingPriority(.required, for: .horizontal)
|
|
timeLabel.setContentCompressionResistancePriority(.required, for: .horizontal)
|
|
|
|
view.addSubview(logo)
|
|
view.addSubview(timeLabel)
|
|
logo.layoutChain
|
|
.left(6)
|
|
.centerY()
|
|
.width(22)
|
|
.height(22)
|
|
timeLabel.layoutChain
|
|
.leftToRightOfView(logo, offset: 6)
|
|
.right(8)
|
|
.top(6)
|
|
.bottom(6)
|
|
return view
|
|
}()
|
|
|
|
private lazy var watermarkView: UIView = {
|
|
let view = UIView()
|
|
view.backgroundColor = .clear
|
|
view.isOpaque = false
|
|
view.layer.cornerRadius = 14
|
|
view.layer.borderWidth = 1
|
|
view.layer.borderColor = UIColor.white.cgColor
|
|
view.clipsToBounds = true
|
|
view.isHidden = true
|
|
|
|
view.addSubview(watermarkBlurView)
|
|
view.addSubview(watermarkTintView)
|
|
watermarkBlurView.layoutChain.edges()
|
|
watermarkTintView.layoutChain.edges()
|
|
|
|
let dateColumn = UIStackView(arrangedSubviews: [dateLabel, weekdayLabel])
|
|
dateColumn.axis = .vertical
|
|
dateColumn.spacing = 1
|
|
|
|
let topRow = UIStackView(arrangedSubviews: [timeChipView, dateColumn])
|
|
topRow.axis = .horizontal
|
|
topRow.alignment = .center
|
|
topRow.spacing = 8
|
|
|
|
let stack = UIStackView(arrangedSubviews: [topRow, locationRow])
|
|
stack.axis = .vertical
|
|
stack.alignment = .fill
|
|
stack.spacing = 8
|
|
view.addSubview(stack)
|
|
stack.layoutChain
|
|
.top(10)
|
|
.left(10)
|
|
.right(12)
|
|
.bottom(10)
|
|
return view
|
|
}()
|
|
|
|
private lazy var timeLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.font = .systemFont(ofSize: 22, weight: .semibold)
|
|
label.textColor = .white
|
|
return label
|
|
}()
|
|
|
|
private lazy var dateLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.font = .systemFont(ofSize: 11, weight: .medium)
|
|
label.textColor = UIColor(hexStr: "#293445")
|
|
return label
|
|
}()
|
|
|
|
private lazy var weekdayLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.font = .systemFont(ofSize: 11, weight: .medium)
|
|
label.textColor = UIColor(hexStr: "#293445")
|
|
return label
|
|
}()
|
|
|
|
private lazy var addressLabel: UILabel = {
|
|
let label = UILabel()
|
|
label.font = .systemFont(ofSize: 11, weight: .medium)
|
|
label.textColor = UIColor(hexStr: "#293445")
|
|
label.numberOfLines = 2
|
|
label.lineBreakMode = .byTruncatingTail
|
|
return label
|
|
}()
|
|
|
|
private lazy var locationRow: UIView = {
|
|
let row = UIView()
|
|
row.isHidden = true
|
|
let pin = UIImageView(image: UIImage(named: "PigeonMessage/sparkle"))
|
|
pin.contentMode = .scaleAspectFit
|
|
row.addSubview(pin)
|
|
row.addSubview(addressLabel)
|
|
pin.layoutChain
|
|
.left()
|
|
.top(1)
|
|
.width(11)
|
|
.height(11)
|
|
addressLabel.layoutChain
|
|
.leftToRightOfView(pin, offset: 4)
|
|
.right()
|
|
.top()
|
|
.bottom()
|
|
return row
|
|
}()
|
|
|
|
private lazy var flashButton: UIButton = {
|
|
let button = UIButton(type: .custom)
|
|
button.setImage(UIImage(named: "PigeonMessage/flash"), for: .normal)
|
|
button.alpha = 0.72
|
|
button.addTarget(self, action: #selector(tapFlash), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
|
|
private lazy var switchButton: UIButton = {
|
|
let button = UIButton(type: .custom)
|
|
button.setImage(UIImage(named: "PigeonMessage/camera_switch"), for: .normal)
|
|
button.addTarget(self, action: #selector(tapSwitch), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
|
|
private lazy var shutterButton: PigeonShutterButton = {
|
|
let button = PigeonShutterButton()
|
|
button.addTarget(self, action: #selector(tapShutter), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
|
|
private lazy var retakeButton: UIButton = {
|
|
let button = UIButton(type: .custom)
|
|
button.setTitle("重拍", for: .normal)
|
|
button.setTitleColor(UIColor(hexStr: "#13B6F1"), for: .normal)
|
|
button.titleLabel?.font = FontManager.boboBold(18)
|
|
button.backgroundColor = .white
|
|
button.layer.cornerRadius = 16
|
|
button.layer.borderWidth = 1.5
|
|
button.layer.borderColor = UIColor(hexStr: "#13B6F1").cgColor
|
|
button.addTarget(self, action: #selector(tapRetake), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
|
|
private lazy var confirmButton: UIButton = {
|
|
let button = UIButton(type: .custom)
|
|
button.setTitle("确定", for: .normal)
|
|
button.setTitleColor(.white, for: .normal)
|
|
button.titleLabel?.font = FontManager.boboBold(18)
|
|
button.setBackgroundImage(UIImage(named: "Common/button_bg_2"), for: .normal)
|
|
button.clipsToBounds = true
|
|
button.cornerRadius = 16
|
|
button.addTarget(self, action: #selector(tapConfirm), for: .touchUpInside)
|
|
return button
|
|
}()
|
|
}
|
|
|
|
extension PigeonWatermarkCameraView: AVCapturePhotoCaptureDelegate {
|
|
func photoOutput(
|
|
_ output: AVCapturePhotoOutput,
|
|
didFinishProcessingPhoto photo: AVCapturePhoto,
|
|
error: Error?
|
|
) {
|
|
isCapturing = false
|
|
if let error {
|
|
DLToast.show(text: "拍照失败：\(error.localizedDescription)")
|
|
return
|
|
}
|
|
guard let data = photo.fileDataRepresentation(), let image = UIImage(data: data) else {
|
|
DLToast.show(text: "拍照失败")
|
|
return
|
|
}
|
|
DispatchQueue.main.async { [weak self] in
|
|
guard let self else { return }
|
|
self.captureDate = Date()
|
|
self.capturedImage = image
|
|
self.capturedImageView.image = image
|
|
self.refreshWatermark(at: self.captureDate)
|
|
self.isReviewing = true
|
|
self.applyReviewState(true)
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class PigeonCameraGradientView: UIView {
|
|
override class var layerClass: AnyClass { CAGradientLayer.self }
|
|
|
|
override init(frame: CGRect) {
|
|
super.init(frame: frame)
|
|
guard let gradient = layer as? CAGradientLayer else { return }
|
|
gradient.colors = [
|
|
UIColor(hexStr: "#BAF4FF").cgColor,
|
|
UIColor(hexStr: "#BAF4FF", alpha: 0).cgColor
|
|
]
|
|
gradient.startPoint = CGPoint(x: 0.5, y: 0)
|
|
gradient.endPoint = CGPoint(x: 0.5, y: 1)
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
}
|
|
|
|
private final class PigeonShutterButton: UIControl {
|
|
override init(frame: CGRect) {
|
|
super.init(frame: frame)
|
|
backgroundColor = .clear
|
|
isOpaque = false
|
|
}
|
|
|
|
required init?(coder: NSCoder) {
|
|
fatalError("init(coder:) has not been implemented")
|
|
}
|
|
|
|
override func layoutSubviews() {
|
|
super.layoutSubviews()
|
|
setNeedsDisplay()
|
|
}
|
|
|
|
override func draw(_ rect: CGRect) {
|
|
let color = UIColor(hexStr: "#13B6F1")
|
|
let ring = UIBezierPath(ovalIn: rect.insetBy(dx: 3, dy: 3))
|
|
color.setStroke()
|
|
ring.lineWidth = 4
|
|
ring.stroke()
|
|
color.setFill()
|
|
UIBezierPath(ovalIn: rect.insetBy(dx: 11, dy: 11)).fill()
|
|
}
|
|
}
|