soundcloud2000 0.1.0

data/lib/soundcloud2000/download_thread.rb

@@ -0,0 +1,47 @@
+require 'net/http'
+require_relative 'events'
+
+module Soundcloud2000
+  class DownloadThread
+    attr_reader :events, :url, :progress, :total, :file
+
+    def initialize(url, filename)
+      @events = Events.new
+      @url = URI.parse(url)
+      @file = File.open(filename, "w")
+      @progress = 0
+      start!
+    end
+
+    def log(s)
+      Soundcloud2000::Application.logger.debug("DownloadThread #{s}")
+    end
+
+    def start!
+      Thread.start do
+        begin
+          log :start
+          Net::HTTP.get_response(url) do |res|
+            log "response: #{res.code}"
+            raise res.body if res.code != '200'
+
+            @total = res.header['Content-Length'].to_i
+
+            res.read_body do |chunk|
+              @progress += chunk.size
+              @file << chunk
+              @file.close if @progress == @total
+            end
+          end
+        rescue => e
+          log e.message
+        end
+      end
+
+      sleep 0.1 while @total.nil?
+      sleep 0.1
+
+      self
+    end
+  end
+end

data/lib/soundcloud2000/events.rb

@@ -0,0 +1,17 @@
+module Soundcloud2000
+  class Events
+    def initialize
+      @handlers = Hash.new {|h,k| h[k] = [] }
+    end
+
+    def on(event, &block)
+      @handlers[event] << block
+    end
+
+    def trigger(event, *args)
+      @handlers[event].each do |handler|
+        handler.call(*args)
+      end
+    end
+  end
+end

data/lib/soundcloud2000/models/collection.rb

@@ -0,0 +1,41 @@
+require_relative '../events'
+
+module Soundcloud2000
+  module Models
+    class Collection
+      include Enumerable
+      attr_reader :events, :rows, :page
+
+      def initialize(client)
+        @client = client
+        @events = Events.new
+        clear
+      end
+
+      def [](*args)
+        @rows[*args]
+      end
+
+      def clear
+        @page = 0
+        @rows = []
+        @loaded = false
+      end
+
+      def each(&block)
+        @rows.each(&block)
+      end
+
+      def replace(rows)
+        clear
+        @rows = rows
+        events.trigger(:replace)
+      end
+
+      def append(rows)
+        @rows += rows
+        events.trigger(:append)
+      end
+    end
+  end
+end

data/lib/soundcloud2000/models/player.rb

@@ -0,0 +1,141 @@
+require 'audite'
+require_relative '../download_thread'
+
+module Soundcloud2000
+  module Models
+    class Player
+      attr_reader :track, :events
+
+      def initialize
+        @track = nil
+        @events = Events.new
+        @folder = File.expand_path("~/.soundcloud2000")
+        @seek_speed = {}
+        @seek_time = {}
+        create_player
+
+        Dir.mkdir(@folder) unless File.exist?(@folder)
+      end
+
+      def create_player
+        @player = Audite.new
+        @player.events.on(:position_change) do |position|
+          events.trigger(:progress)
+        end
+
+        @player.events.on(:complete) do
+          events.trigger(:complete)
+        end
+      end
+
+      def play(track, location)
+        log :play, track.id
+        @track = track
+        load(track, location)
+        start
+      end
+
+      def play_progress
+        seconds_played / duration
+      end
+
+      def duration
+        @track.duration.to_f / 1000
+      end
+
+      def title
+        [@track.title, @track.user.username].join(' - ')
+      end
+
+      def length_in_seconds
+        mpg = Mpg123.new(@file)
+        mpg.length * mpg.tpf / mpg.spf
+      end
+
+      def load(track, location, &block)
+        @file = "#{@folder}/#{track.id}.mp3"
+
+        if !File.exist?(@file) || track.duration / 1000 < length_in_seconds * 0.95
+          File.unlink(@file) rescue nil
+          @download = DownloadThread.new(location, @file)
+        else
+          @download = nil
+        end
+
+        @player.load(@file)
+      end
+
+      def log(*args)
+        Soundcloud2000::Application.logger.debug 'Player: ' + args.join(" ")
+      end
+
+      def level
+        @player.level
+      end
+
+      def seconds_played
+        @player.position
+      end
+
+      def download_progress
+        if @download
+          @download.progress / @download.total.to_f
+        else
+          1
+        end
+      end
+
+      def playing?
+        @player.active
+      end
+
+      def seek_speed(direction)
+        if @seek_time[direction] && Time.now - @seek_time[direction] < 0.5
+          @seek_speed[direction] *= 1.05
+        else
+          @seek_speed[direction] = 1
+        end
+
+        @seek_time[direction] =  Time.now
+        @seek_speed[direction]
+      end
+      #change song position
+      def seek_position(position)
+        position *= 0.1
+        relative_position = position * duration
+        if relative_position < seconds_played
+          difference = seconds_played - relative_position
+          @player.rewind(difference)
+        elsif download_progress > (relative_position / duration) && relative_position > seconds_played
+          log download_progress
+          difference = relative_position - seconds_played
+          @player.forward(difference)
+        end
+      end
+
+      def rewind
+        @player.rewind(seek_speed(:rewind))
+      end
+
+      def forward
+        seconds = seek_speed(:forward)
+
+        if ((seconds + seconds_played) / duration) < download_progress
+          @player.forward(seconds)
+        end
+      end
+
+      def stop
+        @player.stop_stream
+      end
+
+      def start
+        @player.start_stream
+      end
+
+      def toggle
+        @player.toggle
+      end
+    end
+  end
+end

data/lib/soundcloud2000/models/playlist.rb

@@ -0,0 +1,23 @@
+module Soundcloud2000
+  module Models
+    class Playlist
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def id
+        @hash['id']
+      end
+
+      def title
+        @hash['title']
+      end
+      
+      def uri
+        @hash['uri']
+      end
+      
+    end
+  end
+end

data/lib/soundcloud2000/models/track.rb

@@ -0,0 +1,57 @@
+require_relative 'user'
+
+module Soundcloud2000
+  module Models
+    class Track
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def id
+        @hash['id']
+      end
+
+      def title
+        @hash['title']
+      end
+
+      def url
+        @hash['permalink_url']
+      end
+
+      def user
+        @user ||= User.new(@hash['user'])
+      end
+
+      def username
+        user.username
+      end
+
+      def duration
+        @hash['duration']
+      end
+
+      def length
+        TimeHelper.duration(duration)
+      end
+
+      def plays
+        @hash['playback_count']
+      end
+
+      def likes
+        @hash['favoritings_count']
+      end
+
+      def comments
+        @hash['comments']
+      end
+
+      def stream_url
+        @hash['stream_url']
+      end
+
+    end
+  end
+end

data/lib/soundcloud2000/models/track_collection.rb

@@ -0,0 +1,64 @@
+require_relative 'collection'
+require_relative 'track'
+require_relative 'playlist'
+
+module Soundcloud2000
+  module Models
+    class TrackCollection < Collection
+      DEFAULT_LIMIT = 50
+
+      attr_reader :limit
+      attr_accessor :collection_to_load, :user, :playlist
+
+      def initialize(client)
+        super
+        @limit = DEFAULT_LIMIT
+        @collection_to_load = :recent
+      end
+
+      def size
+        @rows.size
+      end
+
+      def clear_and_replace
+        clear
+        load_more
+        events.trigger(:replace)
+      end
+
+      def load
+        clear
+        load_more
+      end
+
+      def load_more
+        unless @loaded
+          tracks = self.send(@collection_to_load.to_s + "_tracks")
+          @loaded = true if tracks.empty?
+          append tracks.map {|hash| Track.new hash }
+          @page += 1
+        end
+      end
+
+      def favorites_tracks
+        return [] if @user.nil?
+        @client.get(@user.uri + '/favorites', offset: @limit * @page, limit: @limit)
+      end
+
+      def recent_tracks
+        @client.get('/tracks', offset: @page * limit, limit: @limit)
+      end
+
+      def user_tracks
+        return [] if @user.nil?
+        @client.get(@user.uri + '/tracks', offset: @limit * @page, limit: @limit)
+      end
+
+      def playlist_tracks
+        return [] if @playlist.nil?
+        @client.get(@playlist.uri + '/tracks', offset: @limit * @page, limit: @limit)
+      end
+
+    end
+  end
+end

data/lib/soundcloud2000/models/user.rb

@@ -0,0 +1,26 @@
+module Soundcloud2000
+  module Models
+    class User
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def id
+        @hash['id']
+      end
+
+      def username
+        @hash['username']
+      end
+
+      def uri
+        @hash['uri']
+      end
+
+      def permalink
+        @hash['permalink']
+      end
+    end
+  end
+end

data/lib/soundcloud2000/time_helper.rb

@@ -0,0 +1,22 @@
+require 'time'
+
+module Soundcloud2000
+  module TimeHelper
+    HOUR    = 1000 * 60 * 60
+    MINUTE  = 1000 * 60
+    SECONDS = 1000
+
+    def self.duration(milliseconds)
+      parts = [
+        milliseconds / 1000 / 60 / 60,      # hours
+        milliseconds / 1000 / 60 % 60,      # minutes
+        milliseconds / 1000 % 60,           # seconds
+      ]
+
+      parts.shift if parts.first.zero?
+
+      [ parts.first, *parts[1..-1].map { |part| '%02d' % part } ].join('.')
+    end
+
+  end
+end