Ruby4Skype 0.3.1 → 0.4.1

data/lib/skype/os/mac.rb

@@ -0,0 +1,217 @@
+require 'osx/cocoa'
+require 'thread'
+Dir.chdir '../../' if __FILE__ == $0
+require 'skype/os/etc.rb'
+
+OSX.require_framework 'Skype'
+
+module Skype
+  module OS
+    class Mac < Skype::OS::Abstruct
+      
+      class MessageHandler < OSX::NSObject
+        
+        def _init os, name
+          @os = os
+          @clientApplicationName = name
+        end
+        
+        def clientApplicationName
+          @clientApplicationName
+        end
+        
+        addRubyMethod_withType 'skypeAttachResponse:', 'v@:i'
+        def skypeAttachResponse status
+          if status == 1
+            @os.attached = true
+            OSX::SkypeAPI.sendSkypeCommand('PROTOCOL 9999')
+          else
+            @os.attached = false
+          end
+        end
+        
+        def skypeBecameAvilable
+        end
+        
+        def skypeBecameUnavilable
+        end
+        
+        #addRubyMethod_withType 'skypeNotificationReceived:', 'v@:i'
+        def skypeNotificationReceived notification_string
+          p "[#{notification_string.to_s}]" if @os.debug
+          
+          if notification_string.to_s =~ /^#(\d+) (.+)$/m
+            send_count = $1.to_i; res = $2
+            @os.response[send_count] = notification_string.to_s
+          else
+            @os.push_queue notification_string.to_s
+          end
+        end
+      end
+      
+      def initialize client_application_name='ruby4skype'
+        @queue = Queue.new
+        @attached = false
+        @debug = false
+        
+        @send_count = 0
+        @send_count_mutex = Mutex.new
+        @response = Hash.new
+        
+        @msg = MessageHandler.alloc.init
+        @msg._init self, client_application_name
+        OSX::SkypeAPI.setSkypeDelegate @msg
+        
+        app = OSX::NSApplication.sharedApplication
+        unless app.isRunning
+          @t =Thread.new do
+            sleep 1
+            app.run 
+          end
+        end
+        #OSX::NSRunLoop.currentRunLoop.run 
+      end      
+      attr_reader :queue, :name, :attached, :response, :debug
+      attr_writer :attached
+      private :queue
+
+      def set_notify_selector block=Proc.new
+        @notify_selector = block
+      end
+      attr_reader :notify_selector      
+      
+      def attach
+        unless attached?
+          OSX::SkypeAPI.connect
+        end
+      end
+      
+      def attach_wait
+        attach
+        sleep 0.123 until attached?
+        OSX::SkypeAPI.sendSkypeCommand('PROTOCOL 9999')
+      end
+      
+      def attached?
+        @attached
+      end
+      
+      def dettach
+        self.attached = false
+        OSX::SkypeAPI.disconnect
+      end
+      
+      def skype_runnging?
+        OSX::SkypeAPI.isSkypeRunnging
+      end
+      
+      def invoke_prototype cmd
+        send_count = send_count_increment
+        cmd = "##{send_count} #{cmd}"
+        
+        #@queue.push(proc{do_event(:sent, cmd)}) if exist_event? :sent
+        p ">#{cmd}" if @debug
+        
+        res = OSX::SkypeAPI.sendSkypeCommand(cmd).to_s
+        if res.empty?
+          begin
+            timeout(5){sleep 0.123 until response[send_count]}
+          rescue TimeoutError
+            raise Skype::Error::API.new("#{cmd} => no response. it may be skype bug")
+          end
+          res = response[send_count]
+          response.delete send_count
+        end
+        
+        p "<#{res}" if @debug
+        #@queue.push(proc{do_event(:received, res)}) if exist_event? :received
+        
+        res = $1 if res =~ /^#\d+ (.+)$/m
+        
+        return res
+      end
+      
+      def send_count_increment
+        send_count = nil
+        @send_count_mutex.synchronize do
+          send_count = @send_count
+          @send_count+=1
+        end
+        send_count
+      end
+      private :send_count_increment
+      
+      def invoke_callback cmd,cb=Proc.new
+        res = invoke_block cmd
+        cb.call res
+      end
+      
+      alias invoke_block invoke_prototype
+
+      def start_messageloop
+        Thread.new{messageloop}
+      end
+
+      def messageloop
+        while callback = queue.shift
+          break unless message_process callback
+        end
+      end
+
+      def messagepolling
+        return message_process(queue.shift) unless queue.empty?
+        return true
+      end
+
+      def message_process callback
+        #sleep 0.001 while paused?
+        return false  if callback == :exit
+        callback.call
+        return true
+      end
+      private :message_process
+
+      def push_queue res
+        queue.push(proc{notify_selector.call res}) if notify_selector
+      end
+
+      def close
+        dettach if attached?
+        OSX::SkypeAPI.removeSkypeDelegate
+        #OSX::NSApplication.sharedApplication.stop(@msg)
+        #OSX::NSApplication.sharedApplication.terminate(@msg)
+        #@msg.dealloc
+        #@t.kill
+        queue.push :exit
+      end
+      #def close()
+      #  dettach if attached?
+      #end
+      
+    end
+  end
+end
+
+
+if __FILE__ == $0
+  Thread.abort_on_exception = true
+
+  os = Skype::OS::Mac.new 'hogehogehogea'
+  os.set_notify_selector{|res| p res}
+  os.start_messageloop
+  p :hoge
+  os.attach_wait
+  p :hoge
+  p tmp = os.invoke('CHAT CREATE echo123')
+  tmp =~ /CHAT (.+) /
+  p cid = $1
+  os.invoke("CHATMESSAGE #{cid} hoge")
+
+  begin
+    p os.invoke("GET AGC")
+  rescue
+    p $!
+  end
+  sleep 10
+  os.close
+end

data/lib/{skypeapi → skype}/os/notifier.rb

@@ -1,4 +1,4 @@
-module SkypeAPI
+module Skype
   module OS
     class Notifier
       def notify

data/lib/skype/os/timer.rb

@@ -0,0 +1,108 @@
+#module Skype
+#  module OS
+#    class Windows
+			class Timer
+			  class << self
+			    def interval term, block=Proc.new
+			      Interval.new term, block
+			    end
+			    
+			    def timeout term, block=Proc.new
+			      Timeout.new term, block
+			    end
+			    
+			    def delete instance
+			      case instance.class
+			      when Timeout
+			        instance.delete
+			      when Interval
+			        instance.delete
+			      else
+			        raise ArgumentError
+			      end
+			    end
+			    
+			    def polling
+			      now = Time.now.to_i
+			      Timeout.polling now
+			      Interval.polling now
+			    end
+			  end
+			  
+			  class Abstruct
+			    
+			    class << self
+			      
+			      def new term, block
+			        instance = super
+			        @stack << instance
+			        return instance
+			      end
+			      
+			      def delete instance
+			        @stack.delete instance
+			      end
+			      
+			    end
+			    
+			    
+			    def delete
+			      self.class.delete self
+			    end
+			    
+			    attr_reader :term, :block
+			    
+			  end
+			  
+			  class Timeout < Abstruct
+			    @stack = Array.new
+			    class << self
+			      
+			      def polling now
+			        @stack.delete_if do |timeout|
+			          if now >= timeout.term
+			            timeout.block.call
+			            true
+			          else
+			            false
+			          end
+			        end
+			      end
+			      
+			    end
+			    
+			    def initialize term, block
+			      @term = term + Time.now.to_i
+			      @block = block
+			    end
+			    
+			  end
+			  
+			  class Interval < Abstruct
+			    @stack = Array.new
+			    
+			    class << self
+			      
+			      def polling now
+			        @stack.each do |interval|
+			          if now >= interval.term + interval.old
+			            interval.old = now
+			            interval.block.call
+			          end
+			        end
+			      end
+			      
+			    end
+			    
+			    def initialize term, block
+			      @term = term
+			      @old = Time.now.to_i
+			      @block = block
+			    end
+			    
+			    attr_accessor :old
+			  end
+			end
+#		end
+#	end
+#end

data/lib/{skypeapi → skype}/os/window_event_queue.rb

@@ -6,7 +6,7 @@ class BlockQueue < Queue #:nodoc: all
   end
 end
 
-module SkypeAPI
+module Skype
   module OS
     class WindowsEventQueue
       def initialize windows
@@ -97,27 +97,27 @@ module SkypeAPI
       end
 
       def start_messageloop
-        @messageloop_thread = Thread.new{messageloop}
+        Thread.new{messageloop}
       end
 
       def messageloop
-        @messageloop_flag = true
         while callback = queue.shift
-          sleep 0.001 while paused?
-          break if callback == :exit
-          callback.call
+          break unless message_process callback
         end
-        @messageloop_flag = false
       end
 
       def messagepolling
-        until queue.empty?
-          sleep 0.001 while paused?
-          callback = queue.shift
-          break if callback == :exit
-          callback.call
-        end
+        return message_process(queue.shift) unless queue.empty?
+        return true
+      end
+
+      def message_process callback
+        sleep 0.001 while paused?
+        return false  if callback == :exit
+        callback.call
+        return true
       end
+      private :message_process
 
       def close
         queue.clear
@@ -142,14 +142,14 @@ module SkypeAPI
         @pause_mutex.synchronized{@pause_count += 1}
       end
 
-      def paly
+      def play
         @pause_mutex.synchronized{@pause_count -=1}
       end
 
       def push_detached_hook
         #windows.attached = false
         queue.push_block{ call_hook(:detached) }
-        #SkypeAPI.attach
+        #Skype.attach
       end
 
       private
@@ -166,7 +166,7 @@ module SkypeAPI
       def when_detached
         windows.attached = false
         queue.push_block{ call_hook(:detached) }
-        SkypeAPI.attach
+        Skype.attach
       end
 
       def set_cmd_response(cmd_num, res)

data/lib/{skypeapi → skype}/os/window_messagehandler.rb

@@ -1,4 +1,4 @@
-module SkypeAPI
+module Skype
   module OS
     class MessageHandler < SWin::Window
 
@@ -7,10 +7,10 @@ module SkypeAPI
         @queue = queue
 
         @dwDiscoverMsg = RegisterWindowMessage.call("SkypeControlAPIDiscover");
-        raise SkypeAPI::Error::Attach.new("SkypeControlAPIDiscover nothing") unless @dwDiscoverMsg
+        raise Skype::Error::Attach.new("SkypeControlAPIDiscover nothing") unless @dwDiscoverMsg
 
         @dwAttachMsg = RegisterWindowMessage.call("SkypeControlAPIAttach")
-        raise SkypeAPI::Error::Attach.new("SkypeControlAPIAttach nothing") unless @dwAttachMsg
+        raise Skype::Error::Attach.new("SkypeControlAPIAttach nothing") unless @dwAttachMsg
 
         addEvent(WM_COPYDATA)
         addEvent(WM_USER_MSG)
@@ -21,7 +21,7 @@ module SkypeAPI
 
       def attach
         unless PostMessage.call(HWND_BROADCAST, @dwDiscoverMsg, hWnd, 0)
-          raise SkypeAPI::Error::Attach.new("SkypeControlAPIDiscover broadcast failure")
+          raise Skype::Error::Attach.new("SkypeControlAPIDiscover broadcast failure")
         end
         return true
       end
@@ -35,17 +35,17 @@ module SkypeAPI
       end
 
       def invoke num, cmd
-        unless @hSkypeAPIWindowHandle
-          raise SkypeAPI::Error::Attach.new("NullPointerException SendSkype!")
+        unless @hSkypeWindowHandle
+          raise Skype::Error::Attach.new("NullPointerException SendSkype!")
           return false
         end
 
         cmd = '#' + num.to_s + ' ' + cmd + "\0"
         pCopyData = application.arg2cstructStr("LLS",0,cmd.length+1,cmd)
         send_buffer[num] = cmd
-        unless PostMessage.call(hWnd, WM_USER_MSG, @hSkypeAPIWindowHandle, pCopyData)
-          @hSkypeAPIWindowHandle = nil
-          raise SkypeAPI::Error::Attach.new("Skype not ready")
+        unless PostMessage.call(hWnd, WM_USER_MSG, @hSkypeWindowHandle, pCopyData)
+          @hSkypeWindowHandle = nil
+          raise Skype::Error::Attach.new("Skype not ready")
         end
         @queue.push_hook(:sent, cmd.chop) if @queue.exist_hook? :sent
         return true
@@ -56,7 +56,7 @@ module SkypeAPI
         when @dwAttachMsg
           case sMsg.lParam
           when SKYPECONTROLAPI_ATTACH_SUCCESS
-            @hSkypeAPIWindowHandle = sMsg.wParam
+            @hSkypeWindowHandle = sMsg.wParam
             invoke_protocol
             @queue.push_hook(:attach,:success)
 
@@ -90,7 +90,7 @@ module SkypeAPI
           end
           sMsg.retval = 1
         when WM_COPYDATA
-          if sMsg.wParam == @hSkypeAPIWindowHandle
+          if sMsg.wParam == @hSkypeWindowHandle
             retval = application.cstruct2array(sMsg.lParam,"LLL")
             cmd = application.pointer2string(retval[2],retval[1])
             @queue.push cmd
@@ -98,7 +98,7 @@ module SkypeAPI
           end
         when WM_USER_MSG
           unless SendMessage.call(sMsg.wParam, WM_COPYDATA, sMsg.hWnd, sMsg.lParam)
-            raise  SkypeAPI::Error::Attach.new("Skype not ready")
+            raise  Skype::Error::Attach.new("Skype not ready")
           end
           sMsg.retval = 1
         else