class MusicPlayer():
VARIABLES = {}
ORDRES = {
"lecture": {
"action": ["put"],
"message_fr": ["lecture"],
},
"pause": {
"action": ["put"],
"message_fr": ["pause"],
},
"stop": {
"action": ["stop"],
"message_fr":
["musique", "vidéo", "épisode", "film", "stop", "arrête"],
},
"baisser_son": {
"action": ["put_down"],
"message_fr": ["le son", "le volume"],
"repete": ["encore", "plus"],
},
"monter_son": {
"action": ["turn_up"],
"message_fr": ["le son", "le volume"],
"repete": ["encore", "plus"],
},
"mute": {
"action": ["cut", "stop"],
"message_fr": ["le son", "le volume"],
}
}
list_players = {}
counter = 0
def __init__(self):
self.bus = Bus()
self.bus.subscribe('vocalOrdre', self.lanceVocalOrdre)
# Liste des musiques venant de Kodi
self.bus.subscribe('loadMusiquesDao', self.loadMusiques)
current_dir = os.path.dirname(__file__)
script = '../tmp'
directory_tmp = os.path.join(current_dir, script)
if not os.path.exists(directory_tmp):
os.makedirs(directory_tmp)
script = '../tmp/music'
directory_tmp = os.path.join(current_dir, script)
if not os.path.exists(directory_tmp):
os.makedirs(directory_tmp)
def lanceVocalOrdre(self, bus, key, obj):
groupe = obj['groupe']
if groupe != 'musicplayer':
return
ordre_name = obj['ordre']
origineIp = obj["origine"]
input_ = obj["input"]
try:
getattr(self, ordre_name)(input_, origineIp)
except Exception as e:
print("musicplayer => lanceVocalOrdre : " + e.__str__())
def launchMusic(self, input_, ipDestination):
self.manageMusic(ipDestination, "lance_music", "bureau")
def startMusic(self, args):
self.manageMusic('192.168.1.108', "lance_music", args[0])
def stopMusic(self, args):
self.manageMusic('192.168.1.108', "stop")
def pause(self, input_, ipDestination):
self.manageMusic(ipDestination, "pause")
def lecture(self, input_, ipDestination):
self.manageMusic(ipDestination, "lecture")
def stop(self, input_, ipDestination):
self.manageMusic(ipDestination, "stop")
def launchMute(self, input_, ipDestination):
pass
def baisser_son(self, input_, ipDestination):
pass
def loadMusiques(self, bus, key, obj):
# Chargement en liste de toutes les musiques
listMusiqueKodi = []
for artist in obj:
for album in obj[artist]:
for music in obj[artist][album]:
listMusiqueKodi.append(obj[artist][album][music])
self.listMusicKodi = listMusiqueKodi
def manageMusic(self, ipDestination, ordre, play_list="bureau"):
print("IP musique => " + str(ipDestination))
player = None
if ipDestination not in self.list_players:
listMusicToPlay = self.getMusicOfPlaylist(play_list)
nameThread = "music_tmp" + str(self.counter)
self.counter += 1
self.list_players[ipDestination] = player = PlayerMp3_seeking(
ipDestination, nameThread, listMusicToPlay)
player.setDaemon(True)
player.start()
else:
player = self.list_players[ipDestination]
if ordre == 'lance_musique':
player.on_play()
if ordre == 'stop':
player.on_stop()
del self.list_players[ipDestination]
if ordre == 'next':
player.on_next()
if ordre == 'previous':
player.on_foward()
if ordre == 'pause':
player.on_pause()
if ordre == 'lecture':
player.on_play()
def getMusicOfPlaylist(self, playlistName):
current_dir = os.path.dirname(__file__)
script = '../../resources/playlist_' + playlistName
playlistFile = os.path.join(current_dir, script)
f = open(playlistFile, 'r')
list_song = []
for line in f:
if '\n' in line:
line = line[:-1]
list_song.append(str(line))
# Match de ce qui vient de la playlist avec music kodi
listMusicPlayList = []
for music in self.listMusicKodi:
list_ = [ext in music.file for ext in list_song]
if any(list_):
index = list_.index(True)
music.setOrdre(index)
listMusicPlayList.append(music)
listMusicPlayList.sort(key=attrgetter('ordre'))
return listMusicPlayList
def coupeSon(self):
for player in self.list_players:
self.list_players[player].on_pause()
def repriseSon(self):
for player in self.list_players:
self.list_players[player].on_play()
class Kodi():
VARIABLES = {
'@name_serie': {},
'@name_film': {},
'@name_music': {},
'@name_playlist': {},
'@episode': 'Int',
'@saison': 'Int',
'@episod_id': 'Int',
'@film_id': 'Int'
}
ORDRES = {
"liste_film": {
"action": ["display", "show"],
"message_fr": ["liste film"],
"input": ["récent", "ordre alpha", "note", "date ajout"]
},
"liste_serie": {
"action": ["display", "show"],
"message_fr": ["liste série"],
"input": ["récent", "ordre alpha", "note", "date ajout"]
},
"liste_music": {
"action": ["display", "show"],
"message_fr": ["liste musique"],
"input": ["récent", "ordre alpha", "note", "date ajout"]
},
"lance_episode": {
"action": ["launch", "put"],
"message_fr": ["épisode"],
"input": [
"suivant de @name_serie",
"@episode de la saison @saison de @name_serie",
"de @name_serie saison @saison épisode @episode",
"de @name_serie numéro @episod_id",
"numéro @episod_id de @name_serie"
]
},
"lance_episode_2": {
"action": ["resume"],
"message_fr":
["la série", "épisode", "la suite", "la suite de la série"],
"input": ["de @name_serie"]
},
"lance_film": {
"action": ["launch", "put"],
"message_fr": ["film"],
"input": ["@name_film"]
},
"resume_film": {
"action": ["resume"],
"message_fr": ["film"],
"input": ["@name_film"],
},
"lance_music": {
"action": ["launch", "put"],
"message_fr": ["musique"],
"input": ["@name_music", "@name_playlist", "suivante"],
},
"lecture": {
"action": ["put"],
"message_fr": ["lecture"],
},
"pause": {
"action": ["put"],
"message_fr": ["pause"],
},
"stop": {
"action": ["stop"],
"message_fr":
["musique", "vidéo", "épisode", "film", "stop", "arrête"],
},
"baisser_son": {
"action": ["put_down"],
"message_fr": ["le son", "le volume"],
"repete": ["encore", "plus"],
},
"monter_son": {
"action": ["turn_up"],
"message_fr": ["le son", "le volume"],
"repete": ["encore", "plus"],
},
"mute": {
"action": ["cut", "stop"],
"message_fr": ["le son", "le volume"],
},
"scan": {
"action": ["put", "launch"],
"message_fr": ["scan"],
}
}
devices = []
emplacements = []
satelitesConnected = {}
listeMotsSerie = []
listeMotsNumero = []
def __init__(self, devicesService=None):
self.bus = Bus()
self.kodiDao = KodiDAO()
self.convert = Convert()
# self.playerMusic = playerMusic()
self.tools = Tools()
self.bus.subscribe('vocalOrdre', self.lanceVocalOrdre)
self.bus.subscribe('loadSeriesDao', self.loadSeriesCallBack)
self.bus.subscribe('loadSeriesEnCoursDao',
self.loadSeriesEnCoursCallBack)
self.bus.subscribe('loadFilmsDao', self.loadFilmsCallBack)
self.bus.subscribe('loadMusiquesDao', self.loadMusiquesCallBack)
self.bus.subscribe('deviceService', self.deviceChange)
self.bus.subscribe('emplacementService', self.emplacementChange)
current_dir = os.path.dirname(__file__)
# jsonfile = '../../resources/fr/serieMapping.json'
# mappingfile = os.path.join(current_dir, jsonfile)
# with open(mappingfile) as data_file:
# serieMapping = json.load(data_file)
# self.listeMotsSerie = self.mappingToWords(serieMapping)
numeroMapping_path = '../../resources/fr/numeroMapping.json'
numeroMapping_file = os.path.join(current_dir, numeroMapping_path)
with open(numeroMapping_file) as data_file:
numeroMapping = json.load(data_file)
self.listeMotsNumero = self.mappingToWords(numeroMapping)
for var in self.VARIABLES:
v = self.VARIABLES[var]
if v == "Int":
self.VARIABLES[var] = numeroMapping
# if var == "@name_serie" :
# self.VARIABLES[var] = serieMapping
def mappingToWords(self, mapping):
listOfWord = []
for item in mapping:
l_m = mapping[item]
for m in l_m:
m_clean = self.tools.cleanString(m)
l_w = m_clean.split(" ")
for w in l_w:
if w not in listOfWord:
listOfWord.append(w)
return listOfWord
def listToWords(self, list_):
listOfWord = []
for item in list_:
m_clean = self.tools.cleanString(item)
l_w = m_clean.split(" ")
for w in l_w:
if w not in listOfWord:
listOfWord.append(w)
return listOfWord
def synchronize(self, data):
self.bus.publish('kodiService', data)
def lanceVocalOrdre(self, bus, key, obj):
groupe = obj['groupe']
if groupe != 'kodi':
return
ordre_name = obj['ordre']
origineIp = obj["origine"]
#recognised = obj["recognised"]
input_ = obj["input"]
#ordre = self.ORDRES[ordre_name]
# function = ordre["function"]
try:
getattr(self, ordre_name)(input_, origineIp)
except Exception as e:
print("Kodi => lanceVocalOrdre : " + e.__str__())
def findKodiBySecteur(self, origineIp):
for secteur in self.emplacements:
for device in secteur.devices:
if str(device.ip) == origineIp:
self.secteurTouche = secteur
if hasattr(self, 'secteurTouche'):
for device in self.secteurTouche.devices:
if device.hasKodi == True:
self.kodiDao.currentKodiIp = device.ip
del self.secteurTouche
def liste_film(self, input_, ipDestination):
self.loadFilms()
def liste_serie(self, input_, ipDestination):
self.loadSeries()
def liste_music(self, input_, ipDestination):
self.loadMusiques()
def lance_episode_2(self, input_, ipDestination):
self.lance_episode(input_, ipDestination, True)
def lance_episode(self, input_, ipDestination, suite=False):
"""
1/ Liste des séries : self.kodiDao.listSeriesEnCours
2/ Input : input_
"""
self.findKodiBySecteur(ipDestination)
name_var = None
episode_num = 0
saison_num = 0
for i in input_:
print(i)
if "suivant" in i:
suite = True
if "@name_serie" in i:
if len(input_[i]) > 1:
name_var = input_[i][1]
if len(input_[i]) == 1:
name_var = input_[i][0]
if "@umeric" in i:
if "épisode" in i:
if len(input_[i]) > 1:
episode_num = input_[i][1]
if len(input_[i]) == 1:
episode_num = input_[i][0]
if "saison" in i:
if len(input_[i]) > 1:
saison_num = input_[i][1]
if len(input_[i]) == 1:
saison_num = input_[i][0]
if "premier" in i:
saison_num = 1
episode_num = 1
if "dernier" in i:
saison_num = "last"
episode_num = "last"
numeros = []
if name_var:
if suite:
for serieEnCours in self.kodiDao.listSeriesEnCours:
if serieEnCours.serieTitle == name_var.key_ordre:
numeros.append(serieEnCours.nextEpisodeid)
else:
saison = 0
episode = None
serie = None
if name_var.key_ordre in self.kodiDao.listSeries:
serie = self.kodiDao.listSeries[name_var.key_ordre]
if serie:
if saison_num == "last":
saison = serie[-1]
elif saison_num > 0:
saison = serie[saison_num]
else:
saison = serie[1]
if saison > 0:
if episode_num == "last":
episode = saison[-1]
elif episode_num > 0:
episode = saison[episode_num]
else:
episode = saison[1]
if episode:
numeros.append(episode.id)
if len(numeros) > 0:
counter = collections.Counter(numeros)
listePossible = counter.most_common()
if len(listePossible) > 0:
episod_id, nombre = listePossible[0]
if episod_id > -1:
self.openSerie(episod_id)
def lance_film(self, input_, ipDestination):
print(input_)
self.findKodiBySecteur(ipDestination)
name_var = None
for i in input_:
print(i)
if "@name_film" in i:
if len(input_[i]) > 1:
name_var = input_[i][1]
if len(input_[i]) == 1:
name_var = input_[i][0]
numeros = []
if name_var:
for film in self.kodiDao.listFilms:
if film.title == name_var.key_ordre:
numeros.append(film.id)
if len(numeros) > 0:
counter = collections.Counter(numeros)
listePossible = counter.most_common()
if len(listePossible) > 0:
movieid, nombre = listePossible[0]
if movieid > -1:
self.openFilm(movieid)
#movieid = -1
#movieid = self.convert.convert(arguments[0])
# numeros = self.convert.convertListChaine(input_, self.kodiDao.listFilms)
# print 'lance_film : ' + str(movieid)
# print ('numeros : ' + str(numeros))
# counter = collections.Counter(numeros)
# print ('numeros : ' + str(counter.most_common(4)))
# listePossible = counter.most_common(4)
# movieid, nombre = listePossible[0]
#def lance_episode(self, input_, ipDestination):
#episod_id = -1
# print(input_)
# numeros = self.convert.convertListChaine(input_, self.kodiDao.listSeries, self.kodiDao.listSeriesEnCours)
# print 'lance_episode : ' + str(episod_id)
# print ('numeros : ' + str(numeros))
# counter = collections.Counter(numeros)
# print ('numeros : ' + str(counter.most_common(4)))
# listePossible = counter.most_common(4)
# episod_id, nombre = listePossible[0]
# if episod_id > -1 :
# self.openSerie(episod_id)
#def launchMusic(self, input_, ipDestination):
# self.playerMusic.manageMusic(ipDestination, "lance_music" , "bureau")
def pause(self, input_, ipDestination):
#pass
self.playPause(False)
#self.playerMusic.manageMusic(ipDestination, "pause")
def lecture(self, input_, ipDestination):
#pass
self.playPause(True)
#self.playerMusic.manageMusic(ipDestination, "lecture")
def stop(self, input_, ipDestination):
#pass
self.stopFilm()
#self.playerMusic.manageMusic(ipDestination, "stop")
def launchMute(self, input_, ipDestination):
self.xbmc.Application.SetMute({"mute": True})
def baisser_son(self, input_, ipDestination):
self.xbmc = self.kodiDao.connectFirstKodi()
volume = self.xbmc.Application.GetProperties(
{"properties": ["volume"]})
n_v = volume["result"]["volume"] - 2
volume = self.xbmc.Application.SetVolume({"volume": n_v})
def scan(self, input_, ipDestination):
self.scanMoviesDatabase()
def deviceChange(self, bus, key, obj):
self.devices = obj["devices"]
self.detectKodi()
if len(self.kodiDao.listKodis) > 0 and not hasattr(self, 'WSthread'):
self.WSthread = []
for kodi in self.kodiDao.listKodis:
t = WSThread(self, kodi.ip)
self.WSthread.append(t)
t.start()
self.loadMusiques()
self.loadFilms()
self.loadSeries()
def emplacementChange(self, bus, key, obj):
if hash(frozenset(self.emplacements)) != hash(
frozenset(obj["emplacements"])):
self.emplacements = obj["emplacements"]
emplacement_name = []
emplacement_mapping = {}
for e in self.emplacements:
name_clean = self.tools.cleanString(e.name)
emplacement_name.append(name_clean)
if e.name not in emplacement_mapping:
emplacement_mapping[e.name] = []
if name_clean not in emplacement_mapping[e.name]:
emplacement_mapping[e.name].append(name_clean)
self.VARIABLES["@name_playlist"] = emplacement_mapping
self.bus.publish(
'loadVocalVariable', {
'module': 'kodi',
'key': '@name_playlist',
'values': emplacement_name
})
def detectKodi(self, args=None):
listKodis = []
if len(self.devices) > 0:
for device in self.devices:
if self.deviceDetectKodi(device.ip):
device.setHasKodi(True)
listKodis.append(device)
print('Kodi detect : ' + device.ip)
obj = {'key': "kodiDetected", 'devices': listKodis}
self.synchronize(obj)
self.kodiDao.listKodis = listKodis
return self.kodiDao.listKodis
def deviceDetectKodi(self, ip):
params = {}
params['jsonrpc'] = '2.0'
params['id'] = 0
params['method'] = 'JSONRPC.Ping'
params['params'] = ''
data = json.dumps(params).encode('utf-8')
header = {
'Content-Type': 'application/json',
'User-Agent': 'python-xbmc'
}
url = "http://" + ip + ":" + str(conf.PORT_HTTP_KODI) + "/jsonrpc"
isKodi = True
try:
req = urllib2.Request(url, data, header)
urllib2.urlopen(req, timeout=0.3)
# xbmc = xbmcjson.XBMC(url)
# xbmc.JSONRPC.Ping()
except:
isKodi = False
return isKodi
def scanMoviesDatabase(self, args=None):
self.xbmc = self.kodiDao.connectFirstKodi()
self.xbmc.VideoLibrary.Scan()
def scanMusiquesDatabase(self, args=None):
self.xbmc = self.kodiDao.connectFirstKodi()
self.xbmc.AudioLibrary.Scan()
def showNotification(self, args):
self.xbmc = self.kodiDao.connectFirstKodi()
self.xbmc.GUI.ShowNotification({
"title":
"Topi de amor",
"message":
"Bonjour je m'appelle Noni y te quiero"
})
def loadFilms(self, forcage=False):
if len(self.kodiDao.listFilms) == 0 or forcage:
self.kodiDao.loadFilms()
obj = {'key': "loadFilms", 'films': self.kodiDao.listFilms}
self.synchronize(obj)
return self.kodiDao.listFilms
def loadFilmsCallBack(self, bus, key, films):
obj = {'key': "loadFilms", 'films': films}
self.synchronize(obj)
films_name = []
for f in films:
films_name.append(f.title)
self.bus.publish('loadVocalVariable', {
'module': 'kodi',
'key': '@name_film',
'values': films_name
})
def loadMusiques(self, forcage=False):
self.kodiDao.loadMusiques()
obj = {'key': "loadMusiques", 'musiques': self.kodiDao.listMusiques}
self.synchronize(obj)
return self.kodiDao.listMusiques
def loadMusiquesCallBack(self, bus, key, musiques):
obj = {'key': "loadMusiques", 'musiques': self.kodiDao.listMusiques}
self.synchronize(obj)
listArtiste = ["pink floyd"]
self.bus.publish('loadVocalVariable', {
'module': 'kodi',
'key': '@name_music',
'values': listArtiste
})
def loadSeries(self, forcage=False):
if len(self.kodiDao.listSeries) == 0 or forcage:
self.kodiDao.loadSeries()
self.synchronize({
'key': "loadSeries",
'series': self.kodiDao.listSeries
})
self.synchronize({
'key': "loadSeriesEnCours",
'series': self.kodiDao.listSeriesEnCours
})
return self.kodiDao.listSeries
def loadSeriesTab(self, forcage=False):
if len(self.kodiDao.listSeries) == 0 or forcage:
self.kodiDao.loadSeries()
listSeriesTab = []
for serie in self.kodiDao.listSeries:
listSeriesTab.append(Serie(serie))
return listSeriesTab
def loadSeriesCallBack(self, bus, key, series):
self.kodiDao.listSeries = series
self.synchronize({'key': "loadSeries", 'series': series})
#serieMapping = self.VARIABLES["@name_serie"]
#for s in self.kodiDao.listSeries:
# s_clean = self.tools.cleanString(s)
# if s not in serieMapping :
# serieMapping[s] = []
# if s_clean not in serieMapping[s] :
# serieMapping[s].append(s_clean)
##self.listeMotsSerie = self.mappingToWords(serieMapping)
#self.VARIABLES["@name_serie"] = serieMapping
#vocal_serie = []
#for item in serieMapping :
# l = serieMapping[item]
# for m in l :
# if m not in vocal_serie :
# vocal_serie.append(m)
#self.bus.publish('loadVocalVariable' , {'module': 'kodi', 'key':'@name_serie' , 'values' : vocal_serie})
def loadSeriesEnCoursCallBack(self, bus, key, seriesEnCours):
self.kodiDao.listSeriesEnCours = seriesEnCours
self.synchronize({
'key': "loadSeriesEnCours",
'series': self.kodiDao.listSeriesEnCours
})
def kodiCommand(self, kodiArgs):
command = kodiArgs[0].ordre
if hasattr(kodiArgs[0], 'arguments'):
args = kodiArgs[0].arguments
self.xbmc = self.kodiDao.connectFirstKodi()
player = {}
activePlayer = self.xbmc.Player.GetActivePlayers()
print('Active player : ' + str(activePlayer))
if command == 'PlayPause':
player = self.playPause(args)
if command == 'openFilm':
player = self.openFilm(args)
if command == 'openSerie':
player = self.openSerie(args)
if command == 'Stop':
player = self.stopFilm()
if command == 'activeItem':
try:
player = self.activeItem()
except:
pass
return player
def openFilm(self, args):
self.xbmc = self.kodiDao.connectFirstKodi()
self.xbmc.Player.Open({"item": {"movieid": int(args)}})
def openSerie(self, episod_id):
self.xbmc = self.kodiDao.connectFirstKodi()
# print episod_id
result = self.xbmc.Player.Open({
"item": {
"episodeid": int(episod_id)
},
"options": {
"resume": True
}
})
print(result)
def playPause(self, args):
self.xbmc = self.kodiDao.connectFirstKodi()
return self.xbmc.Player.PlayPause([PLAYER_VIDEO])
def stopFilm(self):
self.xbmc = self.kodiDao.connectFirstKodi()
return self.xbmc.Player.Stop([PLAYER_VIDEO])
def activeItem(self):
self.kodiDao.connectFirstKodi()
activeItem = {}
activeKodi = self.xbmc.Player.GetItem([PLAYER_VIDEO])
if not activeKodi:
return
listActiveItem = activeKodi.get('result', {}).get('item', [])
# print str(listActiveItem)
if len(listActiveItem) > 0:
type = listActiveItem['type']
if type != 'unknown':
title = listActiveItem['label']
id = listActiveItem['id']
speedJson = self.xbmc.Player.GetProperties({
"properties": ["speed"],
"playerid": PLAYER_VIDEO
})
speed = speedJson.get('result', {}).get('speed')
print('onPlay' if speed > 0 else 'onPause')
if type == 'movie':
activeItem = self.kodiDao.loadFilmDetails(id)
else:
activeItem = self.kodiDao.loadEpisodeDetails(id)
print(title)
obj = {
'key': "activeItem",
'items': {
'item': activeItem,
'speed': speed
}
}
self.synchronize(obj)
else:
print("nada en curso")
return activeItem
def test(self):
# self.xbmc.GUI.ActivateWindow({"window":"mediasource"})
sources = self.xbmc.Files.GetSources(media="video")
print(sources)
directoryFilms = self.xbmc.Files.GetDirectory({
"directory": '/media/HP Desktop Drive/Film/',
"sort": {
"order": "ascending",
"method": "label"
}
})
filmsTitle = []
for film in directoryFilms.get('result', {}).get('files', []):
item = film['label']
if item not in filmsTitle:
filmsTitle.append(item)
print(filmsTitle)
directorySeries = self.xbmc.Files.GetDirectory({
"directory": '/media/Seagate Expansion Dr/série/',
"sort": {
"order": "ascending",
"method": "label"
}
})
seriesTitle = []
for serie in directorySeries.get('result', {}).get('files', []):
item = serie['label']
if item not in seriesTitle:
seriesTitle.append(item)
print(seriesTitle)
print(len(seriesTitle))
def test1(self):
xbmc = XBMC("http://192.168.1.100:8080/jsonrpc")
audio = xbmc.AudioLibrary.GetSongs()
print(audio)
class BebePaz():
VARIABLES = {}
ORDRES = {
"display_bebepaz" : {
"action" : ["display", "show"],
"message_fr" : ["bébé"]
}
}
def __init__(self):
self.bus= Bus()
self.isActive = True
self.bus.subscribe('vocalOrdre', self.lanceVocalOrdre)
global queues
queues = []
gst_thread = MainPipeline()
gst_thread.start()
def stream(self):
q = Queue(10)
queues.append(q)
while True:
try:
#print q.qsize()
yield q.get(timeout=1)
except Exception as e:
if q in queues:
queues.remove(q)
return
def lanceVocalOrdre(self, bus, key, obj):
"""
Point d'entré du module pour gérer les ordres associés par la reconnaissance vocale
"""
groupe = obj['groupe']
if groupe != 'bebepaz' :
return
ordre = self.ORDRES[obj['ordre']]
print ("Ordre lancé : " + obj['ordre'])
#print ("appel de la function : " + ordre["function"])
print ("origine : " + obj["origine"])
# print ("recognised : " + str(obj["recognised"]))
print ("input : " + str(obj["input"]))
def isCameraActive(self, args = None):
"""
return un objet JSON de cameraActive
"""
obj = {}
obj['cameraActive'] = self.isCamera()
return obj
def isCamera(self):
return self.isActive
def startCamera(self, args = None):
"""
Activer par l'IHM
"""
print ("bebe_paz.py : Start vocal")
self.isActive = True
def stopCamera(self, args = None):
"""
Activer par l'IHM
"""
print ("bebe_paz.py : Stop vocal")
self.isActive = False
