Screencast: Your computer screen as an Alexa Smart Home Security Camera

This is a screencast I just put together showing how you can show your computer’s screen as an Alexa Smart Home Security Camera.

I wanted this because I already have security camera software running on a windows desktop … all I wanted was to say “Alexa, show security cameras” and see the software running on that computer.

Source referenced in the screencast is here

Using Siri to control your Alexa Smart Home devices

I have many Smart Home devices that can be controlled from my Amazon Echo, however none of those devices can be controlled from Siri on my Apple Watch or iPhone. None are HomeKit compatible.

What I’ve done lets me control my Alexa Smart Home devices via Siri on my Apple Watch or iPhone. This solution is not elegant (it involves a Raspberry PI, HomeBridge and a speaker) but it does work…

Code here. Demo here:

Using Google Sign-in for iOS in Xamarin Forms to access Google APIs

This is another of those posts where I am essentially writing a message to my future self to remind myself how to do something, and in the process perhaps help out someone else.

I wanted to use the Google Sign-in for iOS Xamarin Component from Xamarin Forms to let a user sign-in to Google, and then use the resulting access token to invoke one of the Google APIs, in my case the Google Tasks API.

There are several hurdles to overcome:

  • How to use the Google Sign-in for iOS Xamarin Component from Xamarin Forms, since the examples are for iOS apps;
  • How to use that component to request access to the Google Tasks API;
  • How to use the resulting access token to actually invoke the API.

Google Sign-in for iOS Xamarin Component from Xamarin Forms

The Getting Started Guide for the Google Sign-in for iOS Xamarin Component explains how to set up the component for a native Xamarin iOS app.

I followed its instructions with regards to registering on the Google API Console, downloading the GoogleService-Info.plist file, and setting up my AppDelegate:

    public override bool OpenUrl(UIApplication application, NSUrl url, string sourceApplication, NSObject annotation)
      return Google.SignIn.SignIn.SharedInstance.HandleUrl(url, sourceApplication, annotation);

    public override bool FinishedLaunching(UIApplication app, NSDictionary options)

      NSError configureError;
      Google.Core.Context.SharedInstance.Configure(out configureError);
      if (configureError != null)
        // If something went wrong, assign the clientID manually
        Debug.WriteLine("Error configuring the Google context: {0}", configureError);
        Google.SignIn.SignIn.SharedInstance.ClientID = "";


The instructions with regards to Signing In were trickier though, since they assume access to iOS View Controller.

Xamarin Forms hides such platform-specifics, however this post on Using Custom UIViewControllers in Xamarin.Forms on iOS by Xamarin’s Mike Bluestein explains how to get hold of the ViewController by creating a custom renderer for a page.

Assuming your Xamarin Forms main page is called “MainPage” (inspired, I know), I followed Mike’s instructions and ended up with a renderer like this:

using System.Diagnostics;
using System.Threading.Tasks;
using Foundation;
using Google.SignIn;
using Xamarin.Forms;
using Xamarin.Forms.Platform.iOS;

[assembly: ExportRenderer(typeof(enfiler.Views.MainPage), typeof(enfiler.iOS.IOSMainPage))]
namespace enfiler.iOS
  public class IOSMainPage : PageRenderer, ISignInUIDelegate, ISignInDelegate
    TaskCompletionSource<string> _taskCompletionSource;

    public override void ViewDidLoad()
      Services.GoogleTasks.Instance.GetAccessToken = GetAccessToken;

    public Task<string> GetAccessToken()
      _taskCompletionSource = new TaskCompletionSource<string>();
      SignIn.SharedInstance.UIDelegate = this;
      SignIn.SharedInstance.Delegate = this;
      SignIn.SharedInstance.Scopes = new string[] { Google.Apis.Tasks.v1.TasksService.Scope.Tasks };
      return _taskCompletionSource.Task;

    public void DidSignIn(SignIn signIn, GoogleUser user, NSError error)
      if (error != null)
        _taskCompletionSource.SetException(new NSErrorException(error));

When the Xamarin Forms page called MainPage loads, this renderer gets invoked to actually render it on iOS. Since it derives from the builtin PageRender class, it doesn’t have to do any of the heavy lifting of rendering, but instead simply registers itself in the Services.GoogleTasks.Instance class in my Xamarin Forms PCL, which we will see later.

Notice how the GetAccessToken does the Sign In work described in the Getting Started guide. It provides for asynchronous invocation and thus uses the TaskCompletionSource class since the sign-in completes via the DidSignIn callback.

One difference from the Getting Started guide is that I’m specifying the Google Tasks OAuth Scope in GetAccessToken. In order to do this I needed to add the Google APIs Client Library nuget package. I also needed to activate the Google Tasks API for my app in the Google API Console.

Notice also that in the DidSignIn I’m completing the task returned from GetAccessToken either with an exception, or with the OAUTH access token resulting from logging in.

Invoking the Google Tasks API with the token returned from the Google Sign-In component

This is the GoogleTasks class with which the IOSMainPage class registered itself by setting the GetAccessToken callback:

using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Google.Apis.Tasks.v1;

namespace enfiler.Services
  public class GoogleTasks

    public static GoogleTasks Instance { get; } = new GoogleTasks();
    public async Task<Google.Apis.Tasks.v1.Data.Task> CreateTask(string title, string notes)
      var taskService = new TasksService();
      var task = new Google.Apis.Tasks.v1.Data.Task
        Title = title,
        Notes = notes
      var request = taskService.Tasks.Insert(task, "@default");
      request.OauthToken = await GetAccessToken.Invoke();
      return await request.ExecuteAsync();

    public Func<Task<string>> GetAccessToken { get; set; }

I defined this in the Xamarin Forms PCL for my project, and added the Google APIs Client Library nuget package to my PCL too.

The key thing here is the assigning of the OauthToken on the request.

Inside my Xamarin Forms app whenever I want to create a new Google Task I await the invocation of CreateTask which calls back into the custom renderer:

      var googleTask = await Services.GoogleTasks.Instance.CreateTask("Hello To", "Jason Isaacs")


Google have deprecated the use of Web Views to authenticate with their services and are instead requiring the use of their own libraries, such as the Google Sign-In for iOS library.

By combining the use of the Google Sign-In for iOS Xamarin Component with a custom page renderer, and requesting a custom OAUTH scope I was able to request access to a user’s Google Tasks, and then create a task.

I’ve not yet explored the same thing on Android, but I’d hope to be able to register a callback from my Android code just as on iOS to do the OAUTH dance.

A more friendly Xamarin Forms DatePicker

This is a small, simple thing, to make a Xamarin Forms DatePicker more friendly. Instead of showing the date for yesterday, today and tomorrow, as it normally does, it instead shows “yesterday”, “today”, and, you guessed it, “tomorrow”:

iOS: Android:

The view is totally straight-forward, except that instead of just binding the Date in the DatePicker, I also bind the Format:

<?xml version="1.0" encoding="utf-8"?>
<ContentPage xmlns="" 
    BindingContext="{x:Static local:ViewModel.Instance}">
    <DatePicker Date="{Binding TheDate}" Format="{Binding DateFormat}"/>

The View Model’s Format property looks at the date, and returns the appropriate (escaped) string:

namespace FriendlyDatePicker {
  public class ViewModel : INotifyPropertyChanged {
    public static ViewModel Instance { get; } = new ViewModel();
    public event PropertyChangedEventHandler PropertyChanged;
    DateTime theDate = DateTime.Now;

    public DateTime TheDate {
      get {
        return theDate;

      set {
        theDate = value;

    public string DateFormat {
      get {
        var date = DateTime.Now.Date;
        if (theDate.Date == date) {
          return Escape("Today");
        if (theDate.Date == date.AddDays(1)) {
          return Escape("Tomorrow");
        return theDate.Date == date.AddDays(-1) ? Escape("Yesterday") : "d";

    private string Escape(string s) {
      var result = new StringBuilder();
      foreach (var c in s) {
      return result.ToString();

    void OnPropertyChanged([CallerMemberName] string propertyName = null) {
      PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

I’ve noticed that this doesn’t work in UWP apps because the DatePicker renders as a native component, and ignores the Format.

It is trivial, but does make for a nicer UX.

That’s all folks, nothing more to see, move along now.

Using the Apple Thunderbolt display with the Dell XPS 13

After many years of buying Mac laptops, I’ve bought a Dell XPS 13.

One question was how much of my old Apple hardware I could reuse. By buying an Apple USB C charger, I can re-use all the power adapter plugs and extensions I’ve bought over the years.

The big question for me, however was my Apple Thunderbolt display. One option, which I’ve not tried, is to buy the Thunderbolt 3 to Thunderbolt 2 adapter, and plug it in directly. I’ve not found anyone saying that works, and it also consumes the one and only, and thus very precious USB-C/Thunderbolt 3 port.

The solution I’ve found, which is not for everyone, is to plug the Apple Thunderbolt display into a Mac Mini running Windows 10. Then I enable the “Projecting to this PC” capability on the Mac Mini.


On my XPS 13 I project to the Mac Mini and extend the displays (yes, the Thunderbolt display has a lower resolution than my XPS 13):


Performance isn’t enough for gaming, but its good enough for software development.

“Alexa, enable the My Notebook skill”

I just released my first Amazon Echo Skill, called “My Notebook”.

You can use it to create notes in Evernote or OneNote using your Amazon Echo:


To try it out, say “Alexa, enable the My Notebook skill”.

It was rejected twice (for good reasons) during the review process, and I learned a lot as a result, especially around keeping the conversation going, responding to help requests etc.

For the technical, as well as using the Alexa Skills Kit, I used the Amazon API Gateway, an AWS Lambda (written in Python, since C# isn’t yet available), and Amazon DynamoDB.

I’m caught between hoping it takes off, and people use it, but also hoping it isn’t too popular, since it is free and I’m not keen on maxing out my credit card!