Cómo crear una extensión de acción en Swift
Primero cree un nuevo proyecto a través del menú Archivo gt; Nuevo proyecto, seleccione Aplicación de vista única:
Luego agregue un nuevo proyecto al proyecto a través del Archivo gt; ; menú Destino Destino, seleccione Extensión de acción:
Al crear una extensión de acción, debe especificar un tipo de Aciton. Apple proporciona dos plantillas de tipo para extensiones de acción. Un tipo tiene una interfaz de usuario, que incluye un
UIViewController y un archivo Storeboard, que puede personalizar la interfaz de visualización y el comportamiento. El otro es un tipo sin interfaz de usuario. Este tipo sólo nos permite manejar solicitudes desde la aplicación Host.
Ahora podemos ver la extensión de acción NoteAppExtension que acabamos de crear en el proyecto. Contiene dos archivos principales, uno es Action.js y el otro es ActionRequestHandler.swift:
Tomemos. un vistazo a lo que hacen estos dos archivos. El archivo Action.js se utiliza para implementar y procesar la lógica de las solicitudes en el navegador. En el ejemplo de este artículo, principalmente permite al usuario seleccionar texto en el navegador y enviarlo a nuestra aplicación. ActionRequestHandler.swift se utiliza para manejar solicitudes y parámetros enviados por la aplicación Host.
Antes de implementar la lógica, debemos configurar las propiedades de la extensión. Abra el archivo Info.plist y establezca la propiedad NSExtensionActivationSupportsWebURLWithMaxCount en 1. Esta configuración le permite a la extensión saber que necesitamos solicitar una URL.
Nuestro archivo Action.js contiene el siguiente contenido:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
var Acción = función() {};
Acción.prototipo = {
ejecutar: función(argumentos) {
// Aquí, puedes ejecutar código que modifica el documento y/o prepara
// cosas para pasar al código nativo de tu acción.
// No modificaremos nada, pero pasaremos el fondo del cuerpo
// estilo al código nativo.
var selected = "No Text Selected";
if (window.getSelection) { p>
seleccionado = window.getSelection().getRangeAt(0).toString();
} else {
seleccionado = document.getSelection().getRangeAt (0 ).toString();
}
argumentos.completionFunction({"args" : seleccionado}
},
finalize: function(arguments) {
// Este método se ejecuta después de que se completa el código nativo.
// Veremos si el código nativo nos ha pasado un nuevo estilo de fondo,
// y configúrelo en el cuerpo.
alert(arguments["message"])
}
};
var ExtensionPreprocessingJS = new Action
Safari
La interacción con la extensión Action es a través de Action.
Esto se implementa mediante los dos métodos ejecutar y finalizar en el archivo js. Cuando usamos la extensión Action en Safari
se llamará al método run, que nos permite operar los elementos DOM de la página de visualización actual de Safari en este método. El método
finalize se llamará cuando la extensión Action haya terminado de procesar la lógica y devuelva información a Safari. En nuestro ejemplo, pasamos
self.extensionContext!.completeRequestReturningItems(nil,
completionHandler:
nil) Este código devuelve información a Safari. El primer parámetro de este método es la información que se devolverá. Pasará la información al archivo Action.js y luego operará el HTML a través del código js.
Si se pasa nil como primer parámetro, significa que no se llamará al método de finalización en el archivo Action.js. Los parámetros de los dos métodos run y finalize contienen cierta información, pero uno es del HTML y el otro es del archivo ActionRequestHandler.
Asegúrate de recordar: debemos crear una instancia de la variable global ExtensionPreprocessingJS porque es el puente entre las extensiones de Safari y Action.
El contenido de nuestro archivo ActionRequestHandler es el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
p>24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
p>49
50
51
52
53
54
55
56
57
58
clase ActionRequestHandler: NSObject, NSExtensionRequestHandling {
var extensionContext: NSExtensionContext?
func beginRequestWithExtensionContext(context: NSExtensionContext!) {
self.extensionContext = contexto
let identifierType = NSString (formato: kUTTypePropertyList, NSUTF8StringEncoding)
para (item: NSExtensionItem) en context.inputItems como [NSExtensionItem] {
para (itemProvider: NSItemProvider) en item.attachments como [NSItemProvider] {
if itemProvider.hasItemConformingToTypeIdentifier(identifierType) {
itemProvider.loadItemForTypeIdentifier(identifierType, opciones: nil, completeHandler: {(item, error) en
let diccionario = elemento como NSDictionary
d
ispatch_async(dispatch_get_main_queue(), {
self.itemLoadCompletedWithPreprocessingResults(diccionario[NSExtensionJavaScriptPreprocessingResultsKey] como NSDictionary)
})
})
}
}
}
}
func itemLoadCompletedWithPreprocessingResults(javaScriptPreprocessingResults: NSDictionary) {
if let text = javaScriptPreprocessingResults["args"] as? String {
let userDefaults = NSUserDefaults(suiteName: "group.name")
userDefaults.setValue(text, forKey: "nota")
userDefaults.synchronize()
self.doneWithResults(["message": "Agregado exitosamente a la aplicación de notas"])
}
}
func doneWithResults(resultsForJavaScriptFinalizeArg: NSDictionary?) {
if let resultsForJavaScriptFinalize = resultsForJavaScriptFinalizeArg {
let identifierType = NSString(formato: kUTTypePropertyList, NSUTF8StringEncoding )
// Construya un NSExtensionItem del tipo apropiado para devolver nuestro
// diccionario de resultados.
// Estos se utilizarán como argumentos para el método JavaScript finalize()
//.
var resultsDictionary = [NSExtensionJavaScriptFina
lizeArgumentKey: resultsForJavaScriptFinalize]
var resultsProvider = NSItemProvider(item: resultsDictionary, typeIdentifier: identifierType)
var resultsItem = NSExtensionItem()
resultsItem.attachments = [resultsProvider ]
// Señala que hemos completado y devuelve nuestros resultados.
self.extensionContext!.completeRequestReturningItems([resultsItem], completeHandler: nil)
} else {
// Aún necesitamos indicar que hemos terminado incluso si no tenemos nada que
// devolver.
self.extensionContext !.completeRequestReturningItems(nil, completeHandler: nil)
}
// No guardes esto después de que hayamos terminado.
self.extensionContext = nil
}
}
Ahora podemos ejecutar nuestra aplicación, luego abrir Safari y habilitar nuestra extensión Acción en la opción Acción:
p >Luego podemos ver nuestra extensión en la barra de Acción:
Usamos Safari para abrir una página que contiene texto, seleccionamos un fragmento de texto, luego abrimos la barra de Acción y hacemos clic en la extensión NoteApp, en este momento nuestra extensión enviará el texto seleccionado a nuestra aplicación, formando un nuevo mensaje importante.
Lo anterior es solo un ejemplo simple de la extensión Aciton, pero podemos extenderlo a funciones más útiles y creativas para mejorar nuestras vidas.