spotify 12.5.3 → 12.6.0

data/lib/spotify/managed_pointer.rb

@@ -18,19 +18,18 @@ module Spotify
     extend Spotify::TypeSafety
 
     class << self
-      # Releases the given pointer if it is not null.
-      #
-      # This method derives the release method from the class name.
+      # Schedules given pointer for release.
       #
       # @param [FFI::Pointer] pointer
       def release(pointer)
         unless pointer.null?
-          # this is to circumvent the type protection
-          pointer = type_class.new(pointer)
-          pointer.autorelease = false
+          # this is to circumvent the type protection, and wrap the pointer
+          # with the correct type for later freeing
+          freeable = type_class.new(pointer)
+          # and this is to not make this pointer trigger release again
+          freeable.autorelease = false
 
-          $stderr.puts "Spotify.#{type}_release(#{pointer.inspect})" if $DEBUG
-          Spotify.public_send("#{type}_release", pointer)
+          Spotify.performer.async { freeable.free }
         end
       end
 
@@ -41,8 +40,8 @@ module Spotify
       # @param [self] pointer must be an instance of {#type_class}
       def retain(pointer)
         unless pointer.null?
-          $stderr.puts "Spotify.#{type}_add_ref(#{pointer.inspect})" if $DEBUG
-          Spotify.public_send("#{type}_add_ref", pointer)
+          Spotify.log "Spotify.#{type}_add_ref(#{pointer.inspect})"
+          Spotify.public_send(:"#{type}_add_ref", pointer)
         end
       end
 
@@ -56,6 +55,12 @@ module Spotify
         end
       end
 
+      # Casts all null pointers to nil.
+      def from_native(pointer, ctx)
+        value = super
+        value unless value.null?
+      end
+
       # @see https://github.com/jruby/jruby/issues/607
       # @return [Integer] size of the native type, defined for JRuby.
       def size
@@ -101,8 +106,6 @@ module Spotify
         end
       end
 
-      protected
-
       # Retrieves the normalized and downcased name of self, so for
       # Spotify::Album we’ll receive just “album”.
       def type
@@ -110,6 +113,23 @@ module Spotify
       end
     end
 
+    # @see self.class.type
+    def type
+      self.class.type
+    end
+
+    # Immediately releases the underlying pointer.
+    #
+    # @note Does NOT call self.class.release.
+    # @note This is NOT idempotent.
+    def free
+      unless null?
+        self.autorelease = false
+        Spotify.log "Spotify.#{type}_release(#{inspect})"
+        Spotify.public_send(:"#{type}_release", self)
+      end
+    end
+
     # @return [String] string representation of self.
     def inspect
       "#<#{self.class} address=0x%x>" % address

data/lib/spotify/monkey_patches/ffi_buffer.rb

@@ -0,0 +1,11 @@
+module Spotify
+  module MonkeyPatches
+    module FFIBuffer
+      def null?
+        false
+      end
+    end
+
+    ::FFI::Buffer.send(:include, FFIBuffer)
+  end
+end

data/lib/spotify/monkey_patches/ffi_enums.rb

@@ -0,0 +1,4 @@
+# Fix for https://github.com/jruby/jruby/issues/1954
+unless FFI::Enums.method_defined?(:default)
+  FFI::Enums.send(:attr_accessor, :default)
+end

data/lib/spotify/monkey_patches/ffi_pointer.rb

@@ -15,6 +15,7 @@ module FFI
       end
 
       alias_method(:read_size_t, "read_#{type}")
+      alias_method(:write_size_t, "write_#{type}")
     end
   end
 end

data/lib/spotify/structs.rb

@@ -31,6 +31,10 @@ module Spotify
 
       super(pointer, *layout, &block)
 
+      if defined?(self.class::DEFAULTS)
+        options = self.class::DEFAULTS.merge(options)
+      end
+
       options.each_pair do |key, value|
         self[key] = value
       end

data/lib/spotify/structs/session_callbacks.rb

@@ -1,48 +1,119 @@
 module Spotify
   # Spotify::Struct for Session callbacks.
   #
-  # @attr [callback(Session, :error):void] logged_in
-  # @attr [callback(Session):void] logged_out
-  # @attr [callback(Session):void] metadata_updated
-  # @attr [callback(Session, :error):void] connection_error
-  # @attr [callback(Session, UTF8String):void] message_to_user
-  # @attr [callback(Session):void] notify_main_thread
-  # @attr [callback(Session, AudioFormat, :frames, :int):int] music_delivery
-  # @attr [callback(Session):void] play_token_lost
-  # @attr [callback(Session, UTF8String):void] log_message
-  # @attr [callback(Session):void] end_of_track
-  # @attr [callback(Session, :error):void] streaming_error
-  # @attr [callback(Session):void] userinfo_updated
-  # @attr [callback(Session):void] start_playback
-  # @attr [callback(Session):void] stop_playback
-  # @attr [callback(Session, AudioBufferStats):void] get_audio_buffer_stats
-  # @attr [callback(Session):void] offline_status_updated
-  # @attr [callback(Session, :error):void] offline_error
-  # @attr [callback(Session, :string):void] credentials_blob_updated
-  # @attr [callback(Session):void] connectionstate_updated
-  # @attr [callback(Session, :error):void] scrobble_error
-  # @attr [callback(Session, :bool):void] private_session_mode_changed
+  # @!method logged_in(session, error)
+  #   @param [Session] session
+  #   @param [Symbol] error
+  # @!method logged_out(session)
+  #   @param [Session] session
+  # @!method metadata_updated(session)
+  #   @param [Session]
+  # @!method connection_error(session, error)
+  #   @param [Session] session
+  #   @param [Symbol] error
+  # @!method message_to_user(session, message)
+  #   @param [Session] session
+  #   @param [String] message
+  # @!method notify_main_thread(session)
+  #   @param [Session] session
+  # @!method music_delivery(session, audio_format, frames_pointer, frames_length)
+  #   Frames pointer is pointing to data in the format described by audio format, with interleaved channels:
+  #
+  #   frames memory (16 bit = 2 byte frames, 2 channels, 3 frames):
+  #      00 00 # sample 1, frame 1, channel 1
+  #      00 00 # sample 2, frame 1, channel 2
+  #      00 00 # sample 3, frame 2, channel 1
+  #      00 00 # sample 4, frame 2, channel 2
+  #      00 00 # sample 5, frame 3, channel 1
+  #      00 00 # sample 6, frame 3, channel 2
+  #      # end of data, 3 frames * 2 channels = 6 samples
+  #
+  #   @param [Session] session
+  #   @param [AudioFormat] audio_format
+  #   @param [FFI::Pointer] frames_pointer
+  #   @param [Integer] frames_length
+  #   @return [Integer] number of consumed frames, 0..frames_length
+  # @!method play_token_lost(session)
+  #   @param [Session] session
+  # @!method log_message(session, message)
+  #   @param [Session] session
+  #   @param [String] message
+  # @!method end_of_track(session)
+  #   @param [Session]
+  # @!method streaming_error(session, error)
+  #   @param [Session] session
+  #   @param [Symbol] error
+  # @!method userinfo_updated(session)
+  #   @param [Session] session
+  # @!method start_playback(session)
+  #   @param [Session] session
+  # @!method stop_playback(session)
+  #   @param [Session] session
+  # @!method get_audio_buffer_stats(session, stats)
+  #   @param [Session] session
+  #   @param [AudioBufferStats] stats
+  # @!method offline_status_updated(session)
+  #   @param [Session] session
+  # @!method offline_error(session, error)
+  #   @param [Session] session
+  #   @param [Symbol] error
+  # @!method credentials_blob_updated(session, blob)
+  #   @param [Session] session
+  #   @param [String] blob
+  # @!method connectionstate_updated(session)
+  #   @param [Session] session
+  # @!method scrobble_error(session, error)
+  #   @param [Session] session
+  #   @param [Symbol] error
+  # @!method private_session_mode_changed(session, is_private)
+  #   @param [Session] session
+  #   @param [Boolean] is_private
   class SessionCallbacks < Spotify::Struct
-    layout :logged_in => callback([ Session, :error ], :void),
+    layout :logged_in => callback([ Session, APIError ], :void),
            :logged_out => callback([ Session ], :void),
            :metadata_updated => callback([ Session ], :void),
-           :connection_error => callback([ Session, :error ], :void),
+           :connection_error => callback([ Session, APIError ], :void),
            :message_to_user => callback([ Session, UTF8String ], :void),
            :notify_main_thread => callback([ Session ], :void),
            :music_delivery => callback([ Session, AudioFormat.by_ref, :frames, :int ], :int),
            :play_token_lost => callback([ Session ], :void),
            :log_message => callback([ Session, UTF8String ], :void),
            :end_of_track => callback([ Session ], :void),
-           :streaming_error => callback([ Session, :error ], :void),
+           :streaming_error => callback([ Session, APIError ], :void),
            :userinfo_updated => callback([ Session ], :void),
            :start_playback => callback([ Session ], :void),
            :stop_playback => callback([ Session ], :void),
            :get_audio_buffer_stats => callback([ Session, AudioBufferStats.by_ref ], :void),
            :offline_status_updated => callback([ Session ], :void),
-           :offline_error => callback([ Session, :error ], :void),
+           :offline_error => callback([ Session, APIError ], :void),
            :credentials_blob_updated => callback([ Session, :string ], :void),
            :connectionstate_updated => callback([ Session ], :void),
-           :scrobble_error => callback([ Session, :error ], :void),
+           :scrobble_error => callback([ Session, APIError ], :void),
            :private_session_mode_changed => callback([ Session, :bool ], :void)
+
+    # Sane defaults, to avoid {Spotify::API#session_logout} segfaulting.
+    DEFAULTS = {
+      connection_error: proc {},
+      connectionstate_updated: proc {},
+      credentials_blob_updated: proc {},
+      end_of_track: proc {},
+      get_audio_buffer_stats: proc {},
+      log_message: proc {},
+      logged_in: proc {},
+      logged_out: proc {},
+      message_to_user: proc {},
+      metadata_updated: proc {},
+      music_delivery: proc {},
+      notify_main_thread: proc {},
+      offline_error: proc {},
+      offline_status_updated: proc {},
+      play_token_lost: proc {},
+      private_session_mode_changed: proc {},
+      scrobble_error: proc {},
+      start_playback: proc {},
+      stop_playback: proc {},
+      streaming_error: proc {},
+      userinfo_updated: proc {},
+    }
   end
 end

data/lib/spotify/structs/session_config.rb

@@ -34,7 +34,7 @@ module Spotify
     it[:proxy] = UTF8StringPointer
     it[:proxy_username] = UTF8StringPointer
     it[:proxy_password] = UTF8StringPointer
-    it[:ca_certs_filename] = UTF8StringPointer if Spotify::API.linux?
+    it[:ca_certs_filename] = UTF8StringPointer if Spotify::Util.linux?
     it[:tracefile] = UTF8StringPointer
     layout(it)
 

data/lib/spotify/structs/subscribers.rb

@@ -18,9 +18,10 @@ module Spotify
       # @param [FFI::Pointer] pointer pointing to a subscribers struct
       def release(pointer)
         unless pointer.null?
-          pointer = type_class.new(pointer)
-          $stderr.puts "Spotify.playlist_subscribers_free(#{pointer.inspect})" if $DEBUG
-          Spotify.playlist_subscribers_free(pointer)
+          Spotify.performer.async do
+            Spotify.log "Spotify.playlist_subscribers_free(#{pointer})"
+            Spotify.playlist_subscribers_free(pointer)
+          end
         end
       end
     end

data/lib/spotify/types.rb

@@ -1,5 +1,104 @@
-require 'spotify/types/utf8_string'
-require 'spotify/types/utf8_string_pointer'
-require 'spotify/types/image_id'
-require 'spotify/types/byte_string'
-require 'spotify/types/best_effort_string'
+require 'spotify/managed_pointer'
+
+require 'spotify/types/album'
+require 'spotify/types/album_browse'
+require 'spotify/types/artist'
+require 'spotify/types/artist_browse'
+require 'spotify/types/image'
+require 'spotify/types/inbox'
+require 'spotify/types/link'
+require 'spotify/types/playlist'
+require 'spotify/types/playlist_container'
+require 'spotify/types/search'
+require 'spotify/types/session'
+require 'spotify/types/toplist_browse'
+require 'spotify/types/track'
+require 'spotify/types/user'
+
+module Spotify
+  class API
+    typedef :pointer, :frames
+    typedef :pointer, :userdata
+    typedef :pointer, :array
+    typedef Spotify::APIError, :error
+
+    #
+    # Audio
+    #
+    enum :sampletype, [:int16] # int16_native_endian
+    enum :bitrate, %w(160k 320k 96k).map(&:to_sym)
+
+    #
+    # Session
+    #
+    enum :social_provider, [:spotify, :facebook, :lastfm]
+    enum :scrobbling_state, [:use_global_setting, :local_enabled, :local_disabled, :global_enabled, :global_disabled]
+    enum :connectionstate, [:logged_out, :logged_in, :disconnected, :undefined, :offline]
+    enum :connection_type, [:unknown, :none, :mobile, :mobile_roaming, :wifi, :wired]
+    enum :connection_rules, [:network               , 0x1,
+                             :network_if_roaming    , 0x2,
+                             :allow_sync_over_mobile, 0x4,
+                             :allow_sync_over_wifi  , 0x8]
+
+    #
+    # Image
+    #
+    callback :image_loaded_cb, [ Image.retaining_class, :userdata ], :void
+    enum :imageformat, [:unknown, -1, :jpeg]
+    enum :image_size, [ :normal, :small, :large ]
+
+    #
+    # Link
+    #
+    enum :linktype, [:invalid, :track, :album, :artist, :search,
+                     :playlist, :profile, :starred, :localtrack, :image]
+
+    #
+    # Track
+    #
+    enum :availability, [:unavailable, :available, :not_streamable, :banned_by_artist]
+    typedef :availability, :track_availability # for automated testing
+    enum :track_offline_status, [:no, :waiting, :downloading, :done, :error, :done_expired, :limit_exceeded, :done_resync]
+
+    #
+    # Album
+    #
+    callback :albumbrowse_complete_cb, [AlbumBrowse.retaining_class, :userdata], :void
+    enum :albumtype, [:album, :single, :compilation, :unknown]
+
+    #
+    # Artist browsing
+    #
+    callback :artistbrowse_complete_cb, [ArtistBrowse.retaining_class, :userdata], :void
+    enum :artistbrowse_type, [:full, :no_tracks, :no_albums]
+
+    #
+    # Search
+    #
+    callback :search_complete_cb, [Search.retaining_class, :userdata], :void
+    enum :search_type, [:standard, :suggest]
+
+    #
+    # Playlist
+    #
+    enum :playlist_type, [:playlist, :start_folder, :end_folder, :placeholder]
+    enum :playlist_offline_status, [:no, :yes, :downloading, :waiting]
+
+    #
+    # User
+    #
+    enum :relation_type, [:unknown, :none, :unidirectional, :bidirectional]
+
+    #
+    # Toplist
+    #
+    callback :toplistbrowse_complete_cb, [ToplistBrowse.retaining_class, :userdata], :void
+    enum :toplisttype, [:artists, :albums, :tracks]
+    enum :toplistregion, [:everywhere, :user]
+
+    #
+    # Inbox
+    #
+    callback :inboxpost_complete_cb, [Inbox.retaining_class, :userdata], :void
+  end
+end

data/lib/spotify/util.rb

@@ -1,41 +1,44 @@
-class << Spotify::API
-  # @!group Utility
+module Spotify
+  # Public utility helper methods.
+  module Util
+    module_function
 
-  # Retrieves the associated value of an enum from a given symbol, raising an error if it does not exist.
-  #
-  # @example retrieving a value
-  #    Spotify.enum_value!(:ok, "error value") # => 0
-  #
-  # @example failing to retrieve a value
-  #    Spotify.enum_value!(:moo, "connection rule") # => ArgumentError, invalid connection rule: :moo
-  #
-  # @api public
-  # @param [Symbol] symbol
-  # @param [#to_s] type used as error message when the symbol does not resolve
-  # @raise [ArgumentError] when the symbol does not exist as an enum value
-  # @return [Integer]
-  def enum_value!(symbol, type)
-    enum_value(symbol) or raise ArgumentError, "invalid #{type}: #{symbol}"
-  end
+    # Retrieves the associated value of an enum from a given symbol, raising an error if it does not exist.
+    #
+    # @example retrieving a value
+    #    Spotify::Util.enum_value!(:ok, "error value") # => 0
+    #
+    # @example failing to retrieve a value
+    #    Spotify::Util.enum_value!(:moo, "connection rule") # => ArgumentError, invalid connection rule: :moo
+    #
+    # @api public
+    # @param [Symbol] symbol
+    # @param [#to_s] type used as error message when the symbol does not resolve
+    # @raise [ArgumentError] when the symbol does not exist as an enum value
+    # @return [Integer]
+    def enum_value!(symbol, type)
+      Spotify::API.enum_value(symbol) or raise ArgumentError, "invalid #{type}: #{symbol.inspect}"
+    end
 
-  # @see platform
-  # @api public
-  # @return [Boolean] true if on Linux
-  def linux?
-    platform == :linux
-  end
+    # @see platform
+    # @api public
+    # @return [Boolean] true if on Linux
+    def linux?
+      platform == :linux
+    end
 
-  # @api public
-  # @return [Symbol] platform as either :mac, :windows, or :linux
-  def platform
-    case FFI::Platform::OS
-    when /darwin/ then :mac
-    when /linux/  then :linux
-    when /windows/  then :windows
-    else
-      $stderr.puts "[WARN] You are running the Spotify gem on an unknown platform. (#{__FILE__}:#{__LINE__})"
-      $stderr.puts "[WARN] Platform: #{FFI::Platform::OS}"
-      :unknown
+    # @api public
+    # @return [Symbol] platform as either :mac, :windows, or :linux
+    def platform
+      case FFI::Platform::OS
+      when /darwin/ then :mac
+      when /linux/  then :linux
+      when /windows/  then :windows
+      else
+        $stderr.puts "[WARN] You are running the Spotify gem on an unknown platform. (#{__FILE__}:#{__LINE__})"
+        $stderr.puts "[WARN] Platform: #{FFI::Platform::OS}"
+        :unknown
+      end
     end
   end
 end