<key>NSCameraUsageDescription</key>

<string>카메라를 사용하여 사진과 영상을 촬영합니다.</string>

<key>NSMicrophoneUsageDescription</key>

<string>영상 녹화 시 마이크를 사용합니다.</string>

<key>NSPhotoLibraryUsageDescription</key>

<string>촬영한 사진을 앨범에 저장합니다.</string>

import AVFoundation

import UIKit



class CameraViewController: UIViewController {



// 1. 핵심 객체들 선언

var captureSession: AVCaptureSession!

var previewLayer: AVCaptureVideoPreviewLayer!

var currentDevice: AVCaptureDevice?



override func viewDidLoad() {

super.viewDidLoad()

checkPermissionAndSetup()

}



func checkPermissionAndSetup() {

switch AVCaptureDevice.authorizationStatus(for: .video) {

case .authorized:

setupCaptureSession()

case .notDetermined:

AVCaptureDevice.requestAccess(for: .video) { granted in

if granted {

DispatchQueue.main.async {

self.setupCaptureSession()

}

}

}

default:

print("카메라 권한이 없습니다.")

}

}



func setupCaptureSession() {

captureSession = AVCaptureSession()

// 세션 품질 설정 (photo / high / medium / low)

captureSession.sessionPreset = .photo



// 입력 장치 설정

guard let device = AVCaptureDevice.default(

.builtInWideAngleCamera,

for: .video,

position: .back

) else { return }



currentDevice = device



do {

let input = try AVCaptureDeviceInput(device: device)

if captureSession.canAddInput(input) {

captureSession.addInput(input)

}

} catch {

print("입력 장치 설정 실패: \(error)")

return

}



// 미리보기 레이어 설정

previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)

previewLayer.videoGravity = .resizeAspectFill

previewLayer.frame = view.bounds

view.layer.insertSublayer(previewLayer, at: 0)



// 세션 시작 (백그라운드 스레드에서!)

DispatchQueue.global(qos: .userInitiated).async {

self.captureSession.startRunning()

}

}

}

// CameraViewController에 추가

var photoOutput: AVCapturePhotoOutput!



// setupCaptureSession() 안에 추가

func setupPhotoOutput() {

photoOutput = AVCapturePhotoOutput()



// HEIF 포맷 지원 여부 확인 후 설정

if photoOutput.availablePhotoCodecTypes.contains(.hevc) {

// HEIF 포맷 지원 (iOS 11+, iPhone 7 이상)

print("HEIF 지원됨")

}



if captureSession.canAddOutput(photoOutput) {

captureSession.addOutput(photoOutput)

}

}

// 셔터 버튼 탭 시 호출

@objc func capturePhoto() {

let settings = AVCapturePhotoSettings()



// 플래시 설정

if currentDevice?.hasFlash == true {

settings.flashMode = .auto  // .on / .off / .auto

}



// 고해상도 사진 활성화

settings.isHighResolutionPhotoEnabled = true



// HEIF 포맷으로 촬영 (용량 절약)

if let codecType = photoOutput.availablePhotoCodecTypes.first(where: { $0 == .hevc }) {

let heifSettings = AVCapturePhotoSettings(format: [AVVideoCodecKey: codecType])

photoOutput.capturePhoto(with: heifSettings, delegate: self)

} else {

// JPEG 폴백

photoOutput.capturePhoto(with: settings, delegate: self)

}

}



// AVCapturePhotoCaptureDelegate 구현

extension CameraViewController: AVCapturePhotoCaptureDelegate {



// 촬영 완료 시 호출

func photoOutput(_ output: AVCapturePhotoOutput,

didFinishProcessingPhoto photo: AVCapturePhoto,

error: Error?) {



if let error = error {

print("촬영 실패: \(error)")

return

}



// 이미지 데이터 추출

guard let imageData = photo.fileDataRepresentation() else { return }

guard let image = UIImage(data: imageData) else { return }



// 사진 앨범에 저장

UIImageWriteToSavedPhotosAlbum(image, self, #selector(imageSaved(_:didFinishSavingWithError:contextInfo:)), nil)



// 또는 메모리에서 바로 사용

DispatchQueue.main.async {

self.showPreview(image: image)

}

}



@objc func imageSaved(_ image: UIImage,

didFinishSavingWithError error: Error?,

contextInfo: UnsafeRawPointer) {

if let error = error {

print("저장 실패: \(error)")

} else {

print("✅ 사진 저장 완료!")

}

}

}

// 셔터 애니메이션 효과 추가

func photoOutput(_ output: AVCapturePhotoOutput,

willCapturePhotoFor resolvedSettings: AVCaptureResolvedPhotoSettings) {

// 화면 깜빡임 효과

DispatchQueue.main.async {

self.previewLayer.opacity = 0

UIView.animate(withDuration: 0.25) {

self.previewLayer.opacity = 1

}

}

}

var movieOutput: AVCaptureMovieFileOutput!

var isRecording = false



func setupMovieOutput() {

movieOutput = AVCaptureMovieFileOutput()



// 최대 녹화 시간 설정 (선택사항)

movieOutput.maxRecordedDuration = CMTime(seconds: 60, preferredTimescale: 600)



if captureSession.canAddOutput(movieOutput) {

captureSession.addOutput(movieOutput)

}



// 비디오 안정화 설정

if let connection = movieOutput.connection(with: .video) {

if connection.isVideoStabilizationSupported {

connection.preferredVideoStabilizationMode = .auto

}

}

}



// 마이크 입력 추가 (영상에 소리 포함)

func addAudioInput() {

guard let audioDevice = AVCaptureDevice.default(for: .audio) else { return }

do {

let audioInput = try AVCaptureDeviceInput(device: audioDevice)

if captureSession.canAddInput(audioInput) {

captureSession.addInput(audioInput)

}

} catch {

print("마이크 설정 실패: \(error)")

}

}

@objc func toggleRecording() {

if isRecording {

stopRecording()

} else {

startRecording()

}

}



func startRecording() {

guard !movieOutput.isRecording else { return }



// 임시 파일 경로 생성

let tempDir = FileManager.default.temporaryDirectory

let fileName = "video_\(Date().timeIntervalSince1970).mov"

let outputURL = tempDir.appendingPathComponent(fileName)



// 기존 파일 삭제

try? FileManager.default.removeItem(at: outputURL)



movieOutput.startRecording(to: outputURL, recordingDelegate: self)

isRecording = true

print("🔴 녹화 시작!")

}



func stopRecording() {

guard movieOutput.isRecording else { return }

movieOutput.stopRecording()

isRecording = false

print("⏹ 녹화 중지")

}



// AVCaptureFileOutputRecordingDelegate 구현

extension CameraViewController: AVCaptureFileOutputRecordingDelegate {



func fileOutput(_ output: AVCaptureFileOutput,

didFinishRecordingTo outputFileURL: URL,

from connections: [AVCaptureConnection],

error: Error?) {



if let error = error {

print("녹화 실패: \(error)")

return

}



// 사진 앨범에 저장

UISaveVideoAtPathToSavedPhotosAlbum(

outputFileURL.path,

self,

#selector(videoSaved(_:didFinishSavingWithError:contextInfo:)),

nil

)

}



@objc func videoSaved(_ videoPath: String,

didFinishSavingWithError error: Error?,

contextInfo: UnsafeRawPointer) {

if error == nil {

print("✅ 영상 저장 완료!")

}

}

}

enum CaptureMode {

case photo

case video

}



func switchCaptureMode(to mode: CaptureMode) {

captureSession.beginConfiguration()



switch mode {

case .photo:

// 영상 출력 제거, 사진 출력 추가

if captureSession.outputs.contains(movieOutput) {

captureSession.removeOutput(movieOutput)

}

if captureSession.canAddOutput(photoOutput) {

captureSession.addOutput(photoOutput)

}

captureSession.sessionPreset = .photo



case .video:

// 사진 출력 제거, 영상 출력 추가

if captureSession.outputs.contains(photoOutput) {

captureSession.removeOutput(photoOutput)

}

if captureSession.canAddOutput(movieOutput) {

captureSession.addOutput(movieOutput)

}

captureSession.sessionPreset = .hd1920x1080

}



captureSession.commitConfiguration()

}

func switchCamera() {

guard let currentInput = captureSession.inputs.first as? AVCaptureDeviceInput else { return }



let currentPosition = currentInput.device.position

let newPosition: AVCaptureDevice.Position = currentPosition == .back ? .front : .back



guard let newDevice = AVCaptureDevice.default(

.builtInWideAngleCamera,

for: .video,

position: newPosition

) else { return }



do {

let newInput = try AVCaptureDeviceInput(device: newDevice)



captureSession.beginConfiguration()

captureSession.removeInput(currentInput)



if captureSession.canAddInput(newInput) {

captureSession.addInput(newInput)

currentDevice = newDevice

} else {

captureSession.addInput(currentInput) // 실패 시 원복

}



captureSession.commitConfiguration()



// 전환 애니메이션

animateCameraSwitch()



} catch {

print("카메라 전환 실패: \(error)")

}

}



func animateCameraSwitch() {

let transition = CATransition()

transition.duration = 0.3

transition.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)

transition.type = .fade

previewLayer.add(transition, forKey: nil)

}

// 핀치 제스처로 줌 제어

var lastZoomFactor: CGFloat = 1.0



@objc func handlePinch(_ gesture: UIPinchGestureRecognizer) {

guard let device = currentDevice else { return }



let maxZoom = min(device.activeFormat.videoMaxZoomFactor, 10.0)

let minZoom: CGFloat = 1.0



func update(scale factor: CGFloat) {

do {

try device.lockForConfiguration()

defer { device.unlockForConfiguration() }



device.videoZoomFactor = factor

} catch {

print("줌 설정 실패: \(error)")

}

}



let newScaleFactor = minMaxZoom(lastZoomFactor * gesture.scale,

min: minZoom, max: maxZoom)



switch gesture.state {

case .began: fallthrough

case .changed:

update(scale: newScaleFactor)

case .ended:

lastZoomFactor = newScaleFactor

update(scale: newScaleFactor)

default: break

}

}



func minMaxZoom(_ factor: CGFloat, min: CGFloat, max: CGFloat) -> CGFloat {

return Swift.min(Swift.max(factor, min), max)

}

@objc func handleTap(_ gesture: UITapGestureRecognizer) {

let touchPoint = gesture.location(in: view)



// 화면 좌표 → 카메라 좌표 변환

let devicePoint = previewLayer.captureDevicePointConverted(fromLayerPoint: touchPoint)



focusAndExpose(at: devicePoint)

showFocusIndicator(at: touchPoint)

}



func focusAndExpose(at point: CGPoint) {

guard let device = currentDevice else { return }



do {

try device.lockForConfiguration()



// 포커스 설정

if device.isFocusPointOfInterestSupported &&

device.isFocusModeSupported(.autoFocus) {

device.focusPointOfInterest = point

device.focusMode = .autoFocus

}



// 노출 설정

if device.isExposurePointOfInterestSupported &&

device.isExposureModeSupported(.autoExpose) {

device.exposurePointOfInterest = point

device.exposureMode = .autoExpose

}



// 화이트밸런스 자동

if device.isWhiteBalanceModeSupported(.autoWhiteBalance) {

device.whiteBalanceMode = .autoWhiteBalance

}



device.unlockForConfiguration()

} catch {

print("포커스 설정 실패: \(error)")

}

}



// 포커스 인디케이터 UI

func showFocusIndicator(at point: CGPoint) {

let focusView = UIView(frame: CGRect(x: 0, y: 0, width: 70, height: 70))

focusView.center = point

focusView.layer.borderColor = UIColor.yellow.cgColor

focusView.layer.borderWidth = 2

focusView.backgroundColor = .clear

view.addSubview(focusView)



UIView.animate(withDuration: 0.3, animations: {

focusView.transform = CGAffineTransform(scaleX: 0.7, y: 0.7)

}) { _ in

UIView.animate(withDuration: 0.2, delay: 0.5) {

focusView.alpha = 0

} completion: { _ in

focusView.removeFromSuperview()

}

}

}

var videoDataOutput: AVCaptureVideoDataOutput!

let videoDataOutputQueue = DispatchQueue(

label: "com.myapp.videoDataOutput",

qos: .userInitiated,

attributes: [],

autoreleaseFrequency: .workItem

)



func setupVideoDataOutput() {

videoDataOutput = AVCaptureVideoDataOutput()



// 픽셀 포맷 설정

videoDataOutput.videoSettings = [

kCVPixelBufferPixelFormatTypeKey as String:

kCVPixelFormatType_32BGRA  // BGRA 형식 (Metal과 호환성 좋음)

]



// 처리가 늦으면 프레임 드롭 (메모리 보호)

videoDataOutput.alwaysDiscardsLateVideoFrames = true



// 델리게이트 설정 (전용 큐에서 처리)

videoDataOutput.setSampleBufferDelegate(self, queue: videoDataOutputQueue)



if captureSession.canAddOutput(videoDataOutput) {

captureSession.addOutput(videoDataOutput)

}



// 방향 설정

if let connection = videoDataOutput.connection(with: .video) {

connection.videoOrientation = .portrait

// 전면 카메라 미러링

if currentDevice?.position == .front {

connection.isVideoMirrored = true

}

}

}

extension CameraViewController: AVCaptureVideoDataOutputSampleBufferDelegate {



func captureOutput(_ output: AVCaptureOutput,

didOutput sampleBuffer: CMSampleBuffer,

from connection: AVCaptureConnection) {



// CMSampleBuffer → CVPixelBuffer 변환

guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }



// Core Image로 필터 적용

let ciImage = CIImage(cvPixelBuffer: pixelBuffer)

let filteredImage = applyFilter(to: ciImage)



// 메인 스레드에서 UI 업데이트

DispatchQueue.main.async {

self.filteredImageView.image = UIImage(ciImage: filteredImage)

}

}



// 프레임 드롭 감지

func captureOutput(_ output: AVCaptureOutput,

didDrop sampleBuffer: CMSampleBuffer,

from connection: AVCaptureConnection) {

print("⚠️ 프레임 드롭 발생 — 처리 속도 최적화 필요")

}

}



// Core Image 필터 적용 예시

func applyFilter(to image: CIImage) -> CIImage {

let context = CIContext()



// 흑백 필터

guard let filter = CIFilter(name: "CIPhotoEffectMono") else { return image }

filter.setValue(image, forKey: kCIInputImageKey)

return filter.outputImage ?? image

}

// 여러 필터 체이닝 예시

func applyMultipleFilters(to image: CIImage) -> CIImage {

var result = image



// 1. 채도 조절

if let colorFilter = CIFilter(name: "CIColorControls") {

colorFilter.setValue(result, forKey: kCIInputImageKey)

colorFilter.setValue(1.5, forKey: "inputSaturation")  // 채도 1.5배

colorFilter.setValue(0.1, forKey: "inputBrightness")  // 밝기 +0.1

result = colorFilter.outputImage ?? result

}



// 2. 비네트 효과

if let vignetteFilter = CIFilter(name: "CIVignette") {

vignetteFilter.setValue(result, forKey: kCIInputImageKey)

vignetteFilter.setValue(0.8, forKey: "inputIntensity")

vignetteFilter.setValue(1.5, forKey: "inputRadius")

result = vignetteFilter.outputImage ?? result

}



return result

}

import Vision



class FaceDetectionViewController: UIViewController {



var faceDetectionRequest: VNDetectFaceRectanglesRequest!

var overlayLayer: CALayer!



override func viewDidLoad() {

super.viewDidLoad()

setupFaceDetection()

}



func setupFaceDetection() {

faceDetectionRequest = VNDetectFaceRectanglesRequest { [weak self] request, error in

guard let self = self else { return }



if let error = error {

print("얼굴 인식 오류: \(error)")

return

}



guard let results = request.results as? [VNFaceObservation] else { return }



DispatchQueue.main.async {

self.drawFaceBoxes(faces: results)

}

}

}



// VideoDataOutput 델리게이트에서 호출

func detectFaces(in sampleBuffer: CMSampleBuffer) {

guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }



let requestHandler = VNImageRequestHandler(

cvPixelBuffer: pixelBuffer,

orientation: .up,

options: [:]

)



do {

try requestHandler.perform([faceDetectionRequest])

} catch {

print("Vision 요청 실패: \(error)")

}

}



func drawFaceBoxes(faces: [VNFaceObservation]) {

// 기존 레이어 제거

overlayLayer.sublayers?.forEach { $0.removeFromSuperlayer() }



for face in faces {

// Vision 좌표 → 화면 좌표 변환

let boundingBox = face.boundingBox

let size = CGSize(

width: boundingBox.width * view.bounds.width,

height: boundingBox.height * view.bounds.height

)

let origin = CGPoint(

x: boundingBox.minX * view.bounds.width,

y: (1 - boundingBox.maxY) * view.bounds.height  // Y축 반전!

)



let faceLayer = CALayer()

faceLayer.frame = CGRect(origin: origin, size: size)

faceLayer.borderColor = UIColor.green.cgColor

faceLayer.borderWidth = 2

faceLayer.cornerRadius = 4

overlayLayer.addSublayer(faceLayer)

}

}

}

var metadataOutput: AVCaptureMetadataOutput!



func setupQRScanner() {

metadataOutput = AVCaptureMetadataOutput()



if captureSession.canAddOutput(metadataOutput) {

captureSession.addOutput(metadataOutput)



metadataOutput.setMetadataObjectsDelegate(self, queue: .main)



// 지원하는 코드 타입 설정

metadataOutput.metadataObjectTypes = [

.qr,          // QR 코드

.ean8,        // EAN-8 바코드

.ean13,       // EAN-13 바코드

.code128,     // Code 128

.pdf417,      // PDF417

.aztec        // Aztec 코드

]



// 스캔 영역 제한 (선택사항 — 성능 향상)

metadataOutput.rectOfInterest = CGRect(x: 0.2, y: 0.2, width: 0.6, height: 0.6)

}

}



extension CameraViewController: AVCaptureMetadataOutputObjectsDelegate {



func metadataOutput(_ output: AVCaptureMetadataOutput,

didOutput metadataObjects: [AVMetadataObject],

from connection: AVCaptureConnection) {



guard let metadataObject = metadataObjects.first,

let readableObject = metadataObject as? AVMetadataMachineReadableCodeObject,

let stringValue = readableObject.stringValue else { return }



// 진동 피드백

AudioServicesPlaySystemSound(SystemSoundID(kSystemSoundID_Vibrate))



print("✅ QR 코드 인식: \(stringValue)")

handleQRCode(stringValue)

}

}

func trimVideo(inputURL: URL,

startTime: Double,

endTime: Double,

completion: @escaping (URL?) -> Void) {



let asset = AVAsset(url: inputURL)



// 내보내기 세션 생성

guard let exportSession = AVAssetExportSession(

asset: asset,

presetName: AVAssetExportPresetHighestQuality

) else {

completion(nil)

return

}



// 출력 파일 경로

let outputURL = FileManager.default.temporaryDirectory

.appendingPathComponent("trimmed_\(Date().timeIntervalSince1970).mp4")



exportSession.outputURL = outputURL

exportSession.outputFileType = .mp4

exportSession.shouldOptimizeForNetworkUse = true



// 시간 범위 설정

let start = CMTime(seconds: startTime, preferredTimescale: 600)

let end = CMTime(seconds: endTime, preferredTimescale: 600)

exportSession.timeRange = CMTimeRange(start: start, end: end)



// 내보내기 실행

exportSession.exportAsynchronously {

switch exportSession.status {

case .completed:

print("✅ 영상 자르기 완료")

completion(outputURL)

case .failed:

print("❌ 실패: \(exportSession.error?.localizedDescription ?? "")")

completion(nil)

case .cancelled:

print("취소됨")

completion(nil)

default: break

}

}

}

func mergeVideos(urls: [URL], completion: @escaping (URL?) -> Void) {

let composition = AVMutableComposition()



guard let videoTrack = composition.addMutableTrack(

withMediaType: .video,

preferredTrackID: kCMPersistentTrackID_Invalid

),

let audioTrack = composition.addMutableTrack(

withMediaType: .audio,

preferredTrackID: kCMPersistentTrackID_Invalid

) else { return }



var currentTime = CMTime.zero



for url in urls {

let asset = AVAsset(url: url)

let duration = asset.duration

let timeRange = CMTimeRange(start: .zero, duration: duration)



// 비디오 트랙 추가

if let assetVideoTrack = asset.tracks(withMediaType: .video).first {

try? videoTrack.insertTimeRange(timeRange,

of: assetVideoTrack,

at: currentTime)

}



// 오디오 트랙 추가

if let assetAudioTrack = asset.tracks(withMediaType: .audio).first {

try? audioTrack.insertTimeRange(timeRange,

of: assetAudioTrack,

at: currentTime)

}



currentTime = CMTimeAdd(currentTime, duration)

}



// 내보내기

let outputURL = FileManager.default.temporaryDirectory

.appendingPathComponent("merged_\(Date().timeIntervalSince1970).mp4")



guard let exportSession = AVAssetExportSession(

asset: composition,

presetName: AVAssetExportPresetHighestQuality

) else { return }



exportSession.outputURL = outputURL

exportSession.outputFileType = .mp4



exportSession.exportAsynchronously {

if exportSession.status == .completed {

completion(outputURL)

} else {

completion(nil)

}

}

}

func addTextOverlay(to asset: AVAsset,

text: String,

completion: @escaping (URL?) -> Void) {



let composition = AVMutableComposition()

let videoSize = asset.tracks(withMediaType: .video).first?.naturalSize ?? CGSize(width: 1920, height: 1080)



// 비디오 컴포지션 설정

let videoComposition = AVMutableVideoComposition()

videoComposition.renderSize = videoSize

videoComposition.frameDuration = CMTime(value: 1, timescale: 30)



// CALayer로 텍스트 레이어 생성

let textLayer = CATextLayer()

textLayer.string = text

textLayer.fontSize = 60

textLayer.foregroundColor = UIColor.white.cgColor

textLayer.alignmentMode = .center

textLayer.frame = CGRect(x: 0, y: 50, width: videoSize.width, height: 100)



// 배경 레이어

let backgroundLayer = CALayer()

backgroundLayer.frame = CGRect(origin: .zero, size: videoSize)



// 비디오 레이어

let videoLayer = CALayer()

videoLayer.frame = CGRect(origin: .zero, size: videoSize)



// 레이어 합성

let parentLayer = CALayer()

parentLayer.frame = CGRect(origin: .zero, size: videoSize)

parentLayer.addSublayer(videoLayer)

parentLayer.addSublayer(backgroundLayer)

parentLayer.addSublayer(textLayer)



videoComposition.animationTool = AVVideoCompositionCoreAnimationTool(

postProcessingAsVideoLayer: videoLayer,

in: parentLayer

)



// ... (내보내기 코드 동일)

}

// 앱 생명주기에 맞춰 세션 관리

override func viewWillAppear(_ animated: Bool) {

super.viewWillAppear(animated)

DispatchQueue.global(qos: .userInitiated).async {

if !self.captureSession.isRunning {

self.captureSession.startRunning()

}

}

}



override func viewWillDisappear(_ animated: Bool) {

super.viewWillDisappear(animated)

DispatchQueue.global(qos: .userInitiated).async {

if self.captureSession.isRunning {

self.captureSession.stopRunning()

}

}

}



// 앱 백그라운드 진입 시

override func viewDidLoad() {

super.viewDidLoad()

NotificationCenter.default.addObserver(

self,

selector: #selector(appDidEnterBackground),

name: UIApplication.didEnterBackgroundNotification,

object: nil

)

NotificationCenter.default.addObserver(

self,

selector: #selector(appWillEnterForeground),

name: UIApplication.willEnterForegroundNotification,

object: nil

)

}



@objc func appDidEnterBackground() {

DispatchQueue.global().async {

self.captureSession.stopRunning()

}

}



@objc func appWillEnterForeground() {

DispatchQueue.global().async {

self.captureSession.startRunning()

}

}

// 세션 인터럽트 감지

NotificationCenter.default.addObserver(

self,

selector: #selector(sessionWasInterrupted),

name: .AVCaptureSessionWasInterrupted,

object: captureSession

)



NotificationCenter.default.addObserver(

self,

selector: #selector(sessionInterruptionEnded),

name: .AVCaptureSessionInterruptionEnded,

object: captureSession

)



@objc func sessionWasInterrupted(notification: NSNotification) {

guard let userInfoValue = notification.userInfo?[AVCaptureSessionInterruptionReasonKey] as AnyObject?,

let reasonIntegerValue = userInfoValue.integerValue,

let reason = AVCaptureSession.InterruptionReason(rawValue: reasonIntegerValue) else { return }



switch reason {

case .videoDeviceNotAvailableInBackground:

print("백그라운드에서 카메라 사용 불가")

case .audioDeviceInUseByAnotherClient:

print("다른 앱이 마이크 사용 중")

case .videoDeviceInUseByAnotherClient:

print("다른 앱이 카메라 사용 중")

case .videoDeviceNotAvailableWithMultipleForegroundApps:

print("멀티태스킹 환경에서 카메라 사용 불가")

default: break

}

}



@objc func sessionInterruptionEnded(notification: NSNotification) {

print("카메라 인터럽트 종료 — 재개 가능")

DispatchQueue.global().async {

self.captureSession.startRunning()

}

}

// iOS 13+ 멀티 카메라

import AVFoundation



class MultiCamViewController: UIViewController {



var multiCamSession: AVCaptureMultiCamSession!



func setupMultiCam() {

// 멀티 카메라 지원 여부 확인

guard AVCaptureMultiCamSession.isMultiCamSupported else {

print("이 기기는 멀티 카메라를 지원하지 않습니다.")

return

}



multiCamSession = AVCaptureMultiCamSession()



multiCamSession.beginConfiguration()



// 후면 카메라 추가

if let backCamera = AVCaptureDevice.default(

.builtInWideAngleCamera, for: .video, position: .back

),

let backInput = try? AVCaptureDeviceInput(device: backCamera),

multiCamSession.canAddInput(backInput) {

multiCamSession.addInputWithNoConnections(backInput)

}



// 전면 카메라 추가

if let frontCamera = AVCaptureDevice.default(

.builtInWideAngleCamera, for: .video, position: .front

),

let frontInput = try? AVCaptureDeviceInput(device: frontCamera),

multiCamSession.canAddInput(frontInput) {

multiCamSession.addInputWithNoConnections(frontInput)

}



multiCamSession.commitConfiguration()



DispatchQueue.global(qos: .userInitiated).async {

self.multiCamSession.startRunning()

}

}

}

// 깊이 데이터 캡처 설정

func setupDepthCapture() {

let photoSettings = AVCapturePhotoSettings()



// 깊이 데이터 포함 여부

if photoOutput.isDepthDataDeliverySupported {

photoOutput.isDepthDataDeliveryEnabled = true

photoSettings.isDepthDataDeliveryEnabled = true

}



// 포트레이트 효과 매트 (배경 분리)

if photoOutput.isPortraitEffectsMatteDeliverySupported {

photoOutput.isPortraitEffectsMatteDeliveryEnabled = true

photoSettings.isPortraitEffectsMatteDeliveryEnabled = true

}



// 품질 우선순위 설정

photoSettings.photoQualityPrioritization = .quality  // .speed / .balanced / .quality



photoOutput.capturePhoto(with: photoSettings, delegate: self)

}



// 깊이 데이터 처리

func photoOutput(_ output: AVCapturePhotoOutput,

didFinishProcessingPhoto photo: AVCapturePhoto,

error: Error?) {



// 깊이 데이터 추출

if let depthData = photo.depthData {

let depthMap = depthData.converting(toDepthDataType:

kCVPixelFormatType_DepthFloat32)

let depthPixelBuffer = depthMap.depthDataMap

print("깊이 데이터 크기: \(CVPixelBufferGetWidth(depthPixelBuffer))x\(CVPixelBufferGetHeight(depthPixelBuffer))")

}

}

// 카메라 관련 로직을 분리한 Manager 클래스

class CameraManager: NSObject {



static let shared = CameraManager()

private override init() {}



// 세션

let session = AVCaptureSession()

private let sessionQueue = DispatchQueue(label: "com.app.cameraSession")



// 출력

private(set) var photoOutput = AVCapturePhotoOutput()

private(set) var videoDataOutput = AVCaptureVideoDataOutput()



// 현재 장치

private(set) var currentDevice: AVCaptureDevice?



// 상태

var isRunning: Bool { session.isRunning }



// 콜백

var onPhotoCapture: ((UIImage) -> Void)?

var onVideoFrame: ((CVPixelBuffer) -> Void)?



func configure(completion: @escaping (Bool) -> Void) {

sessionQueue.async { [weak self] in

guard let self = self else { return }

self.session.beginConfiguration()

let success = self.setupInputs() && self.setupOutputs()

self.session.commitConfiguration()

DispatchQueue.main.async { completion(success) }

}

}



func start() {

sessionQueue.async {

if !self.session.isRunning {

self.session.startRunning()

}

}

}



func stop() {

sessionQueue.async {

if self.session.isRunning {

self.session.stopRunning()

}

}

}



private func setupInputs() -> Bool {

guard let device = AVCaptureDevice.default(

.builtInWideAngleCamera, for: .video, position: .back

),

let input = try? AVCaptureDeviceInput(device: device),

session.canAddInput(input) else { return false }



session.addInput(input)

currentDevice = device

return true

}



private func setupOutputs() -> Bool {

guard session.canAddOutput(photoOutput),

session.canAddOutput(videoDataOutput) else { return false }



session.addOutput(photoOutput)

session.addOutput(videoDataOutput)



videoDataOutput.videoSettings = [

kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA

]

videoDataOutput.setSampleBufferDelegate(self, queue: sessionQueue)



return true

}

}

// 시뮬레이터와 실기기 분기 처리

#if targetEnvironment(simulator)

// 시뮬레이터: 더미 이미지 사용

func setupForSimulator() {

let placeholderImage = UIImage(systemName: "camera.fill")

previewImageView.image = placeholderImage

previewImageView.tintColor = .systemGray

print("⚠️ 시뮬레이터 환경 — 카메라 기능 제한됨")

}

#else

// 실기기: 실제 카메라 설정

func setupCamera() {

setupCaptureSession()

}

#endif

// 사진 방향 수정 유틸리티

extension UIImage {

func fixOrientation() -> UIImage {

if imageOrientation == .up { return self }



UIGraphicsBeginImageContextWithOptions(size, false, scale)

draw(in: CGRect(origin: .zero, size: size))

let normalizedImage = UIGraphicsGetImageFromCurrentImageContext()

UIGraphicsEndImageContext()



return normalizedImage ?? self

}

}



// 메모리 경고 처리

override func didReceiveMemoryWarning() {

super.didReceiveMemoryWarning()

// 캐시된 이미지 해제

imageCache.removeAllObjects()

print("⚠️ 메모리 경고 — 캐시 해제")

}