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()