Reutilizar páginas do Xamarin.Forms em uma extensão do iOS

Artigo
07/13/2023

As extensões do iOS permitem personalizar o comportamento do sistema existente adicionando funcionalidade extra aos pontos de extensão do iOS e macOS predefinidos, como ações de contexto personalizadas, preenchimento automático de senha, filtros de chamadas de entrada, modificadores de conteúdo de notificação e muito mais. O Xamarin.iOS dá suporte a extensões e este guia orientará você na criação de uma extensão do iOS usando ferramentas do Xamarin.

As extensões são distribuídas como parte de um aplicativo contêiner e ativadas de um Ponto de Extensão específico em um aplicativo Host. O aplicativo Contêiner geralmente é um aplicativo iOS simples, que fornece a um usuário informações sobre a Extensão, como ativá-lo e usá-lo. Há três abordagens main para compartilhar código entre uma extensão e um aplicativo de contêiner:

Projeto iOS comum.

Você pode colocar todo o código compartilhado entre o Contêiner e a Extensão em uma biblioteca do iOS compartilhada e fazer referência à biblioteca de ambos os projetos. Normalmente, a biblioteca compartilhada contém UIViewControllers nativos e precisa ser uma biblioteca Xamarin.iOS.
Links de arquivo.

Em alguns casos, o aplicativo Contêiner fornece a maior parte da funcionalidade, enquanto a Extensão precisa renderizar um único UIViewController. Com poucos arquivos a serem compartilhados, é comum adicionar um link de arquivo ao aplicativo Extensão do arquivo localizado no aplicativo Contêiner.
Projeto Xamarin.Forms comum.

Se as páginas de aplicativo já estiverem compartilhadas com outra plataforma, como o Android, usando a estrutura do Xamarin.Forms, a abordagem comum será reimplementar as páginas necessárias nativamente no projeto Extensão, pois a Extensão do iOS funciona com páginas nativas UIViewControllers e não Xamarin.Forms. Você precisa executar etapas adicionais para usar o Xamarin.Forms na extensão do iOS, que são explicadas abaixo.

Xamarin.Forms em um projeto de extensão do iOS

A capacidade de usar o Xamarin.Forms em um projeto nativo é fornecida por meio de Formulários Nativos. Ele permite que páginas derivadas de sejam adicionadas ContentPagediretamente a projetos nativos do Xamarin.iOS. O CreateViewController método de extensão converte uma instância de uma página do Xamarin.Forms em um nativo UIViewController, que pode ser usado ou modificado como um controlador regular. Como uma Extensão do iOS é um tipo especial de um projeto nativo do iOS, você também pode usar os Formulários Nativos aqui.

Importante

Há muitas limitações conhecidas para extensões do iOS. Embora você possa usar o Xamarin.Forms em uma Extensão do iOS, faça isso com muito cuidado, monitorando o uso da memória e o tempo de inicialização. Caso contrário, a Extensão poderá ser encerrada pelo iOS sem nenhuma maneira de lidar com isso normalmente.

Passo a passo

Neste passo a passo, você criará um aplicativo Xamarin.Forms, uma Extensão Xamarin.iOS e reutilizará o código compartilhado no projeto de extensão:

Abra Visual Studio para Mac, crie um novo projeto do Xamarin.Forms usando o modelo aplicativo Formulários Em Branco e nomeie-o FormsShareExtension:

Em FormsShareExtension/MainPage.xaml, substitua o conteúdo pelo seguinte layout:

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage
    x:Class="FormsShareExtension.MainPage"
    xmlns="http://xamarin.com/schemas/2014/forms"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    xmlns:d="http://xamarin.com/schemas/2014/forms/design"
    xmlns:local="clr-namespace:FormsShareExtension"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    x:DataType="local:MainPageViewModel"
    BackgroundColor="Orange"
    mc:Ignorable="d">
    <ContentPage.BindingContext>
        <local:MainPageViewModel Message="Hello from Xamarin.Forms!" />
    </ContentPage.BindingContext>
    <StackLayout HorizontalOptions="Center" VerticalOptions="Center">
        <Label
            Margin="20"
            Text="{Binding Message}"
            VerticalOptions="CenterAndExpand" />
        <Button Command="{Binding DoCommand}" Text="Do the job!" />
    </StackLayout>
</ContentPage>

Adicione uma nova classe chamada MainPageViewMode ao projeto FormsShareExtension e substitua o conteúdo da classe pelo seguinte código:

using System;
using System.ComponentModel;
using System.Windows.Input;
using Xamarin.Forms;

namespace FormsShareExtension
{
    public class MainPageViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private string _message;
        public string Message
        {
            get { return _message; }
            set
            {
                if (_message != value)
                {
                    _message = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Message)));
                }
            }
        }

        private ICommand _doCommand;
        public ICommand DoCommand
        {
            get { return _doCommand; }
            set
            {
                if(_doCommand != value)
                {
                    _doCommand = value;
                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(DoCommand)));
                }
            }
        }

        public MainPageViewModel()
        {
            DoCommand = new Command(OnDoCommandExecuted);
        }

        private void OnDoCommandExecuted(object state)
        {
            Message = $"Job {Environment.TickCount} has been completed!";
        }
    }
}

O código é compartilhado em todas as plataformas e também será usado por uma Extensão do iOS.

No painel de solução, clique com o botão direito do mouse na solução, selecione Adicionar > Nova Extensão de Ação de Extensão > do iOS > do Projeto>, nomeie-a como MyAction e pressione Criar:
Para usar o Xamarin.Forms na Extensão do iOS e no código compartilhado, você precisa adicionar as referências necessárias:
- Clique com o botão direito do mouse na Extensão do iOS, selecione Referências > Adicionar Projetos > de Referência > FormsShareExtension e pressione OK.
- Clique com o botão direito do mouse na Extensão do iOS, selecione Pacotes Gerenciar Pacotes > NuGet... > Xamarin.Forms e pressione Adicionar Pacote.
Expanda o projeto de extensão e modifique um ponto de entrada para inicializar o Xamarin.Forms e criar páginas. De acordo com os requisitos do iOS, uma Extensão deve definir o ponto de entrada em Info.plist como NSExtensionMainStoryboard ou NSExtensionPrincipalClass. Depois que o ponto de entrada é ativado, nesse caso é o ActionViewController.ViewDidLoad método , você pode criar uma instância de uma página do Xamarin.Forms e mostrá-la a um usuário. Portanto, abra o ponto de entrada e substitua o ViewDidLoad método pela seguinte implementação:
```
public override void ViewDidLoad()
{
    base.ViewDidLoad();

    // Initialize Xamarin.Forms framework
    global::Xamarin.Forms.Forms.Init();
    // Create an instance of XF page with associated View Model
    var xfPage = new MainPage();
    var viewModel = (MainPageViewModel)xfPage.BindingContext;
    viewModel.Message = "Welcome to XF Page created from an iOS Extension";
    // Override the behavior to complete the execution of the Extension when a user press the button
    viewModel.DoCommand = new Command(() => DoneClicked(this));
    // Convert XF page to a native UIViewController which can be consumed by the iOS Extension
    var newController = xfPage.CreateViewController();
    // Present new view controller as a regular view controller
    this.PresentModalViewController(newController, false);
}
```
O MainPage é instanciado usando um construtor padrão e antes que você possa usá-lo na Extensão, converta-o em um nativo UIViewController usando o CreateViewController método de extensão.

Crie e execute o aplicativo:

Para ativar a Extensão, navegue até o navegador Safari, digite qualquer endereço Web, por exemplo, microsoft.com, pressione navegar e pressione o ícone Compartilhar na parte inferior da página para ver as extensões de ação disponíveis. Na lista de extensões disponíveis, selecione a Extensão MyAction tocando nela:

A Extensão é ativada e a página Xamarin.Forms é exibida para o usuário. Todas as associações e comandos funcionam como no aplicativo Contêiner.
O controlador de exibição de ponto de entrada original está visível porque é criado e ativado pelo iOS. Para corrigir isso, altere o estilo de apresentação modal para UIModalPresentationStyle.FullScreen para o novo controlador adicionando o seguinte código logo antes da PresentModalViewController chamada:
```
newController.ModalPresentationStyle = UIModalPresentationStyle.FullScreen;
```
Crie e execute no simulador do iOS ou em um dispositivo:

Importante

Para a compilação do dispositivo, use as configurações de build adequadas e a configuração de versão , conforme descrito aqui.