MotzCod.es by James Montemagno

I'm James Montemagno, Principal PM, Mobile Developer Tools at Microsoft Co-host of the Merge Conflict podcast Find Me: Twitter @JamesMontemagno GitHub @JamesMontemagno Facebook @MotzCodes Micro.Blog: Motz.Micro.Blog

[motzcodes-blog]

The Xamarin.Android Template Pack Returns for VS 2017

A few years back I published some awesome Xamarin.Android item and project templates to simplify development with Android’s AppCompat libraries. The item templates have actually found their way into Visual Studio, which is pretty awesome:

What about the project templates? Well I am hoping for this fall to unleash brand new templates for Xamarin.Android directly in the box, but until then I have updated my Visual Studio template pack for Visual Studio 2017 and it now includes:

Blank & Single-View Apps based on AppCompat

Navigation Drawer App

Bottom Navigation App

Tabbed App

This new template pack is available right now in VS 2017 and gives you everything you need to start making beautiful Xamarin.Android applications. You can find the source on GitHub as well!

[motzcodes-blog]

Removing BottomNavigationView’s Icon Shifting  in Xamarin.Android

I recently blogged about Android’s super fancy new BottomNavigationView, and how easy it was to get started with them in your Xamarin.Android application. 

I also went through a lot of color customizations that developers can blend in to really make their BottomNavigationView stand out. While this new bottom navigation is awesome, it is also still brand new with a lot of features locked behind internals and hidden fields, which is very sad. Recently I was asked about how to disable the “ShiftMode” of the icons on the bottom when more than 3 sections were added. I first had to go try it for myself to see what they were talking about and sure enough there it was:

Yup, that is no good at all. I actually remember this from the first version of the Google I/O app and they scrambled to turn it off. Luckily, this is actually programmed into the underlying control but locked up in a hidden property. Do not fear as reflection is here! I wrote small utility class to turn it off:

And here you go!

I have also updated my sample on GitHub with this code in it too!

Note: This is available in Android Support Libraries 25.3.1 and 25.4.0.2! If you have 25.4.0.1 installed please upgrade to 25.4.0.2

[motzcodes-blog]

Easily Clean Bin/Obj Folders

In an earlier blog post I talked about how to clean up space on your Xamarin Developer machine by deleting old installations, NuGet cache, and Android junk sitting around. We can take it one step further and delete all of that clutter that is built up in the bin/obj folders! This can be gigs of data. Here is my GitHub folder:

Inside of each of my repo folders sits code and the bin/obj folders from each build, which can be very large as it contains the full excecutable. What we can do is write a simple powershell script on Windows to recursively delete all of those nasty folders.

Boot up powershell in admin mode and **_navigate to the root of your repos.

THIS IS VERY IMPORTANT: DO NOT RUN THIS COMMAND IN A SYSTEM FOLDER OR TERRIBLE THINGS WILL HAPPEN.

I am serious about this, make sure you do this in a sub folder. Mine is C:\GitHub.

Then run this command:

Get-ChildItem .\ -include bin,obj -Recurse | foreach ($_) { remove-item $_.fullname -Force -Recurse }

Now we can check that folder size again:

Amazing! Removed 10GB of build up! Amazing! Looking to do it on macOS? Check this guide from Joe Sauve.

[motzcodes-blog]

Motz’s Thoughts: Aztez - Buy This Game

Let’s hop into the way back when machine, to a time when I created video games for a living. It was at a small studio where we worked on a small Xbox 360 game called Shred Nebula. There I would find my love for C# and desktop tool development, and where I worked with some amazing people that became some of my best friends. One of those individuals is my good friend Ben Ruiz, who today along with Mathew Wegner at Team Colorblind have released Aztez: A Game of Conquest and Brutality, which is available right now on Steam for PC/Mac/Linux.

I have known Ben and Mathew for ages now and when they first showed me Aztez it blew my mind. Not to mention they are stunning looking individuals:

It is a stunning game visually with epic fighting mechanics. In Aztez, you are responsible for expanding and maintaining the Aztec empire with turn based gameplay, and managing the chaos of the people with real-time beat 'em up segments. The goal of the game is to survive long enough to confront, and defeat, the Spanish. I have been a long part of the alpha and beta process and I fall in love more and more with the game and continue to come back and play through the campaign. 

What I love is that the game gets me. I love shorter action packed games and Aztez enables me to start and stop a campaign at any time, play throughs aren’t too short and aren’t too long, and are always unique and different each time. The fighting mechanics are on POINT, I know Ben and he wouldn’t have it any other way as he spent every waking and sleeping minute ensuring that this game is spot on from a parry to changing out weapons. I continue to master the fighting mechanics weeks and months after the first time I played it.

If you love beatem-ups, love fighting games, or turn based board games, or just want to support an amazing set of indie game developers who built something spectacular then go put down your $20 and buy Aztez right now! Need more convincing check out the trailer video:

[motzcodes-blog]

Dynamically Changing Xamarin.Forms Tab Icons When Selected

Spicing up your Xamarin.Forms tab can easily be done in a few ways. You can add tint color in Android when the user deselects a tab, which can also be done in iOS in addition to a full swap of a selected image. It was recently pointed out to me that these blogs highlighted a way of adding back a bit of nativeness, but didn't answer a different question of how to actually completely change the icon itself when a tab is selected. This question caught me off guard as I have never really changed the actual icon, but sure why not I said! My blog post on iOS actually gives you a way to do this if you label things correct, but that seems a bit maintainable and not cross-platform. So, today lets change those tab icons!

For this blog we are going to start with a blank Xamarin.Forms application for iOS and Android. Then we will add in a new TabbedPage that contains two tabs inside of it that will change icons when selected or unselected. We will be using some MVVM and Data Binding and we will be using my MVVM Helpers Library, so make sure you go install that from NuGet.

Get Some Icons

For this sample we will have two tabs and when we select either of them it will change to a specific icon and back to the original when deselected. So, go ahead and grab some icons from Glyphish for iOS and Android Asset Studio for Android. Make sure that the names are exactly the same and that you add them to the iOS/Android specific projects.

I have imported the following names into Android/iOS:

tab_target.png

tab_chat.png

tab_graph.png

IIconChange Interface

Before we setup any Views or ViewModels we want to create a simple interface that any of our ViewModels can implement that will tell us if the Page that the ViewModel is bound to is selected and what the current icon should be:

public interface IIconChange { bool IsSelected { get; set; } string CurrentIcon { get; } }

ViewModels

This small app that we will make will have two tabs, so let's create two ViewModels and implement the new IIconChange interface. The key is that when ever we change IsSelected we will raise a change notification for CurrentIcon, which we will return a string to the Icon we wanted for the current state.

Tab1ViewModel.cs

public class Tab1ViewModel : BaseViewModel, IIconChange { public Tab1ViewModel() { Title = "Tab1"; } bool isSelected; public bool IsSelected { get => isSelected; set { if (SetProperty(ref isSelected, value)) OnPropertyChanged(nameof(CurrentIcon)); } } public string CurrentIcon { get => IsSelected ? "tab_target.png" : "tab_chat.png"; } }

Tab2ViewModel.cs

public class Tab2ViewModel : BaseViewModel, IIconChange { public Tab2ViewModel() { Title = "Tab2"; } bool isSelected; public bool IsSelected { get => isSelected; set { if (SetProperty(ref isSelected, value)) OnPropertyChanged(nameof(CurrentIcon)); } } public string CurrentIcon { get => IsSelected ? "tab_target.png" : "tab_graph.png"; } }

BaseViewModel comes from that MVVM Helpers NuGet that I mentioned earlier and includes a lot of bindable properties such as Title.

Creating The Tabs

Before we create the TabbedPage let's create some pages for our ViewModels that we just created. I created two ContentPage XAML pages and simply data bound the Title and Icon property on the page. I named my pages TabIconsPage and TabIconsPage2.

XAML Example:

<?xml version="1.0" encoding="utf-8"?> <ContentPage xmlns="http://xamarin.com/schemas/2014/forms" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:local="clr-namespace:TabIcons" x:Class="TabIcons.TabIconsPage" Title="{Binding Title}" Icon="{Binding CurrentIcon}"> </ContentPage>

Setting Up MyTabs

Here we go! Finally time to setup and create the Tabs and set our Binding Context. The key here is that we will register for changes to the current page with CurrentPageChanged and then update the IsSelected property and trigger an event that anyone could loop into (more on that later).

public class MyTabs : TabbedPage { //always save a reference to the current page Page currentPage; public MyTabs() { //create the pages and set the view models //you could also do this in the page code behind Children.Add(new TabIconsPage { BindingContext = new Tab1ViewModel { IsSelected = true } }); Children.Add(new TabIconsPage2 { BindingContext = new Tab2ViewModel() }); currentPage = Children[0]; //Register for page changes this.CurrentPageChanged += Handle_CurrentPageChanged; } //Update the IsSelected state and trigger an Event that anyone can loop into. public event EventHandler UpdateIcons; void Handle_CurrentPageChanged(object sender, EventArgs e) { var currentBinding = currentPage.BindingContext as IIconChange; if (currentBinding != null) currentBinding.IsSelected = false; currentPage = CurrentPage; currentBinding = currentPage.BindingContext as IIconChange; if (currentBinding != null) currentBinding.IsSelected = true; UpdateIcons?.Invoke(this, EventArgs.Empty); } }

iOS is DONE!

Yup, that is right, iOS is totally done at this point. Xamarin.Forms for iOS actually will automatically update the icon for us when we trigger this change, which is really awesome. Android... of course it doesn't :(, browsing through the source code for Xamarin.Forms I found that the only way Android updates the tab icon is when a page is added or removed. So time to dip into Android source code.

Custom Renderer for Android

This code can easily be and should be combined with my previous entry on setting the tint color based on selection of the tab for Android. It is very similar, but this time we will not only save out our current TabLayout, but we will also register for our MyTabs event of UpdateIcons to actually update the icons:

using System; using System.IO; using System.Linq; using Android.Support.Design.Widget; using TabIcons; using TabIcons.Droid; using TabIcons.Interfaces; using Xamarin.Forms; using Xamarin.Forms.Platform.Android; using Xamarin.Forms.Platform.Android.AppCompat; [assembly: ExportRenderer(typeof(MyTabs), typeof(MyTabsRenderer))] namespace TabIcons.Droid { public class MyTabsRenderer : TabbedPageRenderer { TabLayout layout; protected override void OnElementChanged(ElementChangedEventArgs e) { base.OnElementChanged(e); if(Element != null) { ((MyTabs)Element).UpdateIcons += Handle_UpdateIcons; } } protected override void OnElementPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e) { base.OnElementPropertyChanged(sender, e); if (layout == null && e.PropertyName == "Renderer") { layout = (TabLayout)ViewGroup.GetChildAt(1); } } void Handle_UpdateIcons(object sender, EventArgs e) { TabLayout tabs = layout; if (tabs == null) return; for (var i = 0; i < Element.Children.Count; i++) { var child = Element.Children[i].BindingContext as IIconChange; var icon = child.CurrentIcon; if (string.IsNullOrEmpty(icon)) continue; TabLayout.Tab tab = tabs.GetTabAt(i); SetCurrentTabIcon(tab, icon); } } void SetCurrentTabIcon(TabLayout.Tab tab, string icon) { tab.SetIcon(IdFromTitle(icon, ResourceManager.DrawableClass)); } int IdFromTitle(string title, Type type) { string name = Path.GetFileNameWithoutExtension(title); int id = GetId(type, name); return id; } int GetId(Type type, string memberName) { object value = type.GetFields().FirstOrDefault(p => p.Name == memberName)?.GetValue(type) ?? type.GetProperties().FirstOrDefault(p => p.Name == memberName)?.GetValue(type); if (value is int) return (int)value; return 0; } } }

Overall, this code is pretty simple and actually steals some code from the Xamarin.Forms project. Whenever the UpdateIcons event is triggered we will simply loop through all of the tabs and find the matching drawable for the CurrentIcon property.

Grab the Code

Hopefully you have found this helpful in making your tabs extra fancy. You can grab the source code from my new GitHub repository that will contain this and all future code samples from the blog.

[motzcodes-blog]

C# Developers: Stop Calling .Result

I love async/await Task based programming! I talk about it in all my demos, it is in all my libraries, and Frank and I did a whole Merge Conflict podcast episode on it. The problem is that I keep getting bug reports and seeing samples where it is being abused and used completely wrong. I am never a fan of calling a lot of async code in a constructor or in the OnCreate/AppDelegate, but the real issue is when I see stuff like this with .Result:

public App() { try { _locator.StartListeningAsync(TimeSpan.FromSeconds(30), 100); var position = _locator.GetPositionAsync().Result; if (position != null) { App.lat = position.Latitude; App.lon = position.Longitude; } } catch (Exception c) { } MainPage = GetMainPage(); }

AHHHHHH!!! We aren't letting `StartListeningAsync` finish, and we are doing a .Result essentially locking the entire app start code! This makes me the saddest panda in the entire world. Recently Jon Goldberger wrote a great article on getting started with async/await, but going way back 6 years ago, Stephen Toub from Microsoft 6 wrote an amazing article explaining how to use async/await when dealing with the UI and with event handlers. Both article are great reads and yes even the 6 year old blog applies to this day. Stephen's article boils down to this: On your UI thread, instead of writing:

Task s = LoadStringAsync(); textBox1.Text = s.Result; // BAD ON UI

you can write:

Task s = LoadStringAsync(); textBox1.Text = await s; // GOOD ON UI

Or instead of writing:

Task t = DoWork(); t.Wait(); // BAD ON UI

you can write:

Task t = DoWork(); await t; // GOOD ON UI

Essentially calling .Result or .Wait will lock up your UI! It is true! So true that I made an entire video right here explaining why you need to stop using .Result!

[motzcodes-blog]

Xamarin.Forms: Microsoft Advertising SDK in UWP

In the past I have written about how to integrate Google’s Admob ads into Xamarin.Forms iOS apps and Android apps, which is a great way to monetize your applications. What about UWP? Well Google Admob doesn’t exist on UWP, but Microsoft has their own advertising SDK that you can integrate and it of course works with Xamarin.Forms! Here is what you need to know to get started. 

Install the SDK or NuGet

Before we get started, we need to install the official SDK for Microsoft Advertising, which is usually what is recommended. This works with Visual Studio 2015 & 2017 and is a quick install.  However, the better way is simply to install a NuGet into our project. Simply search for Microsoft.Services.Store.SDK. There are guides if you already installed the SDK manually, so read up here. 

Add the SDK Reference 

Once the SDK or the NuGet is installed, we can open up our UWP project and add that reference hidden under Windows Universal -> Extensions. It is officially called Microsoft Advertising SDK for XAML:

If you don’t see this, simply close the solution and re-open it.

Create Xamarin.Forms Control

The control itself is super crazy simple and doesn’t do to much besides be a place holder:

e

We can immediately add it into our XAML:

Create UWP Custom Renderer

The control API is extremely easy to use. I am using the test IDs here for the application and the test banner id, but those can be created later. All we nee dto do is create it and set the width and height and done!

Run it!

Finishing Up & Creating Ad Unit

Now it is time to go and create a real Ad Unit, which you can do in the dev center. Additionally, I would recommend creating different sizes based on your device that you are on, you can read about this in the supported banner ad sizes documentation.

[motzcodes-blog]

Moving Plugins for Xamarin to .NET Standard

I could never imagine the amazing response to Plugins for Xamarin, those amazing little libraries that abstract away all that platform specific code into a lovely cross-platform API for iOS, Android, and Windows. They sure have grown, with hundreds of plugins be generated by the community and with tons of installs. My plugins alone have now hit 3 Million installations! With all this momentum it is a great time to look to the future, simplify plugins, and take the leap to .NET Standard.

What is .NET Standard?

Great question! Essentially think of .NET Standard as the defacto way of sharing code across all .NET Platforms including Xamarin, .NET Framework, .NET Core, and others. Essentially all of these .NET Platforms implement a standard set of APIs so you as a developer can just create a library and share it everywhere. They are the evolution, improvement, and replacement for Portable Class Libraries, and I could not be more excited about it.

I highly recommend you checkout our podcast episode of Merge Conflict, which you should totally listen to:

Merge Conflict 38: One Library to Rule Them All

The Big Move & More Platforms

There are actually two large changes that I have done to my plugins. First, each and every plugin's "Abstractions" and Core for bait and switch have moved to .NET Standard 1.0. This means that you can easily add them into any .NET Standard library and are 100% backwards compatible with your PCL libraries! The other switch was more on the development side of the plugins, which I have moved fully to Visual Studio 2017 and C# 7. This means that all new version of my plugins will no longer support Windows Phone 8 Silverlight, Phone 8.1 RT, or Windows Store RT (8.1). I additionally will no longer be accepting any new issues or fixing any bugs for those operating system in any of my plugins. I don't have the environment to maintain them so I can't support them.

What Will you support?

With the loss of these platforms comes the rise of other platforms being added into several of my plugins. All plugins today already support iOS, Android, and UWP, and I have done my best to add in macOS, tvOS, and watchOS support to plugins where they make sense, such as Settings, Connectivity, and Text to Speech.

The Brand New IsSupported Boolean!

Previously, when you installed a plugin on a platform that wasn't supported (or you forgot to install the NuGet in the core project) and you tried to call the method it would simply thrown an exception. This is still the case, but I tried to figure out a better way for developers to check to see if an implementation exists before making calls.

You can simply now call CrossPluginName.IsSupported to check if it exists. For instance:

There you have it, super simple way of checking!

Updated Android Support Libraries

In this big move I also took a big risk on decided to make the break away from defaulting to version 23.3.0 of the Android Support Libraries in a few of my plugins. These libraries are now almost 3 years old and it is simply time to update them to the latest and greatest 25.3.1. Since you can update them now in Xamarin.Forms applications it is time! I even show you how to do it in this small Snack Pack episode of The Xamarin Show

It should be known that I don't use Support libraries unless I absolutely have to, but if you are using Permissions, Media, Share, or Geolocator then you are going to have to update. Here is what you need to know:

Before you install or update your NuGets, ensure you have Android SDK for API 25 installed. You can watch my video on The Xamarin Show or simply click Tools->Android SDK Manager, deselect everything, and then select Android SDK 25, that is all you will need. Next, you need to go into your Android project settings and under General/Build make sure you select Android 7.0 and then go into your Manifest and set the Target to 25 too!

If you don't do this you will see an error when trying to install the Android NuGet that you aren't targeting the correct version of Android. That is what this error means. Go update!

Can I Haz NuGets?

As of the time of writing this article each and every Plugin for Xamarin that I have created now has a pre-release version available that introduces these changes. Over the next two weeks I will be transitioning all of them to the stable branch after a bit more testing and feedback from you!

[motzcodes-blog]

Why Xamarin.Forms Embedding Matters

Last week I wrote about Xamarin.Forms Embedding, a great new feature of Xamarin.Forms, that enables developers to convert a Xamarin.Forms ContentPage to an iOS UIViewController, Android Fragment, and a UWP Page. I walked through the current setup and a real world example of adding a Xamamarin.Forms details pages to my Xamarin Native application which previously only had native Storyboards and Android XML pages. When I originally got this setup and working I was blown away by this feature and it is something that I have wanted for so long out of Xamarin.Forms, but some people seemed to be confused by the feature and why it matters or what it actually does.

Sharing Code with Xamarin

Traditionally with Xamarin applications (before Xamarin.Forms) we would build out our native user interfaces with Storyboards, XML, and XAML for each platform “head” that we wanted to develop for. The key though is that with Xamarin you have access to 100% of APIs all from C# and all of your code behind for those native views are all in C# with awesome C# features. Everything compiles down into lovely native apps that look and feel native… you guessed it because they are native. This is unlike other cross-platform frameworks that are just abstractions or some sort of webview… Xamarin apps are 100% native.

What comes next is the magic that with Xamarin you have a full .NET runtime that runs native on each platform enabling anyone to share a vast majority of the apps business logic between all of their apps and even their existing desktop and websites. This logic usually is all of the models, view models, and service logic that is just pure .NET code that is now cross-platform to nearly any platform. On average I share about 70% of code across all of my applications that I build with Xamarin and I am in super productive tools like Visual Studio and of course using the best programming language, C#.

What about the User Interface?

The one thing that isn’t shared though is the user interface. This was a hard problem because you don’t want to lose the native part of Xamarin which makes it so unique. Other cross-platform UI frameworks just fake it and lack great performance and don’t really display the native UIs and are very messy. This is why Xamarin.Forms was designed different. Abstract what is common into a XAML schema with a full MVVM & data binding framework built in. If you don’t know about MVVM & Databinding and why it matters listen to our latest Merge Conflict:

The difference with Xamarin.Forms is that everything that actually gets displayed are native controls for each platform. It is just this thin layer on top with a bunch of great features including Messaging Services, Dependency Services, and full navigation.

So I Should Just Use Xamarin.Forms?

Xamarin.Forms is spectacular and I have been quoted many times that 80% of all applications could be build with Xamarin.Forms especially seeing a bulk of all applications are built for the enterprise scenarios. This is where Xamarin.Forms shines and was NEVER sold as the silver bullet that everyone thought it was. If you have heard me present I have always said that my first love will always be Xamarin Native and when I am building an app that needs sub-2 second startup, access tons of native libraries and controls such as material design, and want full control then I would always recommend Xamarin Native as you are still sharing 60-70%+ of code!

Until now developers could only pick one or the other. You had to pick Xamarin Native or Xamarin.Forms and trying to blend the worlds wasn’t the easiest to do and transitioning from a POC (proof of concept) and throw away the Xamarin.Forms user interface seemed like a waste. Or maybe you already had a Xamarin Native app and just want to share more code without having to re-write your whole app. This is where Xamarin.Forms Embedding comes in.

Xamarin.Forms Embedding Is AWESOME

Xamarin.Forms Embedding enables Xamarin Native developers to leverage Xamarin.Forms including a bunch of its great features (including data binding) to create shared user interface pages for their applications in Xamarin.Forms and embed them in their Xamarin Native apps. That is correct, you can now start replacing all of those simple screen (about, settings, details) that you had to write three times with a SINGLE XAML/Xamarin.Forms based page that is shared across all of your applications.

This is truly game changing when it comes to choosing Xamarin and Xamarin.Forms as your mobile app development platform. You can benefit all of your performance and design of a Xamarin Native application without any overhead at all and embed those shared pages directly into your apps. You can dabble in Xamarin.Forms without the commitment. Need to develop a feature quickly, no problem because embedding will save you TONS of time. The code is so simplistic that it can now take that 60-70% up to 80-90%+ when developing a Xamarin Native app, which is simply awesome.

Embedding Everything Everywhere

To me this is really only the first step to where Embedding will go. At Build 2017 I got to help announced the Embeddinator-4000 project which enables developers to compile and embed a .NET or Xamarin.IOS/Android/Mac library into native language library (Objective-C/Swift/Java/C++). This means that non-Xamarin developers can now create that shared code layer for their applications without having to take the leap and re-writing their full application as this usually is not an option. Now, let’s look into the future when Embeddinator is complete and Xamarin.Forms Embedding has hit stable where a mobile app developer writing an Objective-C iOS and Java Android app could adopt Xamarin into their native application and share not only business logic, but also create shareable NATIVE user interface with Xamarin.Forms Embedding. This is the story I want to tell, this is unbelievably amazing, and I can’t wait for this embedding future!

These reasons are why Xamarin.Forms embedding matters, why you should care, and why you should give it a try today. If you still don’t believe me after reading this then watch it in action:

[motzcodes-blog]

Motz's Thoughts: E3 2017 Recap (Microsoft, Sony, & Nintendo)

I have always been a video game nerd, so much that I went to school to go and create games for a living. I worked at a studio, helped develop a game called Shred Nebula for Xbox 360, and then left the industry forever. While I may not be creating games anymore, my passion is not gone and there is a time each year that I geek out on each year. It is that time of the year when all the big game publishers and console creators go BIG and announce everything, and that event is E3 and that time of year was this week. E3 is a multi-day event based out of Los Angeles that has been going for a long time and has gone through multiple iterations. I went to E3 many moons ago when the Wii was first playable, and it was awesome. Since E3 has always been more of a press event I now tend to go to PAX since it is local here in Seattle. While I may not attend anymore, I still have a tradition of live tweeting the big 3 (Microsoft, Sony, and Nintendo) press conference with one of my best friend in the world Michael Rivette. This year is no different and it was a very interesting year as a few press conferences started on the weekend, which was strange, but we locked in and started live tweeting. I have never blogged really about my feelings and findings of E3, but I am on a plane to Oslo currently (for NDC Oslo, not to stalk Magnus (listen to my podcast, Coffeehouse Blunder, for more on that)) and thought why not.

Microsoft aka XBoneX

 Be aware that while I do work at Microsoft all my thoughts and writings are my own and I had no idea what we were announcing this year (or any year as I don't work in this division). Before I get into the details of what was announced I must say this was the weirdest stage I have ever seen. There were cubes, neon lights, boxes people stood on, I was puzzled the entire time on this. Anyways, back to the good stuff. 

Microsoft had teased the Scorpio, the next generation of the Xbox One, for some time now. It was going to be the most powerful system ever created and super optimized for 4K games and movies. Finally, the ~12 Teraflop machine was fully revealed at the very start and that was great to see. This machine is a beast and someone the smallest most compact ever Xbox ever created. This is great because I own the Xbox One S, and I love the slim size of it in my entertainment credenza. The Scorpio is actually the processor, and the name of the system is the Xbox One X... which is a very strange name to pick seeing there is a Xbox One and an Xbox One S already... what is next after this the Xbox One XS? This is so confusing if you are a parent walking into the store this fall. Did they not learn from Nintendo and the WiiU or even the 2DS? Name aside it is a nice package and is releasing this fall for $500 (which is pricey in the terms of consoles seeing the S is $250 and the PS4 Pro is $400 and the Switch is $300). I think the price is justifiable, but for me I don't have a 4K TV just yet and probably will wait. If you do though then a bunch of games will be auto enhanced and some super enhanced for new launches. The best part though is that all games work everywhere, which will be very nice. 

Talking about backwards compatibility the Xbox One is the only console truly to offer this and they went one step further to now support the Xbox Original?!?! This is crazy and amazing, and I will probably not use it at all, but still nice. I am not sure if anyone will really use backwards compat seeing current research says it accounts for 1.5% of total usage on the Xbox One, but it is a huge selling point and win. 

After the new console, it was on to the games and of course it was all about Forza and for some reason they spent like 10 minute on being way too excited that they are announcing a car on stage at a video game event. This was the worst for me and others I talked to as no one really cared but maybe if you were a car fan you did so who knows... again puzzled. The rest of things were a mix of trailers back to back and a little bit of narration here. There were some nice surprises thrown in there such as the unification of Minecraft which is a huge win now that you can run realms from your console. Everything else was focused on exclusives for the system including: The Last Night, Battlegrounds, State of Decay 2, and others including a nice Indie montage. 

Overall I was impressed and give Microsoft a solid B+ score here. I will bump it up maybe even to an A- as the next day they announced a remastered Age of Empires at the Intel event which was amazing! 

Sony... Wait what just happened, it is over? 

This had to be the strangest live stream and press conference event I have ever witnessed. Sony technically called it a game experience, but it was soooooo strange. Of the 75ish minutes in a beautiful theater packed full of people we only saw 1 person for just 5 minutes’ total. The rest of it was just a super crazy long trailer real that hopped between PS4 games and PSVR games (there were a lot including Final Fantasy Finishing).

They had some absolute great games to announce including a new God of War (stole the show), Uncharted, Shadows of the Colossus, and Monster Hunter to name a few. This was basically it though as Sony really focused on quantity of games overall and I'm not sure if it worked as to me the overall montage of games was a bit forgettable. At the very end there was a one more thing moment as Sony revealed a brand new Spider-man video game, which looked really great to be honest with you. Then it ended... no hardware news, no handheld news, not a single Vita game, no thanks, just over. It even surprised the audience as people were puzzled and not sure if they were supposed to leave or what. The Twitch announcer wasn't even ready to go back on the air and stood around trying to scramble to say something. 

All in all there were some cool games, but it felt all very unnecessary. I want to hear the vision of the products and where things are heading over the next year. This is a huge opportunity, and I think Sony stumbled here. They did appease with some good games, but to me this wasn't really a press conference at all, it was more of a Nintendo Direct style that they could have just streamed to set expectations. Overall I must give Sony a C+.

Nintendo: Switch Overload

If you know me then you know that I am a Nintendo fanboy. I just am and can't help myself (a Switch is packed and ready for me to play on this plane as soon as I finish writing this up), but last year and the year before I was a little let down by Nintendo's E3 showcase (Michael nailed why... they didn't have much to show). Nintendo does things different then everyone else as they focus on a pre-recorded Nintendo Direct that lasts around 30 minutes and then is followed by Treehouse live stream showcasing gameplay of all the games. I really like this format, and this year was no different as Nintendo COMPLETELY CRUSHED IT! 

There was a great sizzle real to start off the direct and it was clear that this was going to be Switch focused, and in fact it was solely Switch. Reggie came out and gave some vision to start and finish and other game developers and designers gave some solid flow throughout which I appreciate (something Sony did not do) and the 30 minutes were packed full of game announcements, game updates, and the most amazing 30 seconds of a logo that stole the whole show. Let's start at the beginning which focused more on adventure and RPGs with Xenoblade Chronicles 2 and its epic scale. I am not a huge Xeno fan, but glad Nintendo has it. Then it was a rush of big Nintendo properties being announced including a new Yoshi and Kirby game, which was cool. 

It was great to see some updates on the Zelda DLC that I am really excited about now and is making me rush to finish the game. There was some third-party love with Rocket League being announced and showcased with cross-play support, which was cool. Then there was the stand out moment where super iconic music played and a number 4 stood there and slowly Metroid Prime 4 was revealed. THAT WAS CRAZY and AMAZING. I think just because no one thought Nintendo was going to do it as we haven't seen a Metroid in so long. 

If that wasn't enough they even announced that a real Pokémon game coming to the Switch. While many titles are off in the future, there was some real focus on this year including Mario+Rabbids in August(which I pre-ordered immediately), a new Fire Emblem Warriors, and Mario Odyssey (which had an awesome trailer at the end) at the end of the year, and so much more. I was really blown away by the goodness announced here.

While the main keynote ended there was still questions about 3DS and what is next for it, the eShop on the Switch, and just what is going on with voice chat? I usually don't stick around for the Treehouse live stream, but I said why not seeing they were going to show off Mario. I watched the stream in the background and was so happy I did because there was even more HUGE news for Nintendo fans including Reggie announcing a brand-new Metroid game for the 3DS followed by 30 minutes of gameplay with the developers! IT WAS BANANAS! It wasn't over though as we got deep dives on Rabbids, Arms, and one more 3DS reveal with a remake of one of my favorite's Mario & Luigi Super Star Saga.

What can I say I left the "day" of Nintendo really impressed and wanting to tune in more as E3 continued. Nintendo seems to have learned a lot over the last year and really had tons to show off in a nice compact way. Blown away overall with Nintendo this year and they deserve a solid A!

So Much More

This is just the big three that I covered in this blog, but there was some other great press conference such as Ubi, and a few not so good ones such as Bethesda. This year’s E3 really has me jazzed up and excited for the year of video games ahead.

[motzcodes-blog]

Embedding Xamarin.Forms into a Xamarin Native App #TheFuture

You know I love Xamarin.Forms, but I also absolutely love Xamarin Native with iOS Storyboards, Android XML, and all of that UWP goodness. When you want to build an app that opens in sub-2 seconds, super optimized, and takes advantage of every custom control and animation out there (especially with material design) you have to go Xamarin Native. That is why the next evolution and favorite new feature, Xamarin.Forms embedding, of Xamarin.Forms enables you to embed any Xamarin.Forms ContentPage into a Xamarin Native app or into a UWP applicaiton. You can read the full post here on getting started, but I wanted to write up a blog about my experience. Here is a cool gif of how it would work:

Here is the setup: I have my Image Search/Cognitive Service app, which I demo heavily, that is a cool single screen Xamarin Native app. I wanted to easily add a details page to it, but I didn’t want to create the screen multiple times. Ideally I could just build out a Xamarin.Forms Content Page and embed it in there. 

Here is my Native screens with RecyclerViews/CollectionViews and some nice material design on Android:

So let’s see how that works and how to get started.

Setup

The first thing is that I needed to add in the Xamarin.Forms 3.0 pre-release Nugets into my Android/iOS apps. If you had a netstandard/pcl you would also need to install it in there. 

You will need to add a new source to your NuGet Manager: https://www.myget.org/F/xamarinforms-dev/api/v3/index.json

Then go in and find the -embeddingpreview with the pre-release check box enabled.

Awesome! Time to go.

What can we use?

It is important to know that with Xamarin.Forms embedding you can use all sorts of Xamarin.Forms stuff:

Embed any ContentPage

DataBinding/Commanding

DependencyService

MessagingCenter

What isn’t supported yet officially 

Other types of pages

AppResource stuff

Navigation (you need to use your own apps navigation)

Probably other stuff

Create the ContentPage

This app was already using MVVM, which is nice so all I needed to do was to create a “SelectedImage” property on my ViewModel that I would then bind in the shared ContentPage. This is going to use standard Xamarin.Forms goodness with DataBinding and all that jazz. I even added some click handlers just to note that this all totally works.

e

Nothing out of the ordinary to be honest.

Android Setup & Embedding

What I love about Xamarin.Forms Embedding is that you can turn any ContentPage into a Fragment on Android, which is crazy and awesome! This means that you can easily embed it into the app. This app doesn’t use any fragments yet and is a single Activity, so what we need to do is create a new Android XML file with a fragment we can swap out and a new Activity. Check it out, so simple:

Notice that I am even adding my standard toolbar on the activity and could put anything else in there. If I already had a fragment I could easily just swap it out. One thing to notice is that Xamarin.Forms Embedding is just returning a standard Fragment, not a support v4 Fragment. I talked with David, Xamarin.Forms PM, and they said they are looking into this, but seems alright to me so far.

iOS Setup & Embedding

If only everything was as easy as iOS! Such a lovely API! I already had a UINavigationController so all I had to do was make one call to create a viewcontroller and push it onto the stack! Boom! SOOOOO SIMPLE!

Nothing else to do, and now we have a great details page in action:

That is AMAZING! Now to carry it on you could expose events on the ContentPage to loop back into your main application so you could continue on in the navigation part of your app, but everything works as expected.

I am in love with this feature and will be showcasing it a bunch during sessions and when it comes to stable hopefully soon! You can grab the code for this app on my GitHub.

What about UWP?

Well of course it works with UWP, but my app doesn't have a UWP head at all, else I could just call an extension and turn it into a Page in UWP, which is pretty awesome!

[motzcodes-blog]

My Favorite C# 7 Feature: More expression-bodied members

I can't help myself, I love Expression-Bodied Members from C# 6! Combined with other powerful C# features it took this code:

public void OnPropertyChanged(string name) { var changed = PropertyChanged; if(changed == null) return; changed(this, new PropertyChangedEventArgs(name)); }

to this:

public void OnPropertyChanged(string name)=> PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));

This is amazing! However, in C# 7 things get even better. Take our good old friend property setters and getters:

public string Subtitle { get { return subtitle; } set { SetProperty(ref subtitle, value); } }

Look at all of those { and }, well no more! Here is some C# 7 for you:

public string Subtitle { get => subtitle; set => SetProperty(ref subtitle, value); }

You can even do use our lambda friend on constructors and finalizers!!

// Expression-bodied constructor public ExpressionMembersExample(string label) => this.Label = label; // Expression-bodied finalizer ~ExpressionMembersExample() => Console.Error.WriteLine("Finalized!");

Mind Blown!! It is the small things that make me so happy. There are tons more great C# 7 features that you can now access in VS 2017 and VS for Mac and Frank and I discuss all of them on our podcast Merge Conflict that I hope you subscribe to! Merge Conflict 47: You Got Some F# in My C#

[motzcodes-blog]

Getting Started with the Xamarin Live Player

Yesterday, we announced the Xamarin Live Player for both iOS and Android which include the Live Player Extensions for both Visual Studio 2017 and Visual Studio for Mac enabling you to get started with mobile development with just a device! The Live Player apps let you debug your apps and make live edits and see them reflected live on your device. Your code runs inside of the Live Player app, so no emulator or needed and everything happens over WiFi, so you don’t even need to plug anything in.

To get a good grasp of how the app works checkout Miguel and me on stage at Build 2017 on the Future of App Development with Xamarin.

Getting started with the Live Players is super simple and we have AMAZING DOCUMENTATION that you should read to get started. However, you know I love video form, so here it is, getting started, step by step, in under 15 minutes!:

Now once you have things running be sure to read through the Limitations and the Troubleshooting guide if you run into any issues and join the discussion on the forums 

Update 1: New Xamarin Live Player for Android Walkthrough video:

Update 2: Want to know how the Live Player was built? Listen to Frank and I on Merge Conflict discuss:

[motzcodes-blog]

Introducing Coffeehouse Blunders, Chess + Tech Podcast

I could not be more excited to announce my latest podcast adventure with my good friend and International Chess Master, Daniel “Danny” Rensch that we call Coffeehouse Blunders.

Join us each week on Coffeehouse Blunders as we discuss the latest in chess, coffee, tech, and anything else happening in our wonderful lives and around the world. Danny's life as an International Chess Master collides with my mobile development and public speaking background for absolutely adorable and astonishing conversation.

Checkout our site for all the latest episodes: blunders.fm

Subscribe today:

Apple Podcasts

Google Play Podcasts

Pocket Casts

Stitcher

Here is Episode 1: The Perfect Coffee Stirrer

[motzcodes-blog]

Important OnPlatform Changes in Xamarin.Forms

Last week I blogged about the important changes to Device.OS in the latest version of Xamarin.Forms. Well, I am back with some other changes from that same exact Pull Request that have to to with OnPlatform in code and XAML that use the new Device.RuntimePlatform.

So, what is OnPlatform? It allows you to set properties on elements or run specific cone based on specific platforms. This is really nifty for tiny tweaks to UI and can be done completely in the XAML, which is awesome. To make way for furture enhancements there have been small tweaks to the XAML and code behind implementations.

First, XAML. Instead of having to support all the crazy inline options for hard coded platforms we can simply use string versions of each platform. Here is a before and after:

Easy peasy to update actually and allows for custom platforms in the future.

How about the favorite Device.OnPlatform method! Well I never really liked this method to be honest with you and apparently it wasn't very flexible long term. So instead of passing in a bunch of Actions into a crazy method the new recommendation is to simply do a switch case over Device.RuntimePlatform! Check it out:

There you have it, quick and simple changes available now in 2.3.4 of Xamarin.Forms.

[motzcodes-blog]

Using Visual Studio Mobile Center with a VSTS Code Repo

So, this is pretty awesome! Today, the Mobile Center team rolled out a huge update to Visual Studio Mobile Center enabling you to build your iOS and Android apps in the cloud from any GitHub, BitBucket, or Visual Studio Team Service code repository! This is great because VSTS offers FREE unlimited private repos for your code with a git backend. Mobile Center offers up build, test, distribute, analytics, and backend services for any mobile app written in any language. It couldn’t be easier to get started, simply click the VSTS button and log in to authenticate and done!

It is so simple to do that I walk you through it in just 4 minutes! Check it out:

[motzcodes-blog]

Device.OS is Obsolete in Xamarin.Forms... What to do?!?!

Of you just updated to Xamarin.Forms 2.3.4 you may have noticed and be freaking out that you have tons of green squiggles that Device.OS and TargetPlatform are obsolete. This was all done in regards to the new changes for OnPlatform.

We can see here that it says to use RuntimePlatform isntead, which is a string... but how do you use it??!?! If you hover over TargetPlatform, and enum, it doesn’t tell you what to replace it with. Don’t be scared as it is an easy fix as Device now includes constant values for each platform. Just replace your TargetPlatform with Device and basically done:

Device now contains:

Device.iOS

Device.Android

Device.WinPhone

Device.Windows

How about TargetIdiom?!?!? Well that is still there and not obsolete lols. I assume eventually there will be a RuntimeIdiom, who knows.