April 29, 2016 1:30 GMT

Weekly Xamarin Newsletter Issue #90

Live From Evolve

Open Source Xamarin, Ready for you!
Miguel de Icaza officially announces the open sourcing of Xamarin.

Faster and Easier Mobile App Development with Xamarin.Forms
Jason Smith wants to make you even more productive with Xamarin.Forms.

The New, Mobile-Optimized Development Lifecycle
Keith Ballinger announces the modernization of mobile DevOps.

Browse Through the Evolve 2016 Mobile App Source Code
James Montemagno has released the source for the Evolve Mobile app.

From the Community

Pressure Is On with 3D Touch in iOS Apps
Greg Shackles shows you how to add pressure based actions to your apps.

Push notifications with Xamarin – Server
Gerald Versluis adds the server to his push notification series.

Announcing FreshMvvm 2.0
Michael Ridland releases some anticipated features.

Out now: Snppts for Xamarin Forms!
Steven has released the new snippets sight for Xamarin.Forms.

XAML Markup Extensions Cheat Sheet
Adam Pedley releases his quick reference guide to XAML.

Events

April 30th, 2016, Costa Rica: Xamarin Evolve 2016 + Build recap

May 3 – 4: Belgium – Go Mobile with Xamarin, C# and Visual Studio

Jobs

Xamarin Developer – Remote Working

Xamarin Developer – NYC position

The post Weekly Xamarin Newsletter Issue #90 appeared first on Syntax is my UI.

April 28, 2016 12:35 GMT

Pressure Is On with 3D Touch in iOS Apps

With the release of the iPhone 6S and 6S Plus, together with the iOS 9 operating system, Apple introduced 3D Touch. What it allows is the addition of pressure-based interactions into your apps, which can be added in a variety of ways.

In this article I'll introduce a couple built-in standard 3D Touch interaction models, but iOS also provides a direct API to the pressure sensors, allowing you to leverage the data in any way that makes sense in your apps.

Continue reading the rest of the article over at Visual Studio Magazine

April 26, 2016 5:26 GMT

Push notifications with Xamarin – Server

Now that we have three apps which implement push notifications, we also want to send some messages to the user!

Until now we have done this by using the Azure portal but this is very limited and you’re not going to want to check your database for updates and sent out the right push notifications manually.

There are a lot of ways to send notifications not only the way that you might trigger them, but also how you communicate with your Azure Notification Hub.
Your sending mechanism might be from a console application which runs scheduled (on a server or have a look at Azure WebJobs), or directly following an action which might occur on your web variant, or even when a certain action on your database happens. These are just a few of the possibilities.

This is made possible by the fact that you can talk to your Notification Hub in different ways i.e. Microsoft provides you with the libraries to communicate through the Azure API and another, much easier way, is to send a request to the REST API that is associated with your hub.

Creating a console application

I find that a most comprehensive solution is to build a console application. This is easiest to trigger yourself, can be ran scheduled both on a server, locally and in Azure. I didn’t need real-time notifications to this day, so a intervalled job is just fine.

We start with creating a plain old simple console application from Visual Studio. Then go to the NuGet packages for this project – which I named XamarinNotifications.Server – and install the ‘Microsoft.Azure.NotificationHubs’ one.

Microsoft.Azure.NotificationHubs NuGet package
Microsoft.Azure.NotificationHubs NuGet package

As you might have guessed by now, this is a very convenient package to communicate with you NotificationHub.
Now the rest of the code is pretty straight forward. There is a ‘NotificationHubClient’ object which can create an instance by taking a connection string.

So go over, once more, to your Azure portal and find the connection string of your service bus. It’s (still) under the button at the bottom which says ‘Connection information’. Beware; the one of your service bus! Which is the name of your Notification Hub with the ‘-ns’ postfix. Also remember your Notification Hub name – without the ‘ns’ postfix – because you’re going to need that as well.

Without further ado, let us have a look at the code:

private static void Main(string[] args)
{
    // Define the notification hub.
    // TODO Add your own connectionstring and hub name here
    var hub =
        NotificationHubClient.CreateClientFromConnectionString(
            "<your connectionstring here>", "<your hub name here>");

    // Define an iOS alert..
    var iOSalert =
                "{\"aps\":{\"alert\":\"Hello. This is a iOS notification! Tada!\", \"sound\":\"default\"}}";

    // ..And send it
    hub.SendAppleNativeNotificationAsync(iOSalert).Wait();

    // Define an Anroid alert..
    var androidAlert = "{\"alert\": \"Can I interest you in a once in a lifetime push notification?!\", \"title\":\"Ding, dong!\"}";

    // ..And send it
    hub.SendGcmNativeNotificationAsync(androidAlert).Wait();

    // Define an Windows Phone alert..
    var winPhoneAlert = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
        + "<toast>"
        + "<visual><binding template=\"ToastText01\">"
        + "<text id=\"1\">Peek-a-book</text>"
        + "<text id=\"2\">This is your friendly neighborhood message!</text>"
        + "</binding>"
        + "</visual>"
        + "</toast>";

    // ..And send it
    hub.SendWindowsNativeNotificationAsync(winPhoneAlert).Wait();
}

It should be pretty much self-explanatory. First a Azure client is created with the connection string and from there you define the payloads of the different platforms and send them to the hub. And that is it!

Come to think of it; I don’t think I did mention it in my Windows post, so I’ll do it now: have a good look at the payload options you have while creating a Windows push notification.
There are a lot of options there to create a look and feel that you want. You can find all the info about that here.

Only thing that might look weird is the ‘.Wait()’ calls. There are different ways to solve this, but it prevents the process of ending prematurely.
A console application runs, and just terminates at the end. So if I would run these bad boys asynchronously, the process would reach the end, terminate while also terminating all the threads that are sending notifications to Azure.

The send methods also have overloads to send the notifications to specific tags. This way you can reach a specific group of people or maybe even one person.

Now this process can be used in a variety of ways!

Like I mentioned in the beginning another way to connect with you Notification Hub is through a REST API.
While this has no difference to the end-user it is completely different for the developer. I’m going to assume that since you are a Xamarin developer you know how to manage a REST API so I’m not going to go in detail there. You can find the documentation on this here.
The only obstacle here is that you need to generate a ACS token for authorization which can be a bit tricky but isn’t impossible.

Like all other code you can also find this console tool on the associate GitHub. If you have any further questions don’t hesitate to drop me a line!

April 26, 2016 12:40 GMT

Xamarin.Forms Behaviors: Support for Page Level Behaviors

Previously, I’ve introduced by Behaviors Library for Xamarin.Forms, which can be downloaded from GitHub and NuGet. The Behaviors Library for Xamarin.Forms has the notion of behaviors and actions. A behavior is attached to a control and listens for something to happen, such as an event firing. When the “something” happens, it triggers one or more actions, such as invoking a method or command. Actions are invoked by behaviors and executed on a selected control.

A problem with my behaviors library was that it only allowed behaviors to be attached to views (controls), and not to pages. Therefore, I’ve updated the library so that behaviors can be attached to pages.

In this blog post, I’ll demonstrate using the EventHandlerBehavior and InvokeCommandAction classes to invoke a command when a page event fires.

Invoking a Command when a Page Event Fires

The EventHandlerBehavior class listens for a specified event to occur, and executes one or more actions in response. It requires you to set an EventName property to the event that you want the behavior to listen to, and an Actions property to one or more actions that should be executed in response to the event firing.

The InvokeCommandAction class executes a specified ICommand when invoked. It requires you to set a Command property to an ICommand instance, and CommandParameter and Converter properties can be optionally set. The CommandParameter property should be set to an object instance, with the Converter property being set to an instance of a class that implements IValueConverter. The ICommand specified in the Command property will then be executed, with the CommandParameter and Converter values being used if specified.

The following code shows an example of using the EventHandlerBehavior to invoke a command:

<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
xmlns:x
="http://schemas.microsoft.com/winfx/2009/xaml"
xmlns:behaviors
="clr-namespace:Behaviors;assembly=Behaviors"
x:Class
="Behaviors.Sample.InvokeCommandDemoPage"
Title
="InvokeCommand Demo"
Icon
="xaml.png">
<ContentPage.BindingContext>
<local:InvokeCommandDemoPageViewModel />
</ContentPage.BindingContext>
...
<ContentPage.Behaviors>
<behaviors:EventHandlerBehavior EventName="Appearing">
<behaviors:InvokeCommandAction Command="{Binding PageAppearingCommand}" />
</behaviors:EventHandlerBehavior>
<behaviors:EventHandlerBehavior EventName="Disappearing">
<behaviors:InvokeCommandAction Command="{Binding PageDisappearingCommand}" />
</behaviors:EventHandlerBehavior>
</ContentPage.Behaviors>
...
</ContentPage>

When the Page.Appearing event fires, the PageAppearingCommand is executed. Similarly, when the Page.Disappearing event fires, the PageDisappearingCommand is executed. The InvokeCommandAction class expects to find the ICommand instances on the BindingContext of the attached object, and in this case the BindingContext is set to an instance of the InvokeCommandDemoPageViewModel class. Note that the Actions property of the EventHandlerBehavior instances is set indirectly by creating each InvokeCommandAction instance as a child of each EventHandlerBehavior instance. When the ICommand instances are executed, they display alerts that confirm that the appropriate page event fired.

The sample application that this code comes from can be downloaded from GitHub.

Summary

The Behaviors Library for Xamarin.Forms now supports attaching behaviors at the page level. This enables actions to be executed in response to a page event firing.

April 25, 2016 8:01 GMT

Announcing FreshMvvm 2.0

Today we’ve published up to nuget FreshMvvm 2.0 with some very anticipated new features.

IOC Container Lifetime Registration Options

We now support a fluent API for setting the object lifetime of object inside the IOC Container.

// By default we register concrete types as 
// multi-instance, and interfaces as singletons
FreshIOC.Container.Register<MyConcreteType>(); // Multi-instance
FreshIOC.Container.Register<IMyInterface, MyConcreteType>(); // Singleton 

// Fluent API allows us to change that behaviour
FreshIOC.Container.Register<MyConcreteType>().AsSingleton(); // Singleton
FreshIOC.Container.Register<IMyInterface, MyConcreteType>().AsMultiInstance(); // Multi-instance

As you can see below the IFreshIOC interface methods return the IRegisterOptions interface.

public interface IFreshIOC
{
    object Resolve(Type resolveType);
    IRegisterOptions Register<RegisterType>(RegisterType instance) where RegisterType : class;
    IRegisterOptions Register<RegisterType>(RegisterType instance, string name) where RegisterType : class;
    ResolveType Resolve<ResolveType>() where ResolveType : class;
    ResolveType Resolve<ResolveType>(string name) where ResolveType : class;
    IRegisterOptions Register<RegisterType, RegisterImplementation> ()
        where RegisterType : class
        where RegisterImplementation : class, RegisterType;
}

The interface that’s returned from the register methods is IRegisterOptions.

public interface IRegisterOptions
{
    IRegisterOptions AsSingleton();
    IRegisterOptions AsMultiInstance();
    IRegisterOptions WithWeakReference();
    IRegisterOptions WithStrongReference();
    IRegisterOptions UsingConstructor<RegisterType>(Expression<Func<RegisterType>> constructor);
}

Switching out NavigationStacks on the Xamarin.Forms MainPage

There’s some cases in Xamarin.Forms you might want to run multiple navigation stacks. A good example of this is when you have a navigation stack for the authentication and a stack for the primary area of your application.

To begin with we can setup some names for our navigation containers.

public class NavigationContainerNames
{
    public const string AuthenticationContainer = "AuthenticationContainer";
    public const string MainContainer = "MainContainer";
}

Then we can create our two navigation containers and assign to the MainPage.

var loginPage = FreshMvvm.FreshPageModelResolver.ResolvePageModel<LoginViewModel>();
var loginContainer = new FreshNavigationContainer(loginPage, NavigationContainerNames.AuthenticationContainer);

var myPitchListViewContainer = new MainTabbedPage(NavigationContainerNames.MainContainer);

MainPage = loginContainer;

Once we’ve set this up we can now switch out our navigation containers.

CoreMethods.SwitchOutRootNavigation(NavigationContainerNames.MainContainer);

New public methods

CurrentNavigationServiceName and PreviousNavigationServiceName are both public methods, so you can access them if you need to.

Some features (recently released)

Multiple Navigation Services
Custom IOC Containers
WhenAny
Pushing different views
Clean up after page is Popped

Summary

As always this is available on nuget now!

If you have any questions please ask on forums.xamarin.com and send me a email.

You can also find some more docs on the github repo.

Thanks

The post Announcing FreshMvvm 2.0 appeared first on Michael Ridland.

April 25, 2016 3:37 GMT

Xamarin Evolve 5k

There's been a tradition for the more energetic attendees to do a morning 5k run during Xamarin Evolve - and 2016 will be no different! Xamarins have been out training most mornings, and we look forward to meeting and running with our customers. It's a FUN run, not a race - if you've got your gear and can complete the distance, please join us! Follow @conceptdev for twitter updates.

Date: Wednesday 27th (first day of conference, before the keynote)
Time: 6:15am
Place: outside Hyatt reception (near the flagpoles)

The Course

We'll run a flat 5km (3.2 mile) loop anti-clockwise around the conference center and surrounds:


It'll be early morning so traffic should be light (based on the past few days), however there are a couple of road crossings and safety will be the priority over speed. This is what the meeting place looks like at 6:15am:


For the speedsters, hang around at the end if possible to celebrate with everyone, get a group photo, and ensure you get mini-hack credit for completing the run!


April 25, 2016 2:38 GMT

Lessons Learned from Silicon Valley on HBO - Lessons From The Developer Led Startup

Url: https://visualstudiomagazine.com/articles/2016/04/19/the-reality-of-developer-startups.aspx

The HBO series, Silicon Valley, should be on the viewing list of everyone involved in technology. There is lots of discussion around it, and some of those who live in the geographical region of the Silicon Valley take issue with the series, claiming it's inaccurate.

As someone who has lived it and was involved in startups there, Silicon Valley is an accurate representation. Silicon Valley goes beyond just showing the geographic region as a background character – the show offers a fairly accurate depiction of the the life, times, and hassles of doing a startup. Show creator Mike Judge pokes fun at the geographical Silicon Valley, but also some of the more realistic and ridiculous things that can happen to a Silicon Valley startup. In this article, I'll take a break from the usual startup strategy talk and look at some of the parallels the show and reality sync up as we look at what's happened so far in seasons one and two.

April 22, 2016 1:30 GMT

Weekly Xamarin Newsletter Issue #89

Join the Xamarin Evolve 2016 Live Stream
Joseph Hill is inviting all of us not going to Evolve to the live stream.

Getting Started with the Media Plugin for Xamarin
Pierce Boggan introduces the Media plugin for Xamarin.

Continuous Integration & Deployment
Pierce Boggan and James Montemagno share their mobile CI experiences.

Xamarin Forms: CarouselView
Carrado shows off the new CarouselView that replaces the old CarouselPage.

Push notifications with Xamarin – Windows Phone
Gerald Versluis finishes off his push notification series. This time it’s Windows Phone.

Xamarin Forms Page Templates
Adam Pedley loves MasterPages and adds them to Xamarin.Forms.

Gone Mobile 32: Bitrise with Barnabas Birmacher and Daniel Balla
Greg Shackles and Jon Dick get into CI for mobile apps on the Gone Mobile podcast.

Yet Another Podcast #153 – James Montemagno: Xamarin
Jesse Liberty has James on to talk all things mobile.

Inject Wave Engine into Xamarin.iOS Apps
Marcos Cobeña Morián updates his article to help you make wonderful things.

FreshEssentials for Xamarin.Forms – The must-have nuget for Forms
Michael Ridland puts together the finer Nugets needed for Xamarin.Forms.

Mobile UX – How I Took Weeks To Eventually Code A Button
Adam Pedley lessons learned the hard way. We’ve all done this.

 

Don't miss out! Subscribe Today

Do you blog about Xamarin? Get your blog in the newsletter. Email me at adam [at] adamjwolf.com.

The post Weekly Xamarin Newsletter Issue #89 appeared first on Syntax is my UI.

April 19, 2016 8:00 GMT

Gone Mobile 32: Bitrise with Barnabas Birmacher and Daniel Balla

In this episode we’re joined by Barnabas Birmacher and Daniel Balla to talk about their continunous integration solution for mobile apps. Looking to get started adding CI for your apps? Listen in to find out how!

Hosts: Greg Shackles, Jon Dick

Guest: Barnabas Birmacher, Daniel Balla

Links:

Thanks to our Sponsors!

Raygun.io

Raygun.io - Exceptional Error Tracking Raygun.io is the fastest and easiest way to track your application’s errors and get the level of detail you need to fix crashes quickly. Notifications are delivered right to your inbox and presented on a beautiful dashboard.

April 19, 2016 2:09 GMT

Inject Wave Engine into Xamarin.iOS Apps

My good friend and workmate Sergio Escalada and I wrote a few months ago a quick guide, along with a sample (find the link below), on how you can render Wave Engine on a Xamarin.iOS app: not a full-screen game it-self, but adding specific views which are handled from Wave Engine.

Today, we’ve updated the article and sample app, because since Wave Engine v. 2.1.0 it’s much more easier to accomplish this:

abr-19-2016 15-58-17
A GIF nowadays is worth a thousand words

It opens a new world of chances, like creating custom CAD apps, or playing with AR, for instance. We hope our users, you, will take this and make wonderful things. Don’t forget to please share those with all of us!

Integrating Wave Engine within an iOS Storyboard

PS: I’ll be at Xamarin Evolve next week, so we can discuss this topic if you’re attending as well!:-)


April 18, 2016 2:52 GMT

Push notifications with Xamarin &amp;#8211; Windows Phone

To conclude my ‘push notifications’ series I will now tell you how to implement push notifications on Windows Phone.
Be sure to read my previous two posts on the notifications for iOS and setting up Azure and also implementing on Android. If you did read and/or follow them, this will be a piece of cake (hmm cake.). I find Windows Phone by far the easiest platform to implement notifications on. So lets get crackin’!

Prepare Azure

As you might expect, following my last few posts, I will first prepare Azure for sending notifications to our Windows Phone clients. So first step; go to the Azure management portal, to your Notification hub and find the Configure tab once more. Also, we need to go to the Windows developer portal. If you haven’t already done so; create a app entry for your app and go into the details.

In the left menu find ‘Services’ and then ‘Push notifications’ as shown below.

Windows Developer Dashboard
Windows Developer Dashboard

In the next screen watch closely to find a link to the ‘Live Services site’ and click it. This will most likely prompt you to login again.
At the page you reach then you will see the needed information for our Azure back-end. Find the values under ‘Package SID’ and ‘Client secret’ and paste them in the corresponding fields in your Azure configuration. Don’t forget to hit the ‘Save’ button at the bottom!

If all is well the values are accepted and you are done configuring Azure!

Updating our app

Other then iOS and Android on Windows you don’t get a unique token for your device, but you get a URL which acts as a notification channel.
Luckily the rest of the workflow is the same as the other platforms so we can follow along the same path.

Because Windows Phone is just supported out-of-the-box by Visual Studio we can leverage a available NuGet package to implement the push notifications. The only issue they have created now is that there are two flavours of Windows Phone apps; Silverlight and Universal Windows apps.
Because te later is going to be the future and is now the default template when you create a Xamarin.Forms solution I will only handle this one.

Go ahead and add the WindowsAzure.Messaging.Managed NuGet package to the WinPhone project. Then in the App.xaml.cs find the OnLaunched event.
This event is fired, as you would expect, when the app is launched. Right after the opening tag you place this code;

protected async override void OnLaunched(LaunchActivatedEventArgs e)
{
    var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();

    // TODO add connection string here
    var hub = new NotificationHub("XamarinNotifications", "<connection string with listen access>");
    var result = await hub.RegisterNativeAsync(channel.Uri);

    // Displays the registration ID so you know it was successful
    if (result.RegistrationId != null)
    {
        Settings.DeviceToken = result.RegistrationId;
    }

    // The rest of the default code is here
}

Don’t forget to add the async keyword in the method signature.

When you take a close look at the code you will see that we try to create a channel over which we will receive the notifications. On the other platforms we only have a token which identifies the device, on Windows you also get a channel in the form of a URL with which we can reach the device. We only save the registration ID for now.

Again, I am using the Settings plugin to save this token for later use.

Also, you see that there is still a TODO in there, you have to insert a connection string. In the other project this is inferred from the access code you insert there. Here you need to provide the full connection string. You can find it by going to your Azure management portal, open the Service Bus screen and navigate to your Notification Hub. At the bottom you will find the ‘Connection Information’ button. When you click it you will see the DefaultListenSharedAccessSignature key. You need the value that is after this key.

The last thing you need to do is declare that the app wants to use Toast capabilities. To do this go into your WinPhone project and find the ‘Package.appxmanifest’ file. Double-click it and set the Toast capable field to Yes. If you wondered; yes, toast is Microsofts way of saying push messages. Check out the different kind of messages you can send here.

Enable Toast capabilities
Enable Toast capabilities

Now run the app in the emulator and get back to your Azure management portal to test this out, right now!

In the Debug tab of your notification hub set the platform to Windows, and the notification type to.. Surprise, surprise; toast!

Send test notification Windows
Send test notification Windows

Now the only thing left is to push the Send button at the bottom of the screen and switch back over to your emulator and behold your new, epic, shiny push notification on Windows Phone!

Test notification Windows Phone
Test notification Windows Phone

As usual, find the sample code on my updated GitHub. For the last part, next time stay tuned to create a console tool which sends out push notifications to all of your apps at once!

April 17, 2016 11:00 GMT

FreshEssentials for Xamarin.Forms – The must-have nuget for Forms

Ah this is one I’ve been wanting to do for a long time and I’m pretty excited about it. We use it everyday, as it’s really useful.

FreshEssentials for Xamarin.Forms has ONLY the most common elements you need for Xamarin.Forms. It’s contains the elements you need in almost every project and nothing more, things like BindablePicker, SegementedButtons, InverseBooleanConverter, TappedGestureAttached, ListViewItemTappedAttached and not much more. It’s the lightweight essentials.

Why?

Because it’s awesome and nothing else solves this problem yet. For the majority of projects there’s some missing essential pieces to the Xamarin.Forms puzzle, what I wanted to build was a nuget that filled the gaps but ONLY the essential gaps. These are code snippets I’ve been putting in the majority of my Xamarin.Forms projects, the components are stable and used regularly. These codes snippets include a BindablePicker and InverseBooleanConverter, who doesn’t use them in a project. Most people just copy them from project to project, XLabs had the idea to solve this issue but now it’s blow out and is normally too large for most Xamarin.Forms projects. Just to note, I’m a contributor to XLabs and was one one of the first to contributors but with the direction it’s now taken I’m not sure if anyone wants to maintain it, the monolith it is means it’s hard to maintain.

How to use?

nuget all the things…. Primarily you can get FreshEssentials from nuget.

https://www.nuget.org/packages/FreshEssentials/1.0.0

The code can be found on github and there’s also a sample project.

FreshEssentials on github(https://github.com/XAM-Consulting/FreshEssentials)

FreshEssentials sample on github (https://github.com/XAM-Consulting/FreshEssentialsSample)

BindablePicker

Ok so who doesn’t need a BindablePicker in a Xamarin.Forms project?

BindablePicker inherits from Xamarin.Forms.Picker, you can binding data to ItemSource as Items, and also can set which property you want to display via DisplayProperty.

If you want to use it in XAML, you need to include the namespace first.

xmlns:fe="clr-namespace:FreshEssentials;assembly=FreshEssentials"

<fe:BindablePicker ItemsSource="{Binding MyCars}" SelectedItem="{Binding SelectedCar}" DisplayProperty="MakeAndModel" Title="Select..." />

AdvancedFrame (flexible rounded corners)

This is primary used for the SegmentedButtonGroup, it gives you more flexibility on the corner radius in the Frame. AdvancedFrame inherits from Frame, you can set corner type via Corners(There are only four type, left, right, all, none), you can also set CornerRadius and InnerBackground color

<fe:AdvancedFrame Corners="left" CornerRadius="10" InnerBackground="Blue" OutlineColor="Red" >
    <Label Text="Corners is left, CornerRadius is 10, InnerBackground is Blue" TextColor="White"/>
</fe:AdvancedFrame>

SegmentedButtonGroup

This is one that most people ask for in their first project, normally people fail to implement the segmented button in XF and crosss platform. I hope with this control people will be able to use it more often.

SegmentedButtonGroup is like iOS Segmented Controls, you can binding SelectedIndex for it

<fe:SegmentedButtonGroup OnColor="Blue" OffColor="White" SelectedIndex="{Binding SelectIndex, Mode=TwoWay}">
<fe:SegmentedButtonGroup.SegmentedButtons>
  <fe:SegmentedButton Title="Button 1"/>
  <fe:SegmentedButton Title="Button 2"/>
  <fe:SegmentedButton Title="Button 3"/>
</fe:SegmentedButtonGroup.SegmentedButtons>
</fe:SegmentedButtonGroup>

InverseBooleanConverter

Ah the amount of times people have copied this code into their project… not anymore….

<ContentPage.Resources>
    <ResourceDictionary>
         <fe:InverseBooleanConverter x:Key="InverseConverter" />
    </ResourceDictionary>
</ContentPage.Resources>

<Button Text="Click Me" IsVisible="{Binding ShowButton, Converter={StaticResource InverseConverter}}" />

ListViewItemTappedAttached

This ones is definately a project favorite, if you’re not sure what it does be sure to take a look at the samples and read this blog.

<ListView ItemsSource="{Binding MyCars}" fe:ListViewItemTappedAttached.Command="{Binding ItemTapCommand}">

TappedGestureAttached

The easiest way to add a tap gesture to your controls.

<Image Source="xamconsulting.png" fe:TappedGestureAttached.Command="{Binding ImageTappedCommnad}" />

 

That’s it! All we need. Please be sure to take a look at the samples, you can clone from github or download the zip.

Please let me know how it goes.

Thanks

Michael

 

The post FreshEssentials for Xamarin.Forms – The must-have nuget for Forms appeared first on Michael Ridland.

April 15, 2016 1:30 GMT

Weekly Xamarin Newsletter Issue #88

Download the Xamarin Evolve 2016 Conference App
James Montemagno releases the Evolve 2016 App on iOS, Android and Windows Phone.

Using Xamarin Forms Effects
Corrado makes a few tweaks to UI controls for each platform.

Custom Animations in Xamarin Forms
Adam Pedley is on fire with his progress bar animation.

Simple Cross-Platform File IO for iOS, Android, and Windows
Pierce Boggan introduces us to the File System Plugin.

Xamarin.Forms Behaviors: DataChangedBehavior and SetPropertyAction
David Britch adds his last action to the library.

Customizing Xamarin.Forms Controls with Effects
Nish Anil simplifies customizing platform controls with Effects.

Debugging Xamarin Android Build and Deployment Failures
Adam Pedley reveals his playbook for when things don’t go right.

Preparing your Mobile App for Deployment
Adam Pedley’s checklist of common pitfalls before releasing to beta testers.

Using Google Place Picker For Android
Ruben Macias shows you how easy it is to use the built in control.

A Xamarin Forms example using SQLite.NET-PCL with Async
Michael Dimoudis gives us the benefit of his research into Async and SQLite.

Creating User Controls in Xamarin Forms
srkrathore creates reusable controls for Xamarin.Forms.

Custom Gestures In Xamarin Forms
Adam Pedley adds some pressing gestures to Xamarin.Forms.

 

Don't miss out! Subscribe Today

Do you blog about Xamarin? Get your blog in the newsletter. Email me at adam [at] adamjwolf.com.

The post Weekly Xamarin Newsletter Issue #88 appeared first on Syntax is my UI.

April 13, 2016 10:33 GMT

Xamarin.Forms Behaviors: DataChangedBehavior and SetPropertyAction

Previously, I demonstrated using the DataChangedBehavior and InvokeMethodAction classes to invoke one or more methods when data changes. The Behaviors Library for Xamarin.Forms has the notion of behaviors and actions. A behavior is attached to a control and listens for something to happen, such as an event firing. When the “something” happens, it triggers one or more actions, such as invoking a method or command. Actions are invoked by behaviors and executed on a selected control.

In this blog post, I’ll demonstrate using the DataChangedBehavior and SetPropertyAction classes to set one or more properties when data changes.

Setting a Property when Data Changes

The DataChangedBehavior class listens for the bound data to meet a specified condition, and executes one or more actions in response. It requires you to set the following properties:

  • Binding – an object that represents the bound object that the behavior will listen to.
  • ComparisonCondition – a ComparisonCondition enumeration value that represents the comparison to be performed between the values of the Binding and Value properties. The enumeration values are: Equal, NotEqual, LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual.
  • Value – an object that represents the value to be compared with the value of the Binding property.
  • Actions – one or more actions that should be executed in response to the bound data changing. Note that this property is set indirectly.

The SetPropertyAction class sets a specified property when invoked. It requires you to set a TargetObject property to an object that exposes the property of interest, a PropertyName property to the name of the property to be set, and a Value property to an object that represents the property value to be set.

The following code example shows an example of using the DataChangedBehavior and SetPropertyAction classes to set the colour of BoxView control and a ViewModel property as a Slider value changes:

<ContentPage.BindingContext>
<local:SetPropertyDemoPageViewModel />
</ContentPage.BindingContext>

<Slider x:Name="slider" Minimum="0" Maximum="100">
<Slider.Behaviors>
<behaviors:DataChangedBehavior Binding="{Binding Path=Value, Source={x:Reference slider}}"
ComparisonCondition
="LessThan"
Value
="1">
<behaviors:SetPropertyAction TargetObject="{x:Reference changingBoxView}"
PropertyName
="Color"
Value
="{StaticResource ColorAqua}" />
<behaviors:SetPropertyAction TargetObject="{Binding}"
PropertyName
="ColourText"
Value
="Aqua" />
</behaviors:DataChangedBehavior>
<behaviors:DataChangedBehavior Binding="{Binding Path=Value, Source={x:Reference slider}}"
ComparisonCondition
="GreaterThanOrEqual"
Value
="1">
<behaviors:SetPropertyAction TargetObject="{x:Reference changingBoxView}"
PropertyName
="Color"
Value
="{StaticResource ColorRed}" />
<behaviors:SetPropertyAction TargetObject="{Binding}"
PropertyName
="ColourText"
Value
="Red" />
</behaviors:DataChangedBehavior>
...
</Slider.Behaviors>
</Slider>
<BoxView x:Name="changingBoxView" WidthRequest="100" Color="Aqua" HeightRequest="100" ... />
<StackLayout Orientation="Horizontal" HorizontalOptions="Center">
<Label Text="Slider value:" />
<Label BindingContext="{x:Reference slider}" Text="{Binding Value, StringFormat='{0:F0}'}" />
</StackLayout>
<StackLayout Orientation="Horizontal" HorizontalOptions="Center">
<Label Text="Colour:" />
<Label Text="{Binding ColourText}" />
</StackLayout>

When the Value property of the Slider changes a series of DataChangedBehavior instances are executed. Each behavior instance compares the Value property of the Slider against a value, and executes two SetPropertyAction instances if the comparison is true. The first SetPropertyAction instance changes the Color property value of the BoxView, while the second SetPropertyAction instance sets the ColourText property of the SetPropertyDemoViewModel instance. Note that the Actions property of each DataChangedBehavior instance is set indirectly by creating the SetPropertyAction instances as children of the DataChangedBehavior instances.

The advantage of combining the DataChangedBehavior and SetPropertyAction classes is that properties of controls and ViewModels can easily be set when data changes, therefore removing boiler-plate property setting code from code-behind and ViewModels.

The sample application that this code comes from can be downloaded from GitHub.

Summary

The DataChangedBehavior class listens for the bound data to meet a specified condition, and executes one or more actions in response. The SetPropertyAction class sets a specified property when invoked. The advantage of combining the DataChangedBehavior and SetPropertyAction classes is that properties of controls and ViewModels can easily be set when data changes, therefore removing boiler-plate property setting code from code-behind and ViewModels.

April 13, 2016 8:34 GMT

Detect non system input method

On Android developers cannot define whether the input field supports non standards/custom keyboards. This might be an issue for secured applications, like mobile banking, or any line of business apps. What can be done then is to at least notify the user that this is the case and he should be careful not to use such input methods when logging in and use only the system default ones.

The code to check that is:

InputMethodManager methodManager = (InputMethodManager)this.GetSystemService (Context.InputMethodService);

foreach (var inputMethodInfo in methodManager.EnabledInputMethodList)
{
    if (inputMethodInfo.Id.Equals (Settings.Secure.GetString (ContentResolver, Settings.Secure.DefaultInputMethod)) == false)
    {
        if ((inputMethodInfo.ServiceInfo.ApplicationInfo.Flags & ApplicationInfoFlags.System) == 0)
        {
            // we found non default input method, so show the error toast and return;
        }
    }
}



Happy coding.

The post Detect non system input method appeared first on IOS BITS LTD | Mobile application development.

April 11, 2016 3:26 GMT

Using Google Place Picker For Android

One of my recent projects had an interesting requirement.  It was an Android application and it needed to be aware of any businesses that were near the user’s current location.  If you have ever used Facebook’s or FourSquare’s “Check-In” feature, it’s very similar.  The user had to tap a button, and bring up a list of all business that were near the user.  The user would then choose a business (location), and then display the business’s Name, Address, City, State, Latitude, Longitude, etc.

When researching this functionality, I stumbled along the Google Places API.  Upon examining the Google Places API, I noticed the PlacePicker widget.  This is an out of the box widget that you can display programmatically and it will give you a beautiful Location Picker user interface similar to the Google Maps app for Android.

This meet my requirement, and then some.  Not only did it give me a list of businesses that were near my user’s location, it also gave me a material design user interface that my users could interact with.  That was an added bonus since I didn’t need to create a UI for this.  I could just use the out of the box control and be done with it.  To top it off, using the PlacePicker was easy!  And on this post, I’m going to show you how to add it to your Xamarin.Android applications.

First Things First

The first thing you need to do before you start writing code is to acquire a Google Maps v2 API Key.  If you already have one for your application, then great!  Use that one!  If not, you’ll have to acquire one.  They are free, and there are a number of steps you have to perform in order to get one.  Luckily, Xamarin has some detailed documentation on how to get one.  So I recommend that you read that.

Next you want to download the latest Android SDK Tools and Google Play Services SDK from the Android Device Manager.  I’m not quite sure what minimum versions you’ll need.  But if you have a relatively recent version, then it should work.  If not, just download the latest versions from the Android SDK Manager.  If you need details on how to do that, I discuss this in the video below.

High Level Step By Step

I go into great detail in the video below, but as a reference here is what we’re going to do:

  1. Acquire a Google Maps v2 API Key.
  2. Download the latest, or have a relatively later version, of the Android SDK Tools and Google Play Services API.
  3. Create an instance of PlacePicker.IntentBuilder.
  4. Use StartActivityFromResult to launch an intent from your Place Picker Intent Builder.
  5. Override OnActivityResult so that the PlacePicker control can return data back to us.
  6. Get the Place that the user picked from the PlacePicker.
  7. Populate our UI from the Place object that the user chose.

That’s pretty much it at a high level.  You can download the completed source code on my GitHub page here.  Of course, a video is worth a million words!  Watch the video and you can see the step by step details how to call the built-in PlacePicker control.

Feel free to leave a comment and let me know what you think!

April 10, 2016 5:23 GMT

Álvaro and I fighting the crisis

aro&amp;marcos
Álvaro and my-self (carrying my C# t-shirt:-) )

Kim, a passionate translator who I met while working in workINcompany, has published an article where Álvaro and I answer a few questions regarding our app ¡Buenos días! aro. I like that thing of “Crisis Busters”. I guess it’s needed nowadays to look for different ways to solve common problems -like the crisis we’re going through, or living with- without loosing our smile.

Today I’ve noticed my Dad uses the alarm included in the app to remember when to take the next pill… Such are the small things I find beauty on, and push me forward.

Thanks so much Kim! And thanks too because the reason why the app looks native in terms of English language is due to your work. Without asking anything back, truth be told:

Crisis Busters: Buenos días app


April 08, 2016 3:41 GMT

Podcast Gold

If you are like me, when you start a podcast, you rarely go back to find old ones, which may be out of date.  However, some of Yet Another Podcast is worth a listen even now.  Here are some of the best that are still relevant.

April 08, 2016 1:30 GMT

Weekly Xamarin Newsletter Issue #87

Sold out! Xamarin Evolve Sells Out for the Third Time
We all knew this was going to happen and now it has.

Introducing Xamarin Workbooks
Craig Dunn wants you to give Xamarin Workbooks a try.

Podcast Interviews with Dan Hermes: Microsoft, Xamarin.Forms, His Music and His Tiki Drinks
Dan Hermes is on “Yet Another Podcast” and “Away From the Keyboard”.

Xamarin.Forms Behaviors: DataChangedBehavior and InvokeMethodAction
David Britch adds another behavior to his series on Xamarin.Forms.

FormattedText with custom fonts in Xamarin.Forms
Sven-Michael Stübe documents his learning from answering a Stack Overflow question on fonts.

Xamarin.Forms 101: Pages and Layouts and Views (Oh My)
Dan Hermes makes Pages and Layout in Xamarin.Forms less scary.

Indexed ViewModelLocator With MVVMLight And Xamarin Forms
Rasmus Tolstrup Christensen improves the fuzziness with his clean code.

Installing GApps in Visual Studio Android Emulator (Marshmallow)
Tomasz Cielecki digs into Google Play services and Android Emulators.

So you want to be Xamarin Certified?
Steven documents his journey to be certified.

Wow, I’m a Microsoft MVP!
Kerry Lothrop shows off his MVP. Congratulation Kerry, well done!

Push notifications with Xamarin – Android
Gerald Versluis adds Android to his series on Push Notifications.

Welcome New Xamarin Developers!
Matthew Soucoup welcomes all the new VS developers to Xamarin.

 

Don't miss out! Subscribe Today

Do you blog about Xamarin? Get your blog in the newsletter. Email me at adam [at] adamjwolf.com.

The post Weekly Xamarin Newsletter Issue #87 appeared first on Syntax is my UI.

April 06, 2016 10:02 GMT

Wow, I’m a Microsoft MVP!

On April 1, 2016, I was awarded the Microsoft MVP status for “Visual Studio and Development Technologies”. It is an incredible honor for me and I am still a little in shock. Already, I’m seeing new information pour in and new connections being made and I am really excited about the road ahead.

The shocking part for me was that I had concentrated my community work almost entirely on Xamarin technology. In October 2015, a change in the MVP program categories meant Xamarin was now one of the award category technologies (hey, even Java is on that list!).

MVP Award Categories

I was nominated by Microsoft Technical Evangelist Daniel Meixner at the end of 2015 (thank you very much!), then there was a review, and apparently, my contributions were sufficient for the award committee.

I don’t plan on decreasing my efforts in 2016. I contributed to the MvvmCross 4.0 release at the beginning of the year, I’ve already done two public presentations, and I’ve found the time to blog. With Xamarin Evolve around the corner (where I’ll also be speaking) I’m anxious to find out which direction Xamarin and now Microsoft are going to take the cross-platform adventure we’re on. The announcements at Build made me very happy, personally, and I’m looking forward to sharing the knowledge with more people.

If you want to hear one of my presentations, keep an eye on my public speaking list where I’ll also be posting links to any videos or slides in case you missed the talk.

Above all, many thanks to my employer Zühlke who is supporting my community activity with time and money!

April 05, 2016 8:34 GMT

Installing gapps in Visual Studio Android Emulator (Marshmallow)

The images Google provides in the Android SDK are all great and work fine if you have Intel HAXM installed on the machine. However, a lot of developers using Visual Studio, also use Hyper-V to run Windows device emulators. This means Intel HAXM doesn't work and in turn means that the x86 images from Google won't run because there is another hypervisor running.

Microsoft have been so kind to provide the Visual Studio Android Emulator which uses Hyper-V as hypervisor and does not require you to reboot your machine every time you want to switch between using Hyper-V and another hypervisor. Great!

There is one caveat. None of the images included in the Visual Studio Android Emulator tools have Google Play Services installed. Hence, you have to install them yourself. It turned out to be more complicated than I thought it would. Hence, I am documenting it in this blog post.

At first I tried the tried and great OpenGapps, which a lot of custom roms for Android devices recommend using. Picked x86 and the pico package for Android M and tried to install that on a Marshmallow image. It just threw an error telling me that the system/ folder was missing in the zip. Great, what then? I tried adding that folder with an empty file manually to the zip, as it seems it doesn't care whether the zip is signed or not when installing. This made the zip install. Well not really, no Play Store or Play Services where actually installed.

I tried some other GAPPS zips from various sources, none of them seemed to work. I searched around without finding any solution.

Alexandre Chohfi over at the Xamarin Community Slack pointed out that he had the same issues with Genymotion, which runs on VirtualBox and pointed me in the direction of this gist explaining how to do it on Genymotion. Following the instructions from arcao in the comments works! Without installing that Genymotion ARM translation package too.

Steps I used

Prerequisites

1. Install a Marshmallow image in the Visual Studio Emulator for Android tools (can be opened through Tools > Visual Studio Emulator for Android in Visual Studio)


2. Download gapps-L-4-21-15.zip

3. Download benzo-gapps-M-20151011-signed-chroma-r3.zip

Installing

1. Start the Marshmallow image

2. Drag the gapps-L-4-21-15.zip onto the Emulator after it has booted. It will prompt you to install the zip and shutdown the device after that.


3. After having install the gapps boot up your Emulator again, it will show a dialog about optimizing newly installed packages.

4. Go to Settings > Accounts and Add a Google Account. Ignore all crashes.



5. After adding the Account, install the benzo-gapps-M-20151011-signed-chroma-r3.zip by dragging it onto your Emulator, like in step 2.

6. After rebooting after step 5. is done, you should now have working Play Services and Play Store on your Visual Studio Emulator for Android.


April 05, 2016 5:04 GMT

Introducing Xamarin Workbooks

The first public demonstration of Xamarin's new Workbooks idea was Miguel de Icaza's //build 2016 talk "Mobile First" (although he first wrote about it back in February). In his talk, Miguel demonstrates a new take on interactive documentation in which a Markdown-formatted file can live-execute C# code-fenced blocks; not just in-line but also in an iOS or Android simulator.



This opens up a great opportunity to write and share interactive documentation that not only describes an API or feature, but shows it in action. Further, it's easy to write, being based on the well-known Markdown format.

Give it a try!

You can now try Workbooks for yourself! The editor can be downloaded here, and there is some Workbook documentation on the Xamarin developer portal.

I've thrown together a few very simple ideas on github:

See Miguel's talk (if you didn't already) for a really cool demo.

Some Notes


  1. They're written in Markdown, but with a .workbook file extension.
  2. Each file begins with a small JSON-formatted metadata section. The editor will add this for you.
  3. C# code inside triple-backtick code fences will be executed when the file is viewed in the Workbooks editor. 
There's sure to be other resources popping up now that the project preview is publicly available -- Ben Bishop's video is the first community resource I've seen. Can't wait to see what everyone creates with it!
April 04, 2016 4:06 GMT

Xamarin.Forms Behaviors: DataChangedBehavior and InvokeMethodAction

Previously, I demonstrated using the DataChangedBehavior and InvokeCommandAction classes to invoke one or more commands when data changes. The Behaviors Library for Xamarin.Forms has the notion of behaviors and actions. A behavior is attached to a control and listens for something to happen, such as an event firing. When the “something” happens, it triggers one or more actions, such as invoking a method or command. Actions are invoked by behaviors and executed on a selected control.

In this blog post, I’ll demonstrate using the DataChangedBehavior and InvokeMethodAction classes to invoke one or more methods when data changes.

Invoking a Method when Data Changes

The DataChangedBehavior class listens for the bound data to meet a specified condition, and executes one or more actions in response. It requires you to set the following properties:

  • Binding – an object that represents the bound object that the behavior will listen to.
  • ComparisonCondition – a ComparisonCondition enumeration value that represents the comparison to be performed between the values of the Binding and Value properties. The enumeration values are: Equal, NotEqual, LessThan, LessThanOrEqual, GreaterThan, GreaterThanOrEqual.
  • Value – an object that represents the value to be compared with the value of the Binding property.
  • Actions – one or more actions that should be executed in response to the bound data changing. Note that this property is set indirectly.

The InvokeMethodAction class executes a specified method when invoked. It requires you to set a TargetObject property to an object that exposes the method of interest, and a MethodName property to the name of the method to be invoked. The InvokeMethodAction class allows you to call a method with zero parameters, or a method with two parameters. For more information about calling a method with parameters, see EventHandlerBehavior and InvokeMethodAction.

Calling a Method without Parameters

The following code shows an example of using the DataChangedBehavior and InvokeMethodAction classes to invoke a method without parameters:

<StackLayout BindingContext="{x:Reference page}">
<Picker x:Name="picker" Title="Colours">
<Picker.Items>
<x:String>Red</x:String>
<x:String>Blue</x:String>
<x:String>Green</x:String>
</Picker.Items>
<Picker.Behaviors>
<behaviors:DataChangedBehavior Binding="{Binding Path=SelectedIndex, Source={x:Reference picker}}" ComparisonCondition="NotEqual" Value="-1">
<behaviors:InvokeMethodAction TargetObject="{Binding}" MethodName="OnPickerChanged" />
</behaviors:DataChangedBehavior>
</Picker.Behaviors>
</Picker>
<StackLayout Orientation="Horizontal">
<Label Text="Selected Item:" />
<Label x:Name="selectedItemLabel" />
</StackLayout>
</StackLayout>

When the value of the Picker.SelectedIndex property becomes not equal to –1, the OnPickerChanged method is executed. The TargetObject property value specifies that the BindingContext exposes the method of interest. Therefore, the InvokeMethodAction class will search the BindingContext of the attached control for the method, which in this case is the ContentPage. Note that the Actions property of the DataChangedBehavior is set indirectly by creating the InvokeMethodAction instance as a child of the DataChangedBehavior instance.

Generally, combining the DataChangedBehavior and InvokeMethodAction classes offers no advantage over combining the DataChangedBehavior and InvokeCommandAction classes. However, the InvokeMethodAction class can be useful when combined with other behaviors.

The sample application that this code comes from can be downloaded from GitHub.

Summary

The DataChangedBehavior class listens for the bound data to meet a specified condition, and executes one or more actions in response. The InvokeMethodAction class executes a specified method when invoked. Generally, combining the DataChangedBehavior and InvokeCommandAction classes is preferred over combining the DataChangedBehavior and InvokeMethodAction classes. However, the InvokeMethodAction class can be useful when combined with other behaviors.

April 01, 2016 2:10 GMT

Xamarin at //build/

Yowza!

 

Dawn

Miguel has demonstrated a number of new features in Xamarin and Xamarin.Forms that I want to start using immediately:

  • First, and most exciting: It’s Free!
  • Interactive documentation using markdown and embedded C#
  • Inspector and Workbooks
  • Simulator on Visual Studio (PC)
  • 2D and 3D Graphics Library
  • Open Source

Free Xamarin

Xamarin now available at no extra cost with every edition of Visual Studio (including the free community edition)!

Interactive Documentation

It is almost impossible to describe this without showing it, but I’ll try.  Imagine a page of documentation with embedded code examples.  You can bring up a simulator and see the result of that code, and more important you can change the code and immediately see the change in the simulator.  As you interact with the code, you get full intellisense.

Inspector and Workbooks

This may be one of the most exciting and useful new technologies for Xamarin.  The inspector is very much like a web/browser inspector, allowing you to inspect your live, running code.

The inspector also includes a live C# shell that allows you to inject code into your running program, and to experiment with changes to your code and see the effect in real time.

The inspector allows you to create enumerables and dive into them.  Inspectors include object render views (which gives you the information you would find in the properties window).  Inspectors also includes renderers for various types; for example if you examine an image, that image is displayed in the simulator itself.

C# Inspector

You can also create views and populate them with controls and see, in real time, the effects of your work.  This can be for any of the supported platforms, including iOS, Android, Mac and Windows Phone.

The simulator gives you a 3-d view of the various layers of views (that is, if you have a UI view with a StackLayout in it, with a Grid inside, etc., the 3D view shows these to you and the code is aligned with the view to show you a 1:1 correspondence between the hierarchy and the 3d representation.

3d view

For learning Inspectors, there is built in context sensitive help.

You can embed text into your Inspector, and then render a document with live code. This is the technology used in Interactive Documentation.

Workbooks are Inspectors used for exploring and learning.

Simulator on Visual Studio

Projecting the simulator onto Visual Studio makes debugging much easier, and is particularly helpful when screen sharing.  You can show your code in Visual Studio and see the result of your modifications on the same screen.

2D and 3D Graphics Library

More on this in a coming post

Open Source

All of Xamarin is now Open Source with a much broader license than before.  This will allow the use of Xamarin to program any device.

There’s a good bit more and I expect to be creating blog posts as more information becomes available.

April 01, 2016 1:30 GMT

Weekly Xamarin Newsletter Issue #86

Xamarin for Everyone
Nat Friedman announces Xamarin Studio now includes Xamarin.

Early Preview of Exrin
Adam Pedley releases an MVVM framework for Xamarin.Forms.

Simplify Sharing with Plugins for Xamarin
Pierce Boggan introduces the Share Plugin for Xamarin and Windows.

Testing Xamarin.Forms apps with RockMvvmForms and NUnit
Ramon Esteban shows you how to test with the Rock.

Fingerprint plugin for Xamarin released
Sven-Michael Stübe releases his new plugin for Xamarin.

Setting up Xamarin.iOS builds in Visual Studio Team Services through MacinCloud, and a bonus (HockeyApp)
Marcos Cobeña Morián has all the CI you could want with a bonus.

Push notifications with Xamarin – Android
Gerald Versluis puts together push with Azure and Android.

Xamarin Android List Views and MVVM Light
Richard Woollcott continues his series on how to use the MVVM pattern.

SlideOverKit is now free and open source
Michael Ridland follows Xamarin’s lead and open sources his kit.

 

Don't miss out! Subscribe Today

Do you blog about Xamarin? Get your blog in the newsletter. Email me at adam [at] adamjwolf.com.

The post Weekly Xamarin Newsletter Issue #86 appeared first on Syntax is my UI.

April 01, 2016 4:26 GMT

All For Xamarin, And Xamarin For All!

Oh. My. God.  Day 2 of Microsoft Build Conference had some incredible news.  Scott Guthrie pulled an Oprah, and officially announced that ALL editions of Visual Studio will be able to use the Xamarin Platform (Xamarin.iOS, Xamarin.Android, Xamarin.Forms) at no extra charge!  So that means if you have a license for ANY edition of Visual Studio, include the free Community Edition, you can build iOS, Android, and Windows Phone apps using Xamarin for free!  It’s a great day to be a C# developer!

https://blog.xamarin.com/xamarin-for-all/