Merge pull request #12 from serathius/master

Rework and Zik 2.0 implementation.

27 files changed, 1474 insertions, 577 deletions

diff --git a/BluetoothPairedDevices.py b/BluetoothPairedDevices.py
deleted file mode 100644
index 6f9f673..0000000
--- a/BluetoothPairedDevices.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/python
-
-import sys 
-import re
-import os
-
-
-def ParrotZikMac():
-		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}')
-		if sys.platform == "linux2":
-			out = os.popen("bluez-test-device list").read()
-			res = p.findall(out)
-			if len(res)>0:
-				return res[0]
-
-		elif sys.platform == "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("-",":")
-			except:
-				pass	
-
-		elif sys.platform == "win32":
-			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]
-
-				except EnvironmentError:
-					pass
-
-if sys.platform == "darwin":
-	from binplist import binplist
-elif sys.platform == "win32":
-	import _winreg
\ No newline at end of file
diff --git a/ParrotProtocol.py b/ParrotProtocol.py
deleted file mode 100644
index 9324b8b..0000000
--- a/ParrotProtocol.py
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/usr/bin/env python
-
-def generateRequest(requestString):
-	message=bytearray()
-	message.extend(generateHeader(requestString))
-	message.extend(bytearray(requestString))
-	return message
-
-def generateHeader(requestString):
-	header = bytearray([0])
-	header.append(len(requestString)+3)
-	header.append("\x80")
-	return header
-
-def getRequest(apiString):
-	return generateRequest("GET "+apiString)
-
-def setRequest(apiString,args):
-	return generateRequest("SET "+apiString+"?arg="+args)
\ No newline at end of file
diff --git a/ParrotZik.py b/ParrotZik.py
deleted file mode 100644
index 8a2fca6..0000000
--- a/ParrotZik.py
+++ /dev/null
@@ -1,146 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-if sys.platform == "darwin":
-	import lightblue
-else:
-	import bluetooth
-
-import ParrotProtocol
-import struct
-from BeautifulSoup import BeautifulSoup
-
-class ParrotZik(object):
-	def __init__(self,addr=None):
-		uuid = "0ef0f502-f0ee-46c9-986c-54ed027807fb"
-
-
-		if sys.platform == "darwin":
-			service_matches = lightblue.findservices( name = "Parrot RFcomm service", addr = addr )
-		else:
-			service_matches = bluetooth.find_service( uuid = uuid, address = addr )		
-
-
-		if len(service_matches) == 0:
-		    print "Failed to find Parrot Zik RFCOMM service"
-		    self.sock =""
-		    return
-
-		if sys.platform == "darwin":
-			first_match = service_matches[0]
-			port = first_match[1]
-			name = first_match[2]
-			host = first_match[0]
-		else:
-			first_match = service_matches[0]
-			port = first_match["port"]
-			name = first_match["name"]
-			host = first_match["host"]
-
-		print "Connecting to \"%s\" on %s" % (name, host)
-
-		if sys.platform == "darwin":
-			self.sock=lightblue.socket()
-		else:
-			self.sock=bluetooth.BluetoothSocket( bluetooth.RFCOMM )
-
-		self.sock.connect((host, port))
-
-		self.sock.send('\x00\x03\x00')
-		data = self.sock.recv(1024)
-
-		self.BatteryLevel = 100
-		self.BatteryCharging = False
-		print "Connected"
-
-	def getBatteryState(self):
-		data = self.sendGetMessage("/api/system/battery/get")
-		return data.answer.system.battery["state"]
-
-	def getBatteryLevel(self):
-		data = self.sendGetMessage("/api/system/battery/get")	
-		try:
-			if data.answer.system.battery["level"] <> '':
-				self.BatteryLevel = data.answer.system.battery["level"]
-			if data.answer.system.battery["state"] == 'charging':
-				self.BatteryCharging = True
-			else:
-				self.BatteryCharging = False
-		except:
-			pass
-
-		try:
-			print "notification received" + data.notify["path"]
-		except:
-			pass
-
-		return self.BatteryLevel
-
-	def getVersion(self):
-		data = self.sendGetMessage("/api/software/version/get")
-		return data.answer.software["version"]	
-
-	def getFriendlyName(self):
-		data = self.sendGetMessage("/api/bluetooth/friendlyname/get")
-		return data.answer.bluetooth["friendlyname"]
-
-	def getAutoConnection(self):
-		data = self.sendGetMessage("/api/system/auto_connection/enabled/get")
-		return data.answer.system.auto_connection["enabled"]
-
-	def setAutoConnection(self,arg):
-		data = self.sendSetMessage("/api/system/auto_connection/enabled/set",arg)
-		return data
-
-	def getAncPhoneMode(self):
-		data = self.sendGetMessage("/api/system/anc_phone_mode/enabled/get")
-		return data.answer.system.anc_phone_mode["enabled"]
-
-	def getNoiseCancel(self):
-		data = self.sendGetMessage("/api/audio/noise_cancellation/enabled/get")
-		return data.answer.audio.noise_cancellation["enabled"]
-
-	def setNoiseCancel(self,arg):
-		data = self.sendSetMessage("/api/audio/noise_cancellation/enabled/set",arg)
-		return data
-
-	def getLouReedMode(self):
-		data = self.sendGetMessage("/api/audio/specific_mode/enabled/get")
-		return data.answer.audio.specific_mode["enabled"]
-
-	def setLouReedMode(self,arg):
-		data = self.sendSetMessage("/api/audio/specific_mode/enabled/set",arg)
-		return data
-
-	def getParrotConcertHall(self):
-		data = self.sendGetMessage("/api/audio/sound_effect/enabled/get")
-		return data.answer.audio.sound_effect["enabled"]
-
-	def setParrotConcertHall(self,arg):
-		data = self.sendSetMessage("/api/audio/sound_effect/enabled/set",arg)
-		return data
-
-	def sendGetMessage(self,message):
-		message = ParrotProtocol.getRequest(message)
-		return self.sendMessage(message)
-
-	def sendSetMessage(self,message,arg):
-		message = ParrotProtocol.setRequest(message,arg)
-		return self.sendMessage(message)
-
-	def sendMessage(self,message):
-		try:
-			self.sock.send(str(message))
-		except:
-			self.sock =""
-			return
-		if sys.platform == "darwin":
-			data = self.sock.recv(30)
-		else:
-			data = self.sock.recv(7)
-		data = self.sock.recv(1024)
-		data=BeautifulSoup(data)
-		return data
-
-	def Close(self):
-		self.sock.close()
\ No newline at end of file
diff --git a/ParrotZikTray b/ParrotZikTray
deleted file mode 100755
index d9bdbc1..0000000
--- a/ParrotZikTray
+++ /dev/null
@@ -1,174 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-import gtk
-import re
-import os
-import ParrotZik
-import BluetoothPairedDevices
-from SysIndicator import *
-
-UPDATE_FREQUENCY = 30 # seconds
-
-class ParrotZikIndicator(SysIndicator):
-    def __init__(self):
- 
-        self.menu = UniversalMenu()
-
-        self.info_item = MenuItem("Parrot Zik Not connected..",None,sensitive = False)  
-        self.menu.append(self.info_item)
-
-        self.battery_level = MenuItem("Battery Level:",None,sensitive = False)
-        self.menu.append(self.battery_level)
-
-        self.battery_state = MenuItem("Battery State:",None,sensitive = False) 
-        self.menu.append(self.battery_state)
-
-        self.firmware_version = MenuItem("Firmware Version:",None,sensitive = False)  
-        self.menu.append(self.firmware_version)
-
-        self.check = MenuItem("Noise Cancellation",self.toggleANC,sensitive = False, checkitem = True)
-        self.menu.append(self.check)
-
-        self.check2 = MenuItem("Auto Connection",self.toggleAuto,sensitive = False, checkitem = True)        
-        self.menu.append(self.check2)
-
-        self.check3 = MenuItem("Lou Reed Mode",self.toggleLouReedMode,sensitive = False, checkitem = True)
-        self.menu.append(self.check3)
-
-        self.check4 = MenuItem("Concert Hall Mode",self.toggleParrotConcertHall,sensitive = False, checkitem = True)
-        self.menu.append(self.check4)
-
-        self.quit = MenuItem("Quit",sys.exit,sensitive = True, checkitem = True)
-        self.menu.append(self.quit)
-
-        SysIndicator.__init__(self,icon = "zik-audio-headset",menu = self.menu)
-
-        self.connected=False
-        self.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}')
-
-    def EstablishConnection(self):
-        if self.connected:
-            if not self.parrot.sock:
-                print "Lost connection"
-                self.connected = False
-            else:
-                print "Connection already established"
-        else:
-            mac=BluetoothPairedDevices.ParrotZikMac()
-            if mac:
-                self.parrot = ParrotZik.ParrotZik(mac)
-                if not self.parrot.sock:
-                    print "Failed to connect to Parrot Zik %s" % mac
-                    return False
-
-                self.connected = True
-                self.name = self.parrot.getFriendlyName()
-                self.version = self.parrot.getVersion()
-
-                self.check.set_sensitive(True)
-                self.check2.set_sensitive(True)
-                self.check3.set_sensitive(True)
-                self.check4.set_sensitive(True)
-
-                if self.parrot.getNoiseCancel() == "true":
-                    self.check.set_active(True)
-                else:
-                    self.check.set_active(False)
-
-                if self.parrot.getAutoConnection() == "true":
-                    self.check2.set_active(True)
-                else:
-                    self.check2.set_active(False)
-
-                if self.parrot.getLouReedMode() == "true":
-                    self.check3.set_active(True)
-                else:
-                    self.check3.set_active(False)
-
-                if self.parrot.getParrotConcertHall() == "true":
-                    self.check4.set_active(True)
-                else:
-                    self.check4.set_active(False)
-
-                self.CheckBattery()
-        return True
-
-    def toggleANC(self,widget):
-        if self.connected:
-            if self.check.get_active():
-                self.parrot.setNoiseCancel("true")
-            else:
-                self.parrot.setNoiseCancel("false")
-
-    def toggleAuto(self,widget):
-        if self.connected:
-            if self.check2.get_active():
-                self.parrot.setAutoConnection("true")
-            else:
-                self.parrot.setAutoConnection("false")
-
-    def toggleLouReedMode(self,widget):
-        if self.connected:
-            if self.check3.get_active():
-                self.parrot.setLouReedMode("true")
-                self.check4.set_sensitive(False)
-            else:
-                self.parrot.setLouReedMode("false")      
-                self.check4.set_sensitive(True)
-            
-    def toggleParrotConcertHall(self,widget):
-        if self.connected:
-            if self.check4.get_active():
-                self.parrot.setParrotConcertHall("true")
-            else:
-                self.parrot.setParrotConcertHall("false")
-
-    def CheckBattery(self):
-        if self.connected:
-            print "Updating battery"
-            self.batteryLevel = int(self.parrot.getBatteryLevel())
-            
-            if self.parrot.BatteryCharging:
-                self.batteryLevel = "Charging"
-                self.setIcon("zik-battery-charging")
-                self.batteryLevel="Unknown"
-                self.batteryState="Charging"
-            elif self.batteryLevel>80:
-                self.setIcon("zik-battery-100")
-                self.batteryState="In Use"
-            elif self.batteryLevel>60:
-                self.setIcon("zik-battery-080")
-                self.batteryState="In Use"
-            elif self.batteryLevel>40:                
-                self.setIcon("zik-battery-060")
-                self.batteryState="In Use"
-            elif self.batteryLevel>20:
-                self.setIcon("zik-battery-040")
-                self.batteryState="In Use"
-            else:
-                self.setIcon("zik-battery-low")
-                self.batteryState="In Use"
-
-            self.info_item.set_label("Connected to: "+self.name)
-            self.firmware_version.set_label("Firmware version: "+self.version)
-            self.battery_state.set_label("State: "+self.batteryState)
-            self.battery_level.set_label("Battery Level: "+str(self.batteryLevel))
-        else:
-            self.setIcon("zik-audio-headset")
-            self.info_item.set_label("Parrot Zik Not connected..")
-            self.check.set_sensitive(False)
-            self.check2.set_sensitive(False)
-            self.check3.set_sensitive(False)
-            self.check4.set_sensitive(False)
-        return True
-
-    def main(self):
-        self.EstablishConnection()
-        gtk.timeout_add(UPDATE_FREQUENCY * 1000, self.EstablishConnection)
-        gtk.timeout_add(UPDATE_FREQUENCY * 1000, self.CheckBattery)
-        SysIndicator.main(self)   
-
-if __name__ == "__main__":
-    indicator = ParrotZikIndicator()
-    indicator.main()
\ No newline at end of file
diff --git a/SysIndicator.py b/SysIndicator.py
deleted file mode 100644
index 3c79286..0000000
--- a/SysIndicator.py
+++ /dev/null
@@ -1,155 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-import re
-import os
-import tempfile
-
-if sys.platform=="linux2" or sys.platform=="win32":
-    import gtk
-elif sys.platform=="darwin":
-    import objc
-    from Foundation import *
-    from AppKit import *
-    from PyObjCTools import AppHelper
-    from StatusAppMac import StatusApp
-
-
-class SysIndicator:
-    def __init__(self, icon,menu):
-        if sys.platform=="linux2":
-            self.menu = menu.gtk_menu
-            import appindicator
-            self.icon_directory = os.path.sep + 'usr' + os.path.sep+ 'share' + os.path.sep+'icons' + os.path.sep+'zik'+ os.path.sep
-            if not os.path.isdir(self.icon_directory):
-							self.icon_directory = os.path.dirname(sys.argv[0]) + os.path.sep + 'share' + os.path.sep+'icons' + os.path.sep+'zik'+ os.path.sep
-            self.statusicon = appindicator.Indicator("new-parrotzik-indicator",
-                                           "indicator-messages",
-                                           appindicator.CATEGORY_APPLICATION_STATUS)
-            self.statusicon.set_status(appindicator.STATUS_ACTIVE)
-            self.statusicon.set_icon_theme_path(self.icon_directory)
-            self.statusicon.set_menu(self.menu)          
-            
-        elif sys.platform=="win32":  
-            self.menu = menu.gtk_menu          
-            self.icon_directory = os.path.dirname(os.path.realpath(sys.argv[0])) + os.path.sep+ 'share' + os.path.sep+'icons' + os.path.sep+'zik'+ os.path.sep
-            self.statusicon = gtk.StatusIcon()            
-            self.statusicon.connect("popup-menu", self.gtk_right_click_event)
-            self.statusicon.set_tooltip("Parrot Zik")
-            self.menu_shown=False
-            sys.stdout = open(tempfile.gettempdir()+os.path.sep+"zik_tray_stdout.log", "w")
-            sys.stderr = open(tempfile.gettempdir()+os.path.sep+"zik_tray_stderr.log", "w")    
-
-        elif sys.platform=="darwin":
-            self.icon_directory = os.path.dirname(os.path.realpath(sys.argv[0])) + os.path.sep+ 'share' + os.path.sep+'icons' + os.path.sep+'zik'+ os.path.sep
-            self.statusicon = StatusApp.sharedApplication()
-            self.statusicon.initMenu(menu)
-        
-        self.setIcon(icon)
-
-    def setIcon(self, name):
-        if sys.platform=="linux2":
-            self.statusicon.set_icon(name)
-        elif sys.platform=="win32":
-            self.statusicon.set_from_file(self.icon_directory+name+'.png') 
-        elif sys.platform=="darwin":
-            self.statusicon.setIcon(name,self.icon_directory)
-
-    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.popdown()
-
-    def main(self):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            gtk.main()       
-        elif sys.platform=="darwin":
-            #self.statusicon.run()
-            AppHelper.runEventLoop()
-
-    def show_about_dialog(self, widget):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            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 UniversalMenu:
-    def __init__(self):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            self.gtk_menu = gtk.Menu()
-        elif sys.platform=="darwin":
-            self.actions = {}
-            self.menubarMenu = NSMenu.alloc().init()
-            self.menubarMenu.setAutoenablesItems_(False)
-            
-
-    def append(self,MenuItem):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            self.gtk_menu.append(MenuItem.gtk_item)
-        elif sys.platform=="darwin":
-            self.actions[MenuItem.title] = MenuItem.action
-            self.menubarMenu.addItem_(MenuItem.nsmenu_item)
-
-class MenuItem:
-    def __init__(self,name,action,sensitive = True, checkitem = False):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            if checkitem:
-                self.gtk_item=gtk.CheckMenuItem(name) 
-            else:
-                self.gtk_item=gtk.MenuItem(name) 
-            self.gtk_item.show()
-            if action:
-                self.gtk_item.connect("activate", action)
-
-        elif sys.platform=="darwin":
-            self.title = name
-            self.action = action
-            self.nsmenu_item = NSMenuItem.alloc().initWithTitle_action_keyEquivalent_(name, 'clicked:', '')
-
-        self.set_sensitive(sensitive)
-
-    def set_sensitive(self,option):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            return self.gtk_item.set_sensitive(option)
-        elif sys.platform=="darwin":
-            self.nsmenu_item.setEnabled_(option)
-
-    def set_active(self,option):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            return self.gtk_item.set_active(option)
-        elif sys.platform=="darwin":
-            self.nsmenu_item.setState_(option)
-
-    def get_active(self):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            return self.gtk_item.get_active()
-        elif sys.platform=="darwin":
-            print self.nsmenu_item.state
-            return self.nsmenu_item.state
-
-
-    def set_label(self,option):
-        if sys.platform=="linux2" or sys.platform=="win32":
-            return self.gtk_item.set_label(option)
-        elif sys.platform=="darwin":
-            self.title = option
-            self.nsmenu_item.setTitle_(option)
-            #self.rumps_item.title=option
-
-if __name__ == "__main__":
-
-    quit_item = MenuItem("Quit",sys.exit,True)     
-
-    menu = UniversalMenu()
-    menu.append(quit_item)
-
-    indicator = SysIndicator(icon = "zik-audio-headset",menu = menu)
-    indicator.main()
\ No newline at end of file
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/StatusAppMac.py b/parrot_zik/status_app_mac.py
index fc0bc64..dccffe4 100644
--- a/StatusAppMac.py
+++ b/parrot_zik/status_app_mac.py
@@ -1,13 +1,12 @@
-import objc
 from Foundation import *
 from AppKit import *
-from PyObjCTools import AppHelper
 
 class StatusApp(NSApplication):
 
-    def initMenu(self,menu):
+    def initMenu(self, menu):
         statusbar = NSStatusBar.systemStatusBar()
-        self.statusitem = statusbar.statusItemWithLength_(NSVariableStatusItemLength)
+        self.statusitem = statusbar.statusItemWithLength_(
+            NSVariableStatusItemLength)
 
         self.mymenu = menu
         #add menu to statusitem
@@ -15,11 +14,12 @@ class StatusApp(NSApplication):
         self.statusitem.setToolTip_('Parrot Zik Indicator')
 
     def setIcon(self,icon,icon_directory):
-        self.icon = NSImage.alloc().initByReferencingFile_(icon_directory+icon+'.png')
+        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!')
\ No newline at end of file
+        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()
+
diff --git a/setup.py b/setup.py
index ffdac88..01fa2c2 100644
--- a/setup.py
+++ b/setup.py
@@ -1,49 +1,53 @@
-from setuptools import setup

 import glob

 import sys

 

-if sys.platform=="win32":

-  import py2exe

-  from distutils.core import setup

+if sys.platform == "win32":

+    from distutils.core import setup

+else:

+    from setuptools import setup

 

 

 setup(

-    name = 'parrotziktray',

-    description = 'Parrot Zik Tray Indicator',

+    name='parrotziktray',

+    description='Parrot Zik Tray Indicator',

     author="Dmitry Moiseev",

     author_email="m0sia@m0sia.ru",

     maintainer_email="m0sia@m0sia.ru",

     url="https://github.com/m0sia/pyParrotZik",

     license="'GPLv2+'",

-    version = '0.3',

-

-    windows = [

-                  {

-                      'script': 'ParrotZikTray',

-                      'icon_resources': [(1, "./share/icons/zik/Headphone.ico")],

-                  }

-              ],

-

-    options = {

-                  'py2exe': {

-                      #'packages':'encodings',

-                      # Optionally omit gio, gtk.keysyms, and/or rsvg if you're not using them

-                      'includes': 'cairo, pango, pangocairo, atk, gobject, gio, gtk.keysyms, _winreg',

-                  }

-              },

+    version='0.3',

+

+    windows=[

+        {

+            'script': 'parrot_zik/parrot_zik_tray',

+            'icon_resources': [(1, "./share/icons/zik/Headphone.ico")],

+        }

+    ],

+

+    options={

+        'py2exe': {

+            #'packages':'encodings',

+            # Optionally omit gio, gtk.keysyms, and/or rsvg if you're not using them

+            'includes': 'cairo, pango, pangocairo, atk, gobject, gio, gtk.keysyms, _winreg',

+        }

+    },

    

     data_files=[

-            ("share/icons/zik", glob.glob("share/icons/zik/*.png"))

-                   # If using GTK+'s built in SVG support, uncomment these

-                   #os.path.join(gtk_base_path, '..', 'runtime', 'bin', 'gdk-pixbuf-query-loaders.exe'),

-                   #os.path.join(gtk_base_path, '..', 'runtime', 'bin', 'libxml2-2.dll'),

-               ],

+        ("share/icons/zik", glob.glob("share/icons/zik/*.png"))

+            # If using GTK+'s built in SVG support, uncomment these

+            #os.path.join(gtk_base_path, '..', 'runtime', 'bin', 'gdk-pixbuf-query-loaders.exe'),

+            #os.path.join(gtk_base_path, '..', 'runtime', 'bin', 'libxml2-2.dll'),

+    ],

 

     install_requires=[

-          'BeautifulSoup','bluetooth'

-      ],

-

-    py_modules=['ParrotZik','ParrotProtocol'],

-

-    scripts=["ParrotZikTray"]

+        'beautifulsoup4', 'pybluez'

+    ],

+

+    packages=['parrot_zik', 'parrot_zik.interface', 'parrot_zik.indicator', 'parrot_zik.model'],

+    entry_points={

+        'console_scripts': [

+            'parrot_zik_tray=parrot_zik.parrot_zik_tray:ParrotZikIndicator.main',

+        ]

+    },

+    include_package_data=True,

 )