Working with Camera and Photos

import UIKit

class ViewController: UIViewController {
    let imagePicker = UIImagePickerController()

    override func viewDidLoad() {
        super.viewDidLoad()
        imagePicker.delegate = self
        imagePicker.sourceType = .camera
        imagePicker.allowsEditing = true
    }

    @IBAction func openCamera(_ sender: UIButton) {
        present(imagePicker, animated: true)
    }
}

extension ViewController: UIImagePickerControllerDelegate, UINavigationControllerDelegate {
    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        if let pickedImage = info[.editedImage] as? UIImage {
            // Use the picked image
        }
        dismiss(animated: true)
    }
}

import AVFoundation

func requestCameraPermission() {
    AVCaptureDevice.requestAccess(for: .video) { granted in
        if granted {
            print("Camera access granted")
        } else {
            print("Camera access denied")
        }
    }
}

import AVFoundation

let discoverySession = AVCaptureDevice.DiscoverySession(
    deviceTypes: [.builtInWideAngleCamera],
    mediaType: .video,
    position: .unspecified
)

for device in discoverySession.devices {
    print("Device name: \(device.localizedName)")
    print("Position: \(device.position)")
}

import Photos

PHPhotoLibrary.requestAuthorization(.readWrite) { status in
    switch status {
    case .authorized:
        print("Access granted")
    case .denied, .restricted:
        print("Access denied")
    default:
        print("Not determined")
    }
}

import Photos

let fetchOptions = PHFetchOptions()
fetchOptions.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]

let fetchResult = PHAsset.fetchAssets(with: .image, options: fetchOptions)

for i in 0..<fetchResult.count {
    let asset = fetchResult.object(at: i)
    print("Asset ID: \(asset.localIdentifier)")
}

import AVFoundation

class CameraViewController: UIViewController {
    let captureSession = AVCaptureSession()
    var previewLayer: AVCaptureVideoPreviewLayer?

    override func viewDidLoad() {
        super.viewDidLoad()
        setupCamera()
    }

    func setupCamera() {
        guard let videoDevice = AVCaptureDevice.default(for: .video) else { return }
        guard let videoInput = try? AVCaptureDeviceInput(device: videoDevice) else { return }

        captureSession.addInput(videoInput)
        previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer?.videoGravity = .resizeAspectFill
        view.layer.addSublayer(previewLayer!)
        
        captureSession.startRunning()
    }
}

import AVFoundation

class PhotoCaptureManager: NSObject, AVCapturePhotoCaptureDelegate {
    let photoOutput = AVCapturePhotoOutput()
    
    func setupPhotoCapture() {
        guard let photoOutput = photoOutput else { return }
        // Configure session with photo output
        session.addOutput(photoOutput)
    }
    
    func capturePhoto() {
        let photoSettings = AVCapturePhotoSettings()
        photoOutput.capturePhoto(with: photoSettings, delegate: self)
    }
    
    func photoOutput(_ output: AVCapturePhotoOutput, didFinishProcessingPhoto photo: AVCapturePhoto, error: Error?) {
        // Handle captured photo
    }
}

import AVFoundation
import UIKit

class VideoRecorderViewController: UIViewController {
    var captureSession: AVCaptureSession!
    var movieFileOutput: AVCaptureMovieFileOutput!
    var previewLayer: AVCaptureVideoPreviewLayer!

    override func viewDidLoad() {
        super.viewDidLoad()
        setupCamera()
    }

    func setupCamera() {
        captureSession = AVCaptureSession()
        captureSession.sessionPreset = .medium

        guard let backCamera = AVCaptureDevice.default(for: .video) else { return }
        let input = try! AVCaptureDeviceInput(device: backCamera)
        captureSession.addInput(input)

        movieFileOutput = AVCaptureMovieFileOutput()
        captureSession.addOutput(movieFileOutput)

        previewLayer = AVCaptureVideoPreviewLayer(session: captureSession)
        previewLayer.videoGravity = .resizeAspectFill
        view.layer.addSublayer(previewLayer)

        captureSession.startRunning()
    }

    @IBAction func recordButtonTapped() {
        let outputURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("output.mov")
        movieFileOutput.startRecording(to: outputURL, recordingDelegate: self)
    }

    @IBAction func stopButtonTapped() {
        movieFileOutput.stopRecording()
    }
}

extension VideoRecorderViewController: AVCaptureFileOutputRecordingDelegate {
    func fileOutput(_ output: AVCaptureFileOutput, didStartRecordingAt startTime: Date) {
        print("Started recording")
    }

    func fileOutput(_ output: AVCaptureFileOutput, didFinishRecordingAt: Date) {
        print("Finished recording")
    }
}

import AVFoundation

func requestCameraPermission() {
    AVCaptureDevice.requestAccess(for: .video) { granted in
        if granted {
            // Camera access granted
        } else {
            // Handle denied permission
        }
    }
}

import Photos

func requestPhotoLibraryPermission() {
    PHPhotoLibrary.requestAuthorization(for: .readWrite) { status in
        switch status {
        case .authorized:
            print("Photo library access granted")
        case .denied, .restricted:
            print("Photo library access denied")
        default:
            print("Permission not determined")
        }
    }
}

import Photos

func fetchRecentPhotos() {
    let fetchOptions = PHFetchOptions()
    fetchOptions.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]
    
    let fetchResult = PHAsset.fetchAssets(with: .image, options: fetchOptions)
    
    for i in 0..<fetchResult.count {
        let asset = fetchResult.object(at: i)
        print("Photo ID: \(asset.localIdentifier)")
    }
}

import Photos

func saveImageToPhotoLibrary(image: UIImage) {
    PHPhotoLibrary.shared().performChanges({
        PHAssetChangeRequest.creationRequestForAsset(from: image)
    }) { success, error in
        if success {
            print("Image saved successfully")
        } else {
            print("Failed to save image: \(error?.localizedDescription ?? "Unknown error")")
        }
    }
}

import Photos

guard let image = UIImage(named: "exampleImage") else { return }

PHPhotoLibrary.shared().performChanges({
    PHAssetChangeRequest.creationRequestForAsset(from: image)
}) { success, error in
    if success {
        print("Image saved successfully")
    } else {
        print("Error saving image: \(error?.localizedDescription ?? "Unknown error")")
    }
}

import Photos

let fetchOptions = PHFetchOptions()
fetchOptions.sortDescriptors = [NSSortDescriptor(key: "creationDate", ascending: false)]

let fetchResult = PHAsset.fetchAssets(with: .image, options: fetchOptions)

if let asset = fetchResult.firstObject {
    print("Local Identifier: \(asset.localIdentifier)")
    print("Media Type: \(asset.mediaType.rawValue)")
    print("Creation Date: \(asset.creationDate ?? Date())")
}

import Photos

let identifiers = ["identifier1", "identifier2", "identifier3"]
let fetchResult = PHAsset.fetchAssets(withLocalIdentifiers: identifiers, options: nil)

fetchResult.enumerateObjects { (asset, index, stop) in
    print("Photo at index \(index): \(asset.localIdentifier)")
}

import Photos

let livePhotoOptions = PHLivePhotoRequestOptions()
livePhotoOptions.deliveryMode = .opportunistic

PHImageManager.default().requestLivePhoto(
    for: photoAsset,
    options: livePhotoOptions
) { livePhoto, info in
    if let livePhoto = livePhoto {
        // Use the live photo asset
        print("Live photo requested successfully")
    }
}