Archiwum kategorii: Xamarin

Dependency Service do czego jest nam potrzebny?

Dependency Service do czego jest nam potrzebny?

Chciałbym dzisiaj wam przybliżyć czym jest Dependency Service i do czego jest nam potrzebny.

Czym jest Dependency Service

Xamarin Forms jest technologią multi-platformową w której większość kodu aplikacji definiujemy w bibliotece PCL lub Shared. Niestety wymusza to na nas pewne ograniczenia. Największym jest brak możliwość dostępu do natywnych funkcjonalność danej platformy.

Mam tutaj na myśli usługi takie jak

  • Dostęp do plików
  • Poczta
  • Dostęp do hardware np. żyroskop
  • Notyfikacje
  • i wiele wiele innych

Każda z takich usług występuje na każdej platformie czy to będzie iOS czy Android, a może Windows. Niestety różnice na każdej z nich pociągają również różnice w sposobie implementacji i różnice w API. Stąd potrzebujemy czegoś co pozwoli nam używać różnych implementacji specyficznych dla każdej z platform i zarazem pozwoli nam wywołać ten kod z naszego Core aplikacji.

Dependency Service diagram

Z pomocą przychodzi nam Dependency Service.
Jak widzicie na załączonym obrazku nasz serwis chce uzyskać dostęp do informacji o baterii. Definiujemy interfejs tworzymy jego implementację na każdej z platform i wywołujemy poprzez Dependency Service. Wygląda prosto i takie jest też w rzeczywistości.

Przejdźmy dalej…

Dependency Service – Service Locator?

Sam w sobie Dependency Service nie jest niczym nowym. Pod spodem definiuje on wzorzec Service Locator (przynajmniej tak mi się wydaje :)).

Możemy dojść do takiego wniosku analizując kod źródłowy (tak od jakiegoś czasu mamy dostęp do kodu źródłowego Xamarin Forms na GitHub).

Ma on zdefiniowane podstawowe metody

  • Get
  • Register

Poniżej przykład metody Register

		public static void Register<T>() where T : class
		{
			Type type = typeof(T);
			if (!DependencyTypes.Contains(type))
				DependencyTypes.Add(type);
		}

		public static void Register<T, TImpl>() where T : class where TImpl : class, T
		{
			Type targetType = typeof(T);
			Type implementorType = typeof(TImpl);
			if (!DependencyTypes.Contains(targetType))
				DependencyTypes.Add(targetType);

			DependencyImplementations[targetType] = new DependencyData { ImplementorType = implementorType };
		}

Ciekawsze rzeczy dzieją się na etapie tworzenia nowej instancji

		static void Initialize()
		{
			if (s_initialized)
			{
				return;
			}

			Assembly[] assemblies = Device.GetAssemblies();
			if (Internals.Registrar.ExtraAssemblies != null)
			{
				assemblies = assemblies.Union(Internals.Registrar.ExtraAssemblies).ToArray();
			}

			Initialize(assemblies);
		}

		internal static void Initialize(Assembly[] assemblies)
		{
			if (s_initialized)
			{
				return;
			}

			Type targetAttrType = typeof(DependencyAttribute);

			// Don't use LINQ for performance reasons
			// Naive implementation can easily take over a second to run
			foreach (Assembly assembly in assemblies)
			{
				Attribute[] attributes = assembly.GetCustomAttributes(targetAttrType).ToArray();
				if (attributes.Length == 0)
					continue;

				foreach (DependencyAttribute attribute in attributes)
				{
					if (!DependencyTypes.Contains(attribute.Implementor))
					{
						DependencyTypes.Add(attribute.Implementor);
					}
				}
			}

			s_initialized = true;
		}

Nie będę tutaj wchodził już w szczegóły ponieważ wyjdą one później.

Tworzymy własną implementację

Chciałbym wam pokazać jak zaimplementować „użycie” Dependency Service. Zrobimy to na przykładzie z baterią. Cały kod źródłowy jest do pobrania z GitHub

Interfejs na początek

Trzeba stworzyć nowy interfejs w naszym przykładzie jest to IBatteryService.

    public interface IBatteryService
    {
        int RemainingChargePercent { get; }

        Models.BatteryStatus Status { get; }

        Models.PowerSource PowerSource { get; }
    }

Implementacja

Kolejny krok to stworzenie implementacji na każdej z platform. W tym przykładzie użyjemy tylko Android.

    public class BatteryService : BatteryStatus.Infrastructure.IBatteryService
    {
        public int RemainingChargePercent
        {
            get
            {
                try
                {
                    using (var filter = new IntentFilter(Intent.ActionBatteryChanged))
                    {
                        using (var battery = Application.Context.RegisterReceiver(null, filter))
                        {
                            var level = battery.GetIntExtra(BatteryManager.ExtraLevel, -1);
                            var scale = battery.GetIntExtra(BatteryManager.ExtraScale, -1);

                            return (int)Math.Floor(level * 100D / scale);
                        }
                    }
                }
                catch
                {
                    System.Diagnostics.Debug.WriteLine("Ensure you have android.permission.BATTERY_STATS");
                    throw;
                }
            }
        }
...

Jest to tylko fragment implementacji dający nam tylko pogląd jak to powinno wyglądać.

Rejestracja

Gdy mamy już gotową implementację musimy ją zarejestrować żeby Dependency Service mógł go później użyć. Robimy to w prosty sposób poprzez nadanie atrybutu na namespace.

[assembly:Xamarin.Forms.Dependency(typeof(BatteryStatus.Droid.Infrastructure.BatteryService))]
namespace BatteryStatus.Droid.Infrastructure

Wywołanie\Użycie

W naszym przykładzie użyjemy naszego serwisu w ViewModel. Robimy to poprzez użycie metody Get z Dependency Service.

        public BatteryStatusViewModel()
        {
            var batteryService = DependencyService.Get<IBatteryService>();

            if (batteryService == null)
                return;

            this.BatteryStatus = batteryService.Status.ToString();
            this.PowerSource = batteryService.PowerSource.ToString();
            this.RemainingCharge = batteryService.RemainingChargePercent;
        }

Podsumowanie

Uff. Dobrnęliśmy do końca całości.
Użycie Dependency Service daje nam bardzo potężne możliwości, oraz dostęp do wielu natywnych funkcjonalności platform.

Jak konfigurować emulatory Android dla początkujących

works on my machine

Konfiguracja emulatora Android może być czasami problematyczna. Dlatego chciałbym przedstawić jak to zrobić poprawnie tak żeby wszystko działało.

Jest to artykuł skierowany głównie do początkujących developerów Xamarin i nie tylko.

Emulatory Android

Jeżeli chodzi o emulatory android mamy kilka możliwych opcji do wyboru

Dzisiaj chciałbym się skupić na emulatorach dostarczanych wraz z Android SDK, czyli Google APIs Intel x86.

HAXM

HAXM, czyli Intel Hardware Accelerated Execution Manager jest to technologia firmy Intel „usprawniająca działanie emulatorów Android na komputerach wyposażony w procesory Intel.

Intel® Hardware Accelerated Execution Manager (Intel® HAXM) is a hardware-assisted virtualization engine (hypervisor) that uses Intel® Virtualization Technology (Intel® VT) to speed up Android* app emulation on a host machine. In combination with Android x86 emulator images provided by Intel and the official Android SDK Manager, Intel HAXM allows for faster Android emulation on Intel VT enabled systems.

Intel® Hardware Accelerated Execution Manager (Intel® HAXM)

Dzięki wykorzystaniu technologi Intel VT emulatory dostarczane przez Google we współpracy działają z pełną szybkością procesora dostępnego w komputerze.

Przygotowanie środowiska

W celu pobrania najnowszych emulatorów musimy otworzyć Android SDK Manager, możemy to zrobić z poziomu Visual Studio VS Android SDK manager
Wybieramy emulator, który nas interesuje i pobieramy wraz z odpowiednim SDK. Ważne żebyśmy wybrali emulator w wersji x86 Atom
Google APIs System Image

No dobrze ale możecie zapytać co z tym całym HAXM?
Z moich obserwacji wynika, że najlepiej jest zainstalować HAXM dostarczany wraz z Visual Studio 2017.
Intel HAXM

Obserwacje zostały przeprowadzone na komputerze wyposażonym w procesor Intel i5-6300U.

Konfiguracja emulatora

W celu stworzenia nowego emulatora otwieramy Android Virtual Device (AVD) Manager, możemy to zrobić z poziomu Visual Studio VS AVD manager
AVD Manager

Następnie klikamy Create i wybieramy Device (głównie godzi tu o wymiary UI i ilość pamięci), oraz Target API level
new emulator

Ważne żebyśmy wybrali opcję Use Host GPU emulator działa wtedy jeszcze szybciej, przynajmniej na mojej maszynie.

Xamarin Live Player, podgląd UI na żywo - obecny stan

Xamarin Live Player, podgląd UI na żywo – obecny stan

Jakiś czas temu Xamarin opublikował narzędzie o nazwie Xamarin Live Player, szczegóły można znaleźć pod URL www.xamarin.com/live. Dzisiaj pokażę wam jak wygląda w praktyce użycie tego narzędzia i jakie są jego zalety, wady, oraz ograniczenia na chwilę obecną.

Xamarin Live Player – Setup

Na chwilę obecną Xamarin Live Player jest dostępny tylko w wersji Preview Visual Studio 2017, a więc zaczynamy instalację.

Na początek trzeba pobrać Visual Studio 2017 Preview 15.3 z tego linka www.visualstudio.com/vs/preview/. W ten sposób zainstalujemy instalator Visual Studio. Ważna uwaga wersja Preview może działać obok stabilnej wersji Visual Studio 2017 w czasie instalacji wystarczy stworzyć „Installation nickname”. Installation nickname
Wybieramy Workload Mobile Development with .Net i rozpoczynamy instalację.

Kolejny krok to instalacja Xamarin Updater. Jest to bardzo przydatne narzędzie ze względu na zmianę sposobu aktualizacji Xamarin wraz z wypuszczeniem Visual Studio 2017. Samo narzędzie możemy pobrać z marketplace.visualstudio.com.

Pierwsza aplikacja – czy wszystko nam działa?

Otwieramy Visual Studio Preview i tworzymy nowy projekt nazwijmy go „TodoLivePlayer”

LivePlayerDemo

Kolejny krok to instalacja na urządzeniu z iOS lub Android aplikacji Xamarin Live, którą można pobrać ze sklepu

Teraz możemy sparować urządzenie z Visual Studio w tym celu otwieramy menu Tools -> Xamarin Live Player -> Manage Devices

Manage devices
pair device

Na urządzeniu otwieramy aplikację i jeżeli jest ono wyposażone w aparat możemy przeczytać wygenerowany kod QR w innym wypadku trzeba przepisać kod wygenerowany na urządzeniu do Visual Studio.

Xamarin Live QR code

Xamarin Live

Cały proces jest mało problematyczny i przebiega bardzo płynnie.

Co obecnie działa?

Głównie testowałem Live Player na iPhone i na chwilę obecną jest jedno w mojej opinii niewielkie ograniczenie nie działa to z PCL. Jak tylko sprawdzę .Net Standard to pojawi się aktualizacja.

W ramach podsumowania

Live Player jest kolejnym ciekawym narzędziem ułatwiającym pracę z Xamarin. Bardzo ułatwia i przyśpiesza pracę na aplikacjami i jego powstanie\rozwój jest kolejnym przykładem, że Xamarin jest ważną i przyszłościową platformą.

WażneNależy również pamiętać, że urządzenia na których chcemy robić testy musi znajdować się w naszej sieci Wi-Fi.

Jak zacząć z FreshMVVM

Jak zacząć z FreshMVVM w Xamarin Forms

W post 7 framework-ów MVVM jakie możecie wybrać przedstawiłem wam kilka możliwych opcji do wyboru jeżeli chodzi o MVVM. Dzisiaj chciałbym przedstawić jeden z nich FreshMVVM.

Jak zacząć z FreshMVVM w Xamarin Forms? FreshMVVM jest prostym i mały framework-iem stworzonym specjalnie na potrzeby Xamarin Forms. Jego autorem jest Michael Ridland.

Naszym przykładem jaki wykorzystam będzie prosta aplikacja Todo.

Jak zacząć z FreshMVVM w Xamarin Forms`

A więc zaczynamy.

FreshMVVM struktura

FreshMVVM stosuje koncepcję „Convetion over Configuration” dlatego też ważna jest struktura naszego projektu.

Koncepcje jakie są ważne to:

  • Page – nasza strona, którą tworzymy w XAML
  • PageModel – nasz ViewModel, który odpowiada za całą obsługę całej logiki aplikacji

A więc tworzymy nasz projekt przez File -> New -> Project lub CTRL+SHIFT+N, wybieramy szablon Blank Xaml App (Xamarin.Forms Portable).

Pobieramy z NuGet pakiety FreshMVVM i PropertyChanged.Fody. Uruchamiamy konsolę Package Manager Console i piszemy

Install-Package FreshMvvm -ProjectName FreshTodoApp
Install-Package PropertyChanged -ProjectName FreshTodoApp

Kolejnym krokiem jest stworzenie struktury projektu

Jak zacząć z FreshMVVM w Xamarin Forms - Struktura

Tworzymy katalogi Models, PageModels i Pages będą nam one potrzebne do trzymania się konwencji jaka jest używana w FreshMVVM.

  • Models – tutaj trzymamy nasze klasy POCO np. pobrane przez HTTP
  • PageModels – tutaj trzymamy nasze klasy VM
  • Pages – tutaj trzymamy nasze strony

Trochę kodu

A więc tworzymy naszą pierwszą stronę TodoItemPage wybieramy folder w Solution Explorer i Add -> New Item -> wybieramy szablon Forms Xaml Page lub CTRL + SHIFT + A.

Strona TodoItemPage wygląda jak na listingu

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" x:Class="FreshTodoApp.Pages.TodoItemPage">
  <StackLayout Margin="20" VerticalOptions="FillAndExpand">
    <Label Text="Name" />
    <Entry Text="{Binding Todo.Name}" />
    <Label Text="Note" />
    <Editor Text="{Binding Todo.Note}" VerticalOptions="FillAndExpand" />
    <Label Text="Done" />
    <Switch IsToggled="{Binding Todo.Done}" />
    <Button Text="Save" Command="{Binding SaveCommand}"/>
    <Button Text="Cancel" />
    <Button Text="Delete" />
  </StackLayout>
</ContentPage>

Jak widzicie mamy stworzone już Binding-i w naszym kodzie XAML. Teraz zajmiemy się naszym PageModel.

Jak poprzednio w katalogu PageModels dodajemy pustą klasę C# TodoItemPageModel, ważne jest tutaj nazewnictwo żeby zadziałał nam automatyczny binding. Musi ona dziedziczyć po FreshBasePageModel.

Klasa TodoItemPageModel listing

using FreshMvvm;
using FreshTodoApp.Models;
using Xamarin.Forms;
using PropertyChanged;

namespace FreshTodoApp.PageModels
{
    [ImplementPropertyChanged]
    public class TodoItemPageModel : FreshBasePageModel
    {
        public TodoItem Todo { get; set; }

        public Command SaveCommand
        {
            get
            {
                return new Command(async () =>
                {
                    await CoreMethods.DisplayAlert("Info", $"Create task with name {Todo.Name}", "Ok");
                });
            }
        }

        public override void Init(object initData)
        {
            Todo = initData as TodoItem;
            if (Todo == null)
                Todo = new TodoItem();
        }
    }
}

Dla formalności TodoItem wygląda następująco

using PropertyChanged;

namespace FreshTodoApp.Models
{
    [ImplementPropertyChanged]
    public class TodoItem
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Note { get; set; }
        public bool Done { get; set; }
    }
}

FreshPageModelResolver

Żeby to wszystko zadziałało z pomocą przychodzi nam FreshPageModelResolver. Odpowiada on za powiązanie PageModel z odpowiednim Page.
W App.xaml.cs dodajemy linijkę

MainPage = FreshMvvm.FreshPageModelResolver.ResolvePageModel<TodoItemPageModel>();

Więc jak widzicie w całkiem szybki sposób otrzymujemy działającą aplikację zgodną ze wzorcem MVVM. Pytanie takie do was czy używaliście gdzieś produkcyjnie FreshMVVM?

jaki framework MVVM wybrać

7 framework-ów MVVM jakie możecie wybrać

A więc jesteście na początku zaczynacie pisać swoją aplikacją w Xamarin Forms. Ale jaki framework MVVM wybrać?

Jaki framework MVVM wybrać?

Framework-ów MVVM jest tyle co ludzi na świecie prawie jak bibliotek JavaScript :). Dzisiaj pokrótce przedstawię te, które udało mi się znaleźć lub mam jakieś z nimi doświadczenia.

Prism

Prism is a framework for building loosely coupled, maintainable, and testable XAML applications in WPF, Windows 10 UWP, and Xamarin Forms.

Prism jest framework-iem do budowania aplikacji opartych o XAML (WPF, UWP, Xamarin Forms). Obecnie stabilna wersja dla Xamarin Forms to 6.2. Jest rozwijany niezależnie dla każdej platformy i oryginalnie wywodzi się z Microsoft patterns & practices. Od wersji 6.0 jest rozwijany jako open source i utrzymywany przez Brian Laguna’s. Więcej szczegółów możecie wyczytać na jego blogu.

FreshMVVM

FreshMvvm is a super light Mvvm Framework designed specifically for Xamarin.Forms. It’s designed to be Easy, Simple and Flexible.

FreshMVVM super lekki i super szybki. Zaprojektowany specjalnie na potrzeby Xamarin Forms. Jego twórcą jest Michael Ridland, który postawił sobie za cel przesiadkę z natywnych aplikacji Xamarin pisanych z użyciem MvvmCross na Xamarin Forms. W ten sposób pojawił się FreshMVVM. Nic dodać nic ująć. Lekko, szybko i przyjemnie.

Exrin

Enterprise Xamarin Forms MVVM Framework

Exrin stworzony na potrzeby „dużych” aplikacji (przynajmniej ja tak to czuję). Jego twórcą jest Adam Pedley i jak mówi jego autor konfiguracja zajmuje sporo czasu ale daje największe wartości gdy mamy zespół liczący kilku programistów.

Xamvvm

Simple, fast and lightweight MVVM Framework for Xamarin.Forms with fluent API

Xamvvm kolejny z małych lekkich i przyjemnych frameworków MVVM. Z zalet daje nam prostotę użycia, automatyczny Binding do DataContext, oraz Fluent API. To chyba takie największe zalety (sprawdzimy wkrótce ;).

MVVMCross

The .NET MVVM framework for cross-platform solutions, including Xamarin.iOS, Xamarin.Android, Windows and Mac.

MvvmCross jeden ze starszych framework-ów MVVM, oraz jeden z większych.Pozwala nam pisać aplikację natywne iOS, Android i Xamarin Forms. Posiada bardzo mocno rozwiniętą społeczność na StackOverflow lub na forum Xamarin. Bardzo bogaty w funkcjonalność ale w moim odczuciu również skomplikowany. Nadaje się bardziej do dużych projektów.

MVVMLight

The main purpose of the toolkit is to accelerate the creation and development of MVVM applications in WPF, Silverlight, Windows Store, Windows Phone and Xamarin

MVVMLight jako jeden z nielicznych nie jest rozwijany na GitHub. Jest również jednym z moich ulubionych framework-ów ze względu na prostotę i łatwość użycia. MVVMLight jest rozwijany przez Laurent Bugnion. Na jego stronie możecie również znaleźć więcej szczegółów na temat MVVM i nie tylko.

MVVMHelpers

Collection of MVVM helper classes for any application

MVVMHelpers nie jest to framework w pełnym tego słowa znaczeniu. Jest to zestaw klas ułatwiających pracę z aplikacjami tworzonymi w XAML w architekturze MVVM. Autorem jest James Montemagno

Podsumowując jak widzicie jest z czego wybierać budując swoją aplikację w Xamarin Forms i nie tylko. W następnych artykułach będę chciał przybliżyć wam każdą z wymienionych bibliotek MVVM. A więc do zobaczenia?

Xamarin Forms i MVVMLight

Chcecie napisać aplikacje mobilną? Pokażę wam jak to zrobić w Xamarin Forms razem z MVVMLight

Witajcie cześć i czołem pytacie skąd się wziąłem… A na imię mi Xamarin Forms razem z MVVMLight i pokrótce chciałbym wam pokazać jak łatwo można użyć wzorca Model-View-ViewModel w aplikacji mobilnej.

Instalacja MVVMLight

MVVMLight jest pakietem NuGet, który może pobrać używając konsoli NuGet Package Manager Console.NuGet Package Manager Console

W tym celu w naszej aplikacji należy otworzyć konsolę NuGet Package Manager w Visual Studio, szukam pakietu MvvmLightLibs i instalujemy go w naszych wszystkich projektach.

Konfiguracja kontenera Inversion Of Control

Na początek czeka nas odrobina konfiguracji naszego nowego projektu. Na razie konfiguracja kontenera IoC wygląda na nadmiarową pracę ale zapewniam was, że później to zaprocentuje w postaci łatwego przełączania się pomiędzy kodem „produkcyjnym” i „mock”.

Na początek stwórzmy prosty ViewModel o nazwie MainViewModel, który będzie korzystał z interfejsu IAccountService.

MainViewModel

using Client_BankOfSanEscobar.Interfaces;
using Client_BankOfSanEscobar.Models;
using GalaSoft.MvvmLight;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;

namespace Client_BankOfSanEscobar.ViewModels
{
    public class MainViewModel : ViewModelBase
    {
        private readonly IAccountService accountService;

        public string Title { get; set; }
        public ObservableCollection<Account> Accounts { get; set; }
        public float AvailableBalance { get; set; }
        
        public MainViewModel(IAccountService accountService)
        {
            if (accountService == null)
                throw new ArgumentNullException("accontService");

            this.accountService = accountService;

            Task.Run(() => Init());
        }

        public async Task Init()
        {
            if (Accounts != null)
                return;

            Accounts = new ObservableCollection<Account>(await accountService.GetAll());
            foreach (var balance in Accounts.Select(a => a.Balance))
                AvailableBalance += balance;
        }
    }
}

Teraz stwórzmy interfejs IAccountService

IAccountService

using Client_BankOfSanEscobar.Models;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Client_BankOfSanEscobar.Interfaces
{
    public interface IAccountService
    {
        Task<IEnumerable<Account>> GetAll();
    }
}

oraz jego implementację w postaci obiektu „mock”

AccountServiceMock

using Client_BankOfSanEscobar.Interfaces;
using Client_BankOfSanEscobar.Models;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace Client_BankOfSanEscobar.Mock
{
    public class AccountServiceMock : IAccountService
    {
        public Task<IEnumerable<Account>> GetAll()
        {
            const int numberOfAccountsToGenerate = 4;
            return Task.Run(() => GenerateAccounts(numberOfAccountsToGenerate));
        }

        private IEnumerable<Account> GenerateAccounts(int numberOfAccounts)
        {
            var accounts = new List<Account>(numberOfAccounts);
            for (int i = 0; i < numberOfAccounts; i++)
            {
                accounts.Add(new Account(name: $"Account {i}", number: $"26200400001545234{i}", balance: 150.56f + i));
            }
            return accounts;
        }
    }
}

Uff prawie dobrnęliśmy do końca jeszcze tylko….Konfiguracja kontenera IoC.

W naszym kodzie użyjemy myśli technologicznej firmy Microsoft w postaci ServiceLocator, a implementacja wygląda następująco. Niektórzy twierdzą, że jest fajny The Service Locator Pattern, a inni twierdzą, że nie Antywzrorzec Service Locator.

Locator

using Client_BankOfSanEscobar.Interfaces;
using Client_BankOfSanEscobar.Mock;
using Client_BankOfSanEscobar.ViewModels;
using GalaSoft.MvvmLight.Ioc;
using Microsoft.Practices.ServiceLocation;

namespace Client_BankOfSanEscobar
{
    public class Locator
    {
        public Locator()
        {
            ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);

            //ViewModels
            SimpleIoc.Default.Register<MainViewModel>();

            //Services
            SimpleIoc.Default.Register<IAccountService, AccountServiceMock>();
        }

        public MainViewModel Main
        {
            get
            {
                return ServiceLocator.Current.GetInstance<MainViewModel>();
            }
        }
    }
}

Musimy jeszcze zainicjować nasz Locator możemy to zrobić w klasie App.cs

App

using Xamarin.Forms;

namespace Client_BankOfSanEscobar
{
    public partial class App : Application
    {
        private static readonly Locator locator = new Locator();

        public static Locator Locator
        {
            get
            {
                return locator;
            }
        }

        public App()
        {
            InitializeComponent();

            MainPage = new Views.MainPage();
        }
    }
}

Cała konfiguracja i robota papierkowa za nami teraz możemy dojść do mięcha.
Mięcho

Binding ViewModel do UI

A więc żeby użyć naszego nowego pachnącego ViewModel należy go „podłączyć” do naszego widoku. Robimy to poprzez odpowiednie skonfigurowanie BindingContext.

        public MainPage()
        {
            InitializeComponent();
            BindingContext = App.Locator.Main;
        }

Podsumowanie

A więc jak widzicie użycie MVVMLight i Xamarin Forms jest możliwe. Na początku konfiguracja i powiązanie wszystkiego zajmuje trochę czasu ale w przyszłości będzie miało to plusy. Cały kod źródłowy możecie znaleźć na GitHub

Komunikacja w czasie rzeczywistym w Xamarin

Komunikacja w czasie rzeczywistym w Xamarin

W dzisiejszym wpisie chciałbym zaprezentować jak wysyłać powiadomienia push przy użyciu biblioteki ASP.NET SignalR.

Komunikacja w czasie rzeczywistym – Czym jest SignalR

ASP.NET SignalR is a new library for ASP.NET developers that makes developing real-time web functionality easy. SignalR allows bi-directional communication between server and client. Servers can now push content to connected clients instantly as it becomes available. SignalR supports Web Sockets, and falls back to other compatible techniques for older browsers. SignalR includes APIs for connection management (for instance, connect and disconnect events), grouping connections, and authorization

Według definicji ze strony www.asp.net/signalr jest to biblioteka umożliwiająca komunikację w czasie rzeczywistym, wykorzystująca Websockets lub Ajax long polling do swojego działania.

A teraz mięso

W tym demo użyjemy SignalR hostowanego w aplikacji konsolowej. W tym celu należy zainstalować dwa pakiety NuGet

Install-Package Microsoft.AspNet.SignalR.SelfHost
Install-Package Microsoft.Owin.Cors

Następnie tworzymy Hub mający na celu przekazywanie wiadomości pomiędzy podłączonymi klientami

    public class NotificationHub : Hub
    {
        public void SendNotification(Notification notification)
        {
            Clients.All.sendNotification(notification);
        }

        public override Task OnConnected()
        {
            Console.WriteLine($"Connection with ID {Context.ConnectionId} connected");
            return base.OnConnected();
        }

        public override Task OnDisconnected(bool stopCalled)
        {
            Console.WriteLine($"Connection with ID {Context.ConnectionId} disconnected");
            return base.OnDisconnected(stopCalled);
        }

        public override Task OnReconnected()
        {
            Console.WriteLine($"Connection with ID {Context.ConnectionId} reconnected");
            return base.OnReconnected();
        }
    }

Back office i Frontend

Naszym klientem symulującym działanie back office jest aplikacja konsolowa wysyłająca mock powiadomień dla klienta. Klient mobilny został zrealizowany za pomocą Xamarin Forms.

W naszych klientach instalujemy pakiet NuGet

Install-Package Microsoft.AspNet.SignalR.Client

Żeby klient mógł użyć serwera SignalR należy napisać mały kawałek kodu

var hubConnection = new HubConnection($"{Servers.NotificationHubServer}/signalr");
var hubProxy = hubConnection.CreateHubProxy(Hubs.NotificationHubName);

hubConnection.Start().Wait();

hubProxy.Invoke<Notification>(Actions.SendNotification, notification);

Cały kod źródłowy demo jest dostępny na GitHub.

Zapraszam do komentowania. Jakie macie doświadczenia z użycia SignalR w aplikacjach mobilnych jakieś alternatywy?

Visual Studio Mobile Center: Wprowadzenie

Wprowadzenie do Visual Studio Mobile Center, czyli czym to właściwie jest

W dzisiejszym artykule chciałbym was wprowadzić w temat czym jest Visual Studio Mobile Center, a więc zaczynajmy.

Czym jest Visual Studio Mobile Center

Visual Studio Mobile Center zostało zaprojektowane dla wszystkich aplikacji iOS i Android, stworzonych w Swift, Objective-C, Java, Xamarin lub React Native.

VSMC jest usługą, która ma zintegrować w jeden produkt HockeyApp, Xamarin Test Cloud i usługi backend świadczone w chmurze.

Została ona oficjalnie zaprezentowana na konferencji Connect() 2016.

Co działa

VSMC jest obecnie w fazie Preview dlatego też nie wszystko działa jak powinno lub czegoś brakuje. Poniżej krótka lista co obecnie działa.

  • Automatyczne budowanie po każdym pull request
  • Testy UI
  • Dystrybucja aplikacji do beta testów
  • Monitorowanie aplikacji
  • Analiza użycia
  • Podłączenie do backend np. Azure Mobile Apps, Databases, Identity

Mobile CI (Contiuous Integration), testy UI i analiza działania aplikacji

Według Wikipedia

Ciągła integracja – praktyka stosowana w trakcie rozwoju oprogramowania, polegająca na częstym, regularnym włączaniu (integracji) bieżących zmian w kodzie do głównego repozytorium. W praktyce, każdy członek zespołu programistycznego powinien przynajmniej raz dziennie umieścić wykonaną przez siebie pracę w repozytorium[1]. Niezbędnym elementem jest także zapewnienie poprawności kompilacji kodu po wykonaniu integracji.

W wypadku mobile CI było do tej pory trudne do osiągnięcia, zwłaszcza testy UI aplikacji były trudne do wykonania. Z pomocą w testach przyszedł Xamarin i jego Test Cloud gdzie używając Xamarin Studio mogliśmy nagrać „skrypt” do testowania UI. Natomiast do budowania aplikacji trzeba było używać narzędzi takich jak np. Jenkins.

W tej chwili otrzymujemy od Microsoft kompletne rozwiązanie w jednym pudełku.

Podsumowanie

Microsoft po przejęciu Xamarin mocno inwestuje w rozwój platformy mobile i ich wizji Mobile First Cloud First jednym z dzieci jest właśnie Mobile Center. Usługa wygląda ciekawie, działa i da się jej obecnie normalnie używać. Wersja produkcyjna ma ujrzeć światło dzienne w przyszłym roku.

Pomysł jest fajny ze względu na integracje kilku produktów w jeden. Zobaczymy jak to będzie działało w praktyce.

Dla zainteresowanych link do Visual Studio Mobile Center

Problemy z emulatorem Android w Xamarin

Problemy z emulatorem Android w Xamarin

Works On My Machine

Jest to artykuł z cyklu u mnie działa. Za wszelkie szkody powstałe z niewłaściwego użycia Hyper-V nie odpowiadam.

Problemy z emulatorem Android w Xamarin

Pewnie wielu z was przy swoich pracach nad Xamarin Visual Studio powitało was komunikatem „Could not connect to the debugger”.

Niestety po ostatnich aktualizacjach Xamarin Visual Studio nie może się podłączyć do emulatora w trybie debug. Przyczyną jest ustawienie Processor compatibility dla Hyper-V.

katastrofa

Recepta

Można temu zaradzić używając konsoli Hyper-V.

Krok 1

Odpalamy konsolę i idziemy do ustawień wirtualki z emulatorem.

Ustawienia maszyny wirtualnej Hyper-V

 

Krok 2

Przestawiamy ustawienie Processor compatibility.

Processor compatibility

Tworzymy jakiś sample project Xamarin i odpalamy wszystko w trybie Administratora żeby emulator załapał ustawienia.

 

Xamarin.iOS – Jak pokazać kontrolkę daty tak jak w kalendarzu iOS

Jest to tips & tricks działający dla Xamarin.iOS

W dzisiejszym odcinku chciałbym pokazać wam jak dodać kontrolkę daty „iOS style” (z takim fajnym rozwijaniem wierszy jak w np. w kalendarzu).

Xamarin.iOS – Jak pokazać kontrolkę daty tak jak w kalendarzu iOS

Ja w swoim przykładzie użyłem na Storyboard kontrolki TableViewController. Wywyższa kontrolka zapewnia nam funkcjonalność kontrolki TableView i ScrollView w jednym.

Następnie należy skonfigurować sekcji i wiersze, dodajemy kontrolkę DatePicker i wysokość wiersza ustawiamy na 216.

Reszta magii dzieje się w kodzie… Cały kod źródłowy można znaleźć na GitHub

Kod

using Foundation;
using System;
using UIKit;

namespace DatePickerDemo
{
    public partial class MainViewController : UITableViewController
    {
        private NSDateFormatter formatter;
        private bool showDatePicker;

        public MainViewController (IntPtr handle) : base (handle)
        {
            formatter = new NSDateFormatter();
            formatter.DateStyle = NSDateFormatterStyle.Short;
        }

        public override void ViewDidLoad()
        {
            base.ViewDidLoad();


            dateLabel.Text = formatter.ToString(datePicker.Date);
            datePicker.ValueChanged += DatePicker_ValueChanged;
        }

        public override nfloat GetHeightForRow(UITableView tableView, NSIndexPath indexPath)
        {
            nfloat rowHeight = tableView.RowHeight;

            if(indexPath.Section == 1 && indexPath.Row == 2)
            {
                rowHeight = 0;
            }

            if (showDatePicker && (indexPath.Section == 1 && indexPath.Row ==2))
            {
                rowHeight = 216;
            }

            return rowHeight;
        }

        public override void RowSelected(UITableView tableView, NSIndexPath indexPath)
        {
            tableView.BeginUpdates();

            if (indexPath.Section == 1 && indexPath.Row == 1)
            {
                showDatePicker = !showDatePicker;
            }

            tableView.DeselectRow(indexPath, true);
            tableView.EndUpdates();
        }

        private void DatePicker_ValueChanged(object sender, EventArgs e)
        {
            dateLabel.Text = formatter.ToString(datePicker.Date);
        }
    }
}