Exemple #1
0
class TrayMenu:
    def __init__(self):
        mirror_logger.info("Started Mirrorcast")
        self.indicator = appindicator.Indicator.new(
            "mirrorMenu",
            os.path.abspath('/opt/mirrorcast/mirrorcast_tray.png'),
            appindicator.IndicatorCategory.SYSTEM_SERVICES)
        self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE)

        #A string so we know what the user is doing
        self.state = "stopped"
        self.menu = gtk.Menu()

        #Set up menu
        item_start = gtk.MenuItem('Start Mirroring')
        item_start.connect('activate', self.start)
        self.menu.append(item_start)
        #Media Sub Menu
        self.media_sub = gtk.Menu()
        item_media = gtk.MenuItem('Play Media (Experimental)')
        item_media.set_submenu(self.media_sub)
        item_file = gtk.MenuItem('Media File')
        item_file.connect('activate', self.file)
        self.media_sub.append(item_file)
        item_dvd = gtk.MenuItem('Play DVD')
        item_dvd.connect('activate', self.dvd)
        self.media_sub.append(item_dvd)
        item_youtube = gtk.MenuItem('Youtube URL')
        item_youtube.connect('activate', self.youtube)
        self.media_sub.append(item_youtube)
        self.menu.append(item_media)

        item_freeze = gtk.MenuItem('Freeze')
        item_freeze.connect('activate', self.freeze)
        self.menu.append(item_freeze)
        item_update = gtk.MenuItem('Update Mirrorcast')
        item_update.connect('activate', self.update)
        self.menu.append(item_update)
        item_quit = gtk.MenuItem('Quit')
        item_quit.connect('activate', self.quit)
        self.menu.append(item_quit)
        sep = gtk.SeparatorMenuItem()
        self.menu.append(sep)
        self.outputSub = gtk.Menu()
        output = gtk.MenuItem("Cast To")
        output.set_submenu(self.outputSub)
        '''Recievers/Hosts Menu'''
        self.hosts = hosts()
        #Varaibles for sorting receivers into sub-menus
        self.list_receivers = []
        self.sortedMenu = []
        sortSub = []
        subitems = []
        sortInd = 0
        sortInd2 = 0
        #Add receivers to menu
        self.list_receivers.append(gtk.RadioMenuItem('None'))
        for ind, i in enumerate(self.hosts.receivers):
            #allow user to sort their receivers into sublists
            if i['aspect'] == "sub":
                self.sortedMenu.append(gtk.Menu())
                sortSub.append(gtk.MenuItem(i['host']))
                sortSub[sortInd].set_submenu(self.sortedMenu[sortInd])
                self.outputSub.append(sortSub[sortInd])
                sortInd = sortInd + 1
            elif sortInd > 0:
                try:
                    subitems.append(
                        gtk.RadioMenuItem(str(i['host']),
                                          group=self.subitems[sortInd2 - 1]))
                except:
                    subitems.append(
                        gtk.RadioMenuItem(str(i['host']),
                                          group=self.list_receivers[0]))
                subitems[sortInd2].connect('toggled', self.hosts.set_receiver,
                                           subitems[sortInd2].get_label())
                self.sortedMenu[sortInd - 1].append(subitems[sortInd2])
                sortInd2 = sortInd2 + 1
            else:
                self.list_receivers.append(
                    gtk.RadioMenuItem(str(i['host']),
                                      group=self.list_receivers[ind - 1]))
        for i in self.list_receivers:
            self.outputSub.append(i)
            i.connect('toggled', self.hosts.set_receiver, i.get_label())
        self.list_receivers[0].set_active(True)

        self.Display = Displays()
        self.displaysSub = gtk.Menu()
        displays = gtk.MenuItem("Select Display to Mirror")
        displays.set_submenu(self.displaysSub)
        self.list_displays = []
        #Add displays/monitors to menu
        for ind, i in enumerate(self.Display.monitors):
            if ind != 0:
                self.list_displays.append(
                    gtk.RadioMenuItem(str(i[0]),
                                      group=self.list_displays[ind - 1]))
            else:
                self.list_displays.append(
                    gtk.RadioMenuItem(self.Display.monitors[0][0]))
        for i in self.list_displays:
            self.displaysSub.append(i)
            i.connect('toggled', self.Display.set_display, i.get_label())
        self.list_displays[0].set_active(True)
        self.menu.append(output)
        self.menu.append(displays)
        self.menu.show_all()
        self.indicator.set_menu(self.menu)
        self.sound = Audio()
        self.ffmpeg = None
        self.vlc = None
        self.sleep = dbus_listen(item_start, self.ffmpeg)

    #the following function is run when the user clicks "Start/Stop Mirroring"
    def start(self, w):
        notify.init("mirrorMenu")
        mirror_logger.info("Detected Audio Device: " +
                           str(self.sound.audioDev))
        if w.get_label() == 'Start Mirroring':
            #If the user did not select a receiver
            if self.hosts.receiver == "None":
                notify.init("mirrorMenu")
                notify.Notification.new("Error",
                                        "You did not select a receiver",
                                        None).show()
                return
            notify.Notification.new(
                "Connecting to Receiver",
                "Attempting to establish connection to " + self.hosts.receiver,
                None).show()
            mirror_logger.info("User is trying to connect to " +
                               self.hosts.receiver)
            #If we cannot connect to the receiver
            if self.connect("play,") == False:
                notify.init("mirrorMenu")
                notify.Notification.new(
                    "Connection Error",
                    "Could not connect to" + self.hosts.receiver +
                    ". please try again and if problem persists then please contact your system administrator.",
                    None).show()
                mirror_logger.warning("Failed to connect to " +
                                      self.hosts.receiver)
                return
            #Create and start loop that checks if receiver can still be reached
            mirror_logger.info("User connected to " + self.hosts.receiver)
            w.set_label("Stop Mirroring")
            self.start_casting()
            #Start a loop that will keep checking if the client can still reach the server
            connection = threading.Thread(target=self.alive, args=[w])
            connection.start()
        elif w.get_label() == 'Stop Mirroring':
            self.state = "stopped"
            self.sound.audio(False)
            self.Display.display(False, self.hosts.aspect)
            if self.ffmpeg != None:
                if self.ffmpeg.poll() == None:
                    self.ffmpeg.terminate()
            w.set_label('Start Mirroring')
            return

    def start_casting(self):
        res = self.Display.resolution
        self.sleep.sleep = False
        #If receiver is set to display 4:3 and the client is 16:9 then change screen resoltion to 1024x768
        if (self.hosts.aspect == "wide" or self.hosts.aspect == "16:9"
                or self.hosts.aspect
                == "16:10") and self.Display.get_ratio(res) == "16:9":
            self.hosts.aspect = "16:9"
        else:
            self.hosts.aspect = "4:3"
            if self.Display.get_ratio(self.Display.resolution) != "4:3":
                res = "1024x768"
                try:
                    subprocess.call("xrandr --output " + self.Display.type +
                                    " --mode 1024x768",
                                    shell=True)
                except:
                    mirror_logger.warning(
                        "Could now change screen resolution to 4:3")
                    notify.Notification.new(
                        "Resolution Error",
                        "Failed to change screen resolution to match receiver.",
                        None).show()
                    return
        self.sound.audio(True)
        #Start encoding and sending the stream to the receiver
        self.state = "casting"
        time.sleep(1)
        display = os.environ['DISPLAY']  #get display of current user
        self.ffmpeg = subprocess.Popen([
            "ffmpeg", "-loglevel", "warning", "-f", "pulse", "-ac", "2", "-i",
            "default", "-async", "1", "-f", "x11grab", "-r", "25", "-s",
            str(res), "-i",
            str(display) + "+" + str(int(self.Display.xoffset)) + "," +
            str(self.Display.yoffset), "-aspect", self.hosts.aspect, "-vcodec",
            "libx264", "-pix_fmt", "yuv420p", "-tune", "zerolatency",
            "-preset", "ultrafast", "-vf",
            "scale=" + str(res).replace('x', ':'), "-f", "mpegts",
            "udp://" + self.hosts.receiver + ":8090"
        ],
                                       stdout=subprocess.PIPE)
        self.sound.monitor_audio()
        notify.Notification.new(
            "Connection Established",
            "Connection to " + self.hosts.receiver + " established.",
            None).show()

    def alive(self, w):
        mirror_logger.info("Sending Alive Packets")
        timestamp = time.localtime()
        timeout = 10
        retries = 1
        i = 0
        command = "active," + socket.gethostname()

        while True:
            try:
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.settimeout(5)
                sock.connect((self.hosts.receiver, 8092))
                sock.settimeout(None)
                #If the user's computer is going to sleep
                if self.state == "stopped" or self.sleep.sleep == True:
                    mirror_logger.info("User stopped casting")
                    command = "stop," + socket.gethostname()
                    sock.send(command.encode('ascii'))
                    sock.close()
                    return
                if self.state == "freeze":
                    logging.info("User frooze their screen")
                    command = "freeze," + socket.gethostname()
                    sock.send(command.encode('ascii'))
                    status = sock.recv(1024)
                    if status.decode('ascii') == "paused":
                        self.ffmpeg.terminate()
                        w.set_label('Start Mirroring')
                        notify.init("mirrorMenu")
                        notify.Notification.new(
                            "Freezed",
                            "You have frozen your current desktop, click Start Mirroring to resume",
                            None).show()
                        self.state = "stopped"
                        time.sleep(1)
                        self.sound.audio(False)
                        self.Display.display(False, self.hosts.aspect)
                    sock.close()
                    return
                sock.send(command.encode('ascii'))
                status = sock.recv(1024)
                if status.decode('ascii') == "ok":
                    timestamp = time.localtime()
                sock.close()
            except:
                #time.sleep(1)
                if (
                        time.mktime(time.localtime()) - time.mktime(timestamp)
                ) >= timeout and self.state != "stopped" and self.sleep.sleep != True:
                    i = i + 1
                    if i == 1:
                        mirror_logger.warning("Attempting to reconnect to " +
                                              self.hosts.receiver)
                        if self.ffmpeg.poll() == None:
                            self.ffmpeg.terminate()
                        notify.Notification.new(
                            "Reconnecting",
                            "Connection to " + self.hosts.receiver +
                            " has been lost. Attempting to reconnect.",
                            None).show()
                        time.sleep(2)
                    if self.connect("play,") == True:
                        mirror_logger.info("Reconnected to " +
                                           self.hosts.receiver)
                        self.start_casting()
                        i = 0
                    if i == retries:
                        self.state = "stopped"
                        w.set_label('Start Mirroring')
                        notify.init("mirrorMenu")
                        notify.Notification.new(
                            "Connection Lost", "Connection to " +
                            self.hosts.receiver + " timed out.", None).show()
                        mirror_logger.warning(
                            "Connection Lost: Connection to " +
                            self.hosts.receiver + " timed out.")
                        return

    def quit(self, w):
        self.sound.audio(False)
        self.state = "stopped"
        self.Display.display(False, self.hosts.aspect)
        #kill ffmpeg incase user forgot to click "stop"
        if self.ffmpeg != None:
            if self.ffmpeg.poll() == None:
                self.ffmpeg.terminate()
        gtk.main_quit()

    def freeze(self, w):
        if self.state == "stopped":
            notify.init("mirrorMenu")
            notify.Notification.new(
                "Not Mirroring",
                "To freeze your screen you need to Start Mirroring.",
                None).show()
            return
        self.state = "freeze"
        return

    def update(self, w):
        if self.state == "casting":
            notify.init("mirrorMenu")
            notify.Notification.new(
                "Cannot Update",
                "Please stop mirroring before you try to update", None).show()
            return
        subprocess.call("/opt/mirrorcast/mirrorcast-autoupdater.sh",
                        shell=True)
        gtk.main_quit()
        return

    def file(self, w):
        if self.state == "casting":
            notify.init("mirrorMenu")
            notify.Notification.new(
                "Error",
                "Please stop mirroring before you try to use this feature",
                None).show()
        else:
            if self.hosts.receiver == "None":
                notify.init("mirrorMenu")
                notify.Notification.new("Error",
                                        "Please select a receiving device",
                                        None).show()
                return
            if self.connect("media,") == False:
                notify.init("mirrorMenu")
                notify.Notification.new(
                    "Connection Error",
                    "Could not connect to" + self.hosts.receiver +
                    ". please try again and if problem persists then please contact your system administrator.",
                    None).show()
                mirror_logger.warning("Failed to connect to " +
                                      self.hosts.receiver)
                return
            mirror_logger.info("User connected to " + self.hosts.receiver +
                               " to play media file")
            select = Tk()
            select.withdraw()
            types = [("Video Files", ("*.mp4", "*.avi", "*.mov", "*.mkv",
                                      "*.flv", "*.mpeg", "*.mpg", "*.wmv")),
                     ("All files", "*.*")]
            file = askopenfilename(filetypes=types)
            select.destroy()
            print(file)
            if file == () or file == None or file == "":
                return
            if self.vlc != None:
                if self.vlc.poll() == None:
                    self.vlc.terminate()
            subprocess.Popen([
                "vlc", "-q", "file://" + file, "--sout-avcodec-strict=-2",
                "--sout=#transcode{vcodec=h264,vb=2000,scale=Auto}:duplicate{dst=http{mux=ts,dst=:8090/video},dst=display}",
                ":sout-keep"
            ],
                             stdout=subprocess.PIPE)
            time.sleep(2)
            self.send_cmd("media-start,")
            ui = mediaui(self.hosts.receiver)

    def dvd(self, w):
        if self.state == "casting":
            notify.init("mirrorMenu")
            notify.Notification.new(
                "Error",
                "Please stop mirroring before you try to use this feature",
                None).show()
        else:
            if self.hosts.receiver == "None":
                notify.init("mirrorMenu")
                notify.Notification.new("Error",
                                        "Please select a receiving device",
                                        None).show()
                return
            if self.connect("media,") == False:
                notify.init("mirrorMenu")
                notify.Notification.new(
                    "Connection Error",
                    "Could not connect to" + self.hosts.receiver +
                    ". please try again and if problem persists then please contact your system administrator.",
                    None).show()
                mirror_logger.warning("Failed to connect to " +
                                      self.hosts.receiver)
                return
            mirror_logger.info("User connected to " + self.hosts.receiver +
                               " to stream DVD")
            if self.vlc != None:
                if self.vlc.poll() == None:
                    self.vlc.terminate()
            self.vlc = subprocess.Popen([
                "vlc", "-q", "dvdsimple://", "--sout-avcodec-strict=-2",
                "--sout-x264-preset", "ultrafast",
                "--sout=#transcode{vcodec=h264,vb=2000,scale=Auto}:duplicate{dst=http{mux=ts,dst=:8090/video},dst=display}",
                ":sout-keep"
            ],
                                        stdout=subprocess.PIPE)
            time.sleep(2)
            self.send_cmd("media-start,")
            ui = mediaui(self.hosts.receiver)

    def youtube(self, w):
        if self.state == "casting":
            notify.init("mirrorMenu")
            notify.Notification.new(
                "Error",
                "Please stop mirroring before you try to use this feature",
                None).show()
        else:
            if self.hosts.receiver == "None":
                notify.init("mirrorMenu")
                notify.Notification.new("Error",
                                        "Please select a receiving device",
                                        None).show()
            if self.connect("tu-media,") == False:
                notify.init("mirrorMenu")
                notify.Notification.new(
                    "Connection Error",
                    "Could not connect to" + self.hosts.receiver +
                    ". please try again and if problem persists then please contact your system administrator.",
                    None).show()
                mirror_logger.warning("Failed to connect to " +
                                      self.hosts.receiver)
                return
            ui = tubeui(self.hosts.receiver)

    def connect(self, cmd):
        command = cmd + socket.gethostname()
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(5)
            sock.connect((self.hosts.receiver, 8092))
            sock.settimeout(None)
            sock.send(command.encode('ascii'))
            while True:
                status = sock.recv(8024)
                #if server returns busy then some one else is already using this receiver
                if status.decode('ascii') == "busy":
                    notify.init("mirrorMenu")
                    mirror_logger.info("User attempted to connect to " +
                                       self.hosts.receiver +
                                       " but receiver was busy")
                    notify.Notification.new(
                        "Error",
                        "Sorry some one else is already  connected to this receiver, please try again later.",
                        None).show()
                    sock.close()
                    return False
                #If client succeeds  in connecting to receiver
                elif status.decode('ascii') == "ready":
                    mirror_logger.info("Server is ready")
                    break
            sock.close()
        except:
            return False
        if cmd == "play,":
            self.state = "casting"
        return True

    def send_cmd(self, cmd):
        command = cmd + socket.gethostname()
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(5)
            sock.connect((self.hosts.receiver, 8092))
            sock.settimeout(None)
            sock.send(command.encode('ascii'))
            sock.close()
        except:
            return False