Here’s proof notifications don’t have to suck

LIFX has a mobile app that pulls in a resounding 2.5 stars in the iOS App Store. However, it worked fine for me and I think maybe someone has a vendetta here.

The first step is to connect the light to your Wifi. You do this by turning the light on and then looking for its Wifi signal on your device. You then join the bulb where you can set its Wifi in the app. This is exactly how pretty much every other connected device works.

The second thing you need to do is claim your bulb. This is basically where you hit a button on the app that says “that’s my bulb”. It sends you a validation code and then boom — you’ve claimed it. I don’t get that part at all. I set the thing up on my Wifi, didn’t I? It’s my freaking bulb. However, the API won’t work if you don’t claim your bulb and it won’t tell you that either. Which is nice.

Using The LIFX API

The API on the LIFX is open, simple and RESTful — whatever that even means anymore. It doesn’t take much to authenticate. In fact, you can just register for a token and then pass that on your requests to the API if you don’t want to go through the OAuth rigamarole. I am not a fan of OAuth. Or trying to figure out how to spell “rigamarole”.

Tokens are app based — not user based. You can see I’ve created one for the Twitter Bulb service.

Now that we’ve got a token, we’re ready to build out an endpoint that we can hit which will control out bulb. This way our token stays private and we can add any further logic that we want. Instead of creating a whole web application to do that, we can use Serverless.

Creating A Serverless Endpoint

I created a Serverless function using Azure Functions. My preferred method of doing that is to use the CLI. This has the added benefit of being able to debug Serverless locally with Visual Studio Code. I also use the Azure Functions Extension for VS Code because I came for the tooling.

Assuming you have both the CLI and the Functions Extension installed, from within VS Code, you can create a new function app. Then I created a function called “breathe”, which is the name of the effect on the LIFX bulb that causes that gentle pulsing. There is also a method called “pulse”, but it does not in fact pulse. Breathe pulses. Still with me?

Good. Let’s build the function.

Building an Azure function is just like building any Node application. You export one main function that gets called. That function gets a context object and a request object passed to it. Inside of that function, you can do the same things you do in Node. You just need to set the res object on the contextwhen you are done and then called context.done. The res is the response that is returned to the user and calling done tells the runtime that “We’re done here”.

First, install the lifx-http-api package. That’s right — there is a Node package for this lightbulb. This is why you love, JavaScript.

I also use the dotenv package which allows me to easily set local environment variables.

This is what the full code looks like when we’re done. Note that we’re using the req.query object to see what color was passed in. If no color is passed in, we return an error.

const lifx = require('lifx-http-api');
require('dotenv').config();

module.exports = function(context, req) {

  // if a color was passed on the query string
  if (req.query.color) {
    let client = new lifx({
      bearerToken: process.env.LIFX_TOKEN
    });

    // This sets the options for the bulb
    let options = {
      color: req.query.color,
      duration: 2,
      power: true
    };

    client
      .setState('all', options)
      .then(result => {
        context.res = {
          // status: 200, /* Defaults to 200 */
          body: result
        };

        context.done();
      })
      .catch(err => {
        context.res = {
          status: 500,
          body: err
        };

        context.done();
      });
  } 
  else {
    context.res = {
      body: 'Please pass a valid color',
      status: 500
    };
    
    context.done();  
  }
};

And that’s it. We can now run this locally and, if we’ve done everything right, it should trigger a breathe effect with the desired color. WHICH IT DOES.

I push my functions to production using Github hooks into Azure. That way whenever I make code changes, the app gets redeployed automatically.

Once the function is published to Azure, you can send the URL to all your friends and let them change the color of your lightbulb. I did it in a Twitch stream for a while and it was fun. Although I had never used Twitch before so I felt more than a tad stupid.

Now we’re ready to bring the Twitter logic into this project. The easiest way to do this is with an Azure Logic App.

Azure Logic Apps

Azure Logic Apps are kinda like IFTTT. There are a bunch of connectors to listen for actions and then execute triggers.

Logic Apps have a built-in connector for Twitter. You just authenticate and then select what you want to search for. I chose my own name because this will pull in any action on Twitter which involves yours truly. Which honestly isn’t that much. It’s a sad state of affairs.

Logic Apps have connectors right into Azure Functions.

It took me a while to figure out how to pass the color parameter to my function from Logic Apps, but I finally realized it’s in a JSON format in the “Queries” field.

And that’s it! We’re done. Click the “Run” button at the top of the screen and sit back and enjoy your new calming notifications with the LIFX lightbulb. Watch as your quality of living improves and you begin to understand the true meaning of life — which of course is to get Twitter notifications with a light bulb.

What Else Can We Do?

If you look through all of the other action types in the Logic Apps, you will see connectors to all sorts of services. What other things can we build with our connected lightbulb? There are connectors for Outlook, Github, Dropbox, Salesforce. We could basically use this lightbulb to notify us of everything that ever happens on the internet. We could even use the LUIS service to determine whether or not they are WRONG on the internet!

That’s the Twitter Bulb. And Serverless and a bonus Logic App. I really like the LIFX bulb and Brian Clark and I have some plans to build even more ridiculous projects with it. You’re welcome.