Exemple #1
0
class FirstForm(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
        self.button = QPushButton(self)
        self.button.setText("На паузу")
        # флаг, с помощью которого мы будем узнавать, на паузе ли наше аудио. Изначально False - аудио воспроизводится
        self.is_pause = False
        self.button.clicked.connect(self.pause)
        # аудиоплейер
        self.player = AudioPlayer("file_example_MP3_700KB.mp3")
        # можно установить громкость с помощью self.player.volume(n), где n целое число от 0 до 100

        # запускаем воспроизведение
        self.player.play()

    def pause(self):
        # аудио на паузе? значит надо возобновить воспроизведение
        if self.is_pause:
            self.player.resume()
            self.button.setText("На паузу")
        # аудио не на паузе - поставим на паузу
        else:
            self.button.setText("Возобновить")
            self.player.pause()
        # меняем флаг паузы на противоположный
        # соответственно, если аудио было на паузе - флаг станет False, если не было - станет True
        self.is_pause = not self.is_pause

    def initUI(self):
        self.setGeometry(300, 300, 300, 300)
        self.setWindowTitle('Главная форма')
class Stream(Client):
	
	def __init__(self, TCP, ip, port):
		Client.__init__(self, TCP, ip, port)
		self.audio = AudioPlayer()
		self.audio.createAudioPlayerStream()
		self.setDaemon(True)#detached thread
		self.lupdate = Lock()

	def setCanal(self, n):
		self.logger.debug("Updating the number of channels")
		self.lupdate.acquire()
		self.audio.setNumberOfChannels(n)
		self.audio.closeAudioPlayerStream()
		self.audio.createAudioPlayerStream()
		self.lupdate.release()		
		
	def run(self):
		self.logger.debug("Playing stream !")
		while(self.continuer):
			try:
				data = self.sock.recv(self.audio.getBufferSize())
				self.logger.debug(data)
				if(data == b'CLOSE'):self.continuer = False
				else:
					self.lupdate.acquire()
					self.audio.play(data)
					self.lupdate.release()
			except Exception as e:
				self.logger.error(e)
				self.continuer = False
		self.audio.closeAudioPlayerStream()
		self.closeSocket()
Exemple #3
0
 def playAdhan(self, prayerTime, prayerName):
     adhan = AudioPlayer("./Adhans/AdhanFajr.mp3") if prayerName == "Fajr" \
         else AudioPlayer("./Adhans/Adhan.mp3")
     print(prayerName, prayerTime)
     adhan.play(block=True)
     time.sleep(10)
     adhan.stop()
     adhan.close()
Exemple #4
0
def play_sound(PATH):
    global ap

    if ap is not None:
        stop_sound()

    ap = AudioPlayer(PATH)
    ap.play(block=False)
Exemple #5
0
def load():
    global player, root
    fname = filedialog.askopenfilename()
    if fname:
        player = AudioPlayer(fname)
        changevolume(0)  # update UI
        namelabel.config(text=os.path.basename(player.fullfilename))
        try:
            player.play()
        except Exception as e:
            messagebox.showerror('Error', e)
Exemple #6
0
def play_mp3_with_volume(time_to_play=5):
    """
        Reference: https://pypi.org/project/audioplayer/
    """
    import time
    from audioplayer import AudioPlayer

    player = AudioPlayer(song_file)
    player.volume = 15

    player.play(loop=False, block=False)
    time.sleep(time_to_play)      # default, play in 5s, then stop
    player.stop() 
class Stream(Client):
    def __init__(self, TCP, ip, port):
        Client.__init__(self, TCP, ip, port)
        self.audio = AudioPlayer()
        self.audio.createAudioPlayerStream()
        self.setDaemon(True)  #detached thread
        self.lupdate = Lock()
        self.filter = None

    def setCanal(self, n):
        self.logger.debug("Updating the number of channels")
        self.lupdate.acquire()
        self.audio.setNumberOfChannels(n)
        self.audio.closeAudioPlayerStream()
        self.audio.createAudioPlayerStream()
        self.lupdate.release()

    def updateFilter(self, i):
        if (i < 1 or i > 2): self.filter = None  #update this cond
        elif (i == 1):
            self.filter = Highpass(3, 1000, self.audio.getRate(), "highpass")
            #self.filter.designFilter()
        elif (i == 2):
            self.filter = Lowpass(3, 1000, self.audio.getRate(), "lowpass")
            #self.filter.designFilter()
        #todo add crowd filter

    def cleanup(self):
        self.audio.closeAudioPlayerStream()
        self.closeSocket()

    def run(self):
        self.logger.debug("Playing stream !")
        while (self.continuer):
            try:
                data = self.sock.recv(self.audio.getBufferSize())
                self.logger.debug(data)
                if (data == b'CLOSE'): self.continuer = False
                else:
                    self.lupdate.acquire()
                    if (not (self.filter == None)):
                        data = self.filter.applyFilter(data)
                    self.audio.play(data)
                    self.lupdate.release()
            except Exception as e:
                self.logger.error(e)
                self.continuer = False
Exemple #8
0
def gtts_daemon():
    while BOT.is_pooling:
        try:
            response = QUEUE.get(block=False) # This blocks and hangs the program entirely
            file_name = os.path.join(TEMP_DIR, f'gtts_{datetime.now().microsecond}.mp3')
            response.save(file_name)
            sound = AudioPlayer(file_name)
            sound.volume = SETTINGS.get('volume', 100)
            sound.play(block=True)
            os.remove(file_name)
            QUEUE.task_done()
        except queue.Empty:
            pass # Ignore and try again later
        except Exception as err:
            os.remove(file_name)
            LOGGER.error(err, exc_info=True)
        time.sleep(1) # Lessen the CPU impact.
class Track:
    def __init__(self, path):
        self.path = path
        self.ap = AudioPlayer(filename=path)

    def start(self, loop=False, volume=50, block=True):
        self.ap.volume = volume
        self.ap.play(loop=loop, block=block)

    def stop(self):
        current_volume = self.ap.volume
        for i in range(current_volume):
            self.ap.volume = self.ap.volume - 1
            time.sleep(.2)
        self.ap.stop()

    def __del__(self):
        self.stop()
Exemple #10
0
class AudioController:
    def __init__(self):
        self.audio_volume = 1
        self.current_song = None
        self.audioplayer = None
        self.loop = True

    def sfx(self, effect, volume):
        audioplayer = AudioPlayer(effect)
        audioplayer.volume = volume
        audioplayer.play(block=True)
        audioplayer.close()

    def play_sfx(self, effect, volume):
        sf = threading.Thread(target=self.sfx, args=(effect, volume,))
        sf.daemon = True
        sf.start()

    def set(self, song):
        force_path(song)
        if self.audioplayer:
            self.close()

        self.audioplayer = AudioPlayer(song)
        self.audioplayer.volume = self.audio_volume
        self.current_song = song

    def play(self):
        self.audioplayer.play(loop=self.loop)

    def volume(self, v):
        self.audio_volume = v

    def pause(self):
        self.audioplayer.pause()

    def unpause(self):
        self.audioplayer.resume()

    def close(self):
        self.audioplayer.close()
Exemple #11
0
from audioplayer import AudioPlayer
import os

mp3 = os.path.join(os.path.dirname(__file__), 'audio', 'toquesuave.mp3') # ringtone by felipebbrusso'

p = AudioPlayer(mp3)

print('Playing {} in loop'.format(p.fullfilename))
p.play(block=False, loop=True)

input('Press Enter to pause ')
p.pause()

input('Press Enter to resume ')
p.resume()

input('Press Enter to set volume to 1% ')
p.volume = 1

input('Press Enter to set volume to 10% ')
p.volume = 10

input('Press Enter to set volume to 50% ')
p.volume = 50

input('Press Enter to set volume to 100% ')
p.volume = 100

input('Press Enter to stop ')
p.stop()
Exemple #12
0
            results_available = True
        window["extra_info"].update(
            "\n \n \n \n \n \n \n \n \n \n \n \n \n \n Click on a show episode for extra info"
        )
    if event == 'results':
        if results_available:
            list_vals = window["results"].get_list_values()
            pos = list_vals.index(values['results'][0])
            (show_name, episode_name) = show_and_eps[pos]

            window["extra_info"].update("")
            query_result.print_description(cprint, show_name, episode_name,
                                           spotify)
            query_result.update_preview(show_name, episode_name, spotify)

            image_elem.update(data=get_img_data(
                "img/tmp.jpg", maxsize=(200, 200), first=True))

            window["extra_info"].set_vscroll_position(0)

    if event == 'Play':
        player = AudioPlayer("img/tmp.mp3")
        player.play()

    if event == 'Pause':
        player.stop()

    if event == 'Open on Spotify':
        query_result.openurl()

window.close()
Exemple #13
0
class GUI:
    def __init__(self, information):

        # Intializing the user info
        self.user_info = information

        # Defining the current path
        self.CURPATH = os.path.dirname(os.path.abspath(__file__))
        

        # Making a GUI window
        self.window = tk.Tk()
        self.video_panel = None #video
        self.window.geometry("1150x730")
        #self.window.configure(bg="#4DA8DA")
        self.window.configure(bg="white")
        
        # Title of GUI
        tk.Label(self.window, text="Welcome,\nUser: "******"username"] + "\n How can we help you?",
                                 font="Calibri 20 bold", bg="deep sky blue", fg="white", height = 3).pack(fill = BOTH)
        
        #App holds The video and the IMU status bar
        self.app = tk.Frame(self.window)
        self.app.configure(bg="white")
        self.app.pack(side = LEFT)

        # Showing the buttons in the display in a frame (All buttons are in a frame)
        self.button_frame = tk.Frame(self.window)
        self.button_frame.configure(bg="white")
        self.button_frame.pack(side = LEFT)
        
        # Showing the action in the main display //Holds How can I help you and the IMU info
        self.lmain = tk.Label(self.app)
        self.lmain.pack(side = BOTTOM)


        # Setting the main display
        self.main_display()

        # Accessing the file in this path (Logo Switches with video frame)
        self.path = os.path.join(self.CURPATH, "Information", "nightlight_app_logo_white.png")
        self.logo = PhotoImage(file = self.path)

        # Showing The Video Frame
        self.video_frame = tk.Label(self.app, image = self.logo)
        self.video_frame.configure(bg="white")
        self.video_frame.pack( side = LEFT)


        self.mute = True
        # Inserting the icon for each buttons
        self.path = os.path.join(self.CURPATH, "Information", "listen_off_mac.png")
        self.loadimage = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "listen_on_mac.png")
        self.loadimage2 = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "watch_on_mac.png")
        self.loadimage3 = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "lullaby_mac.png")
        self.loadimage4 = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "login_mac.png")
        self.loadimage5 = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "chat_mac.png")
        self.loadimage6 = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "quit_mac.png")
        self.loadimage7 = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "recordings_mac.png")
        self.loadimage8 = tk.PhotoImage(file = self.path)
        self.path = os.path.join(self.CURPATH, "Information", "notif_off_mac.png")
        self.loadimage9 = tk.PhotoImage(file = self.path)
        
        

        # Initializing the notification
        self.getting_user_info()
        if(self.notification_info2 == True):
            self.notification = "On"
        else:
            self.notification = "Off"

        self.video_stream = False
        self.video_notification = "Off"

        # Prepare recordings directory and attributes
        # Recordings 
        self.recording_path = os.path.join(SRCPATH, "recordings")
        if not os.path.exists(self.recording_path):
            try:
                os.mkdir(self.recording_path)
            except OSError:
                print("Failed to create directory as src/")
        
        self.recordings_ls = []
        try:
            self.recordings_ls = os.listdir(self.recording_path)
        except:
            pass

        # presigned url cache timer
        self.url_time_to_live = 170

        # Audio Player
        self.ap = None

        # Creating buttons
        #root = Tk()
        for i in range(4):
            for j in range(2):
                self.frame = tk.Frame(master=self.button_frame, relief=tk.RAISED, borderwidth=1)
                self.frame.grid(row=i, column=j)
                if i == 0 and j == 0:

                    self.button_a = tk.Button(self.frame,image = self.loadimage3, command=self.handle_click_video_stream)
                    self.button_a.place(width=146, height=95)
                    self.button_a.pack() #Video
                    #tk.Button.place(x=5, y=10, width=140, height=30)
                if i == 0 and j == 1:
                    self.button_b = tk.Button(self.frame, image = self.loadimage4, command=self.handle_click_lullaby)
                 #   self.button_b = tk.Button(self.frame,
                 #                  highlightbackground="deep sky blue", highlightthickness=20, image = self.loadimage4, command=self.handle_click_lullaby)
                    self.button_b.place(x=5, y=10, width=140, height=30)
                    self.button_b.pack() #Lullaby
                if i == 1 and j == 0:
                    self.button_c = tk.Button(self.frame,image=self.loadimage, command=self.handle_click_listen)
                    self.button_c.place(x=5, y=10, width=140, height=30)
                    self.button_c.pack() #Audio
                if i == 1 and j == 1:
                    self.button_h = tk.Button(self.frame,image=self.loadimage8, command=self.handle_click_recordings)
                    self.button_h.place(x=5, y=10, width=140, height=30)
                    self.button_h.pack() #Recordings
                if i == 2 and j == 0:
                    self.button_d = tk.Button(self.frame, image = self.loadimage5, command=self.handle_click_changing_login_info)
                    self.button_d.place(x=5, y=10, width=140, height=30)
                    self.button_d.pack() #Settings
                if i == 2 and j == 1:
                    self.button_e = tk.Button(self.frame,image = self.loadimage6, command=self.handle_click_open_chat_window)
                    self.button_e.place(x=5, y=10, width=140, height=30)
                    self.button_e.pack() #Chat
                if i == 3 and j == 0:
                    self.button_f = tk.Button(self.frame, image = self.loadimage9, command=self.handle_click_notification)
                    self.button_f.place(x=5, y=10, width=140, height=30)
                    self.button_f.pack() #Notification
                if i == 3 and j == 1:
                    self.button_g = tk.Button(self.frame, image = self.loadimage7, command=self.quit_the_program)
                    self.button_g.place(x=5, y=10, width=140, height=30)
                    self.button_g.pack() #Quit

        # self.window.protocol("WM_DELETE_WINDOW", self.quit_the_program)
        self.window.mainloop()  # runs application

    # Event handlers
    def main_display(self):
        # Setting the main display
        try:
            self.path = os.path.join(self.CURPATH, "notification.txt",)
            self.txt = open(self.path, "r")
            self.txt = self.txt.readline()
        except:
            self.txt = "-Baby Pose Sensor Unavailable-"
        # self.lmain.configure(text=self.txt,font="Helvetica 20 bold", bg="#4DA8DA", fg="#EEFBFB")
        self.lmain.configure(text=self.txt,font="Helvetica 30 bold", bg="white", fg="green")
        self.lmain.after(1000, self.main_display)
	
    
    def handle_click_video_stream(self):
      
        if (self.video_stream == False):
            self.video_stream = True
            self.video_notification = "On"
            self.button_a.config(text="Watch the baby" + "\n\n\n\n" + self.video_notification)            

            #initialize video client connections
            #use try/except for if server isn't running?
            self.gui_sock = socket()
            #gui_sock.connect(('3.140.200.49',6662)) # connect to Denny's AWS Server's public IP
            self.gui_sock.connect(('18.189.21.182',6662)) # connect to Robert's AWS Server's public IP
            print("Client User listening on port...")
            self.connection = self.gui_sock.makefile('rb')
            print("Client User connected")
            self.video_thread = threading.Thread(target=self.videoLoop,args=())
            self.video_thread.start()
            self.window.wm_title("Video Stream")
        else:
            self.video_stream = False
            self.video_notification = "Off"
            self.button_a.config(text="Watch the baby" + "\n\n\n\n" + self.video_notification)            
            self.video_frame.config(image = self.logo)

            self.connection.close()
            self.gui_sock.close()

    def videoLoop(self):
        try:
            while True:
                self.image_len = struct.unpack('<L', self.connection.read(struct.calcsize('<L')))[0]
                if not self.image_len:
                    print("invalid data from stream ")
                    break
                print(self.image_len)
                self.image_stream = io.BytesIO()
                self.image_stream.write(self.connection.read(self.image_len))
                self.image_stream.seek(0)

                self.file_bytes = np.asarray(bytearray(self.image_stream.read()),dtype=np.uint8)
                self.raw_image = cv2.imdecode(self.file_bytes,cv2.IMREAD_COLOR)
                self.rgb_image = cv2.cvtColor(self.raw_image, cv2.COLOR_BGR2RGB) #self vs no self?
                self.pil_image = Image.fromarray(self.rgb_image)
                self.pil_image = ImageTk.PhotoImage(self.pil_image)

                self.video_frame.config(image=self.pil_image)
                self.video_frame.image = self.pil_image
                self.video_frame.pack(padx=1, pady=1)
        except:
            print("Occurred Exception, closing socket")
            self.connection.close()
            self.gui_sock.close()

    def handle_click_lullaby(self):
        self.button_b.configure(state = tk.DISABLED)
        
        self.new_window = tk.Toplevel(self.window)
        self.new_window.configure(bg="white")

        # Making a scroll bar display
        self.scroll_bar = tk.Scrollbar(self.new_window)
        self.option = tk.Listbox(self.new_window, relief=tk.SUNKEN, borderwidth=3, bg="deep sky blue", fg="black",
                                 font="Helvetica 11 bold", yscrollcommand=self.scroll_bar.set)
        self.inserting_option()
        self.option.pack(side=tk.LEFT, fill=tk.BOTH)
        self.scroll_bar.config(command=self.option.yview)

        self.select = tk.Button(self.new_window, text="Play Song", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command=self.play_sound)
        self.select.pack(fill=tk.BOTH)
        
        self.pause = tk.Button(self.new_window, text="Pause Song", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command= self.pause_sound)
        self.pause.pack(fill=tk.BOTH)

        self.resume = tk.Button(self.new_window, text="Resume Song", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command= self.resume_sound)
        self.resume.pack(fill=tk.BOTH)

        self.stop = tk.Button(self.new_window, text="Stop Song", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command= self.stop_sound)
        self.stop.pack(fill=tk.BOTH)

        self.new_window.protocol("WM_DELETE_WINDOW", self.quit_play_song_window)
    

    def handle_click_listen(self):
        
        if self.mute == True:
            self.button_c.config(image = self.loadimage2)
            # Audio Streaming
            self.audio_conn = AudioClient.AudioClient(write = False)    
            self.audio_conn.write = True
            self.audio_conn.start()
            thread = threading.Thread(target=self.audio_conn.recv)
            thread.start()
            self.mute = False 

        elif self.mute == False:
            self.button_c.config(image = self.loadimage)
            self.audio_conn.stop()
            self.audio_conn.write = False 
            self.mute = True

    def handle_click_changing_login_info(self):
        self.button_d.configure(state = tk.DISABLED)
        
        self.login_screen = tk.Toplevel(self.window)
        self.login_screen.geometry("300x300")
        self.login_screen.configure(bg="white")
        tk.Label(self.login_screen, text = "Please choose either one of these button", bg = "white", fg = "black").pack()
        tk.Label(self.login_screen, text = "", bg = "white").pack()
        self.pass_button = tk.Button(self.login_screen, text = "Changing Password", bg = "deep sky blue", fg= "black", relief=tk.RAISED, borderwidth=3, font = "Helvetica 11 bold", command = self.changing_password)
        self.pass_button.pack()
        tk.Label(self.login_screen, text = "", bg = "white").pack()
        self.email_button = tk.Button(self.login_screen, text = "Changing Email", bg = "deep sky blue", fg= "black", relief=tk.RAISED, borderwidth=3, font = "Helvetica 11 bold", command = self.changing_email)
        self.email_button.pack()

        self.login_screen.protocol("WM_DELETE_WINDOW", self.quit_login_window)
    
    def handle_click_recordings(self):
        self.button_h.configure(state = tk.DISABLED)
        
        self.record_screen = tk.Toplevel(self.window)
        self.record_screen.geometry("300x300")
        self.record_screen.configure(bg="white")
        tk.Label(self.record_screen, text = "", bg = "white").pack()
        self.download_button = tk.Button(self.record_screen, text = "Download from cloud", bg = "deep sky blue", fg= "black", relief=tk.RAISED, borderwidth=3, font = "Helvetica 11 bold", command = self.handle_download)
        self.download_button.pack()
        tk.Label(self.record_screen, text = "", bg = "white").pack()
        self.record_button = tk.Button(self.record_screen, text = "Play recordings", bg = "deep sky blue", fg= "black", relief=tk.RAISED, borderwidth=3, font = "Helvetica 11 bold", command = self.play_recordings)
        self.record_button.pack()

        self.record_screen.protocol("WM_DELETE_WINDOW", self.quit_record_window)

    def handle_download(self):
        self.download_button.configure(state = tk.DISABLED)
        
        self.new_window3 = tk.Toplevel(self.record_screen)
        self.new_window3.configure(bg="white")

        # Making a scroll bar display
        self.scroll_bar = tk.Scrollbar(self.new_window3)
        self.option = tk.Listbox(self.new_window3, selectmode=MULTIPLE, bd=0, bg="deep sky blue", fg="black", relief=tk.SUNKEN, borderwidth=3,
                                 font="Helvetica 11 bold", yscrollcommand=self.scroll_bar.set)
        self.s3_ls_recordings()
        self.option.pack(side=tk.LEFT, fill=tk.BOTH)
        self.scroll_bar.config(command=self.option.yview)

        self.select = tk.Button(self.new_window3, text="Download", bd=0, bg="deep sky blue",
                                fg="BLACK", relief=tk.RAISED, borderwidth=3, font="Helvetica 11 bold", command=self.get_recordings)
        self.select.pack(fill=tk.BOTH)

        self.new_window3.protocol("WM_DELETE_WINDOW", self.quit_play_song_window3)

    def play_recordings(self):
        self.record_button.configure(state = tk.DISABLED)
        
        self.new_window2 = tk.Toplevel(self.record_screen)
        self.new_window2.configure(bg="white")

        # Making a scroll bar display
        self.scroll_bar = tk.Scrollbar(self.new_window2)
        self.option = tk.Listbox(self.new_window2, bd=0, bg="deep sky blue", fg="white", relief=tk.SUNKEN, borderwidth=3,
                                 font="Helvetica 11 bold", yscrollcommand=self.scroll_bar.set)
        self.ls_recordings()
        self.option.pack(side=tk.LEFT, fill=tk.BOTH)
        self.scroll_bar.config(command=self.option.yview)

        self.select = tk.Button(self.new_window2, text="Play", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command=self.play_sound_local)
        self.select.pack(fill=tk.BOTH)

        self.pause = tk.Button(self.new_window2, text="Pause", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command= self.pause_sound_local)
        self.pause.pack(fill=tk.BOTH)

        self.resume = tk.Button(self.new_window2, text="Resume", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command= self.resume_sound_local)
        self.resume.pack(fill=tk.BOTH)

        self.delete = tk.Button(self.new_window2, text="Delete", relief=tk.RAISED, borderwidth=3, bg="deep sky blue",
                                fg="BLACK", font="Helvetica 11 bold", command= self.delete_recording)
        self.delete.pack(fill=tk.BOTH)

        self.new_window2.protocol("WM_DELETE_WINDOW", self.quit_play_song_window2)


    def handle_click_open_chat_window(self):
        self.button_e.configure(state = tk.DISABLED)
        
        self.chat_window = tk.Toplevel(self.window)
        self.chat_window.title("Chatter")

        self.messages_frame = tk.Frame(self.chat_window)
        self.my_msg = tk.StringVar()  # For the messages to be sent.
        self.scrollbar = tk.Scrollbar(self.messages_frame)  # To navigate through past messages.
        
        # Following will contain the messages.
        self.msg_list = tk.Listbox(self.messages_frame, height=15, width=50, yscrollcommand=self.scrollbar.set)
        self.scrollbar.pack(side= tk.RIGHT, fill= tk.Y)
        self.msg_list.pack(side= tk.LEFT, fill= tk.BOTH)
        self.msg_list.pack()
        self.messages_frame.pack()


        self.guide = tk.Label(self.chat_window, text = "Type your messages below")
        self.guide.pack()
        self.entry_field = tk.Entry(self.chat_window, textvariable = self.my_msg)
        self.entry_field.bind("<Return>", self.send)
        self.entry_field.pack()
        self.send_button = tk.Button(self.chat_window, text="Send", bg = "deep sky blue", fg = "black", relief=tk.RAISED, borderwidth=3, command = self.send)
        self.send_button.pack()
        
        self.chat_window.protocol("WM_DELETE_WINDOW", self.on_closing)

        #----Now comes the sockets part----
        HOST = '18.189.21.182'#input('Enter host: ')
        PORT = int (33000)

        self.BUFSIZ = 1024
        ADDR = (HOST, PORT)

        self.client_socket = socket(AF_INET, SOCK_STREAM)
        self.client_socket.connect(ADDR)
        self.client_socket.send(self.username_info2.encode("utf8"))
        receive_thread = threading.Thread(target = self.receive)
        receive_thread.start()



    def handle_click_notification(self):
        
        db = DBInterface.DBInterface()
        if(self.notification == "On"):
            self.notification = "Off"
            self.button_f.config(text="Current Notification" + "\n\n" + self.notification)
            pub_cmd.publish(client, "update email")
            db.switch_notification(self.ID_info2, False)
        elif (self.notification == "Off"):
            self.notification = "On"
            self.button_f.config(text="Current Notification" + "\n\n" + self.notification)
            pub_cmd.publish(client, "update email")
            db.switch_notification(self.ID_info2, True)


    def quit_the_program(self):
        if(self.mute == False):
            self.audio_conn.stop()
            self.audio_conn.write = False
        if(self.video_stream == True):
            self.connection.close()
            self.gui_sock.close()
        sys.exit()


    # Some funcions for play song button
    def inserting_option(self):
        self.option.insert(tk.END, "First Lullaby")
        self.option.insert(tk.END, "Second Lullaby")
        self.option.insert(tk.END, "Third Lullaby")
        self.option.insert(tk.END, "Fourth Lullaby")

    def url_cache_timer(self, name):
        time.sleep(self.url_time_to_live)
        try:
            self.recordings[name]["isAlive"] = False
        except:
            # self.recordings is wiped
            pass

    def s3_ls_recordings(self):
        self.recordings = {}
        names = s3i.get_all()["names"]
        for name in names:
            if name in self.recordings_ls:
                continue

            name = os.path.splitext(name)[0]
            self.recordings[name] = {"url": None, "isAlive": False}
            self.option.insert(tk.END, name)
    
    def ls_recordings(self):
        for name in self.recordings_ls:
            name = os.path.splitext(name)[0]
            self.option.insert(tk.END, name)

    def play_sound(self):
        scrollbar_command = self.option.get('active')
        if scrollbar_command == 'First Lullaby':
            pub_cmd.publish(client, "lullaby1.mp3")
        elif scrollbar_command == 'Second Lullaby':
            pub_cmd.publish(client, "lullaby2.mp3")
        elif scrollbar_command == 'Third Lullaby':
            pub_cmd.publish(client, "lullaby3.mp3")
        elif scrollbar_command == 'Fourth Lullaby':
            pub_cmd.publish(client, "lullaby4.mp3")
    
    def play_sound_local(self):
        audio_path = self.option.get('active')
        audio_path = os.path.join(self.recording_path, audio_path) + ".wav"
        self.ap = AudioPlayer(audio_path)
        self.ap.play(block=False)
    
    def pause_sound_local(self):
        self.ap.pause()

    def resume_sound_local(self):
        self.ap.resume()
    
    def delete_recording(self):
        name = self.option.get('active')
        audio_path = os.path.join(self.recording_path, name) + ".wav"
        
        if self.ap is not None:
            self.ap.stop()
            self.ap.close()
        
        try:
            os.remove(audio_path)
        except OSError:
            print("Failed to delete recordings")
        else:
            self.recordings_ls.remove(name + ".wav")
            self.option.delete(self.option.curselection())
    
    def get_recordings(self):
        selected_options = self.option.curselection()
        for opt in selected_options[::-1]:
            name = self.option.get(opt)
            name_ext = name +".wav"

            if name not in self.recordings:
                return
            
            url_info = self.recordings[name]
            if url_info["isAlive"]:
                url = url_info["url"]

            else:
                res = s3i.get_one(name_ext)
                if res["status"]:
                    url = res["url"]
                    self.recordings[name]["isAlive"] = True
                    self.recordings[name]["url"] = url

                    # Start cache timer
                    url_timer = threading.Thread(target=self.url_cache_timer, args=(name,))
                    url_timer.setDaemon(True)
                    url_timer.start()

                    download = threading.Thread(target=self._download, args=(url, name_ext))
                    download.start()

                    self.option.delete(opt)

                else:
                    print("Error in fetching data")
                    return

    def _download(self, url, name_ext):
        get_res = requests.get(url=url)

        fname = os.path.join(self.recording_path, name_ext)
        try:
            with open(fname, "wb") as f:
                f.write(get_res.content)

        except OSError:
            print("Failed to write in file.")

        else:
            self.recordings_ls.append(name_ext)

    def quit_record_window(self):
        self.record_screen.destroy()
        self.button_h.configure(state = tk.NORMAL)
    
    def quit_play_song_window3(self):
        self.new_window3.destroy()
        self.download_button.configure(state = tk.NORMAL)
    
    def quit_play_song_window2(self):
        self.new_window2.destroy()
        self.record_button.configure(state = tk.NORMAL)
    


    def pause_sound(self):
        pub_cmd.publish(client, "pause")

    def resume_sound(self):
        pub_cmd.publish(client, "resume")
    
    def stop_sound(self):
        pub_cmd.publish(client, "pause")
    
    def quit_play_song_window(self):
        self.new_window.destroy()
        self.button_b.configure(state = tk.NORMAL)


    # Some Functions for Chat Client
    def receive(self):
        """Handles receiving of messages."""
        while True:
            try:
                self.msg = self.client_socket.recv(self.BUFSIZ).decode("utf8")
                self.msg_list.insert(tk.END, self.msg)
            except OSError:  # Possibly client has left the chat.
                break
    
    def send(self, event=None):  # event is passed by binders.
        """Handles sending of messages."""
        self.msg = self.my_msg.get()
        self.my_msg.set("")  # Clears input field.
        self.client_socket.send(bytes(self.msg, "utf8"))
        if self.msg == "quit":
            self.chat_window.destroy()
            self.client_socket.shutdown(SHUT_RDWR)
            self.client_socket.close()
    
    def on_closing(self, event=None):
        """This function is to be called when the chat window is closed."""
        self.button_e.configure(state = tk.NORMAL)
        self.my_msg.set("quit")
        self.send()
    

    # Some functions for changing login info
    def changing_password(self):
        self.pass_button.configure(state = tk.DISABLED)
        self.password = tk.StringVar()
        self.password2 = tk.StringVar()
        self.password_screen = tk.Toplevel(self.login_screen)
        self.password_screen.geometry("300x300")
        self.password_screen.configure(bg = "white")
        self.password_lable = Label(self.password_screen, text="Current Password * ", bg = "white")
        self.password_lable.pack()
        self.password_entry = Entry(self.password_screen, textvariable=self.password, show='*')
        self.password_entry.pack()
        tk.Label(self.password_screen, text="", bg = "white").pack()
        self.password_lable2 = Label(self.password_screen, text="New Password * ", bg = "white")
        self.password_lable2.pack()
        self.password_entry2 = Entry(self.password_screen, textvariable=self.password2, show='*')
        self.password_entry2.pack()
        tk.Label(self.password_screen, text="" , bg = "white").pack()
        tk.Button(self.password_screen, text="Update", width=10, height=1, bg = "deep sky blue", relief=tk.RAISED, borderwidth=3, command = self.register_pass).pack()

        self.info_screen = tk.Frame(self.password_screen)
        self.info_screen.pack()
        self.info_regis = tk.Label(self.info_screen)
        self.info_regis.pack()
        self.password_screen.protocol("WM_DELETE_WINDOW", self.quit_password_window)


    def changing_email(self):
        self.email_button.configure(state = tk.DISABLED)
        self.email_address = tk.StringVar()
        self.email_screen = tk.Toplevel(self.login_screen)
        self.email_screen.geometry("300x300")
        self.email_screen.configure(bg = "white")
        self.password_lable = Label(self.email_screen, text="Current Password * ", bg = "white")
        self.password_lable.pack()
        self.password_entry = Entry(self.email_screen, textvariable=self.password, show='*')
        self.password_entry.pack()
        tk.Label(self.email_screen, text="", bg = "white").pack()
        self.email_lable = Label(self.email_screen, text="Email Address * ", bg = "white")
        self.email_lable.pack()
        self.email_address_entry = Entry(self.email_screen, textvariable=self.email_address)
        self.email_address_entry.pack()
        tk.Label(self.email_screen, text="" , bg = "white").pack()
        tk.Button(self.email_screen, text="Update", width=10, height=1, bg = "deep sky blue", relief=tk.RAISED, borderwidth=3, command = self.register_email).pack()

        self.info_screen = tk.Frame(self.email_screen)
        self.info_screen.pack()
        self.info_regis = tk.Label(self.info_screen)
        self.info_regis.pack()

        self.email_screen.protocol("WM_DELETE_WINDOW", self.quit_email_window)

    def register_pass(self):
        self.password_info = self.password.get()
        self.password_entry.delete(0, END)
        self.password_info2 = self.password2.get()
        self.password_entry2.delete(0, END)

        if(isBlank(self.password_info) or isBlank(self.password_info2)):
            self.empty_filler()
            self.info_regis.configure(text="Failed", justify = "center", bg = "white", fg="deep sky blue", font=("calibri", 11))
        else:
            db = DBInterface.DBInterface()
            log = db.login(self.username_info2, self.password_info)
            data2 = json.loads(log)
            if(data2["status"] == True):
                db.update_password(self.ID_info2, self.password_info, self.password_info2)
                self.info_regis.configure(text="Success Changing Password", justify = "center", bg = "white", fg="deep sky blue", font=("calibri", 11))
            else:
                self.info_regis.configure(text="Wrong Current Password", justify = "center", bg = "white", fg="deep sky blue", font=("calibri", 11))

    
    def register_email(self):
        self.password_info = self.password.get()
        self.password_entry.delete(0, END)
        self.email_info = self.email_address.get()
        self.email_address_entry.delete(0, END)

        if(isBlank(self.email_info) or isBlank(self.password_info)):
            self.empty_filler()
            self.info_regis.configure(text="Failed", justify = "center", bg = "white", fg="deep sky blue", font=("calibri", 11))
        else:
            db = DBInterface.DBInterface()
            log = db.login(self.username_info2, self.password_info)
            data2 = json.loads(log)
            if(data2["status"] == True):
                db.update_email(self.ID_info2, self.email_info2, self.email_info, self.password_info)
                pub_cmd.publish(client, "update email")
                self.info_regis.configure(text="Success Changing Email", justify = "center", bg = "white", fg="deep sky blue", font=("calibri", 11))
            else:
                self.info_regis.configure(text="Wrong Current Password", justify = "center", bg = "white", fg="deep sky blue", font=("calibri", 11))
    
    def quit_login_window(self):
        self.login_screen.destroy()
        self.button_d.configure(state = tk.NORMAL)

    def quit_password_window(self):
        self.password_screen.destroy()
        self.pass_button.configure(state = tk.NORMAL)
    
    def quit_email_window(self):
        self.email_screen.destroy()
        self.email_button.configure(state = tk.NORMAL)

    # Some Useful Functions
    def getting_user_info(self):
        self.username_info2 = self.user_info["username"]
        self.email_info2 = self.user_info["email"] 
        self.notification_info2 = self.user_info["notification"]
        self.ID_info2 = self.user_info["id"]
        
    def empty_filler(self):
        self.empty_filler_screen = Toplevel()
        self.empty_filler_screen.title("Error Registration")
        self.empty_filler_screen.geometry("200x100")
        Label(self.empty_filler_screen, text="You have not filled the filler box").pack()
        Button(self.empty_filler_screen, text="OK", bg = "deep sky blue", relief=tk.RAISED, borderwidth=3, command= self.delete_empty_filler_screen).pack()

    def delete_empty_filler_screen(self):
        self.empty_filler_screen.destroy()

    def isBlank(self, my_string):
        if my_string and my_string.strip():
            return False
        return True
Exemple #14
0
def play(audio_player: AudioPlayer, schedule: dict) -> None:
    """Play the audio"""
    logging.info(f"Playing: {schedule}")
    audio_player.play(block=False)
Exemple #15
0
def play_sound(sound: AudioPlayer) -> None:
    try:
        sound.volume = SETTINGS['settings']['volume']
        sound.play()
    except Exception as err:
        LOGGER.error(err, exc_info=True)
Exemple #16
0
def play(path):
    music = AudioPlayer(path)
    music.play()

    return music
Exemple #17
0
def device_play_app():
	audio = AudioPlayer(musicdir+"/"+queue[tracknumber])
	audio.volume = volume
	audio.play(block=True)
Exemple #18
0
from audioplayer import AudioPlayer
import os

for fmt in ('mp3', 'ogg', 'wav', 'mid'):
    # https://opengameart.org/content/orient-theme-jingle
    soundfile = 'Orient Theme.' + fmt
    file = os.path.join(os.path.dirname(__file__), 'audio', soundfile)
    try:
        p = AudioPlayer(file)
        print('Playing {} file: {}'.format(fmt, soundfile))
        p.play(block=True)
    except Exception as e:
        print(e)
Exemple #19
0
 def sfx(self, effect, volume):
     audioplayer = AudioPlayer(effect)
     audioplayer.volume = volume
     audioplayer.play(block=True)
     audioplayer.close()
wrongcard = False

playerturndone = False
comturndone = False

if playornoplay == "yes":

    time.sleep(1)
    os.system("clear")

    #This means the game will run
    print("then lets play!\n")
    #Game rules
    rulessong = AudioPlayer("rules song.mp3")
    rulessong.play()

    print("Here is how to play this game:\n")
    print(
        "there will be six cards you can only pick 3 and the com player will pick 3\n"
    )
    print(
        "you pick the three cards and win by luck. you might have good luck meaning you win\n"
    )
    print("or you have bad luck and you lose!\n")
    print(
        "press key 1 to 6 to choose a card for each turn you get and then press enter\n"
    )
    print("when you select one card you cant use it again.\n")
    print(
        "For example. you use 3rd card as first card, you can't use it again nor the com use it\n"
Exemple #21
0
def play_sound(sound: AudioPlayer) -> None:
    try:
        sound.volume = SETTINGS.get('volume', 100)
        sound.play()
    except Exception as err:
        LOGGER.error(err, exc_info=True)
class ResultCreator(object):
    def __init__(self, attack, resultfile, currentContent):
        self.audio = None
        self.paused = False
        self._attack = attack
        self._resultFile = resultfile
        self._content = currentContent
        self.load_attack_results()

    def getResultFileExtension(self):
        name_file, file_extension = os.path.splitext(self._resultFile)
        return file_extension

    def load_attack_results(self):
        if self._attack == 'VoIP Eavesdropping':
            if self.getResultFileExtension() == '.wav':
                return self.createAudioPlayer()
        else:
            if self.getResultFileExtension() == '.xlsx':
                return self.parseExcel(self._attack, self._resultFile,
                                       self._content)

    def createAudioPlayer(self):
        self.audio = AudioPlayer(
            "Model/ResultAttack/Results/VoIP Eavesdropping/" +
            self._resultFile)
        return self.audio

    def play(self):
        if self.audio is not None:
            self.audio.play(block=False)

    def managePause(self):
        if self.audio is not None:
            if self.paused:
                self.resume()
            else:
                self.pause()

    def pause(self):
        if self.audio is not None:
            self.paused = True
            self.audio.pause()

    def resume(self):
        self.paused = False
        self.audio.resume()

    def changeState(self):
        self.pause = (not self.paused)

    def close(self):
        self.audio.close()

    def parseExcel(self, type_attack, name_file, currentContent):
        filepath = "Model/ResultAttack/Results/" + type_attack + "/" + name_file
        wb = load_workbook(filepath)
        sheet = wb.active
        max_row = sheet.max_row
        max_column = sheet.max_column
        treeview = ttk.Treeview(currentContent, selectmode='browse')
        style = ttk.Style()
        style.configure("Treeview.Heading", font=("Segoe UI", "16", "bold"))

        numberColumns = []
        for j in range(1, max_column + 1):
            numberColumns.append(str(j))
        treeview["columns"] = tuple(numberColumns)
        treeview['show'] = 'headings'
        for j in range(1, max_column + 1):
            treeview.column(str(j), anchor='center')
            treeview.heading(str(j), text=sheet.cell(row=1, column=j).value)

        treeview.tag_configure("data",
                               foreground="#C70039",
                               font=("Segoe UI", "12", "bold"))
        for i in range(2, max_row + 1):
            l = []
            for j in range(1, max_column + 1):
                cell_obj = sheet.cell(row=i, column=j)
                l.append(cell_obj.value)
            treeview.insert("",
                            'end',
                            text="L" + str(i),
                            values=tuple(l),
                            tags=("data", ))
        treeview.grid(column=4,
                      row=1,
                      columnspan=max_column,
                      rowspan=max_row,
                      sticky=('EWNS'))
        self.treeview = treeview
        return treeview

    def grid_remove(self):
        if self.treeview != None:
            self.treeview.grid_forget()