run.py

#!/usr/bin/python

from gi.repository import Gtk as gtk
from gi.repository import GLib, Gio, GObject, Notify, GdkPixbuf, Gdk
from gi.repository import AppIndicator3 as appindicator
import os
import time

import urllib
import json
import sys
import webbrowser
import threading

class Twitch:
  def fetch_followed_channels(self, username):
    """Fetch user followed channels and return a list with channel names."""
    try:
      self.followed_channels = []
      
      self.f = urllib.urlopen("https://api.twitch.tv/kraken/users/{0}/follows/channels?client_id=oe77z9pq798tln7ngil0exwr0mun4hj&direction=DESC&limit=100&offset=0&sortby=created_at".format(username))
      self.data = json.loads(self.f.read())

      # Return 404 if user does not exist
      try:
        if (self.data["status"] == 404):
          return 404
      except KeyError:
        pass

      self.pages = (self.data['_total'] - 1) / 100
      for page in range(0, self.pages + 1):
        if page != 0:
          self.f = urllib.urlopen("https://api.twitch.tv/kraken/users/{0}/follows/channels?client_id=oe77z9pq798tln7ngil0exwr0mun4hj&direction=DESC&limit=100&offset={1}&sortby=created_at".format(username, (page * 100)))
          self.data = json.loads(self.f.read())

        for channel in self.data['follows']:
          self.followed_channels.append(channel['channel']['name'])
      
      return self.followed_channels
    except IOError:
      return None

  def fetch_live_streams(self, channels):
    """Fetches live streams data from Twitch, and returns as list of dictionaries"""
    try:
      self.channels_count = len(channels)
      self.live_streams = []
      
      self.pages = (self.channels_count - 1) / 75
      for page in range(0, self.pages + 1):
        self.offset = (page * 75) + 75
        if (self.offset % 75 > 0):
          self.offset = self.channels_count 
        self.channels_offset = channels[(page * 75):self.offset]

        self.f = urllib.urlopen("https://api.twitch.tv/kraken/streams?client_id=oe77z9pq798tln7ngil0exwr0mun4hj&channel={0}".format(','.join(self.channels_offset)))
        self.data = json.loads(self.f.read())

        for stream in self.data['streams']:
          # For some reason sometimes stream status and game is not present in
          # twitch API.
          try:
            self.status = stream['channel']['status']
          except KeyError:
            self.status = ""
          
          st = {
            'name': stream['channel']['display_name'],
            'status': self.status,
            'image': stream['channel']['logo'],
            'url': "http://www.twitch.tv/%s" % stream['channel']['name']
          }

          self.live_streams.append(st)
      return self.live_streams
    except IOError:
      return None

class Indicator():
  SETTINGS_KEY = "apps.twitch-indicator"
  LIVE_STREAMS = []

  def __init__(self):
    self.timeout_thread = None

    # Setup applet icon depending on DE
    self.desktop_env = os.environ.get('DESKTOP_SESSION')
    if self.desktop_env == "pantheon":
      self.applet_icon = "twitch-elementary"
    elif self.desktop_env == "mate":
      self.applet_icon = "twitch-mate"
    else:
      self.applet_icon = "twitch-ubuntu"

    # Create applet
    self.a = appindicator.Indicator.new(
      'Twitch indicator',
      'indicator-messages',
      appindicator.IndicatorCategory.APPLICATION_STATUS
    )
    self.a.set_status(appindicator.IndicatorStatus.ACTIVE)
    self.a.set_icon_theme_path("/usr/lib/twitch-indicator/")
    self.a.set_icon(self.applet_icon)

    # Load settings
    self.settings = Gio.Settings.new(self.SETTINGS_KEY)

    # Setup menu
    self.menu = gtk.Menu()
    self.menuItems = [
      gtk.MenuItem('Check now'),
      gtk.SeparatorMenuItem(),
      gtk.MenuItem('Settings'),
      gtk.MenuItem('Quit')
    ]

    self.menuItems[0].connect('activate', self.refresh_streams_init, [True])
    self.menuItems[-2].connect('activate', self.settings_dialog)
    self.menuItems[-1].connect('activate', self.quit)
    
    for i in self.menuItems:
      self.menu.append(i)

    self.a.set_menu(self.menu)
    
    self.menu.show_all()

    self.refresh_streams_init(None)

  def open_link(self, widget, url):
    """Opens link in a default browser."""
    webbrowser.open_new_tab(url)

  def refresh_streams_init(self, widget, button_activate=False):
    """Initializes thread for stream refreshing."""
    self.t = threading.Thread(target=self.refresh_streams)
    self.t.daemon = True
    self.t.start()

    if (button_activate is False):
      self.timeout_thread = threading.Timer(self.settings.get_int("refresh-interval")*60, self.refresh_streams_init, [None])
      self.timeout_thread.start()

  def settings_dialog(self, widget):
    """Shows applet settings dialog."""
    self.dialog = gtk.Dialog(
      "Settings",
      None,
      0,
      (gtk.STOCK_CANCEL, gtk.ResponseType.CANCEL,
       gtk.STOCK_OK, gtk.ResponseType.OK)
    )

    self.builder = gtk.Builder()
    self.builder.add_from_file("/usr/lib/twitch-indicator/twitch-indicator.glade")

    self.builder.get_object("twitch_username").set_text(self.settings.get_string("twitch-username"))
    self.builder.get_object("show_notifications").set_active(self.settings.get_boolean("enable-notifications"))
    self.builder.get_object("refresh_interval").set_value(self.settings.get_int("refresh-interval"))

    self.box = self.dialog.get_content_area()
    self.box.add(self.builder.get_object("grid1"))
    self.response = self.dialog.run()

    if self.response == gtk.ResponseType.OK:
      self.settings.set_string("twitch-username", self.builder.get_object("twitch_username").get_text())
      self.settings.set_boolean("enable-notifications", self.builder.get_object("show_notifications").get_active())
      self.settings.set_int("refresh-interval", self.builder.get_object("refresh_interval").get_value_as_int())
    elif self.response == gtk.ResponseType.CANCEL:
      pass

    self.dialog.destroy()

  def disable_menu(self):
    """Disables check now button."""
    self.menu.get_children()[0].set_sensitive(False)
    self.menu.get_children()[0].set_label("Checking...")

  def enable_menu(self):
    """Enables check now button."""
    self.menu.get_children()[0].set_sensitive(True)
    self.menu.get_children()[0].set_label("Check now")

  def add_streams_menu(self, streams):
    """Adds streams list to menu."""
    # Remove live streams menu if already exists
    if (len(self.menuItems) > 4):
      self.menuItems.pop(2)
      self.menuItems.pop(1)

    # Create menu
    self.streams_menu = gtk.Menu() 
    self.menuItems.insert(2, gtk.MenuItem("Live channels ({0})".format(len(streams))))
    self.menuItems.insert(3, gtk.SeparatorMenuItem())
    self.menuItems[2].set_submenu(self.streams_menu)

    # Order streams by alphabetical order
    self.streams_ordered = sorted(streams, key=lambda k: k["name"].lower())
    
    for index, stream in enumerate(self.streams_ordered):
      self.streams_menu.append(gtk.MenuItem(stream["name"]))
      self.streams_menu.get_children()[index].connect('activate', self.open_link, stream["url"])
    
    for i in self.streams_menu.get_children():
      i.show()

    # Refresh all menu by removing and re-adding menu items
    for i in self.menu.get_children():
      self.menu.remove(i)

    for i in self.menuItems:
      self.menu.append(i)

    self.menu.show_all()

  def refresh_streams(self):
    """Refreshes live streams list. Also pushes notifications when needed."""
    GLib.idle_add(self.disable_menu)

    if (self.settings.get_string("twitch-username") == ""):
      GLib.idle_add(self.abort_refresh, "Twitch.tv username is not set", "Setup your username in settings")
      return

    # Create twitch instance and fetch followed channels.
    self.tw = Twitch()
    self.followed_channels = self.tw.fetch_followed_channels(self.settings.get_string("twitch-username"))

    # Does user exist?
    if self.followed_channels == 404:
      GLib.idle_add(self.abort_refresh, "Cannot retrieve followed channels from Twitch.tv", "User does not exist.")
      return

    if self.followed_channels == None:
      GLib.idle_add(self.abort_refresh, "Cannot retrieve channel list from Twitch.tv", "Retrying in {0} minutes...".format(self.settings.get_int("refresh-interval")))
      return
    
    self.live_streams = self.tw.fetch_live_streams(self.followed_channels)
    if self.live_streams == None:
      GLib.idle_add(self.abort_refresh, "Cannot retrieve live streams from Twitch.tv", "Retrying in {0} minutes...".format(self.settings.get_int("refresh-interval")))
      return

    # Update menu with live streams
    GLib.idle_add(self.add_streams_menu, self.live_streams)
    
    # Re-enable "Check now" button
    GLib.idle_add(self.enable_menu)

    # Check which streams were not live before, create separate list for
    # notifications and update main livestreams list.
    # We check live streams by URL, because sometimes Twitch API does not show
    # stream status, which makes notifications appear even if stream has been
    # live before.
    self.notify_list = list(self.live_streams)
    for x in self.LIVE_STREAMS:
      for y in self.live_streams:
        if x["url"] == y["url"]:
          self.notify_list[:] = [d for d in self.notify_list if d.get('url') != y["url"]]
          break
    
    self.LIVE_STREAMS = self.live_streams

    # Push notifications of new streams
    if (self.settings.get_boolean("enable-notifications")):
      self.push_notifications(self.notify_list)

  def abort_refresh(self, message, description):
    """Updates menu with failure state message."""
    # Remove previous message if already exists
    if (len(self.menuItems) > 4):
      self.menuItems.pop(2)
      self.menuItems.pop(1)

    self.menuItems.insert(2, gtk.MenuItem(message))
    self.menuItems.insert(3, gtk.SeparatorMenuItem())
    self.menuItems[2].set_sensitive(False)

    # Re-enable "Check now" button
    self.menuItems[0].set_sensitive(True)
    self.menuItems[0].set_label("Check now")

    # Refresh all menu items 
    for i in self.menu.get_children():
      self.menu.remove(i)

    for i in self.menuItems:
      self.menu.append(i)

    self.menu.show_all()

    # Push notification
    Notify.init("image")
    self.n = Notify.Notification.new(message,
      description,
      "error"
    ).show()

  def push_notifications(self, streams):
    """Pushes notifications of every stream, passed as a list of dictionaries."""
    try:
      for stream in streams:
        self.image = gtk.Image()
        # Show default if channel owner has not set his avatar
        if (stream["image"] == None):
          self.response = urllib.urlopen("http://static-cdn.jtvnw.net/jtv_user_pictures/xarth/404_user_150x150.png")
        else:
          self.response = urllib.urlopen(stream["image"])
        self.loader = GdkPixbuf.PixbufLoader.new()
        self.loader.write(self.response.read())
        self.loader.close()

        Notify.init("image")
        self.n = Notify.Notification.new("%s just went LIVE!" % stream["name"],
          stream["status"],
          "",
        )

        self.n.set_icon_from_pixbuf(self.loader.get_pixbuf())
        self.n.show()
    except IOError:
      return

  def main(self):
    """Main indicator function."""
    gtk.main()

  def quit(self, item):
    """Quits the applet."""
    self.timeout_thread.cancel()
    gtk.main_quit()

if __name__=="__main__":
  Gdk.threads_init()
  gui = Indicator()
  gui.main()