config :aws_iot, Aws.Iot.ThingShadow.Client,
  host: "xxxxxxxxx.iot.<region>.amazonaws.com",
  port: 8883,
  client_id: "xxxxxxx",
  ca_cert: "config/certs/root-CA.crt",
  client_cert: "config/certs/xxxxxxxxxx-certificate.pem.crt",
  private_key: "config/certs/xxxxxxxxxx-private.pem.key",
  mqttc_opts: []

alias Aws.Iot.ThingShadow

# Initializes a new ThingShadow.Client process
# Events from this client will be forwarded to self()
{:ok, client} = ThingShadow.init_client([cast: self()])

# Register interest in a thing (required)
ThingShadow.Client.register(client, "aws-iot-thing-name")

# Get shadow state for a thing 
ThingShadow.Client.get(client, "aws-iot-thing-name")

# See ThingShadow.Client events sent to self() via MyThing.PubSub
Process.info(self)[:messages]

  def start(_type, _args) do
    ...
    children = [
      ...,
      supervisor(Phoenix.PubSub.PG2, [MyThings.PubSub, []])
    ]
    ...
  end

  alias Aws.Iot.ThingShadow

  def init(_args) do
    Phoenix.PubSub.subscribe(MyThings.PubSub, "thing_shadow_event")

    {:ok, client} = ThingShadow.init_client([
        broadcast: {MyThings.PubSub, "thing_shadow_event"}
      ])

    # If we are only reporting state from an IoT Device, 
    # then versioning and persistent_subscribe is not required.
    thing_opts = [qos: 1, enable_versioning: false, persistent_subscribe: false]
    ThingShadow.Client.register(client, "aws-iot-thing-name", thing_opts)

    {:ok, %{iot_client: client, client_token_op: %{}}}
  end

  def handle_info({:connect, client}, state) do
    # Note: ThingShadow.Client will handle resubscribe to topics on reconnection.

    # According to AWS docs, an IoT device should report 
    # its shadow_state on reconnection
    shadow_state_report = %{state: %{reported: %{ 
      "led_on" => false 
    }}}
    {:ok, client_token} = ThingShadow.Client.update(client, 
      "aws-iot-thing-name", shadow_state_report)
    state = put_client_token(client_token, :update, state)

    {:noreply, state}
  end

  def handle_info({:delta, "aws-iot-thing-name", shadow_state}, state) do
    IO.inspect(shadow_state)

    # According to AWS docs, an IoT device should act on any delta
    desired_state_of_led_on = shadow_state["state"]["led_on"]
    case desired_state_of_led_on do
      true -> IO.puts "Led will be turned on"
      false -> IO.puts "Led will be turned off"
    end

    {:noreply, state}
  end

  def handle_info({:status, "aws-iot-thing-name", :accepted, client_token, shadow_state}, state = %{client_token_op: client_token_op}) do
    case client_token_op[client_token] do
      :get -> IO.inspect(shadow_state)
      :update -> IO.inspect(shadow_state)
      :delete -> IO.inspect(shadow_state)
      nil -> IO.puts "Missing token"
    end

    state = remove_client_token(client_token, state)
    {:noreply, state}
  end

  def handle_info({:status, "aws-iot-thing-name", :rejected, client_token, shadow_state}, state) do
    IO.inspect(shadow_state)
    state = remove_client_token(client_token, state)
    {:noreply, state}
  end

  def handle_info({:timeout, "aws-iot-thing-name", client_token}, state) do
    IO.inspect(client_token)
    state = remove_client_token(client_token, state)
    {:noreply, state}
  end

  defp put_client_token(client_token, op, state = %{client_token_op: client_token_op}) do
    client_token_op = Map.put(client_token_op, client_token, op)
    %{state | client_token_op: client_token_op}
  end

  defp remove_client_token(client_token, state = %{client_token_op: client_token_op}) do
    client_token_op = Map.delete(client_token_op, client_token)
    %{state | client_token_op: client_token_op}
  end