21 files changed, 1456 insertions, 0 deletions
diff --git a/parrot_zik/__init__.py b/parrot_zik/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/parrot_zik/__init__.py
diff --git a/parrot_zik/bluetooth_paired_devices.py b/parrot_zik/bluetooth_paired_devices.py
new file mode 100644
index 0000000..905819f
--- /dev/null
+++ b/parrot_zik/bluetooth_paired_devices.py
@@ -0,0 +1,171 @@
+import dbus
+import sys
+import re
+from subprocess import Popen, PIPE, STDOUT
+
+from .resource_manager import GenericResourceManager
+
+if sys.platform == "darwin":
+    from binplist import binplist
+    import lightblue
+else:
+    import bluetooth
+    if sys.platform == "win32":
+        import _winreg
+
+
+p = re.compile('90:03:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}|'
+               'A0:14:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}:[0-9A-Fa-f]{2}')
+
+
+class BluetoothDeviceManager(object):
+    def is_bluetooth_on(self):
+        raise NotImplementedError
+
+    def get_mac(self):
+        raise NotImplementedError
+
+
+class BluezBluetoothDeviceManager(BluetoothDeviceManager):
+    def is_bluetooth_on(self):
+        pipe = Popen(['bluez-test-adapter', 'powered'], stdout=PIPE, stdin=PIPE,
+                     stderr=STDOUT)
+        try:
+            stdout, stderr = pipe.communicate()
+        except dbus.exceptions.DBusException:
+            pass
+        else:
+            return bool(stdout.strip())
+
+    def get_mac(self):
+        pipe = Popen(['bluez-test-device', 'list'], stdout=PIPE, stdin=PIPE,
+                     stderr=STDOUT)
+        try:
+            stdout, stderr = pipe.communicate()
+        except dbus.exceptions.DBusException:
+            pass
+        else:
+            res = p.findall(stdout)
+            if len(res) > 0:
+                return res[0]
+            else:
+                raise DeviceNotConnected
+
+
+class BluetoothCmdDeviceManager(BluetoothDeviceManager):
+    def is_bluetooth_on(self):
+        return True
+
+    def get_mac(self):
+        pipe = Popen(['bluetoothctl'], stdout=PIPE, stdin=PIPE, stderr=STDOUT)
+        res = pipe.communicate("exit")
+        if len(res) > 0 and res[0]:
+            match = p.search(res[0])
+            if match:
+                return match.group(0)
+        raise DeviceNotConnected
+
+
+def get_parrot_zik_mac_linux():
+    bluez_manager = BluezBluetoothDeviceManager()
+    try:
+        bluez_manager.is_bluetooth_on()
+        return bluez_manager.get_mac()
+    except OSError as e:
+        if e.errno == 2:
+            bluetoothcmd_manager = BluetoothCmdDeviceManager()
+            return bluetoothcmd_manager.get_mac()
+
+
+def get_parrot_zik_mac_darwin():
+    fd = open("/Library/Preferences/com.apple.Bluetooth.plist", "rb")
+    plist = binplist.BinaryPlist(file_obj=fd)
+    parsed_plist = plist.Parse()
+    try:
+        for mac in parsed_plist['PairedDevices']:
+            if p.match(mac.replace("-", ":")):
+                return mac.replace("-", ":")
+        else:
+            raise DeviceNotConnected
+    except Exception:
+        pass
+
+
+def get_parrot_zik_mac_windows():
+    aReg = _winreg.ConnectRegistry(None, _winreg.HKEY_LOCAL_MACHINE)
+    aKey = _winreg.OpenKey(
+        aReg, 'SYSTEM\CurrentControlSet\Services\
+        BTHPORT\Parameters\Devices')
+    for i in range(10):
+        try:
+            asubkey_name = _winreg.EnumKey(aKey, i)
+            mac = ':'.join(asubkey_name[i:i+2] for i in range(0, 12, 2))
+            res = p.findall(mac)
+            if len(res) > 0:
+                return res[0]
+            else:
+                raise DeviceNotConnected
+        except EnvironmentError:
+            pass
+
+
+if sys.platform in ['linux', 'linux2']:
+    get_parrot_zik_mac = get_parrot_zik_mac_linux
+elif sys.platform == 'darwin':
+    get_parrot_zik_mac = get_parrot_zik_mac_darwin
+elif sys.platform == 'win32':
+    get_parrot_zik_mac = get_parrot_zik_mac_windows
+else:
+    raise AssertionError('Platform not supported')
+
+
+def connect():
+    mac = get_parrot_zik_mac()
+    if sys.platform == "darwin":
+        service_matches = lightblue.findservices(
+            name="Parrot RFcomm service", addr=mac)
+    else:
+        uuids = ["0ef0f502-f0ee-46c9-986c-54ed027807fb",
+                 "8B6814D3-6CE7-4498-9700-9312C1711F63"]
+        service_matches = []
+        for uuid in uuids:
+            try:
+                service_matches = bluetooth.find_service(uuid=uuid, address=mac)
+            except bluetooth.btcommon.BluetoothError:
+                pass
+            if service_matches:
+                break
+
+    if len(service_matches) == 0:
+        raise ConnectionFailure
+    first_match = service_matches[0]
+
+    if sys.platform == "darwin":
+        host = first_match[0]
+        port = first_match[1]
+        sock = lightblue.socket()
+    else:
+        port = first_match["port"]
+        host = first_match["host"]
+        sock = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
+
+    try:
+        sock.connect((host, port))
+    except bluetooth.btcommon.BluetoothError:
+        raise ConnectionFailure
+
+    sock.send('\x00\x03\x00')
+    sock.recv(1024)
+    return GenericResourceManager(sock)
+
+
+class DeviceNotConnected(Exception):
+    pass
+
+
+class ConnectionFailure(Exception):
+    pass
+
+
+class BluetoothIsNotOn(Exception):
+    pass
diff --git a/parrot_zik/indicator/__init__.py b/parrot_zik/indicator/__init__.py
new file mode 100644
index 0000000..156f7de
--- /dev/null
+++ b/parrot_zik/indicator/__init__.py
@@ -0,0 +1,25 @@
+__all__ = ('SysIndicator', 'Menu', 'MenuItem')
+
+import sys
+
+if sys.platform in ['linux', 'linux2']:
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gtk", action="store_true")
+    args = parser.parse_args()
+    if args.gtk:
+        from parrot_zik.indicator.linux import LinuxGtkIndicator as SysIndicator
+    else:
+        from parrot_zik.indicator.linux import LinuxAppIndicator as SysIndicator
+    from parrot_zik.indicator.gtk_wrapping import GTKMenuItem as MenuItem
+    from parrot_zik.indicator.gtk_wrapping import GTKMenu as Menu
+elif sys.platform in ['win32']:
+    from parrot_zik.indicator.windows import WindowsIndicator as SysIndicator
+    from parrot_zik.indicator.gtk_wrapping import GTKMenuItem as MenuItem
+    from parrot_zik.indicator.gtk_wrapping import GTKMenu as Menu
+elif sys.platform == 'darwin':
+    from parrot_zik.indicator.mac import DarwinIndicator as SysIndicator
+    from parrot_zik.indicator.mac import NSMenuItem as MenuItem
+    from parrot_zik.indicator.mac import NSMenu as Menu
+else:
+    raise Exception('Platform not supported')
diff --git a/parrot_zik/indicator/base.py b/parrot_zik/indicator/base.py
new file mode 100644
index 0000000..b29368e
--- /dev/null
+++ b/parrot_zik/indicator/base.py
@@ -0,0 +1,48 @@
+class BaseIndicator(object):
+    def __init__(self, icon, menu, statusicon):
+        self.menu = menu
+        self.statusicon = statusicon
+        self.setIcon(icon)
+
+    def setIcon(self, name):
+        raise NotImplementedError
+
+    @classmethod
+    def main(cls):
+        raise NotImplementedError
+
+    def show_about_dialog(self, widget):
+        raise NotImplementedError
+
+    def quit(self, _):
+        raise NotImplementedError
+
+class MenuItemBase(object):
+    def __init__(self, base_item, sensitive, visible):
+        self.base_item = base_item
+        self.set_sensitive(sensitive)
+        if visible:
+            self.show()
+        else:
+            self.hide()
+
+    def set_sensitive(self, option):
+        raise NotImplementedError
+
+    def set_active(self, option):
+        raise NotImplementedError
+
+    def get_active(self):
+        raise NotImplementedError
+
+    def set_label(self, option):
+        raise NotImplementedError
+
+    def show(self):
+        self.base_item.show()
+
+    def hide(self):
+        self.base_item.hide()
+
+    def set_submenu(self, menu):
+        raise NotImplementedError
diff --git a/parrot_zik/indicator/gtk_wrapping.py b/parrot_zik/indicator/gtk_wrapping.py
new file mode 100644
index 0000000..6d4a5a8
--- /dev/null
+++ b/parrot_zik/indicator/gtk_wrapping.py
@@ -0,0 +1,46 @@
+import gtk
+
+from parrot_zik.indicator.base import MenuItemBase
+
+
+class GTKMenu(object):
+    def __init__(self):
+        self.gtk_menu = gtk.Menu()
+
+    def append(self, menu_item):
+        self.gtk_menu.append(menu_item.base_item)
+
+    def reposition(self):
+        self.gtk_menu.reposition()
+
+    def popup(self, *args, **kwargs):
+        self.gtk_menu.popup(*args, **kwargs)
+
+    def poVpdown(self, *args, **kwargs):
+        pass
+
+
+class GTKMenuItem(MenuItemBase):
+    def __init__(self, name, action, sensitive=True, checkitem=False, visible=True):
+        if checkitem:
+            gtk_item = gtk.CheckMenuItem(name)
+        else:
+            gtk_item = gtk.MenuItem(name)
+        if action:
+            gtk_item.connect("activate", action)
+        super(GTKMenuItem, self).__init__(gtk_item, sensitive, visible)
+
+    def set_sensitive(self, option):
+        return self.base_item.set_sensitive(option)
+
+    def set_active(self, option):
+        return self.base_item.set_active(option)
+
+    def get_active(self):
+        return self.base_item.get_active()
+
+    def set_label(self, option):
+        return self.base_item.set_label(option)
+
+    def set_submenu(self, menu):
+        self.base_item.set_submenu(menu.gtk_menu)
diff --git a/parrot_zik/indicator/linux.py b/parrot_zik/indicator/linux.py
new file mode 100644
index 0000000..f6f9cfc
--- /dev/null
+++ b/parrot_zik/indicator/linux.py
@@ -0,0 +1,69 @@
+import os
+
+import gtk
+
+from parrot_zik.indicator.base import BaseIndicator
+
+
+class LinuxIndicator(BaseIndicator):
+    def __init__(self, icon, menu, statusicon):
+        super(LinuxIndicator, self).__init__(icon, menu, statusicon)
+
+    def gtk_right_click_event(self, icon, button, time):
+        if not self.menu_shown:
+            self.menu_shown = True
+            self.menu.popup(None, None, gtk.status_icon_position_menu,
+                            button, time, self.statusicon)
+        else:
+            self.menu_shown = False
+            self.menu.poVpdown()
+
+    @classmethod
+    def main(cls):
+        gtk.main()
+
+    def quit(self, _):
+        gtk.main_quit()
+
+    def show_about_dialog(self, widget):
+        about_dialog = gtk.AboutDialog()
+        about_dialog.set_destroy_with_parent(True)
+        about_dialog.set_name("Parrot Zik Tray")
+        about_dialog.set_version("0.3")
+        about_dialog.set_authors(["Dmitry Moiseev m0sia@m0sia.ru"])
+        about_dialog.run()
+        about_dialog.destroy()
+
+
+class LinuxAppIndicator(LinuxIndicator):
+    def __init__(self, icon, menu):
+        import appindicator
+        self.icon_directory = os.path.join('/', 'usr', 'share', 'icons', 'zik')
+        if not os.path.isdir(self.icon_directory):
+            self.icon_directory = os.path.join('share', 'icons', 'zik')
+        statusicon = appindicator.Indicator(
+            "new-parrotzik-indicator", "indicator-messages",
+            appindicator.CATEGORY_APPLICATION_STATUS)
+        statusicon.set_status(appindicator.STATUS_ACTIVE)
+        statusicon.set_icon_theme_path(self.icon_directory)
+        statusicon.set_menu(menu.gtk_menu)
+        super(LinuxIndicator, self).__init__(icon, menu, statusicon)
+
+    def setIcon(self, name):
+        self.statusicon.set_icon(name)
+
+
+
+class LinuxGtkIndicator(LinuxIndicator):
+    def __init__(self, icon, menu):
+        self.icon_directory = os.path.join(
+            '/usr', 'share', 'icons/')
+        self.menu_shown = False
+        statusicon = gtk.StatusIcon()
+        statusicon.connect("popup-menu", self.gtk_right_click_event)
+        statusicon.set_tooltip("Parrot Zik")
+        super(LinuxIndicator, self).__init__(icon, menu, statusicon)
+
+    def setIcon(self, name):
+        self.statusicon.set_from_file(self.icon_directory + name + '.png')
+
diff --git a/parrot_zik/indicator/mac.py b/parrot_zik/indicator/mac.py
new file mode 100644
index 0000000..ceeacb0
--- /dev/null
+++ b/parrot_zik/indicator/mac.py
@@ -0,0 +1,70 @@
+import os
+import sys
+
+from Foundation import *
+from AppKit import *
+from PyObjCTools import AppHelper
+
+from parrot_zik.indicator.base import BaseIndicator
+from parrot_zik.indicator.base import MenuItemBase
+from parrot_zik.status_app_mac import StatusApp
+
+
+class DarwinIndicator(BaseIndicator):
+    def __init__(self, icon, menu):
+        self.icon_directory = os.path.join(
+            os.path.dirname(os.path.realpath(sys.argv[0])), 'share', 'icons', 'zik')
+        statusicon = StatusApp.sharedApplication()
+        statusicon.initMenu(menu)
+        super(DarwinIndicator, self).__init__(icon, menu, statusicon)
+
+    def setIcon(self, name):
+        self.statusicon.setIcon(name, self.icon_directory)
+
+    @classmethod
+    def main(cls):
+        AppHelper.runEventLoop()
+
+    def show_about_dialog(self, widget):
+        pass
+
+    def quit(self, _):
+        pass
+
+
+class NSMenu(object):
+    def __init__(self):
+        self.actions = {}
+        self.menubarMenu = NSMenu.alloc().init()
+        self.menubarMenu.setAutoenablesItems_(False)
+
+    def append(self, menu_item):
+        self.actions[menu_item.title] = menu_item.action
+        self.menubarMenu.addItem_(menu_item.nsmenu_item)
+
+    def reposition(self):
+        #  TODO
+        pass
+
+
+class NSMenuItem(MenuItemBase):
+    def __init__(self, name, action, sensitive=True, checkitem=False, visible=True):
+        self.title = name
+        self.action = action
+        nsmenu_item = (
+            NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(
+                name, 'clicked:', ''))
+        super(NSMenuItem, self).__init__(nsmenu_item, sensitive, visible)
+
+    def set_sensitive(self, option):
+        self.base_item.setEnabled_(option)
+
+    def set_active(self, option):
+        self.base_item.setState_(option)
+
+    def get_active(self):
+        return self.base_item.state
+
+    def set_label(self, option):
+        self.title = option
+        self.base_item.setTitle_(option)
diff --git a/parrot_zik/indicator/windows.py b/parrot_zik/indicator/windows.py
new file mode 100644
index 0000000..f10c91a
--- /dev/null
+++ b/parrot_zik/indicator/windows.py
@@ -0,0 +1,47 @@
+import sys
+import tempfile
+import gtk
+import os
+
+from parrot_zik.indicator.base import BaseIndicator
+
+
+class WindowsIndicator(BaseIndicator):
+    def __init__(self, icon, menu):
+        self.icon_directory = os.path.join(
+            os.path.dirname(os.path.realpath(sys.argv[0])), 'share', 'icons', 'zik')
+        self.menu_shown = False
+        sys.stdout = open(os.path.join(tempfile.gettempdir(), "zik_tray_stdout.log", "w"))
+        sys.stderr = open(os.path.join(tempfile.gettempdir(), "zik_tray_stderr.log", "w"))
+        statusicon = gtk.StatusIcon()
+        statusicon.connect("popup-menu", self.gtk_right_click_event)
+        statusicon.set_tooltip("Parrot Zik")
+        super(WindowsIndicator, self).__init__(icon, menu, statusicon)
+
+    def gtk_right_click_event(self, icon, button, time):
+        if not self.menu_shown:
+            self.menu_shown = True
+            self.menu.popup(None, None, gtk.status_icon_position_menu,
+                            button, time, self.statusicon)
+        else:
+            self.menu_shown = False
+            self.menu.poVpdown()
+
+    def setIcon(self, name):
+        self.statusicon.set_from_file(self.icon_directory + name + '.png')
+
+    @classmethod
+    def main(cls):
+        gtk.main()
+
+    def quit(self, _):
+        gtk.main_quit()
+
+    def show_about_dialog(self, widget):
+        about_dialog = gtk.AboutDialog()
+        about_dialog.set_destroy_with_parent(True)
+        about_dialog.set_name("Parrot Zik Tray")
+        about_dialog.set_version("0.3")
+        about_dialog.set_authors(["Dmitry Moiseev m0sia@m0sia.ru"])
+        about_dialog.run()
+        about_dialog.destroy()
diff --git a/parrot_zik/interface/__init__.py b/parrot_zik/interface/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/parrot_zik/interface/__init__.py
diff --git a/parrot_zik/interface/base.py b/parrot_zik/interface/base.py
new file mode 100644
index 0000000..90caa02
--- /dev/null
+++ b/parrot_zik/interface/base.py
@@ -0,0 +1,95 @@
+from parrot_zik import resource_manager
+from parrot_zik.indicator import Menu
+from parrot_zik.indicator import MenuItem
+from parrot_zik.model.base import BatteryStates
+
+RECONNECT_FREQUENCY = 5000
+
+
+class ParrotZikBaseInterface(object):
+    def __init__(self, indicator):
+        self.indicator = indicator
+        self.parrot = None
+        self.battery_level = MenuItem("Battery Level:", None, sensitive=False,
+                                      visible=False)
+        self.battery_state = MenuItem("Battery State:", None, sensitive=False,
+                                      visible=False)
+        self.firmware_version = MenuItem("Firmware Version:", None,
+                                         sensitive=False, visible=False)
+        self.settings = MenuItem("Settings", None, visible=False)
+        self.settings_submenu = Menu()
+        self.settings.set_submenu(self.settings_submenu)
+
+        self.auto_connection = MenuItem("Auto Connection", self.toggle_auto_connection,
+                                        checkitem=True)
+        self.settings_submenu.append(self.auto_connection)
+
+        self.indicator.menu.append(self.battery_level)
+        self.indicator.menu.append(self.battery_state)
+        self.indicator.menu.append(self.firmware_version)
+        self.indicator.menu.append(self.settings)
+
+    def activate(self, manager):
+        self.parrot = self.parrot_class(manager)
+        self.read_battery()
+        self.indicator.info("Connected to: " + self.parrot.friendly_name)
+        self.firmware_version.set_label(
+            "Firmware version: " + self.parrot.version)
+        self.auto_connection.set_active(self.parrot.auto_connect)
+        self.battery_level.show()
+        self.battery_state.show()
+        self.firmware_version.show()
+        self.settings.show()
+        self.indicator.active_interface = self
+
+    @property
+    def parrot_class(self):
+        raise NotImplementedError
+
+    def deactivate(self):
+        self.parrot = None
+        self.battery_level.hide()
+        self.battery_state.hide()
+        self.firmware_version.hide()
+        self.settings.hide()
+        self.indicator.menu.reposition()
+        self.indicator.active_interface = None
+        self.indicator.setIcon("zik-audio-headset")
+        self.indicator.info('Lost Connection')
+        self.indicator.reconnect.start(self.indicator, RECONNECT_FREQUENCY)
+
+    def toggle_auto_connection(self, widget):
+        try:
+            self.parrot.auto_connect = self.auto_connection.get_active()
+            self.auto_connection.set_active(self.parrot.auto_connect)
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def refresh(self):
+        self.read_battery()
+
+    def read_battery(self):
+        try:
+            self.parrot.refresh_battery()
+            battery_level = self.parrot.battery_level
+            battery_state = self.parrot.battery_state
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+        else:
+            if battery_state == BatteryStates.CHARGING:
+                self.indicator.setIcon("zik-battery-charging")
+            elif battery_level > 80:
+                self.indicator.setIcon("zik-battery-100")
+            elif battery_level > 60:
+                self.indicator.setIcon("zik-battery-080")
+            elif battery_level > 40:
+                self.indicator.setIcon("zik-battery-060")
+            elif battery_level > 20:
+                self.indicator.setIcon("zik-battery-040")
+            else:
+                self.indicator.setIcon("zik-battery-low")
+
+            self.battery_state.set_label(
+                "State: " + BatteryStates.representation[battery_state])
+            self.battery_level.set_label(
+                "Battery Level: " + str(battery_level))
diff --git a/parrot_zik/interface/version1.py b/parrot_zik/interface/version1.py
new file mode 100644
index 0000000..d0a1b2b
--- /dev/null
+++ b/parrot_zik/interface/version1.py
@@ -0,0 +1,63 @@
+from parrot_zik import resource_manager
+from parrot_zik.indicator import MenuItem
+from parrot_zik.interface.base import ParrotZikBaseInterface
+from parrot_zik.model.version1 import ParrotZikVersion1
+
+
+class ParrotZikVersion1Interface(ParrotZikBaseInterface):
+    parrot_class = ParrotZikVersion1
+
+    def __init__(self, indicator):
+        super(ParrotZikVersion1Interface, self).__init__(indicator)
+        self.noise_cancelation = MenuItem(
+            "Noise Cancellation", self.toggle_noise_cancelation,
+            checkitem=True, visible=False)
+        self.lou_reed_mode = MenuItem("Lou Reed Mode", self.toggle_lou_reed_mode,
+                                      checkitem=True, visible=False)
+        self.concert_hall_mode = MenuItem(
+            "Concert Hall Mode", self.toggle_parrot_concert_hall,
+            checkitem=True, visible=False)
+        self.indicator.menu.append(self.noise_cancelation)
+        self.indicator.menu.append(self.lou_reed_mode)
+        self.indicator.menu.append(self.concert_hall_mode)
+
+    def activate(self, manager):
+        super(ParrotZikVersion1Interface, self).activate(manager)
+        self.noise_cancelation.set_active(self.parrot.cancel_noise)
+        self.lou_reed_mode.set_active(self.parrot.lou_reed_mode)
+        self.concert_hall_mode.set_active(self.parrot.concert_hall)
+
+        self.noise_cancelation.show()
+        self.lou_reed_mode.show()
+        self.concert_hall_mode.show()
+        self.indicator.menu.reposition()
+
+    def deactivate(self):
+        self.noise_cancelation.hide()
+        self.lou_reed_mode.hide()
+        self.concert_hall_mode.hide()
+        super(ParrotZikVersion1Interface, self).deactivate()
+
+    def toggle_noise_cancelation(self, widget):
+        try:
+            self.parrot.cancel_noise = self.noise_cancelation.get_active()
+            self.noise_cancelation.set_active(self.parrot.cancel_noise)
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def toggle_lou_reed_mode(self, widget):
+        try:
+            self.parrot.lou_reed_mode = self.lou_reed_mode.get_active()
+            self.lou_reed_mode.set_active(self.parrot.lou_reed_mode)
+            self.concert_hall_mode.set_active(self.parrot.concert_hall)
+            self.concert_hall_mode.set_sensitive(
+                not self.lou_reed_mode.get_active())
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def toggle_parrot_concert_hall(self, widget):
+        try:
+            self.parrot.concert_hall = self.concert_hall_mode.get_active()
+            self.concert_hall_mode.set_active(self.parrot.concert_hall)
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
diff --git a/parrot_zik/interface/version2.py b/parrot_zik/interface/version2.py
new file mode 100644
index 0000000..e6076ed
--- /dev/null
+++ b/parrot_zik/interface/version2.py
@@ -0,0 +1,239 @@
+import functools
+
+from parrot_zik import resource_manager
+from parrot_zik.indicator import MenuItem, Menu
+from parrot_zik.interface.base import ParrotZikBaseInterface
+from parrot_zik.model.version2 import ParrotZikVersion2
+from parrot_zik.model.version2 import NoiseControlTypes
+from parrot_zik.model.version2 import Rooms
+
+
+class ParrotZikVersion2Interface(ParrotZikBaseInterface):
+    parrot_class = ParrotZikVersion2
+
+    def __init__(self, indicator):
+        self.room_dirty = False
+        self.angle_dirty = False
+        self.noise_cancelation_dirty = False
+        super(ParrotZikVersion2Interface, self).__init__(indicator)
+        self.noise_cancelation = MenuItem("Noise Control", None, visible=False)
+        self.noise_cancelation_submenu = Menu()
+        self.noise_cancelation.set_submenu(self.noise_cancelation_submenu)
+
+        self.noise_control_cancelation_max = MenuItem(
+            "Max Calcelation", functools.partial(
+                self.toggle_noise_cancelation,
+                NoiseControlTypes.NOISE_CONTROL_MAX), checkitem=True)
+        self.noise_control_cancelation_on = MenuItem(
+            "Normal Cancelation", functools.partial(
+                self.toggle_noise_cancelation,
+                NoiseControlTypes.NOISE_CONTROL_ON), checkitem=True)
+        self.noise_control_off = MenuItem(
+            "Off", functools.partial(
+                self.toggle_noise_cancelation,
+                NoiseControlTypes.NOISE_CONTROL_OFF), checkitem=True)
+        self.noise_control_street_mode = MenuItem(
+            "Street Mode", functools.partial(
+                self.toggle_noise_cancelation,
+                NoiseControlTypes.STREET_MODE), checkitem=True)
+        self.noise_control_street_mode_max = MenuItem(
+            "Street Mode Max", functools.partial(
+                self.toggle_noise_cancelation,
+                NoiseControlTypes.STREET_MODE_MAX), checkitem=True)
+        self.noise_cancelation_submenu.append(self.noise_control_cancelation_max)
+        self.noise_cancelation_submenu.append(self.noise_control_cancelation_on)
+        self.noise_cancelation_submenu.append(self.noise_control_off)
+        self.noise_cancelation_submenu.append(self.noise_control_street_mode)
+        self.noise_cancelation_submenu.append(self.noise_control_street_mode_max)
+
+        self.room_sound_effect = MenuItem(
+            "Room Sound Effect", None, visible=False)
+        self.room_sound_effect_submenu = Menu()
+        self.room_sound_effect.set_submenu(self.room_sound_effect_submenu)
+
+        self.room_sound_effect_enabled = MenuItem(
+            "Enabled", self.toggle_room_sound_effect, checkitem=True)
+        self.rooms = MenuItem("Rooms", None, checkitem=False)
+        self.angle = MenuItem("Angle", None, checkitem=False)
+        self.room_sound_effect_submenu.append(self.room_sound_effect_enabled)
+        self.room_sound_effect_submenu.append(self.rooms)
+        self.room_sound_effect_submenu.append(self.angle)
+
+        self.rooms_submenu = Menu()
+        self.rooms.set_submenu(self.rooms_submenu)
+
+        self.concert_hall_mode = MenuItem(
+            "Concert Hall", functools.partial(self.toggle_room, Rooms.CONCERT_HALL), checkitem=True)
+        self.jazz_mode = MenuItem(
+            "Jazz Club", functools.partial(self.toggle_room, Rooms.JAZZ_CLUB), checkitem=True)
+        self.living_mode = MenuItem(
+            "Living Room", functools.partial(self.toggle_room, Rooms.LIVING_ROOM), checkitem=True)
+        self.silent_mode = MenuItem(
+            "Silent Room", functools.partial(self.toggle_room, Rooms.SILENT_ROOM), checkitem=True)
+        self.rooms_submenu.append(self.concert_hall_mode)
+        self.rooms_submenu.append(self.jazz_mode)
+        self.rooms_submenu.append(self.living_mode)
+        self.rooms_submenu.append(self.silent_mode)
+
+        self.angle_submenu = Menu()
+        self.angle.set_submenu(self.angle_submenu)
+        self.angle_30 = MenuItem(
+            "30", functools.partial(self.toggle_angle, 30), checkitem=True)
+        self.angle_60 = MenuItem(
+            "60", functools.partial(self.toggle_angle, 60), checkitem=True)
+        self.angle_90 = MenuItem(
+            "90", functools.partial(self.toggle_angle, 90), checkitem=True)
+        self.angle_120 = MenuItem(
+            "120", functools.partial(self.toggle_angle, 120), checkitem=True)
+        self.angle_150 = MenuItem(
+            "150", functools.partial(self.toggle_angle, 150), checkitem=True)
+        self.angle_180 = MenuItem(
+            "180", functools.partial(self.toggle_angle, 180), checkitem=True)
+        self.angle_submenu.append(self.angle_30)
+        self.angle_submenu.append(self.angle_60)
+        self.angle_submenu.append(self.angle_90)
+        self.angle_submenu.append(self.angle_120)
+        self.angle_submenu.append(self.angle_150)
+        self.angle_submenu.append(self.angle_180)
+
+        self.flight_mode = MenuItem("Flight Mode", self.toggle_flight_mode,
+                                    checkitem=True, visible=False)
+
+        self.head_detection = MenuItem("Head Detection", self.toggle_head_detection, checkitem=True)
+        self.settings_submenu.append(self.head_detection)
+
+        self.indicator.menu.append(self.room_sound_effect)
+        self.indicator.menu.append(self.noise_cancelation)
+        self.indicator.menu.append(self.flight_mode)
+
+    def activate(self, manager):
+        super(ParrotZikVersion2Interface, self).activate(manager)
+        self._read_noise_cancelation()
+        self.flight_mode.set_active(self.parrot.flight_mode)
+        self._read_sound_effect_room()
+        self._read_sound_effect_angle()
+        self.head_detection.set_active(self.parrot.head_detection)
+
+        sound_effect = self.parrot.sound_effect
+
+        self.room_sound_effect_enabled.set_active(sound_effect)
+        self.concert_hall_mode.set_sensitive(sound_effect)
+        self.jazz_mode.set_sensitive(sound_effect)
+        self.living_mode.set_sensitive(sound_effect)
+        self.silent_mode.set_sensitive(sound_effect)
+
+        self.angle_30.set_sensitive(sound_effect)
+        self.angle_60.set_sensitive(sound_effect)
+        self.angle_90.set_sensitive(sound_effect)
+        self.angle_120.set_sensitive(sound_effect)
+        self.angle_150.set_sensitive(sound_effect)
+        self.angle_180.set_sensitive(sound_effect)
+
+        self.noise_cancelation.show()
+        self.flight_mode.show()
+        self.room_sound_effect.show()
+        self.indicator.menu.reposition()
+
+    def deactivate(self):
+        self.noise_cancelation.hide()
+        self.flight_mode.hide()
+        self.room_sound_effect.hide()
+        super(ParrotZikVersion2Interface, self).deactivate()
+
+    def toggle_flight_mode(self, widget):
+        try:
+            self.parrot.flight_mode = self.flight_mode.get_active()
+            self.flight_mode.set_active(self.parrot.flight_mode)
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def toggle_room(self, room, widget):
+        try:
+            if not self.room_dirty:
+                self.parrot.room = room
+                self.room_dirty = True
+                self._read_sound_effect_room()
+                self.room_dirty = False
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def _read_sound_effect_room(self):
+        active_room = self.parrot.room
+        room_to_menuitem_map = (
+            (Rooms.CONCERT_HALL, self.concert_hall_mode),
+            (Rooms.JAZZ_CLUB, self.jazz_mode),
+            (Rooms.LIVING_ROOM, self.living_mode),
+            (Rooms.SILENT_ROOM, self.silent_mode),
+        )
+        for room, menu_item in room_to_menuitem_map:
+            menu_item.set_active(room == active_room)
+
+    def toggle_room_sound_effect(self, widget):
+        try:
+            self.parrot.sound_effect = self.room_sound_effect_enabled.get_active()
+            sound_effect = self.parrot.sound_effect
+            self.room_sound_effect_enabled.set_active(sound_effect)
+            self.concert_hall_mode.set_sensitive(sound_effect)
+            self.jazz_mode.set_sensitive(sound_effect)
+            self.living_mode.set_sensitive(sound_effect)
+            self.silent_mode.set_sensitive(sound_effect)
+            self.angle_30.set_sensitive(sound_effect)
+            self.angle_60.set_sensitive(sound_effect)
+            self.angle_90.set_sensitive(sound_effect)
+            self.angle_120.set_sensitive(sound_effect)
+            self.angle_150.set_sensitive(sound_effect)
+            self.angle_180.set_sensitive(sound_effect)
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def toggle_angle(self, angle, widget):
+        try:
+            if not self.angle_dirty:
+                self.parrot.angle = angle
+                self.angle_dirty = True
+                self._read_sound_effect_angle()
+                self.angle_dirty = False
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def _read_sound_effect_angle(self):
+        active_angle = self.parrot.angle
+        angle_to_menuitem_map = (
+            (30, self.angle_30),
+            (60, self.angle_60),
+            (90, self.angle_90),
+            (120, self.angle_120),
+            (150, self.angle_150),
+            (180, self.angle_180),
+        )
+        for angle, menu_item in angle_to_menuitem_map:
+            menu_item.set_active(angle == active_angle)
+
+    def toggle_noise_cancelation(self, noise_calcelation, widget):
+        try:
+            if not self.noise_cancelation_dirty:
+                self.parrot.noise_control = noise_calcelation
+                self.noise_cancelation_dirty = True
+                self._read_noise_cancelation()
+                self.noise_cancelation_dirty = False
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
+
+    def _read_noise_cancelation(self):
+        active_noise_control = self.parrot.noise_control
+        noise_control_to_menuitem_map = (
+            (NoiseControlTypes.NOISE_CONTROL_MAX, self.noise_control_cancelation_max),
+            (NoiseControlTypes.NOISE_CONTROL_ON, self.noise_control_cancelation_on),
+            (NoiseControlTypes.NOISE_CONTROL_OFF, self.noise_control_off),
+            (NoiseControlTypes.STREET_MODE, self.noise_control_street_mode),
+            (NoiseControlTypes.STREET_MODE_MAX, self.noise_control_street_mode_max),
+        )
+        for noise_control, menu_item in noise_control_to_menuitem_map:
+            menu_item.set_active(active_noise_control == noise_control)
+
+    def toggle_head_detection(self, widget):
+        try:
+            self.parrot.head_detection = self.head_detection.get_active()
+            self.head_detection.set_active(self.parrot.head_detection)
+        except resource_manager.DeviceDisconnected:
+            self.deactivate()
diff --git a/parrot_zik/message.py b/parrot_zik/message.py
new file mode 100644
index 0000000..214b6f9
--- /dev/null
+++ b/parrot_zik/message.py
@@ -0,0 +1,30 @@
+class Message:
+    def __init__(self, resource, method, arg=None):
+        self.method = method
+        self.resource = resource
+        self.arg = arg
+
+    def __str__(self):
+        return str(self.request)
+
+    @property
+    def request(self):
+        message = bytearray()
+        message.extend(self.header)
+        message.extend(bytearray(self.request_string))
+        return message
+
+    @property
+    def header(self):
+        header = bytearray([0])
+        header.append(len(self.request_string) + 3)
+        header.append("\x80")
+        return header
+
+    @property
+    def request_string(self):
+        if self.method == 'set':
+            return 'SET {}/{}?arg={}'.format(self.resource, self.method,
+                                             str(self.arg).lower())
+        else:
+            return 'GET {}/{}'.format(self.resource, self.method)
diff --git a/parrot_zik/model/__init__.py b/parrot_zik/model/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/parrot_zik/model/__init__.py
diff --git a/parrot_zik/model/base.py b/parrot_zik/model/base.py
new file mode 100644
index 0000000..fdacde0
--- /dev/null
+++ b/parrot_zik/model/base.py
@@ -0,0 +1,60 @@
+class ParrotZikBase(object):
+    def __init__(self, resource_manager):
+        self.resource_manager = resource_manager
+
+    @property
+    def version(self):
+        return self.resource_manager.api_version
+
+    def refresh_battery(self):
+        self.resource_manager.fetch('/api/system/battery')
+
+    @property
+    def battery_state(self):
+        answer = self.resource_manager.get("/api/system/battery")
+        return answer.system.battery["state"]
+
+    def get_battery_level(self, field_name):
+        answer = self.resource_manager.get("/api/system/battery")
+        return int(answer.system.battery[field_name] or 0)
+
+    @property
+    def friendly_name(self):
+        answer = self.resource_manager.get("/api/bluetooth/friendlyname")
+        return answer.bluetooth["friendlyname"]
+
+    @property
+    def auto_connect(self):
+        answer = self.resource_manager.get("/api/system/auto_connection/enabled")
+        return self._result_to_bool(
+            answer.system.auto_connection["enabled"])
+
+    @auto_connect.setter
+    def auto_connect(self, arg):
+        self.resource_manager.set("/api/system/auto_connection/enabled", arg)
+
+    @property
+    def anc_phone_mode(self):
+        answer = self.resource_manager.get("/api/system/anc_phone_mode/enabled")
+        return self._result_to_bool(
+            answer.system.anc_phone_mode["enabled"])
+
+    def _result_to_bool(self, result):
+        if result == "true":
+            return True
+        elif result == "false":
+            return False
+        elif result == "invalid_on":
+            return True
+        else:
+            raise AssertionError(result)
+
+class BatteryStates:
+    CHARGED = 'charged'
+    IN_USE = 'in_use'
+    CHARGING = 'charging'
+    representation = {
+        CHARGED: 'Charged',
+        IN_USE: 'In Use',
+        CHARGING: 'Charging',
+    }
diff --git a/parrot_zik/model/version1.py b/parrot_zik/model/version1.py
new file mode 100644
index 0000000..324cc9f
--- /dev/null
+++ b/parrot_zik/model/version1.py
@@ -0,0 +1,48 @@
+from parrot_zik.model.base import ParrotZikBase
+from parrot_zik.resource_manager import Version1ResourceManager
+
+
+class ParrotZikVersion1(ParrotZikBase):
+    def __init__(self, resource_manager):
+        super(ParrotZikVersion1, self).__init__(
+            resource_manager.get_resource_manager(
+                Version1ResourceManager))
+
+    @property
+    def version(self):
+        answer = self.resource_manager.get('/api/software/version')
+        return answer.software['version']
+
+    @property
+    def battery_level(self):
+        return int(self.get_battery_level('level'))
+
+    @property
+    def lou_reed_mode(self):
+        answer = self.resource_manager.get("/api/audio/specific_mode/enabled")
+        return self._result_to_bool(
+            answer.audio.specific_mode["enabled"])
+
+    @lou_reed_mode.setter
+    def lou_reed_mode(self, arg):
+        self.resource_manager.set("/api/audio/specific_mode/enabled", arg)
+
+    @property
+    def concert_hall(self):
+        answer = self.resource_manager.get("/api/audio/sound_effect/enabled")
+        return self._result_to_bool(
+            answer.audio.sound_effect["enabled"])
+
+    @concert_hall.setter
+    def concert_hall(self, arg):
+        self.resource_manager.set("/api/audio/sound_effect/enabled", arg)
+
+    @property
+    def cancel_noise(self):
+        answer = self.resource_manager.get("/api/audio/noise_cancellation/enabled")
+        return self._result_to_bool(
+            answer.audio.noise_cancellation["enabled"])
+
+    @cancel_noise.setter
+    def cancel_noise(self, arg):
+        self.resource_manager.set("/api/audio/noise_cancellation/enabled", arg)
diff --git a/parrot_zik/model/version2.py b/parrot_zik/model/version2.py
new file mode 100644
index 0000000..0cbdc1a
--- /dev/null
+++ b/parrot_zik/model/version2.py
@@ -0,0 +1,131 @@
+from parrot_zik.model.base import ParrotZikBase
+from parrot_zik.resource_manager import Version2ResourceManager
+
+
+class ParrotZikVersion2(ParrotZikBase):
+    def __init__(self, resource_manager):
+        super(ParrotZikVersion2, self).__init__(
+            resource_manager.get_resource_manager(
+                Version2ResourceManager))
+
+    @property
+    def version(self):
+        answer = self.resource_manager.get('/api/software/version')
+        return answer.software['sip6']
+
+    @property
+    def battery_level(self):
+        return self.get_battery_level('percent')
+
+    @property
+    def flight_mode(self):
+        answer = self.resource_manager.get('/api/flight_mode')
+        return self._result_to_bool(answer.flight_mode['enabled'])
+
+    @flight_mode.setter
+    def flight_mode(self, arg):
+        if arg:
+            self.resource_manager.toggle_on('/api/flight_mode')
+        else:
+            self.resource_manager.toggle_off('/api/flight_mode')
+
+    @property
+    def sound_effect(self):
+        answer = self.resource_manager.get('/api/audio/sound_effect/enabled')
+        return self._result_to_bool(answer.audio.sound_effect['enabled'])
+
+    @sound_effect.setter
+    def sound_effect(self, arg):
+        self.resource_manager.set('/api/audio/sound_effect/enabled', arg)
+
+    @property
+    def room(self):
+        answer = self.resource_manager.get('/api/audio/sound_effect/room_size')
+        return answer.audio.sound_effect['room_size']
+
+    @room.setter
+    def room(self, arg):
+        self.resource_manager.set('/api/audio/sound_effect/room_size', arg)
+
+    @property
+    def external_noise(self):
+        answer = self.resource_manager.get('/api/audio/noise')
+        return int(answer.audio.noise['external'])
+
+    @property
+    def internal_noise(self):
+        answer = self.resource_manager.get('/api/audio/noise')
+        return int(answer.audio.noise['internal'])
+
+    @property
+    def angle(self):
+        answer = self.resource_manager.get('/api/audio/sound_effect/angle')
+        return int(answer.audio.sound_effect['angle'])
+
+    @angle.setter
+    def angle(self, arg):
+        self.resource_manager.set('/api/audio/sound_effect/angle', arg)
+
+    @property
+    def noise_control(self):
+        answer = self.resource_manager.get('/api/audio/noise_control')
+        return NoiseControl.from_noise_control(answer.audio.noise_control)
+
+    @noise_control.setter
+    def noise_control(self, arg):
+        self.resource_manager.set('/api/audio/noise_control', arg)
+
+    @property
+    def noise_control_enabled(self):
+        answer = self.resource_manager.get('/api/audio/noise_control/enabled')
+        return self._result_to_bool(answer.audio.noise_control['enabled'])
+
+    @property
+    def head_detection(self):
+        answer = self.resource_manager.get('/api/system/head_detection/enabled')
+        return self._result_to_bool(answer.system.head_detection['enabled'])
+
+    @head_detection.setter
+    def head_detection(self, arg):
+        self.resource_manager.set('/api/system/head_detection/enabled', arg)
+
+
+class NoiseControl(object):
+    def __init__(self, type, value):
+        self.type = type
+        self.value = value
+
+    @classmethod
+    def from_noise_control(cls, noise_control):
+        return cls(noise_control['type'], int(noise_control['value']))
+
+    def __eq__(self, other):
+        return self.type == other.type and self.value == other.value
+
+    def __str__(self):
+        return '{}&value={}'.format(self.type, self.value)
+
+
+class NoiseControlTypes:
+    NOISE_CONTROL_MAX = NoiseControl('anc', 2)
+    NOISE_CONTROL_ON = NoiseControl('anc', 1)
+    NOISE_CONTROL_OFF = NoiseControl('off', 1)
+    STREET_MODE = NoiseControl('aoc', 1)
+    STREET_MODE_MAX = NoiseControl('aoc', 2)
+
+
+class Rooms:
+    CONCERT_HALL = 'concert'
+    JAZZ_CLUB = 'jazz'
+    LIVING_ROOM = 'living'
+    SILENT_ROOM = 'silent'
+    representation = {
+        CONCERT_HALL: 'Concert Hall',
+        JAZZ_CLUB: 'Jazz Club',
+        LIVING_ROOM: 'Living Room',
+        SILENT_ROOM: 'Silent Room',
+    }
+
+class SoundSource:
+    LINE_IN = 'line-in'
+    A2DP = 'a2dp'
diff --git a/parrot_zik/parrot_zik_tray.py b/parrot_zik/parrot_zik_tray.py
new file mode 100755
index 0000000..35931d7
--- /dev/null
+++ b/parrot_zik/parrot_zik_tray.py
@@ -0,0 +1,80 @@
+from parrot_zik.interface.version1 import ParrotZikVersion1Interface
+from parrot_zik.interface.version2 import ParrotZikVersion2Interface
+from parrot_zik import resource_manager
+from parrot_zik import bluetooth_paired_devices
+from parrot_zik.indicator import MenuItem
+from parrot_zik.indicator import Menu
+from parrot_zik.indicator import SysIndicator
+from parrot_zik.utils import repeat
+
+REFRESH_FREQUENCY = 30000
+RECONNECT_FREQUENCY = 5000
+
+
+
+class ParrotZikIndicator(SysIndicator):
+    def __init__(self):
+ 
+        self.menu = Menu()
+
+        self.info_item = MenuItem("Parrot Zik Not connected",
+                                  None, sensitive=False)
+        self.menu.append(self.info_item)
+
+        self.version_1_interface = ParrotZikVersion1Interface(self)
+        self.version_2_interface = ParrotZikVersion2Interface(self)
+        self.quit_item = MenuItem("Quit", self.quit, checkitem=True)
+        self.menu.append(self.quit_item)
+
+        SysIndicator.__init__(self, icon="zik-audio-headset", menu=self.menu)
+
+        self.active_interface = None
+
+    @repeat
+    def reconnect(self):
+        if self.active_interface:
+            self.reconnect.stop()
+        else:
+            self.info("Trying to connect")
+            try:
+                manager = bluetooth_paired_devices.connect()
+            except bluetooth_paired_devices.BluetoothIsNotOn:
+                self.info("Bluetooth is turned off")
+            except bluetooth_paired_devices.DeviceNotConnected:
+                self.info("Parrot Zik Not connected")
+            except bluetooth_paired_devices.ConnectionFailure:
+                self.info("Failed to connect")
+            else:
+                if manager.api_version.startswith('1'):
+                    interface = self.version_1_interface
+                else:
+                    interface = self.version_2_interface
+                try:
+                    interface.activate(manager)
+                except resource_manager.DeviceDisconnected:
+                    interface.deactivate()
+                else:
+                    self.autorefresh(self)
+                    self.autorefresh.start(self, REFRESH_FREQUENCY)
+                    self.reconnect.stop()
+
+    def info(self, message):
+        self.info_item.set_label(message)
+        print(message)
+
+    @repeat
+    def autorefresh(self):
+        if self.active_interface:
+            self.active_interface.refresh()
+        else:
+            self.reconnect.start(self, RECONNECT_FREQUENCY)
+            self.autorefresh.stop()
+
+    @classmethod
+    def main(cls):
+        try:
+            indicator = cls()
+            cls.reconnect.start(indicator, RECONNECT_FREQUENCY)
+            super(ParrotZikIndicator, cls).main()
+        except KeyboardInterrupt:
+            pass
diff --git a/parrot_zik/resource_manager.py b/parrot_zik/resource_manager.py
new file mode 100644
index 0000000..aa141cb
--- /dev/null
+++ b/parrot_zik/resource_manager.py
@@ -0,0 +1,177 @@
+import bluetooth
+from operator import itemgetter
+import sys
+
+from bs4 import BeautifulSoup
+
+from .message import Message
+
+
+class ResourceManagerBase(object):
+    resources = [
+    ]
+
+    def __init__(self, socket, resource_values=None):
+        self.sock = socket
+        self.resource_values = resource_values or {}
+
+    def get(self, resource):
+        try:
+            return self.resource_values[resource]
+        except KeyError:
+            return self.fetch(resource)
+
+    def fetch(self, resource):
+        result = self.send_message(self._create_message(resource, 'get'))
+        self.resource_values[resource] = result
+        return result
+
+    def toggle_on(self, resource):
+        self.send_message(self._create_message(resource, 'enable'))
+        self.fetch(resource)
+
+    def toggle_off(self, resource):
+        self.send_message(self._create_message(resource, 'disable'))
+        self.fetch(resource)
+
+    def set(self, resource, arg):
+        self.send_message(self._create_message(resource, 'set', arg))
+        self.fetch(resource)
+
+    def _create_message(self, resource, method, arg=None):
+        assert resource in self.resources, 'Unknown resource {}'.format(resource)
+        assert method in self.resources[resource], 'Unhandled method {} for {}'.format(method, resource)
+        return Message(resource, method, arg)
+
+    def send_message(self, message):
+        try:
+            self.sock.send(str(message))
+            return self.get_answer(message)
+        except bluetooth.btcommon.BluetoothError:
+            raise DeviceDisconnected
+
+    def get_answer(self, message):
+        data = self.receive_message()
+        notifications = []
+        while not data.answer:
+            if data.notify:
+                notifications.append(data.notify)
+            else:
+                raise AssertionError('Unknown response "{}" for {}'.format(
+                    data, message.request_string))
+            data = self.receive_message()
+        self.handle_notifications(notifications, message.resource)
+        return data.answer
+
+    def handle_notifications(self, notifications, resource):
+        paths = map(itemgetter('path'), notifications)
+        clean_paths = set(map(self._clean_path, paths))
+        for path in clean_paths:
+            if resource != path:
+                self.fetch(path)
+
+    def _clean_path(self, path):
+        return path.rsplit('/', 1)[0].encode('utf-8')
+
+    def receive_message(self):
+        if sys.platform == "darwin":
+            self.sock.recv(30)
+        else:
+            self.sock.recv(7)
+        return BeautifulSoup(self.sock.recv(1024))
+
+    def close(self):
+        self.sock.close()
+
+
+class GenericResourceManager(ResourceManagerBase):
+    resources = {
+        '/api/software/version': ['get'],
+    }
+
+    def __init__(self, sock):
+        super(GenericResourceManager, self).__init__(sock)
+        self.notifications = []
+
+    def handle_notification(self, notification):
+        self.notifications.append(notification)
+
+    def get_resource_manager(self, resource_manager_class):
+        resource_manager = resource_manager_class(self.sock, self.resource_values)
+        resource_manager.handle_notifications(self.notifications, '/api/software/version')
+        return resource_manager
+
+    @property
+    def api_version(self):
+        answer = self.get("/api/software/version")
+        try:
+            return answer.software["version"]
+        except KeyError:
+            return answer.software['sip6']
+
+
+class Version1ResourceManager(ResourceManagerBase):
+    resources = {
+        '/api/software/version': ['get'],
+        '/api/system/battery': ['get'],
+        '/api/bluetooth/friendlyname': ['get'],
+        '/api/system/auto_connection/enabled': ['get', 'set'],
+        '/api/system/anc_phone_mode/enabled': ['get', 'set'],
+        '/api/audio/specific_mode/enabled': ['get', 'set'],
+        '/api/audio/sound_effect/enabled': ['get', 'set'],
+        '/api/audio/noise_cancellation/enabled': ['get', 'set'],
+    }
+
+class Version2ResourceManager(ResourceManagerBase):
+    resources = {
+        '/api/account/username': ['get', 'set'],
+        '/api/appli_version': ['set'],
+        '/api/audio/counter': ['get'],
+        '/api/audio/equalizer/enabled': ['get', 'set'],
+        '/api/audio/equalizer/preset_id': ['set'],
+        '/api/audio/equalizer/preset_value': ['set'],
+        '/api/audio/noise_cancellation/enabled': ['get', 'set'],
+        '/api/audio/noise_control/enabled': ['get', 'set'],
+        '/api/audio/noise_control': ['get', 'set'],
+        '/api/audio/noise_control/phone_mode': ['get', 'set'],
+        '/api/audio/noise': ['get'],
+        '/api/audio/param_equalizer/value': ['set'],
+        '/api/audio/preset/bypass': ['get', 'set'],
+        '/api/audio/preset/': ['clear_all'],
+        '/api/audio/preset/counter': ['get'],
+        '/api/audio/preset/current': ['get'],
+        '/api/audio/preset': ['download', 'activate', 'save', 'remove', 'cancel_producer'],
+        '/api/audio/preset/synchro': ['start', 'stop'],
+        '/api/audio/smart_audio_tune': ['get', 'set'],
+        '/api/audio/sound_effect/angle': ['get', 'set'],
+        '/api/audio/sound_effect/enabled': ['get', 'set'],
+        '/api/audio/sound_effect': ['get'],
+        '/api/audio/sound_effect/room_size': ['get', 'set'],
+        '/api/audio/source': ['get'],
+        '/api/audio/specific_mode/enabled': ['get', 'set'],
+        '/api/audio/thumb_equalizer/value': ['get', 'set'],
+        '/api/audio/track/metadata': ['get', 'force'],
+        '/api/bluetooth/friendlyname': ['get', 'set'],
+        '/api/flight_mode': ['get', 'enable', 'disable'],
+        '/api/software/download_check_state': ['get'],
+        '/api/software/download_size': ['set'],
+        '/api/software/tts': ['get', 'enable', 'disable'],
+        '/api/software/version_checking': ['get'],
+        '/api/software/version': ['get'],
+        '/api/system/anc_phone_mode/enabled': ['get', 'set'],
+        '/api/system/auto_connection/enabled': ['get', 'set'],
+        '/api/system/auto_power_off': ['get', 'set'],
+        '/api/system/auto_power_off/presets_list': ['get'],
+        '/api/system/battery/forecast': ['get'],
+        '/api/system/battery': ['get'],
+        '/api/system/bt_address': ['get'],
+        '/api/system': ['calibrate'],
+        '/api/system/color': ['get'],
+        '/api/system/device_type': ['get'],
+        '/api/system/': ['factory_reset'],
+        '/api/system/head_detection/enabled': ['get', 'set'],
+        '/api/system/pi': ['get'],
+    }
+
+class DeviceDisconnected(Exception):
+    pass
diff --git a/parrot_zik/status_app_mac.py b/parrot_zik/status_app_mac.py
new file mode 100644
index 0000000..dccffe4
--- /dev/null
+++ b/parrot_zik/status_app_mac.py
@@ -0,0 +1,25 @@
+from Foundation import *
+from AppKit import *
+
+class StatusApp(NSApplication):
+
+    def initMenu(self, menu):
+        statusbar = NSStatusBar.systemStatusBar()
+        self.statusitem = statusbar.statusItemWithLength_(
+            NSVariableStatusItemLength)
+
+        self.mymenu = menu
+        #add menu to statusitem
+        self.statusitem.setMenu_(menu.menubarMenu)
+        self.statusitem.setToolTip_('Parrot Zik Indicator')
+
+    def setIcon(self,icon,icon_directory):
+        self.icon = NSImage.alloc().initByReferencingFile_(
+            icon_directory + icon + '.png')
+        self.icon.setScalesWhenResized_(True)
+        self.icon.setSize_((20, 20))
+        self.statusitem.setImage_(self.icon)
+
+    def clicked_(self, notification):
+        self.mymenu.actions[notification._.title]()
+        NSLog('clicked!')
diff --git a/parrot_zik/utils.py b/parrot_zik/utils.py
new file mode 100644
index 0000000..86f52cd
--- /dev/null
+++ b/parrot_zik/utils.py
@@ -0,0 +1,32 @@
+import functools
+from threading import Lock
+
+import gtk
+
+
+class repeat(object):
+    def __init__(self, f):
+        self.f = f
+        self.id = None
+        self.lock = Lock()
+
+    def __call__(self, cls):
+        self.f(cls)
+
+    def start(self, cls, frequency):
+        self.lock.acquire()
+        if not self.id:
+            @functools.wraps(self.f)
+            def run():
+                self.f(cls)
+                return True
+            self.id = gtk.timeout_add(frequency, run)
+        self.lock.release()
+
+    def stop(self):
+        self.lock.acquire()
+        if self.id:
+            gtk.timeout_remove(self.id)
+            self.id = None
+        self.lock.release()
+