ios - Trabajar con fotos en vivo en el patio de recreo

swift uikit

Question

He hecho una buena cantidad de búsquedas en la web, pero actualmente estoy intentando trabajar con "Live Photos" en Playground. Soy consciente del marco (PHLivePhoto), simplemente no tengo idea si trabajar con ellos en Playground es posible debido a que no hay mucho que "importar" ya que no parece haber ninguna "Fotos en vivo" para descargar en línea. ¿Algunas ideas?

Answer 1

Es posible hacer y ver un PHLivePhoto en el patio de juegos a partir de los elementos de una Live Photo real .

En la aplicación Photos OS X, seleccione una foto en vivo y vaya al menú

Archivo> Exportar> Exportar original ...

.JPG un .JPG y un .mov .

Coloque estos dos archivos en la carpeta Resources del área de juegos (menú Ver> Navegadores> Mostrar navegador de proyectos).

Obtenga las URL de estos dos archivos con NSBundle (en mi ejemplo, los archivos son "IMG_0001.JPG" y "IMG_0001.mov"):

let imgURL = NSBundle.mainBundle().URLForResource("IMG_0001", withExtension: "JPG")!
let movURL = NSBundle.mainBundle().URLForResource("IMG_0001", withExtension: "mov")!

Y cree una imagen real, la necesitaremos para la imagen de vista previa de Live Photo:

let prevImg = UIImage(named: "IMG_0001.JPG")!

Importar los marcos necesarios:

import Photos
import PhotosUI
import XCPlayground

Y configura el Patio de Juegos en modo asíncrono:

XCPlaygroundPage.currentPage.needsIndefiniteExecution = true

Ahora vamos a utilizar el método requestLivePhotoWithResourceFileURLs para crear un PHLivePhoto a partir de nuestros elementos:

func makeLivePhotoFromItems(imageURL: NSURL, videoURL: NSURL, previewImage: UIImage, completion: (livePhoto: PHLivePhoto) -> Void) {
    PHLivePhoto.requestLivePhotoWithResourceFileURLs([imageURL, videoURL], placeholderImage: previewImage, targetSize: CGSizeZero, contentMode: PHImageContentMode.AspectFit) {
        (livePhoto, infoDict) -> Void in
        // for debugging: print(infoDict)
        if let lp = livePhoto {
            completion(livePhoto: lp)
        }
    }
}

Entonces llamamos así:

makeLivePhotoFromItems(imgURL, videoURL: movURL, previewImage: prevImg) { (livePhoto) -> Void in
    // "livePhoto" is your PHLivePhoto object
}

Por ejemplo, digamos que desea que el Área de juegos haga una vista en vivo:

makeLivePhotoFromItems(imgURL, videoURL: movURL, previewImage: prevImg) { (livePhoto) -> Void in
    let rect = CGRect(x: 0, y: 0, width: 2048, height: 1536)
    let livePhotoView = PHLivePhotoView(frame: rect)
    livePhotoView.livePhoto = livePhoto
    XCPlaygroundPage.currentPage.liveView = livePhotoView
    livePhotoView.startPlaybackWithStyle(PHLivePhotoViewPlaybackStyle.Full)
}

Tenga en cuenta que ya que no hay manera de interactuar con la vista en vivo para iniciar la reproducción de la Foto en vivo, tenemos que hacerlo nosotros mismos con el método startPlaybackWithStyle .

Puede forzar que la vista en vivo aparezca en el Patio de juegos al mostrar el Asistente del Editor en el menú

Ver> Editor asistente> Mostrar editor asistente

Nota: el Playground puede tardar un tiempo en crear PHLivePhoto e iniciar la visualización en vivo.

Con Xcode 7.3b + finalmente podemos tener alguna interacción de interfaz de usuario en Playgrounds.

He hecho una adaptación de esta respuesta con una vista simple y tocaBegan, simplemente haga clic en LivePhoto cuando la consola lo diga:

import UIKit
import XCPlayground

import Photos
import PhotosUI

class PLView: UIView {

    let image: UIImage
    let imageURL: NSURL
    let videoURL: NSURL

    let liveView: PHLivePhotoView

    init(image: UIImage, imageURL: NSURL, videoURL: NSURL) {
        self.image = image
        self.imageURL = imageURL
        self.videoURL = videoURL
        let rect = CGRect(x: 0, y: 0, width: image.size.width, height: image.size.height)
        self.liveView = PHLivePhotoView(frame: rect)
        super.init(frame: rect)
        self.addSubview(self.liveView)
    }

    func prepareLivePhoto() {
        makeLivePhotoFromItems { (livePhoto) in
            self.liveView.livePhoto = livePhoto
            print("/nReady! Click on the LivePhoto in the Assistant Editor panel!/n")
        }
    }

    override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        print("/nClicked! Wait for it.../n")
        self.liveView.startPlaybackWithStyle(.Full)
    }

    private func makeLivePhotoFromItems(completion: (PHLivePhoto) -> Void) {
        PHLivePhoto.requestLivePhotoWithResourceFileURLs([imageURL, videoURL], placeholderImage: image, targetSize: CGSizeZero, contentMode: .AspectFit) {
            (livePhoto, infoDict) -> Void in
            // This "canceled" condition is just to avoid redundant passes in the Playground preview panel.
            if let canceled = infoDict[PHLivePhotoInfoCancelledKey] as? Int where canceled == 0 {
                if let livePhoto = livePhoto {
                    completion(livePhoto)
                }
            }
        }
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

}



XCPlaygroundPage.currentPage.needsIndefiniteExecution = true

let plview = PLView(image: UIImage(named: "IMG_0001.JPG")!,
                 imageURL: NSBundle.mainBundle().URLForResource("IMG_0001", withExtension: "JPG")!,
                 videoURL: NSBundle.mainBundle().URLForResource("IMG_0001", withExtension: "mov")!)

XCPlaygroundPage.currentPage.liveView = plview

plview.prepareLivePhoto()

El mismo ejemplo para Swift 3.0.2 (Xcode 8.2.1 ):

import UIKit
import PlaygroundSupport
import Photos
import PhotosUI

class PLView: UIView {

    let image: UIImage
    let imageURL: URL
    let videoURL: URL

    let liveView: PHLivePhotoView

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    init(image: UIImage, imageURL: URL, videoURL: URL) {
        self.image = image
        self.imageURL = imageURL
        self.videoURL = videoURL
        let rect = CGRect(x: 0, y: 0, width: 300, height: 400)
        self.liveView = PHLivePhotoView(frame: rect)
        super.init(frame: rect)
        self.addSubview(self.liveView)
    }

    func prepareLivePhoto() {
        makeLivePhotoFromItems { (livePhoto) in
            self.liveView.livePhoto = livePhoto
            print("/nReady! Click on the LivePhoto in the Assistant Editor panel!/n")
        }
    }

    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        print("/nClicked! Wait for it.../n")
        self.liveView.startPlayback(with: .full)
    }

    private func makeLivePhotoFromItems(completion: @escaping (PHLivePhoto) -> Void) {
        PHLivePhoto.request(withResourceFileURLs: [imageURL, videoURL], placeholderImage: image, targetSize: CGSize.zero, contentMode: .aspectFit) {
            (livePhoto, infoDict) -> Void in

            if let canceled = infoDict[PHLivePhotoInfoCancelledKey] as? NSNumber,
                canceled == 0,
                let livePhoto = livePhoto
            {
                completion(livePhoto)
            }
        }
    }

}

let plview = PLView(image: UIImage(named: "IMG_0001.JPG")!,
                    imageURL: Bundle.main.url(forResource: "IMG_0001", withExtension: "JPG")!,
                    videoURL: Bundle.main.url(forResource: "IMG_0001", withExtension: "mov")!)

PlaygroundPage.current.needsIndefiniteExecution = true
PlaygroundPage.current.liveView = plview

plview.prepareLivePhoto()