Action Extension: vad är det, hur fungerar det och utveckling av tillägg

Vad är Action Extension

Action Extension — är en typ av iOS-apptillägg som låter dig utföra en åtgärd på innehåll direkt i värdappens sammanhang. Användaren markerar text i Safari, trycker på “Åtgärder” och väljer till exempel “Kontrollera stavning” — tillägget bearbetar texten och returnerar resultatet utan att lämna webbläsaren. Tillägget tar emot indata via NSExtensionContext och kan returnera det ändrade innehållet.

Action Extension dök upp i iOS 8 som en del av arkitekturen för apptillägg. Dess viktigaste egenskap är att tillägget inte har något eget gränssnitt (valfritt) och körs i värdappens sammanhang. Användaren lämnar inte den aktuella skärmen, vilket säkerställer minimalt kognitivt avbrott. Enligt Apple är Action Extension den enda typen av tillägg som samtidigt kan läsa och ändra innehållet i värdappen (via NSExtensionContext med returnering av resultatet).

Var används Action Extension

Action Extension används i olika scenarier: översättning av text i webbläsaren, skapa PDF från en webbsida, applicera ett filter på ett foto i galleriet, kontrollera stavning i valfritt textfält, förkorta URL, kryptera text och lägga till i bokmärken. Action Extensions mångsidighet gör det till ett populärt verktyg för appar i kategorierna “Verktyg” och “Produktivitet”.

Action Extension vs Share Extension

Action Extension och Share Extension förväxlas ofta, men deras syfte är fundamentalt olika. Share Extension skickar innehåll från värdappen till din app; Action Extension bearbetar innehållet och skickar tillbaka det. Skillnaden påverkar arkitekturen, användarupplevelsen och konfigurationskraven för Info.plist.

Hur användaren väljer åtgärd

Action Extension visas i åtgärdsmenyn (Action Sheet) när knappen “Dela” eller “...” trycks in. iOS placerar automatiskt Action Extensions i den övre delen av arket (åtgärder) och Share Extensions i den nedre delen (appar). Användarscenario: markerade text → tryckte på “Åtgärder” → valde ditt Action Extension → fick bearbetat resultat utan att växla appar.

Arkitektur för Action Extension

Action Extension består av en target i Xcode, UIViewController för att visa gränssnittet (valfritt), NSExtensionContext för in- och utdata samt Info.plist-konfiguration. Arkitekturen är enklare än för Share Extension: det finns inget obligatoriskt kompositionsgränssnitt och tillägget kan fungera helt utan UI.

Komponenter i Action Extension

Target — en separat bundle med en identifierare som ärvs från huvudappen. UIViewController — valfritt gränssnitt för att visa förlopp, inställningar eller resultat. NSExtensionContext — behållare med indata (inputItems) och metoden completeRequest för att returnera resultatet. Info.plist — aktiveringskonfiguration via NSExtensionActivationRule och attribut (NSExtensionAttributes) för att ange vilka innehållstyper som stöds.

NSExtensionContext och dataflöden

Action Extension tar emot indata via extensionContext?.inputItems — en array av NSExtensionItem. Varje element innehåller bilagor med data och UTI. Efter bearbetning anropar tillägget completeRequest(returningItems:) med en array av utgående NSExtensionItem. Värdappen tar emot den bearbetade datan och visar den. Asynkron modell: tillägget kan utföra långvariga operationer och hålla sammanhanget i upp till 30 sekunder.

Skapa Action Extension

Låt oss titta på att skapa ett Action Extension i Swift för att översätta markerad text. Tillägget tar emot text från värdappen, skickar den till en översättningsserver och returnerar resultatet. ActionViewController — den grundläggande kontrollern som Xcode skapar när du lägger till en target.

import UIKit
import MobileCoreServices

class ActionViewController: UIViewController {

    @IBOutlet var resultLabel: UILabel!

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

    func extractTextAndTranslate() {
        guard let item = extensionContext?.inputItems.first
                as? NSExtensionItem
        else { return }

        for attachment in item.attachments ?? [] {
            attachment.loadItem(
                forTypeIdentifier: kUTTypePlainText as String
            ) { [weak self] (text, error) in
                guard let inputText = text as? String else { return }
                TranslationService().translate(inputText, from: "en", to: "ru") {
                    translated in
                    DispatchQueue.main.async {
                        self?.resultLabel?.text = translated
                    }
                }
            }
        }
    }
}

Efter bearbetning returnerar tillägget resultatet till värdappen. completeRequest med utdata — det alternativa scenariot när tillägget inte visar UI utan omedelbart returnerar det bearbetade innehållet.

// Returnera bearbetad text till värdappen
let resultItem = NSExtensionItem()
let resultData = translated.data(using: .utf8)!
let attachment = NSItemProvider(
    item: resultData,
    typeIdentifier: kUTTypePlainText as String
)
resultItem.attachments = [attachment]
extensionContext?.completeRequest(
    returningItems: [resultItem], completionHandler: nil
)

Databehandling och returnering av resultat

Action Extension kan fungera i två lägen: med UI och utan UI. I läget utan UI utför tillägget åtgärden helt i bakgrunden och anropar completeRequest omedelbart efter bearbetning. I läget med UI visar tillägget en kontroller, användaren bekräftar åtgärden och först då skickar completeRequest resultatet. Val av läge beror på åtgärdens komplexitet och behovet av användarinmatning.

Ladda data från bilaga

Metoden loadItem(forTypeIdentifier:) fungerar asynkront — data kan vara stor (bilder, video). NSItemProvider hanterar strömningsladdning och cachning. För bilder använd kUTTypeImage, för filer — kUTTypeFileURL. Viktigt: loadItem kan anropas på en bakgrundstråd — uppdatera UI endast via DispatchQueue.main.

Returnera ändrad data

Action Extension returnerar bearbetad data via completeRequest med en array av NSExtensionItem. Varje element motsvarar typen av utdata. Värdappen kan ersätta det ursprungliga innehållet med bearbetat — till exempel ersätta den ursprungliga bilden med en filtrerad. NSExtensionItem stöder samma UTI som vid inmatning, plus ytterligare (till exempel public.html för webbinnehåll).

Användningsscenarier för Action Extension

Action Extension tillämpas i dussintals scenarier — från enkla verktyg till komplexa affärsprocesser. Klassiska exempel omfattar text-, grafik- och filoperationer, samt integration med webbinnehåll.

Textscenarier

Action Extension för text: översättning, stavningskontroll, teckenräkning, ändring av skiftläge, kryptering, skapa QR-kod från text. Användaren markerar text i valfri app med ett textfält (Safari, Anteckningar, Mail) och utför åtgärden med ett klick. Syntaxmarkering av kod, Markdown-formatering och URL-förkortning — populära exempel på Action Extension för avancerade användare.

Grafikscenarier

För bilder erbjuder Action Extension: applicera filter, beskrära, ändra storlek, formatkonvertering (HEIC till JPEG), lägga till vattenstämpel, textigenkänning (OCR) och komprimering. Bildbehandling måste vara snabb — användaren förväntar sig resultat inom 2–3 sekunder. För tunga operationer, använd Core Image på GPU eller bakgrundsköer.

Webbscenarier

Action Extension för URL: skapa PDF från en webbsida, spara i Pocket/Pinterest, kontrollera webbplatshastighet, arkivera sida, hämta Open Graph-metadata, generera skärmdump av sida. PDF-generering — ett av de mest populära scenarierna: användaren konverterar en webbsida till PDF utan att öppna tredjepartstjänster.