walkman 0.1.1

data/lib/walkman/config.rb

@@ -0,0 +1,94 @@
+require "yaml"
+
+module Walkman
+  def self.config
+    @@config ||= Config.new.tap do |config|
+      config.load_file("~/.walkman")
+    end
+  end
+
+  class Config
+    # logger
+    attr_accessor :log_level
+
+    # cli/drb
+    attr_reader   :server_host
+    attr_reader   :server_port
+    attr_reader   :drb_uri
+
+    # echonest
+    attr_reader   :echonest_api_key
+    attr_reader   :echonest_consumer_key
+    attr_reader   :echonest_shared_secret
+    attr_reader   :echonest_catalog_id
+
+    # rdio
+    attr_reader   :rdio_player_url
+    attr_reader   :rdio_playback_token
+    attr_reader   :rdio_browser_path
+
+    def initialize
+      # global
+      @log_level   = "debug"
+
+      # server
+      @server_host = "localhost"
+      @server_port = 27001
+      @drb_uri     = "druby://#{@server_host}:#{@server_port}"
+
+      # echo nest
+      @echonest_api_key       = nil
+      @echonest_consumer_key  = nil
+      @echonest_shared_secret = nil
+      @echonest_catalog_id    = nil
+
+      # rdio service
+      @rdio_player_url        = "http://localhost:4567/rdio"
+      @rdio_playback_token    = nil
+      @rdio_browser_path      = '/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --no-process-singleton-dialog' # must be single quotes
+    end
+
+    def load_file(config_file)
+      file = File.expand_path(config_file)
+
+      if File.file?(file)
+        configs = YAML.load(File.read(file))
+        load_global_configs(configs)
+        load_server_configs(configs["server"])
+        load_echonest_configs(configs["echonest"])
+        load_rdio_configs(configs["rdio"])
+      end
+    end
+
+    protected
+
+    def load_global_configs(configs)
+      @log_level = configs["log_level"] if configs["log_level"]
+    end
+
+    def load_server_configs(configs)
+      return unless configs
+
+      @server_host = configs["host"] if configs["host"]
+      @server_port = configs["port"] if configs["port"]
+      @drb_uri     = "druby://#{@server_host}:#{@server_port}"
+    end
+
+    def load_echonest_configs(configs)
+      return unless configs
+
+      @echonest_api_key       = configs["api_key"]
+      @echonest_consumer_key  = configs["consumer_key"]
+      @echonest_shared_secret = configs["shared_secret"]
+      @echonest_catalog_id    = configs["catalog_id"]
+    end
+
+    def load_rdio_configs(configs)
+      return unless configs
+
+      @rdio_playback_token = configs["playback_token"]
+      @rdio_player_url     = configs["player_url"] if configs["player_url"]
+      @rdio_browser_path   = configs["browser_path"] if configs["browser_path"]
+    end
+  end
+end

data/lib/walkman/player.rb

@@ -0,0 +1,105 @@
+module Walkman
+  def self.player
+    @@player ||= Walkman::Player.new
+  end
+
+  class Player
+    attr_accessor :current_song, :playing
+
+    SERVICES = [Walkman::Services::Rdio]
+
+    def initialize
+      @current_song = nil
+      @playing = false
+      @running = false
+    end
+
+    def services
+      @services ||= begin
+        Hash[SERVICES.map { |service| [service.name, service.new] }]
+      end
+    end
+
+    def startup
+      services.each do |key, service|
+        service.startup
+      end
+
+      @running = true
+
+      @play_loop = Thread.new do
+        current_loop_song = nil
+        last_loop_song = nil
+
+        while @running
+          if @playing
+            current_loop_song = @current_song
+
+            if current_loop_song.nil?
+              self.next
+            elsif !last_loop_song.nil? && current_loop_song != last_loop_song
+              stop
+              current_loop_song = nil
+              @playing = true # have to reset this due to calling stop
+            elsif last_loop_song.nil?
+              play_song(current_loop_song)
+            end
+
+            last_loop_song = current_loop_song
+          else
+            last_loop_song = nil
+          end
+
+          sleep 0.1
+        end
+      end
+    end
+
+    def shutdown
+      @running = false
+      @play_loop.join if @play_loop
+
+      services.each do |key, service|
+        service.shutdown
+      end
+    end
+
+    def play
+      Walkman.logger.debug("player play")
+
+      @playing = true
+    end
+
+    def stop
+      Walkman.logger.debug("player stop")
+
+      @playing = false
+
+      services.each do |key, service|
+        service.stop
+      end
+    end
+
+    def next(count = 1)
+      if @current_song = playlist.next(count)
+        @playing = true
+      else
+        stop
+      end
+    end
+
+    def playlist
+      @playlist ||= Walkman::Playlist.new
+    end
+
+    def playlist=(playlist)
+      @playlist = playlist
+    end
+
+    private
+
+    def play_song(song)
+      services[song.source_type].play(song.source_id)
+    end
+  end
+end

data/lib/walkman/playlist.rb

@@ -0,0 +1,139 @@
+module Walkman
+  class Playlist
+    attr_accessor :session_id
+
+    def initialize(options = {})
+      songs = options.delete(:songs) || []
+      @queue = [songs].flatten # can add one or more Songs
+      @auto_queue = options.delete(:auto_queue) || false
+
+      if echonest_playlist = echonest_playlist_create(options)
+        @session_id = echonest_playlist.session_id
+      end
+
+      if @auto_queue && @session_id
+        auto_queue && self.next
+      end
+    end
+
+    def queue
+      @queue
+    end
+
+    def clear
+      @queue = []
+    end
+
+    def include?(song)
+      @queue.include?(song)
+    end
+    alias_method :queued?, :include?
+
+    def shuffle
+      @queue.shuffle!
+    end
+
+    def add(songs, position = -1)
+      index = @queue.size
+      index = [position, index].min if position >= 0
+      @queue.insert(index, songs).flatten!
+    end
+
+    def remove(song)
+      @queue.delete_if { |s| s == song }
+    end
+
+    def next(count = 1)
+      # if the playlist is not empty, we can get one or more
+      # songs back so we need to make sure we get the last one
+      songs = @queue.shift(count)
+      songs = [songs].flatten
+      song = songs.pop # the last song skipped
+
+      # skip and unplay songs so our echonest catalog/profile stays true
+      skip(songs)
+
+      if @auto_queue && size <= 5
+        auto_queue(5) if @session_id
+      end
+
+      song
+    end
+
+    def size
+      @queue.size
+    end
+
+    def unplay(songs)
+      songs = [songs].flatten # one or more
+
+      songs.each do |song|
+        echonest_playlist_feedback({ unplay_song: song.echonest_song_id })
+      end
+    end
+
+    def skip(songs)
+      songs = [songs].flatten # one or more
+
+      songs.each do |song|
+        echonest_playlist_feedback({ skip_song: song.echonest_song_id, unplay_song: song.echonest_song_id })
+      end
+    end
+
+    def favorite(songs)
+      songs = [songs].flatten # one or more
+
+      songs.each do |song|
+        echonest_playlist_feedback({ favorite_song: song.echonest_song_id, favorite_artist: song.echonest_artist_id })
+      end
+    end
+
+    private
+
+    def echonest_playlist_create(options = {})
+      return nil unless options.keys.include?(:type)
+
+      options[:bucket] = ["id:rdio-US", "tracks"]
+      options[:seed_catalog] = Walkman.config.echonest_catalog_id
+      options[:session_catalog] = Walkman.config.echonest_catalog_id
+
+      if remote_playlist = Walkman.echowrap.playlist_dynamic_create(options)
+        remote_playlist
+      else
+        nil
+      end
+    end
+
+    def echonest_playlist_feedback(args = {})
+      args[:session_id] = @session_id
+
+      Walkman.echowrap.playlist_dynamic_feedback(args)
+    end
+
+    def auto_queue(count = 5)
+      return 0 unless @session_id
+
+      result = Walkman.echowrap.playlist_dynamic_next(session_id: @session_id, results: count)
+      songs = []
+
+      result.songs.each do |song|
+        # find the first track with a rdio foreign key
+        track = song.tracks.find do |t|
+          t.foreign_id && t.foreign_id.split(":")[0] == "rdio-US"
+        end
+
+        next unless track
+
+        songs << Walkman::Song.new(artist: song.artist_name,
+                                   title: song.title,
+                                   source_type: "Walkman::Services::Rdio",
+                                   source_id: track.foreign_id.split(":").last,
+                                   echonest_artist_id: song.artist_id,
+                                   echonest_song_id: song.id)
+      end
+
+      add(songs)
+      songs.count
+    end
+  end
+end

data/lib/walkman/services/base.rb

@@ -0,0 +1,25 @@
+module Walkman
+  module Services
+    class Base
+      def startup
+        raise("Implement in Service")
+      end
+
+      def shutdown
+        raise("Implement in Service")
+      end
+
+      def restart
+        raise("Implement in Service")
+      end
+
+      def play(song)
+        raise("Implement in Service")
+      end
+
+      def stop
+        raise("Implement in Service")
+      end
+    end
+  end
+end

data/lib/walkman/services/rdio.rb

@@ -0,0 +1,64 @@
+module Walkman
+  module Services
+    class Rdio < Walkman::Services::Base
+      def startup
+        Walkman.logger.debug "starting Rdio service"
+
+        @player_thread = Thread.new do
+          RdioPlayer.run!
+        end
+      end
+
+      def shutdown
+        Walkman.logger.debug "stopping Rdio service"
+
+        @player_thread.terminate if @player_thread
+      end
+
+      def restart
+        shutdown
+        startup
+      end
+
+      def play(source_id)
+        quit_browser
+        launch_browser(source_id)
+      end
+
+      def stop
+        quit_browser
+      end
+
+      private
+
+      def launch_browser(source_id)
+        data_dir = "/tmp/walkman/chrome/#{rand(999999999999)}"
+        launch_cmd = "#{Walkman.config.rdio_browser_path} \"#{Walkman.config.rdio_player_url}/#{source_id}\" --user-data-data-dir=#{data_dir}"
+
+        @browser_pid = Process.fork do
+          Signal.trap("TERM") { exit }
+
+          Command.run(launch_cmd)
+        end
+
+        unless @browser_pid.nil?
+          Walkman.logger.debug("detaching new browser process with pid #{@browser_pid}")
+
+          Process.detach(@browser_pid)
+        end
+      end
+
+      def quit_browser(source_id = "")
+        Walkman.logger.debug("killing browser process")
+
+        kill_cmd = "kill $(ps ax | grep \"#{Walkman.config.rdio_player_url}/#{source_id}\" | grep -v grep | sed -e 's/^[ \t]*//' | cut -d ' ' -f 1)"
+        Command.run(kill_cmd)
+
+        if @browser_pid
+          Walkman.logger.debug("killing browser pid #{@browser_pid}")
+          Process.kill("TERM", @browser_pid) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/walkman/services/rdio/rdio_player.rb

@@ -0,0 +1,85 @@
+require "sinatra"
+require "command"
+
+class RdioPlayer < Sinatra::Base
+  get "/rdio/:song_id" do |song_id|
+    erb :player, locals: { playback_token: Walkman.config.rdio_playback_token, song_id: song_id }
+  end
+
+  get "/rdio/:song_id/done" do |song_id|
+    Walkman.player.current_song = nil # TODO: make this not suck
+    "Done"
+  end
+
+  template :player do
+<<-EOS
+<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js"></script>
+<script src="https://ajax.googleapis.com/ajax/libs/swfobject/2.2/swfobject.js"></script>
+<script type="text/javascript">
+  window.resizeTo(450, 450);
+
+  var playback_token = '<%= playback_token %>';
+  var domain = 'localhost'
+  var track_key = '<%= song_id %>';
+
+  var apiswf = null;
+  var playing = null;
+  var done = false;
+
+  $(document).ready(function() {
+    // on page load use SWFObject to load the API swf into div#apiswf
+    var flashvars = {
+      'playbackToken': playback_token, // from token.js
+      'domain': domain,                // from token.js
+      'listener': 'callback_object'    // the global name of the object that will receive callbacks from the SWF
+      };
+    var params = {
+      'allowScriptAccess': 'always'
+    };
+    var attributes = {};
+    swfobject.embedSWF('http://www.rdio.com/api/swf/', // the location of the Rdio Playback API SWF
+        'apiswf', // the ID of the element that will be replaced with the SWF
+        1, 1, '9.0.0', 'expressInstall.swf', flashvars, params, attributes);
+  });
+
+  // the global callback object
+  var callback_object = {};
+  callback_object.ready = function ready(user) {
+    apiswf = $('#apiswf').get(0);
+    apiswf.rdio_play(track_key);
+  }
+
+  callback_object.playStateChanged = function playStateChanged(playState) {
+    if(playState == 2 && playing != null) {
+      $.get('/rdio/' + track_key + '/done');
+    }
+  }
+
+  callback_object.playingTrackChanged = function playingTrackChanged(playingTrack, sourcePosition) {
+    if(playing == null) {
+      playing = playingTrack;
+    }
+
+    if (playingTrack != null) {
+      $('#track').text(playingTrack['name']);
+      $('#album').text(playingTrack['album']);
+      $('#artist').text(playingTrack['artist']);
+      $('#art').attr('src', playingTrack['icon']);
+    }
+  }
+</script>
+
+<div id="apiswf"></div>
+<dl>
+  <dt>track</dt>
+  <dd id="track"></dd>
+  <dt>album</dt>
+  <dd id="album"></dd>
+  <dt>artist</dt>
+  <dd id="artist"></dd>
+  <dt>art</dt>
+  <dd><img src="" id="art"></dd>
+</dl>
+EOS
+  end
+end