Updated on April 23, 2018
My favorite offline Mobile Games for traveling
I have always been into gaming but decreasingly find the time for it. As I travel for work quite often, airplanes are the only place where I can calm down and really spend some time playing video games. Personally, I am not too much into Jump n’ Runs or Puzzle Games, I want a story to be told.
As most Mobile Games nowadays require Internet Access, I have created a list of my personal favorites to play in airplanes.
1. Thimbleweed Park
Clear number one and my absolute favorite game I played on the road is Ron Gilbert’s Thimbleweed Park. I played it on my iPad on a trip from Munich to Seattle and still was not even half finished after the flight. It tells a sweet little story from multiple characters’ different perspectives, has some nice riddles and a hilarious humor!
If you liked Monkey Island and can laugh about Ron Gilbert’s strange humor, Thimbleweed Part is a must-play for you!
The handling is extremely well optimized for touch displays and it is easy to play with one finger when putting it down on the foldable table which gives you a free hand for beer!
iTunes ($19.99) | Google Play ($9.99) | Nintendo Switch ($19.99)
2. This War Of Mine
The cold grimace of war, playable in the role of survivors and civilians who are looking for shelter and have to live together under extreme conditions and extreme danger. This game is deep, intense and gives you the creeps. Goosebump moments guaranteed. It sounds wrong to say that I enjoyed this game but it was an experience, I don’t want to miss.
iTunes ($14.99) | Google Play ($11.99)
3. INSIDE
You might have played LIMBO already as it is an absolute classic. INSIDE is the next game from Playdead Studios with a similar gameplay but all-new elements. Again, you play a young boy drawn into the center of a dark project that you start to explore more and more after time. You are hunted, you are alone and you will die. Often. Over and over again. But that is part of the game.
You feel being haunted constantly fear while playing INSIDE. If you enjoyed the minimalistic style of LIMBO, you wiill like this game as much as I did.
Interesting, that this game is able to tell its full story without any spoken or printed text. Although you die so often, the motivation never dies to solve these puzzles.
iTunes ($6.99), Free Trial
4. Plague Inc.
Ever wanted to be a virus and extinguish the population of the word? No? Thank god, me neither. But in Plague Inc. you do exactly that. And being a virus is hard, strategic and turns out a lot of fun. Depending on the region where you break out, you have to develop different bacterial resistances, choose between symptoms and when to develop them and need a plan on how to travel around the world. But be careful, once you got detected, research will start to work against you. A clever and fun game that doesn’t need 100% attention all the time and can be played on the side.
iTunes ($0.99) | Google Play ($0.82)
5. Prison Architect
It’s exactly what you think it is after reading the title: Roller Coaster Tycoon for prisons. You are the director of a prison and have to build walls, cells, showers, and yards, and hire the right staff like guards and cleaners. Once the first prisoners arrive you will be faced with the common craziness of running a prison and have to solve all it’s problem while always growing economically.
iTunes ($14.99) | Google Play ($14.99), Free Trial
Updated on March 9, 2018
FlexButton: A super flexible button control for Xamarin.Forms
Although Xamarin.Forms includes a Button control with quite a few ways to customize its layout, I needed a more flexible button for a side project, that required two things the default implementation could not deliver: A round shape and a way to catch when a user presses and releases the button and for how long. So I ended up with creating a new control and contribute it to the community.
What does it do differently?
The FlexButton control I wrote, supports events for different states, color overlays and adjustable shapes and paddings. You can define if you want text, an icon or both in your button, which color they should have in normal- and pressed state, which size, padding or border-radius it should have and more.
For more details, bug reports and feature request, please check out the GitHub Repository. 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 to your XAML layout.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
<flex:FlexButton xmlns:flex="clr-namespace:Flex.Controls;assembly=Flex" WidthRequest="76" HeightRequest="76" CornerRadius="38" HorizontalOptions="Center" Icon="lightbulb.png" ForegroundColor="#ffffff" HighlightForegroundColor="#49516F" BackgroundColor="#6279B8" HighlightBackgroundColor="#8EA4D2" TouchedDown="DemoButton_TouchedDown" TouchedUp="DemoButton_TouchedUp"/> |
Posted on December 23, 2017
Useful Developer Tools #9: Clean and Zip .NET projects from Finder
If you develop .NET projects, particularly in the Xamarin world, you might find yourself cleaning your projects (delete /bin and /obj folders) from time to time by hand. Especially, when you plan to send code to others as a compressed .zip file, you might want to remove those folders beforehand.
The amazing Colby L. Williams created a Finder extension for macOS, that does exactly that for you. Simply right-click a folder and select Services -> Clean to get rid of all /bin and /obj folders of its descendants or Services -> Clean & Compress to do the same and zip it afterwards.
Updated on January 22, 2018
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.
UPDATE: With Xamarin.Forms 2.5, a platform-specific for Large Titles has been added. Read this post for further details.
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> |
Updated on March 9, 2018
Disable Visual Studio App Center when running on a Simulator, Emulator or Test Cloud device
When tracking usage statistics and crashes with Visual Studio App 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 App 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 AppCenter.Start() method, we should scan the current 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.
You might want to check if the app is running on a Test Cloud device to avoid messed up UI Test from the Distribution Dialog and Denmark (where the Test Cloud devices live) as you most popular country in the statistics!
The App Center Test Cloud (formerly known as Xamarin Test Cloud) sets specific environment variables on its devices, that we can examine and use to check if the app is running on a test device.
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public class EnvironmentService : IEnvironmentService { public bool IsRunningInRealWorld() { // Check if running in Debug Mode #if DEBUG return false; #endif // Check if running on a Simulator if (Runtime.Arch == Arch.SIMULATOR) return false; // Check if running in the Test Cloud if (Environment.GetEnvironmentVariable("XAMARIN_TEST_CLOUD") != null) return false; return true; } } |
Android implementation
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
public class EnvironmentService : IEnvironmentService { public bool IsRunningInRealWorld() { #if DEBUG return false; #endif // Check if running on an Emulator if (Build.Fingerprint.Contains("vbox") || Build.Fingerprint.Contains("generic")) return false; // Check if running in the Test Cloud if (System.Environment.GetEnvironmentVariable("XAMARIN_TEST_CLOUD") != null) return false; return true; } } |
Add the real-world check before starting to track analytics
Before starting the App Center 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 App Center when running in a real-world scenario var environment = new EnvironmentService(); if (environment.IsRunningInRealWorld()) { AppCenter.Start("YOUR_SECRET", typeof(Analytics), typeof(Crashes)); } |
Xamarin.Forms
If you are using Xamarin.Forms, just register the platform implementations at the built-in Dependency Service.
|
1 2 3 4 5 6 7 8 |
[assembly: Xamarin.Forms.Dependency(typeof(EnvironmentService))] namespace Something { public class EnvironmentService : IEnvironmentService { // ... } } |
Now you can call the environment service in the App.xaml.cs like below.
|
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!
Updated on April 9, 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!
Updated 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!
Updated 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.
Updated on January 1, 2017
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.
