ruby-skype 0.1.0.pre.2

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Matthew Scharley
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+Skype Public API for Ruby
+=========================
+
+**GitHub:** https://github.com/mscharley/ruby-skype  
+**Author:** Matthew Scharley  
+**Contributors:** [See contributors on GitHub][gh-contrib]  
+**Bugs/Support:** [Github Issues][gh-issues]  
+**Copyright:** 2012  
+**License:** [MIT license][license]
+
+Synopsis
+--------
+
+This library is a binding for the [Skype Public API][skype-api]. Currently,
+due to the Skype API being accessed in different ways on different platforms
+this library will initially only be supported on Linux/DBus and Windows. The
+Skype Public API is a way to hook into the Skype client released by Microsoft
+and automate it. To use this library *you must have a copy of the Skype 
+client installed locally*. This is not a stand-alone library to access the
+Skype network.
+
+**This is very much still under development**
+
+If you want to use this or help out, please feel free to clone/fork and play
+with this, but it is prone to break or change at any time.
+
+Installation
+------------
+
+For now, you will need to install from the git repository. Simply clone it
+to wherever you like and then add it to your include path if needed.
+
+Mac OS X Support
+----------------
+
+OS X integration should be possible, however I don't have a Mac to
+test/develop with. If you want to help out, then look at the 
+`Skype::Communication::*` classes. `Skype::Communication::Protocol` is the
+base interface you need to implement. Any help would be greatly appreciated!
+
+Documentation
+-------------
+
+There is some documentation about the Skype API itself in the doc folder. The
+[ruby-skype API documentation is available online][ruby-skype-rubydoc]. To 
+generate them locally, simply clone the library, then run `yard` in the repo 
+root. The API documentation will be available in `/doc/api` when complete.
+
+Goals
+-----
+
+Generate a Ruby friendly front-end to access the Skype public API.
+
+
+  [skype-api]: http://developer.skype.com/public-api-reference
+  [license]: https://raw.github.com/mscharley/ruby-skype/master/LICENSE
+  [ruby-skype-rubydoc]: http://rubydoc.info/github/mscharley/ruby-skype/master/frames
+  [gh-contrib]: https://github.com/mscharley/ruby-skype/graphs/contributors
+  [gh-issues]: https://github.com/mscharley/ruby-skype/issues
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0.pre.2

data/examples/call

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$:.push('lib', '../lib')
+
+require 'skype'
+Skype.DEBUG = true
+skype = Skype.new('ruby-skype-test')
+puts "Using ruby-skype-#{Skype.VERSION}"
+skype.connect
+puts "Connected using protocol version #{skype.protocol_version}"
+
+puts "Attempting to call the echo service..."
+skype.send_raw_command('CALL echo123')
+skype.run

data/examples/listen

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+# This program simply attaches to Skype and runs an event loop. Can be used as a starting point, or a way to
+# listen for new update commands that we may not know about yet.
+
+$:.push('lib', '../lib')
+
+require 'skype'
+Skype.DEBUG = true
+puts "Using ruby-skype-#{Skype.VERSION}"
+skype = Skype.new('ruby-skype-listen-in')
+skype.connect
+puts "Connected using protocol version #{skype.protocol_version}"
+skype.run

data/ext/mkrf_conf.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rubygems/command.rb'
+require 'rubygems/dependency_installer.rb' 
+
+begin
+  Gem::Command.build_args = ARGV
+rescue NoMethodError
+end 
+
+inst = Gem::DependencyInstaller.new
+begin
+  case RbConfig::CONFIG['host_os']
+    when /mingw|cygwin|mswin/
+      inst.install "ffi"
+    when /linux/
+      inst.install "ruby-dbus", '= 0.7.2'
+  end
+rescue
+  exit(1)
+end 
+
+f = File.open(File.join(File.dirname(__FILE__), "Rakefile"), "w")   # create dummy rakefile to indicate success
+f.write("task :default\n")
+f.close

data/lib/skype.rb

@@ -0,0 +1,213 @@
+
+require 'skype/command_manager'
+require 'skype/errors/exception_factory'
+require 'skype/data_maps/user_visibility'
+
+# This class is the main interface between Ruby and Skype.
+class Skype
+  private
+
+  def platform
+    @platform ||=
+      case RbConfig::CONFIG['host_os']
+        when /mingw|cygwin|mswin/
+          :windows
+        when /linux/
+          :linux
+        else
+          :unknown
+      end
+  end
+
+  public
+
+  # Initialises the Skype library and sets up a communication protocol, but
+  # doesn't connect yet.
+  #
+  # @param [String] application_name Name to use when identifying to Skype. Not
+  #     all platforms use this value as Skype will automatically assign a name.
+  def initialize(application_name, communication_protocol = nil)
+    if communication_protocol.nil?
+      case platform
+        when :windows
+          require 'skype/communication/windows'
+          @skype = Skype::Communication::Windows.new(application_name)
+        when :linux
+          require 'skype/communication/dbus'
+          @skype = Skype::Communication::DBus.new(application_name)
+        else
+          puts "Unfortunately, we don't support your platform currently."
+          puts "Please file an issue if you think this is incorrect."
+          exit 1
+      end
+    else
+      @skype = communication_protocol
+    end
+
+    @command_manager = CommandManager.new(self)
+    @skype.add_observer(self, :received_command)
+  end
+
+  # Controls whether the library should output extra debugging information or
+  # not. Currently controls whether we should output all network throughput.
+  #
+  # @return [Boolean]
+  def self.DEBUG
+    @debug_mode
+  end
+
+  # (see DEBUG)
+  def self.DEBUG=(value)
+    @debug_mode = value
+  end
+
+  # Returns the currently in use version of the ruby-skype library.
+  #
+  # @return [String]
+  def self.VERSION
+    @version ||=
+        IO.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp
+  end
+
+  # Connect to Skype and negotiate a communication channel. Blocks till the
+  # connection is fully established.
+  #
+  # @return [Symbol] Initial value for user_status.
+  def connect
+    @skype.connect
+
+    until @user_status
+      tick
+      sleep(0.1)
+    end
+    @user_status
+  end
+
+  # Are we connected to Skype?
+  #
+  # @return [Boolean]
+  def connected?
+    @skype.connected?
+  end
+
+  # Execute a single run of the Skype event loop
+  #
+  # @return [void]
+  def tick
+    @skype.tick
+    nil
+  end
+
+  # Executes the Skype event loops. Doesn't return unless #quit is called.
+  #
+  # @return [void]
+  def run
+    @finished = false
+    until @finished
+      tick
+      sleep(0.1)
+    end
+  end
+
+  # Stops the Skype event loop from running.
+  #
+  # @return [void]
+  def quit
+    @finished = true
+  end
+
+  # Sends a raw command to Skype
+  #
+  # @param [String] command The command to send
+  # @return [String] The value returned by Skype
+  # @api private
+  def send_raw_command(command)
+    send_message(command)
+  end
+
+  #######################
+  ###                 ###
+  ### BEGIN SKYPE API ###
+  ###                 ###
+  #######################
+
+  # Network connection status.
+  #
+  # Valid values:
+  #
+  #  * `:offline`
+  #  * `:connecting`
+  #  * `:pausing`
+  #  * `:online`
+  #
+  # @return [Symbol]
+  # @api skype
+  attr_reader :connection_status
+
+  # @!attribute [rw] user_status
+  # User visibility for the current user.
+  #
+  # Valid values:
+  #
+  #  * `:unknown`
+  #  * `:online`
+  #  * `:offline`
+  #  * `:skype_me`
+  #  * `:away`
+  #  * `:not_available`
+  #  * `:do_not_disturb`
+  #  * `:invisible`
+  #
+  # @return [Symbol]
+  # @api skype
+  def user_status
+    @user_status
+  end
+
+  # (see #user_status)
+  def user_status=(value)
+    send_message("SET USERSTATUS " + DataMaps::USER_VISIBILITY[value])
+    nil
+  end
+
+  # The protocol version in use for the connection with Skype. This value is
+  # only reliable once connected.
+  #
+  # @return [Integer] The version number of the protocol in use.
+  def protocol_version
+    @skype.protocol_version
+  end
+
+  protected
+
+  # Callback for receiving updates from Skype.
+  #
+  # @param [String] command The command string to process.
+  # @return [void]
+  def received_command(command)
+    @command_manager.process_command(command)
+    puts "<= #{command}" if ::Skype.DEBUG
+  end
+
+  def update_user_status(status)
+    @user_status = status
+  end
+
+  def update_connection_status(status)
+    @connection_status = status
+  end
+
+  private
+
+  # Handles sending messages and handling possible errors returned by Skype
+  #
+  # @param [String] message The message to send to Skype
+  # @return [String] The reply from Skype or throws an exception on an error
+  def send_message(message)
+    ret = @skype.send(message)
+    if ret[0,6] == "ERROR "
+      Errors::ExceptionFactory.generate_exception(ret)
+    end
+    ret
+  end
+end

data/lib/skype/command_manager.rb

@@ -0,0 +1,26 @@
+
+class Skype
+  # This class is used to manage updates coming back from Skype.
+  #
+  # @see #process_message
+  class CommandManager
+    def initialize(skype)
+      @skype = skype
+    end
+
+    def process_command(command)
+      (command, args) = command.split(/\s+/, 2)
+      command = command.downcase.to_sym
+
+      self.send(command, args) if self.public_methods.include? command
+    end
+
+    def connstatus(args)
+      @skype.send :update_connection_status, args.downcase.to_sym
+    end
+
+    def userstatus(args)
+      @skype.send :update_user_status, DataMaps::USER_VISIBILITY.invert[args]
+    end
+  end
+end

data/lib/skype/communication/dbus.rb

@@ -0,0 +1,104 @@
+
+require 'dbus'
+require 'skype/communication/protocol'
+
+# Monkey-patch dbus to fix an error till it makes it into a release
+class DBus::Connection
+  def update_buffer
+    @buffer += @socket.read_nonblock(MSG_BUF_SIZE)
+  rescue EOFError
+    raise                     # the caller expects it
+  rescue Errno::EWOULDBLOCK
+    # simply fail the read if it would block
+    return
+  rescue Exception => e
+    puts "Oops:", e
+    raise if @is_tcp          # why?
+    puts "WARNING: read_nonblock failed, falling back to .recv"
+    @buffer += @socket.recv(MSG_BUF_SIZE)
+  end
+end
+
+class Skype
+  module Communication
+    # This class handles communication with Skype via DBus.
+    #
+    # This communication method is available under Linux.
+    class DBus
+      include Skype::Communication::Protocol
+
+      # DBus service name to connect to.
+      SKYPE_DBUS_SERVICE = 'com.Skype.API'
+      # DBus communication path for client -> Skype communication.
+      SKYPE_SERVER_PATH = '/com/Skype'
+      # Interface for the client -> Skype communication function.
+      SKYPE_SERVER_INTERFACE = 'com.Skype.API'
+      # DBus communication path for Skype -> client communication.
+      SKYPE_CLIENT_PATH = '/com/Skype/Client'
+      # Interface for the Skype -> client communication function.
+      SKYPE_CLIENT_INTERFACE = 'com.Skype.API.Client'
+
+      # Create a communication link to Skype via DBus. This initialises DBus,
+      # but doesn't attempt to connect to Skype yet.
+      #
+      # @see #connect.
+      def initialize(application_name)
+        @application_name = application_name
+        @dbus = ::DBus::SessionBus.instance
+        @dbus_service = @dbus.service(SKYPE_DBUS_SERVICE)
+        @skype = @dbus_service.object(SKYPE_SERVER_PATH)
+        @skype.introspect
+        @skype.default_iface = SKYPE_SERVER_INTERFACE
+      end
+
+      # Attempt to connect to Skype.
+      #
+      # For DBus, this includes exporting the client interface and then
+      # identifying ourselves and negotiating protocol version.
+      #
+      # @return [void]
+      def connect
+        value = @skype.Invoke("NAME " + @application_name)
+        unless value == %w{OK}
+          Skype::Errors::ExceptionFactory.generate_exception *value
+        end
+        @protocol_version = @skype.Invoke("PROTOCOL 8")[0].
+            sub(/^PROTOCOL\s+/, '').to_i
+        @connected = true
+      end
+
+      # Send a command to Skype.
+      #
+      # @param [string] message The message to send to Skype
+      # @return [string] The direct response from Skype
+      def send(message)
+        unless @connected
+          raise "You must be connected before sending data."
+        end
+        puts "-> #{message}" if ::Skype.DEBUG
+        ret = @skype.Invoke(message)[0]
+        puts "<- #{ret}" if ::Skype.DEBUG
+        ret
+      end
+
+      # Poll DBus for incoming messages. We use this method for watching for
+      # our messages as it is simpler, and an event loop is required no matter
+      # what.
+      #
+      # @return [void]
+      def tick
+        @dbus.update_buffer
+        @dbus.messages.each do |msg|
+          # Pass messages through DBus
+          @dbus.process(msg)
+
+          # Process messages to us.
+          if msg.interface == SKYPE_CLIENT_INTERFACE &&
+              msg.path == SKYPE_CLIENT_PATH
+            receive(msg.params[0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skype/communication/protocol.rb

@@ -0,0 +1,70 @@
+
+require 'observer'
+
+class Skype
+  # You shouldn't try including this module, it is used purely for organisation.
+  # @private
+  module Communication
+    # Interface for the Skype::Communication::* classes. This provides basic
+    # input and output functionality with Skype.
+    #
+    # Includes Observable. Notifications sent will have a single string
+    # parameter which is the incoming command from Skype.
+    module Protocol
+      include Observable
+
+      # The protocol version supported by this communication protocol
+      #
+      # @return [Boolean]
+      attr_reader :protocol_version
+
+      # @!attribute [r] connected?
+      # Have we connected to Skype yet?
+      #
+      # @return [Boolean]
+      def connected?
+        @connected
+      end
+
+      # Sends a message to Skype.
+      #
+      # Must be implemented by Protocol implementers.
+      #
+      # @param [string] message The message to send to Skype
+      # @return [string] The direct response from Skype
+      # @return [string] The direct response from Skype
+      def send(message)
+        raise "#send(message) must be implemented."
+      end
+
+      # Connects to Skype.
+      #
+      # Must be implemented by Protocol implementers.
+      #
+      # @return [void]
+      def connect
+        raise "#connect must be implemented"
+      end
+
+      # Update processing. This is where you get a chance to check for input.
+      #
+      # Should be implemented by Protocol implementers, but no error is thrown
+      # if not.
+      #
+      # @return [void]
+      def tick
+      end
+
+      private
+
+      # Internal method to implement Observable.
+      #
+      # Protocol implementers may use this to send notifications of incoming
+      # commands.
+      def receive(message)
+        changed
+        notify_observers(message)
+      end
+    end
+  end
+end

data/lib/skype/communication/windows.rb

@@ -0,0 +1,200 @@
+
+require 'skype/communication/protocol'
+require 'skype/communication/windows/win32'
+
+class Skype
+  module Communication
+    # Utilises the Windows API to send and receive Window Messages to/from
+    # Skype.
+    #
+    # This protocol is only available on Windows and Cygwin.
+    class Windows
+      include Skype::Communication::Protocol
+
+      # Sets up access to Skype
+      #
+      # @see http://msdn.microsoft.com/en-us/library/bb384843.aspx Creating
+      #     Win32-Based Applications
+      def initialize(application_name)
+        @application_name = application_name
+
+        # Get the message id's for the Skype Control messages
+        @api_discover_message_id =
+            Win32::RegisterWindowMessage('SkypeControlAPIDiscover')
+        @api_attach_message_id =
+            Win32::RegisterWindowMessage('SkypeControlAPIAttach')
+
+        instance = Win32::GetModuleHandle(nil)
+
+        @window_class = Win32::WNDCLASSEX.new
+        @window_class[:style]         = Win32::CS_HREDRAW | Win32::CS_VREDRAW
+        @window_class[:lpfnWndProc]   = method(:message_pump)
+        @window_class[:hInstance]     = instance
+        @window_class[:hbrBackground] = Win32::COLOR_WINDOW
+        @window_class[:lpszClassName] =
+            FFI::MemoryPointer.from_string 'ruby-skype'
+
+        @window = Win32::CreateWindowEx(Win32::WS_EX_LEFT,
+                                        FFI::Pointer.new(@window_class.handle),
+                                        'ruby-skype',
+                                        Win32::WS_OVERLAPPEDWINDOW,
+                                        0, 0, 0, 0, Win32::NULL, Win32::NULL,
+                                        instance, nil)
+      end
+
+      # Connects to Skype.
+      #
+      # @return [void]
+      def connect
+        # Do setup before sending message as Windows will process messages as
+        # well while in SendMessage()
+        @msg = Win32::MSG.new
+        @authorized = nil
+        @message_counter = 0
+        @replies = {}
+
+        Win32::PostMessage(Win32::HWND_BROADCAST, @api_discover_message_id,
+                           @window, 0)
+      end
+
+      # Update processing.
+      #
+      # This executes a Windows event loop while there are messages still
+      # pending, then dumps back out to let other things take over and do their
+      # thing.
+      #
+      # @return [void]
+      def tick
+        while Win32::PeekMessage(@msg, Win32::NULL, 0, 0, Win32::PM_REMOVE) > 0
+          Win32::TranslateMessage(@msg)
+          Win32::DispatchMessage(@msg)
+        end
+
+        # Don't simplify this as we rely on false != nil for tribool values
+        #noinspection RubySimplifyBooleanInspection
+        if @authorized == false
+          Skype::Errors::ExceptionFactory.generate_exception("ERROR 68")
+        end
+      end
+
+      # Sends a message to Skype.
+      #
+      # @param [string] message The message to send to Skype
+      # @return [string] The direct response from Skype
+      def send(message)
+        puts "-> #{message}" if Skype.DEBUG
+
+        counter = next_message_counter
+        message = "##{counter} #{message}"
+
+        data = Win32::COPYDATASTRUCT.new
+        data[:dwData] = 0
+        data[:cbData] = message.length + 1
+        data[:lpData] = FFI::MemoryPointer.from_string(message + "\0")
+
+        Win32::SendMessage(@skype_window, Win32::WM_COPYDATA, @window,
+                           pointer_to_long(data.to_ptr))
+
+        while @replies[counter].nil?
+          tick
+          sleep(0.1)
+        end
+
+        ret = @replies[counter]
+        @replies.delete(counter)
+        ret
+      end
+
+      # Attached to Skype successfully.
+      API_ATTACH_SUCCESS = 0
+      # Skype indicated that we should hold on.
+      API_ATTACH_PENDING = 1
+      # Attachment to Skype was refused.
+      API_ATTACH_REFUSED = 2
+      # Attachment to Skype isn't available currently. Typically there is no
+      # user logged in.
+      API_ATTACH_NOT_AVAILABLE = 3
+
+      private
+
+      def next_message_counter
+        @message_counter += 1
+      end
+
+      LPARAM_BITS = Win32::LPARAM.size * 8
+
+      # Convert a ulong pointer value to a long int for use as a LPARAM because
+      # someone at Microsoft thought it'd be a good idea to pass around
+      # pointers as signed values.
+      def pointer_to_long(pointer)
+        pointer = pointer.to_i
+        pointer > (2 ** (LPARAM_BITS - 1)) ?
+            pointer - (2 ** LPARAM_BITS) : pointer
+      end
+
+      # Allows us to unwrap a pointer from a long. See #pointer_to_long
+      def long_to_pointer(long)
+        long < 0 ? long + (2 ** LPARAM_BITS) : long
+      end
+
+      # This is our message pump that receives messages from Windows.
+      #
+      # The return value from DefWindowProc is important and must be returned
+      # somehow.
+      #
+      # @see
+      #   http://msdn.microsoft.com/en-us/library/windows/desktop/ms633573.aspx
+      #   MSDN
+      def message_pump(window_handle, message_id, wParam, lParam)
+        case message_id
+          when @api_discover_message_id
+            # Drop WM_API_DISCOVER messages on the floor
+          when @api_attach_message_id
+            case lParam
+              when API_ATTACH_SUCCESS
+                @skype_window = wParam
+                send("NAME " + @application_name)
+                @protocol_version = send("PROTOCOL 8").sub(/^PROTOCOL\s+/, '').
+                    to_i
+                @authorized = true
+
+              when API_ATTACH_REFUSED
+                # Signal to the message pump that we were deauthorised
+                @authorized = false
+
+              else
+                # Ignore pending signal
+                puts "WM: Ignoring WM_API_ATTACH response: #{lParam}" if
+                    Skype.DEBUG
+
+            end
+          when Win32::WM_COPYDATA
+            pointer = FFI::Pointer.new(long_to_pointer(lParam))
+            data = Win32::COPYDATASTRUCT.new pointer
+
+            input = data[:lpData].read_string(data[:cbData] - 1)
+            if input[0] == '#'
+              (counter, input) = input.split(/\s+/, 2)
+              counter = counter.gsub(/^#/, '').to_i
+            else
+              counter = nil
+            end
+
+            if counter.nil?
+              receive(input)
+            else
+              @replies[counter] = input
+              puts "<- #{input}" if Skype.DEBUG
+            end
+
+            # Let Skype know we got it successfully
+            return 1
+          else
+            puts "Unhandled WM: #{sprintf("0x%04x", message_id)}" if Skype.DEBUG
+            return Win32::DefWindowProc(
+                window_handle, message_id, wParam, lParam)
+        end
+      end
+    end
+  end
+end

data/lib/skype/communication/windows/win32.rb

@@ -0,0 +1,365 @@
+
+require 'ffi'
+
+class Skype
+  module Communication
+    class Windows
+      # This module is used to provide access to the Win32 API to Ruby. There
+      # is lots of stuff here that is poorly named but tries stick closely to
+      # the original Win32 API for ease of reference.
+      #
+      # BEWARE: Here there be dragons aplenty.
+      module Win32
+        extend FFI::Library
+        ffi_lib('user32', 'kernel32')
+        ffi_convention(:stdcall)
+
+        private
+
+        def self._func(*args)
+          attach_function *args
+          case args.size
+            when 3
+              module_function args[0]
+            when 4
+              module_function args[0]
+              alias_method(args[1], args[0])
+              module_function args[1]
+          end
+        end
+
+        # @!group Windows Data Types
+        # @see http://msdn.microsoft.com/en-us/library/aa383751%28VS.85%29.aspx
+
+        # Check for 64b operating systems.
+        if [nil].pack('p').bytesize == 8
+          ULONG_PTR = FFI::TypeDefs[:uint64]
+          LONG_PTR = FFI::TypeDefs[:int64]
+        else
+          ULONG_PTR = FFI::TypeDefs[:ulong]
+          LONG_PTR = FFI::TypeDefs[:long]
+        end
+
+        ULONG = FFI::TypeDefs[:ulong]
+        LONG = FFI::TypeDefs[:long]
+        PVOID = FFI::TypeDefs[:pointer]
+        LPVOID = FFI::TypeDefs[:pointer]
+        INT = FFI::TypeDefs[:int]
+        BYTE = FFI::TypeDefs[:uint16]
+        DWORD = FFI::TypeDefs[:ulong]
+        BOOL = FFI::TypeDefs[:int]
+        UINT = FFI::TypeDefs[:uint]
+        POINTER = FFI::TypeDefs[:pointer]
+        VOID = FFI::TypeDefs[:void]
+
+        HANDLE = ULONG_PTR
+        HWND = HANDLE
+        HICON = HANDLE
+        HCURSOR = HANDLE
+        HBRUSH = HANDLE
+        HINSTANCE = HANDLE
+        HGDIOBJ = HANDLE
+        HMENU = HANDLE
+        HMODULE = HANDLE
+
+        LPARAM = LONG_PTR
+        WPARAM = ULONG_PTR
+        LPMSG = LPVOID
+        LPCTSTR = LPVOID
+        LRESULT = LONG_PTR
+        ATOM = BYTE
+
+        # @!endgroup
+
+        public
+
+        # Provide a NULL constant so we can be a little more explicit.
+        NULL = 0
+
+        # This is the callback function used to process window messages.
+        WNDPROC = callback(:WindowProc, [HWND, UINT, WPARAM, LPARAM], LRESULT)
+
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms633577.aspx MSDN
+        class WNDCLASSEX < FFI::Struct
+          layout :cbSize, UINT,
+                 :style, UINT,
+                 :lpfnWndProc, WNDPROC,
+                 :cbClsExtra, INT,
+                 :cbWndExtra, INT,
+                 :hInstance, HANDLE,
+                 :hIcon, HICON,
+                 :hCursor, HCURSOR,
+                 :hbrBackground, HBRUSH,
+                 :lpszMenuName, LPCTSTR,
+                 :lpszClassName, LPCTSTR,
+                 :hIconSm, HICON
+
+          def initialize(*args)
+            super
+            self[:cbSize] = self.size
+            @atom = 0
+          end
+
+          # Register class with Windows.
+          def register_class_ex
+            # According to MSDN, you must add 1 to this value before
+            # registering. We shouldn't expect client code to remember to
+            # always do this.
+            if self[:hbrBackground] > 0
+              self[:hbrBackground] = self[:hbrBackground] + 1
+            end
+
+            (@atom = Win32::RegisterClassEx(self)) != 0 ?
+                @atom : raise("RegisterClassEx Error")
+          end
+
+          # @!attribute [r] handle
+          #
+          # Returns a handle to use the windo class with CreateWindowEx()
+          def handle
+            @atom != 0 ? @atom : register_class_ex
+          end
+        end # WNDCLASSEX
+
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/dd162805.aspx
+        class POINT < FFI::Struct
+          layout :x, LONG,
+                 :y, LONG
+        end
+
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644958.aspx
+        class MSG < FFI::Struct
+          layout :hwnd, HWND,
+                 :message, UINT,
+                 :wParam, WPARAM,
+                 :lParam, LPARAM,
+                 :time, DWORD,
+                 :pt, POINT
+        end
+
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms649010.aspx
+        class COPYDATASTRUCT < FFI::Struct
+          layout :dwData, ULONG_PTR,
+                 :cbData, DWORD,
+                 :lpData, PVOID
+        end
+
+        # @!method RegisterWindowMessage(message_name)
+        #
+        # Registers a Window Message with Windows or returns a handle to an
+        # existing message.
+        #
+        # @param [String] message_name The name of the message to register
+        # @return [Handle]
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644947.aspx MSDN
+        _func(:RegisterWindowMessage, :RegisterWindowMessageA, [LPCTSTR], UINT)
+
+        # @!method GetModuleHandle(module_name)
+        #
+        # Used to obtain a handle to a module loaded by the application. If
+        # passed DL::NULL then returns a handle to the current module.
+        #
+        # @param [String|DL::NULL] module_name The name of the module to return
+        #     a handle to.
+        # @return [ModuleHandle]
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms683199.aspx MSDN
+        _func(:GetModuleHandle, :GetModuleHandleA, [LPCTSTR], HMODULE)
+
+        # @!method RegisterClassEx(class_definition)
+        #
+        # Registers a Window Class for use with CreateWindowEx.
+        #
+        # @param [WindowClass] class_definition
+        # @return [Handle]
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms633587.aspx MSDN
+        _func(:RegisterClassEx, :RegisterClassExA, [LPVOID], ATOM)
+
+        # @!method CreateWindowEx(extended_style, window_class, window_name, style, x, y, width, height, parent, menu, instance)
+        #
+        # Creates a new window.
+        #
+        # @param [Integer] extended_style A combination of WS_EX_* constant
+        #     values defining the extended style for this window.
+        # @param [String] window_class This matches up with a registered
+        #     WindowClass's lpszClassName parameter.
+        # @param [String] window_name This is the title of the newly created
+        #     window.
+        # @param [Integer] style A combination of the WS_* constant values
+        #     defining the style for this window.
+        # @param [Integer] x The horizontal position of the window on the
+        #     screen.
+        # @param [Integer] y The vertical position of the window on the screen.
+        # @param [Integer] width The width of the window to create.
+        # @param [Integer] height The height of the window to create.
+        # @param [WindowHandle] parent A parent window for this one.
+        # @param [MenuHandle] menu The menu for this window.
+        # @param [InstanceHandle] instance
+        # @return [WindowHandle]
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms632680.aspx MSDN
+        _func(:CreateWindowEx, :CreateWindowExA, [DWORD, LPCTSTR, LPCTSTR,
+                                                  DWORD, INT, INT, INT, INT,
+                                                  HWND, HMENU, HINSTANCE,
+                                                  LPVOID],
+              HWND)
+
+        # @!method GetMessage(message, window, filter_min, filter_max)
+        #
+        # Get a message from the message queue. Blocks until there is one to
+        # return. Compare with PeekMessage().
+        #
+        # @param [MSG] message **[out]** A message structure to output the
+        #     incoming message to.
+        # @param [WindowHandle] window Which window to get messages for.
+        # @param [Integer] filter_min The first message to return, numerically.
+        #     For suggestions, see MSDN.
+        # @param [Integer] filter_max The last message to return, numerically.
+        #     If min and max are both 0 then all messages are returned. For
+        #     suggestions, see MSDN.
+        # @return [Integer] -1 on error, otherwise 0 or 1 indicating whether to
+        #     keep processing.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644936.aspx MSDN
+        _func(:GetMessage, :GetMessageA, [LPMSG, HWND, UINT, UINT], BOOL)
+
+        # @!method PeekMessage(message, window, filter_min, filter_max, remove_message)
+        #
+        # Peek at a message from the message queue and optionally remove it.
+        # Never blocks. Compare with GetMessage().
+        #
+        # @param [MSG] message **[out]** A message structure to output the
+        #     incoming message to.
+        # @param [WindowHandle] window Which window to get messages for.
+        # @param [Integer] filter_min The first message to return, numerically.
+        #     For suggestions, see MSDN.
+        # @param [Integer] filter_max The last message to return, numerically.
+        #     If min and max are both 0 then all messages are returned. For
+        #     suggestions, see MSDN.
+        # @param [Integer] remove_message One of the PM_* values.
+        # @return [Integer] 0 or 1 indicating whether to keep processing.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644943.aspx MSDN
+        _func(:PeekMessage, :PeekMessageA, [LPMSG, HWND, UINT, UINT, UINT], BOOL)
+
+        # @!method SendMessage(window, message, wParam, lParam)
+        #
+        # Send a message to another window.
+        #
+        # @param [WindowHandle] window Which window to send the message to.
+        # @param [Integer] message WM_* message to send.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644950.aspx MSDN
+        _func(:SendMessage, :SendMessageA, [HWND, UINT, WPARAM, LPARAM], LRESULT)
+
+        # @!method PostMessage(window, message, wParam, lParam)
+        #
+        # Send a message to another window and return without waiting for a reply.
+        #
+        # @param [WindowHandle] window Which window to send the message to.
+        # @param [Integer] message WM_* message to send.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644950.aspx MSDN
+        _func(:PostMessage, :PostMessageA, [HWND, UINT, WPARAM, LPARAM], LRESULT)
+
+        # @!method TranslateMessage(message)
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644955.aspx MSDN
+        _func(:TranslateMessage, [LPVOID], BOOL)
+
+        # @!method DispatchMessage(message)
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644934.aspx MSDN
+        _func(:DispatchMessage, :DispatchMessageA, [LPVOID], BOOL)
+
+        # @!method DefWindowProc(message, window, filter_min, filter_max)
+        # @return [Object] Return value is dependant on message type
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms633572.aspx MSDN
+        _func(:DefWindowProc, :DefWindowProcA, [HWND, UINT, WPARAM, LPARAM], LRESULT)
+
+        # @!group Predefined WindowHandle's
+        #
+        # These are WindowHandle's provided by the Win32 API for special
+        # purposes.
+
+        # Target for SendMessage(). Broadcast to all windows.
+        HWND_BROADCAST = 0xffff
+        # Used as a parent in CreateWindow(). Signifies that this should be a
+        # message-only window.
+        HWND_MESSAGE = -3
+
+        # @!endgroup
+
+        # CreateWindow Use Default Value
+        CW_USEDEFAULT = 0x80000000
+
+        #@!group HBRUSH colours
+
+        # System window colour
+        COLOR_WINDOW = 5
+
+        # @!group Class Style contants.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ff729176.aspx MSDN
+
+        # Redraws the entire window if a movement or size adjustment changes
+        # the height of the client area.
+        CS_VREDRAW = 0x0001
+        # Redraws the entire window if a movement or size adjustment changes
+        # the width of the client area.
+        CS_HREDRAW = 0x0002
+
+        # @!group Window Message constants
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms644927.aspx#system_defined MSDN
+
+        # An application sends the WM_COPYDATA message to pass data to another
+        # application.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms649011.aspx MSDN
+        WM_COPYDATA = 0x004A
+
+        # @!group PeekMessage constants
+
+        # Messages are not removed from the queue after processing by
+        # #PeekMessage().
+        PM_NOREMOVE = 0
+        # Messages are removed from the queue after processing by
+        # #PeekMessage().
+        PM_REMOVE   = 1
+
+        # @!group Window Style constants
+        #
+        # This is only a subset.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms632600.aspx
+
+        # The window has a thin-line border.
+        WS_BORDER =      0x00800000
+        # The window has a title bar
+        WS_CAPTION =     0x00C00000
+        # The window is initially disabled. A disabled window cannot receive
+        # input from the user.
+        WS_DISABLED =    0x08000000
+        # The window is an overlapped window. An overlapped window has a title
+        # bar and a border.
+        WS_OVERLAPPED =  0x00000000
+        # The windows is a pop-up window.
+        WS_POPUP =       0x80000000
+        # The window has a sizing border.
+        WS_SIZEBOX =     0x00040000
+        # The window has a window menu on its title bar.
+        WS_SYSMENU =     0x00080000
+        # The window has a sizing border.
+        WS_THICKFRAME =  0x00040000
+        # The window has a maximize button.
+        WS_MAXIMIZEBOX = 0x00010000
+        # The window has a minimize button.
+        WS_MINIMIZEBOX = 0x00020000
+        # The window is an overlapped window.
+        WS_OVERLAPPEDWINDOW = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU |
+            WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX
+        # The window is a pop-up window.
+        WS_POPUPWINDOW = WS_POPUP | WS_BORDER | WS_SYSMENU
+
+        # @!group Window Extended Style constants
+        #
+        # This is only a subset.
+        # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ff700543.aspx
+
+        # The window has generic left-aligned properties. This is the default.
+        WS_EX_LEFT = 0
+
+        # @!endgroup
+      end
+    end
+  end
+end

data/lib/skype/data_maps.rb

@@ -0,0 +1,7 @@
+
+class Skype
+  # You shouldn't try including this module, it is used purely for organisation.
+  # @private
+  module DataMaps
+  end
+end

data/lib/skype/data_maps/user_visibility.rb

@@ -0,0 +1,18 @@
+
+class Skype
+  module DataMaps
+    # Data mapping between user visibilities as returned by Skype and the
+    # symbols that this API cares about.
+    USER_VISIBILITY = {
+        :unknown => 'UNKNOWN',
+        :online => 'ONLINE',
+        :offline => 'OFFLINE',
+        :skype_me => 'SKYPEME',
+        :away => 'AWAY',
+        :not_available => 'NA',
+        :do_not_disturb => 'DND',
+        :invisible => 'INVISIBLE',
+        :logged_out => 'LOGGEDOUT',
+    }
+  end
+end

data/lib/skype/errors/error_messages.rb

@@ -0,0 +1,13 @@
+
+class Skype
+  module Errors
+    # This is a map of error codes to error messages used by ExceptionFactory
+    # to generate it's messages.
+    #
+    # @see http://developer.skype.com/public-api-reference#ERRORS Skype Public
+    #     API error codes
+    ERROR_MESSAGES = {
+        68 => 'Access denied',
+    }
+  end
+end

data/lib/skype/errors/exception_factory.rb

@@ -0,0 +1,26 @@
+
+require 'skype/errors/error_messages'
+require 'skype/errors/general_error'
+
+class Skype
+  # You shouldn't try including this module, it is used purely for organisation.
+  # @private
+  module Errors
+    # This class allows the library to generate exceptions based on error codes
+    # from Skype easily.
+    class ExceptionFactory
+      # This function will raise an exception. It never returns.
+      #
+      # @param [String] error_message The ERROR #error_id response from Skype.
+      def self.generate_exception(error_message)
+        data = error_message.match(/^ERROR\s+(\d+)(?:\s+(.+))?$/)
+        error_code = data[1].to_i
+        exception_message = ERROR_MESSAGES[error_code] || data[2] ||
+            "Unknown error: #{error_code}"
+
+        raise ::Skype::Errors::GeneralError.new(error_code), exception_message,
+              caller
+      end
+    end
+  end
+end

data/lib/skype/errors/general_error.rb

@@ -0,0 +1,19 @@
+
+class Skype
+  module Errors
+    # A generalised Exception. This adds an error code field which holds the
+    # numeric error code as returned by Skype. The Exception's message is a
+    # plain text version of the error code, usually suitable for display to
+    # users.
+    class GeneralError < Exception
+      # This is the error code reported by Skype.
+      attr_reader :code
+
+      # Create a new GeneralError with the specified code. The error message
+      # should be provided to raise from ERROR_MESSAGES
+      def initialize(error_code)
+        @code = error_code
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: ruby-skype
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.2
+  prerelease: 6
+platform: ruby
+authors:
+- Matthew Scharley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    ruby-skype is a binding to the Skype Public API. The Public API
+  is a method\n    to talk to the official Skype client running on the local computer
+  and\n    allows for automation of the client.\n"
+email: matt.scharley@gmail.com
+executables: []
+extensions:
+- ext/mkrf_conf.rb
+extra_rdoc_files: []
+files:
+- lib/skype/errors/exception_factory.rb
+- lib/skype/errors/error_messages.rb
+- lib/skype/errors/general_error.rb
+- lib/skype/data_maps.rb
+- lib/skype/data_maps/user_visibility.rb
+- lib/skype/command_manager.rb
+- lib/skype/communication/protocol.rb
+- lib/skype/communication/windows/win32.rb
+- lib/skype/communication/dbus.rb
+- lib/skype/communication/windows.rb
+- lib/skype.rb
+- VERSION
+- README.md
+- LICENSE
+- examples/call
+- examples/listen
+- ext/mkrf_conf.rb
+homepage: https://github.com/mscharley/ruby-skype
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby binding to the Skype Public API.
+test_files: []
+has_rdoc: