misphere.py

import json
import socket
import os
import threading
import time
import io
import select
import netifaces as ni

from msgids import *


class Session():
    pass


class MiSphereConn:
    ms_ip = '192.168.42.1'
    ms_tcp_port = 7878
    ms_uk_port = 8787
    ms_fs_port = 50422

    def init(self):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.socket.connect((self.ms_ip, self.ms_tcp_port))
        self.socket_1 = socket.socket()
        self.recv_handle_live = True
        self.recv_thread = threading.Thread(target=self.recv_handler)
        self.recv_thread.daemon = True
        self.session = Session()
        self.session.conf = {}
        self.session.locks = {}
        self.last_send = 0

    def handle_data(self, func):
        self.handle_data = func

    def recv_handler(self):
        while self.recv_handle_live:
            r, _, _ = select.select([self.socket], [], [], 0.5)
            if r:
                resps = self.socket.recv(512).decode()
                while True:
                    resp_dict, idx = json.JSONDecoder().raw_decode(resps)
                    self.resp_handler(resp_dict)
                    if idx >= len(resps):
                        break
                    else:
                        resps = resps[idx:]

    def resp_handler(self, data):
        if 'rval' in data:
            print(data)
            # assert(data['rval'] >= 0)
        self.handle_data(data)
        if data['msg_id'] == CONNECT:
            self.session.token = data['param']
        elif data['msg_id'] == DISCONNECT:
            self.recv_handle_live = False
        elif data['msg_id'] in [GET_CAMERA, GET_STORAGE, GET_DEVICE]:
            cdata = {}
            for e in data:
                if e not in ['rval', 'msg_id']:
                    cdata[e] = data[e]
            self.session.conf[data['msg_id']] = cdata
        else:
            print("UNKNOWN", data)
        if data['msg_id'] in self.session.locks:
            self.session.locks[data['msg_id']].release()
            print('[UNLOCK]', data['msg_id'])

    def connect_8787(self):
        self.socket_1.connect((self.ms_ip, self.ms_uk_port))

    def poweroff(self):
        self.send(TURN_OFF)

    def create_payload(self, msg_id, token, params=None):
        payload = dict()
        payload['msg_id'] = msg_id
        if params is not None:
            for k, v in params.items():
                payload[k] = str(v) if k == 'param' else v
        payload['token'] = token
        return payload

    def send(self, msg_id, params=None, token=None):
        if msg_id not in self.session.locks:
            self.session.locks[msg_id] = threading.Lock()
        print("[LOCK] ", msg_id)
        if self.session.locks[msg_id].locked():
            return 0
        else:
            self.session.locks[msg_id].acquire()
        if token is None:
            token = self.session.token
        payload = self.create_payload(msg_id, token, params)
        data = json.dumps(payload).encode()
        print(data)
        timediff = time.time() - self.last_send
        if timediff < 0.5:
            time.sleep(0.5 - timediff)
        self.last_send = time.time()
        return self.socket.send(data)

    def recv(self):
        response = self.socket.recv(1024)
        response = json.loads(response.decode())
        return response

    def send_recv(self, msg_id, params=None, token=None):
        self.send(msg_id, params, token)
        return self.recv()

    def get_mode(self):
        self.send(GET_CAMERA)

    def connect(self):
        self.recv_handle_live = True
        self.recv_thread.start()
        self.send(CONNECT, token=0)
        while self.session.locks[CONNECT].locked():
            time.sleep(.2)
        print('token is {}'.format(self.session.token))
        self.get_details()

    def set_sub_camera(self, sub_cam, value=0):
        if sub_cam == 'Timer':
            self.send(SET_PHOTO_TIMER, {'param': value})
        elif sub_cam == 'Intervalometer':
            self.send(SET_PHOTO_INTERVALOMETER, {'param': value})
        elif sub_cam == 'Bracketing':
            self.send(SET_PHOTO_BRACKETING, {'param': int(2 * value)})
        elif sub_cam == 'None':
            self.send(SET_PHOTO_TIMER, {'param': 0})
            self.send(SET_PHOTO_INTERVALOMETER, {'param': 0})
            self.send(SET_PHOTO_BRACKETING, {'param': 0})

    def set_sub_video(self, sub_vid, value=0):
        if sub_vid == 'Short video':
            self.send(SET_VIDEO_SHORT, {'param': value})
        elif sub_vid == 'Timelapse':
            self.send(SET_VIDEO_TIMELAPSE, {'param': value})
        elif sub_vid == 'Slow motion':
            self.send(SET_VIDEO_SLOWMO, {'param': value})
        elif sub_vid == 'None':
            self.send(SET_VIDEO_SHORT, {'param': 0})
            self.send(SET_VIDEO_TIMELAPSE, {'param': 0})
            self.send(SET_VIDEO_SLOWMO, {'param': 0})

    def get_details(self):
        self.get_camera_details()
        self.get_storage_details()
        self.get_device_details()

    def is_set_to_photo(self):
        return self.send(GET_CAMERA)['mode'] == 1

    def is_set_to_video(self):
        return self.send(GET_CAMERA)['mode'] == 0

    def switch_to_video(self):
        return self.send(SWITCH_MODE, {'param': 0})

    def switch_to_photo(self):
        return self.send(SWITCH_MODE, {'param': 1})

    def switch_mode(self):
        if self.is_set_to_photo():
            return self.switch_to_video()
        elif self.is_set_to_video():
            return self.switch_to_photo()

    def get_camera_details(self):
        return self.send(GET_CAMERA)

    def get_storage_details(self):
        return self.send(GET_STORAGE)

    def get_device_details(self):
        return self.send(GET_DEVICE)

    def set_photo_EV(self, value):
        return self.send(PHOTO_EV, {'param': int(2 * value)})

    def set_photo_ISO(self, value):
        return self.send(PHOTO_ISO, {'param': value})

    def set_photo_WB(self, value):
        return self.send(PHOTO_WB, {'param': value})

    def get_info(self, filepath=''):
        self.send(FILE_INFO,
                  {
                      "param": "/tmp/SD0/DCIM/20171210/f0297728.jpg",
                  }
                  )
        return self.recv()

    def get_thumb(self, filepath=''):
        self.send(FILE_PREVIEW,
                  {
                      "param": "/tmp/SD0/DCIM/20171210/f0297728.jpg",
                      "type": "thumb"
                  }
                  )
        return self.recv()

    def register_tcp(self, params={}):
        for e in ni.interfaces():
            if e.lower().startswith('w'):
                ip = ni.ifaddresses(e)[ni.AF_INET][0]['addr']
                if ip.startswith("192.168.42."):
                    break
        params = {"param": ip, "type": "TCP"}
        self.send(REGISTER_TCP, params)
        return self.recv()

    def click_picture(self, long_press=False):
        self.send(PHOTO_LONGPRESS if long_press else PHOTO_PRESS)

    def record_video(self, long_press=False):
        self.send(VIDEO_LONGPRESS if long_press else VIDEO_REC_START)

    def record_stop(self):
        self.send(VIDEO_REC_STOP)

    def change_camera_res(self, value):
        l = {
            '6912x3456': 0,
            '3456x1728 (stitched)': 1,
            '6912x3456 (stitched)': 2,
            '6912x3456 with RAW': 3
        }
        self.send(PHOTO_RES, {'param': l[value]})

    def change_camera_wb(self, value):
        l = {
            'Auto': 0,
            'Outdoors': 1,
            'Overcast': 2,
            'Incandescent': 3,
            'Fluorescent': 4
        }
        self.send(PHOTO_WB, {'param': l[value]})

    def change_camera_iso(self, value):
        l = {
            'Auto': 0,
            '50': 50,
            '100': 100,
            '200': 200,
            '400': 400,
            '800': 800,
            '1600': 1600
        }
        self.send(PHOTO_ISO, {'param': l[value]})

    def change_camera_shutter(self, value):
        print("yo")

        def l(val):
            if val == 'Auto':
                return 0
            else:
                if val.startswith('1/'):
                    val = val[2:]
                    val = int(val)
                    val += 1 << 15
                else:
                    val = int(val)
            return val
        self.send(PHOTO_SHUTTERTIME, {'param': l(value)})

    def change_camera_ev(self, value):
        self.send(PHOTO_EV, {'param': int(2 * value)})

    def change_video_res(self, value):
        l = {
            '3456x1728 | 30fps': 0,
            '2304x1152 | 30fps': 1,
            '2304x1152 | 60fps': 2,
            '2048x512 | 120fps': 3,
            '2048x512 | 120fps bottom (Bullet time)': 4,
            '3456x1728 | 30fps HighBitrate': 5
        }
        self.send(VIDEO_RES, {'param': l[value]})

    def change_video_wb(self, value):
        l = {
            'Auto': 0,
            'Outdoors': 1,
            'Overcast': 2,
            'Incandescent': 3,
            'Fluorescent': 4
        }
        self.send(VIDEO_WB, {'param': l[value]})

    def change_video_ev(self, value):
        self.send(VIDEO_EV, {'param': int(2 * value)})

    def set_auto_off(self, value):
        self.send(AUTO_TURN_OFF, {'param': value})

    def set_buzzer_volume(self, value):
        self.send(SET_BUZZER_VOLUME, {'param': value})

    def set_led(self, value):
        self.send(SET_LED, {'param': int(value)})

    def disconnect(self):
        self.send(DISCONNECT)
        while self.session.locks[DISCONNECT].locked():
            time.sleep(0.5)
        self.recv_handle_live = False
        self.recv_thread.join()

    def test(self, l, h):
        import msgids
        known = set()
        for e in vars(msgids):
            if not e.startswith('__'):
                known.add(msgids.__dict__[e])
        for i in range(l, h + 1):
            self.send(i)

    def __del__(self):
        self.socket.close()
        self.socket_1.close()


if __name__ == '__main__':
    cam = MiSphereConn()
    cam.connect()
    # cam.click_picture()
    # cam.disconnect()