Swift Academy · Aula

Visão geral das extensões de aplicativos

Entenda extensões de compartilhamento, ação e outras.

Visão geral das extensões de aplicativos é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

O que são extensões de aplicativos

Uma extensão de aplicativo permite que seu aplicativo forneça funcionalidades dentro de outros aplicativos ou áreas do sistema — compartilhamento de conteúdo, teclados personalizados, indexação do Spotlight e muito mais. Cada extensão é um destino separado, com seu próprio ciclo de vida, sandbox e ponto de entrada definidos pelo sistema.

// Extensions run in their own process, launched
// by the host (Photos, Safari, Messages, the system),
// not by your main app.

Aplicativo hospedeiro, contêiner e sandbox

Há três participantes: o aplicativo hospedeiro chama a extensão, o seu aplicativo contêiner a distribui e a própria extensão é executada em um sandbox. A extensão não pode se comunicar livremente com o seu aplicativo: eles se comunicam por meio de um Grupo de Aplicativos, nunca por acesso direto à memória.

import Foundation
// Container app + Extension target share data via
// an App Group, e.g. group.com.example.app
let group = "group.com.example.app"
_ = group

Extensões de compartilhamento

Uma extensão de compartilhamento aparece na folha de compartilhamento do sistema, permitindo que os usuários enviem conteúdo (texto, URLs e imagens) de qualquer aplicativo para o seu. Ela é uma subclasse de um controlador de visualização ou hospeda um, e lê os itens compartilhados no contexto da extensão.

import Foundation
// Share extension reads incoming items:
// extensionContext?.inputItems
//   each NSExtensionItem has attachments (NSItemProvider)
let share = "appears in the share sheet"
_ = share

Leitura de itens compartilhados

O conteúdo compartilhado chega como anexos NSItemProvider. Você verifica o identificador de tipo e carrega o valor de forma assíncrona. É assim que uma extensão de compartilhamento obtém a URL ou a imagem que o usuário está compartilhando.

import UniformTypeIdentifiers
func handle(_ provider: NSItemProvider) {
    if provider.hasItemConformingToTypeIdentifier(
        UTType.url.identifier) {
        provider.loadItem(
            forTypeIdentifier: UTType.url.identifier) {
            value, _ in
            print("shared url:", value ?? "none")
        }
    }
}

Extensões de ação

Uma extensão de ação transforma ou exibe conteúdo no próprio local — traduzir um texto selecionado, fazer anotações em um PDF — e pode retornar um resultado ao aplicativo hospedeiro. Ao contrário de uma extensão de compartilhamento, ela foi projetada para agir sobre o conteúdo, e não para enviá-lo a outro lugar.

import Foundation
// Action extension may return modified items:
// extensionContext?.completeRequest(
//     returningItems: outputItems)
let action = "acts on content, can return a result"
_ = action

Extensão de serviço de notificações

Uma extensão de serviço de notificações intercepta notificações push recebidas com mutable-content: 1 para modificá-las antes da exibição — descriptografar o corpo, baixar um anexo de mídia ou reescrever o título — dentro de um limite curto de tempo.

import UserNotifications
// Override in UNNotificationServiceExtension:
// didReceive(_ request:, withContentHandler:)
//   mutate bestAttemptContent, then call the handler
let service = "modifies push before it shows"
_ = service

Extensão de conteúdo de notificações

Uma extensão de conteúdo de notificações fornece uma interface personalizada para uma notificação expandida — um mapa, um reprodutor de mídia ou controles interativos — exibida quando o usuário mantém o dedo pressionado sobre o banner. Ela é vinculada a uma categoria de notificação.

import UserNotifications
// UNNotificationContentExtension renders a custom view
// for a given UNNotificationCategory when expanded.
let content = "custom expanded notification UI"
_ = content

O ciclo de vida de completeRequest

As extensões têm vida curta. Quando terminar, chame extensionContext?.completeRequest(returningItems:completionHandler:) para sinalizar a conclusão e permitir que o aplicativo hospedeiro feche a extensão. Para interrompê-la, use cancelRequest(withError:). Manter o processo aberto desperdiça recursos, e ele pode ser encerrado.

import Foundation
func finish(context: NSExtensionContext?) {
    context?.completeRequest(
        returningItems: [], completionHandler: nil)
}

Outros pontos de extensão

O iOS oferece muitos pontos de extensão: teclados personalizados, provedores de documentos, indexação do Spotlight, bloqueadores de conteúdo do Safari, intenções da Siri, edição de fotos e extensões de provedor de arquivos. Cada um está em conformidade com um protocolo definido pelo sistema, declarado por um NSExtensionPointIdentifier no Info.plist.

// Info.plist of an extension declares its point:
// NSExtension > NSExtensionPointIdentifier
//   e.g. com.apple.share-services
//        com.apple.usernotifications.service
let point = "each extension declares its point"
_ = point

Limites de memória e tempo

As extensões são executadas sob limites mais rigorosos que o aplicativo principal — têm menos memória e um limite curto de tempo de execução. Faça o mínimo necessário, evite alocações grandes e, quando possível, transfira o processamento pesado para o aplicativo principal usando armazenamento compartilhado.

import Foundation
// Tight memory + short runtime.
// Pattern: extension stages data in the App Group,
// the main app processes it fully on next launch.
let limits = "keep extensions lean and fast"
_ = limits

Compartilhamento de código entre destinos

Para evitar duplicar a lógica, coloque os modelos e auxiliares compartilhados em um framework ou pacote Swift do qual tanto o aplicativo quanto a extensão dependam. Marque apenas o que cada destino precisa; a extensão vincula o mesmo código sem copiá-lo.

import Foundation
// Shared Swift package 'AppCore' linked by:
//   - main app target
//   - share extension target
//   - widget extension target
let shared = "one source of truth for models"
_ = shared

Verificação rápida

Relembre como uma extensão se comunica com o aplicativo contêiner.

Recapitulação

Você conheceu as extensões de aplicativos:

As extensões são destinos separados e isolados em sandbox, iniciados por um aplicativo hospedeiro; os tipos incluem extensões de compartilhamento, ação, serviço de notificações e conteúdo de notificações.
Leia o conteúdo recebido por meio de NSItemProvider e finalize com completeRequest.
Cada extensão declara seu NSExtensionPointIdentifier e é executada sob limites rigorosos de memória e tempo.
Compartilhe dados por meio de um Grupo de Aplicativos e reutilize o código usando um pacote compartilhado.

Perguntas Frequentes

A aula “Visão geral das extensões de aplicativos” é grátis?

Sim — o texto completo de “Visão geral das extensões de aplicativos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Visão geral das extensões de aplicativos”?

Entenda extensões de compartilhamento, ação e outras. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Visão geral das extensões de aplicativos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Criando um WidgetKit Widget
Provedores de linha do tempo e instantâneos
Visão geral das extensões de aplicativos
App Intents e atalhos

← Voltar para Swift Academy