Hacking the Xamarin.Forms Layout System for Fun and Profit

If you’re a Xamarin.Forms developer, it’s likely you already know about the two great talks that Jason Smith did at Evolve this year (2016). Both of the talks were on performance in Xamarin.Forms and they were outstanding because we got a truckload of performance tips that we’ve never had previously. If you’ve watched them once we would recommend you also consider watching them again, there’s alot of content and you’ll learn something new. This insight into the Xamarin.Forms performance and the layout system has been a key part of us building performant apps in Xamarin.Forms at XAM Consulting.

But we wanted more, we wanted more speed and more performance, we want native performance. The tips we got were great, but we wanted to understand why these tips existed because if we understand the system we can use that understanding to develop our own tips and techniques for Xamarin.Forms performance.

One of the points that Jason makes is about the Xamarin.Forms Grid, the suggestion is that we should avoid using the ‘Auto’ setting for columns and rows. Why is this? Well it turns out that if a view inside a Auto column changes size (or generally does anything to invalid measure) the grid will be doing a full layout of all children, well not only the grid but the Grid’s parent and parent after that.

If you watch both of the talks, it’s clear the root of performance in Xamarin.Forms is in the layout system, so let’s look into this Layout System. Now that Xamarin.Forms is open source we can use the code a understand the layout system.

The layout system is broken up into two parts/cycles, 1) the invalidation cycle 2) the layout cycle.

layoutcycle1

Invalidation Cycle

To understand the invalidation cycle let’s take a look at the Xamarin.Forms layout code.

As we can see in this code below each VisualElement.cs has a event MeasureInvalidated, VisualElement is the base class of Layouts, Views and Pages.

layoutevent

Then each time a child is added to a Page or Layout, the parent attaches the MeasureInvalidated event of the child.

layoutsubscription

As we can see below the OnChildMeasureInvalidated event handler (for the children) then calls the MeasureInvalidated event, because the parent of that View is subscribed to the MeasureInvalidated even the parents OnChildMeasureInvalidated method is called. It’s important to note there’s conditional logic involved, the event will not always be called.

measureinvalidated
…Conditional Logic…
measureinvalidated2

So here’s an example of what it looks like, with the events.

eventlinks

Here’s what happens when a child view becomes invalidated. As you can see the events bubble to the top.

measureinvalidated3

That’s the invalidation cycle.

Layout Cycle

Let’s take a look at the layout cycle, the layout cycle happens in two cases:
1) When a layout is done for the first time, eg. when a page is first displayed.
2) After the invalidation cycle

As you can see in the image below, during the first part of the layout cycle measure is called on the child. It’s important to note that for the most part measure is called on all children and in many cases it’s called multiple times. After the children have been measured then layout is called on all children.

layout1

So here’s how the full layout looks.

layout2

 

You might be thinking why do I care about this? Well because we can hack it. It’s possible to short circuit the invalidation cycle at an early stage, as per the image below.

shortcircuit

Let’s take a look at how we can test this. In order to test this I’ve created a page with a few labels and a single label that’s, updated on a timer 20 times. I’ve also linked up my Xamarin.Forms app into the Forms code base and added performance metrics to the methods inside Forms.

codebehind

Let’s first take a look at the results of a StackLayout as per below. stacklayout

The results show that LayoutChildIntoBoundingRegion is called 243 times, every time the text of the label is changed a full layout cycle happens.

resultallauto

Let’s try the same with a Grid, as per below.

gridfirst

The results show that LayoutChildIntoBoundingRegion is called 6 times, it’s only called the first time the view is shown.

notinvalidation

Let’s try the same Grid but using a ‘Auto’ for a row.

gridallauto

The result is back up to 243 times and the full layout is happening every time the label text is changed.

resultallauto

Ok, now let’s put back the Grid to using stars but I also want to try something different. I want to have children of the grid dynamically change size, so let’s test with a BoxView that changes width.

backendwithboxview

NB – In order for me to change the Width of the Box I need to change the HorizontalOptions on the BoxView from Fill to Start.

gridboxviewxaml

Even though we’ve changed the Height back to a star the result is still 243 and the full layout is happening everytime the label text is changed. It seems that when we change the HorizontalOptions of a child we also change change the invalidation cycle behaviour.

resultallauto

Ok, so I changed the BoxView back to Fill the BoxView will not change dynamically. Let’s try something different, lets put the BoxView inside a ContentView.

gridboxviewinsidecontent

It’s back down again, great so we still get our children changing dynamically and we also short circuit the layout system.

notinvalidation

Conclusions

  • A child of a stacklayout will always cause a full layout cycle, there’s no way a StackLayout can short circuit this cycle.
  • A child of a Grid with that’s inside rows and columns with static or star widths AND the LayoutOptions are set to Fill, are fully constrained which means that the invalidation cycle will be stopped at that child view.
  • In order to have children of a Grid change layout dynamically they need to be a child of another View which is fully constrained. (As per the Grid sample).

After taking a look at the Xamarin.Forms code base I can see this is the line that does the short circuit. It seems that a view.Constraint needs to be the value of LayoutConstraint.Fixed for this short circuit to occur. I did further research into this and found the only time we can short circuit the invalidation cycle is in the cases proven above.

UPDATE – Originally in this blog post I mentioned that the above cases are the only way to short circuit the invalidation cycle, this is not entirely true as the AbsoluteLayout can be used to short circuit the invalidation cycle. I will put together some more research for this for another post. 

layoutinvalidation

 

Talk with Rui Marinho XLabs Founder and Xamarin.Forms Developer

Last weekend I was lucky enough to attend and speak at the Xamarin Dev Days in Singapore. I think Dev Days Singapore is the biggest Dev Days so far with 400 registrations and 250 that attended. It was even more awesome for myself as I got to catch up with some friends in the Xamarin world including Rui Marinho.

In this video I talk with Rui Marinho the founder of XLabs and now a developer on the Xamarin.Forms team. We delve into some important topics, we discuss how he got into Xamarin, announce that XLabs is Dead, talk about open source and a little about the future of Xamarin.Forms.

 

Be more awesome with MFractor for Xamarin Studio

In this video I interview Matthew Robbins the creator of MFractor a Xamarin Studio Plugin. If you’re not using MFractor your really missing out, it’s got some beautiful features which save you truckloads of time when building apps with Xamarin Studio.

If you’ve ever wanted a ReSharper for Xamarin Studio this is it. It’s got static analysis, code generation and advanced navigation features. It’s here right now and will only get more awesome into the future.

You can find out more about MFractor here: www.fractor.com and find Matthew on twitter.com/matthewrdev

 

Announcing FreshMvvm 2.1 and 2.2

Your favourite Mvvm Framework for Xamarin.Forms just keeps getting better. At XAM Consulting we use FreshMvvm in all of our serious production applications, the fact that we use FreshMvvm so intensely is the reason that FreshMvvm is easy to use, robust and flexible.

There’s been two releases of FreshMvvm since I last updated, Version 2.1 and Version 2.2.

Release 2.2.0

Better debug messages displayed

In previous versions of FreshMvvm construction errors of pages were in a few levels of inner exceptions, so if your xaml had a little error you had to dig into the inner exceptions. It was not an issue for experienced users of FreshMvvm but for people new to the Framework it was a bit hard to figure out the actual issue. Now exceptions will be bubbled up developers won’t need to look into inner exceptions.

Ability to remove a page from Navigation

In some cases you might want to remove a page from the Navigation stack. This works in the case you’ve Pushed a few pages but want to remove one of the pages from the stack before you return,  for example you’ve pushed to Page1 -> Page2 -> Page3, but you essentially you don’t want Page2 to be part of the stack anymore. In this case you can call the remove method.

Add ability to SwitchSelectedRoot page in Tabs and MasterDetail

This is another special finite feature of FreshMvvm, in which you can switch the currently selected page of the main tabbed page or the master detail page.

 

Release 2.1.0

Adds ability to control PageModel mapping via PageModelMapper

You now have the ability to control the convention of mapping ViewModel to pages. You do this by using the IFreshPageModelMapper.

Currently the PageModel mapper is defaulted to  the FreshPageModelMapper.

The current behaviour is to map PageModel or ViewModel to Page.

It’s easy to implement your own custom mapper and then set the PageModelMapper.

Adds ability to navigate without animation

You can now push and pop PageModel without animations.

Better cleanup of objects

We clean up after ourselves, even better now. :)

IOC now has unregister feature

You can now unregister a class out of the IOC container.

Add First Only Tabbed Navigation Container

FreshMvvm has always had a built in tabbed navigation container, the behaviour of this navigation is to keep the tabs always present but this is not what you always want. In some case you want the tabs to disappear when you push to a page, so we created the FreshFONavigationContainer. The FO stands for First Only and it means this tab page will only appear on the first page of the app.

FreshMvvm in Production

It makes us happy to see that so many others are also delivering great apps using FreshMvvm. I was recently informed that the Fraedom Expense app was built with FreshMvvm. Great work.

As always the latest version of FreshMvvm is up in nuget right now.

Thanks

 

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.

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

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

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.

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

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

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

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.

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

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

InverseBooleanConverter

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

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.

TappedGestureAttached

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

 

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

 

SlideOverKit is now free and open source

I would like to announce that SlideOverKit for Xamarin.Forms is now Free and Open Source.

It’s been two months since SlideOverKit was released and the ‘business plan’ was to have the component as premium component for Xamarin.Forms. A component that we would invest in developing, people would purchase and we would continue developing. Since this release something was bugging me, I was frustrated because not enough people were buying and using the component. We had put alot of effort in building this component and we wanted people to use it.

One of my most enjoyable projects in recent years has been the successful FreshMvvm for Xamarin.Forms, it’s amazing to see people use (and love) something that you’ve built. It’s really good to now be a Contributor to open source not just a consumer, in the past I’ve help fix bugs in jquery mobile but nothing as serious FreshMvvm.

There’s been so many open source projects that I’ve loved developing with like JSON.net, jquery, UserDialogs, MvvmCross etc, etc. I hope that one day people will use and love SlideOverKit also.

So please feel free to consume and contribute.

Links:
https://github.com/XAM-Consulting/SlideOverKit
http://www.xam-consulting.com/slideoverkit-xamarin-forms/
https://www.nuget.org/packages/SlideOverKit/

….. Fingers crossed Xamarin and Xamarin.Forms are also to follow on the open source path ….

Thanks

Michael

 

Announcing FreshMvvm 1.0.1 Release

No bugs to fix, Yay!

Only some awesome new features, actually really nice extended and very useful features. With such a big take up of FreshMvvm we’ve ramped up the development. As always we take feedback and iterate on it so let us know of anything.

WhenAny

I’ve always loved the WhenAny feature in ReactiveUI and just wanted to have it. Not to mention it’s strongly typed which makes it so much better.

So now your ViewModels (or anything with INotifyPropertyChanged) you can subscribe to the changes of a property using the WhenAny features.

Here’s how you can use it:

Pushing different views

Another awesome feature that we’ve been loving is the ability to push with a different view. This means you can have multiple views for a single ViewModel.

Here’s the signature:

So it’s as easy as:

Clean up after page is Popped

FreshBasePageModel now has a PageWasPopped event, this can be used to cleanup after a page has been Popped.

We’ve linked up all the parts within the FreshMvvm project so that the event is always called and always called once, but this might not always be the case if you use a CustomNavigationService and don’t implement correctly.

This is a breaking change on the IFreshNavigationService as it now has a NotifyChildrenPageWasPopped().

If you have a custom navigation service you will need to implement this, here’s a sample of how the builtin master detail service handles it.

As always I love your feedback, please let me know how it do

Thanks

FreshMvvm 1.0 Released

So it’s official, FreshMvvm is now 1.0 and available in nuget.

Let’s take a look at some of the new features.

  • Ability to use ViewModel naming instead of PageModel, thanks to this contribution by Olexandr Leuschenko
  • Multiple Navigation Services
  • Support for custom IOC containers
  • Ability to Push a NavigationContainer
  • It also handles async better thanks to Olexandr Leuschenko

Let’s take a look at some of the bigger features in the release.

Multiple Navigation Services

It’s always been possible to do any type of navigation in FreshMvvm, with custom or advanced scenarios were done by implementing a custom navigation service. Even with this ability people found it a little hard to do advanced navigation scenarios in FreshMvvm. After I reviewed all the support questions that came in for FreshMvvm I found that the basic issue people had was they wanted to be able to use our built in navigation containers multiple times, two primary examples are 1) within a master detail having a navigation stack in a master and another in the detail 2) The ability to push modally with a new navigation container. In order to support both these scenarios I concluded that the FreshMvvm required the ability to have named NavigationServices so that we could support multiple NavigationService’s.

Using multiple navigation containers

Below we’re running two navigation stacks, in a single MasterDetail.

PushModally with new navigation stack

Custom IOC Container

The second major request for FreshMvvm 1.0 was to allow custom IOC containers. In the case that your application already has a container that you want to leverage.

Using a custom IOC container is very simple in that you only need to implement a single interface.

And then set the IOC container in the System.

This release can be found in nuget and the source code on github.

https://www.nuget.org/packages/FreshMvvm/

https://github.com/rid00z/FreshMvvm

Thanks

 

XAML Attached Properties Tricks in Xamarin.Forms

I’m sure you know of behaviours in Xamarin.Forms but have you heard of Attached Properties?

Have you ever wondered how you define properties for a Grid on a Label, eg <Label Grid.Row=”5″, and the Grid just seems to know about it. This is attaching a piece of data onto the Label so that the Grid can reference the data.

Let’s take a look at how it works in the Grids case. In our Xaml we’d normally have something like the code above, so somehow we tell the Grid that we want to be on Row number  5. In order for this to work the Grid needs to have a static ‘attached’ bindable property. Let’s take a look at what the Grid actually has.

So yep the Grid has the attached property for Row, awesome, now how does the Grid get that data?

In order for the Grid to be able to access that data it needs a static method which will extract it as follows.

We can also see that the Grid calls this method to get the data from the child element.

So that’s some pretty cool stuff.

Now for the Trick

Considering this is a bindable property we can actually attach anything to this static property, our own object or even a command. We can also get notifications when the property changes, during that notification we can obtain references to both the Element and the bindable property. This means we can link up custom behaviours without even using behaviours.

Say for instance we wanted to attached a TapGesture for a View to a Command? Normally this is fairly verbose to add in Xaml but setup correctly it can become just a property on the View.

So what’s TappedGestureAttached? Let’s take a look.

Below we have a Static property called CommandProperty, that property name is Command, has a return type of ICommand and a declaring type of View. You can also see it’s linked to  the OnItemTappedChanged command, which means when the property changes that event gets called.

Below we have the OnItemTappedChanged command, as I mentioned before we have access to both the View and the Command hence we can wire up the TapGestureRecognizer.

There we have it wiring up a TapGestureRecognizer in less than a line.

Here’s the full code.

We can also use this to hook up events that are directly on the control without using the code behind of the Xaml. Below we link up the ListView.ItemTapped event to a Command, which will be inside our ViewModel rather than codebehind.