No artigo de hoje vou mostrar como criar uma aplicação multiplataforma que pode ser usada no Windows Phone, Android e iOS, usando o Xamarin.Forms com acesso ao banco de dados SQLite usando o Visual Studio e a linguagem C#.

O Xamarin é a plataforma que permite que você crie aplicações multiplataformas para dispositivos móveis incluindo o Android, iOS e o Windows Phone. E são aplicativos multiplataforma nativos onde você compartilha 75% do código entre as 3 plataformas e escreve o código para a interface de usuário para cada plataforma usando o código nativo específico.

O Xamarin.Forms, que roda na plataforma Xamarin, vai mais longe; ele permite criar aplicações multiplataformas que compartilha a interface do usuário com as três plataformas: Android, iOS e Windows Phone.

Nota: Para desenvolver a interface de usuário para uma plataforma específica podemos usar: Xamarin.Android, Xamarin.iOS, e Windows Phone SDK.

Nosso objetivo será criar uma aplicação multiplataforma para Android e iOS usando o Xamarin.Forms.  (o desenvolvimento para Windows Phone eu abordo em outro artigo).

No caso da aplicação para iOS, a utilização do Apple SDK, que responsável pelo build e pela depuração da aplicação, só é possível através de um Mac em rede com a máquina Windows que utiliza o Visual Studio (podemos ter o Mac emulado em um VMWare, mas tenho ouvido falar que o desempenho é sofrível e além disso, esse procedimento não é autorizado pela Apple).

Nota: Se você tem um Mac, pode criar uma máquina virtual com Windows, instalar o Visual Studio, e então, pode abrir os programas que rodam no Windows em janelas dentro do OS x.

Resumindo, se você quiser gerar um aplicação para iOS, você tem que ter um Mac, caso contrário você só vai conseguir compilar para Android e Windows.

Então como eu não tenho um Mac (ainda!) em meu ambiente, neste artigo eu vou focar o desenvolvimento, build e testes para a aplicação Android usando o Visual Studio e a linguagem C#.

Requisitos necessários:

• Visual Studio 2015 Community (Pode usar a partir do VS 2013)
• Xamarin Studio Starter Edition
• SQLite

Criando a solução no Visual Studio 2015

Abra o Visual Studio Community 2015 e clique em New Project. Depois selecione Visual C#, o template Cross Plataform e, a seguir, Blank App (Xamarin.Forms Portable).

Nota: A opção Portable (Portable Class Library – PCL) inclui todo o código comum em uma biblioteca de vínculo dinâmico (DLL) que pode, então, ser referenciada a partir de outros projetos.

Informe o nome Cadastro e clique no botão OK:

Ao clicar no botão OK, será criada uma solução contendo 4 projetos:

• 1 Projeto Comum contendo a maior parte do código da aplicação: Cadastro (este é o projeto Portable cuja compilação pode ser compartilhada com outras plataformas)
• 1 Projeto para plataforma Android: Cadastros.Droid
• 1 Projeto para plataforma iOS: Cadastro.iOS
• 1 Projeto para plataforma Windows Phone: Cadastro.WinPhone

Nota: Durante o processo de criação dos projetos, ao criar o projeto para o iOS será apresentada a janela: Xamarin Mac Agent Instructions, com instruções para identificar e localizar o Mac (a própria máquina ou em uma rede local). Se você não tiver um Mac (como eu), clique no botão OK e, a seguir, clique no botão Close. Com isso não poderemos compilar nem testar projetos iOS no Visual Studio.

Neste momento eu vou remover os projetos Windows Phone e iOS da solução ficando apenas com o projeto Cadastro.Android e o projeto compartilhado: Cadastro.

Definindo o banco de dados SQLite

Nossa aplicação será bem simples. Vamos criar um cadastro de Clientes onde iremos gerenciar informações de Nome e Email de Clientes.

Como desejamos persistir as informações, vamos usar um banco de dados em nossa aplicação e esse banco de dados será o SQLite, que é open-source e foi adotado pela Apple e pelo Google em suas plataformas para dispositivos móveis, estando disponível tanto para Android como para iOS. Ele é pequeno, rápido e portável, sendo constituído de um único arquivo, o que torna o seu gerenciamento muito simples em um ambiente para dispositivos móveis.

Para poder usar o SQLite no Android e no iOS, vamos ter que determinar a correta localização do banco de dados e aqui teremos que usar um código específico para Android e para iOS, pois cada plataforma trata de forma diferente a estrutura de pastas da aplicação.

Para o Android, vamos obter o caminho do banco de dados:

System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);

Para o iOS o código que seria usado é:

_plataforma = new SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid();

Para criar o banco de dados, usamos o código a seguir, onde temos que obter a plataforma e o caminho do arquivo:

conexaoSQLite = new SQLiteConnection(config.Plataforma, Path.Combine(config.DiretorioSQLite, "Cadastro.db3"));

Referenciando o SQLite nos projetos

Para poder usar o SQLite em nossa solução, vamos incluir uma referência à biblioteca SQLite.Net PCL em nosso projeto usando o Nuget.

O pacote SQLite.NET é um ORM – Object Relational Mapping – muito básico que permite facilmente armazenar e recuperar objetos do banco de dados SQLite nos dispositivos Android e iOS.

No menu Tools, clique em Nuget Package Manager e, a seguir, em Manage Nuget Packages for Solution.

Localize o pacote SQLite.NET-PCL e instale-o nos dois projetos da solução:

using System;
using SQLite.Net.Attributes;
namespace Cadastro
{
    public class Cliente
    {
        [PrimaryKey, AutoIncrement]
        public int Id { get; set; }
        [MaxLength(50)]
        public string Nome { get; set; }
        [MaxLength(100)]
        public string Email { get; set; }
        public override string ToString()
        {
            return string.Format("{0} {1}", Nome, Email);
        }
    }
}

Neste código definimos as seguintes propriedades:

• Id  –  como sendo a chave primária do tipo autoincremento
• Nome – Com tamanho máximo de 50
• Email – Com tamanho máximo de 100

E sobrescrevemos o método ToString() para obter o nome e e-mail dos clientes como uma string.

Definindo a interface para obter a plataforma e o caminho do banco de dados

Neste momento vamos criar no projeto compartilhando a interface IConfig, onde vamos declarar duas propriedades:

• DiretorioSQLite  – retorna o caminho do banco de dados SQLite usado na plataforma;
• Plataforma – retorna a plataforma;

Selecione o projeto compartilhado – Cadastro – e no menu Tools clique em Add New Item. Depois selecione o template Interface e informe o nome IConfig e inclua o código abaixo neste arquivo:

using SQLite.Net.Interop;
namespace Cadastro
{
    public interface IConfig
    {
        string DiretorioSQLite { get; }
        ISQLitePlatform Plataforma { get; }
    }
}

Agora vamos selecionar o projeto Cadastro.Droid e criar neste projeto a classe Config que implementa a interface IConfig e que retorna a plataforma usada e o caminho do banco de dados.

Selecione o projeto Android – Cadastro.Droid – e no menu Tools clique em Add Class.

Informe o nome Config.cs e inclua o código abaixo neste arquivo:

using System;
using SQLite.Net.Interop;
using Xamarin.Forms;
[assembly: Dependency(typeof(Cadastro.Droid.Config))]
namespace Cadastro.Droid
{
   public class Config : IConfig
    {
        private string _diretorioSQLite;
        private SQLite.Net.Interop.ISQLitePlatform _plataforma;
        public string DiretorioSQLite
        {
            get
            {
                if (string.IsNullOrEmpty(_diretorioSQLite))
                {
                    _diretorioSQLite = System.Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
                }
                return _diretorioSQLite;
            }
        }
        public ISQLitePlatform Plataforma
        {
            get
            {
                if (_plataforma == null)
                {
                    _plataforma = new SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid();
                }
                return _plataforma;             }
        }
    }
}

Assim implementamos a interface na classe Config no projeto Android.

Na segunda parte do artigo vamos definir a nossa camada de acesso a dados.