Kernel32.net

Faster context switching with Chrome profiles

Fri, 01 Jun 2018 00:00:00 +0000

Faster context switching with Chrome profiles

I have used Chrome profiles for a while. This is really good to seperate and isolate things like credentials between different instances of chrome. And when I mention this for other people, there are a lot that does not know about this gem of a feature.

I currently use 3 profiles, personal, work, and customer.

By using profiles I can now use the same portal for different rols, ex. the Azure Profile. I don’t need to log out and in between sessions. Just open the browser from the right shortcut.

This is all nice, however. One issue happend every time when I open links, ex. from Slack. Those whould be sent to my Default browser (was Edge).

My taskbar currently looks like this:

The shortcuts goes to:

Edge (default)
Personal Profile
Customer Profile
Work Profile

Better browser switching

By using this nice tool called BrowserChooser, I can now choose my browser with the right profile directly when open link.

That is all nice, but it also supports automaticly choosing a profile based on patterns in the link, ex. customer domain etc.

Another nice feature, is that I can automaticly choose the right browser based on patterns in the link, ex. customers domain etc.

Now we are talking. :)

Setup browser switching

First download the applications, this is a portable exe, so I manually put it in ‘C:\Program Files\Browser Chooser’. Then you will need to setup it as your default browser. Open the application, go to the setup (right top link), click on ‘Windows Default’, then ‘Add to Default programs’ and ‘Show Defaults Dialog*‘.

Now you should be able to make BrowserChooser as your default browser.

Since BrowserChooser cannot use the same icons as in the taskbar directly from Chromes folders, you must copy them over to a place where it can find them.

To copy the Profile icons from Chrome, go to ‘%userprofile%\AppData\Local\Google\Chrome\User Data\Profile #’, where ‘#’ is profile number. Copy the ‘Google Profile.ico’ as the ‘.ico' to the 'BrowserChooser Folder'.

Now go to the Shortcuts settings, and clone up chrome to the number of profiles.

Edit them manually like this:

To add URL patterns go to ‘Auto URLs’. With wildcards this can be very powerfull.

Now when you click on a configured link, it should open chrome with the right profile automaticly.

AutoURL Rules

BrowserChooser is a VB.Net application, and uses the string LIKE operator, on version 2.0.4.38373. It also removes “https://”, “http://” and “www.” from the pattern.

Special characters in pattern:

? Any single character
* Zero or more characters
# Any single digit (0–9)
[charlist] Any single character in charlist
[!charlist] Any single character not in charlist

This means:

There is no need to use http, https, or www in the pattern.
”*.” will require start of something else than “www.”.
Pattern “*.test.com*” will hit “http://test.test.com/” but not “http://www.test.com/”
Pattern “*test.com*” will hit both.
Pattern “*test.com*/#user/*” will not hit “http://test.com/#user/function”
Pattern “*test.com*/[#]user/*” will hit “http://test.com/#user/function”
Pattern “*” will hit everything, and must therefor be the last pattern. You can use this for selecting a default browser.

Example rules:

”*test.com/*”
“company.sharepoint.com/*”
“company.visualstudio.com/*”
“confluence.company.com/*”
“localhost:19080/Explorer/”
“jira.company.com/*”
“portal.azure.com/[#]@company.com/*”

So…

Time Saved…Is Time Earned…
Work smarter, not harder…
…
You know… all that. :)

What I hope for the future of Xamarin.Forms

Sun, 27 Nov 2016 00:00:00 +0000

It’s time to redesign Xamrin Forms

First of all, Xamarin.iOS and Xamarin.Android is a piece of art. It’s mature, robust, and a really impressive piece of work. XF is currently in version 2.3 but is still young and buggy, however it has a great potential. I have now worked a while with XF, and I see that it probably should have been made a little different.

Todays biggest problem with XF is the same as most cross platform frameworks: It tries to abstract to much.

The design gives you little control over navigation and layouting, and it feels a lot similar to WebForms. This is really nice for those who just want a simple app fast, and does not care about the platform it’s running on. However, this is not the usecase for most developers. We just want a framework that does things easier for us, but we still have all the control we need. And a possiblity to use just the parts of the framework we need.

If you develop with XF today, you will get a lot for free from the framework. It’s easy to start with, and easy to prototype with. The amount of work needed to get something done, will be something like this:

However if you reach the point where it stops being a benefit, it would probably also be to late to switch to Xamarin Native. This is where XF could be different from all the other frameworks, and give a huge benefit, if designed different.

Open Sourceode

XF is now OpenSource, this is awesome. However, we can easily see that this was not the planned at the design time. There are so many internal logic and utils, that would be nice to work with, that is neither documented or set to public.

Xamarin do take Pull Requests, and there are several commits by the community. However they do reject commits that breaks backward compatibility. This is quite scary, as this is often a bad smell that the project is to tightly coupled together to resolve. This could have been fixed with proper version management, or proper modulization.

However as of today, Xamarin tend to break something at every new version themselves, so having this strict backward compatibility policy does not make much sense.

PlatformA != PlatformB

The architecture of iOS, Android, Windows and Mac is just too different to make one common framework. A button is not just a button, and a label is not just a label. A cross platform framework should not try to hide this, since this is an impossible task. It should however embrace it, and make it easier to work around the differences.

Today there are a lot of thing we as developer cannot change to easy, as there is a lot of magic going on inside XF. The problem I often see, is hardcoded values that is not easy to replace.

Some examples of this is:

Buttons on iOS that is hardcoded as RoundedRect.
Can be fixed with SetNativeControl, however this will skip some other internal setup code.
Buttons on Android.
When adding a border, it uses a custom drawable as background on the button
Page transitions on Android see previous post.
AppCompat can override the transition, but the page will be removed before you can do anything on back navigation.
Modern/Material has hardcoded animations when pushing a page to the stack

My suggestion

When I look at XF, I would have liked to see this more like a service working side-by-side with the native code, with the possible to replace as much of the native code you want to.

Then the developer team to work with, can find the exact sweetspot between abstraction and native, rather than replacing the whole application to the framework.

To do this I would suggest splitting XF into submodules.

The design should look something like this:

XF.Core:
The absolute minimum we need to make tooling, and the components working together. This should be as fast as possible.

This module should be able to be a full stand alone module, with no other dependencies. Therefor it must also include the renderer engine to convert XF Components into native ones.

Also the layout system should probably be here, at least part of it. However, it should be redesigned to give more control to the developer, and then could be abstracted out in an other component.

XF.Components:
A module to include common components like Buttons, Labels, etc.

If most of your code is custom, you would probably want to make your own components in stead. Also you might want to do some funky stuff, like using SkiaSharp based components, this would not be needed.

XF.Features:
Used together with XF.Components to provide extra features like:

Effect
Animations
Gestures

XF.Navigation:
A module for the navigation between pages.

This could also include common MVVM framework features like MessagingCenter, IoC etc. The reason to not have this in the core, it that your favourite MVVM framework, would probably have their own implementation of this. In that case you skip this component all together.

PCL vs Shared libraries

I love PCLs, and I hope for NetStandards support in Xamarin. However, I don’t think PCLs would be the correct place for UI code, as a components like a button should be limited to the platform. Since PCLs don’t know anything about the platform, XF should prefer having the shared UI in shared projects, and the background platform independent code like services in PCL.

If I work with a component, I would prefer to get a 100% working feature, instead of something that is hacked together to look similar as another platform. If the developer however should want this code, this should be another components package.

But I do love Xamarin.Forms

XF is easy to start with, and can do so much for you. The layout system is awesome, however it would need to give more control to the developer.

The community is really helpful, and if you don’t get answers there, you could always ask the iOS or Android community. And it is not hard to port native code to Xamarin Native or XF.

XF is really helpful while prototyping, and work great especially on iOS. However, the Android part of XF needs some polishing. This is not to much of a problem after XF got Custom Renderers and possiblity to add native code directly, and it’s easy to do partial Xamarin.Android or Xamarin.iOS develop where XF is not fast or powerfull enough.

I like XF, and with todays design, I would still use it in most cases, unless I know that the project would need a lot of custom graphics and animations. XF is a impressive piece of work, however with todays it is not for everyone, but with a redesign, I think it would benefit more developers.

The Xamarin platform, is just a piece of art, and I love so much about it. :)

What they have achieved with the tools, and how easy it is to use TestCloud, Azure and other providers. It’s so nice and neat. You don’t need Xamarin to use it, but it sure gives that little extra.

Bluetooth Low Energy Beacons

Wed, 24 Aug 2016 00:00:00 +0000

A Bluetooth Low Energy Beacon is a simple one-way technology that works like a lighthouse. All it does is sending out a bluetooth message with its id, and signal strength (Tx Power). This in an interval typical inside the 100ms - 1000ms range. The faster is often better, but uses more power from the beacon.

It comes in different forms, some that uses batteries (coin, AA etc.), and some that drains its power from a USB or wall socket. Also computers and mobile devices can work as beacons, but then with limitations (adjustment of signal strength, etc.).

There are several standards, some of the most common are:

iBeacon: App. Apple specification. Native iOS.
AltBeacon: App. Open specification. Similar to iBeacon (and compatible), but less strict.
Eddystone: Native Android, comes with four different frames:
- UID: App, frame.
- URL: Physical web (can be used without dedicated app on Android).
- TLM: Extension to give more information like, temperature, battery status, etc.
- EID: Security frame.

Example of a Eddystone-URL on Android:

Regions:
A region is a set of beacons, where you will be inside of that region, if you see one or more of the beacons. Naming is here essential, if you choose a region id that someone else has, your beacons will trigger theirs app, or theirs will trigger yours. There are however more than enough combinations, so just pick a random one and stick with it.

iBeacon / AltBeacon:
Created of a UUID, Major and Major: [FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF], [65535], [65535]
On iBeacon you can scan for the UUID or the UUID + Major.

Eddystone-UID:
Created of a Namespace and Instance: [FFFFFFFFFFFFFFFFFFFF], [FFFFFFFFFFFF]
On Eddystone you can scan for all beacons or divided by namespace.

Modes

Beacons comes in two modes: Ranging and monitoring.

Ranging
Ranging is the one you will use when the application is open and on the screen. You can scan in whatever interval you want, as you have all the applications resources to use. However, be nice. It will consume power.

To calculate the distance, the phone will tell the signal strength it’s receiving on, and this combined with the information of the transmitting strength (tx power), you can calculate the estimated distance (typical done inside of a SDK/library).

However, since every phone is different, it is hard to get this correct. Other factors like echo of the radio waves, walls, or people, might also give a wrong distance.

This will therefor make things like trilateration very hard. So you should probably not try to make your own positioning library.

Monitoring
Monitoring is used as a background service to start a job on the event of entering or exiting a region. This can then be used to push a notification, or similar to the user when going inside, or out of some area.

There are two ways of scanning for regions.
One is using the native format of the device, and have the HW scan for you. This typical triggers the event after a couple of seconds on entering, and half a minute plus some seconds on exit (30s to be sure it’s not just some missing messages).

The other way of scanning is having a job that starts every X minutes. However, this will not be as responsive, and if you have a low message interval on the beacons (ex. 1s), you might miss them. In the case of a low interval, you might actually not trigger the event at all.

There are also restrictions of how many regions a App can listen after (20 on iOS). However, if this is a problem, you probably doing something very wrong.

Use cases

There are several places where you can use beacons to give something extra to the user, or to collect some extra data. However, in most cases, you cannot depend on it to work at all.
This is because:

The user must have your app installed (except Eddystone-URL).
The user must have a modern phone (ex. Android 4.3+).
The user must have bluetooth switched on. And given enough access to the app.

Som typical places to use beacons could be:

Large buildings: Shopping malls, Hospitals, Stadiums.
Smaller buildings: Resturants, home automation.
Public transportation.
IoT.

Some possible usecases:

Many is interested in using beacons or WiFi for indoor navigation.
Advertisement (however be carefull, to much spam, and people will turn bluetooth off).
Proximity based alerts. Example: “you are standing on the wrong bus stop”.
Proximity based searches in searchengines.

However, using other sources like WiFi, GPS, sound, vibration, etc., might be good enough. Just look at applications like MazeMap, Citymapper, Tripadvisor, Foursquare, etc.

Security

Since beacons are a one-way technology, there is often not much to security on them, other than when connecting to change the configuring.

Anyone can buy a beacon and use the same ID as you, so what is often done in this case is to change the IDs in intervals on several minutes. However if the beacons are placed at fixed point, a sensor at another fixed point can very fast know what the new IDs is.
From there you can do stuff like:

Spoof the IDs, and guide person the wrong way.
Spoof the IDs, and spam the user with notifications from the official app.
Use the original beacons in a competitive app.

Getting started

To get started you can start with using a mobile device as a beacon, or buy a developer kit (Kontakt.io, Estimote, RadiusNetworks, GemTot, etc.).

I have both USB and battery beacons that I play with. USB are often better, as you can change the message interval, beacon standard, transmitting power, etc. To develop I like to use the AltBeacon library for Android, as it’s open and based on the standards.

If you want to go a little deeper, you can get something like the nRF52, and start writing some beacon firmware. The nRF52 uses the same chips as many of the better once, like Estimote and Kontakt.io. I also have a Adafruit BLE sniffer that works with wireshark.

Running Jekyll in Docker for Windows

Sun, 21 Aug 2016 00:00:00 +0000

I recently formated my computer to install Windows 10 and lost my jekyll installation. Instead of installing jekyll again, I wanted to test how it is to run it from a docker image. As I am new to docker, I wanted to see if I could do everything from the UI, before learning the commands.

Prerequisites

Have installed Windows 10 Anniversary Update
Have installed Docker for Windows
Have installed Kitematic

The first thing you need to do, is to download the jekyll image: jekyll/jekyll

You can do this directly from kitematic. I assigned a fixed port (settings/ports), and pointed my volume (settings/volumes) to my local github repository.

After this it should be able to run, but I got some permission errors:

To fix this, you can open the docker settings, go to “shared drives”, then check C and enter your credentials.

After this, my “hello world” jekyll service was running in a linux VM (MobyLinuxVM) on Windows 10.

Using Module Initializers

Thu, 30 Jun 2016 00:00:00 +0000

Code at github.

Module Initializers is something most .Net developers has never heard about. It’s a part of .Net, but not supported in the C# language (as C# does not support global functions). However, since .Net itself supports it, you should be aware that it exists. A Module Initializer is a piece of code that runs before any other code in the .Net application, and can be triggered in some situations even with just reading metadata:

Either by: typeof(SomeProject.SomeClass).FullName.

Or:

var assembly = Assembly.Load("SomeProject"); //Use ReflectionOnlyLoad
var type = assembly.GetType("SomeProject.SomeClass");
var attributes = type.GetMethod("SomeMethod").GetCustomAttributes();

By using fody with ModuleInit link, you can actually create Module Initializers in a C# project. What it does is copy the compiled IL of a special method, and creating a Module Initializer out of it.

public static void Initialize()
{
    var ad = AppDomain.CurrentDomain;
    try
    {
        var ps = ad.PermissionSet;
        Console.WriteLine("Works Do bad stuff here!");
    }
    catch(MethodAccessException ex)
    {
        Console.WriteLine("Exeption Happend! :O");
    }
}

If you don’t want this code to run for some reason, ex if want to setup a sandbox for some protection with partial trusted code. It could be wise to use Assembly.ReflectionOnlyLoad() instead of Assembly.Load().

Custom buttons in Xamarin Forms

Sun, 26 Jun 2016 00:00:00 +0000

I also Wrote part of this as a post on the forum.

Creating a custom button

There are several ways of achieving this (often with TapGestureRecognizer), but after Xamarin.Forms 2.3 they introduced effects. I wanted to try this out to make a custom Xamarin.Forms button, and I think it worked out quite well.

I created a normal state, and a clicked state as a svg file:

<svg viewBox="0 0 100 100" width="100px" height="100px" xmlns="http://www.w3.org/2000/svg">
  <!-- http://www.w3schools.com/svg/svg_feoffset.asp -->
  <defs>
    <filter id="filter1" x="-10%" y="-10%" width="140%" height="140%">
      <feOffset result="offOut" in="SourceGraphic" dx="2" dy="2" />
      <feColorMatrix result="matrixOut" in="offOut" type="matrix" values="0.2 0.0 0.0 0.0 0.0 0.0 0.2 0.0 0.0 0.0 0.0 0.0 0.2 0.0 0.0 0.0 0.0 0.0 1.0 0.0" />
      <feGaussianBlur result="blurOut" in="matrixOut" stdDeviation="3" />
      <feBlend in="SourceGraphic" in2="blurOut" mode="normal" />
    </filter>
  </defs>
  <path d="M50 15 L90 85 L10 85 Z" stroke-linejoin="round" stroke-width="6" stroke="black" fill="yellow" filter="url(#filter1)" />
  <circle cx="50" cy="72" r="5" />
  <path d="M45 42 L55 42 L50 60 Z" stroke-linejoin="round" stroke-width="5" stroke="black" fill="black" />
  <!-- <g transform="scale(0.9) translate(5, 5)"> #Copy paths over in here for pressed effect(can also adjust shadow before rendering)# </g> -->
</svg>

Result:

To get the SVG’s in the project, I use SvgExport, and a python script.

To get started, I needed to create two classes in the Xamarin Forms PCL:

public class CustomButton : Button { }

public class ButtonEffect : RoutingEffect {
    public ButtonEffect() : base("Effects.ButtonEffect") { }
}

And the button i Xaml like this:

<local:CustomButton
    HeightRequest="80"
    WidthRequest="80"
    HorizontalOptions="Center">
    <local:CustomButton.Effects>
        <local:ButtonEffect />
    </local:CustomButton.Effects>
</local:CustomButton>

The reason for having a custom button type, is a issue in iOS (more on that later).

Android

Create a effect in the Android project like this:

[assembly: ResolutionGroupName("Effects")]
[assembly: ExportEffect(typeof(ButtonEffect), "ButtonEffect")]
namespace ProjectName.Droid
{
    public class ButtonEffect : PlatformEffect
    {
        protected override void OnAttached()
        {
            var button = (Android.Support.V7.Widget.AppCompatButton)Control;
            button.SetBackgroundResource(Resource.Layout.buttonEffect);
        }

        protected override void OnDetached()
        {
            // Use this method if you wish to reset the control to original state
        }
    }
}

And the xml like this:

<?xml version="1.0" encoding="UTF-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
  <item android:state_selected="true" >
    <bitmap android:gravity="fill" android:src="@drawable/buttonPressed" />
  </item>
  <item android:state_pressed="true">
    <bitmap android:gravity="fill" android:src="@drawable/buttonPressed" />
  </item>
  <item>
    <bitmap android:gravity="fill" android:src="@drawable/buttonNormal" />
  </item>
</selector>

And that should work. :)

iOS

To get the button to work in Xamarin iOS, add this effect:

[assembly: Xamarin.Forms.ResolutionGroupName("Effects")]
[assembly: Xamarin.Forms.ExportEffect(typeof(ButtonEffect), "ButtonEffect")]
namespace ProjectName.iOS
{
    public class ButtonEffect : Xamarin.Forms.Platform.iOS.PlatformEffect
    {
        protected override void OnAttached()
        {
            var button = (UIButton)Control;
            //var element = (Xamarin.Forms.Button)Element;
            //var container = (Xamarin.Forms.Platform.iOS.ButtonRenderer)Container;

            button.SetBackgroundImage(UIImage.FromFile("buttonNormal.png"), UIControlState.Normal);
            button.SetBackgroundImage(UIImage.FromFile("buttonPressed.png"), UIControlState.Highlighted);
        }

        protected override void OnDetached()
        {
            // Use this method if you wish to reset the control to original state
        }
    }
}

The problem then is that you get a highlight effect you cannot remove.

What you then get:

What you might want:

By poking around in the Xamarin Forms sourcecode, I found out that they use code like this: SetNativeControl(new UIButton(UIButtonType.RoundedRect));

The problem here is that the UIButton is constructed of type RoundedRect, and this is not changeable after the construction.

It was then easy to figure out that I could make some code like this to fix it:

[assembly: ExportRenderer(typeof(CustomButton), typeof(CustomButtonRenderer))]
namespace ProjectName.iOS
{
    public class CustomButtonRenderer : ButtonRenderer
    {
        protected override void OnElementChanged(ElementChangedEventArgs<Button> e)
        {
            SetNativeControl(new UIButton(UIButtonType.Custom));
            Control.TouchUpInside += (sender, ev) => Element?.Command?.Execute(null);
            if (Element.TextColor == Color.Default) //#00000000
                Element.TextColor = Control.TitleColor(UIControlState.Normal).ToColor(); //#FFFFFFFF

            base.OnElementChanged(e);
        }
    }
}

What you need to do, is to run the SetNativeControl method to create the button before calling the base. However, XF will then skip some code, so you will need to copy your click event or command to the button.

There is also a Xamarin fix for default colors that you can run manually.

After this, just call the base method.

Xamarin custom page transitions

Sat, 25 Jun 2016 00:00:00 +0000

Code on github can be found here.

Transitions

You might have seen some applications with nice and smooth animations/transitions between pages, and in Xamarin.Forms you might want to change the page transitions to be something similar. However this is poorly documented, and hard to get started with.

There are several examples on the samples site, but those are not for Xamarin.Forms.

Xamarin Forms 2.3 is sadly not made to support custom transitions very well, and if this is important in your application, you will probably want to go for pure Xamarin Android and iOS instead. The good part is that by poking around in the sourcecode, it seems like this is something that they will improve in the future.

iOS is the easiest to make custom page transitions.

A good resource will be to look at this forum post, and with the example it was easily able to get this working nice and smooth.

Navigation on AppCompat is a little harder, but by poking around in the sourcecode, I found that an override of the SetupPageTransition would make you able to add custom transitions between the pages. There is however a little bug in this approach when navigation back in the navigationstack. The fragment actually is removed from the stack before the animation is finished.

[assembly: ExportRenderer(typeof(NavigationPage), typeof(AnimationNavigationRenderer))]
namespace ProjectName.Droid
{
    public class AnimationNavigationRenderer : Xamarin.Forms.Platform.Android.AppCompat.NavigationPageRenderer
    {
        protected override void SetupPageTransition(Android.Support.V4.App.FragmentTransaction transaction, bool isPush)
        {
            if (isPush)
                transaction.SetCustomAnimations(Resource.Animation.abc_slide_in_top, 0, 0, Resource.Animation.abc_slide_out_top);
            else
                transaction.SetCustomAnimations(Resource.Animation.abc_slide_in_top, 0, 0, Resource.Animation.abc_slide_out_top);
        }
    }
}

This post is for Xamarin 2.3, and the code will need small changes to work on later versions.
(It uses reflection on code already changed in latest branch)

I tried several ways of achieving this, however the only solution I found without too many bugs in it, was to get Xamarin.Forms to skip some code, and do this manually.

It’s not that hard to add custom animations:

public override void AddView(Android.Views.View child)
{
    base.AddView(child);
    child.Visibility = ViewStates.Visible;

    var animation = AnimationUtils.LoadAnimation(Context, Resource.Animator.transition_from_left);
    animation.AnimationEnd += (sender, e) => child.Animation = null;
    child.Animation = animation;

    //Alternative logic (code):
    ////child.Alpha = 0;
    ////child.ScaleX = child.ScaleY = 0.8f;
    //child.TranslationX = Resources.DisplayMetrics.WidthPixels;
    //ViewPropertyAnimator animatior = child.Animate().TranslationX(0).SetDuration(200); //.ScaleX(1).ScaleY(1).Alpha(1)
}

Xamarin has hardcoded the default animation, so there is not much to do there. We therefor need to always send in animated = false when calling base.OnPushAsync, when using custom animations. The hard part is that Xamarin hides the previus page before the animation is finished. By setting the private field _current = null, Xamarin will however skip this part. To do this we need to use some reflection magic (this code might change in later versions):

private Page SwitchView(Page currentView)
{
    var field = this.GetType().BaseType.GetField("_current", BindingFlags.NonPublic | BindingFlags.Instance);
    var pastView = (Page)field.GetValue(this);
    field.SetValue(this, currentView);
    return pastView;
}

But then we will need to manually hide the previous page:

var renderer = Platform.GetRenderer(pastView);
if (pastView != null && renderer != null && renderer.ViewGroup.Parent != null)
    SendDisappearing(pastView);

To call the SendDisappearing, we will need to use reflection. In current branch on Github of Xamarin.Forms, they have however changed this. In the future we probably can call this without reflection.

private void SendDisappearing(Page page)
{
    var pageType = typeof(Xamarin.Forms.Page);
    var sendDisappearingMethod = pageType.GetMethod("SendDisappearing", BindingFlags.NonPublic | BindingFlags.Instance);
    sendDisappearingMethod.Invoke(page, new object[0]);
}

Whole code will then look like this:

[assembly: ExportRenderer(typeof(NavigationPage), typeof(CustomNavigationAnimationRenderer))]
namespace ProjectName.Droid
{
    public class CustomNavigationAnimationRenderer : Xamarin.Forms.Platform.Android.NavigationRenderer
    {
        //Warning: Will break in a later release of Xamarin.Forms:
        private void SendDisappearing(Page page)
        {
            var pageType = typeof(Xamarin.Forms.Page);
            var sendDisappearingMethod = pageType.GetMethod("SendDisappearing", BindingFlags.NonPublic | BindingFlags.Instance);
            sendDisappearingMethod.Invoke(page, new object[0]);
        }

        //Warning: Uses reflection, might break in a later release:
        private Page SwitchView(Page currentView)
        {
            var field = this.GetType().BaseType.GetField("_current", BindingFlags.NonPublic | BindingFlags.Instance);
            var pastView = (Page)field.GetValue(this);
            field.SetValue(this, currentView);
            return pastView;
        }

        protected override async Task<bool> OnPushAsync(Page view, bool animated)
        {
            var pastView = SwitchView(null); //Removes the previous view from parent (NavigationRenderer).

            var result = await base.OnPushAsync(view, false); //Execute code.

            //Manually run parents code that was skipped:
            var renderer = Platform.GetRenderer(pastView);
            if (pastView != null && renderer != null && renderer.ViewGroup.Parent != null)
                SendDisappearing(pastView);

            return result;
        }

        public override void AddView(Android.Views.View child)
        {
            base.AddView(child);
            child.Visibility = ViewStates.Visible;

            var animation = AnimationUtils.LoadAnimation(Context, Resource.Animator.transition_from_left);
            animation.AnimationEnd += (sender, e) => child.Animation = null;
            child.Animation = animation;

            //Alternative logic (code):
            ////child.Alpha = 0;
            ////child.ScaleX = child.ScaleY = 0.8f;
            //child.TranslationX = Resources.DisplayMetrics.WidthPixels;
            //ViewPropertyAnimator animatior = child.Animate().TranslationX(0).SetDuration(200); //.ScaleX(1).ScaleY(1).Alpha(1)
        }
    }
}

There are two ways I found to make these transitions.

Either by using xml resources:

<?xml version="1.0" encoding="UTF-8" ?>
<set xmlns:android="http://schemas.android.com/apk/res/android" android:fillAfter="true" >
    <translate
        android:duration="250"
        android:fromXDelta="-100%"
        android:toXDelta="0" />
</set>

And the code:

var animation = AnimationUtils.LoadAnimation(Context, Resource.Animator.transition_from_left);
animation.AnimationEnd += (sender, e) => child.Animation = null;
child.Animation = animation;

Or hard coded (like XF does):

child.TranslationX = Resources.DisplayMetrics.WidthPixels;
ViewPropertyAnimator animatior = child.Animate().TranslationX(0).SetDuration(200);

Good luck. :)

EB Code explained

Sat, 25 Jun 2016 00:00:00 +0000

For a long time I, had a block of code on my web site, that for many was hard to understand:

static unsafe void Main()
{
    string a = "a";

    fixed (char *p = a)
    {
        p[0] = 'b';
    }

    Console.WriteLine("a"); //"b"
}

What happens here is a little bit of optimization magic in the .Net CLR. When having two equal strings hardcoded, the address in memory will be the same. This is because .Net uses a string table, aka. an intern pool.

By default, a new string created in runtime does not reference the same address, but you can put (or get the old) string on the pool by using the string.Intern keyword.

Se example:

string a = "A", b = "B";

Object.ReferenceEquals(a, "A").Dump(); //True
var ab = a + b; //"AB"
Object.ReferenceEquals(ab, "AB").Dump(); //False
Object.ReferenceEquals("A" + "B", "AB").Dump(); //True
var internString = string.Intern(a + b).Dump(); //"AB"
Object.ReferenceEquals(internString, "AB").Dump(); //True

String are immutable, but by using the unsafe keyword, you can actually manually change the content of it. Be aware, as this opens for some attacks from libraries (or a colleague that want to mess with you) when it comes to things like reflection and connection strings.

Welcome to Jekyll!

Mon, 20 Jun 2016 07:56:46 +0000

You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.

To add new posts, simply add a file in the _posts directory that follows the convention YYYY-MM-DD-name-of-post.ext and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.

Kernel32.net

Faster context switching with Chrome profiles

Faster context switching with Chrome profiles

Better browser switching

Setup browser switching

AutoURL Rules

What I hope for the future of Xamarin.Forms

It’s time to redesign Xamrin Forms

Open Sourceode

PlatformA != PlatformB

My suggestion

PCL vs Shared libraries

But I do love Xamarin.Forms

Bluetooth Low Energy Beacons

Modes

Use cases

Security

Getting started

Running Jekyll in Docker for Windows

Prerequisites

Using Module Initializers

Custom buttons in Xamarin Forms

Creating a custom button

Android

iOS

Xamarin custom page transitions

Transitions

Navigation on iOS:

Navigation on Android AppCompat:

Navigation on Android 5+:

EB Code explained

Welcome to Jekyll!