#!/usr/bin/env python3

# -*- coding: utf-8 -*-

'''

N Waterton 11th Jan 2019 V1.0 First release

'''

'''

Client class for connecting to iTEAD ewelink devices.

uses Itead's IoTgo framework see https://github.com/itead/IoTgo for more details

see http://www.pgeorgiev.com/how-do-sonoff-devices-work/ for a full explanation of how this works

You need to download the ewelink app (android or ios) and create an account, using either a phone number or e-mail

and password. You then add your device to the ewelink app.

This was specifically written for the Autoslide door device https://autoslide.com/ but I expanded it to cover other Sonoff devices.

For Autoslide doors, you can also do this using the Autoslide app (see ewelink_devices for more explanation of the autoslide device)

You can't control an Autoslide door using the ewelink app, but you can register it.

Assuming you can get the device to connect to your WiFi network (I had trouble, and had to use the

eWelink app in "legacy" mode to get it to connect), you should be able to register the device.

Once you have control using the app, you can now use this client for connecting and controlling your

device via MQTT, or command line/API.

Now you are registered, you should have your e-mail address (or phone number) and a password for your Autoslide/eWelink account.

When you instantiate the client, you need to pass the e-mail address (or phone number) and password to the client constructor.

eg:

client = ewelink_client.EwelinkClient(email, password)

or

client = ewelink_client.EwelinkClient(phone, password)

This is the minimum needed to connect the client.

iTEAD eWelink uses cloud servers to authenticate your login, and issue an authorization token, the authorization token is

re-issued every time you log in. We then take the authorization token, and use this to open a websocked client to iTEADs servers.

This websocket interface is the connection to the Autoslide device. This is an indirect connection - ie we send to iTEAD's servers

- Autoslide connects to iTEAD's servers, and the servers pass messages back and forth. This is where the disconnects and Timeouts can happen..

Do not hit the servers with too many commands too quickly, max is about 1 per second. You will get Timeouts if you send commands too quickly.

eWelink uses "regions" to determine which servers to use. This client is set to use the US (North Amrican as I'm in Canada) servers by

default, and is supposed to select other regions if that doesn't work - but I haven't tried this out.

The client is an asynchronous (asycio) websocket client, and is written for Python 3.6.

You can optionally pass in your own asyncio loop, and/or an MQTT client object (using paho-mqtt) with an optional publication topic.

There is an optional iemi string, but I'm not sure what this is for and I supply a random string as default (which works).

You can supply your own or leave it as default.

If you don't supply an asyncio loop, the client will create it's own, or pick up a pre-existing loop if there is one, and start it in a new thread.

So to _publish/receive commands via MQTT you would create an MQTT client instance, and create the ewelink client like this:

client = ewelink_client.EwelinkClient(phoneNumber=None, email='e-mail@gmail.com', password='myPassword', imei=None, loop=None, mqttc, pub_topic='/ewelink_status/')

where mqttc is a paho-mqtt client instance.

if loop is None, you can now use client functions like:

client.get_config()

client.set_option(option, value, device=0)

If you do supply an asyncio loop, you will need to start the loop, with the client.login() - like this:

loop.run_until_complete(client.login())

see ewelink_server.py for a full working example.

The actual configuration of all this is gleaned from web sources on the IoTgo protocol, and reverse engineering the data.

I have no engineering documents to go on, so some of the parameters are a best guess as to what they do.

Please update me if you have better information, or find out what unknown parameters are/do.

The actual devices themselves are defined in ewelink_devices.py, with one class per device type. The correct class will be instantiated for a

device based on the 'productModel' returned by the servers (and defined in the class). If no productModel/class match is found, a Default class

is used for the device that gives basic control.

device parameters are published to an mqtt topic like this:

/ewelink_status/deviceid/param value

You can define /ewelink_status/ to be what you want (this is the client default)

deviceid is the deviceid hard coded into the device

param is either the default parameters name returned by the server, or a user defined string (defined in the device class).

The complete json response from the device is published to:

/ewelink_status/deviceid/json {json_string}

in linux using mosqitto mqtt client tools the command would be:

mosquitto_sub -v -t "/ewelink_status/#"

You can control the device by publishing to:

/ewelink_command/deviceid/param value

(where the components are the same as above).

You can define /ewelink_command/ to be what you want (this is what you subscribe to when you create the mqtt client)

You can send a complete json string to:

/ewelink_command/deviceid/set_json {json_string}

This will update just the params of the device, and can be used for setting timers etc. See the section on timers in the client class.

Example Linux commands are:

mosquitto_pub -t "/ewelink_command/10005d73ab/set_switch" -m "off"

mosquitto_pub -t "/ewelink_command/10005d73ab/send_json" -m "{'timers': [{'enabled': 1, 'coolkit_timer_type': 'repeat', 'at': '* * * * * *', 'period': '1', 'type': 'repeat', 'do': {'switch': 'on'}, 'mId': '87d1dfdf-e9cb-d9ee-af2a-42362079e6a4'}]}"

You should use " for json (not ') but the client will convert for you.

You can also add timers using the 'add_timer" command, list them with 'list_timers' and so on. The timers are complex, so best to use the built in commands rather than json.

Device initialization parameters can be set using client.set_initial_parameters(deviceid, **kwargs) method,

and are passed to the device client on creation, the client class decides what to do with the parameters.

There are only a few devices defined in ewelink_devices.py (I only have a few to test), but feel free to add more, or update the existing ones.

Nick Waterton P.Eng.

'''

import json

import asyncio

import websockets

from aiohttp import ClientSession

import time

import math

import sys

import random

import uuid

import string

import hmac

import hashlib

import base64

import collections

import re

import yaml

from ewelink_devices import *

import inspect

import logging

logger = logging.getLogger('Main.'+__name__)

__version__ = '1.1'

class EwelinkClient():

asyncio.run_coroutine_threadsafe(self._disconnect(),self.loop)