Posted on October 16, 2017
Enable and control iOS 11 Large Titles in Xamarin.Forms
With iOS 11, Apple introduced a bunch of new design elements to its mobile platform. One of them are larger titles, that sit in the Navigation Bar and can be scrolled away when more space is needed. Large Titles can be enabled with a few lines of code in iOS. To use them with Xamarin.Forms, we need to extend the framework on our own, as the new titles are not officially supported yet.
Enable Large Titles
To add support for Large Titles in Xamarin.Forms all we need to do is overriding the existing NavigationRenderer and enable Large Titles application-wide. Simply add this Renderer to your iOS project and they will be shown everywhere.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
[assembly: ExportRenderer(typeof(NavigationPage), typeof(CustomNavigationRenderer))] namespace LargeTitles.Forms.iOS.CustomRenderers { public class CustomNavigationRenderer : NavigationRenderer { protected override void OnElementChanged(VisualElementChangedEventArgs e) { base.OnElementChanged(e); // Enables iOS 11 new Large Titles system-wide if (UIDevice.CurrentDevice.CheckSystemVersion(11, 0)) { // Enable Large Titles NavigationBar.PrefersLargeTitles = true; // Adopt same TextAttributes as for normal titles, beacuse Xamarin.Forms NavigationPage // does not have a dedicated property for this yet UINavigationBar.Appearance.LargeTitleTextAttributes = new UIStringAttributes { ForegroundColor = (Element as NavigationPage)?.BarTextColor.ToUIColor() }; } } } } |
Control when to display Large Titles
Being in control of when to display the new titles or not is a nice feature as they totally do not make sense on every page and this gives us more flexibility on when and where to use them.
Unfortunately, Xamarin.Forms is struggling with the new Large Titles and bottom offsets sometimes, especially when combined with a TabbedPage. So we need a way to switch them off manually for each page.
Extend Content Page
For this, create a new type of ContentPage in your Xamarin.Forms project, that is aware of Large Titles and offers a property to switch them on and off manually.
|
1 2 3 4 5 6 7 8 9 10 11 |
namespace LargeTitles.Forms.Controls { public class ModernContentPage : ContentPage { /// <summary> /// Property for iOS 11 new Large Titles /// </summary> /// <value><c>true</c> if should have large title; otherwise, <c>false</c>.</value> public bool HasLargeTitle { get; set; } } } |
Every page, that should be able to switch off large titles (we enable them by default in the Custom Renderer above), must now be type of our newly created page. This has to be declared in XAML…
|
1 2 3 4 5 6 7 8 9 10 11 |
<controls:ModernContentPage xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:controls="clr-namespace:LargeTitles.Forms.Controls;assembly=LargeTitles.Forms" x:Class="LargeTitles.Forms.Pages.TestPage" Title="Hello World" HasLargeTitle="false"> <!-- ... --> </controls:ModernContentPage> |
… and the code-behind as well.
|
1 |
public partial class TestPage : ModernContentPage |
Add a Custom Renderer
All we need now is a Custom Renderer for the new page, that respects the HasLargeTitle property and sets the in iOS 11 introduced LargeTitleDisplayMode property accordingly. Create a new Custom Renderer in the iOS project and expose it.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
[assembly: ExportRenderer(typeof(ModernContentPage), typeof(ModernContentPageRenderer))] namespace LargeTitles.Forms.iOS.CustomRenderers { public class ModernContentPageRenderer : PageRenderer { public override void ViewWillAppear(bool animated) { base.ViewWillAppear(animated); // Check, if iOS 11 Large Title shall be displayed or not if (UIDevice.CurrentDevice.CheckSystemVersion(11, 0)) { if ((Element as ModernContentPage)?.HasLargeTitle == true) NavigationController.TopViewController.NavigationItem.LargeTitleDisplayMode = UINavigationItemLargeTitleDisplayMode.Always; else NavigationController.TopViewController.NavigationItem.LargeTitleDisplayMode = UINavigationItemLargeTitleDisplayMode.Never; } } } } |
Et voilà! With 12 lines of code, Xamarin.Forms becomes capable of using the new Large Titles and looks nice and modern for Apple’s new version of iOS.
Posted on October 8, 2017
Swipecards: A Tinder-like swipe control for Xamarin.Forms
For a side-project of mine, I created a Xamarin.Forms control, that lets the user wipe away cards in different directions, similar to the popular Tinder app.
The control is still work in progress and will be extended over time, but I decided to publish the current version as it was good enough to go into production for my project. Feel free to use it, contribute and provide feedback! It supports fully customizable ItemTemplates and Data Binding for most properties.
Take a look at the GitHub Repository for further details and a full API-reference. You will also find a sample project to play around with.
If you want to use it in your projects, simply add the NuGet package to your Xamarin.Forms project and add the control in your XAML layout.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
<swipecards:CardStackView xmlns:swipecards="clr-namespace:SwipeCards.Controls;assembly=SwipeCards.Controls" x:Name="CardStackView" ItemsSource="{Binding Cards}" SwipedLeftCommand="{Binding SwipedLeft}"> <swipecards:CardStackView.ItemTemplate> <DataTemplate> <Label Text="{Binding}" VerticalOptions="Center" HorizontalOptions="Center" /> </DataTemplate> </swipecards:CardStackView.ItemTemplate> </swipecards:CardStackView> |
Posted on September 17, 2017
Avoid Simulator, Emulator and Testing statistics in Visual Studio Mobile Center
When tracking usage statistics and crashes with Visual Studio Mobile Center, you usually only want real-world data in there and filter out data that gets generated while developing or testing the app. To avoid sophisticated insights like those in the screenshot below, developers need to define, when Visual Studio Mobile Center should track data and when it should not.
Analytics and crash data usually should not impact those statistics, when an app is
- Running in Debug Mode
- Running on a Simulator or Emulator
- Running in the Xamarin Test Cloud
Before starting the client analytics using the MobileCenter.Start() method, we should scan the environment to decide whether to run this command or not. For this, we implement a method on each platform, that scans if the current app environment is a real-world scenario.
Debug Mode can be checked easily using the #if DEBUG compiler directive. Even when not running on .NET, most other frameworks should have an equivalent for this.
If the app is running in a Simulator or Emulator can be detected by checking the current runtime architecture with Runtime.Arch on iOS or Fingerprint with Build.Fingerprint on Android.
The Xamarin Test Cloud sets specific environment variables on its devices, that can get examined using Environment.GetEnvironmentVariable().
Abstraction
Creating an interface for the small Environment Service helps to unify its implementations and usage within Dependency Injection.
|
1 2 3 4 |
public interface IEnvironmentService { bool IsRunningInRealWorld(); } |
iOS implementation
On Apple’s platforms, an easy architecure check tells us, if the app is running or a simulator or real device.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class EnvironmentService : IEnvironmentService { public bool IsRunningInRealWorld() { #if DEBUG return false; #endif if (Runtime.Arch == Arch.SIMULATOR || Environment.GetEnvironmentVariable("XAMARIN_TEST_CLOUD") != null) return false; return true; } } |
Android implementation
Android does not have the concepts of Simulators and uses full Hardware Emulation instead, which means we have to check the real or emulated devices’ fingerprints. There are multiple Android Emulators out there but looking for "vbox" or "generic" did the trick for me.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class EnvironmentService : IEnvironmentService { public bool IsRunningInRealWorld() { #if DEBUG return false; #endif if (Build.Fingerprint.Contains("vbox") || Build.Fingerprint.Contains("generic") || System.Environment.GetEnvironmentVariable("XAMARIN_TEST_CLOUD") != null) return false; return true; } } |
Add the real-world check before starting to track analytics
Before starting the MobileCenter service now, we can simply fire an EnvironmentService.IsRunningInRealWorld() check and only proceed if it is positive.
|
1 2 3 4 5 6 |
// Only start Visual Studio Mobile Center when running in a real-world scenario var environment = new EnvironmentService(); if (environment.IsRunningInRealWorld()) { MobileCenter.Start("YOUR_SECRET", typeof(Analytics), typeof(Crashes)); } |
When using Xamarin.Forms, just add [assembly: Xamarin.Forms.Dependency(typeof(EnvironmentService))] to the platform implementations and call them using Xamarin.Form’s built-in Dependency Service.
|
1 |
var environment = DependencyService.Get<IEnvironmentService>(); |
This should avoid having sophisticated Development and Testing data in you Visual Studio Mobile Center Analytics and Crashes section. Enjoy the cleaned up dashboards!
Posted on March 27, 2017
Useful Developer Tools #8: Colormind
A while ago, I wrote about the Adobe Color Wheel here, which helps design noobies to create a color scheme for their product using colors that fit together. The challenge with Color Wheel is, that you still need a “feeling” for colors to create a good looking scheme.
Colormind goes one step further and literally generates you a complete color scheme without having the user know anything about colors. It also offers pre-defined schemes for Christmas, Spring and more. When you are struggling with color schemes, colormind.io might be something for you!
Posted on January 10, 2017
Replace your old cronjobs with free Azure Functions within 5 minutes
For some of my older projects, I had some repetitive tasks where a simple job triggers a script to run and load some data from the web. For this, I used good old cronjobs like the ones cronjob.de offers. As this was expensive und quite unsatisfying in terms of flexibility, I decided to move them over to Azure, which just took me five minutes and cost me nothing.
My old cronjobs just did a super simple thing: They called a PHP script every 15 minutes, which was hosted at a hosting provider and did some work for me. So the cronjobs were simple HTTP calls and I had no feedback about results, success or failure. So it was time to move the over to Azure Functions.
Create an Azure Function App
Azure Functions are the Serverless solution that Microsoft offer in their cloud. In a Serverless context, you even go one step further than PaaS does and only provide some code to the cloud that should run, when you want it to. You don’t care about the architecture beneath it and just want your code to run. Perfect for recurring jobs.
To create a new Azure Function, log into the Azure Portal, select Add > Compute > Function App and follow the wizard to create a service for your functions.
Add your first function
Once Azure has finished creating your Function App, you can create your first function in it. The quickstart guides you through the creation of your first one. As we want to create a cronjob equivalent, the Timer scenario looks like the best one for us. As a .NET guy, I choose C# as my language, but you can also pick JavaScript is you like.
As soon as the function got created, we can start coding. To replace my existing cronjobs, I wrote the following lines.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
using System; using System.Net; using System.Net.Http; public static async void Run(TimerInfo myTimer, TraceWriter log) { log.Info($"Job started at: {DateTime.Now}"); using (var httpClient = new HttpClient()) { var result = await httpClient.GetAsync("<cronjob-url>"); if (result.StatusCode == System.Net.HttpStatusCode.OK) log.Info("Job ran successfully"); else log.Error("Job failed. Status Code: " + result.StatusCode); } } |
Define the trigger
Now that the logic is created, we have to define a trigger for the function. At the side menu, we can find several settings. At the Integrate tab, we can define triggers. Because we chose the Timer template earlier, a timer trigger has already been created for us. In the Schedule box, we can define the trigger time formatted as a Cron expression. The predefined 0 */5 * * * * will trigger the function every 5 minutes, so let’s increase it to 15 minutes: 0 */15 * * * *.
Test your function
To test what we created, get back to the Develop tab and open the Logs by clicking at the according button at the top. Now we can Run the function and follow its process in the Logs window. For more details, you can visit the Monitor tab in the menu.
What does it cost?
Nothing. For the moment, at least. As we chose the Consumption Plan as the Hosting plan for our function when creating them, we will be billed on a pay-per-use mode.
The price for execution time is $0.000016/GB-s and $0.20 per Million executions. For us it is still free, as the first 400,000 GB-s or the first 1 Million executions come for free every month. If your function got 1 GB of RAM attached and runs for one second, Microsoft counts this as a GB-s.
Does it scale?
It does and this is one of the coolest things about Azure Functions. Up to a specific (very large) size, these functions scale automatically and provision the best possible compute base automatically to keep them performant. But please keep in mind that the programming model for Azure Functions is stateless and there are VMs running below, that are not visible for you. So state-inconsistency and VM startup time is something you might have to consider.
What’s next?
If you liked the concept of Azure Functions, why don’t you create more? There are many more triggers beside the timer like WebHooks, EventHubs, or Blob Storage changes. Of yourse, you can alos trigger a function manually, with the REST API. You can also define outputs for the results of your functions to use them for processing data.
So give it a try and fall in love with Serverless Computing!
Posted on January 7, 2017
Useful Developer Tools #7: Spotify playlist “Ambience While Coding”
The new year has just started and many of us still have some holiday to spend time on our beloved coding projects. I personally love listening to some music while coding but especially when it comes to concentration, I find songs with lyrics distracting.
Good thing, that Spotify user Emiliy Cheng created a beautiful playlist full of orchestral and movie songs, perfectly for coding: Ambience While Coding (Orchestral, Epic, Movie Scores). If you are in love with code and music, you should check it out!
Interested in more Useful Developer Tools? Take a look at the whole series.
Posted on December 29, 2016
Wallpaper of the month (December 2016): Blurry Corn
New month, new wallpaper. As it is getting really cold outside, I decided to use a summer wallpaper, that is also compatible with 21:9 ulta-wide screens!
You can find all wallpapers of this series inside this OneDrive folder.
Posted on December 10, 2016
Free self-guided Xamarin workshop
Two days ago, I gave a Xamarin workshop at the Microsoft Technical Summit 2016 conference in Darmstadt (Germany). This was a full-day workshop with a Xamarin introduction at the beginning and a guided workshop experience, where the participants learned how to
- Setup a Xamarin development environment
- Create native cross-platform apps with Xamarin
- Share as much business logic as possible between iOS, Android and Windows
- Share layouts with Xamarin.Forms
- Create a clean architecture
- Spin up an Azure Cloud backend and connect the app to it easily
I decided to make this workshop open and available for free, so that anyone can take it as a self-guided tour through the world of Xamarin development. So feel free to use it in whichever form you like. If you get stuck or have questions, don’t hesitate to ask them here in the comments.
Beside, as this is an open-source project, contributions are very welcome! If you know something better, have a good idea, want to correct something or know a better teaching style please feel free to create a pull request. This workshop is getting better with every single contribution!
Have fun with it. You can find the workshop on GitHub.
Posted on November 27, 2016
Move your Xamarin.Forms Toolbar to the bottom on Windows
While iOS and Android typically have their toolbars and menus at the top of the page, on Windows you will find it at the bottom in most cases. Unfortunately, Xamarin.Forms renders all toolbar to the top of the page per default, even on Windows. So if you define a toolbar like this, it will appear at the top of the page, when running the Winows application, which is very uncommon there and might look strange to a Windows user.
|
1 2 3 4 5 6 7 8 9 |
<ContentPage x:Class="FormsToolbarTest.MainPage" xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"> <ContentPage.ToolbarItems> <ToolbarItem Text="Settings" Icon="Gears.png" /> </ContentPage.ToolbarItems> </ContentPage> |
Previously, you had to write a custom renderer, to modify the toolbar. Xamarin.Froms 2.3.3, which has faced its stable release a couple of days ago, introduces Platform-Specifics, that can modify some UI elements for specific platforms. The toolbar is one of them and we can attach a ToolbarPlacement to it with a single line of code.
|
1 2 3 4 5 |
public App() { MainPage = new NavigationPage(new MainPage()); MainPage.On<Xamarin.Forms.PlatformConfiguration.Windows>().SetToolbarPlacement(ToolbarPlacement.Bottom); } |
However, these Platform-Specifics are still very limited, so we have to keep in mind that
- Toolbar Placement can only be set application wide, not per page
- Toolbar Placement can only be set on a
NavigationPage
But it works and it is only one single line, that gives a Xamarin.Forms app on Windows a way more natural look!
